Abstracted assembler

Open questions

1. What is the default data size, 32 or 64 bit?
2. How to specify SIMD and floating-point operations?
3. What is the simplest type system that will work?
4. Which instruction sets should be supported?

Language features

bit slicing

   index-index
       a = b.[10..2]
   index-count
       a = b.[10,2]
   index    
       bit = n.[index]
       

Common operators

+   addition
<+> addition and set condition codes on result
-
*
/ 
< > <= >= <> 
& and
| or
^ eor
  bic
  orn
  eon
  not

<<  lsl
>>  lsr
>>> asr
>|> ror

Built in functions

clz    count leading zeros
cls    count leading signs
rbit   mirror bits
rev    swap endian
cnt    population count
cset   conditionally set 0 or 1
csetm  conditionally set 0 or -1

Program flow

    call
    return
    again
    exit
    bcc
    while
    dowhile
    for
       for x
       for x = 1 to y
    if then else
    

Conditional

<op> set condition flags on the result of op a = b <+> c
a = cond ? val1 : val2
b = <eq> ? x+1 : y

<le> returns 1 if the condition flags matches the condition for Less than or equal.
<c> returns the Carry flag.

Condition flags

N Negative - The most significant bit of the result, 1 if the result is negative otherwise 0.
Z Zero     - 1 if the result of the instruction is zero, 0 otherwise.
C Carry    - 1 if the instruction results in a carry condition, for example an unsigned overflow that is the result of an addition.
V Overflow - 1 if the instruction results in an overflow condition, for example a signed overflow that is the result of an addition.

Mnemonic                        Condition     Exactly opposite
   AL    Always                    Any           NOP
   CC    Carry clear               C=0           CS
   CS    Carry set                 C=1           CC
   EQ    Equal                     Z=1           NE
   GE    Greater than or equal     N=V           LT
   GT    Greater than              N=V and Z=0   LE
   HI    Higher (unsigned)         C=1 and Z=0   LS
   LE    Less than or equal        N<>V or Z=1   GT
   LS    Lower or same (unsigned)  C=0  or Z=1   HI
   LT    Less than                 N<>V          GE
   MI    Negative                  N=1           PL
   NE    Not equal                 Z=0           EQ
   PL    Positive                  N=0           MI
   VC    Overflow clear            V=0           VS
   VS    Overflow set              V=1           VC
   LO    Lower (unsigned)          Alias for CC  HS
   HS    Higher/same (unsigned)    Alias for CS  LO

Memory access

   [addr].32 = 0
   b = [addr].s16
   b = [addr1 + addr2].s16
   arr[idx].64 = [addr2]
   arr[idx]!64 = [addr2]     Increment idx by 8

Data structures

String
Array
BitArray
List
Hastable
Set
Tree

Examples

Print value in hexadecimal

toHexStringNLZ:
   clz     x11,x0
   sub     x11,x11,#64
   subs    x1,x1,x11,asr #2
   cinc    x1,x1,eq
   strb    wzr,[x1]
.loop:
   ubfx    x10,x0,#0,#4
   cmp     x10,#9
   add     x10,x10,#'0'
   add     x11,x10,#7
   csel    x11,x10,x11,ls
   strb    w11,[x1,#-1]!
   lsr     x0,x0,#4
   cbne    x0,.loop
   ret

tohhex adr number
   leadingZeros = clz number
   remainingBits = 64 - leadingZeros
   remainingDigits = remainingBits / 4
   adr = adr + remainingDigits

   if remainingDigits = 0
       adr += 1
   [adr].8 = 0
    
   dowhile number <> 0
       digit = number.[3..0]
       number = number >> 4

       if digit <= 9
           digit = digit + '0'
       else
           digit = digit + '0' + 7  

           adr -= 1
           [adr].8 = digit