Instruction Set Architecture

This section covers the architecture concepts required to understand and use UPMEM DPU processor as a software developer. It is also providing an exhaustive list of the available processor instructions.

Software developers should use this section as a reference manual to develop or debug assembly code.

Resources overview

Thread registers

The system is composed of 24 hardware threads on the v1A DPU, or 16 hardware threads on the v1B DPU. Each of them owns a set of private resources:

24 general purpose 32-bits registers named r0 through r23

A 16-bits wide program counter, named PC. Notice that the PC value does not address an instruction in memory, but the index of such an instruction directly. For example, a PC equal to 1 represents the second instruction in the DPU’s program memory.

Two persistent flags, keeping information about the previous result of an arithmetic or logical instruction:

ZF: last result is equal to zero

CF: last result produced a carry bit

For any processor instruction, the dynamic operands of a thread always belong to the private state of this thread. This state is not visible to other threads.

Several instructions use 64-bits registers, resulting from pairing 2 general purpose 32-bits registers, as summarized here-after:

64 bits register

Related register pair

d0

r0, r1

d2

r2, r3

d4

r4, r5

d6

r6, r7

d8

r8, r9

d10

r10, r11

d12

r12, r13

d14

r14, r15

d16

r16, r17

d18

r18, r19

d20

r20, r21

d22

r22, r23

Pairs registers are organized such that the most significant bits of the enclosing 64-bits register reside in the corresponding even 32-bits register. For example, if r0 is equal to the hexadecimal value 12345678 and r1 to 9abcdef0, then d0 represents the 64-bits hexadecimal value 12345678.9abcdef0 (r0 contains the most significant bits).

Source operands

In addition to the 24 general purpose 32-bits registers, 8 special registers can be used as one of the source operand with a constant value:

Special register

Value

zero

0

one

1

lneg

ffffffff hexadecimal

mneg

80000000 hexadecimal

id

The thread identity

id2

2 times the thread identity

id4

4 times the thread identity

id8

8 times the thread identity

Efficient scheduling

From the thread standpoint, the apparent latency of any instruction is always one cycle. This is ensured by:

The use of a revolver pipeline at any given time, a thread can have only one instruction in progress in the pipeline, thus pipeline stages don’t have any instruction dependency

A thread which executes a DMA instruction is immediately suspended until the transfer is complete. DMA instructions are the only instruction not entirely executed by the pipeline

Under special circumstances, the result of the previous instruction executed by a given thread and the fetching of the current instruction operands may require too many accesses to the general purpose register file. In this case, the previous result is stored into the proper register first, then the instruction is replayed, implying one extra cycle of execution. The execution of other threads is not impacted by this replay mechanism, since the pipeline is not stalled.

To understand more in details the replay mechanism, one must consider two families of operands, denoted as OpA and OpB:

OpA: any of the general purpose or special 32-bits registers

OpB: one of

The general purpose 32-bits registers

The general purpose 64-bits registers

Immediate values

The special register id

If an instruction has one of the following properties, then it will execute without taking an extra cycle:

Use an immediate value as OpB or has no OpB operand

Use a special register as OpA or has no OpA operand

Use the previous instruction result as OpA and/or OpB

Use two general purpose 32-bits registers as OpA and OpB, one of the register having an even index (e.g. r2) and the other an odd index (e.g. r5)

To understand if an instruction is taking one extra cycle to execute, one should proceed as follows:

Count the write accesses of the previous instruction:

Use two variables: the even and odd counters, both initialized to 0

If the previous instruction generates a 32-bits result into a general purpose register with an even index (e.g. r6), then increase the even counter

If the previous instruction generates a 32-bits result into a general purpose register with an odd index (e.g. r9) then increase the odd counter

If the instruction generates a 64-bits result into a register, then increment both counters

Count the read accesses of the current instruction:

If the instruction uses an operand representing a 32-bits register written by the previous instruction, then let the corresponding even or odd counter unchanged, since the read access to the register file will be bypassed

Otherwise, if the instruction uses an operand representing a special register, then let the even and odd counters unchanged

Otherwise increase the even and/or odd counters according to the operands used by the instruction.

In the case of 64-bits operands, one shall consider the same process by considering the 32-bits odd register and 32-bits even register represeting this operand

Check the access port limits:

If either the even or the odd counter (or both) is greater than two, then the current instruction requires an extra cycle to execute

Next are illustrations of the above process:

ld d0, r10, 0        // even = 1, odd = 1
add r2, r2, r4       // even = 3, odd = 1 one extra cycle

ld d0, r10, 0        // even = 1, odd = 1
add r2, r3, r4       // even = 2, odd = 2 no extra cycle

ld d0, r10, 0        // even = 1, odd = 1
sd zero, 0, d2       // even = 2, odd = 2 no extra cycle

ld d0, r10, 0        // even = 1, odd = 1
sd r4, 0, d2         // even = 3, odd = 2 one extra cycle

ld d0, zero, 0       // even = 1, odd = 1
sd r1, 0, d2         // even = 2, odd = 2 no extra cycle
                     //  (r1 is bypassed)

move r0, 10          // even = 1, odd = 0
sd r1, 0, d2         // even = 2, odd = 2 no extra cycle

DMA Operations

The DPU has no data and instruction cache but two fast memories instead:

The instruction RAM, called IRAM

A scratchpad memory, called WRAM

The transfers from the 64-Megabytes memory array (MRAM) to the memories are managed by specific DMA load and store instructions:

ldma: loads N bytes from the MRAM into the WRAM

sdma: stores N bytes from the WRAM into the MRAM

ldmai: loads N bytes from the MRAM into the IRAM

The DMA transfers are constrained by 3 specific rules :

The base address in WRAM and MRAM are aligned on 8 bytes

The transfer size is in the range 8 bytes to 2048 bytes (included)

The transfer size is a multiple of 8 bytes

Alignment rule is implicitly handled by the DPU by automatically masking the addresses to align on the required boundaries.

When considering transfers from the MRAM to the IRAM, one should understand that:

instructions are considered to be 64-bit long (with their most significant bytes set to 0)

base transfer address in IRAM should be in bytes (eg. address 8 corresponds to the second instruction in IRAM)

Load/Store operations

Load and store instructions allow to:

Load values from the WRAM into general purpose registers

Write the contents of registers into the WRAM

In both cases, the endianness can be chosen as an argument. This provides the possibility to “swap” from one format to the other.

Locks

In order to implement fast and efficient software exclusions (such as mutual exclusions) the DPU provides acquire and release instructions, based on an atomic bit register. The idea behind is that a thread can:

Acquire a lock, by performing an acquire on an atomic bit, which sets this atomic bit. When used with a “not zero” condition, and a jump on the same instruction, the thread will replay the instruction until the atomic bit transitions from unset to set

Release a lock, by performing a release on an atomic bit, which has the effect to clear the corresponding atomic bit

The DPU hashes the atomic bit addresses by computing the exclusive or of the two least significant bytes of such addresses.

Run bits

A DPU shares notification bits with the host:

Bits 0..23: per-thread run bit, set to one when the corresponding thread is running

Bits 24..63: per-thread notify bit, which can be set and cleared by threads

Performance counter

The performance counter is a 32-bits counter allowing to get:

Either the total number of clock cycles spent by a program

Or the number of clock cycles spent by instructions, excluding DMA transfers (it represents the number of instructions executed by the DPU, along with replays)

Performance counter is configured by T:config, with a 3-bits value described here-after:

Bits

Purpose

0

If set, clear the performance counter

1,2

1: count clock cycles

2: count instructions

3: disable counter

Configuration instructions return the initial counter value into a target register.

Counter can then be regularly fetched with the instructions implementing T:read. The returned value is 64-bits:

Bits

Purpose

0..3

Counter imprecision, must be ignored

4..35

Counter value

36..64

Ignored

Understanding the instruction descriptions

Every instruction description provides the following information:

The instruction’s mnemonic when used in an assembly program
A summary of the instruction behavior
The associated built-in function name, when invoking from a C program

Mnemonic

Instruction mnemonics are represented in the following form:

KEYWORD <arguments>

Where KEYWORD is the instruction name (e.g. move or add).

The following arguments can be registers or immediate values.

The immediate arguments are represented by pairs:

NAME:TYPE

NAME is an arbitrarily assigned name, usually referred in the brief instruction description.

TYPE summarizes the type of each argument. Possible immediate types are summarized here-after:

Type

Corresponds to

u5

5 bits unsigned immediate

u8

8 bits unsigned immediate

u16

16 bits unsigned immediate

u32

32 bits unsigned immediate

s8

8 bits unsigned immediate

s16

16 bits unsigned immediate

s32

32 bits unsigned immediate

Register arguments are represented by “abstract” register names:

Name

Corresponds to

rc

32-bits writable register: one of r0, r1… r23

rb

32-bits writable register: one of r0, r1… r23

ra

32-bits register: one of r0, r1… r23 or a read-only register

dc,db

64-bits writable register: one of d0, d1… d11

dce,dbe

The most significant bits of 64-bits writable registers dc and db

dco,dbo

The least significant bits of 64-bits writable registers dc and db

Available read-only registers are:

id, id2, id4, id8: the current thread number, multiplied by 1, 2, 4, 8 respectively
zero, one, lneg, mneg: special constant register

Notice that zero may also be a destination register, in which case the instruction performs the operation (e.g. add, sub…) but the result is not stored for further processing.

Behavior

Plain description of instruction behaviors use a number of conventions and notations to simplify the reading.

Operation

Description

=

Set the value of a register (or temporary variable

<-

Set the value of one or multiple flags

jump

Change PC value

call

Save the value of PC+1 and change PC value

boot

Reset the PC of a thread and start it

resume

Start a thread without resetting its PC value

acquire

Acquire a lock

release

Release a lock

read RB

Read the specified run bit

clear RB

Clear the specified run bit

T:config

Configure the performance counter

T:read

Read the performance counter

sats

Saturation function: (value < 0) ? 0x7FFFFFFF : 0x80000000

~

Flip bits

+

Arithmetic add

-

Arithmetic sub

*

Multiply

|

Bitwise or

&

Bitwise and

^

Bitwise exclusive or

>>

Shift to the right

<<

Shift to the left

<<r

Rotate bits to the left

>>r

Rotate bits to the right

>>a

Arithmetic shift to the right

Finally, the bit extraction operation X [ i : j ] describes the extraction of bits i to j (inclusive) from value X (for example 0x44[0:3] is equal to 4).

Atomic

ACQUIRE

acquire:rici

mnemonic

acquire ra:r32 imm:s16 acquire_cc:cc pc:pc16

behavior

- cc = (ZF <- acquire((ra + imm)[8:15] ^ (ra + imm)[0:7]))

- if (acquire_cc cc) then

-     jump @[pc]

built-in syntax

__builtin_acquire_rici(ra, imm, acquire_cc, pc) ;

RELEASE

release:rici

mnemonic

release ra:r32 imm:s16 release_cc:cc pc:pc16

behavior

- cc = (ZF <- release((ra + imm)[8:15] ^ (ra + imm)[0:7]))

- if (release_cc cc) then

-     jump @[pc]

built-in syntax

__builtin_release_rici(ra, imm, release_cc, pc) ;

Arithmetic

ADD

add

add:rri

mnemonic

add rc:wr32 ra:r32 imm:u32

behavior

- rc = (ra + imm)

- ZF,CF <- rc

built-in syntax

__builtin_add_rri(rc, ra, imm) ;

add:rric

mnemonic

add rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_rric(rc, ra, imm, log_set_cc) ;

add:rrici

mnemonic

add rc:wr32 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm

- rc = x

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_rrici(rc, ra, imm, add_nz_cc, pc) ;

add:rrif

mnemonic

add rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_add_rrif(rc, ra, imm, false_cc) ;

add:rrr

mnemonic

add rc:wr32 ra:r32 rb:wr32

behavior

- x = ra + rb

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_add_rrr(rc, ra, rb) ;

add:rrrc

mnemonic

add rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_rrrc(rc, ra, rb, log_set_cc) ;

add:rrrci

mnemonic

add rc:wr32 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb

- rc = x

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_rrrci(rc, ra, rb, add_nz_cc, pc) ;

add:ssi

mnemonic

add sc:wr32 sa:r32 imm:s17

behavior

- cc = (ra & 0xffff) + imm >> 16

- if (const_cc_zero cc) then

-     ZF,CF <- rc = (ra + imm)

- else

-     ZF,CF <- rc = (ra + imm) & 0xffffff | (id << 25)

-     raise exception(_memory_fault)

built-in syntax

__builtin_add_ssi(sc, sa, imm) ;

syntactic sugars

adds rc:wr32 ra:r32 imm:s17

add:sss

mnemonic

add sc:wr32 sa:r32 sb:wr32

behavior

- cc = (ra & 0xffff) + rb >> 16

- if (const_cc_zero cc) then

-     ZF,CF <- rc = (ra + rb)

- else

-     ZF,CF <- rc = (ra + rb) & 0xffffff | (id << 25)

-     raise exception(_memory_fault)

built-in syntax

__builtin_add_sss(sc, sa, sb) ;

syntactic sugars

adds rc:wr32 ra:r32 rb:wr32

add:zri

mnemonic

add zero rb:wr32 imm:u32

behavior

- ZF,CF <- rb + imm

built-in syntax

__builtin_add_zri(zero, rb, imm) ;

add:zric

mnemonic

add zero ra:r32 imm:s27 log_set_cc:cc

behavior

- ZF,CF <- ra + imm

built-in syntax

__builtin_add_zric(zero, ra, imm, log_set_cc) ;

add:zrici

mnemonic

add zero ra:r32 imm:s11 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_zrici(zero, ra, imm, add_nz_cc, pc) ;

add:zrif

mnemonic

add zero ra:r32 imm:s27 false_cc:cc

behavior

- ZF,CF <- ra + imm

built-in syntax

__builtin_add_zrif(zero, ra, imm, false_cc) ;

add:zrr

mnemonic

add zero ra:r32 rb:wr32

behavior

- ZF,CF <- ra + rb

built-in syntax

__builtin_add_zrr(zero, ra, rb) ;

add:zrrc

mnemonic

add zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF,CF <- ra + rb

built-in syntax

__builtin_add_zrrc(zero, ra, rb, log_set_cc) ;

add:zrrci

mnemonic

add zero ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_zrrci(zero, ra, rb, add_nz_cc, pc) ;

add.s

add.s:rri

mnemonic

add.s dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb + imm):S64

- ZF,CF <- dc

built-in syntax

__builtin_add_s_rri(dc, rb, imm) ;

add.s:rric

mnemonic

add.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_s_rric(dc, ra, imm, log_set_cc) ;

add.s:rrici

mnemonic

add.s dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm

- dc = x:S64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_s_rrici(dc, ra, imm, add_nz_cc, pc) ;

add.s:rrif

mnemonic

add.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_add_s_rrif(dc, ra, imm, false_cc) ;

add.s:rrr

mnemonic

add.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + rb

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_add_s_rrr(dc, ra, rb) ;

add.s:rrrc

mnemonic

add.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_s_rrrc(dc, ra, rb, log_set_cc) ;

add.s:rrrci

mnemonic

add.s dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb

- dc = x:S64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_s_rrrci(dc, ra, rb, add_nz_cc, pc) ;

add.u

add.u:rri

mnemonic

add.u dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb + imm):U64

- ZF,CF <- dc

built-in syntax

__builtin_add_u_rri(dc, rb, imm) ;

add.u:rric

mnemonic

add.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_u_rric(dc, ra, imm, log_set_cc) ;

add.u:rrici

mnemonic

add.u dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm

- dc = x:U64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_u_rrici(dc, ra, imm, add_nz_cc, pc) ;

add.u:rrif

mnemonic

add.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_add_u_rrif(dc, ra, imm, false_cc) ;

add.u:rrr

mnemonic

add.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + rb

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_add_u_rrr(dc, ra, rb) ;

add.u:rrrc

mnemonic

add.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_add_u_rrrc(dc, ra, rb, log_set_cc) ;

add.u:rrrci

mnemonic

add.u dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb

- dc = x:U64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_add_u_rrrci(dc, ra, rb, add_nz_cc, pc) ;

ADDC

addc

addc:rri

mnemonic

addc rc:wr32 ra:r32 imm:u32

behavior

- rc = (ra + imm + CF)

- ZF,CF <- rc

built-in syntax

__builtin_addc_rri(rc, ra, imm) ;

addc:rric

mnemonic

addc rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm + CF

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_rric(rc, ra, imm, log_set_cc) ;

addc:rrici

mnemonic

addc rc:wr32 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm + CF

- rc = x

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_rrici(rc, ra, imm, add_nz_cc, pc) ;

addc:rrif

mnemonic

addc rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_addc_rrif(rc, ra, imm, false_cc) ;

addc:rrr

mnemonic

addc rc:wr32 ra:r32 rb:wr32

behavior

- x = ra + rb + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_addc_rrr(rc, ra, rb) ;

addc:rrrc

mnemonic

addc rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb + CF

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_rrrc(rc, ra, rb, log_set_cc) ;

addc:rrrci

mnemonic

addc rc:wr32 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb + CF

- rc = x

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_rrrci(rc, ra, rb, add_nz_cc, pc) ;

addc:zri

mnemonic

addc zero rb:wr32 imm:u32

behavior

- ZF,CF <- rb + imm + CF

built-in syntax

__builtin_addc_zri(zero, rb, imm) ;

addc:zric

mnemonic

addc zero ra:r32 imm:s27 log_set_cc:cc

behavior

- ZF,CF <- ra + imm + CF

built-in syntax

__builtin_addc_zric(zero, ra, imm, log_set_cc) ;

addc:zrici

mnemonic

addc zero ra:r32 imm:s11 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm + CF

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_zrici(zero, ra, imm, add_nz_cc, pc) ;

addc:zrif

mnemonic

addc zero ra:r32 imm:s27 false_cc:cc

behavior

- ZF,CF <- ra + imm + CF

built-in syntax

__builtin_addc_zrif(zero, ra, imm, false_cc) ;

addc:zrr

mnemonic

addc zero ra:r32 rb:wr32

behavior

- ZF,CF <- ra + rb + CF

built-in syntax

__builtin_addc_zrr(zero, ra, rb) ;

addc:zrrc

mnemonic

addc zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF,CF <- ra + rb + CF

built-in syntax

__builtin_addc_zrrc(zero, ra, rb, log_set_cc) ;

addc:zrrci

mnemonic

addc zero ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb + CF

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_zrrci(zero, ra, rb, add_nz_cc, pc) ;

addc.s

addc.s:rric

mnemonic

addc.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm + CF

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rric(dc, ra, imm, log_set_cc) ;

addc.s:rrici

mnemonic

addc.s dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm + CF

- dc = x:S64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rrici(dc, ra, imm, add_nz_cc, pc) ;

addc.s:rrif

mnemonic

addc.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rrif(dc, ra, imm, false_cc) ;

addc.s:rrr

mnemonic

addc.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + rb + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rrr(dc, ra, rb) ;

addc.s:rrrc

mnemonic

addc.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb + CF

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rrrc(dc, ra, rb, log_set_cc) ;

addc.s:rrrci

mnemonic

addc.s dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb + CF

- dc = x:S64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_s_rrrci(dc, ra, rb, add_nz_cc, pc) ;

addc.u

addc.u:rric

mnemonic

addc.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra + imm + CF

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rric(dc, ra, imm, log_set_cc) ;

addc.u:rrici

mnemonic

addc.u dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16

behavior

- x = ra + imm + CF

- dc = x:U64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rrici(dc, ra, imm, add_nz_cc, pc) ;

addc.u:rrif

mnemonic

addc.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + imm + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rrif(dc, ra, imm, false_cc) ;

addc.u:rrr

mnemonic

addc.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + rb + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rrr(dc, ra, rb) ;

addc.u:rrrc

mnemonic

addc.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra + rb + CF

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rrrc(dc, ra, rb, log_set_cc) ;

addc.u:rrrci

mnemonic

addc.u dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16

behavior

- x = ra + rb + CF

- dc = x:U64

