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 | +--------------------+-----------------------------+ .. _scheduling-explanation-label: 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 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 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* .. code-block:: none acquire ra:r32 imm:s16 acquire_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none release ra:r32 imm:s16 release_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add rc:wr32 ra:r32 imm:u32 *behavior* .. code-block:: none - rc = (ra + imm) - ZF,CF <- rc *built-in syntax* * __builtin_add_rri(rc, ra, imm) ; add:rric ^^^^^^^^ *mnemonic* .. code-block:: none add rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add rc:wr32 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra + imm - rc = x - ZF,CF <- x *built-in syntax* * __builtin_add_rrif(rc, ra, imm, false_cc) ; add:rrr ^^^^^^^ *mnemonic* .. code-block:: none add rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb - rc = x - ZF,CF <- x *built-in syntax* * __builtin_add_rrr(rc, ra, rb) ; add:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none add rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add rc:wr32 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add sc:wr32 sa:r32 imm:s17 *behavior* .. code-block:: none - 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* .. code-block:: none adds rc:wr32 ra:r32 imm:s17 add:sss ^^^^^^^ *mnemonic* .. code-block:: none add sc:wr32 sa:r32 sb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none adds rc:wr32 ra:r32 rb:wr32 add:zri ^^^^^^^ *mnemonic* .. code-block:: none add zero rb:wr32 imm:u32 *behavior* .. code-block:: none - ZF,CF <- rb + imm *built-in syntax* * __builtin_add_zri(zero, rb, imm) ; add:zric ^^^^^^^^ *mnemonic* .. code-block:: none add zero ra:r32 imm:s27 log_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + imm *built-in syntax* * __builtin_add_zric(zero, ra, imm, log_set_cc) ; add:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none add zero ra:r32 imm:s11 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add zero ra:r32 imm:s27 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + imm *built-in syntax* * __builtin_add_zrif(zero, ra, imm, false_cc) ; add:zrr ^^^^^^^ *mnemonic* .. code-block:: none add zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- ra + rb *built-in syntax* * __builtin_add_zrr(zero, ra, rb) ; add:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none add zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + rb *built-in syntax* * __builtin_add_zrrc(zero, ra, rb, log_set_cc) ; add:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none add zero ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add.s dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb + imm):S64 - ZF,CF <- dc *built-in syntax* * __builtin_add_s_rri(dc, rb, imm) ; add.s:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none add.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.s dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_add_s_rrr(dc, ra, rb) ; add.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none add.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.s dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add.u dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb + imm):U64 - ZF,CF <- dc *built-in syntax* * __builtin_add_u_rri(dc, rb, imm) ; add.u:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none add.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.u dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none add.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_add_u_rrr(dc, ra, rb) ; add.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none add.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none add.u dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc rc:wr32 ra:r32 imm:u32 *behavior* .. code-block:: none - rc = (ra + imm + CF) - ZF,CF <- rc *built-in syntax* * __builtin_addc_rri(rc, ra, imm) ; addc:rric ^^^^^^^^^ *mnemonic* .. code-block:: none addc rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc rc:wr32 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra + imm + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_addc_rrif(rc, ra, imm, false_cc) ; addc:rrr ^^^^^^^^ *mnemonic* .. code-block:: none addc rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_addc_rrr(rc, ra, rb) ; addc:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none addc rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc rc:wr32 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc zero rb:wr32 imm:u32 *behavior* .. code-block:: none - ZF,CF <- rb + imm + CF *built-in syntax* * __builtin_addc_zri(zero, rb, imm) ; addc:zric ^^^^^^^^^ *mnemonic* .. code-block:: none addc zero ra:r32 imm:s27 log_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + imm + CF *built-in syntax* * __builtin_addc_zric(zero, ra, imm, log_set_cc) ; addc:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none addc zero ra:r32 imm:s11 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc zero ra:r32 imm:s27 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + imm + CF *built-in syntax* * __builtin_addc_zrif(zero, ra, imm, false_cc) ; addc:zrr ^^^^^^^^ *mnemonic* .. code-block:: none addc zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- ra + rb + CF *built-in syntax* * __builtin_addc_zrr(zero, ra, rb) ; addc:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none addc zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + rb + CF *built-in syntax* * __builtin_addc_zrrc(zero, ra, rb, log_set_cc) ; addc:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none addc zero ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.s dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb + CF - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_addc_s_rrr(dc, ra, rb) ; addc.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none addc.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.s dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.u dc:wr64 ra:r32 imm:s8 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none addc.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + rb + CF - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_addc_u_rrr(dc, ra, rb) ; addc.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none addc.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none addc.u dc:wr64 ra:r32 rb:wr32 add_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and rc:wr32 ra:wr32 imm:u32 *behavior* .. code-block:: none - rc = (ra & imm) - ZF <- rc *built-in syntax* * __builtin_and_rri(rc, ra, imm) ; and:rric ^^^^^^^^ *mnemonic* .. code-block:: none and rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra & imm - rc = x - ZF <- x *built-in syntax* * __builtin_and_rrif(rc, ra, imm, false_cc) ; and:rrr ^^^^^^^ *mnemonic* .. code-block:: none and rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra & rb - rc = x - ZF <- x *built-in syntax* * __builtin_and_rrr(rc, ra, rb) ; and:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none and rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and zero rb:wr32 imm:u32 *behavior* .. code-block:: none - ZF <- rb & imm *built-in syntax* * __builtin_and_zri(zero, rb, imm) ; and:zric ^^^^^^^^ *mnemonic* .. code-block:: none and zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra & imm *built-in syntax* * __builtin_and_zric(zero, ra, imm, log_set_cc) ; and:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none and zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ra & imm *built-in syntax* * __builtin_and_zrif(zero, ra, imm, false_cc) ; and:zrr ^^^^^^^ *mnemonic* .. code-block:: none and zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra & rb *built-in syntax* * __builtin_and_zrr(zero, ra, rb) ; and:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none and zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra & rb *built-in syntax* * __builtin_and_zrrc(zero, ra, rb, log_set_cc) ; and:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none and zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and.s dc:wr64 ra:r32 imm:u32 *behavior* .. code-block:: none - dc = (ra & imm):S64 - ZF <- dc *built-in syntax* * __builtin_and_s_rki(dc, ra, imm) ; *syntactic sugars* .. code-block:: none move.s dc:wr64 imm:u32 - ra = lneg and.s:rri ^^^^^^^^^ *mnemonic* .. code-block:: none and.s dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb & imm):S64 - ZF <- dc *built-in syntax* * __builtin_and_s_rri(dc, rb, imm) ; and.s:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none and.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra & imm - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_and_s_rrif(dc, ra, imm, false_cc) ; and.s:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none and.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra & rb - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_and_s_rrr(dc, ra, rb) ; and.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none and.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and.u dc:wr64 ra:r32 imm:u32 *behavior* .. code-block:: none - dc = (ra & imm):U64 - ZF <- dc *built-in syntax* * __builtin_and_u_rki(dc, ra, imm) ; *syntactic sugars* .. code-block:: none move.u dc:wr64 imm:u32 - ra = lneg and.u:rri ^^^^^^^^^ *mnemonic* .. code-block:: none and.u dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb & imm):U64 - ZF <- dc *built-in syntax* * __builtin_and_u_rri(dc, rb, imm) ; and.u:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none and.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none and.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra & imm - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_and_u_rrif(dc, ra, imm, false_cc) ; and.u:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none and.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra & rb - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_and_u_rrr(dc, ra, rb) ; and.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none and.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none and.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra & imm - rc = x - ZF <- x *built-in syntax* * __builtin_andn_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none andn rc:wr32 ra:r32 imm:s24 - false_cc = false andn:rrr ^^^^^^^^ *mnemonic* .. code-block:: none andn rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra & rb - rc = x - ZF <- x *built-in syntax* * __builtin_andn_rrr(rc, ra, rb) ; andn:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none andn rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~ra & imm *built-in syntax* * __builtin_andn_zric(zero, ra, imm, log_set_cc) ; andn:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none andn zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ~ra & imm *built-in syntax* * __builtin_andn_zrif(zero, ra, imm, false_cc) ; andn:zrr ^^^^^^^^ *mnemonic* .. code-block:: none andn zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ~ra & rb *built-in syntax* * __builtin_andn_zrr(zero, ra, rb) ; andn:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none andn zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~ra & rb *built-in syntax* * __builtin_andn_zrrc(zero, ra, rb, log_set_cc) ; andn:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none andn zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra & imm - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_andn_s_rrif(dc, ra, imm, false_cc) ; andn.s:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none andn.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra & rb - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_andn_s_rrr(dc, ra, rb) ; andn.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none andn.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none andn.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra & imm - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_andn_u_rrif(dc, ra, imm, false_cc) ; andn.u:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none andn.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra & rb - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_andn_u_rrr(dc, ra, rb) ; andn.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none andn.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none andn.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra >>a shift[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_asr_rri(rc, ra, shift) ; asr:rric ^^^^^^^^ *mnemonic* .. code-block:: none asr rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >>a rb[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_asr_rrr(rc, ra, rb) ; asr:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none asr rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra >>a shift[0:4] *built-in syntax* * __builtin_asr_zri(zero, ra, shift) ; asr:zric ^^^^^^^^ *mnemonic* .. code-block:: none asr zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >>a shift[0:4] *built-in syntax* * __builtin_asr_zric(zero, ra, shift, log_set_cc) ; asr:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none asr zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra >>a rb[0:4] *built-in syntax* * __builtin_asr_zrr(zero, ra, rb) ; asr:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none asr zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >>a rb[0:4] *built-in syntax* * __builtin_asr_zrrc(zero, ra, rb, log_set_cc) ; asr:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none asr zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none asr.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cao rc:wr32 ra:r32 *behavior* .. code-block:: none - x = count one bits in ra - rc = x - ZF <- x *built-in syntax* * __builtin_cao_rr(rc, ra) ; cao:rrc ^^^^^^^ *mnemonic* .. code-block:: none cao rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cao rc:wr32 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cao zero ra:r32 *behavior* .. code-block:: none - ZF <- count one bits in ra *built-in syntax* * __builtin_cao_zr(zero, ra) ; cao:zrc ^^^^^^^ *mnemonic* .. code-block:: none cao zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- count one bits in ra *built-in syntax* * __builtin_cao_zrc(zero, ra, log_set_cc) ; cao:zrci ^^^^^^^^ *mnemonic* .. code-block:: none cao zero ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cao.s dc:wr64 ra:r32 *behavior* .. code-block:: none - x = count one bits in ra - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_cao_s_rr(dc, ra) ; cao.s:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none cao.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cao.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cao.u dc:wr64 ra:r32 *behavior* .. code-block:: none - x = count one bits in ra - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_cao_u_rr(dc, ra) ; cao.u:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none cao.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cao.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clo rc:wr32 ra:r32 *behavior* .. code-block:: none - x = count leading one bits of ra - rc = x - ZF <- x *built-in syntax* * __builtin_clo_rr(rc, ra) ; clo:rrc ^^^^^^^ *mnemonic* .. code-block:: none clo rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clo rc:wr32 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clo zero ra:r32 *behavior* .. code-block:: none - ZF <- count leading one bits of ra *built-in syntax* * __builtin_clo_zr(zero, ra) ; clo:zrc ^^^^^^^ *mnemonic* .. code-block:: none clo zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- count leading one bits of ra *built-in syntax* * __builtin_clo_zrc(zero, ra, log_set_cc) ; clo:zrci ^^^^^^^^ *mnemonic* .. code-block:: none clo zero ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clo.s dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none clo.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clo.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clo.u dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none clo.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clo.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cls rc:wr32 ra:r32 *behavior* .. code-block:: none - x = count leading sign bit of ra - rc = x - ZF <- x *built-in syntax* * __builtin_cls_rr(rc, ra) ; cls:rrc ^^^^^^^ *mnemonic* .. code-block:: none cls rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cls rc:wr32 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cls zero ra:r32 *behavior* .. code-block:: none - ZF <- count leading sign bit of ra *built-in syntax* * __builtin_cls_zr(zero, ra) ; cls:zrc ^^^^^^^ *mnemonic* .. code-block:: none cls zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- count leading sign bit of ra *built-in syntax* * __builtin_cls_zrc(zero, ra, log_set_cc) ; cls:zrci ^^^^^^^^ *mnemonic* .. code-block:: none cls zero ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cls.s dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none cls.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cls.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cls.u dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none cls.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cls.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clz rc:wr32 ra:r32 *behavior* .. code-block:: none - x = count leading zero bits of ra - rc = x - ZF <- x *built-in syntax* * __builtin_clz_rr(rc, ra) ; clz:rrc ^^^^^^^ *mnemonic* .. code-block:: none clz rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clz rc:wr32 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clz zero ra:r32 *behavior* .. code-block:: none - ZF <- count leading zero bits of ra *built-in syntax* * __builtin_clz_zr(zero, ra) ; clz:zrc ^^^^^^^ *mnemonic* .. code-block:: none clz zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- count leading zero bits of ra *built-in syntax* * __builtin_clz_zrc(zero, ra, log_set_cc) ; clz:zrci ^^^^^^^^ *mnemonic* .. code-block:: none clz zero ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clz.s dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none clz.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clz.s dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none clz.u dc:wr64 ra:r32 *behavior* .. code-block:: none - 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* .. code-block:: none clz.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none clz.u dc:wr64 ra:r32 count_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 zero ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4 zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none cmpb4.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none div_step dc:wr64 ra:r32 db:wr64 shift:u5 div_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none div_step dc:wr64 ra:r32 db:wr64 shift:u5 - div_cc = false - pc = 0 EXTSB +++++ extsb ~~~~~ extsb:rr ^^^^^^^^ *mnemonic* .. code-block:: none extsb rc:wr32 ra:r32 *behavior* .. code-block:: none - x = ra[0:7]:S32 - rc = x - ZF <- x *built-in syntax* * __builtin_extsb_rr(rc, ra) ; extsb:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none extsb rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extsb rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extsb zero ra:r32 *behavior* .. code-block:: none - ZF <- ra[0:7]:S32 *built-in syntax* * __builtin_extsb_zr(zero, ra) ; extsb:zrc ^^^^^^^^^ *mnemonic* .. code-block:: none extsb zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra[0:7]:S32 *built-in syntax* * __builtin_extsb_zrc(zero, ra, log_set_cc) ; extsb:zrci ^^^^^^^^^^ *mnemonic* .. code-block:: none extsb zero ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extsb.s dc:wr64 ra:r32 *behavior* .. code-block:: none - x = ra[0:7]:S32 - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_extsb_s_rr(dc, ra) ; extsb.s:rrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none extsb.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extsb.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extsh rc:wr32 ra:r32 *behavior* .. code-block:: none - x = ra[0:15]:S32 - rc = x - ZF <- x *built-in syntax* * __builtin_extsh_rr(rc, ra) ; extsh:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none extsh rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extsh rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extsh zero ra:r32 *behavior* .. code-block:: none - ZF <- ra[0:15]:S32 *built-in syntax* * __builtin_extsh_zr(zero, ra) ; extsh:zrc ^^^^^^^^^ *mnemonic* .. code-block:: none extsh zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra[0:15]:S32 *built-in syntax* * __builtin_extsh_zrc(zero, ra, log_set_cc) ; extsh:zrci ^^^^^^^^^^ *mnemonic* .. code-block:: none extsh zero ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extsh.s dc:wr64 ra:r32 *behavior* .. code-block:: none - x = ra[0:15]:S32 - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_extsh_s_rr(dc, ra) ; extsh.s:rrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none extsh.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extsh.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extub rc:wr32 ra:r32 *behavior* .. code-block:: none - x = ra[0:7]:U32 - rc = x - ZF <- x *built-in syntax* * __builtin_extub_rr(rc, ra) ; extub:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none extub rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extub rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extub zero ra:r32 *behavior* .. code-block:: none - ZF <- ra[0:7]:U32 *built-in syntax* * __builtin_extub_zr(zero, ra) ; extub:zrc ^^^^^^^^^ *mnemonic* .. code-block:: none extub zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra[0:7]:U32 *built-in syntax* * __builtin_extub_zrc(zero, ra, log_set_cc) ; extub:zrci ^^^^^^^^^^ *mnemonic* .. code-block:: none extub zero ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extub.u dc:wr64 ra:r32 *behavior* .. code-block:: none - x = ra[0:7]:U32 - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_extub_u_rr(dc, ra) ; extub.u:rrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none extub.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extub.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extuh rc:wr32 ra:r32 *behavior* .. code-block:: none - x = ra[0:15]:U32 - rc = x - ZF <- x *built-in syntax* * __builtin_extuh_rr(rc, ra) ; extuh:rrc ^^^^^^^^^ *mnemonic* .. code-block:: none extuh rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extuh rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extuh zero ra:r32 *behavior* .. code-block:: none - ZF <- ra[0:15]:U32 *built-in syntax* * __builtin_extuh_zr(zero, ra) ; extuh:zrc ^^^^^^^^^ *mnemonic* .. code-block:: none extuh zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra[0:15]:U32 *built-in syntax* * __builtin_extuh_zrc(zero, ra, log_set_cc) ; extuh:zrci ^^^^^^^^^^ *mnemonic* .. code-block:: none extuh zero ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none extuh.u dc:wr64 ra:r32 *behavior* .. code-block:: none - x = ra[0:15]:U32 - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_extuh_u_rr(dc, ra) ; extuh.u:rrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none extuh.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none extuh.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra << shift[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_lsl_rri(rc, ra, shift) ; lsl:rric ^^^^^^^^ *mnemonic* .. code-block:: none lsl rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra << rb[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_lsl_rrr(rc, ra, rb) ; lsl:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none lsl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra << shift[0:4] *built-in syntax* * __builtin_lsl_zri(zero, ra, shift) ; lsl:zric ^^^^^^^^ *mnemonic* .. code-block:: none lsl zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra << shift[0:4] *built-in syntax* * __builtin_lsl_zric(zero, ra, shift, log_set_cc) ; lsl:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none lsl zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra << rb[0:4] *built-in syntax* * __builtin_lsl_zrr(zero, ra, rb) ; lsl:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none lsl zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra << rb[0:4] *built-in syntax* * __builtin_lsl_zrrc(zero, ra, rb, log_set_cc) ; lsl:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none lsl zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra << shift[0:4] - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_lsl_s_rri(dc, ra, shift) ; lsl.s:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra << rb[0:4] - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_lsl_s_rrr(dc, ra, rb) ; lsl.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra << shift[0:4] - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_lsl_u_rri(dc, ra, shift) ; lsl.u:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra << rb[0:4] - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_lsl_u_rrr(dc, ra, rb) ; lsl.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add rc:wr32 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add zero rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_lsl_add_zrri(zero, rb, ra, shift) ; lsl_add:zrrici ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none lsl_add zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub rc:wr32 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub zero rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_lsl_sub_zrri(zero, rb, ra, shift) ; lsl_sub:zrrici ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none lsl_sub zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub.s dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub.u dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl_sub.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra << shift[0:4] padded with ones - rc = x - ZF <- x *built-in syntax* * __builtin_lsl1_rri(rc, ra, shift) ; lsl1:rric ^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra << rb[0:4] padded with ones - rc = x - ZF <- x *built-in syntax* * __builtin_lsl1_rrr(rc, ra, rb) ; lsl1:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra << shift[0:4] padded with ones *built-in syntax* * __builtin_lsl1_zri(zero, ra, shift) ; lsl1:zric ^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra << shift[0:4] padded with ones *built-in syntax* * __builtin_lsl1_zric(zero, ra, shift, log_set_cc) ; lsl1:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1 zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra << rb[0:4] padded with ones *built-in syntax* * __builtin_lsl1_zrr(zero, ra, rb) ; lsl1:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra << rb[0:4] padded with ones *built-in syntax* * __builtin_lsl1_zrrc(zero, ra, rb, log_set_cc) ; lsl1:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none lsl1 zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsl1x.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lslx.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra >> shift[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_lsr_rri(rc, ra, shift) ; lsr:rric ^^^^^^^^ *mnemonic* .. code-block:: none lsr rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >> rb[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_lsr_rrr(rc, ra, rb) ; lsr:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none lsr rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra >> shift[0:4] *built-in syntax* * __builtin_lsr_zri(zero, ra, shift) ; lsr:zric ^^^^^^^^ *mnemonic* .. code-block:: none lsr zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >> shift[0:4] *built-in syntax* * __builtin_lsr_zric(zero, ra, shift, log_set_cc) ; lsr:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none lsr zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra >> rb[0:4] *built-in syntax* * __builtin_lsr_zrr(zero, ra, rb) ; lsr:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none lsr zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >> rb[0:4] *built-in syntax* * __builtin_lsr_zrrc(zero, ra, rb, log_set_cc) ; lsr:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none lsr zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra >> shift[0:4] - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_lsr_s_rri(dc, ra, shift) ; lsr.s:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >> rb[0:4] - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_lsr_s_rrr(dc, ra, rb) ; lsr.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra >> shift[0:4] - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_lsr_u_rri(dc, ra, shift) ; lsr.u:rric ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >> rb[0:4] - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_lsr_u_rrr(dc, ra, rb) ; lsr.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add rc:wr32 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add rc:wr32 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add zero rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_lsr_add_zrri(zero, rb, ra, shift) ; lsr_add:zrrici ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none lsr_add zero rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add.s dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr_add.u dc:wr64 rb:wr32 ra:r32 shift:u5 div_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra >> shift[0:4] padded with ones - rc = x - ZF <- x *built-in syntax* * __builtin_lsr1_rri(rc, ra, shift) ; lsr1:rric ^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >> rb[0:4] padded with ones - rc = x - ZF <- x *built-in syntax* * __builtin_lsr1_rrr(rc, ra, rb) ; lsr1:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra >> shift[0:4] padded with ones *built-in syntax* * __builtin_lsr1_zri(zero, ra, shift) ; lsr1:zric ^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >> shift[0:4] padded with ones *built-in syntax* * __builtin_lsr1_zric(zero, ra, shift, log_set_cc) ; lsr1:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1 zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra >> rb[0:4] padded with ones *built-in syntax* * __builtin_lsr1_zrr(zero, ra, rb) ; lsr1:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >> rb[0:4] padded with ones *built-in syntax* * __builtin_lsr1_zrrc(zero, ra, rb, log_set_cc) ; lsr1:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none lsr1 zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsr1x.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none lsrx.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[8:15]):S32 *built-in syntax* * __builtin_mul_sh_sh_zrr(zero, ra, rb) ; mul_sh_sh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sh_sh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[0:7]):S32 *built-in syntax* * __builtin_mul_sh_sl_zrr(zero, ra, rb) ; mul_sh_sl:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sh_sl zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_sl.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[8:15]):S32 *built-in syntax* * __builtin_mul_sh_uh_zrr(zero, ra, rb) ; mul_sh_uh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sh_uh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_uh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[0:7]):S32 *built-in syntax* * __builtin_mul_sh_ul_zrr(zero, ra, rb) ; mul_sh_ul:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sh_ul zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sh_ul.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[8:15]):S32 *built-in syntax* * __builtin_mul_sl_sh_zrr(zero, ra, rb) ; mul_sl_sh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sl_sh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[0:7]):S32 *built-in syntax* * __builtin_mul_sl_sl_zrr(zero, ra, rb) ; mul_sl_sl:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sl_sl zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_sl.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[8:15]):S32 *built-in syntax* * __builtin_mul_sl_uh_zrr(zero, ra, rb) ; mul_sl_uh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sl_uh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_uh.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[0:7]):S32 *built-in syntax* * __builtin_mul_sl_ul_zrr(zero, ra, rb) ; mul_sl_ul:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_sl_ul zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_sl_ul.s dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_step dc:wr64 ra:r32 db:wr64 shift:u5 boot_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_step dc:wr64 ra:r32 db:wr64 shift:u5 - boot_cc = false - pc = 0 mul_uh_uh ~~~~~~~~~ mul_uh_uh:rrr ^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_uh_uh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[8:15]):U32 *built-in syntax* * __builtin_mul_uh_uh_zrr(zero, ra, rb) ; mul_uh_uh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_uh_uh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_uh.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[8:15] * rb[0:7]):U32 *built-in syntax* * __builtin_mul_uh_ul_zrr(zero, ra, rb) ; mul_uh_ul:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_uh_ul zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_uh_ul.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[8:15]):U32 *built-in syntax* * __builtin_mul_ul_uh_zrr(zero, ra, rb) ; mul_ul_uh:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_ul_uh zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_uh.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul rc:wr32 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- (ra[0:7] * rb[0:7]):U32 *built-in syntax* * __builtin_mul_ul_ul_zrr(zero, ra, rb) ; mul_ul_ul:zrrc ^^^^^^^^^^^^^^ *mnemonic* .. code-block:: none mul_ul_ul zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul zero ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none mul_ul_ul.u dc:wr64 ra:r32 rb:wr32 mul_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra & imm) - rc = x - ZF <- x *built-in syntax* * __builtin_nand_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none nand rc:wr32 ra:r32 imm:s24 - false_cc = false nand:rrr ^^^^^^^^ *mnemonic* .. code-block:: none nand rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra & rb) - rc = x - ZF <- x *built-in syntax* * __builtin_nand_rrr(rc, ra, rb) ; nand:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none nand rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra & imm) *built-in syntax* * __builtin_nand_zric(zero, ra, imm, log_set_cc) ; nand:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none nand zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra & imm) *built-in syntax* * __builtin_nand_zrif(zero, ra, imm, false_cc) ; nand:zrr ^^^^^^^^ *mnemonic* .. code-block:: none nand zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ~(ra & rb) *built-in syntax* * __builtin_nand_zrr(zero, ra, rb) ; nand:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none nand zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra & rb) *built-in syntax* * __builtin_nand_zrrc(zero, ra, rb, log_set_cc) ; nand:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none nand zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra & imm) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nand_s_rrif(dc, ra, imm, false_cc) ; nand.s:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none nand.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra & rb) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nand_s_rrr(dc, ra, rb) ; nand.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none nand.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nand.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra & imm) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nand_u_rrif(dc, ra, imm, false_cc) ; nand.u:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none nand.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra & rb) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nand_u_rrr(dc, ra, rb) ; nand.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none nand.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nand.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra | imm) - rc = x - ZF <- x *built-in syntax* * __builtin_nor_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none nor rc:wr32 ra:r32 imm:s24 - false_cc = false nor:rrr ^^^^^^^ *mnemonic* .. code-block:: none nor rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra | rb) - rc = x - ZF <- x *built-in syntax* * __builtin_nor_rrr(rc, ra, rb) ; nor:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none nor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra | imm) *built-in syntax* * __builtin_nor_zric(zero, ra, imm, log_set_cc) ; nor:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none nor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra | imm) *built-in syntax* * __builtin_nor_zrif(zero, ra, imm, false_cc) ; nor:zrr ^^^^^^^ *mnemonic* .. code-block:: none nor zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ~(ra | rb) *built-in syntax* * __builtin_nor_zrr(zero, ra, rb) ; nor:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none nor zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra | rb) *built-in syntax* * __builtin_nor_zrrc(zero, ra, rb, log_set_cc) ; nor:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none nor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra | imm) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nor_s_rrif(dc, ra, imm, false_cc) ; nor.s:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none nor.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra | rb) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nor_s_rrr(dc, ra, rb) ; nor.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none nor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nor.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra | imm) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nor_u_rrif(dc, ra, imm, false_cc) ; nor.u:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none nor.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra | rb) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nor_u_rrr(dc, ra, rb) ; nor.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none nor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra ^ imm) - rc = x - ZF <- x *built-in syntax* * __builtin_nxor_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none nxor rc:wr32 ra:r32 imm:s24 - false_cc = false nxor:rrr ^^^^^^^^ *mnemonic* .. code-block:: none nxor rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra ^ rb) - rc = x - ZF <- x *built-in syntax* * __builtin_nxor_rrr(rc, ra, rb) ; nxor:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none nxor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra ^ imm) *built-in syntax* * __builtin_nxor_zric(zero, ra, imm, log_set_cc) ; nxor:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none nxor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra ^ imm) *built-in syntax* * __builtin_nxor_zrif(zero, ra, imm, false_cc) ; nxor:zrr ^^^^^^^^ *mnemonic* .. code-block:: none nxor zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ~(ra ^ rb) *built-in syntax* * __builtin_nxor_zrr(zero, ra, rb) ; nxor:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none nxor zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~(ra ^ rb) *built-in syntax* * __builtin_nxor_zrrc(zero, ra, rb, log_set_cc) ; nxor:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none nxor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra ^ imm) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nxor_s_rrif(dc, ra, imm, false_cc) ; nxor.s:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none nxor.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra ^ rb) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_nxor_s_rrr(dc, ra, rb) ; nxor.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none nxor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none nxor.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~(ra ^ imm) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nxor_u_rrif(dc, ra, imm, false_cc) ; nxor.u:rrr ^^^^^^^^^^ *mnemonic* .. code-block:: none nxor.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~(ra ^ rb) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_nxor_u_rrr(dc, ra, rb) ; nxor.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none nxor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none nxor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none or rc:wr32 ra:r32 imm:u32 *behavior* .. code-block:: none - rc = (ra | imm) - ZF <- rc *built-in syntax* * __builtin_or_rri(rc, ra, imm) ; *syntactic sugars* .. code-block:: none move rc:wr32 imm:u32 - ra = zero or:rric ^^^^^^^ *mnemonic* .. code-block:: none or rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none move rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 - imm = 0 .. code-block:: none move rc:wr32 imm:s8 log_nz_cc:cc pc:pc16 - ra = zero or:rrif ^^^^^^^ *mnemonic* .. code-block:: none or rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra | imm - rc = x - ZF <- x *built-in syntax* * __builtin_or_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none move rc:wr32 ra:r32 - imm = 0 - false_cc = false or:rrr ^^^^^^ *mnemonic* .. code-block:: none or rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra | rb - rc = x - ZF <- x *built-in syntax* * __builtin_or_rrr(rc, ra, rb) ; or:rrrc ^^^^^^^ *mnemonic* .. code-block:: none or rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none or zero rb:wr32 imm:u32 *behavior* .. code-block:: none - ZF <- rb | imm *built-in syntax* * __builtin_or_zri(zero, rb, imm) ; or:zric ^^^^^^^ *mnemonic* .. code-block:: none or zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra | imm *built-in syntax* * __builtin_or_zric(zero, ra, imm, log_set_cc) ; or:zrici ^^^^^^^^ *mnemonic* .. code-block:: none or zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none or zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ra | imm *built-in syntax* * __builtin_or_zrif(zero, ra, imm, false_cc) ; or:zrr ^^^^^^ *mnemonic* .. code-block:: none or zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra | rb *built-in syntax* * __builtin_or_zrr(zero, ra, rb) ; or:zrrc ^^^^^^^ *mnemonic* .. code-block:: none or zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra | rb *built-in syntax* * __builtin_or_zrrc(zero, ra, rb, log_set_cc) ; or:zrrci ^^^^^^^^ *mnemonic* .. code-block:: none or zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none or.s dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb | imm):S64 - ZF <- dc *built-in syntax* * __builtin_or_s_rri(dc, rb, imm) ; or.s:rric ^^^^^^^^^ *mnemonic* .. code-block:: none or.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none move.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 - imm = 0 .. code-block:: none move.s dc:wr64 imm:s8 log_nz_cc:cc pc:pc16 - ra = zero or.s:rrif ^^^^^^^^^ *mnemonic* .. code-block:: none or.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra | imm - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_or_s_rrif(dc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none move.s dc:wr64 ra:r32 - imm = 0 - false_cc = false or.s:rrr ^^^^^^^^ *mnemonic* .. code-block:: none or.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra | rb - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_or_s_rrr(dc, ra, rb) ; or.s:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none or.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none or.u dc:wr64 rb:wr32 imm:u32 *behavior* .. code-block:: none - dc = (rb | imm):U64 - ZF <- dc *built-in syntax* * __builtin_or_u_rri(dc, rb, imm) ; or.u:rric ^^^^^^^^^ *mnemonic* .. code-block:: none or.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none move.u dc:wr64 imm:s8 log_nz_cc:cc pc:pc16 - ra = zero .. code-block:: none move.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 - imm = 0 or.u:rrif ^^^^^^^^^ *mnemonic* .. code-block:: none or.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra | imm - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_or_u_rrif(dc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none move.u dc:wr64 ra:r32 - imm = 0 - false_cc = false or.u:rrr ^^^^^^^^ *mnemonic* .. code-block:: none or.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra | rb - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_or_u_rrr(dc, ra, rb) ; or.u:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none or.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none or.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra | imm - rc = x - ZF <- x *built-in syntax* * __builtin_orn_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none orn rc:wr32 ra:r32 imm:s24 - false_cc = false orn:rrr ^^^^^^^ *mnemonic* .. code-block:: none orn rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra | rb - rc = x - ZF <- x *built-in syntax* * __builtin_orn_rrr(rc, ra, rb) ; orn:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none orn rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~ra | imm *built-in syntax* * __builtin_orn_zric(zero, ra, imm, log_set_cc) ; orn:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none orn zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ~ra | imm *built-in syntax* * __builtin_orn_zrif(zero, ra, imm, false_cc) ; orn:zrr ^^^^^^^ *mnemonic* .. code-block:: none orn zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ~ra | rb *built-in syntax* * __builtin_orn_zrr(zero, ra, rb) ; orn:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none orn zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ~ra | rb *built-in syntax* * __builtin_orn_zrrc(zero, ra, rb, log_set_cc) ; orn:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none orn zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra | imm - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_orn_s_rrif(dc, ra, imm, false_cc) ; orn.s:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none orn.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra | rb - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_orn_s_rrr(dc, ra, rb) ; orn.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none orn.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none orn.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ~ra | imm - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_orn_u_rrif(dc, ra, imm, false_cc) ; orn.u:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none orn.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ~ra | rb - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_orn_u_rrr(dc, ra, rb) ; orn.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none orn.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none orn.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rol rc:wr32 ra:r32 shift:u5 *behavior* .. code-block:: none - x = ra <>r shift[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_ror_rri(rc, ra, shift) ; ror:rric ^^^^^^^^ *mnemonic* .. code-block:: none ror rc:wr32 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror rc:wr32 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra >>r rb[0:4] - rc = x - ZF <- x *built-in syntax* * __builtin_ror_rrr(rc, ra, rb) ; ror:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none ror rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror rc:wr32 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror zero ra:r32 shift:u5 *behavior* .. code-block:: none - ZF <- ra >>r shift[0:4] *built-in syntax* * __builtin_ror_zri(zero, ra, shift) ; ror:zric ^^^^^^^^ *mnemonic* .. code-block:: none ror zero ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >>r shift[0:4] *built-in syntax* * __builtin_ror_zric(zero, ra, shift, log_set_cc) ; ror:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none ror zero ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra >>r rb[0:4] *built-in syntax* * __builtin_ror_zrr(zero, ra, rb) ; ror:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none ror zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra >>r rb[0:4] *built-in syntax* * __builtin_ror_zrrc(zero, ra, rb, log_set_cc) ; ror:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none ror zero ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror.s dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 shift:u5 *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 shift:u5 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 shift:u5 imm_shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none ror.u dc:wr64 ra:r32 rb:wr32 shift_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsub rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb - ra - rc = x - ZF,CF <- x *built-in syntax* * __builtin_rsub_rrr(rc, ra, rb) ; rsub:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none rsub rc:wr32 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsub rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsub zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- rb - ra *built-in syntax* * __builtin_rsub_zrr(zero, ra, rb) ; rsub:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none rsub zero ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- rb - ra *built-in syntax* * __builtin_rsub_zrrc(zero, ra, rb, sub_set_cc) ; rsub:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none rsub zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsub.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb - ra - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_rsub_s_rrr(dc, ra, rb) ; rsub.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none rsub.s dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsub.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsub.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb - ra - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_rsub_u_rrr(dc, ra, rb) ; rsub.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none rsub.u dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsub.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsubc rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb + ~ra + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_rsubc_rrr(rc, ra, rb) ; rsubc:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none rsubc rc:wr32 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsubc rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsubc zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- rb + ~ra + CF *built-in syntax* * __builtin_rsubc_zrr(zero, ra, rb) ; rsubc:zrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none rsubc zero ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- rb + ~ra + CF *built-in syntax* * __builtin_rsubc_zrrc(zero, ra, rb, sub_set_cc) ; rsubc:zrrci ^^^^^^^^^^^ *mnemonic* .. code-block:: none rsubc zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsubc.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb + ~ra + CF - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_rsubc_s_rrr(dc, ra, rb) ; rsubc.s:rrrc ^^^^^^^^^^^^ *mnemonic* .. code-block:: none rsubc.s dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsubc.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none rsubc.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = rb + ~ra + CF - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_rsubc_u_rrr(dc, ra, rb) ; rsubc.u:rrrc ^^^^^^^^^^^^ *mnemonic* .. code-block:: none rsubc.u dc:wr64 ra:r32 rb:wr32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none rsubc.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub rc:wr32 imm:u32 ra:r32 *behavior* .. code-block:: none - rc = (imm - ra) - ZF,CF <- rc *built-in syntax* * __builtin_sub_rir(rc, imm, ra) ; *syntactic sugars* .. code-block:: none neg rc:wr32 ra:r32 - imm = 0 sub:rirc ^^^^^^^^ *mnemonic* .. code-block:: none sub rc:wr32 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub rc:wr32 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none neg rc:wr32 ra:r32 sub_nz_cc:cc pc:pc16 - imm = 0 sub:rirf ^^^^^^^^ *mnemonic* .. code-block:: none sub rc:wr32 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - x = imm - ra - rc = x - ZF,CF <- x *built-in syntax* * __builtin_sub_rirf(rc, imm, ra, false_cc) ; sub:rric ^^^^^^^^ *mnemonic* .. code-block:: none sub rc:wr32 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub rc:wr32 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra - imm - rc = x - ZF,CF <- x *built-in syntax* * __builtin_sub_rrif(rc, ra, imm, false_cc) ; sub:rrr ^^^^^^^ *mnemonic* .. code-block:: none sub rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra - rb - rc = x - ZF,CF <- x *built-in syntax* * __builtin_sub_rrr(rc, ra, rb) ; sub:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none sub rc:wr32 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub sc:wr32 sa:r32 imm:s17 *behavior* .. code-block:: none - 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* .. code-block:: none subs rc:wr32 ra:r32 imm:s17 sub:sss ^^^^^^^ *mnemonic* .. code-block:: none sub sc:wr32 sa:r32 sb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none subs rc:wr32 ra:r32 rb:wr32 sub:zir ^^^^^^^ *mnemonic* .. code-block:: none sub zero imm:u32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- imm - rb *built-in syntax* * __builtin_sub_zir(zero, imm, rb) ; sub:zirc ^^^^^^^^ *mnemonic* .. code-block:: none sub zero imm:s27 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- imm - ra *built-in syntax* * __builtin_sub_zirc(zero, imm, ra, sub_set_cc) ; sub:zirci ^^^^^^^^^ *mnemonic* .. code-block:: none sub zero imm:s11 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub zero imm:s27 ra:r32 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- imm - ra *built-in syntax* * __builtin_sub_zirf(zero, imm, ra, false_cc) ; sub:zric ^^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 imm:s27 ext_sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra - imm *built-in syntax* * __builtin_sub_zric(zero, ra, imm, ext_sub_set_cc) ; sub:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 imm:s11 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none jeq ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = z .. code-block:: none jneq ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = nz .. code-block:: none jz ra:r32 pc:pc16 - zero = zero - imm = 0 - sub_nz_cc = z .. code-block:: none jnz ra:r32 pc:pc16 - zero = zero - imm = 0 - sub_nz_cc = nz .. code-block:: none jltu ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = ltu .. code-block:: none jgtu ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = gtu .. code-block:: none jleu ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = leu .. code-block:: none jgeu ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = geu .. code-block:: none jlts ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = lts .. code-block:: none jgts ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = gts .. code-block:: none jles ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = les .. code-block:: none jges ra:r32 imm:s11 pc:pc16 - zero = zero - sub_nz_cc = ges sub:zrif ^^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 imm:s27 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra - imm *built-in syntax* * __builtin_sub_zrif(zero, ra, imm, false_cc) ; sub:zrr ^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- ra - rb *built-in syntax* * __builtin_sub_zrr(zero, ra, rb) ; sub:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra - rb *built-in syntax* * __builtin_sub_zrrc(zero, ra, rb, ext_sub_set_cc) ; sub:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none sub zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none jeq ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = z .. code-block:: none jneq ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = nz .. code-block:: none jltu ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = ltu .. code-block:: none jgtu ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = gtu .. code-block:: none jleu ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = leu .. code-block:: none jgeu ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = geu .. code-block:: none jlts ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = lts .. code-block:: none jgts ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = gts .. code-block:: none jles ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = les .. code-block:: none jges ra:r32 rb:wr32 pc:pc16 - zero = zero - sub_nz_cc = ges sub.s ~~~~~ sub.s:rirc ^^^^^^^^^^ *mnemonic* .. code-block:: none sub.s dc:wr64 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra - rb - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_sub_s_rrr(dc, ra, rb) ; sub.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none sub.s dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra - rb - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_sub_u_rrr(dc, ra, rb) ; sub.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none sub.u dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sub.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 imm:u32 ra:r32 *behavior* .. code-block:: none - rc = (imm + ~ra + CF) - ZF,CF <- rc *built-in syntax* * __builtin_subc_rir(rc, imm, ra) ; subc:rirc ^^^^^^^^^ *mnemonic* .. code-block:: none subc rc:wr32 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - x = imm + ~ra + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_subc_rirf(rc, imm, ra, false_cc) ; subc:rric ^^^^^^^^^ *mnemonic* .. code-block:: none subc rc:wr32 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra + ~imm + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_subc_rrif(rc, ra, imm, false_cc) ; subc:rrr ^^^^^^^^ *mnemonic* .. code-block:: none subc rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + ~rb + CF - rc = x - ZF,CF <- x *built-in syntax* * __builtin_subc_rrr(rc, ra, rb) ; subc:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none subc rc:wr32 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc rc:wr32 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc zero imm:u32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- imm + ~rb + CF *built-in syntax* * __builtin_subc_zir(zero, imm, rb) ; subc:zirc ^^^^^^^^^ *mnemonic* .. code-block:: none subc zero imm:s27 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- imm + ~ra + CF *built-in syntax* * __builtin_subc_zirc(zero, imm, ra, sub_set_cc) ; subc:zirci ^^^^^^^^^^ *mnemonic* .. code-block:: none subc zero imm:s11 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc zero imm:s27 ra:r32 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- imm + ~ra + CF *built-in syntax* * __builtin_subc_zirf(zero, imm, ra, false_cc) ; subc:zric ^^^^^^^^^ *mnemonic* .. code-block:: none subc zero ra:r32 imm:s27 ext_sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + ~imm + CF *built-in syntax* * __builtin_subc_zric(zero, ra, imm, ext_sub_set_cc) ; subc:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none subc zero ra:r32 imm:s11 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc zero ra:r32 imm:s27 false_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + ~imm + CF *built-in syntax* * __builtin_subc_zrif(zero, ra, imm, false_cc) ; subc:zrr ^^^^^^^^ *mnemonic* .. code-block:: none subc zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF,CF <- ra + ~rb + CF *built-in syntax* * __builtin_subc_zrr(zero, ra, rb) ; subc:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none subc zero ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - ZF,CF <- ra + ~rb + CF *built-in syntax* * __builtin_subc_zrrc(zero, ra, rb, ext_sub_set_cc) ; subc:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none subc zero ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + ~rb + CF - dc = x:S64 - ZF,CF <- x *built-in syntax* * __builtin_subc_s_rrr(dc, ra, rb) ; subc.s:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none subc.s dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.s dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 imm:s24 ra:r32 sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 imm:s8 ra:r32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 imm:s24 ra:r32 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 ra:r32 imm:s24 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 ra:r32 imm:s8 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra + ~rb + CF - dc = x:U64 - ZF,CF <- x *built-in syntax* * __builtin_subc_u_rrr(dc, ra, rb) ; subc.u:rrrc ^^^^^^^^^^^ *mnemonic* .. code-block:: none subc.u dc:wr64 ra:r32 rb:wr32 ext_sub_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none subc.u dc:wr64 ra:r32 rb:wr32 sub_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor rc:wr32 ra:r32 imm:u32 *behavior* .. code-block:: none - rc = (ra ^ imm) - ZF <- rc *built-in syntax* * __builtin_xor_rri(rc, ra, imm) ; *syntactic sugars* .. code-block:: none not rc:wr32 ra:r32 - imm = -1 xor:rric ^^^^^^^^ *mnemonic* .. code-block:: none xor rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none not rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 - imm = -1 xor:rrif ^^^^^^^^ *mnemonic* .. code-block:: none xor rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra ^ imm - rc = x - ZF <- x *built-in syntax* * __builtin_xor_rrif(rc, ra, imm, false_cc) ; xor:rrr ^^^^^^^ *mnemonic* .. code-block:: none xor rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra ^ rb - rc = x - ZF <- x *built-in syntax* * __builtin_xor_rrr(rc, ra, rb) ; xor:rrrc ^^^^^^^^ *mnemonic* .. code-block:: none xor rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor zero rb:wr32 imm:u32 *behavior* .. code-block:: none - ZF <- rb ^ imm *built-in syntax* * __builtin_xor_zri(zero, rb, imm) ; xor:zric ^^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra ^ imm *built-in syntax* * __builtin_xor_zric(zero, ra, imm, log_set_cc) ; xor:zrici ^^^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none not ra:r32 log_nz_cc:cc pc:pc16 - zero = zero - imm = -1 xor:zrif ^^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- ra ^ imm *built-in syntax* * __builtin_xor_zrif(zero, ra, imm, false_cc) ; xor:zrr ^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- ra ^ rb *built-in syntax* * __builtin_xor_zrr(zero, ra, rb) ; xor:zrrc ^^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- ra ^ rb *built-in syntax* * __builtin_xor_zrrc(zero, ra, rb, log_set_cc) ; xor:zrrci ^^^^^^^^^ *mnemonic* .. code-block:: none xor zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra ^ imm - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_xor_s_rrif(dc, ra, imm, false_cc) ; xor.s:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none xor.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra ^ rb - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_xor_s_rrr(dc, ra, rb) ; xor.s:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none xor.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none xor.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = ra ^ imm - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_xor_u_rrif(dc, ra, imm, false_cc) ; xor.u:rrr ^^^^^^^^^ *mnemonic* .. code-block:: none xor.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = ra ^ rb - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_xor_u_rrr(dc, ra, rb) ; xor.u:rrrc ^^^^^^^^^^ *mnemonic* .. code-block:: none xor.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none xor.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none boot ra:r32 imm:s8 boot_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none boot ra:r32 imm:s8 - boot_cc = false - pc = 0 RESUME ++++++ resume:rici ~~~~~~~~~~~ *mnemonic* .. code-block:: none resume ra:r32 imm:s8 boot_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none resume ra:r32 imm:s8 - boot_cc = false - pc = 0 STOP ++++ stop:ci ~~~~~~~ *mnemonic* .. code-block:: none stop boot_cc:cc pc:pc16 *behavior* .. code-block:: none - if (boot_cc 1) then - jump @[pc] - stop current thread *built-in syntax* * __builtin_stop_ci(boot_cc, pc) ; *syntactic sugars* .. code-block:: none stop - boot_cc = false - pc = 0 Flow Control ------------ CALL ++++ call:rri ~~~~~~~~ *mnemonic* .. code-block:: none call rc:wr32 ra:r32 off:pc24 *behavior* .. code-block:: none - rc = call @[ra + off] *built-in syntax* * __builtin_call_rri(rc, ra, off) ; *syntactic sugars* .. code-block:: none call rc:wr32 ra:r32 - off = 0 .. code-block:: none call rc:wr32 off:pc24 - ra = zero call:rrr ~~~~~~~~ *mnemonic* .. code-block:: none call rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - rc = call @[ra + rb] *built-in syntax* * __builtin_call_rrr(rc, ra, rb) ; call:zri ~~~~~~~~ *mnemonic* .. code-block:: none call zero ra:r32 off:pc28 *behavior* .. code-block:: none - call @[ra + off] *built-in syntax* * __builtin_call_zri(zero, ra, off) ; *syntactic sugars* .. code-block:: none jump ra:r32 off:pc28 - zero = zero .. code-block:: none jump off:pc28 - zero = zero - ra = zero .. code-block:: none jump ra:r32 - zero = zero - off = 0 call:zrr ~~~~~~~~ *mnemonic* .. code-block:: none call zero ra:r32 rb:wr32 *behavior* .. code-block:: none - call @[ra + rb] *built-in syntax* * __builtin_call_zrr(zero, ra, rb) ; Miscellaneous ------------- FAULT +++++ fault:i ~~~~~~~ *mnemonic* .. code-block:: none fault imm:s24 *behavior* .. code-block:: none - raise fault *built-in syntax* * __builtin_fault_i(imm) ; *syntactic sugars* .. code-block:: none bkp - imm = 0 NOP +++ nop: ~~~~ *mnemonic* .. code-block:: none nop *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_nop_() ; SATS ++++ sats ~~~~ sats:rr ^^^^^^^ *mnemonic* .. code-block:: none sats rc:wr32 ra:r32 *behavior* .. code-block:: none - x = sats(ra) - rc = x - ZF <- x *built-in syntax* * __builtin_sats_rr(rc, ra) ; sats:rrc ^^^^^^^^ *mnemonic* .. code-block:: none sats rc:wr32 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sats rc:wr32 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sats zero ra:r32 *behavior* .. code-block:: none - ZF <- sats(ra) *built-in syntax* * __builtin_sats_zr(zero, ra) ; sats:zrc ^^^^^^^^ *mnemonic* .. code-block:: none sats zero ra:r32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- sats(ra) *built-in syntax* * __builtin_sats_zrc(zero, ra, log_set_cc) ; sats:zrci ^^^^^^^^^ *mnemonic* .. code-block:: none sats zero ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sats.s dc:wr64 ra:r32 *behavior* .. code-block:: none - x = sats(ra) - dc = x:S64 - ZF <- x *built-in syntax* * __builtin_sats_s_rr(dc, ra) ; sats.s:rrc ^^^^^^^^^^ *mnemonic* .. code-block:: none sats.s dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sats.s dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none sats.u dc:wr64 ra:r32 *behavior* .. code-block:: none - x = sats(ra) - dc = x:U64 - ZF <- x *built-in syntax* * __builtin_sats_u_rr(dc, ra) ; sats.u:rrc ^^^^^^^^^^ *mnemonic* .. code-block:: none sats.u dc:wr64 ra:r32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none sats.u dc:wr64 ra:r32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash rc:wr32 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash rc:wr32 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash rc:wr32 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - x = hash(ra,imm[0:3]) - rc = x - ZF <- x *built-in syntax* * __builtin_hash_rrif(rc, ra, imm, false_cc) ; *syntactic sugars* .. code-block:: none hash rc:wr32 ra:r32 imm:s24 - false_cc = false hash:rrr ^^^^^^^^ *mnemonic* .. code-block:: none hash rc:wr32 ra:r32 rb:wr32 *behavior* .. code-block:: none - x = hash(ra,rb[0:3]) - rc = x - ZF <- x *built-in syntax* * __builtin_hash_rrr(rc, ra, rb) ; hash:rrrc ^^^^^^^^^ *mnemonic* .. code-block:: none hash rc:wr32 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash rc:wr32 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash zero ra:r32 imm:s28 log_set_cc:cc *behavior* .. code-block:: none - ZF <- hash(ra,imm[0:3]) *built-in syntax* * __builtin_hash_zric(zero, ra, imm, log_set_cc) ; hash:zrici ^^^^^^^^^^ *mnemonic* .. code-block:: none hash zero ra:r32 imm:s12 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash zero ra:r32 imm:s28 false_cc:cc *behavior* .. code-block:: none - ZF <- hash(ra,imm[0:3]) *built-in syntax* * __builtin_hash_zrif(zero, ra, imm, false_cc) ; hash:zrr ^^^^^^^^ *mnemonic* .. code-block:: none hash zero ra:r32 rb:wr32 *behavior* .. code-block:: none - ZF <- hash(ra,rb[0:3]) *built-in syntax* * __builtin_hash_zrr(zero, ra, rb) ; hash:zrrc ^^^^^^^^^ *mnemonic* .. code-block:: none hash zero ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - ZF <- hash(ra,rb[0:3]) *built-in syntax* * __builtin_hash_zrrc(zero, ra, rb, log_set_cc) ; hash:zrrci ^^^^^^^^^^ *mnemonic* .. code-block:: none hash zero ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.s dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 imm:s24 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 imm:s8 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 imm:s24 false_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 rb:wr32 log_set_cc:cc *behavior* .. code-block:: none - 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* .. code-block:: none hash.u dc:wr64 ra:r32 rb:wr32 log_nz_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none movd dc:wr64 db:wr64 true_false_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none movd dc:wr64 db:wr64 - true_false_cc = false - pc = 0 SWAPD +++++ swapd:rrci ~~~~~~~~~~ *mnemonic* .. code-block:: none swapd dc:wr64 db:wr64 true_false_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none swapd dc:wr64 db:wr64 - true_false_cc = false - pc = 0 TIME ++++ time ~~~~ time:r ^^^^^^ *mnemonic* .. code-block:: none time rc:wr32 *behavior* .. code-block:: none - x = (T:read)[4:35] - rc = x *built-in syntax* * __builtin_time_r(rc) ; time:rci ^^^^^^^^ *mnemonic* .. code-block:: none time rc:wr32 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time zero *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_time_z(zero) ; time:zci ^^^^^^^^ *mnemonic* .. code-block:: none time zero true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time.s dc:wr64 *behavior* .. code-block:: none - x = (T:read)[4:35] - dc = x:S64 *built-in syntax* * __builtin_time_s_r(dc) ; time.s:rci ^^^^^^^^^^ *mnemonic* .. code-block:: none time.s dc:wr64 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time.u dc:wr64 *behavior* .. code-block:: none - x = (T:read)[4:35] - dc = x:U64 *built-in syntax* * __builtin_time_u_r(dc) ; time.u:rci ^^^^^^^^^^ *mnemonic* .. code-block:: none time.u dc:wr64 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg rc:wr32 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg rc:wr32 rb:wr32 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg zero rb:wr32 *behavior* .. code-block:: none - instruction with no effect *built-in syntax* * __builtin_time_cfg_zr(zero, rb) ; *syntactic sugars* .. code-block:: none time_cfg rb:wr32 - zero = zero time_cfg:zrci ^^^^^^^^^^^^^ *mnemonic* .. code-block:: none time_cfg zero rb:wr32 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg.s dc:wr64 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg.s dc:wr64 rb:wr32 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg.u dc:wr64 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none time_cfg.u dc:wr64 rb:wr32 true_cc:cc pc:pc16 *behavior* .. code-block:: none - 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* .. code-block:: none lbs endian:e rc:wr32 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbs rc:wr32 ra:r32 off:s24 - endian = !little lbs:ersi ^^^^^^^^ *mnemonic* .. code-block:: none lbs endian:e rc:wr32 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbss rc:wr32 ra:r32 off:s24 - endian = !little lbs.s ~~~~~ lbs.s:erri ^^^^^^^^^^ *mnemonic* .. code-block:: none lbs.s endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbs.s dc:wr64 ra:r32 off:s24 - endian = !little LBU +++ lbu ~~~ lbu:erri ^^^^^^^^ *mnemonic* .. code-block:: none lbu endian:e rc:wr32 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbu rc:wr32 ra:r32 off:s24 - endian = !little lbu:ersi ^^^^^^^^ *mnemonic* .. code-block:: none lbu endian:e rc:wr32 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbus rc:wr32 ra:r32 off:s24 - endian = !little lbu.u ~~~~~ lbu.u:erri ^^^^^^^^^^ *mnemonic* .. code-block:: none lbu.u endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lbu.u dc:wr64 ra:r32 off:s24 - endian = !little LD ++ ld:erri ~~~~~~~ *mnemonic* .. code-block:: none ld endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none ld dc:wr64 ra:r32 off:s24 - endian = !little ld:ersi ~~~~~~~ *mnemonic* .. code-block:: none ld endian:e dc:wr64 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lds dc:wr64 ra:r32 off:s24 - endian = !little LHS +++ lhs ~~~ lhs:erri ^^^^^^^^ *mnemonic* .. code-block:: none lhs endian:e rc:wr32 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhs rc:wr32 ra:r32 off:s24 - endian = !little lhs:ersi ^^^^^^^^ *mnemonic* .. code-block:: none lhs endian:e rc:wr32 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhss rc:wr32 ra:r32 off:s24 - endian = !little lhs.s ~~~~~ lhs.s:erri ^^^^^^^^^^ *mnemonic* .. code-block:: none lhs.s endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhs.s dc:wr64 ra:r32 off:s24 - endian = !little LHU +++ lhu ~~~ lhu:erri ^^^^^^^^ *mnemonic* .. code-block:: none lhu endian:e rc:wr32 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhu rc:wr32 ra:r32 off:s24 - endian = !little lhu:ersi ^^^^^^^^ *mnemonic* .. code-block:: none lhu endian:e rc:wr32 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhus rc:wr32 ra:r32 off:s24 - endian = !little lhu.u ~~~~~ lhu.u:erri ^^^^^^^^^^ *mnemonic* .. code-block:: none lhu.u endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lhu.u dc:wr64 ra:r32 off:s24 - endian = !little LW ++ lw ~~ lw:erri ^^^^^^^ *mnemonic* .. code-block:: none lw endian:e rc:wr32 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lw rc:wr32 ra:r32 off:s24 - endian = !little lw:ersi ^^^^^^^ *mnemonic* .. code-block:: none lw endian:e rc:wr32 sa:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lws rc:wr32 ra:r32 off:s24 - endian = !little lw.s ~~~~ lw.s:erri ^^^^^^^^^ *mnemonic* .. code-block:: none lw.s endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lw.s dc:wr64 ra:r32 off:s24 - endian = !little lw.u ~~~~ lw.u:erri ^^^^^^^^^ *mnemonic* .. code-block:: none lw.u endian:e dc:wr64 ra:r32 off:s24 *behavior* .. code-block:: none - 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* .. code-block:: none lw.u dc:wr64 ra:r32 off:s24 - endian = !little SB ++ sb ~~ sb:erii ^^^^^^^ *mnemonic* .. code-block:: none sb endian:e ra:r32 off:s12 imm:s8 *behavior* .. code-block:: none - 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* .. code-block:: none sb ra:r32 off:s12 imm:s8 - endian = !little sb:erir ^^^^^^^ *mnemonic* .. code-block:: none sb endian:e ra:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none sb ra:r32 off:s24 rb:wr32 - endian = !little sb:esii ^^^^^^^ *mnemonic* .. code-block:: none sb endian:e sa:r32 off:s12 imm:s8 *behavior* .. code-block:: none - 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* .. code-block:: none sbs ra:r32 off:s12 imm:s8 - endian = !little sb:esir ^^^^^^^ *mnemonic* .. code-block:: none sb endian:e sa:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none sbs ra:r32 off:s24 rb:wr32 - endian = !little sb_id ~~~~~ sb_id:erii ^^^^^^^^^^ *mnemonic* .. code-block:: none sb_id endian:e ra:r32 off:s12 imm:s8 *behavior* .. code-block:: none - 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* .. code-block:: none sb_id ra:r32 off:s12 imm:s8 - endian = !little .. code-block:: none sb_id ra:r32 off:s12 - endian = !little - imm = 0 SD ++ sd ~~ sd:erii ^^^^^^^ *mnemonic* .. code-block:: none sd endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sd ra:r32 off:s12 imm:s16 - endian = !little sd:erir ^^^^^^^ *mnemonic* .. code-block:: none sd endian:e ra:r32 off:s24 db:wr64 *behavior* .. code-block:: none - 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* .. code-block:: none sd ra:r32 off:s24 db:wr64 - endian = !little sd:esii ^^^^^^^ *mnemonic* .. code-block:: none sd endian:e sa:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sds ra:r32 off:s12 imm:s16 - endian = !little sd:esir ^^^^^^^ *mnemonic* .. code-block:: none sd endian:e sa:r32 off:s24 db:wr64 *behavior* .. code-block:: none - 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* .. code-block:: none sds ra:r32 off:s24 db:wr64 - endian = !little sd_id ~~~~~ sd_id:erii ^^^^^^^^^^ *mnemonic* .. code-block:: none sd_id endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sd_id ra:r32 off:s12 imm:s16 - endian = !little .. code-block:: none sd_id ra:r32 off:s12 - endian = !little - imm = 0 SH ++ sh ~~ sh:erii ^^^^^^^ *mnemonic* .. code-block:: none sh endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sh ra:r32 off:s12 imm:s16 - endian = !little sh:erir ^^^^^^^ *mnemonic* .. code-block:: none sh endian:e ra:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none sh ra:r32 off:s24 rb:wr32 - endian = !little sh:esii ^^^^^^^ *mnemonic* .. code-block:: none sh endian:e sa:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none shs ra:r32 off:s12 imm:s16 - endian = !little sh:esir ^^^^^^^ *mnemonic* .. code-block:: none sh endian:e sa:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none shs ra:r32 off:s24 rb:wr32 - endian = !little sh_id ~~~~~ sh_id:erii ^^^^^^^^^^ *mnemonic* .. code-block:: none sh_id endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sh_id ra:r32 off:s12 imm:s16 - endian = !little .. code-block:: none sh_id ra:r32 off:s12 - endian = !little - imm = 0 SW ++ sw ~~ sw:erii ^^^^^^^ *mnemonic* .. code-block:: none sw endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sw ra:r32 off:s12 imm:s16 - endian = !little sw:erir ^^^^^^^ *mnemonic* .. code-block:: none sw endian:e ra:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none sw ra:r32 off:s24 rb:wr32 - endian = !little sw:esii ^^^^^^^ *mnemonic* .. code-block:: none sw endian:e sa:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sws ra:r32 off:s12 imm:s16 - endian = !little sw:esir ^^^^^^^ *mnemonic* .. code-block:: none sw endian:e sa:r32 off:s24 rb:wr32 *behavior* .. code-block:: none - 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* .. code-block:: none sws ra:r32 off:s24 rb:wr32 - endian = !little sw_id ~~~~~ sw_id:erii ^^^^^^^^^^ *mnemonic* .. code-block:: none sw_id endian:e ra:r32 off:s12 imm:s16 *behavior* .. code-block:: none - 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* .. code-block:: none sw_id ra:r32 off:s12 imm:s16 - endian = !little .. code-block:: none sw_id ra:r32 off:s12 - endian = !little - imm = 0 Load Store MRAM --------------- LDMA ++++ ldma:rri ~~~~~~~~ *mnemonic* .. code-block:: none ldma ra:r32 rb:wr32 immDma:u8 *behavior* .. code-block:: none - 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* .. code-block:: none ldmai ra:r32 rb:wr32 immDma:u8 *behavior* .. code-block:: none - 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* .. code-block:: none sdma ra:r32 rb:wr32 immDma:u8 *behavior* .. code-block:: none - 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) ;