Difference between revisions of "Abstracted assembler"
From ScienceZero
(→Common operators) |
(→bit slicing) |
||
Line 20: | Line 20: | ||
index-count | index-count | ||
a = n.[10,2] | a = n.[10,2] | ||
+ | msbbase | ||
+ | a = n.[-2..] strip the two most significant bits | ||
index | index | ||
bit = n.[index] | bit = n.[index] |
Revision as of 16:20, 6 October 2017
Contents
Goals
- Let the compiler allocate registers
- Make it possible to use readable variable names in a safe way
- Add a thin level of abstraction that does not require a full compiler to generate good code
Open questions
- What is the default data size, 32 or 64 bit?
- How to specify SIMD and floating-point operations?
- What is the simplest type system that will work?
- 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
Default order of operations is left to right ( ) 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. <c> returns the Carry flag, x = y + z + <c>
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 {list} Access the system stack pop {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