- if (add_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_addc_u_rrrci(dc, ra, rb, add_nz_cc, pc) ;

AND

and

and:rri

mnemonic

and rc:wr32 ra:wr32 imm:u32

behavior

- rc = (ra & imm)

- ZF <- rc

built-in syntax

__builtin_and_rri(rc, ra, imm) ;

and:rric

mnemonic

and rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra & imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_and_rric(rc, ra, imm, log_set_cc) ;

and:rrici

mnemonic

and rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra & imm

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_rrici(rc, ra, imm, log_nz_cc, pc) ;

and:rrif

mnemonic

and rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra & imm

- rc = x

- ZF <- x

built-in syntax

__builtin_and_rrif(rc, ra, imm, false_cc) ;

and:rrr

mnemonic

and rc:wr32 ra:r32 rb:wr32

behavior

- x = ra & rb

- rc = x

- ZF <- x

built-in syntax

__builtin_and_rrr(rc, ra, rb) ;

and:rrrc

mnemonic

and rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra & rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_and_rrrc(rc, ra, rb, log_set_cc) ;

and:rrrci

mnemonic

and rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra & rb

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_rrrci(rc, ra, rb, log_nz_cc, pc) ;

and:zri

mnemonic

and zero rb:wr32 imm:u32

behavior

- ZF <- rb & imm

built-in syntax

__builtin_and_zri(zero, rb, imm) ;

and:zric

mnemonic

and zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ra & imm

built-in syntax

__builtin_and_zric(zero, ra, imm, log_set_cc) ;

and:zrici

mnemonic

and zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ra & imm

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_zrici(zero, ra, imm, log_nz_cc, pc) ;

and:zrif

mnemonic

and zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ra & imm

built-in syntax

__builtin_and_zrif(zero, ra, imm, false_cc) ;

and:zrr

mnemonic

and zero ra:r32 rb:wr32

behavior

- ZF <- ra & rb

built-in syntax

__builtin_and_zrr(zero, ra, rb) ;

and:zrrc

mnemonic

and zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra & rb

built-in syntax

__builtin_and_zrrc(zero, ra, rb, log_set_cc) ;

and:zrrci

mnemonic

and zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra & rb

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_zrrci(zero, ra, rb, log_nz_cc, pc) ;

and.s

and.s:rki

mnemonic

and.s dc:wr64 ra:r32 imm:u32

behavior

- dc = (ra & imm):S64

- ZF <- dc

built-in syntax

__builtin_and_s_rki(dc, ra, imm) ;

syntactic sugars

move.s dc:wr64 imm:u32

- ra = lneg

and.s:rri

mnemonic

and.s dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb & imm):S64

- ZF <- dc

built-in syntax

__builtin_and_s_rri(dc, rb, imm) ;

and.s:rric

mnemonic

and.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra & imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_and_s_rric(dc, ra, imm, log_set_cc) ;

and.s:rrici

mnemonic

and.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra & imm

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

and.s:rrif

mnemonic

and.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra & imm

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_and_s_rrif(dc, ra, imm, false_cc) ;

and.s:rrr

mnemonic

and.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra & rb

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_and_s_rrr(dc, ra, rb) ;

and.s:rrrc

mnemonic

and.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra & rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_and_s_rrrc(dc, ra, rb, log_set_cc) ;

and.s:rrrci

mnemonic

and.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra & rb

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

and.u

and.u:rki

mnemonic

and.u dc:wr64 ra:r32 imm:u32

behavior

- dc = (ra & imm):U64

- ZF <- dc

built-in syntax

__builtin_and_u_rki(dc, ra, imm) ;

syntactic sugars

move.u dc:wr64 imm:u32

- ra = lneg

and.u:rri

mnemonic

and.u dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb & imm):U64

- ZF <- dc

built-in syntax

__builtin_and_u_rri(dc, rb, imm) ;

and.u:rric

mnemonic

and.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra & imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_and_u_rric(dc, ra, imm, log_set_cc) ;

and.u:rrici

mnemonic

and.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra & imm

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

and.u:rrif

mnemonic

and.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra & imm

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_and_u_rrif(dc, ra, imm, false_cc) ;

and.u:rrr

mnemonic

and.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra & rb

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_and_u_rrr(dc, ra, rb) ;

and.u:rrrc

mnemonic

and.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra & rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_and_u_rrrc(dc, ra, rb, log_set_cc) ;

and.u:rrrci

mnemonic

and.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra & rb

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_and_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

ANDN

andn

andn:rric

mnemonic

andn rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra & imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_andn_rric(rc, ra, imm, log_set_cc) ;

andn:rrici

mnemonic

andn rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & imm

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_rrici(rc, ra, imm, log_nz_cc, pc) ;

andn:rrif

mnemonic

andn rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra & imm

- rc = x

- ZF <- x

built-in syntax

__builtin_andn_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

andn rc:wr32 ra:r32 imm:s24

- false_cc = false

andn:rrr

mnemonic

andn rc:wr32 ra:r32 rb:wr32

behavior

- x = ~ra & rb

- rc = x

- ZF <- x

built-in syntax

__builtin_andn_rrr(rc, ra, rb) ;

andn:rrrc

mnemonic

andn rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra & rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_andn_rrrc(rc, ra, rb, log_set_cc) ;

andn:rrrci

mnemonic

andn rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & rb

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_rrrci(rc, ra, rb, log_nz_cc, pc) ;

andn:zric

mnemonic

andn zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ~ra & imm

built-in syntax

__builtin_andn_zric(zero, ra, imm, log_set_cc) ;

andn:zrici

mnemonic

andn zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & imm

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_zrici(zero, ra, imm, log_nz_cc, pc) ;

andn:zrif

mnemonic

andn zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ~ra & imm

built-in syntax

__builtin_andn_zrif(zero, ra, imm, false_cc) ;

andn:zrr

mnemonic

andn zero ra:r32 rb:wr32

behavior

- ZF <- ~ra & rb

built-in syntax

__builtin_andn_zrr(zero, ra, rb) ;

andn:zrrc

mnemonic

andn zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ~ra & rb

built-in syntax

__builtin_andn_zrrc(zero, ra, rb, log_set_cc) ;

andn:zrrci

mnemonic

andn zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & rb

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_zrrci(zero, ra, rb, log_nz_cc, pc) ;

andn.s

andn.s:rric

mnemonic

andn.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra & imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_andn_s_rric(dc, ra, imm, log_set_cc) ;

andn.s:rrici

mnemonic

andn.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & imm

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

andn.s:rrif

mnemonic

andn.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra & imm

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_andn_s_rrif(dc, ra, imm, false_cc) ;

andn.s:rrr

mnemonic

andn.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ~ra & rb

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_andn_s_rrr(dc, ra, rb) ;

andn.s:rrrc

mnemonic

andn.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra & rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_andn_s_rrrc(dc, ra, rb, log_set_cc) ;

andn.s:rrrci

mnemonic

andn.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & rb

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

andn.u

andn.u:rric

mnemonic

andn.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra & imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_andn_u_rric(dc, ra, imm, log_set_cc) ;

andn.u:rrici

mnemonic

andn.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & imm

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

andn.u:rrif

mnemonic

andn.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra & imm

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_andn_u_rrif(dc, ra, imm, false_cc) ;

andn.u:rrr

mnemonic

andn.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ~ra & rb

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_andn_u_rrr(dc, ra, rb) ;

andn.u:rrrc

mnemonic

andn.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra & rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_andn_u_rrrc(dc, ra, rb, log_set_cc) ;

andn.u:rrrci

mnemonic

andn.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra & rb

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_andn_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

ASR

asr

asr:rri

mnemonic

asr rc:wr32 ra:r32 shift:u5

behavior

- x = ra >>a shift[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_asr_rri(rc, ra, shift) ;

asr:rric

mnemonic

asr rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>a shift[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_asr_rric(rc, ra, shift, log_set_cc) ;

asr:rrici

mnemonic

asr rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a shift[0:4]

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

asr:rrr

mnemonic

asr rc:wr32 ra:r32 rb:wr32

behavior

- x = ra >>a rb[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_asr_rrr(rc, ra, rb) ;

asr:rrrc

mnemonic

asr rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>a rb[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_asr_rrrc(rc, ra, rb, log_set_cc) ;

asr:rrrci

mnemonic

asr rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a rb[0:4]

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

asr:zri

mnemonic

asr zero ra:r32 shift:u5

behavior

- ZF <- ra >>a shift[0:4]

built-in syntax

__builtin_asr_zri(zero, ra, shift) ;

asr:zric

mnemonic

asr zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra >>a shift[0:4]

built-in syntax

__builtin_asr_zric(zero, ra, shift, log_set_cc) ;

asr:zrici

mnemonic

asr zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a shift[0:4]

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

asr:zrr

mnemonic

asr zero ra:r32 rb:wr32

behavior

- ZF <- ra >>a rb[0:4]

built-in syntax

__builtin_asr_zrr(zero, ra, rb) ;

asr:zrrc

mnemonic

asr zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra >>a rb[0:4]

built-in syntax

__builtin_asr_zrrc(zero, ra, rb, log_set_cc) ;

asr:zrrci

mnemonic

asr zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a rb[0:4]

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

asr.s

asr.s:rri

mnemonic

asr.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra >>a shift[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_asr_s_rri(dc, ra, shift) ;

asr.s:rric

mnemonic

asr.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>a shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_asr_s_rric(dc, ra, shift, log_set_cc) ;

asr.s:rrici

mnemonic

asr.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a shift[0:4]

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

asr.s:rrr

mnemonic

asr.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >>a rb[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_asr_s_rrr(dc, ra, rb) ;

asr.s:rrrc

mnemonic

asr.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>a rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_asr_s_rrrc(dc, ra, rb, log_set_cc) ;

asr.s:rrrci

mnemonic

asr.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a rb[0:4]

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

asr.u

asr.u:rri

mnemonic

asr.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra >>a shift[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_asr_u_rri(dc, ra, shift) ;

asr.u:rric

mnemonic

asr.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>a shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_asr_u_rric(dc, ra, shift, log_set_cc) ;

asr.u:rrici

mnemonic

asr.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a shift[0:4]

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

asr.u:rrr

mnemonic

asr.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >>a rb[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_asr_u_rrr(dc, ra, rb) ;

asr.u:rrrc

mnemonic

asr.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>a rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_asr_u_rrrc(dc, ra, rb, log_set_cc) ;

asr.u:rrrci

mnemonic

asr.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>a rb[0:4]

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_asr_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

CAO

cao

cao:rr

mnemonic

cao rc:wr32 ra:r32

behavior

- x = count one bits in ra

- rc = x

- ZF <- x

built-in syntax

__builtin_cao_rr(rc, ra) ;

cao:rrc

mnemonic

cao rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = count one bits in ra

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_cao_rrc(rc, ra, log_set_cc) ;

cao:rrci

mnemonic

cao rc:wr32 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count one bits in ra

- rc = x

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cao_rrci(rc, ra, count_nz_cc, pc) ;

cao:zr

mnemonic

cao zero ra:r32

behavior

- ZF <- count one bits in ra

built-in syntax

__builtin_cao_zr(zero, ra) ;

cao:zrc

mnemonic

cao zero ra:r32 log_set_cc:cc

behavior

- ZF <- count one bits in ra

built-in syntax

__builtin_cao_zrc(zero, ra, log_set_cc) ;

cao:zrci

mnemonic

cao zero ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count one bits in ra

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cao_zrci(zero, ra, count_nz_cc, pc) ;

cao.s

cao.s:rr

mnemonic

cao.s dc:wr64 ra:r32

behavior

- x = count one bits in ra

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_cao_s_rr(dc, ra) ;

cao.s:rrc

mnemonic

cao.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count one bits in ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cao_s_rrc(dc, ra, log_set_cc) ;

cao.s:rrci

mnemonic

cao.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count one bits in ra

- dc = x:S64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cao_s_rrci(dc, ra, count_nz_cc, pc) ;

cao.u

cao.u:rr

mnemonic

cao.u dc:wr64 ra:r32

behavior

- x = count one bits in ra

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_cao_u_rr(dc, ra) ;

cao.u:rrc

mnemonic

cao.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count one bits in ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cao_u_rrc(dc, ra, log_set_cc) ;

cao.u:rrci

mnemonic

cao.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count one bits in ra

- dc = x:U64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cao_u_rrci(dc, ra, count_nz_cc, pc) ;

CLO

clo

clo:rr

mnemonic

clo rc:wr32 ra:r32

behavior

- x = count leading one bits of ra

- rc = x

- ZF <- x

built-in syntax

__builtin_clo_rr(rc, ra) ;

clo:rrc

mnemonic

clo rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = count leading one bits of ra

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_clo_rrc(rc, ra, log_set_cc) ;

clo:rrci

mnemonic

clo rc:wr32 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading one bits of ra

- rc = x

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clo_rrci(rc, ra, count_nz_cc, pc) ;

clo:zr

mnemonic

clo zero ra:r32

behavior

- ZF <- count leading one bits of ra

built-in syntax

__builtin_clo_zr(zero, ra) ;

clo:zrc

mnemonic

clo zero ra:r32 log_set_cc:cc

behavior

- ZF <- count leading one bits of ra

built-in syntax

__builtin_clo_zrc(zero, ra, log_set_cc) ;

clo:zrci

mnemonic

clo zero ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading one bits of ra

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clo_zrci(zero, ra, count_nz_cc, pc) ;

clo.s

clo.s:rr

mnemonic

clo.s dc:wr64 ra:r32

behavior

- x = count leading one bits of ra

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_clo_s_rr(dc, ra) ;

clo.s:rrc

mnemonic

clo.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading one bits of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_clo_s_rrc(dc, ra, log_set_cc) ;

clo.s:rrci

mnemonic

clo.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading one bits of ra

- dc = x:S64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clo_s_rrci(dc, ra, count_nz_cc, pc) ;

clo.u

clo.u:rr

mnemonic

clo.u dc:wr64 ra:r32

behavior

- x = count leading one bits of ra

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_clo_u_rr(dc, ra) ;

clo.u:rrc

mnemonic

clo.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading one bits of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_clo_u_rrc(dc, ra, log_set_cc) ;

clo.u:rrci

mnemonic

clo.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading one bits of ra

- dc = x:U64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clo_u_rrci(dc, ra, count_nz_cc, pc) ;

CLS

cls

cls:rr

mnemonic

cls rc:wr32 ra:r32

behavior

- x = count leading sign bit of ra

- rc = x

- ZF <- x

built-in syntax

__builtin_cls_rr(rc, ra) ;

cls:rrc

mnemonic

cls rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = count leading sign bit of ra

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_cls_rrc(rc, ra, log_set_cc) ;

cls:rrci

mnemonic

cls rc:wr32 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading sign bit of ra

- rc = x

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cls_rrci(rc, ra, count_nz_cc, pc) ;

cls:zr

mnemonic

cls zero ra:r32

behavior

- ZF <- count leading sign bit of ra

built-in syntax

__builtin_cls_zr(zero, ra) ;

cls:zrc

mnemonic

cls zero ra:r32 log_set_cc:cc

behavior

- ZF <- count leading sign bit of ra

built-in syntax

__builtin_cls_zrc(zero, ra, log_set_cc) ;

cls:zrci

mnemonic

cls zero ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading sign bit of ra

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cls_zrci(zero, ra, count_nz_cc, pc) ;

cls.s

cls.s:rr

mnemonic

cls.s dc:wr64 ra:r32

behavior

- x = count leading sign bit of ra

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_cls_s_rr(dc, ra) ;

cls.s:rrc

mnemonic

cls.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading sign bit of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cls_s_rrc(dc, ra, log_set_cc) ;

cls.s:rrci

mnemonic

cls.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading sign bit of ra

- dc = x:S64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cls_s_rrci(dc, ra, count_nz_cc, pc) ;

cls.u

cls.u:rr

mnemonic

cls.u dc:wr64 ra:r32

behavior

- x = count leading sign bit of ra

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_cls_u_rr(dc, ra) ;

cls.u:rrc

mnemonic

cls.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading sign bit of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cls_u_rrc(dc, ra, log_set_cc) ;

cls.u:rrci

mnemonic

cls.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading sign bit of ra

- dc = x:U64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cls_u_rrci(dc, ra, count_nz_cc, pc) ;

CLZ

clz

clz:rr

mnemonic

clz rc:wr32 ra:r32

behavior

- x = count leading zero bits of ra

- rc = x

- ZF <- x

built-in syntax

__builtin_clz_rr(rc, ra) ;

clz:rrc

mnemonic

clz rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = count leading zero bits of ra

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_clz_rrc(rc, ra, log_set_cc) ;

clz:rrci

mnemonic

clz rc:wr32 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading zero bits of ra

- rc = x

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clz_rrci(rc, ra, count_nz_cc, pc) ;

clz:zr

mnemonic

clz zero ra:r32

behavior

- ZF <- count leading zero bits of ra

built-in syntax

__builtin_clz_zr(zero, ra) ;

clz:zrc

mnemonic

clz zero ra:r32 log_set_cc:cc

behavior

- ZF <- count leading zero bits of ra

built-in syntax

__builtin_clz_zrc(zero, ra, log_set_cc) ;

clz:zrci

mnemonic

clz zero ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading zero bits of ra

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clz_zrci(zero, ra, count_nz_cc, pc) ;

clz.s

clz.s:rr

mnemonic

clz.s dc:wr64 ra:r32

behavior

- x = count leading zero bits of ra

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_clz_s_rr(dc, ra) ;

clz.s:rrc

mnemonic

clz.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading zero bits of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_clz_s_rrc(dc, ra, log_set_cc) ;

clz.s:rrci

mnemonic

clz.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading zero bits of ra

- dc = x:S64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clz_s_rrci(dc, ra, count_nz_cc, pc) ;

clz.u

clz.u:rr

mnemonic

clz.u dc:wr64 ra:r32

behavior

- x = count leading zero bits of ra

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_clz_u_rr(dc, ra) ;

clz.u:rrc

mnemonic

clz.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = count leading zero bits of ra

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_clz_u_rrc(dc, ra, log_set_cc) ;

clz.u:rrci

mnemonic

clz.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16

behavior

- x = count leading zero bits of ra

- dc = x:U64

- if (count_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_clz_u_rrci(dc, ra, count_nz_cc, pc) ;

CMPB4

cmpb4

cmpb4:rrr

mnemonic

cmpb4 rc:wr32 ra:r32 rb:wr32

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- rc = x

- ZF <- x

built-in syntax

__builtin_cmpb4_rrr(rc, ra, rb) ;

cmpb4:rrrc

mnemonic

cmpb4 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_cmpb4_rrrc(rc, ra, rb, log_set_cc) ;

cmpb4:rrrci

mnemonic

cmpb4 rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cmpb4_rrrci(rc, ra, rb, log_nz_cc, pc) ;

cmpb4:zrr

mnemonic

cmpb4 zero ra:r32 rb:wr32

behavior

- ZF <- For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

built-in syntax

__builtin_cmpb4_zrr(zero, ra, rb) ;

cmpb4:zrrc

mnemonic

cmpb4 zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

built-in syntax

__builtin_cmpb4_zrrc(zero, ra, rb, log_set_cc) ;

cmpb4:zrrci

mnemonic

cmpb4 zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cmpb4_zrrci(zero, ra, rb, log_nz_cc, pc) ;

cmpb4.s

cmpb4.s:rrr

mnemonic

cmpb4.s dc:wr64 ra:r32 rb:wr32

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_cmpb4_s_rrr(dc, ra, rb) ;

cmpb4.s:rrrc

mnemonic

cmpb4.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cmpb4_s_rrrc(dc, ra, rb, log_set_cc) ;

cmpb4.s:rrrci

mnemonic

cmpb4.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cmpb4_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

cmpb4.u

cmpb4.u:rrr

mnemonic

cmpb4.u dc:wr64 ra:r32 rb:wr32

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_cmpb4_u_rrr(dc, ra, rb) ;

cmpb4.u:rrrc

mnemonic

cmpb4.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_cmpb4_u_rrrc(dc, ra, rb, log_set_cc) ;

cmpb4.u:rrrci

mnemonic

cmpb4.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = For i=[0..3] if byte ra[i] == byte rb[i] then byte i is set to 1, 0 otherwise

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_cmpb4_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

DIV

div_step:rrrici

mnemonic

div_step dc:wr64 ra:r32 db:wr64 shift:u5 div_cc:cc pc:pc16

behavior

- cc = (dbo - (ra << shift))

- cc = if (const_cc_geu cc) then

-     x = dbe << 1 padded with ones

-     y = dbo - (ra << shift)

-     dc = (x, y)

-     dc

- else

-     dce = (dbe << 1)

- if (div_cc cc) then

-     jump @[pc]

built-in syntax

__builtin_div_step_rrrici(dc, ra, db, shift, div_cc, pc) ;

syntactic sugars

div_step dc:wr64 ra:r32 db:wr64 shift:u5

- div_cc = false

- pc = 0

EXTSB

extsb

extsb:rr

mnemonic

extsb rc:wr32 ra:r32

behavior

- x = ra[0:7]:S32

- rc = x

- ZF <- x

built-in syntax

__builtin_extsb_rr(rc, ra) ;

extsb:rrc

mnemonic

extsb rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = ra[0:7]:S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_extsb_rrc(rc, ra, log_set_cc) ;

extsb:rrci

mnemonic

extsb rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:S32

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsb_rrci(rc, ra, log_nz_cc, pc) ;

extsb:zr

mnemonic

extsb zero ra:r32

behavior

- ZF <- ra[0:7]:S32

built-in syntax

__builtin_extsb_zr(zero, ra) ;

extsb:zrc

mnemonic

extsb zero ra:r32 log_set_cc:cc

behavior

- ZF <- ra[0:7]:S32

built-in syntax

__builtin_extsb_zrc(zero, ra, log_set_cc) ;

extsb:zrci

mnemonic

extsb zero ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:S32

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsb_zrci(zero, ra, log_nz_cc, pc) ;

extsb.s

extsb.s:rr

mnemonic

extsb.s dc:wr64 ra:r32

behavior

- x = ra[0:7]:S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_extsb_s_rr(dc, ra) ;

extsb.s:rrc

mnemonic

extsb.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = ra[0:7]:S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_extsb_s_rrc(dc, ra, log_set_cc) ;

extsb.s:rrci

mnemonic

extsb.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:S32

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsb_s_rrci(dc, ra, log_nz_cc, pc) ;

EXTSH

extsh

extsh:rr

mnemonic

extsh rc:wr32 ra:r32

behavior

- x = ra[0:15]:S32

- rc = x

- ZF <- x

built-in syntax

__builtin_extsh_rr(rc, ra) ;

extsh:rrc

mnemonic

extsh rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = ra[0:15]:S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_extsh_rrc(rc, ra, log_set_cc) ;

extsh:rrci

mnemonic

extsh rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:S32

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsh_rrci(rc, ra, log_nz_cc, pc) ;

extsh:zr

mnemonic

extsh zero ra:r32

behavior

- ZF <- ra[0:15]:S32

built-in syntax

__builtin_extsh_zr(zero, ra) ;

extsh:zrc

mnemonic

extsh zero ra:r32 log_set_cc:cc

behavior

- ZF <- ra[0:15]:S32

built-in syntax

__builtin_extsh_zrc(zero, ra, log_set_cc) ;

extsh:zrci

mnemonic

extsh zero ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:S32

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsh_zrci(zero, ra, log_nz_cc, pc) ;

extsh.s

extsh.s:rr

mnemonic

extsh.s dc:wr64 ra:r32

behavior

- x = ra[0:15]:S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_extsh_s_rr(dc, ra) ;

extsh.s:rrc

mnemonic

extsh.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = ra[0:15]:S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_extsh_s_rrc(dc, ra, log_set_cc) ;

extsh.s:rrci

mnemonic

extsh.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:S32

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extsh_s_rrci(dc, ra, log_nz_cc, pc) ;

EXTUB

extub

extub:rr

mnemonic

extub rc:wr32 ra:r32

behavior

- x = ra[0:7]:U32

- rc = x

- ZF <- x

built-in syntax

__builtin_extub_rr(rc, ra) ;

extub:rrc

mnemonic

extub rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = ra[0:7]:U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_extub_rrc(rc, ra, log_set_cc) ;

extub:rrci

mnemonic

extub rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:U32

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extub_rrci(rc, ra, log_nz_cc, pc) ;

extub:zr

mnemonic

extub zero ra:r32

behavior

- ZF <- ra[0:7]:U32

built-in syntax

__builtin_extub_zr(zero, ra) ;

extub:zrc

mnemonic

extub zero ra:r32 log_set_cc:cc

behavior

- ZF <- ra[0:7]:U32

built-in syntax

__builtin_extub_zrc(zero, ra, log_set_cc) ;

extub:zrci

mnemonic

extub zero ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:U32

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extub_zrci(zero, ra, log_nz_cc, pc) ;

extub.u

extub.u:rr

mnemonic

extub.u dc:wr64 ra:r32

behavior

- x = ra[0:7]:U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_extub_u_rr(dc, ra) ;

extub.u:rrc

mnemonic

extub.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = ra[0:7]:U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_extub_u_rrc(dc, ra, log_set_cc) ;

extub.u:rrci

mnemonic

extub.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:7]:U32

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extub_u_rrci(dc, ra, log_nz_cc, pc) ;

EXTUH

extuh

extuh:rr

mnemonic

extuh rc:wr32 ra:r32

behavior

- x = ra[0:15]:U32

- rc = x

- ZF <- x

built-in syntax

__builtin_extuh_rr(rc, ra) ;

extuh:rrc

mnemonic

extuh rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = ra[0:15]:U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_extuh_rrc(rc, ra, log_set_cc) ;

extuh:rrci

mnemonic

extuh rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:U32

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extuh_rrci(rc, ra, log_nz_cc, pc) ;

extuh:zr

mnemonic

extuh zero ra:r32

behavior

- ZF <- ra[0:15]:U32

built-in syntax

__builtin_extuh_zr(zero, ra) ;

extuh:zrc

mnemonic

extuh zero ra:r32 log_set_cc:cc

behavior

- ZF <- ra[0:15]:U32

built-in syntax

__builtin_extuh_zrc(zero, ra, log_set_cc) ;

extuh:zrci

mnemonic

extuh zero ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:U32

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extuh_zrci(zero, ra, log_nz_cc, pc) ;

extuh.u

extuh.u:rr

mnemonic

extuh.u dc:wr64 ra:r32

behavior

- x = ra[0:15]:U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_extuh_u_rr(dc, ra) ;

extuh.u:rrc

mnemonic

extuh.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = ra[0:15]:U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_extuh_u_rrc(dc, ra, log_set_cc) ;

extuh.u:rrci

mnemonic

extuh.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = ra[0:15]:U32

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_extuh_u_rrci(dc, ra, log_nz_cc, pc) ;

LSL

lsl

lsl:rri

mnemonic

lsl rc:wr32 ra:r32 shift:u5

behavior

- x = ra << shift[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl_rri(rc, ra, shift) ;

lsl:rric

mnemonic

lsl rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl_rric(rc, ra, shift, log_set_cc) ;

lsl:rrici

mnemonic

lsl rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4]

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsl:rrr

mnemonic

lsl rc:wr32 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl_rrr(rc, ra, rb) ;

lsl:rrrc

mnemonic

lsl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl_rrrc(rc, ra, rb, log_set_cc) ;

lsl:rrrci

mnemonic

lsl rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4]

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsl:zri

mnemonic

lsl zero ra:r32 shift:u5

behavior

- ZF <- ra << shift[0:4]

built-in syntax

__builtin_lsl_zri(zero, ra, shift) ;

lsl:zric

mnemonic

lsl zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra << shift[0:4]

built-in syntax

__builtin_lsl_zric(zero, ra, shift, log_set_cc) ;

lsl:zrici

mnemonic

lsl zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4]

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsl:zrr

mnemonic

lsl zero ra:r32 rb:wr32

behavior

- ZF <- ra << rb[0:4]

built-in syntax

__builtin_lsl_zrr(zero, ra, rb) ;

lsl:zrrc

mnemonic

lsl zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra << rb[0:4]

built-in syntax

__builtin_lsl_zrrc(zero, ra, rb, log_set_cc) ;

lsl:zrrci

mnemonic

lsl zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4]

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsl.s

lsl.s:rri

mnemonic

lsl.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra << shift[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl_s_rri(dc, ra, shift) ;

lsl.s:rric

mnemonic

lsl.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl_s_rric(dc, ra, shift, log_set_cc) ;

lsl.s:rrici

mnemonic

lsl.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4]

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl.s:rrr

mnemonic

lsl.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl_s_rrr(dc, ra, rb) ;

lsl.s:rrrc

mnemonic

lsl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl_s_rrrc(dc, ra, rb, log_set_cc) ;

lsl.s:rrrci

mnemonic

lsl.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4]

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsl.u

lsl.u:rri

mnemonic

lsl.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra << shift[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl_u_rri(dc, ra, shift) ;

lsl.u:rric

mnemonic

lsl.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl_u_rric(dc, ra, shift, log_set_cc) ;

lsl.u:rrici

mnemonic

lsl.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4]

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl.u:rrr

mnemonic

lsl.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl_u_rrr(dc, ra, rb) ;

lsl.u:rrrc

mnemonic

lsl.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl_u_rrrc(dc, ra, rb, log_set_cc) ;

lsl.u:rrrci

mnemonic

lsl.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4]

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsl_add

lsl_add:rrri

mnemonic

lsl_add rc:wr32 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- rc = x

built-in syntax

__builtin_lsl_add_rrri(rc, rb, ra, shift) ;

lsl_add:rrrici

mnemonic

lsl_add rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- rc = x

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_add_rrrici(rc, rb, ra, shift, div_nz_cc, pc) ;

lsl_add:zrri

mnemonic

lsl_add zero rb:wr32 ra:r32 shift:u5

behavior

- instruction with no effect

built-in syntax

__builtin_lsl_add_zrri(zero, rb, ra, shift) ;

lsl_add:zrrici

mnemonic

lsl_add zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_add_zrrici(zero, rb, ra, shift, div_nz_cc, pc) ;

lsl_add.s

lsl_add.s:rrri

mnemonic

lsl_add.s dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- dc = x:S64

built-in syntax

__builtin_lsl_add_s_rrri(dc, rb, ra, shift) ;

lsl_add.s:rrrici

mnemonic

lsl_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- dc = x:S64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_add_s_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

lsl_add.u

lsl_add.u:rrri

mnemonic

lsl_add.u dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- dc = x:U64

built-in syntax

__builtin_lsl_add_u_rrri(dc, rb, ra, shift) ;

lsl_add.u:rrrici

mnemonic

lsl_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb + (ra << shift[0:4])

- dc = x:U64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_add_u_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

lsl_sub

lsl_sub:rrri

mnemonic

lsl_sub rc:wr32 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- rc = x

built-in syntax

__builtin_lsl_sub_rrri(rc, rb, ra, shift) ;

lsl_sub:rrrici

mnemonic

lsl_sub rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- rc = x

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_sub_rrrici(rc, rb, ra, shift, div_nz_cc, pc) ;

lsl_sub:zrri

mnemonic

lsl_sub zero rb:wr32 ra:r32 shift:u5

behavior

- instruction with no effect

built-in syntax

__builtin_lsl_sub_zrri(zero, rb, ra, shift) ;

lsl_sub:zrrici

mnemonic

lsl_sub zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_sub_zrrici(zero, rb, ra, shift, div_nz_cc, pc) ;

lsl_sub.s

lsl_sub.s:rrri

mnemonic

lsl_sub.s dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- dc = x:S64

built-in syntax

__builtin_lsl_sub_s_rrri(dc, rb, ra, shift) ;

lsl_sub.s:rrrici

mnemonic

lsl_sub.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- dc = x:S64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_sub_s_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

lsl_sub.u

lsl_sub.u:rrri

mnemonic

lsl_sub.u dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- dc = x:U64

built-in syntax

__builtin_lsl_sub_u_rrri(dc, rb, ra, shift) ;

lsl_sub.u:rrrici

mnemonic

lsl_sub.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra << shift

- x = rb - (ra << shift[0:4])

- dc = x:U64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsl_sub_u_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

LSL1

lsl1

lsl1:rri

mnemonic

lsl1 rc:wr32 ra:r32 shift:u5

behavior

- x = ra << shift[0:4] padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl1_rri(rc, ra, shift) ;

lsl1:rric

mnemonic

lsl1 rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4] padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_rric(rc, ra, shift, log_set_cc) ;

lsl1:rrici

mnemonic

lsl1 rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4] padded with ones

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1:rrr

mnemonic

lsl1 rc:wr32 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4] padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl1_rrr(rc, ra, rb) ;

