Abstracted assembler

From ScienceZero
Revision as of 07:55, 7 October 2017 by Bjoern (Talk | contribs)

Jump to: navigation, search

Most low level details can be found in ARM Architecture Reference Manual ARMv8.

Goals

  1. Let the compiler allocate registers
  2. Make it possible to use readable variable names in a safe way
  3. Add a thin level of abstraction that does not require a full compiler to generate good code

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 = n.[10..2]
   index-lsb
       a = n.[10..]
   msb-index
       a = n.[..2]
   index-count
       a = n.[10,2]
   msbbase
       a = n.[-2..]  strip the two most significant bits    
   index    
       bit = n.[index]

Common operators

Using python operator precedence with assembly style additions
( ) Custom order of operations, a = (a + b) * c
+   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
max
min
swap

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
a = <eq> ? x+1 : y
a = b > c ? 10 : 20
<le> returns -1 if the condition flags matches the condition for Less than or equal otherwise 0.
<c> returns the Carry flag (0|1)

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

[adr].32 = 0
[adr].64 = {xpos,ypos}    Multiple variables
b = [addr].s16
b = [addr1 + addr2].s16
arr[idx].64 = [addr2]
arr[idx]!64 = [addr2]     Increment idx by 8
push {var-list}               Access the system stack
pop {var-list}

Labels

Everything that starts on the first character on a line is a label. If it starts with a . then it is local to the current function.

label    x = 3
.label   y = 5
   notalabel

Data structures

String
Array
BitArray
List
Hastable
Set
Tree

Memory manager

Examples

Print value in hexadecimal

toHexStringNLZ:
   clz     x11,x0
   subs    x11,x11,#64
   sub     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


tohhex adr number
   leadingZeros = clz number
   remainingBits = 64 <-> leadingZeros
   remainingDigits = remainingBits / 4
   adr = adr + remainingDigits
   adr = <eq> ? adr + 1 : adr

   [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

Add with carry

x = y + z + <c>