lsl1:rrrc

mnemonic

lsl1 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4] padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_rrrc(rc, ra, rb, log_set_cc) ;

lsl1:rrrci

mnemonic

lsl1 rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4] padded with ones

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsl1:zri

mnemonic

lsl1 zero ra:r32 shift:u5

behavior

- ZF <- ra << shift[0:4] padded with ones

built-in syntax

__builtin_lsl1_zri(zero, ra, shift) ;

lsl1:zric

mnemonic

lsl1 zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra << shift[0:4] padded with ones

built-in syntax

__builtin_lsl1_zric(zero, ra, shift, log_set_cc) ;

lsl1:zrici

mnemonic

lsl1 zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4] padded with ones

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsl1:zrr

mnemonic

lsl1 zero ra:r32 rb:wr32

behavior

- ZF <- ra << rb[0:4] padded with ones

built-in syntax

__builtin_lsl1_zrr(zero, ra, rb) ;

lsl1:zrrc

mnemonic

lsl1 zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra << rb[0:4] padded with ones

built-in syntax

__builtin_lsl1_zrrc(zero, ra, rb, log_set_cc) ;

lsl1:zrrci

mnemonic

lsl1 zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4] padded with ones

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsl1.s

lsl1.s:rri

mnemonic

lsl1.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra << shift[0:4] padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl1_s_rri(dc, ra, shift) ;

lsl1.s:rric

mnemonic

lsl1.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_s_rric(dc, ra, shift, log_set_cc) ;

lsl1.s:rrici

mnemonic

lsl1.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4] padded with ones

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1.s:rrr

mnemonic

lsl1.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4] padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl1_s_rrr(dc, ra, rb) ;

lsl1.s:rrrc

mnemonic

lsl1.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_s_rrrc(dc, ra, rb, log_set_cc) ;

lsl1.s:rrrci

mnemonic

lsl1.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4] padded with ones

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsl1.u

lsl1.u:rri

mnemonic

lsl1.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra << shift[0:4] padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl1_u_rri(dc, ra, shift) ;

lsl1.u:rric

mnemonic

lsl1.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra << shift[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_u_rric(dc, ra, shift, log_set_cc) ;

lsl1.u:rrici

mnemonic

lsl1.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra << shift[0:4] padded with ones

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1.u:rrr

mnemonic

lsl1.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra << rb[0:4] padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl1_u_rrr(dc, ra, rb) ;

lsl1.u:rrrc

mnemonic

lsl1.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra << rb[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1_u_rrrc(dc, ra, rb, log_set_cc) ;

lsl1.u:rrrci

mnemonic

lsl1.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra << rb[0:4] padded with ones

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

LSL1X

lsl1x

lsl1x:rri

mnemonic

lsl1x rc:wr32 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl1x_rri(rc, ra, shift) ;

lsl1x:rric

mnemonic

lsl1x rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_rric(rc, ra, shift, log_set_cc) ;

lsl1x:rrici

mnemonic

lsl1x rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1x:rrr

mnemonic

lsl1x rc:wr32 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsl1x_rrr(rc, ra, rb) ;

lsl1x:rrrc

mnemonic

lsl1x rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_rrrc(rc, ra, rb, log_set_cc) ;

lsl1x:rrrci

mnemonic

lsl1x rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsl1x:zri

mnemonic

lsl1x zero ra:r32 shift:u5

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra >> (32 - shift[0:4]) padded with ones)

built-in syntax

__builtin_lsl1x_zri(zero, ra, shift) ;

lsl1x:zric

mnemonic

lsl1x zero ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra >> (32 - shift[0:4]) padded with ones)

built-in syntax

__builtin_lsl1x_zric(zero, ra, shift, log_set_cc) ;

lsl1x:zrici

mnemonic

lsl1x zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsl1x:zrr

mnemonic

lsl1x zero ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra >> (32 - rb[0:4]) padded with ones)

built-in syntax

__builtin_lsl1x_zrr(zero, ra, rb) ;

lsl1x:zrrc

mnemonic

lsl1x zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra >> (32 - rb[0:4]) padded with ones)

built-in syntax

__builtin_lsl1x_zrrc(zero, ra, rb, log_set_cc) ;

lsl1x:zrrci

mnemonic

lsl1x zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsl1x.s

lsl1x.s:rri

mnemonic

lsl1x.s dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rri(dc, ra, shift) ;

lsl1x.s:rric

mnemonic

lsl1x.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rric(dc, ra, shift, log_set_cc) ;

lsl1x.s:rrici

mnemonic

lsl1x.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1x.s:rrr

mnemonic

lsl1x.s dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rrr(dc, ra, rb) ;

lsl1x.s:rrrc

mnemonic

lsl1x.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rrrc(dc, ra, rb, log_set_cc) ;

lsl1x.s:rrrci

mnemonic

lsl1x.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsl1x.u

lsl1x.u:rri

mnemonic

lsl1x.u dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rri(dc, ra, shift) ;

lsl1x.u:rric

mnemonic

lsl1x.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rric(dc, ra, shift, log_set_cc) ;

lsl1x.u:rrici

mnemonic

lsl1x.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - shift[0:4]) padded with ones

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsl1x.u:rrr

mnemonic

lsl1x.u dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rrr(dc, ra, rb) ;

lsl1x.u:rrrc

mnemonic

lsl1x.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rrrc(dc, ra, rb, log_set_cc) ;

lsl1x.u:rrrci

mnemonic

lsl1x.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra >> (32 - rb[0:4]) padded with ones

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsl1x_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

LSLX

lslx

lslx:rri

mnemonic

lslx rc:wr32 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- rc = x

- ZF <- x

built-in syntax

__builtin_lslx_rri(rc, ra, shift) ;

lslx:rric

mnemonic

lslx rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lslx_rric(rc, ra, shift, log_set_cc) ;

lslx:rrici

mnemonic

lslx rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lslx:rrr

mnemonic

lslx rc:wr32 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- rc = x

- ZF <- x

built-in syntax

__builtin_lslx_rrr(rc, ra, rb) ;

lslx:rrrc

mnemonic

lslx rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lslx_rrrc(rc, ra, rb, log_set_cc) ;

lslx:rrrci

mnemonic

lslx rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lslx:zri

mnemonic

lslx zero ra:r32 shift:u5

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra >> (32 - shift[0:4]))

built-in syntax

__builtin_lslx_zri(zero, ra, shift) ;

lslx:zric

mnemonic

lslx zero ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra >> (32 - shift[0:4]))

built-in syntax

__builtin_lslx_zric(zero, ra, shift, log_set_cc) ;

lslx:zrici

mnemonic

lslx zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lslx:zrr

mnemonic

lslx zero ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra >> (32 - rb[0:4]))

built-in syntax

__builtin_lslx_zrr(zero, ra, rb) ;

lslx:zrrc

mnemonic

lslx zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra >> (32 - rb[0:4]))

built-in syntax

__builtin_lslx_zrrc(zero, ra, rb, log_set_cc) ;

lslx:zrrci

mnemonic

lslx zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lslx.s

lslx.s:rri

mnemonic

lslx.s dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lslx_s_rri(dc, ra, shift) ;

lslx.s:rric

mnemonic

lslx.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lslx_s_rric(dc, ra, shift, log_set_cc) ;

lslx.s:rrici

mnemonic

lslx.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lslx.s:rrr

mnemonic

lslx.s dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lslx_s_rrr(dc, ra, rb) ;

lslx.s:rrrc

mnemonic

lslx.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lslx_s_rrrc(dc, ra, rb, log_set_cc) ;

lslx.s:rrrci

mnemonic

lslx.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lslx.u

lslx.u:rri

mnemonic

lslx.u dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lslx_u_rri(dc, ra, shift) ;

lslx.u:rric

mnemonic

lslx.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lslx_u_rric(dc, ra, shift, log_set_cc) ;

lslx.u:rrici

mnemonic

lslx.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - shift[0:4])

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lslx.u:rrr

mnemonic

lslx.u dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lslx_u_rrr(dc, ra, rb) ;

lslx.u:rrrc

mnemonic

lslx.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lslx_u_rrrc(dc, ra, rb, log_set_cc) ;

lslx.u:rrrci

mnemonic

lslx.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra >> (32 - rb[0:4])

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lslx_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

LSR

lsr

lsr:rri

mnemonic

lsr rc:wr32 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr_rri(rc, ra, shift) ;

lsr:rric

mnemonic

lsr rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr_rric(rc, ra, shift, log_set_cc) ;

lsr:rrici

mnemonic

lsr rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4]

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsr:rrr

mnemonic

lsr rc:wr32 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr_rrr(rc, ra, rb) ;

lsr:rrrc

mnemonic

lsr rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr_rrrc(rc, ra, rb, log_set_cc) ;

lsr:rrrci

mnemonic

lsr rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4]

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsr:zri

mnemonic

lsr zero ra:r32 shift:u5

behavior

- ZF <- ra >> shift[0:4]

built-in syntax

__builtin_lsr_zri(zero, ra, shift) ;

lsr:zric

mnemonic

lsr zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra >> shift[0:4]

built-in syntax

__builtin_lsr_zric(zero, ra, shift, log_set_cc) ;

lsr:zrici

mnemonic

lsr zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4]

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsr:zrr

mnemonic

lsr zero ra:r32 rb:wr32

behavior

- ZF <- ra >> rb[0:4]

built-in syntax

__builtin_lsr_zrr(zero, ra, rb) ;

lsr:zrrc

mnemonic

lsr zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra >> rb[0:4]

built-in syntax

__builtin_lsr_zrrc(zero, ra, rb, log_set_cc) ;

lsr:zrrci

mnemonic

lsr zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4]

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsr.s

lsr.s:rri

mnemonic

lsr.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr_s_rri(dc, ra, shift) ;

lsr.s:rric

mnemonic

lsr.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr_s_rric(dc, ra, shift, log_set_cc) ;

lsr.s:rrici

mnemonic

lsr.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4]

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr.s:rrr

mnemonic

lsr.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr_s_rrr(dc, ra, rb) ;

lsr.s:rrrc

mnemonic

lsr.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr_s_rrrc(dc, ra, rb, log_set_cc) ;

lsr.s:rrrci

mnemonic

lsr.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4]

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsr.u

lsr.u:rri

mnemonic

lsr.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr_u_rri(dc, ra, shift) ;

lsr.u:rric

mnemonic

lsr.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr_u_rric(dc, ra, shift, log_set_cc) ;

lsr.u:rrici

mnemonic

lsr.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4]

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr.u:rrr

mnemonic

lsr.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr_u_rrr(dc, ra, rb) ;

lsr.u:rrrc

mnemonic

lsr.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr_u_rrrc(dc, ra, rb, log_set_cc) ;

lsr.u:rrrci

mnemonic

lsr.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4]

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsr_add

lsr_add:rrri

mnemonic

lsr_add rc:wr32 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- rc = x

built-in syntax

__builtin_lsr_add_rrri(rc, rb, ra, shift) ;

lsr_add:rrrici

mnemonic

lsr_add rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- rc = x

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsr_add_rrrici(rc, rb, ra, shift, div_nz_cc, pc) ;

lsr_add:zrri

mnemonic

lsr_add zero rb:wr32 ra:r32 shift:u5

behavior

- instruction with no effect

built-in syntax

__builtin_lsr_add_zrri(zero, rb, ra, shift) ;

lsr_add:zrrici

mnemonic

lsr_add zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsr_add_zrrici(zero, rb, ra, shift, div_nz_cc, pc) ;

lsr_add.s

lsr_add.s:rrri

mnemonic

lsr_add.s dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- dc = x:S64

built-in syntax

__builtin_lsr_add_s_rrri(dc, rb, ra, shift) ;

lsr_add.s:rrrici

mnemonic

lsr_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- dc = x:S64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsr_add_s_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

lsr_add.u

lsr_add.u:rrri

mnemonic

lsr_add.u dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- dc = x:U64

built-in syntax

__builtin_lsr_add_u_rrri(dc, rb, ra, shift) ;

lsr_add.u:rrrici

mnemonic

lsr_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra >> shift

- x = rb + (ra >> shift[0:4])

- dc = x:U64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_lsr_add_u_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

LSR1

lsr1

lsr1:rri

mnemonic

lsr1 rc:wr32 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4] padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr1_rri(rc, ra, shift) ;

lsr1:rric

mnemonic

lsr1 rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4] padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_rric(rc, ra, shift, log_set_cc) ;

lsr1:rrici

mnemonic

lsr1 rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4] padded with ones

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1:rrr

mnemonic

lsr1 rc:wr32 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4] padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr1_rrr(rc, ra, rb) ;

lsr1:rrrc

mnemonic

lsr1 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4] padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_rrrc(rc, ra, rb, log_set_cc) ;

lsr1:rrrci

mnemonic

lsr1 rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4] padded with ones

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsr1:zri

mnemonic

lsr1 zero ra:r32 shift:u5

behavior

- ZF <- ra >> shift[0:4] padded with ones

built-in syntax

__builtin_lsr1_zri(zero, ra, shift) ;

lsr1:zric

mnemonic

lsr1 zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra >> shift[0:4] padded with ones

built-in syntax

__builtin_lsr1_zric(zero, ra, shift, log_set_cc) ;

lsr1:zrici

mnemonic

lsr1 zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4] padded with ones

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsr1:zrr

mnemonic

lsr1 zero ra:r32 rb:wr32

behavior

- ZF <- ra >> rb[0:4] padded with ones

built-in syntax

__builtin_lsr1_zrr(zero, ra, rb) ;

lsr1:zrrc

mnemonic

lsr1 zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra >> rb[0:4] padded with ones

built-in syntax

__builtin_lsr1_zrrc(zero, ra, rb, log_set_cc) ;

lsr1:zrrci

mnemonic

lsr1 zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4] padded with ones

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsr1.s

lsr1.s:rri

mnemonic

lsr1.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4] padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr1_s_rri(dc, ra, shift) ;

lsr1.s:rric

mnemonic

lsr1.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_s_rric(dc, ra, shift, log_set_cc) ;

lsr1.s:rrici

mnemonic

lsr1.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4] padded with ones

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1.s:rrr

mnemonic

lsr1.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4] padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr1_s_rrr(dc, ra, rb) ;

lsr1.s:rrrc

mnemonic

lsr1.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_s_rrrc(dc, ra, rb, log_set_cc) ;

lsr1.s:rrrci

mnemonic

lsr1.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4] padded with ones

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsr1.u

lsr1.u:rri

mnemonic

lsr1.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra >> shift[0:4] padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr1_u_rri(dc, ra, shift) ;

lsr1.u:rric

mnemonic

lsr1.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >> shift[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_u_rric(dc, ra, shift, log_set_cc) ;

lsr1.u:rrici

mnemonic

lsr1.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >> shift[0:4] padded with ones

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1.u:rrr

mnemonic

lsr1.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >> rb[0:4] padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr1_u_rrr(dc, ra, rb) ;

lsr1.u:rrrc

mnemonic

lsr1.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >> rb[0:4] padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1_u_rrrc(dc, ra, rb, log_set_cc) ;

lsr1.u:rrrci

mnemonic

lsr1.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >> rb[0:4] padded with ones

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

LSR1X

lsr1x

lsr1x:rri

mnemonic

lsr1x rc:wr32 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr1x_rri(rc, ra, shift) ;

lsr1x:rric

mnemonic

lsr1x rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_rric(rc, ra, shift, log_set_cc) ;

lsr1x:rrici

mnemonic

lsr1x rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1x:rrr

mnemonic

lsr1x rc:wr32 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- rc = x

- ZF <- x

built-in syntax

__builtin_lsr1x_rrr(rc, ra, rb) ;

lsr1x:rrrc

mnemonic

lsr1x rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_rrrc(rc, ra, rb, log_set_cc) ;

lsr1x:rrrci

mnemonic

lsr1x rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsr1x:zri

mnemonic

lsr1x zero ra:r32 shift:u5

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra << (32 - shift[0:4]) padded with ones)

built-in syntax

__builtin_lsr1x_zri(zero, ra, shift) ;

lsr1x:zric

mnemonic

lsr1x zero ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra << (32 - shift[0:4]) padded with ones)

built-in syntax

__builtin_lsr1x_zric(zero, ra, shift, log_set_cc) ;

lsr1x:zrici

mnemonic

lsr1x zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsr1x:zrr

mnemonic

lsr1x zero ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra << (32 - rb[0:4]) padded with ones)

built-in syntax

__builtin_lsr1x_zrr(zero, ra, rb) ;

lsr1x:zrrc

mnemonic

lsr1x zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     -1

- else

- ZF <-       (ra << (32 - rb[0:4]) padded with ones)

built-in syntax

__builtin_lsr1x_zrrc(zero, ra, rb, log_set_cc) ;

lsr1x:zrrci

mnemonic

lsr1x zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsr1x.s

lsr1x.s:rri

mnemonic

lsr1x.s dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rri(dc, ra, shift) ;

lsr1x.s:rric

mnemonic

lsr1x.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rric(dc, ra, shift, log_set_cc) ;

lsr1x.s:rrici

mnemonic

lsr1x.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1x.s:rrr

mnemonic

lsr1x.s dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rrr(dc, ra, rb) ;

lsr1x.s:rrrc

mnemonic

lsr1x.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rrrc(dc, ra, rb, log_set_cc) ;

lsr1x.s:rrrci

mnemonic

lsr1x.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsr1x.u

lsr1x.u:rri

mnemonic

lsr1x.u dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rri(dc, ra, shift) ;

lsr1x.u:rric

mnemonic

lsr1x.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rric(dc, ra, shift, log_set_cc) ;

lsr1x.u:rrici

mnemonic

lsr1x.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - shift[0:4]) padded with ones

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsr1x.u:rrr

mnemonic

lsr1x.u dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rrr(dc, ra, rb) ;

lsr1x.u:rrrc

mnemonic

lsr1x.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rrrc(dc, ra, rb, log_set_cc) ;

lsr1x.u:rrrci

mnemonic

lsr1x.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     -1

- else

-     ra << (32 - rb[0:4]) padded with ones

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsr1x_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

LSRX

lsrx

lsrx:rri

mnemonic

lsrx rc:wr32 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- rc = x

- ZF <- x

built-in syntax

__builtin_lsrx_rri(rc, ra, shift) ;

lsrx:rric

mnemonic

lsrx rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_rric(rc, ra, shift, log_set_cc) ;

lsrx:rrici

mnemonic

lsrx rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

lsrx:rrr

mnemonic

lsrx rc:wr32 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- rc = x

- ZF <- x

built-in syntax

__builtin_lsrx_rrr(rc, ra, rb) ;

lsrx:rrrc

mnemonic

lsrx rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_rrrc(rc, ra, rb, log_set_cc) ;

lsrx:rrrci

mnemonic

lsrx rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

lsrx:zri

mnemonic

lsrx zero ra:r32 shift:u5

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra << (32 - shift[0:4]))

built-in syntax

__builtin_lsrx_zri(zero, ra, shift) ;

lsrx:zric

mnemonic

lsrx zero ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra << (32 - shift[0:4]))

built-in syntax

__builtin_lsrx_zric(zero, ra, shift, log_set_cc) ;

lsrx:zrici

mnemonic

lsrx zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

lsrx:zrr

mnemonic

lsrx zero ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra << (32 - rb[0:4]))

built-in syntax

__builtin_lsrx_zrr(zero, ra, rb) ;

lsrx:zrrc

mnemonic

lsrx zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- if (const_cc_zero cc) then

-     0

- else

- ZF <-       (ra << (32 - rb[0:4]))

built-in syntax

__builtin_lsrx_zrrc(zero, ra, rb, log_set_cc) ;

lsrx:zrrci

mnemonic

lsrx zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

lsrx.s

lsrx.s:rri

mnemonic

lsrx.s dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsrx_s_rri(dc, ra, shift) ;

lsrx.s:rric

mnemonic

lsrx.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_s_rric(dc, ra, shift, log_set_cc) ;

lsrx.s:rrici

mnemonic

lsrx.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsrx.s:rrr

mnemonic

lsrx.s dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_lsrx_s_rrr(dc, ra, rb) ;

lsrx.s:rrrc

mnemonic

lsrx.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_s_rrrc(dc, ra, rb, log_set_cc) ;

lsrx.s:rrrci

mnemonic

lsrx.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

lsrx.u

lsrx.u:rri

mnemonic

lsrx.u dc:wr64 ra:r32 shift:u5

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsrx_u_rri(dc, ra, shift) ;

lsrx.u:rric

mnemonic

lsrx.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_u_rric(dc, ra, shift, log_set_cc) ;

lsrx.u:rrici

mnemonic

lsrx.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- cc = shift[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - shift[0:4])

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

lsrx.u:rrr

mnemonic

lsrx.u dc:wr64 ra:r32 rb:wr32

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_lsrx_u_rrr(dc, ra, rb) ;

lsrx.u:rrrc

mnemonic

lsrx.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_lsrx_u_rrrc(dc, ra, rb, log_set_cc) ;

lsrx.u:rrrci

mnemonic

lsrx.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- cc = rb[0:4]

- x = if (const_cc_zero cc) then

-     0

- else

-     ra << (32 - rb[0:4])

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_lsrx_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

MUL

mul_sh_sh

mul_sh_sh:rrr

mnemonic

mul_sh_sh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_rrr(rc, ra, rb) ;

mul_sh_sh:rrrc

mnemonic

mul_sh_sh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_rrrc(rc, ra, rb, log_set_cc) ;

mul_sh_sh:rrrci

mnemonic

mul_sh_sh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sh_sh:zrr

mnemonic

mul_sh_sh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[8:15]):S32

built-in syntax

__builtin_mul_sh_sh_zrr(zero, ra, rb) ;

mul_sh_sh:zrrc

mnemonic

mul_sh_sh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[8:15]):S32

built-in syntax

__builtin_mul_sh_sh_zrrc(zero, ra, rb, log_set_cc) ;

mul_sh_sh:zrrci

mnemonic

mul_sh_sh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sh_sh.s

mul_sh_sh.s:rrr

mnemonic

mul_sh_sh.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_s_rrr(dc, ra, rb) ;

mul_sh_sh.s:rrrc

mnemonic

mul_sh_sh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sh_sh.s:rrrci

mnemonic

mul_sh_sh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sh_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sh_sl

mul_sh_sl:rrr

mnemonic

mul_sh_sl rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_rrr(rc, ra, rb) ;

mul_sh_sl:rrrc

mnemonic

mul_sh_sl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_rrrc(rc, ra, rb, log_set_cc) ;

mul_sh_sl:rrrci

mnemonic

mul_sh_sl rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sh_sl:zrr

mnemonic

mul_sh_sl zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[0:7]):S32

built-in syntax

__builtin_mul_sh_sl_zrr(zero, ra, rb) ;

mul_sh_sl:zrrc

mnemonic

mul_sh_sl zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[0:7]):S32

built-in syntax

__builtin_mul_sh_sl_zrrc(zero, ra, rb, log_set_cc) ;

mul_sh_sl:zrrci

mnemonic

mul_sh_sl zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sh_sl.s

mul_sh_sl.s:rrr

mnemonic

mul_sh_sl.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_s_rrr(dc, ra, rb) ;

mul_sh_sl.s:rrrc

mnemonic

mul_sh_sl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sh_sl.s:rrrci

mnemonic

mul_sh_sl.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_sl_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sh_uh

mul_sh_uh:rrr

mnemonic

mul_sh_uh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_rrr(rc, ra, rb) ;

mul_sh_uh:rrrc

mnemonic

mul_sh_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_rrrc(rc, ra, rb, log_set_cc) ;

mul_sh_uh:rrrci

mnemonic

mul_sh_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sh_uh:zrr

mnemonic

mul_sh_uh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[8:15]):S32

built-in syntax

__builtin_mul_sh_uh_zrr(zero, ra, rb) ;

mul_sh_uh:zrrc

mnemonic

mul_sh_uh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[8:15]):S32

built-in syntax

__builtin_mul_sh_uh_zrrc(zero, ra, rb, log_set_cc) ;

mul_sh_uh:zrrci

mnemonic

mul_sh_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sh_uh.s

mul_sh_uh.s:rrr

mnemonic

mul_sh_uh.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_s_rrr(dc, ra, rb) ;

mul_sh_uh.s:rrrc

mnemonic

mul_sh_uh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sh_uh.s:rrrci

mnemonic

mul_sh_uh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_uh_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sh_ul

mul_sh_ul:rrr

mnemonic

mul_sh_ul rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_rrr(rc, ra, rb) ;

mul_sh_ul:rrrc

mnemonic

mul_sh_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_rrrc(rc, ra, rb, log_set_cc) ;

mul_sh_ul:rrrci

mnemonic

mul_sh_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sh_ul:zrr

mnemonic

mul_sh_ul zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[0:7]):S32

built-in syntax

__builtin_mul_sh_ul_zrr(zero, ra, rb) ;

mul_sh_ul:zrrc

mnemonic

mul_sh_ul zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[0:7]):S32

built-in syntax

__builtin_mul_sh_ul_zrrc(zero, ra, rb, log_set_cc) ;

mul_sh_ul:zrrci

mnemonic

mul_sh_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sh_ul.s

mul_sh_ul.s:rrr

mnemonic

mul_sh_ul.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_s_rrr(dc, ra, rb) ;

mul_sh_ul.s:rrrc

mnemonic

mul_sh_ul.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sh_ul.s:rrrci

mnemonic

mul_sh_ul.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sh_ul_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sl_sh

mul_sl_sh:rrr

mnemonic

mul_sl_sh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_rrr(rc, ra, rb) ;

mul_sl_sh:rrrc

mnemonic

mul_sl_sh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_rrrc(rc, ra, rb, log_set_cc) ;

mul_sl_sh:rrrci

mnemonic

mul_sl_sh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sl_sh:zrr

mnemonic

mul_sl_sh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[8:15]):S32

built-in syntax

__builtin_mul_sl_sh_zrr(zero, ra, rb) ;

mul_sl_sh:zrrc

mnemonic

mul_sl_sh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[8:15]):S32

built-in syntax

__builtin_mul_sl_sh_zrrc(zero, ra, rb, log_set_cc) ;

mul_sl_sh:zrrci

mnemonic

mul_sl_sh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sl_sh.s

mul_sl_sh.s:rrr

mnemonic

mul_sl_sh.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_s_rrr(dc, ra, rb) ;

mul_sl_sh.s:rrrc

mnemonic

mul_sl_sh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sl_sh.s:rrrci

mnemonic

mul_sl_sh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sh_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sl_sl

mul_sl_sl:rrr

mnemonic

mul_sl_sl rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_rrr(rc, ra, rb) ;

mul_sl_sl:rrrc

mnemonic

mul_sl_sl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_rrrc(rc, ra, rb, log_set_cc) ;

mul_sl_sl:rrrci

mnemonic

mul_sl_sl rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sl_sl:zrr

mnemonic

mul_sl_sl zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[0:7]):S32

built-in syntax

__builtin_mul_sl_sl_zrr(zero, ra, rb) ;

mul_sl_sl:zrrc

mnemonic

mul_sl_sl zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[0:7]):S32

built-in syntax

__builtin_mul_sl_sl_zrrc(zero, ra, rb, log_set_cc) ;

mul_sl_sl:zrrci

mnemonic

mul_sl_sl zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sl_sl.s

mul_sl_sl.s:rrr

mnemonic

mul_sl_sl.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_s_rrr(dc, ra, rb) ;

mul_sl_sl.s:rrrc

mnemonic

mul_sl_sl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sl_sl.s:rrrci

mnemonic

mul_sl_sl.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_sl_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sl_uh

mul_sl_uh:rrr

mnemonic

mul_sl_uh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_rrr(rc, ra, rb) ;

mul_sl_uh:rrrc

mnemonic

mul_sl_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_rrrc(rc, ra, rb, log_set_cc) ;

mul_sl_uh:rrrci

mnemonic

mul_sl_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sl_uh:zrr

mnemonic

mul_sl_uh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[8:15]):S32

built-in syntax

__builtin_mul_sl_uh_zrr(zero, ra, rb) ;

mul_sl_uh:zrrc

mnemonic

mul_sl_uh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[8:15]):S32

built-in syntax

__builtin_mul_sl_uh_zrrc(zero, ra, rb, log_set_cc) ;

mul_sl_uh:zrrci

mnemonic

mul_sl_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sl_uh.s

mul_sl_uh.s:rrr

mnemonic

mul_sl_uh.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_s_rrr(dc, ra, rb) ;

mul_sl_uh.s:rrrc

mnemonic

mul_sl_uh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sl_uh.s:rrrci

mnemonic

mul_sl_uh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_uh_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_sl_ul

mul_sl_ul:rrr

mnemonic

mul_sl_ul rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):S32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_rrr(rc, ra, rb) ;

mul_sl_ul:rrrc

mnemonic

mul_sl_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_rrrc(rc, ra, rb, log_set_cc) ;

mul_sl_ul:rrrci

mnemonic

mul_sl_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_sl_ul:zrr

mnemonic

mul_sl_ul zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[0:7]):S32

built-in syntax

__builtin_mul_sl_ul_zrr(zero, ra, rb) ;

mul_sl_ul:zrrc

mnemonic

mul_sl_ul zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[0:7]):S32

built-in syntax

__builtin_mul_sl_ul_zrrc(zero, ra, rb, log_set_cc) ;

mul_sl_ul:zrrci

mnemonic

mul_sl_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_sl_ul.s

mul_sl_ul.s:rrr

mnemonic

mul_sl_ul.s dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):S32

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_s_rrr(dc, ra, rb) ;

mul_sl_ul.s:rrrc

mnemonic

mul_sl_ul.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):S32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_s_rrrc(dc, ra, rb, log_set_cc) ;

mul_sl_ul.s:rrrci

mnemonic

mul_sl_ul.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):S32

- dc = x:S64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_sl_ul_s_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_step

mul_step:rrrici

mnemonic

mul_step dc:wr64 ra:r32 db:wr64 shift:u5 boot_cc:cc pc:pc16

behavior

- cc = x = dbe >> 1

- cc = (dbe & 0x1) - 1

- if (const_cc_zero cc) then

-     dco = (dbo + (ra << shift))

- dce = x

- if (boot_cc cc) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_step_rrrici(dc, ra, db, shift, boot_cc, pc) ;

syntactic sugars

mul_step dc:wr64 ra:r32 db:wr64 shift:u5

- boot_cc = false

- pc = 0

mul_uh_uh

mul_uh_uh:rrr

mnemonic

mul_uh_uh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):U32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_rrr(rc, ra, rb) ;

mul_uh_uh:rrrc

mnemonic

mul_uh_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_rrrc(rc, ra, rb, log_set_cc) ;

mul_uh_uh:rrrci

mnemonic

mul_uh_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):U32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_uh_uh:zrr

mnemonic

mul_uh_uh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[8:15]):U32

built-in syntax

__builtin_mul_uh_uh_zrr(zero, ra, rb) ;

mul_uh_uh:zrrc

mnemonic

mul_uh_uh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[8:15]):U32

built-in syntax

__builtin_mul_uh_uh_zrrc(zero, ra, rb, log_set_cc) ;

mul_uh_uh:zrrci

mnemonic

mul_uh_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):U32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_uh_uh.u

mul_uh_uh.u:rrr

mnemonic

mul_uh_uh.u dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[8:15]):U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_u_rrr(dc, ra, rb) ;

mul_uh_uh.u:rrrc

mnemonic

mul_uh_uh.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[8:15]):U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_u_rrrc(dc, ra, rb, log_set_cc) ;

mul_uh_uh.u:rrrci

mnemonic

mul_uh_uh.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[8:15]):U32

- dc = x:U64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_uh_u_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_uh_ul

mul_uh_ul:rrr

mnemonic

mul_uh_ul rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):U32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_rrr(rc, ra, rb) ;

mul_uh_ul:rrrc

mnemonic

mul_uh_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_rrrc(rc, ra, rb, log_set_cc) ;

mul_uh_ul:rrrci

mnemonic

mul_uh_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):U32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_uh_ul:zrr

mnemonic

mul_uh_ul zero ra:r32 rb:wr32

behavior

- ZF <- (ra[8:15] * rb[0:7]):U32

built-in syntax

__builtin_mul_uh_ul_zrr(zero, ra, rb) ;

mul_uh_ul:zrrc

mnemonic

mul_uh_ul zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[8:15] * rb[0:7]):U32

built-in syntax

__builtin_mul_uh_ul_zrrc(zero, ra, rb, log_set_cc) ;

mul_uh_ul:zrrci

mnemonic

mul_uh_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):U32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_uh_ul.u

mul_uh_ul.u:rrr

mnemonic

mul_uh_ul.u dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[8:15] * rb[0:7]):U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_u_rrr(dc, ra, rb) ;

mul_uh_ul.u:rrrc

mnemonic

mul_uh_ul.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[8:15] * rb[0:7]):U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_u_rrrc(dc, ra, rb, log_set_cc) ;

mul_uh_ul.u:rrrci

mnemonic

mul_uh_ul.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[8:15] * rb[0:7]):U32

- dc = x:U64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_uh_ul_u_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_ul_uh

mul_ul_uh:rrr

mnemonic

mul_ul_uh rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):U32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_rrr(rc, ra, rb) ;

mul_ul_uh:rrrc

mnemonic

mul_ul_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_rrrc(rc, ra, rb, log_set_cc) ;

mul_ul_uh:rrrci

mnemonic

mul_ul_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):U32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_ul_uh:zrr

mnemonic

mul_ul_uh zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[8:15]):U32

built-in syntax

__builtin_mul_ul_uh_zrr(zero, ra, rb) ;

mul_ul_uh:zrrc

mnemonic

mul_ul_uh zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[8:15]):U32

built-in syntax

__builtin_mul_ul_uh_zrrc(zero, ra, rb, log_set_cc) ;

mul_ul_uh:zrrci

mnemonic

mul_ul_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):U32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_ul_uh.u

mul_ul_uh.u:rrr

mnemonic

mul_ul_uh.u dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[8:15]):U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_u_rrr(dc, ra, rb) ;

mul_ul_uh.u:rrrc

mnemonic

mul_ul_uh.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[8:15]):U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_u_rrrc(dc, ra, rb, log_set_cc) ;

mul_ul_uh.u:rrrci

mnemonic

mul_ul_uh.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[8:15]):U32

- dc = x:U64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_uh_u_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

mul_ul_ul

mul_ul_ul:rrr

mnemonic

mul_ul_ul rc:wr32 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):U32

- rc = x

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_rrr(rc, ra, rb) ;

mul_ul_ul:rrrc

mnemonic

mul_ul_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):U32

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_rrrc(rc, ra, rb, log_set_cc) ;

mul_ul_ul:rrrci

mnemonic

mul_ul_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):U32

- rc = x

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_rrrci(rc, ra, rb, mul_nz_cc, pc) ;

mul_ul_ul:zrr

mnemonic

mul_ul_ul zero ra:r32 rb:wr32

behavior

- ZF <- (ra[0:7] * rb[0:7]):U32

built-in syntax

__builtin_mul_ul_ul_zrr(zero, ra, rb) ;

mul_ul_ul:zrrc

mnemonic

mul_ul_ul zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- (ra[0:7] * rb[0:7]):U32

built-in syntax

__builtin_mul_ul_ul_zrrc(zero, ra, rb, log_set_cc) ;

mul_ul_ul:zrrci

mnemonic

mul_ul_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):U32

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_zrrci(zero, ra, rb, mul_nz_cc, pc) ;

mul_ul_ul.u

mul_ul_ul.u:rrr

mnemonic

mul_ul_ul.u dc:wr64 ra:r32 rb:wr32

behavior

- x = (ra[0:7] * rb[0:7]):U32

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_u_rrr(dc, ra, rb) ;

mul_ul_ul.u:rrrc

mnemonic

mul_ul_ul.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = (ra[0:7] * rb[0:7]):U32

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_u_rrrc(dc, ra, rb, log_set_cc) ;

mul_ul_ul.u:rrrci

mnemonic

mul_ul_ul.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16

behavior

- x = (ra[0:7] * rb[0:7]):U32

- dc = x:U64

- if (mul_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_mul_ul_ul_u_rrrci(dc, ra, rb, mul_nz_cc, pc) ;

NAND

nand

nand:rric

mnemonic

nand rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra & imm)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nand_rric(rc, ra, imm, log_set_cc) ;

nand:rrici

mnemonic

nand rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & imm)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_rrici(rc, ra, imm, log_nz_cc, pc) ;

nand:rrif

mnemonic

nand rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra & imm)

- rc = x

- ZF <- x

built-in syntax

__builtin_nand_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

nand rc:wr32 ra:r32 imm:s24

- false_cc = false

nand:rrr

mnemonic

nand rc:wr32 ra:r32 rb:wr32

behavior

- x = ~(ra & rb)

- rc = x

- ZF <- x

built-in syntax

__builtin_nand_rrr(rc, ra, rb) ;

nand:rrrc

mnemonic

nand rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra & rb)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nand_rrrc(rc, ra, rb, log_set_cc) ;

nand:rrrci

mnemonic

nand rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & rb)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_rrrci(rc, ra, rb, log_nz_cc, pc) ;

nand:zric

mnemonic

nand zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ~(ra & imm)

built-in syntax

__builtin_nand_zric(zero, ra, imm, log_set_cc) ;

nand:zrici

mnemonic

nand zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & imm)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_zrici(zero, ra, imm, log_nz_cc, pc) ;

nand:zrif

mnemonic

nand zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ~(ra & imm)

built-in syntax

__builtin_nand_zrif(zero, ra, imm, false_cc) ;

nand:zrr

mnemonic

nand zero ra:r32 rb:wr32

behavior

- ZF <- ~(ra & rb)

built-in syntax

__builtin_nand_zrr(zero, ra, rb) ;

nand:zrrc

mnemonic

nand zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ~(ra & rb)

built-in syntax

__builtin_nand_zrrc(zero, ra, rb, log_set_cc) ;

nand:zrrci

mnemonic

nand zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & rb)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_zrrci(zero, ra, rb, log_nz_cc, pc) ;

nand.s

nand.s:rric

mnemonic

nand.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra & imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nand_s_rric(dc, ra, imm, log_set_cc) ;

nand.s:rrici

mnemonic

nand.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & imm)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

nand.s:rrif

mnemonic

nand.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra & imm)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nand_s_rrif(dc, ra, imm, false_cc) ;

nand.s:rrr

mnemonic

nand.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra & rb)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nand_s_rrr(dc, ra, rb) ;

nand.s:rrrc

mnemonic

nand.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra & rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nand_s_rrrc(dc, ra, rb, log_set_cc) ;

nand.s:rrrci

mnemonic

nand.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & rb)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

nand.u

nand.u:rric

mnemonic

nand.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra & imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nand_u_rric(dc, ra, imm, log_set_cc) ;

nand.u:rrici

mnemonic

nand.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & imm)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

nand.u:rrif

mnemonic

nand.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra & imm)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nand_u_rrif(dc, ra, imm, false_cc) ;

nand.u:rrr

mnemonic

nand.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra & rb)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nand_u_rrr(dc, ra, rb) ;

nand.u:rrrc

mnemonic

nand.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra & rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nand_u_rrrc(dc, ra, rb, log_set_cc) ;

nand.u:rrrci

mnemonic

nand.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra & rb)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nand_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

NOR

nor

nor:rric

mnemonic

nor rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra | imm)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nor_rric(rc, ra, imm, log_set_cc) ;

nor:rrici

mnemonic

nor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | imm)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_rrici(rc, ra, imm, log_nz_cc, pc) ;

nor:rrif

mnemonic

nor rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra | imm)

- rc = x

- ZF <- x

built-in syntax

__builtin_nor_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

nor rc:wr32 ra:r32 imm:s24

- false_cc = false

nor:rrr

mnemonic

nor rc:wr32 ra:r32 rb:wr32

behavior

- x = ~(ra | rb)

- rc = x

- ZF <- x

built-in syntax

__builtin_nor_rrr(rc, ra, rb) ;

nor:rrrc

mnemonic

nor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra | rb)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nor_rrrc(rc, ra, rb, log_set_cc) ;

nor:rrrci

mnemonic

nor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | rb)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_rrrci(rc, ra, rb, log_nz_cc, pc) ;

nor:zric

mnemonic

nor zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ~(ra | imm)

built-in syntax

__builtin_nor_zric(zero, ra, imm, log_set_cc) ;

nor:zrici

mnemonic

nor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | imm)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_zrici(zero, ra, imm, log_nz_cc, pc) ;

nor:zrif

mnemonic

nor zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ~(ra | imm)

built-in syntax

__builtin_nor_zrif(zero, ra, imm, false_cc) ;

nor:zrr

mnemonic

nor zero ra:r32 rb:wr32

behavior

- ZF <- ~(ra | rb)

built-in syntax

__builtin_nor_zrr(zero, ra, rb) ;

nor:zrrc

mnemonic

nor zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ~(ra | rb)

built-in syntax

__builtin_nor_zrrc(zero, ra, rb, log_set_cc) ;

nor:zrrci

mnemonic

nor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | rb)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_zrrci(zero, ra, rb, log_nz_cc, pc) ;

nor.s

nor.s:rric

mnemonic

nor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra | imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nor_s_rric(dc, ra, imm, log_set_cc) ;

nor.s:rrici

mnemonic

nor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | imm)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

nor.s:rrif

mnemonic

nor.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra | imm)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nor_s_rrif(dc, ra, imm, false_cc) ;

nor.s:rrr

mnemonic

nor.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra | rb)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nor_s_rrr(dc, ra, rb) ;

nor.s:rrrc

mnemonic

nor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra | rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nor_s_rrrc(dc, ra, rb, log_set_cc) ;

nor.s:rrrci

mnemonic

nor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | rb)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

nor.u

nor.u:rric

mnemonic

nor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra | imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nor_u_rric(dc, ra, imm, log_set_cc) ;

nor.u:rrici

mnemonic

nor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | imm)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

nor.u:rrif

mnemonic

nor.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra | imm)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nor_u_rrif(dc, ra, imm, false_cc) ;

nor.u:rrr

mnemonic

nor.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra | rb)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nor_u_rrr(dc, ra, rb) ;

nor.u:rrrc

mnemonic

nor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra | rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nor_u_rrrc(dc, ra, rb, log_set_cc) ;

nor.u:rrrci

mnemonic

nor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra | rb)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nor_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

NXOR

nxor

nxor:rric

mnemonic

nxor rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra ^ imm)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nxor_rric(rc, ra, imm, log_set_cc) ;

nxor:rrici

mnemonic

nxor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ imm)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_rrici(rc, ra, imm, log_nz_cc, pc) ;

nxor:rrif

mnemonic

nxor rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra ^ imm)

- rc = x

- ZF <- x

built-in syntax

__builtin_nxor_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

nxor rc:wr32 ra:r32 imm:s24

- false_cc = false

nxor:rrr

mnemonic

nxor rc:wr32 ra:r32 rb:wr32

behavior

- x = ~(ra ^ rb)

- rc = x

- ZF <- x

built-in syntax

__builtin_nxor_rrr(rc, ra, rb) ;

nxor:rrrc

mnemonic

nxor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra ^ rb)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_nxor_rrrc(rc, ra, rb, log_set_cc) ;

nxor:rrrci

mnemonic

nxor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ rb)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_rrrci(rc, ra, rb, log_nz_cc, pc) ;

nxor:zric

mnemonic

nxor zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ~(ra ^ imm)

built-in syntax

__builtin_nxor_zric(zero, ra, imm, log_set_cc) ;

nxor:zrici

mnemonic

nxor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ imm)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_zrici(zero, ra, imm, log_nz_cc, pc) ;

nxor:zrif

mnemonic

nxor zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ~(ra ^ imm)

built-in syntax

__builtin_nxor_zrif(zero, ra, imm, false_cc) ;

nxor:zrr

mnemonic

nxor zero ra:r32 rb:wr32

behavior

- ZF <- ~(ra ^ rb)

built-in syntax

__builtin_nxor_zrr(zero, ra, rb) ;

nxor:zrrc

mnemonic

nxor zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ~(ra ^ rb)

built-in syntax

__builtin_nxor_zrrc(zero, ra, rb, log_set_cc) ;

nxor:zrrci

mnemonic

nxor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ rb)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_zrrci(zero, ra, rb, log_nz_cc, pc) ;

nxor.s

nxor.s:rric

mnemonic

nxor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra ^ imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nxor_s_rric(dc, ra, imm, log_set_cc) ;

nxor.s:rrici

mnemonic

nxor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ imm)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

nxor.s:rrif

mnemonic

nxor.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra ^ imm)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nxor_s_rrif(dc, ra, imm, false_cc) ;

nxor.s:rrr

mnemonic

nxor.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra ^ rb)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_nxor_s_rrr(dc, ra, rb) ;

nxor.s:rrrc

mnemonic

nxor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra ^ rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nxor_s_rrrc(dc, ra, rb, log_set_cc) ;

nxor.s:rrrci

mnemonic

nxor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ rb)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

nxor.u

nxor.u:rric

mnemonic

nxor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~(ra ^ imm)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nxor_u_rric(dc, ra, imm, log_set_cc) ;

nxor.u:rrici

mnemonic

nxor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ imm)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

nxor.u:rrif

mnemonic

nxor.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~(ra ^ imm)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nxor_u_rrif(dc, ra, imm, false_cc) ;

nxor.u:rrr

mnemonic

nxor.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ~(ra ^ rb)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_nxor_u_rrr(dc, ra, rb) ;

nxor.u:rrrc

mnemonic

nxor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~(ra ^ rb)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_nxor_u_rrrc(dc, ra, rb, log_set_cc) ;

nxor.u:rrrci

mnemonic

nxor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~(ra ^ rb)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_nxor_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

OR

or

or:rri

mnemonic

or rc:wr32 ra:r32 imm:u32

behavior

- rc = (ra | imm)

- ZF <- rc

built-in syntax

__builtin_or_rri(rc, ra, imm) ;

syntactic sugars

move rc:wr32 imm:u32

- ra = zero

or:rric

mnemonic

or rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra | imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_or_rric(rc, ra, imm, log_set_cc) ;

or:rrici

mnemonic

or rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra | imm

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_rrici(rc, ra, imm, log_nz_cc, pc) ;

syntactic sugars

move rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

- imm = 0

move rc:wr32 imm:s8 log_nz_cc:cc pc:pc16

- ra = zero

or:rrif

mnemonic

or rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra | imm

- rc = x

- ZF <- x

built-in syntax

__builtin_or_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

move rc:wr32 ra:r32

- imm = 0

- false_cc = false

or:rrr

mnemonic

or rc:wr32 ra:r32 rb:wr32

behavior

- x = ra | rb

- rc = x

- ZF <- x

built-in syntax

__builtin_or_rrr(rc, ra, rb) ;

or:rrrc

mnemonic

or rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra | rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_or_rrrc(rc, ra, rb, log_set_cc) ;

or:rrrci

mnemonic

or rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra | rb

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_rrrci(rc, ra, rb, log_nz_cc, pc) ;

or:zri

mnemonic

or zero rb:wr32 imm:u32

behavior

- ZF <- rb | imm

built-in syntax

__builtin_or_zri(zero, rb, imm) ;

or:zric

mnemonic

or zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ra | imm

built-in syntax

__builtin_or_zric(zero, ra, imm, log_set_cc) ;

or:zrici

mnemonic

or zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ra | imm

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_zrici(zero, ra, imm, log_nz_cc, pc) ;

or:zrif

mnemonic

or zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ra | imm

built-in syntax

__builtin_or_zrif(zero, ra, imm, false_cc) ;

or:zrr

mnemonic

or zero ra:r32 rb:wr32

behavior

- ZF <- ra | rb

built-in syntax

__builtin_or_zrr(zero, ra, rb) ;

or:zrrc

mnemonic

or zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra | rb

built-in syntax

__builtin_or_zrrc(zero, ra, rb, log_set_cc) ;

or:zrrci

mnemonic

or zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra | rb

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_zrrci(zero, ra, rb, log_nz_cc, pc) ;

or.s

or.s:rri

mnemonic

or.s dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb | imm):S64

- ZF <- dc

built-in syntax

__builtin_or_s_rri(dc, rb, imm) ;

or.s:rric

mnemonic

or.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra | imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_or_s_rric(dc, ra, imm, log_set_cc) ;

or.s:rrici

mnemonic

or.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra | imm

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

syntactic sugars

move.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

- imm = 0

move.s dc:wr64 imm:s8 log_nz_cc:cc pc:pc16

- ra = zero

or.s:rrif

mnemonic

or.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra | imm

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_or_s_rrif(dc, ra, imm, false_cc) ;

syntactic sugars

move.s dc:wr64 ra:r32

- imm = 0

- false_cc = false

or.s:rrr

mnemonic

or.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra | rb

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_or_s_rrr(dc, ra, rb) ;

or.s:rrrc

mnemonic

or.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra | rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_or_s_rrrc(dc, ra, rb, log_set_cc) ;

or.s:rrrci

mnemonic

or.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra | rb

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

or.u

or.u:rri

mnemonic

or.u dc:wr64 rb:wr32 imm:u32

behavior

- dc = (rb | imm):U64

- ZF <- dc

built-in syntax

__builtin_or_u_rri(dc, rb, imm) ;

or.u:rric

mnemonic

or.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra | imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_or_u_rric(dc, ra, imm, log_set_cc) ;

or.u:rrici

mnemonic

or.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra | imm

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

syntactic sugars

move.u dc:wr64 imm:s8 log_nz_cc:cc pc:pc16

- ra = zero

move.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

- imm = 0

or.u:rrif

mnemonic

or.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra | imm

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_or_u_rrif(dc, ra, imm, false_cc) ;

syntactic sugars

move.u dc:wr64 ra:r32

- imm = 0

- false_cc = false

or.u:rrr

mnemonic

or.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra | rb

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_or_u_rrr(dc, ra, rb) ;

or.u:rrrc

mnemonic

or.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra | rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_or_u_rrrc(dc, ra, rb, log_set_cc) ;

or.u:rrrci

mnemonic

or.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra | rb

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_or_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

ORN

orn

orn:rric

mnemonic

orn rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra | imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_orn_rric(rc, ra, imm, log_set_cc) ;

orn:rrici

mnemonic

orn rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | imm

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_rrici(rc, ra, imm, log_nz_cc, pc) ;

orn:rrif

mnemonic

orn rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra | imm

- rc = x

- ZF <- x

built-in syntax

__builtin_orn_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

orn rc:wr32 ra:r32 imm:s24

- false_cc = false

orn:rrr

mnemonic

orn rc:wr32 ra:r32 rb:wr32

behavior

- x = ~ra | rb

- rc = x

- ZF <- x

built-in syntax

__builtin_orn_rrr(rc, ra, rb) ;

orn:rrrc

mnemonic

orn rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra | rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_orn_rrrc(rc, ra, rb, log_set_cc) ;

orn:rrrci

mnemonic

orn rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | rb

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_rrrci(rc, ra, rb, log_nz_cc, pc) ;

orn:zric

mnemonic

orn zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ~ra | imm

built-in syntax

__builtin_orn_zric(zero, ra, imm, log_set_cc) ;

orn:zrici

mnemonic

orn zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | imm

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_zrici(zero, ra, imm, log_nz_cc, pc) ;

orn:zrif

mnemonic

orn zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ~ra | imm

built-in syntax

__builtin_orn_zrif(zero, ra, imm, false_cc) ;

orn:zrr

mnemonic

orn zero ra:r32 rb:wr32

behavior

- ZF <- ~ra | rb

built-in syntax

__builtin_orn_zrr(zero, ra, rb) ;

orn:zrrc

mnemonic

orn zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ~ra | rb

built-in syntax

__builtin_orn_zrrc(zero, ra, rb, log_set_cc) ;

orn:zrrci

mnemonic

orn zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | rb

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_zrrci(zero, ra, rb, log_nz_cc, pc) ;

orn.s

orn.s:rric

mnemonic

orn.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra | imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_orn_s_rric(dc, ra, imm, log_set_cc) ;

orn.s:rrici

mnemonic

orn.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | imm

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

orn.s:rrif

mnemonic

orn.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra | imm

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_orn_s_rrif(dc, ra, imm, false_cc) ;

orn.s:rrr

mnemonic

orn.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ~ra | rb

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_orn_s_rrr(dc, ra, rb) ;

orn.s:rrrc

mnemonic

orn.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra | rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_orn_s_rrrc(dc, ra, rb, log_set_cc) ;

orn.s:rrrci

mnemonic

orn.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | rb

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

orn.u

orn.u:rric

mnemonic

orn.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ~ra | imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_orn_u_rric(dc, ra, imm, log_set_cc) ;

orn.u:rrici

mnemonic

orn.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | imm

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

orn.u:rrif

mnemonic

orn.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ~ra | imm

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_orn_u_rrif(dc, ra, imm, false_cc) ;

orn.u:rrr

mnemonic

orn.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ~ra | rb

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_orn_u_rrr(dc, ra, rb) ;

orn.u:rrrc

mnemonic

orn.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ~ra | rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_orn_u_rrrc(dc, ra, rb, log_set_cc) ;

orn.u:rrrci

mnemonic

orn.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ~ra | rb

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_orn_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

ROL

rol

rol:rri

mnemonic

rol rc:wr32 ra:r32 shift:u5

behavior

- x = ra <<r shift[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_rol_rri(rc, ra, shift) ;

rol:rric

mnemonic

rol rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra <<r shift[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_rol_rric(rc, ra, shift, log_set_cc) ;

rol:rrici

mnemonic

rol rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r shift[0:4]

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

rol:rrr

mnemonic

rol rc:wr32 ra:r32 rb:wr32

behavior

- x = ra <<r rb[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_rol_rrr(rc, ra, rb) ;

rol:rrrc

mnemonic

rol rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra <<r rb[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_rol_rrrc(rc, ra, rb, log_set_cc) ;

rol:rrrci

mnemonic

rol rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r rb[0:4]

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

rol:zri

mnemonic

rol zero ra:r32 shift:u5

behavior

- ZF <- ra <<r shift[0:4]

built-in syntax

__builtin_rol_zri(zero, ra, shift) ;

rol:zric

mnemonic

rol zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra <<r shift[0:4]

built-in syntax

__builtin_rol_zric(zero, ra, shift, log_set_cc) ;

rol:zrici

mnemonic

rol zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r shift[0:4]

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

rol:zrr

mnemonic

rol zero ra:r32 rb:wr32

behavior

- ZF <- ra <<r rb[0:4]

built-in syntax

__builtin_rol_zrr(zero, ra, rb) ;

rol:zrrc

mnemonic

rol zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra <<r rb[0:4]

built-in syntax

__builtin_rol_zrrc(zero, ra, rb, log_set_cc) ;

rol:zrrci

mnemonic

rol zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r rb[0:4]

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

rol.s

rol.s:rri

mnemonic

rol.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra <<r shift[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_rol_s_rri(dc, ra, shift) ;

rol.s:rric

mnemonic

rol.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra <<r shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_rol_s_rric(dc, ra, shift, log_set_cc) ;

rol.s:rrici

mnemonic

rol.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r shift[0:4]

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

rol.s:rrr

mnemonic

rol.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra <<r rb[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_rol_s_rrr(dc, ra, rb) ;

rol.s:rrrc

mnemonic

rol.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra <<r rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_rol_s_rrrc(dc, ra, rb, log_set_cc) ;

rol.s:rrrci

mnemonic

rol.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r rb[0:4]

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

rol.u

rol.u:rri

mnemonic

rol.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra <<r shift[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_rol_u_rri(dc, ra, shift) ;

rol.u:rric

mnemonic

rol.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra <<r shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_rol_u_rric(dc, ra, shift, log_set_cc) ;

rol.u:rrici

mnemonic

rol.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r shift[0:4]

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

rol.u:rrr

mnemonic

rol.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra <<r rb[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_rol_u_rrr(dc, ra, rb) ;

rol.u:rrrc

mnemonic

rol.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra <<r rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_rol_u_rrrc(dc, ra, rb, log_set_cc) ;

rol.u:rrrci

mnemonic

rol.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra <<r rb[0:4]

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_rol_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

rol_add

rol_add:rrri

mnemonic

rol_add rc:wr32 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- rc = x

built-in syntax

__builtin_rol_add_rrri(rc, rb, ra, shift) ;

rol_add:rrrici

mnemonic

rol_add rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- rc = x

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_rol_add_rrrici(rc, rb, ra, shift, div_nz_cc, pc) ;

rol_add:zrri

mnemonic

rol_add zero rb:wr32 ra:r32 shift:u5

behavior

- instruction with no effect

built-in syntax

__builtin_rol_add_zrri(zero, rb, ra, shift) ;

rol_add:zrrici

mnemonic

rol_add zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_rol_add_zrrici(zero, rb, ra, shift, div_nz_cc, pc) ;

rol_add.s

rol_add.s:rrri

mnemonic

rol_add.s dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- dc = x:S64

built-in syntax

__builtin_rol_add_s_rrri(dc, rb, ra, shift) ;

rol_add.s:rrrici

mnemonic

rol_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- dc = x:S64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_rol_add_s_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

rol_add.u

rol_add.u:rrri

mnemonic

rol_add.u dc:wr64 rb:wr32 ra:r32 shift:u5

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- dc = x:U64

built-in syntax

__builtin_rol_add_u_rrri(dc, rb, ra, shift) ;

rol_add.u:rrrici

mnemonic

rol_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16

behavior

- ZF <- ra <<r shift

- x = rb + (ra <<r shift[0:4])

- dc = x:U64

- if (div_nz_cc x) then

-     jump @[pc]

built-in syntax

__builtin_rol_add_u_rrrici(dc, rb, ra, shift, div_nz_cc, pc) ;

ROR

ror

ror:rri

mnemonic

ror rc:wr32 ra:r32 shift:u5

behavior

- x = ra >>r shift[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_ror_rri(rc, ra, shift) ;

ror:rric

mnemonic

ror rc:wr32 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>r shift[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_ror_rric(rc, ra, shift, log_set_cc) ;

ror:rrici

mnemonic

ror rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r shift[0:4]

- rc = x

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_rrici(rc, ra, shift, imm_shift_nz_cc, pc) ;

ror:rrr

mnemonic

ror rc:wr32 ra:r32 rb:wr32

behavior

- x = ra >>r rb[0:4]

- rc = x

- ZF <- x

built-in syntax

__builtin_ror_rrr(rc, ra, rb) ;

ror:rrrc

mnemonic

ror rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>r rb[0:4]

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_ror_rrrc(rc, ra, rb, log_set_cc) ;

ror:rrrci

mnemonic

ror rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r rb[0:4]

- rc = x

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_rrrci(rc, ra, rb, shift_nz_cc, pc) ;

ror:zri

mnemonic

ror zero ra:r32 shift:u5

behavior

- ZF <- ra >>r shift[0:4]

built-in syntax

__builtin_ror_zri(zero, ra, shift) ;

ror:zric

mnemonic

ror zero ra:r32 shift:u5 log_set_cc:cc

behavior

- ZF <- ra >>r shift[0:4]

built-in syntax

__builtin_ror_zric(zero, ra, shift, log_set_cc) ;

ror:zrici

mnemonic

ror zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r shift[0:4]

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_zrici(zero, ra, shift, imm_shift_nz_cc, pc) ;

ror:zrr

mnemonic

ror zero ra:r32 rb:wr32

behavior

- ZF <- ra >>r rb[0:4]

built-in syntax

__builtin_ror_zrr(zero, ra, rb) ;

ror:zrrc

mnemonic

ror zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra >>r rb[0:4]

built-in syntax

__builtin_ror_zrrc(zero, ra, rb, log_set_cc) ;

ror:zrrci

mnemonic

ror zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r rb[0:4]

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_zrrci(zero, ra, rb, shift_nz_cc, pc) ;

ror.s

ror.s:rri

mnemonic

ror.s dc:wr64 ra:r32 shift:u5

behavior

- x = ra >>r shift[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_ror_s_rri(dc, ra, shift) ;

ror.s:rric

mnemonic

ror.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>r shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_ror_s_rric(dc, ra, shift, log_set_cc) ;

ror.s:rrici

mnemonic

ror.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r shift[0:4]

- dc = x:S64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_s_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

ror.s:rrr

mnemonic

ror.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >>r rb[0:4]

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_ror_s_rrr(dc, ra, rb) ;

ror.s:rrrc

mnemonic

ror.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>r rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_ror_s_rrrc(dc, ra, rb, log_set_cc) ;

ror.s:rrrci

mnemonic

ror.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r rb[0:4]

- dc = x:S64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_s_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

ror.u

ror.u:rri

mnemonic

ror.u dc:wr64 ra:r32 shift:u5

behavior

- x = ra >>r shift[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_ror_u_rri(dc, ra, shift) ;

ror.u:rric

mnemonic

ror.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc

behavior

- x = ra >>r shift[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_ror_u_rric(dc, ra, shift, log_set_cc) ;

ror.u:rrici

mnemonic

ror.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r shift[0:4]

- dc = x:U64

- if (imm_shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_u_rrici(dc, ra, shift, imm_shift_nz_cc, pc) ;

ror.u:rrr

mnemonic

ror.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra >>r rb[0:4]

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_ror_u_rrr(dc, ra, rb) ;

ror.u:rrrc

mnemonic

ror.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra >>r rb[0:4]

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_ror_u_rrrc(dc, ra, rb, log_set_cc) ;

ror.u:rrrci

mnemonic

ror.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16

behavior

- x = ra >>r rb[0:4]

- dc = x:U64

- if (shift_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_ror_u_rrrci(dc, ra, rb, shift_nz_cc, pc) ;

RSUB

rsub

rsub:rrr

mnemonic

rsub rc:wr32 ra:r32 rb:wr32

behavior

- x = rb - ra

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_rsub_rrr(rc, ra, rb) ;

rsub:rrrc

mnemonic

rsub rc:wr32 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb - ra

- if (sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsub_rrrc(rc, ra, rb, sub_set_cc) ;

rsub:rrrci

mnemonic

rsub rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb - ra

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsub_rrrci(rc, ra, rb, sub_nz_cc, pc) ;

rsub:zrr

mnemonic

rsub zero ra:r32 rb:wr32

behavior

- ZF,CF <- rb - ra

built-in syntax

__builtin_rsub_zrr(zero, ra, rb) ;

rsub:zrrc

mnemonic

rsub zero ra:r32 rb:wr32 sub_set_cc:cc

behavior

- ZF,CF <- rb - ra

built-in syntax

__builtin_rsub_zrrc(zero, ra, rb, sub_set_cc) ;

rsub:zrrci

mnemonic

rsub zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb - ra

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsub_zrrci(zero, ra, rb, sub_nz_cc, pc) ;

rsub.s

rsub.s:rrr

mnemonic

rsub.s dc:wr64 ra:r32 rb:wr32

behavior

- x = rb - ra

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_rsub_s_rrr(dc, ra, rb) ;

rsub.s:rrrc

mnemonic

rsub.s dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb - ra

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsub_s_rrrc(dc, ra, rb, sub_set_cc) ;

rsub.s:rrrci

mnemonic

rsub.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb - ra

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsub_s_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

rsub.u

rsub.u:rrr

mnemonic

rsub.u dc:wr64 ra:r32 rb:wr32

behavior

- x = rb - ra

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_rsub_u_rrr(dc, ra, rb) ;

rsub.u:rrrc

mnemonic

rsub.u dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb - ra

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsub_u_rrrc(dc, ra, rb, sub_set_cc) ;

rsub.u:rrrci

mnemonic

rsub.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb - ra

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsub_u_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

RSUBC

rsubc

rsubc:rrr

mnemonic

rsubc rc:wr32 ra:r32 rb:wr32

behavior

- x = rb + ~ra + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_rsubc_rrr(rc, ra, rb) ;

rsubc:rrrc

mnemonic

rsubc rc:wr32 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb + ~ra + CF

- if (sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsubc_rrrc(rc, ra, rb, sub_set_cc) ;

rsubc:rrrci

mnemonic

rsubc rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb + ~ra + CF

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsubc_rrrci(rc, ra, rb, sub_nz_cc, pc) ;

rsubc:zrr

mnemonic

rsubc zero ra:r32 rb:wr32

behavior

- ZF,CF <- rb + ~ra + CF

built-in syntax

__builtin_rsubc_zrr(zero, ra, rb) ;

rsubc:zrrc

mnemonic

rsubc zero ra:r32 rb:wr32 sub_set_cc:cc

behavior

- ZF,CF <- rb + ~ra + CF

built-in syntax

__builtin_rsubc_zrrc(zero, ra, rb, sub_set_cc) ;

rsubc:zrrci

mnemonic

rsubc zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb + ~ra + CF

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsubc_zrrci(zero, ra, rb, sub_nz_cc, pc) ;

rsubc.s

rsubc.s:rrr

mnemonic

rsubc.s dc:wr64 ra:r32 rb:wr32

behavior

- x = rb + ~ra + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_rsubc_s_rrr(dc, ra, rb) ;

rsubc.s:rrrc

mnemonic

rsubc.s dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb + ~ra + CF

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsubc_s_rrrc(dc, ra, rb, sub_set_cc) ;

rsubc.s:rrrci

mnemonic

rsubc.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb + ~ra + CF

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsubc_s_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

rsubc.u

rsubc.u:rrr

mnemonic

rsubc.u dc:wr64 ra:r32 rb:wr32

behavior

- x = rb + ~ra + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_rsubc_u_rrr(dc, ra, rb) ;

rsubc.u:rrrc

mnemonic

rsubc.u dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc

behavior

- x = rb + ~ra + CF

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_rsubc_u_rrrc(dc, ra, rb, sub_set_cc) ;

rsubc.u:rrrci

mnemonic

rsubc.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = rb + ~ra + CF

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_rsubc_u_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

SUB

sub

sub:rir

mnemonic

sub rc:wr32 imm:u32 ra:r32

behavior

- rc = (imm - ra)

- ZF,CF <- rc

built-in syntax

__builtin_sub_rir(rc, imm, ra) ;

syntactic sugars

neg rc:wr32 ra:r32

- imm = 0

sub:rirc

mnemonic

sub rc:wr32 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm - ra

- if (sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_rirc(rc, imm, ra, sub_set_cc) ;

sub:rirci

mnemonic

sub rc:wr32 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm - ra

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_rirci(rc, imm, ra, sub_nz_cc, pc) ;

syntactic sugars

neg rc:wr32 ra:r32 sub_nz_cc:cc pc:pc16

- imm = 0

sub:rirf

mnemonic

sub rc:wr32 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm - ra

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_sub_rirf(rc, imm, ra, false_cc) ;

sub:rric

mnemonic

sub rc:wr32 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra - imm

- if (ext_sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_rric(rc, ra, imm, ext_sub_set_cc) ;

sub:rrici

mnemonic

sub rc:wr32 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra - imm

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_rrici(rc, ra, imm, sub_nz_cc, pc) ;

sub:rrif

mnemonic

sub rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra - imm

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_sub_rrif(rc, ra, imm, false_cc) ;

sub:rrr

mnemonic

sub rc:wr32 ra:r32 rb:wr32

behavior

- x = ra - rb

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_sub_rrr(rc, ra, rb) ;

sub:rrrc

mnemonic

sub rc:wr32 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra - rb

- if (ext_sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_rrrc(rc, ra, rb, ext_sub_set_cc) ;

sub:rrrci

mnemonic

sub rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra - rb

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_rrrci(rc, ra, rb, sub_nz_cc, pc) ;

sub:ssi

mnemonic

sub sc:wr32 sa:r32 imm:s17

behavior

- cc = (ra & 0xffff) - imm >> 16

- if (const_cc_zero cc) then

-     ZF,CF <- rc = (ra - imm)

- else

-     ZF,CF <- rc = (ra - imm) & 0xffffff | (id << 25)

-     raise exception(_memory_fault)

built-in syntax

__builtin_sub_ssi(sc, sa, imm) ;

syntactic sugars

subs rc:wr32 ra:r32 imm:s17

sub:sss

mnemonic

sub sc:wr32 sa:r32 sb:wr32

behavior

- cc = (ra & 0xffff) - rb >> 16

- if (const_cc_zero cc) then

-     ZF,CF <- rc = (ra - rb)

- else

-     ZF,CF <- rc = (ra - rb) & 0xffffff | (id << 25)

-     raise exception(_memory_fault)

built-in syntax

__builtin_sub_sss(sc, sa, sb) ;

syntactic sugars

subs rc:wr32 ra:r32 rb:wr32

sub:zir

mnemonic

sub zero imm:u32 rb:wr32

behavior

- ZF,CF <- imm - rb

built-in syntax

__builtin_sub_zir(zero, imm, rb) ;

sub:zirc

mnemonic

sub zero imm:s27 ra:r32 sub_set_cc:cc

behavior

- ZF,CF <- imm - ra

built-in syntax

__builtin_sub_zirc(zero, imm, ra, sub_set_cc) ;

sub:zirci

mnemonic

sub zero imm:s11 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm - ra

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_zirci(zero, imm, ra, sub_nz_cc, pc) ;

sub:zirf

mnemonic

sub zero imm:s27 ra:r32 false_cc:cc

behavior

- ZF,CF <- imm - ra

built-in syntax

__builtin_sub_zirf(zero, imm, ra, false_cc) ;

sub:zric

mnemonic

sub zero ra:r32 imm:s27 ext_sub_set_cc:cc

behavior

- ZF,CF <- ra - imm

built-in syntax

__builtin_sub_zric(zero, ra, imm, ext_sub_set_cc) ;

sub:zrici

mnemonic

sub zero ra:r32 imm:s11 sub_nz_cc:cc pc:pc16

behavior

- x = ra - imm

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_zrici(zero, ra, imm, sub_nz_cc, pc) ;

syntactic sugars

jeq ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = z

jneq ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = nz

jz ra:r32 pc:pc16

- zero = zero

- imm = 0

- sub_nz_cc = z

jnz ra:r32 pc:pc16

- zero = zero

- imm = 0

- sub_nz_cc = nz

jltu ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = ltu

jgtu ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = gtu

jleu ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = leu

jgeu ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = geu

jlts ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = lts

jgts ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = gts

jles ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = les

jges ra:r32 imm:s11 pc:pc16

- zero = zero

- sub_nz_cc = ges

sub:zrif

mnemonic

sub zero ra:r32 imm:s27 false_cc:cc

behavior

- ZF,CF <- ra - imm

built-in syntax

__builtin_sub_zrif(zero, ra, imm, false_cc) ;

sub:zrr

mnemonic

sub zero ra:r32 rb:wr32

behavior

- ZF,CF <- ra - rb

built-in syntax

__builtin_sub_zrr(zero, ra, rb) ;

sub:zrrc

mnemonic

sub zero ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- ZF,CF <- ra - rb

built-in syntax

__builtin_sub_zrrc(zero, ra, rb, ext_sub_set_cc) ;

sub:zrrci

mnemonic

sub zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra - rb

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_zrrci(zero, ra, rb, sub_nz_cc, pc) ;

syntactic sugars

jeq ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = z

jneq ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = nz

jltu ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = ltu

jgtu ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = gtu

jleu ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = leu

jgeu ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = geu

jlts ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = lts

jgts ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = gts

jles ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = les

jges ra:r32 rb:wr32 pc:pc16

- zero = zero

- sub_nz_cc = ges

sub.s

sub.s:rirc

mnemonic

sub.s dc:wr64 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm - ra

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rirc(dc, imm, ra, sub_set_cc) ;

sub.s:rirci

mnemonic

sub.s dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm - ra

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rirci(dc, imm, ra, sub_nz_cc, pc) ;

sub.s:rirf

mnemonic

sub.s dc:wr64 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm - ra

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rirf(dc, imm, ra, false_cc) ;

sub.s:rric

mnemonic

sub.s dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra - imm

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rric(dc, ra, imm, ext_sub_set_cc) ;

sub.s:rrici

mnemonic

sub.s dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra - imm

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rrici(dc, ra, imm, sub_nz_cc, pc) ;

sub.s:rrif

mnemonic

sub.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra - imm

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rrif(dc, ra, imm, false_cc) ;

sub.s:rrr

mnemonic

sub.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra - rb

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rrr(dc, ra, rb) ;

sub.s:rrrc

mnemonic

sub.s dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra - rb

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rrrc(dc, ra, rb, ext_sub_set_cc) ;

sub.s:rrrci

mnemonic

sub.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra - rb

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_s_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

sub.u

sub.u:rirc

mnemonic

sub.u dc:wr64 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm - ra

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rirc(dc, imm, ra, sub_set_cc) ;

sub.u:rirci

mnemonic

sub.u dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm - ra

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rirci(dc, imm, ra, sub_nz_cc, pc) ;

sub.u:rirf

mnemonic

sub.u dc:wr64 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm - ra

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rirf(dc, imm, ra, false_cc) ;

sub.u:rric

mnemonic

sub.u dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra - imm

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rric(dc, ra, imm, ext_sub_set_cc) ;

sub.u:rrici

mnemonic

sub.u dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra - imm

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rrici(dc, ra, imm, sub_nz_cc, pc) ;

sub.u:rrif

mnemonic

sub.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra - imm

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rrif(dc, ra, imm, false_cc) ;

sub.u:rrr

mnemonic

sub.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra - rb

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rrr(dc, ra, rb) ;

sub.u:rrrc

mnemonic

sub.u dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra - rb

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rrrc(dc, ra, rb, ext_sub_set_cc) ;

sub.u:rrrci

mnemonic

sub.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra - rb

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_sub_u_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

SUBC

subc

subc:rir

mnemonic

subc rc:wr32 imm:u32 ra:r32

behavior

- rc = (imm + ~ra + CF)

- ZF,CF <- rc

built-in syntax

__builtin_subc_rir(rc, imm, ra) ;

subc:rirc

mnemonic

subc rc:wr32 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm + ~ra + CF

- if (sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_rirc(rc, imm, ra, sub_set_cc) ;

subc:rirci

mnemonic

subc rc:wr32 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm + ~ra + CF

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_rirci(rc, imm, ra, sub_nz_cc, pc) ;

subc:rirf

mnemonic

subc rc:wr32 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm + ~ra + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_subc_rirf(rc, imm, ra, false_cc) ;

subc:rric

mnemonic

subc rc:wr32 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra + ~imm + CF

- if (ext_sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_rric(rc, ra, imm, ext_sub_set_cc) ;

subc:rrici

mnemonic

subc rc:wr32 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~imm + CF

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_rrici(rc, ra, imm, sub_nz_cc, pc) ;

subc:rrif

mnemonic

subc rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + ~imm + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_subc_rrif(rc, ra, imm, false_cc) ;

subc:rrr

mnemonic

subc rc:wr32 ra:r32 rb:wr32

behavior

- x = ra + ~rb + CF

- rc = x

- ZF,CF <- x

built-in syntax

__builtin_subc_rrr(rc, ra, rb) ;

subc:rrrc

mnemonic

subc rc:wr32 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra + ~rb + CF

- if (ext_sub_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_rrrc(rc, ra, rb, ext_sub_set_cc) ;

subc:rrrci

mnemonic

subc rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~rb + CF

- rc = x

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_rrrci(rc, ra, rb, sub_nz_cc, pc) ;

subc:zir

mnemonic

subc zero imm:u32 rb:wr32

behavior

- ZF,CF <- imm + ~rb + CF

built-in syntax

__builtin_subc_zir(zero, imm, rb) ;

subc:zirc

mnemonic

subc zero imm:s27 ra:r32 sub_set_cc:cc

behavior

- ZF,CF <- imm + ~ra + CF

built-in syntax

__builtin_subc_zirc(zero, imm, ra, sub_set_cc) ;

subc:zirci

mnemonic

subc zero imm:s11 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm + ~ra + CF

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_zirci(zero, imm, ra, sub_nz_cc, pc) ;

subc:zirf

mnemonic

subc zero imm:s27 ra:r32 false_cc:cc

behavior

- ZF,CF <- imm + ~ra + CF

built-in syntax

__builtin_subc_zirf(zero, imm, ra, false_cc) ;

subc:zric

mnemonic

subc zero ra:r32 imm:s27 ext_sub_set_cc:cc

behavior

- ZF,CF <- ra + ~imm + CF

built-in syntax

__builtin_subc_zric(zero, ra, imm, ext_sub_set_cc) ;

subc:zrici

mnemonic

subc zero ra:r32 imm:s11 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~imm + CF

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_zrici(zero, ra, imm, sub_nz_cc, pc) ;

subc:zrif

mnemonic

subc zero ra:r32 imm:s27 false_cc:cc

behavior

- ZF,CF <- ra + ~imm + CF

built-in syntax

__builtin_subc_zrif(zero, ra, imm, false_cc) ;

subc:zrr

mnemonic

subc zero ra:r32 rb:wr32

behavior

- ZF,CF <- ra + ~rb + CF

built-in syntax

__builtin_subc_zrr(zero, ra, rb) ;

subc:zrrc

mnemonic

subc zero ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- ZF,CF <- ra + ~rb + CF

built-in syntax

__builtin_subc_zrrc(zero, ra, rb, ext_sub_set_cc) ;

subc:zrrci

mnemonic

subc zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~rb + CF

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_zrrci(zero, ra, rb, sub_nz_cc, pc) ;

subc.s

subc.s:rirc

mnemonic

subc.s dc:wr64 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm + ~ra + CF

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rirc(dc, imm, ra, sub_set_cc) ;

subc.s:rirci

mnemonic

subc.s dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm + ~ra + CF

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rirci(dc, imm, ra, sub_nz_cc, pc) ;

subc.s:rirf

mnemonic

subc.s dc:wr64 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm + ~ra + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rirf(dc, imm, ra, false_cc) ;

subc.s:rric

mnemonic

subc.s dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra + ~imm + CF

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rric(dc, ra, imm, ext_sub_set_cc) ;

subc.s:rrici

mnemonic

subc.s dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~imm + CF

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rrici(dc, ra, imm, sub_nz_cc, pc) ;

subc.s:rrif

mnemonic

subc.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + ~imm + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rrif(dc, ra, imm, false_cc) ;

subc.s:rrr

mnemonic

subc.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + ~rb + CF

- dc = x:S64

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rrr(dc, ra, rb) ;

subc.s:rrrc

mnemonic

subc.s dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra + ~rb + CF

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rrrc(dc, ra, rb, ext_sub_set_cc) ;

subc.s:rrrci

mnemonic

subc.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~rb + CF

- dc = x:S64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_s_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

subc.u

subc.u:rirc

mnemonic

subc.u dc:wr64 imm:s24 ra:r32 sub_set_cc:cc

behavior

- x = imm + ~ra + CF

- if (sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rirc(dc, imm, ra, sub_set_cc) ;

subc.u:rirci

mnemonic

subc.u dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16

behavior

- x = imm + ~ra + CF

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rirci(dc, imm, ra, sub_nz_cc, pc) ;

subc.u:rirf

mnemonic

subc.u dc:wr64 imm:s24 ra:r32 false_cc:cc

behavior

- x = imm + ~ra + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rirf(dc, imm, ra, false_cc) ;

subc.u:rric

mnemonic

subc.u dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc

behavior

- x = ra + ~imm + CF

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rric(dc, ra, imm, ext_sub_set_cc) ;

subc.u:rrici

mnemonic

subc.u dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~imm + CF

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rrici(dc, ra, imm, sub_nz_cc, pc) ;

subc.u:rrif

mnemonic

subc.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra + ~imm + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rrif(dc, ra, imm, false_cc) ;

subc.u:rrr

mnemonic

subc.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra + ~rb + CF

- dc = x:U64

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rrr(dc, ra, rb) ;

subc.u:rrrc

mnemonic

subc.u dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc

behavior

- x = ra + ~rb + CF

- if (ext_sub_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rrrc(dc, ra, rb, ext_sub_set_cc) ;

subc.u:rrrci

mnemonic

subc.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16

behavior

- x = ra + ~rb + CF

- dc = x:U64

- if (sub_nz_cc x) then

-     jump @[pc]

- ZF,CF <- x

built-in syntax

__builtin_subc_u_rrrci(dc, ra, rb, sub_nz_cc, pc) ;

XOR

xor

xor:rri

mnemonic

xor rc:wr32 ra:r32 imm:u32

behavior

- rc = (ra ^ imm)

- ZF <- rc

built-in syntax

__builtin_xor_rri(rc, ra, imm) ;

syntactic sugars

not rc:wr32 ra:r32

- imm = -1

xor:rric

mnemonic

xor rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra ^ imm

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_xor_rric(rc, ra, imm, log_set_cc) ;

xor:rrici

mnemonic

xor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ imm

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_rrici(rc, ra, imm, log_nz_cc, pc) ;

syntactic sugars

not rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

- imm = -1

xor:rrif

mnemonic

xor rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra ^ imm

- rc = x

- ZF <- x

built-in syntax

__builtin_xor_rrif(rc, ra, imm, false_cc) ;

xor:rrr

mnemonic

xor rc:wr32 ra:r32 rb:wr32

behavior

- x = ra ^ rb

- rc = x

- ZF <- x

built-in syntax

__builtin_xor_rrr(rc, ra, rb) ;

xor:rrrc

mnemonic

xor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra ^ rb

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_xor_rrrc(rc, ra, rb, log_set_cc) ;

xor:rrrci

mnemonic

xor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ rb

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_rrrci(rc, ra, rb, log_nz_cc, pc) ;

xor:zri

mnemonic

xor zero rb:wr32 imm:u32

behavior

- ZF <- rb ^ imm

built-in syntax

__builtin_xor_zri(zero, rb, imm) ;

xor:zric

mnemonic

xor zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- ra ^ imm

built-in syntax

__builtin_xor_zric(zero, ra, imm, log_set_cc) ;

xor:zrici

mnemonic

xor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ imm

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_zrici(zero, ra, imm, log_nz_cc, pc) ;

syntactic sugars

not ra:r32 log_nz_cc:cc pc:pc16

- zero = zero

- imm = -1

xor:zrif

mnemonic

xor zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- ra ^ imm

built-in syntax

__builtin_xor_zrif(zero, ra, imm, false_cc) ;

xor:zrr

mnemonic

xor zero ra:r32 rb:wr32

behavior

- ZF <- ra ^ rb

built-in syntax

__builtin_xor_zrr(zero, ra, rb) ;

xor:zrrc

mnemonic

xor zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- ra ^ rb

built-in syntax

__builtin_xor_zrrc(zero, ra, rb, log_set_cc) ;

xor:zrrci

mnemonic

xor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ rb

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_zrrci(zero, ra, rb, log_nz_cc, pc) ;

xor.s

xor.s:rric

mnemonic

xor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra ^ imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_xor_s_rric(dc, ra, imm, log_set_cc) ;

xor.s:rrici

mnemonic

xor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ imm

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

xor.s:rrif

mnemonic

xor.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra ^ imm

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_xor_s_rrif(dc, ra, imm, false_cc) ;

xor.s:rrr

mnemonic

xor.s dc:wr64 ra:r32 rb:wr32

behavior

- x = ra ^ rb

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_xor_s_rrr(dc, ra, rb) ;

xor.s:rrrc

mnemonic

xor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra ^ rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_xor_s_rrrc(dc, ra, rb, log_set_cc) ;

xor.s:rrrci

mnemonic

xor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ rb

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

xor.u

xor.u:rric

mnemonic

xor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = ra ^ imm

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_xor_u_rric(dc, ra, imm, log_set_cc) ;

xor.u:rrici

mnemonic

xor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ imm

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

xor.u:rrif

mnemonic

xor.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = ra ^ imm

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_xor_u_rrif(dc, ra, imm, false_cc) ;

xor.u:rrr

mnemonic

xor.u dc:wr64 ra:r32 rb:wr32

behavior

- x = ra ^ rb

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_xor_u_rrr(dc, ra, rb) ;

xor.u:rrrc

mnemonic

xor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = ra ^ rb

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_xor_u_rrrc(dc, ra, rb, log_set_cc) ;

xor.u:rrrci

mnemonic

xor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = ra ^ rb

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_xor_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

Boot, stop and resume

BOOT

boot:rici

mnemonic

boot ra:r32 imm:s8 boot_cc:cc pc:pc16

behavior

- x = boot @[(ra + imm)[8:15] ^ (ra + imm)[0:7]]

- if (boot_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_boot_rici(ra, imm, boot_cc, pc) ;

syntactic sugars

boot ra:r32 imm:s8

- boot_cc = false

- pc = 0

RESUME

resume:rici

mnemonic

resume ra:r32 imm:s8 boot_cc:cc pc:pc16

behavior

- x = resume @[(ra + imm)[8:15] ^ (ra + imm)[0:7]]

- if (boot_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_resume_rici(ra, imm, boot_cc, pc) ;

syntactic sugars

resume ra:r32 imm:s8

- boot_cc = false

- pc = 0

STOP

stop:ci

mnemonic

stop boot_cc:cc pc:pc16

behavior

- if (boot_cc 1) then

-     jump @[pc]

- stop current thread

built-in syntax

__builtin_stop_ci(boot_cc, pc) ;

syntactic sugars

stop

- boot_cc = false

- pc = 0

Flow Control

CALL

call:rri

mnemonic

call rc:wr32 ra:r32 off:pc24

behavior

- rc = call @[ra + off]

built-in syntax

__builtin_call_rri(rc, ra, off) ;

syntactic sugars

call rc:wr32 ra:r32

- off = 0

call rc:wr32 off:pc24

- ra = zero

call:rrr

mnemonic

call rc:wr32 ra:r32 rb:wr32

behavior

- rc = call @[ra + rb]

built-in syntax

__builtin_call_rrr(rc, ra, rb) ;

call:zri

mnemonic

call zero ra:r32 off:pc28

behavior

- call @[ra + off]

built-in syntax

__builtin_call_zri(zero, ra, off) ;

syntactic sugars

jump ra:r32 off:pc28

- zero = zero

jump off:pc28

- zero = zero

- ra = zero

jump ra:r32

- zero = zero

- off = 0

call:zrr

mnemonic

call zero ra:r32 rb:wr32

behavior

- call @[ra + rb]

built-in syntax

__builtin_call_zrr(zero, ra, rb) ;

Miscellaneous

FAULT

fault:i

mnemonic

fault imm:s24

behavior

- raise fault

built-in syntax

__builtin_fault_i(imm) ;

syntactic sugars

bkp

- imm = 0

NOP

nop:

mnemonic

nop

behavior

- instruction with no effect

built-in syntax

__builtin_nop_() ;

SATS

sats

sats:rr

mnemonic

sats rc:wr32 ra:r32

behavior

- x = sats(ra)

- rc = x

- ZF <- x

built-in syntax

__builtin_sats_rr(rc, ra) ;

sats:rrc

mnemonic

sats rc:wr32 ra:r32 log_set_cc:cc

behavior

- x = sats(ra)

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_sats_rrc(rc, ra, log_set_cc) ;

sats:rrci

mnemonic

sats rc:wr32 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = sats(ra)

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_sats_rrci(rc, ra, log_nz_cc, pc) ;

sats:zr

mnemonic

sats zero ra:r32

behavior

- ZF <- sats(ra)

built-in syntax

__builtin_sats_zr(zero, ra) ;

sats:zrc

mnemonic

sats zero ra:r32 log_set_cc:cc

behavior

- ZF <- sats(ra)

built-in syntax

__builtin_sats_zrc(zero, ra, log_set_cc) ;

sats:zrci

mnemonic

sats zero ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = sats(ra)

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_sats_zrci(zero, ra, log_nz_cc, pc) ;

sats.s

sats.s:rr

mnemonic

sats.s dc:wr64 ra:r32

behavior

- x = sats(ra)

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_sats_s_rr(dc, ra) ;

sats.s:rrc

mnemonic

sats.s dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = sats(ra)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_sats_s_rrc(dc, ra, log_set_cc) ;

sats.s:rrci

mnemonic

sats.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = sats(ra)

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_sats_s_rrci(dc, ra, log_nz_cc, pc) ;

sats.u

sats.u:rr

mnemonic

sats.u dc:wr64 ra:r32

behavior

- x = sats(ra)

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_sats_u_rr(dc, ra) ;

sats.u:rrc

mnemonic

sats.u dc:wr64 ra:r32 log_set_cc:cc

behavior

- x = sats(ra)

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_sats_u_rrc(dc, ra, log_set_cc) ;

sats.u:rrci

mnemonic

sats.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16

behavior

- x = sats(ra)

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_sats_u_rrci(dc, ra, log_nz_cc, pc) ;

General Purpose

HASH

hash

hash:rric

mnemonic

hash rc:wr32 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = hash(ra,imm[0:3])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_hash_rric(rc, ra, imm, log_set_cc) ;

hash:rrici

mnemonic

hash rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,imm[0:3])

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_rrici(rc, ra, imm, log_nz_cc, pc) ;

hash:rrif

mnemonic

hash rc:wr32 ra:r32 imm:s24 false_cc:cc

behavior

- x = hash(ra,imm[0:3])

- rc = x

- ZF <- x

built-in syntax

__builtin_hash_rrif(rc, ra, imm, false_cc) ;

syntactic sugars

hash rc:wr32 ra:r32 imm:s24

- false_cc = false

hash:rrr

mnemonic

hash rc:wr32 ra:r32 rb:wr32

behavior

- x = hash(ra,rb[0:3])

- rc = x

- ZF <- x

built-in syntax

__builtin_hash_rrr(rc, ra, rb) ;

hash:rrrc

mnemonic

hash rc:wr32 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = hash(ra,rb[0:3])

- if (log_set_cc x) then

-     rc = 1

- else

-     rc = 0

- ZF <- x

built-in syntax

__builtin_hash_rrrc(rc, ra, rb, log_set_cc) ;

hash:rrrci

mnemonic

hash rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,rb[0:3])

- rc = x

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_rrrci(rc, ra, rb, log_nz_cc, pc) ;

hash:zric

mnemonic

hash zero ra:r32 imm:s28 log_set_cc:cc

behavior

- ZF <- hash(ra,imm[0:3])

built-in syntax

__builtin_hash_zric(zero, ra, imm, log_set_cc) ;

hash:zrici

mnemonic

hash zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,imm[0:3])

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_zrici(zero, ra, imm, log_nz_cc, pc) ;

hash:zrif

mnemonic

hash zero ra:r32 imm:s28 false_cc:cc

behavior

- ZF <- hash(ra,imm[0:3])

built-in syntax

__builtin_hash_zrif(zero, ra, imm, false_cc) ;

hash:zrr

mnemonic

hash zero ra:r32 rb:wr32

behavior

- ZF <- hash(ra,rb[0:3])

built-in syntax

__builtin_hash_zrr(zero, ra, rb) ;

hash:zrrc

mnemonic

hash zero ra:r32 rb:wr32 log_set_cc:cc

behavior

- ZF <- hash(ra,rb[0:3])

built-in syntax

__builtin_hash_zrrc(zero, ra, rb, log_set_cc) ;

hash:zrrci

mnemonic

hash zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,rb[0:3])

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_zrrci(zero, ra, rb, log_nz_cc, pc) ;

hash.s

hash.s:rric

mnemonic

hash.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = hash(ra,imm[0:3])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_hash_s_rric(dc, ra, imm, log_set_cc) ;

hash.s:rrici

mnemonic

hash.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,imm[0:3])

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_s_rrici(dc, ra, imm, log_nz_cc, pc) ;

hash.s:rrif

mnemonic

hash.s dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = hash(ra,imm[0:3])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_hash_s_rrif(dc, ra, imm, false_cc) ;

hash.s:rrr

mnemonic

hash.s dc:wr64 ra:r32 rb:wr32

behavior

- x = hash(ra,rb[0:3])

- dc = x:S64

- ZF <- x

built-in syntax

__builtin_hash_s_rrr(dc, ra, rb) ;

hash.s:rrrc

mnemonic

hash.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = hash(ra,rb[0:3])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_hash_s_rrrc(dc, ra, rb, log_set_cc) ;

hash.s:rrrci

mnemonic

hash.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,rb[0:3])

- dc = x:S64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_s_rrrci(dc, ra, rb, log_nz_cc, pc) ;

hash.u

hash.u:rric

mnemonic

hash.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc

behavior

- x = hash(ra,imm[0:3])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_hash_u_rric(dc, ra, imm, log_set_cc) ;

hash.u:rrici

mnemonic

hash.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,imm[0:3])

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_u_rrici(dc, ra, imm, log_nz_cc, pc) ;

hash.u:rrif

mnemonic

hash.u dc:wr64 ra:r32 imm:s24 false_cc:cc

behavior

- x = hash(ra,imm[0:3])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_hash_u_rrif(dc, ra, imm, false_cc) ;

hash.u:rrr

mnemonic

hash.u dc:wr64 ra:r32 rb:wr32

behavior

- x = hash(ra,rb[0:3])

- dc = x:U64

- ZF <- x

built-in syntax

__builtin_hash_u_rrr(dc, ra, rb) ;

hash.u:rrrc

mnemonic

hash.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc

behavior

- x = hash(ra,rb[0:3])

- if (log_set_cc x) then

-     dc = 1

- else

-     dc = 0

- ZF <- x

built-in syntax

__builtin_hash_u_rrrc(dc, ra, rb, log_set_cc) ;

hash.u:rrrci

mnemonic

hash.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16

behavior

- x = hash(ra,rb[0:3])

- dc = x:U64

- if (log_nz_cc x) then

-     jump @[pc]

- ZF <- x

built-in syntax

__builtin_hash_u_rrrci(dc, ra, rb, log_nz_cc, pc) ;

MOVD

movd:rrci

mnemonic

movd dc:wr64 db:wr64 true_false_cc:cc pc:pc16

behavior

- cc = dc = (dbe, dbo)

- if (true_false_cc cc) then

-     jump @[pc]

built-in syntax

__builtin_movd_rrci(dc, db, true_false_cc, pc) ;

syntactic sugars

movd dc:wr64 db:wr64

- true_false_cc = false

- pc = 0

SWAPD

swapd:rrci

mnemonic

swapd dc:wr64 db:wr64 true_false_cc:cc pc:pc16

behavior

- cc = x = dbe

- y = dbo

- dc = (y, x)

- if (true_false_cc cc) then

-     jump @[pc]

built-in syntax

__builtin_swapd_rrci(dc, db, true_false_cc, pc) ;

syntactic sugars

swapd dc:wr64 db:wr64

- true_false_cc = false

- pc = 0

TIME

time

time:r

mnemonic

time rc:wr32

behavior

- x = (T:read)[4:35]

- rc = x

built-in syntax

__builtin_time_r(rc) ;

time:rci

mnemonic

time rc:wr32 true_cc:cc pc:pc16

behavior

- x = (T:read)[4:35]

- rc = x

- if (true_cc x) then

-     jump @[pc]

built-in syntax

__builtin_time_rci(rc, true_cc, pc) ;

time:z

mnemonic

time zero

behavior

- instruction with no effect

built-in syntax

__builtin_time_z(zero) ;

time:zci

mnemonic

time zero true_cc:cc pc:pc16

behavior

- x = (T:read)[4:35]

- if (true_cc x) then

-     jump @[pc]

built-in syntax

__builtin_time_zci(zero, true_cc, pc) ;

time.s

time.s:r

mnemonic

time.s dc:wr64

behavior

- x = (T:read)[4:35]

- dc = x:S64

built-in syntax

__builtin_time_s_r(dc) ;

time.s:rci

mnemonic

time.s dc:wr64 true_cc:cc pc:pc16

behavior

- x = (T:read)[4:35]

- dc = x:S64

- if (true_cc x) then

-     jump @[pc]

built-in syntax

__builtin_time_s_rci(dc, true_cc, pc) ;

time.u

time.u:r

mnemonic

time.u dc:wr64

behavior

- x = (T:read)[4:35]

- dc = x:U64

built-in syntax

__builtin_time_u_r(dc) ;

time.u:rci

mnemonic

time.u dc:wr64 true_cc:cc pc:pc16

behavior

- x = (T:read)[4:35]

- dc = x:U64

- if (true_cc x) then

-     jump @[pc]

built-in syntax

__builtin_time_u_rci(dc, true_cc, pc) ;

time_cfg

time_cfg:rr

mnemonic

time_cfg rc:wr32 rb:wr32

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- rc = y

built-in syntax

__builtin_time_cfg_rr(rc, rb) ;

time_cfg:rrci

mnemonic

time_cfg rc:wr32 rb:wr32 true_cc:cc pc:pc16

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- rc = y

- if (true_cc y) then

-     jump @[pc]

built-in syntax

__builtin_time_cfg_rrci(rc, rb, true_cc, pc) ;

time_cfg:zr

mnemonic

time_cfg zero rb:wr32

behavior

- instruction with no effect

built-in syntax

__builtin_time_cfg_zr(zero, rb) ;

syntactic sugars

time_cfg rb:wr32

- zero = zero

time_cfg:zrci

mnemonic

time_cfg zero rb:wr32 true_cc:cc pc:pc16

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- if (true_cc y) then

-     jump @[pc]

built-in syntax

__builtin_time_cfg_zrci(zero, rb, true_cc, pc) ;

time_cfg.s

time_cfg.s:rr

mnemonic

time_cfg.s dc:wr64 rb:wr32

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- dc = y:S64

built-in syntax

__builtin_time_cfg_s_rr(dc, rb) ;

time_cfg.s:rrci

mnemonic

time_cfg.s dc:wr64 rb:wr32 true_cc:cc pc:pc16

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- dc = y:S64

- if (true_cc y) then

-     jump @[pc]

built-in syntax

__builtin_time_cfg_s_rrci(dc, rb, true_cc, pc) ;

time_cfg.u

time_cfg.u:rr

mnemonic

time_cfg.u dc:wr64 rb:wr32

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- dc = y:U64

built-in syntax

__builtin_time_cfg_u_rr(dc, rb) ;

time_cfg.u:rrci

mnemonic

time_cfg.u dc:wr64 rb:wr32 true_cc:cc pc:pc16

behavior

- x = T:read

- T:config(rb[0:2])

- y = x[4:35]

- dc = y:U64

- if (true_cc y) then

-     jump @[pc]

built-in syntax

__builtin_time_cfg_u_rrci(dc, rb, true_cc, pc) ;

Load Store

LBS

lbs

lbs:erri

mnemonic

lbs endian:e rc:wr32 ra:r32 off:s24

behavior

- let @a = (ra + off)

- rc = (Load 1 byte from WRAM at address @a with endianness endian):S32

built-in syntax

__builtin_lbs_erri(endian, rc, ra, off) ;

syntactic sugars

lbs rc:wr32 ra:r32 off:s24

- endian = !little

lbs:ersi

mnemonic

lbs endian:e rc:wr32 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xffff

-     rc = (Load 1 byte from WRAM at address @a with endianness endian):S32

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     rc = (Load 1 byte from WRAM at address @a with endianness endian):S32

built-in syntax

__builtin_lbs_ersi(endian, rc, sa, off) ;

syntactic sugars

lbss rc:wr32 ra:r32 off:s24

- endian = !little

lbs.s

lbs.s:erri

mnemonic

lbs.s endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 1 byte from WRAM at address @a with endianness endian):S64

built-in syntax

__builtin_lbs_s_erri(endian, dc, ra, off) ;

syntactic sugars

lbs.s dc:wr64 ra:r32 off:s24

- endian = !little

LBU

lbu

lbu:erri

mnemonic

lbu endian:e rc:wr32 ra:r32 off:s24

behavior

- let @a = (ra + off)

- rc = (Load 1 byte from WRAM at address @a with endianness endian):U32

built-in syntax

__builtin_lbu_erri(endian, rc, ra, off) ;

syntactic sugars

lbu rc:wr32 ra:r32 off:s24

- endian = !little

lbu:ersi

mnemonic

lbu endian:e rc:wr32 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xffff

-     rc = (Load 1 byte from WRAM at address @a with endianness endian):U32

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     rc = (Load 1 byte from WRAM at address @a with endianness endian):U32

built-in syntax

__builtin_lbu_ersi(endian, rc, sa, off) ;

syntactic sugars

lbus rc:wr32 ra:r32 off:s24

- endian = !little

lbu.u

lbu.u:erri

mnemonic

lbu.u endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 1 byte from WRAM at address @a with endianness endian):U64

built-in syntax

__builtin_lbu_u_erri(endian, dc, ra, off) ;

syntactic sugars

lbu.u dc:wr64 ra:r32 off:s24

- endian = !little

LD

ld:erri

mnemonic

ld endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 8 bytes from WRAM at address @a with endianness endian)

built-in syntax

__builtin_ld_erri(endian, dc, ra, off) ;

syntactic sugars

ld dc:wr64 ra:r32 off:s24

- endian = !little

ld:ersi

mnemonic

ld endian:e dc:wr64 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off + 8 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfff8

-     dc = (Load 8 bytes from WRAM at address @a with endianness endian)

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     dc = (Load 8 bytes from WRAM at address @a with endianness endian)

built-in syntax

__builtin_ld_ersi(endian, dc, sa, off) ;

syntactic sugars

lds dc:wr64 ra:r32 off:s24

- endian = !little

LHS

lhs

lhs:erri

mnemonic

lhs endian:e rc:wr32 ra:r32 off:s24

behavior

- let @a = (ra + off)

- rc = (Load 2 bytes from WRAM at address @a with endianness endian):S32

built-in syntax

__builtin_lhs_erri(endian, rc, ra, off) ;

syntactic sugars

lhs rc:wr32 ra:r32 off:s24

- endian = !little

lhs:ersi

mnemonic

lhs endian:e rc:wr32 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off + 2 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffe

-     rc = (Load 2 bytes from WRAM at address @a with endianness endian):S32

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     rc = (Load 2 bytes from WRAM at address @a with endianness endian):S32

built-in syntax

__builtin_lhs_ersi(endian, rc, sa, off) ;

syntactic sugars

lhss rc:wr32 ra:r32 off:s24

- endian = !little

lhs.s

lhs.s:erri

mnemonic

lhs.s endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 2 bytes from WRAM at address @a with endianness endian):S64

built-in syntax

__builtin_lhs_s_erri(endian, dc, ra, off) ;

syntactic sugars

lhs.s dc:wr64 ra:r32 off:s24

- endian = !little

LHU

lhu

lhu:erri

mnemonic

lhu endian:e rc:wr32 ra:r32 off:s24

behavior

- let @a = (ra + off)

- rc = (Load 2 bytes from WRAM at address @a with endianness endian):U32

built-in syntax

__builtin_lhu_erri(endian, rc, ra, off) ;

syntactic sugars

lhu rc:wr32 ra:r32 off:s24

- endian = !little

lhu:ersi

mnemonic

lhu endian:e rc:wr32 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off + 2 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffe

-     rc = (Load 2 bytes from WRAM at address @a with endianness endian):U32

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     rc = (Load 2 bytes from WRAM at address @a with endianness endian):U32

built-in syntax

__builtin_lhu_ersi(endian, rc, sa, off) ;

syntactic sugars

lhus rc:wr32 ra:r32 off:s24

- endian = !little

lhu.u

lhu.u:erri

mnemonic

lhu.u endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 2 bytes from WRAM at address @a with endianness endian):U64

built-in syntax

__builtin_lhu_u_erri(endian, dc, ra, off) ;

syntactic sugars

lhu.u dc:wr64 ra:r32 off:s24

- endian = !little

LW

lw

lw:erri

mnemonic

lw endian:e rc:wr32 ra:r32 off:s24

behavior

- let @a = (ra + off)

- rc = (Load 4 bytes from WRAM at address @a with endianness endian)

built-in syntax

__builtin_lw_erri(endian, rc, ra, off) ;

syntactic sugars

lw rc:wr32 ra:r32 off:s24

- endian = !little

lw:ersi

mnemonic

lw endian:e rc:wr32 sa:r32 off:s24

behavior

- cc = (ra & 0xffff) + off + 4 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffc

-     rc = (Load 4 bytes from WRAM at address @a with endianness endian)

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     rc = (Load 4 bytes from WRAM at address @a with endianness endian)

built-in syntax

__builtin_lw_ersi(endian, rc, sa, off) ;

syntactic sugars

lws rc:wr32 ra:r32 off:s24

- endian = !little

lw.s

lw.s:erri

mnemonic

lw.s endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 4 bytes from WRAM at address @a with endianness endian):S64

built-in syntax

__builtin_lw_s_erri(endian, dc, ra, off) ;

syntactic sugars

lw.s dc:wr64 ra:r32 off:s24

- endian = !little

lw.u

lw.u:erri

mnemonic

lw.u endian:e dc:wr64 ra:r32 off:s24

behavior

- let @a = (ra + off)

- dc = (Load 4 bytes from WRAM at address @a with endianness endian):U64

built-in syntax

__builtin_lw_u_erri(endian, dc, ra, off) ;

syntactic sugars

lw.u dc:wr64 ra:r32 off:s24

- endian = !little

SB

sb

sb:erii

mnemonic

sb endian:e ra:r32 off:s12 imm:s8

behavior

- let @a = (ra + off)

- Store imm:8 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sb_erii(endian, ra, off, imm) ;

syntactic sugars

sb ra:r32 off:s12 imm:s8

- endian = !little

sb:erir

mnemonic

sb endian:e ra:r32 off:s24 rb:wr32

behavior

- let @a = (ra + off)

- Store rb:8 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sb_erir(endian, ra, off, rb) ;

syntactic sugars

sb ra:r32 off:s24 rb:wr32

- endian = !little

sb:esii

mnemonic

sb endian:e sa:r32 off:s12 imm:s8

behavior

- cc = (ra & 0xffff) + off - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xffff

-     Store imm:8 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store imm:8 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sb_esii(endian, sa, off, imm) ;

syntactic sugars

sbs ra:r32 off:s12 imm:s8

- endian = !little

sb:esir

mnemonic

sb endian:e sa:r32 off:s24 rb:wr32

behavior

- cc = (ra & 0xffff) + off - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xffff

-     Store rb:8 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store rb:8 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sb_esir(endian, sa, off, rb) ;

syntactic sugars

sbs ra:r32 off:s24 rb:wr32

- endian = !little

sb_id

sb_id:erii

mnemonic

sb_id endian:e ra:r32 off:s12 imm:s8

behavior

- let @a = (ra + off)

- Store (id | imm):8 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sb_id_erii(endian, ra, off, imm) ;

syntactic sugars

sb_id ra:r32 off:s12 imm:s8

- endian = !little

sb_id ra:r32 off:s12

- endian = !little

- imm = 0

SD

sd

sd:erii

mnemonic

sd endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store imm:S64:64 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sd_erii(endian, ra, off, imm) ;

syntactic sugars

sd ra:r32 off:s12 imm:s16

- endian = !little

sd:erir

mnemonic

sd endian:e ra:r32 off:s24 db:wr64

behavior

- let @a = (ra + off)

- Store db:64 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sd_erir(endian, ra, off, db) ;

syntactic sugars

sd ra:r32 off:s24 db:wr64

- endian = !little

sd:esii

mnemonic

sd endian:e sa:r32 off:s12 imm:s16

behavior

- cc = (ra & 0xffff) + off + 8 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfff8

-     Store imm:S64:64 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store imm:S64:64 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sd_esii(endian, sa, off, imm) ;

syntactic sugars

sds ra:r32 off:s12 imm:s16

- endian = !little

sd:esir

mnemonic

sd endian:e sa:r32 off:s24 db:wr64

behavior

- cc = (ra & 0xffff) + off + 8 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfff8

-     Store db:64 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store db:64 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sd_esir(endian, sa, off, db) ;

syntactic sugars

sds ra:r32 off:s24 db:wr64

- endian = !little

sd_id

sd_id:erii

mnemonic

sd_id endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store (id | imm):S64:64 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sd_id_erii(endian, ra, off, imm) ;

syntactic sugars

sd_id ra:r32 off:s12 imm:s16

- endian = !little

sd_id ra:r32 off:s12

- endian = !little

- imm = 0

SH

sh

sh:erii

mnemonic

sh endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store imm:16 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sh_erii(endian, ra, off, imm) ;

syntactic sugars

sh ra:r32 off:s12 imm:s16

- endian = !little

sh:erir

mnemonic

sh endian:e ra:r32 off:s24 rb:wr32

behavior

- let @a = (ra + off)

- Store rb:16 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sh_erir(endian, ra, off, rb) ;

syntactic sugars

sh ra:r32 off:s24 rb:wr32

- endian = !little

sh:esii

mnemonic

sh endian:e sa:r32 off:s12 imm:s16

behavior

- cc = (ra & 0xffff) + off + 2 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffe

-     Store imm:16 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store imm:16 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sh_esii(endian, sa, off, imm) ;

syntactic sugars

shs ra:r32 off:s12 imm:s16

- endian = !little

sh:esir

mnemonic

sh endian:e sa:r32 off:s24 rb:wr32

behavior

- cc = (ra & 0xffff) + off + 2 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffe

-     Store rb:16 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store rb:16 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sh_esir(endian, sa, off, rb) ;

syntactic sugars

shs ra:r32 off:s24 rb:wr32

- endian = !little

sh_id

sh_id:erii

mnemonic

sh_id endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store (id | imm):16 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sh_id_erii(endian, ra, off, imm) ;

syntactic sugars

sh_id ra:r32 off:s12 imm:s16

- endian = !little

sh_id ra:r32 off:s12

- endian = !little

- imm = 0

SW

sw

sw:erii

mnemonic

sw endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store imm:S32:32 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sw_erii(endian, ra, off, imm) ;

syntactic sugars

sw ra:r32 off:s12 imm:s16

- endian = !little

sw:erir

mnemonic

sw endian:e ra:r32 off:s24 rb:wr32

behavior

- let @a = (ra + off)

- Store rb:32 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sw_erir(endian, ra, off, rb) ;

syntactic sugars

sw ra:r32 off:s24 rb:wr32

- endian = !little

sw:esii

mnemonic

sw endian:e sa:r32 off:s12 imm:s16

behavior

- cc = (ra & 0xffff) + off + 4 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffc

-     Store imm:S32:32 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store imm:S32:32 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sw_esii(endian, sa, off, imm) ;

syntactic sugars

sws ra:r32 off:s12 imm:s16

- endian = !little

sw:esir

mnemonic

sw endian:e sa:r32 off:s24 rb:wr32

behavior

- cc = (ra & 0xffff) + off + 4 - (ra >> 16)

- if (const_cc_ge0 cc) then

-     let @a = (ra & 0xffff) + off & 0xfffc

-     Store rb:32 into WRAM at address @a with endianness endian

-     raise exception(_memory_fault)

- else

-     let @a = (ra & 0xffff) + off

-     Store rb:32 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sw_esir(endian, sa, off, rb) ;

syntactic sugars

sws ra:r32 off:s24 rb:wr32

- endian = !little

sw_id

sw_id:erii

mnemonic

sw_id endian:e ra:r32 off:s12 imm:s16

behavior

- let @a = (ra + off)

- Store (id | imm):32 into WRAM at address @a with endianness endian

built-in syntax

__builtin_sw_id_erii(endian, ra, off, imm) ;

syntactic sugars

sw_id ra:r32 off:s12 imm:s16

- endian = !little

sw_id ra:r32 off:s12

- endian = !little

- imm = 0

Load Store MRAM

LDMA

ldma:rri

mnemonic

ldma ra:r32 rb:wr32 immDma:u8

behavior

- let @w = (ra & 0xfffff8)

- let @m = (rb & 0xfffffff8)

- let N = (1 + (immDma:U32 + (ra >> 24) & 0xff) & 0xff) << 3

- Load N bytes from MRAM at address @m into WRAM at address @w

built-in syntax

__builtin_ldma_rri(ra, rb, immDma) ;

LDMAI

ldmai:rri

mnemonic

ldmai ra:r32 rb:wr32 immDma:u8

behavior

- let @i = (ra & 0xfffff8)

- let @m = (rb & 0xfffffff8)

- let N = (1 + (immDma:U32 + (ra >> 24) & 0xff) & 0xff) << 3

- Load N bytes from MRAM at address @m into IRAM at address @w

built-in syntax

__builtin_ldmai_rri(ra, rb, immDma) ;

SDMA

sdma:rri

mnemonic

sdma ra:r32 rb:wr32 immDma:u8

behavior

- let @w = (ra & 0xfffff8)

- let @m = (rb & 0xfffffff8)

- let N = (1 + (immDma:U32 + (ra >> 24) & 0xff) & 0xff) << 3

- Store N bytes from WRAM at address @w into MRAM at address @m

built-in syntax

__builtin_sdma_rri(ra, rb, immDma) ;