SHA512

6 files changed, 401 insertions, 1 deletions

diff --git a/TODO b/TODO
index 496efbc..0c4bc9f 100644
--- a/TODO
+++ b/TODO
@@ -1,3 +1,7 @@
+* better sys .file
+  * don't make newly opened files executable by default
+    * make :executable, :nonexecutable, :writable, :readable, etc.
+  * apply :readwrite by default on :creating
 * apply the trace extractor to non-tail situations
 * reduze ./optimized binary size (clean up lib/sys/opt.ey code)
 * inline trivial functions when optimizer generates ... /rax :movqImmReg /rax :callqReg sequence
diff --git a/compiler/elymasAsmOps.ey b/compiler/elymasAsmOps.ey
index f3fe043..150a863 100644
--- a/compiler/elymasAsmOps.ey
+++ b/compiler/elymasAsmOps.ey
@@ -382,6 +382,16 @@
     i imm8
   } mnemonic /qImm8Reg defOp
 
+  { ==reg ==i
+    reg bit64assert
+    i 65536 65536 mul lt not { "Imm32 too large" die } rep
+
+    1 /none /none reg rex
+    %81
+    modrmOpcode reg modrm11
+    i imm32
+  } mnemonic /qImm32Reg defOp
+
   memoryAddressingVariants keys { ==variant memoryAddressingVariants variant . =*parse
     { parse ==mem ==i
       i 256 lt not { "Imm8 too large" die } rep
@@ -412,6 +422,15 @@
       modrmOpcode mem .encode
       i imm8
     } mnemonic /qImm8 variant cat defOp
+
+    { parse ==mem ==i
+      i 65536 65536 mul lt not { "Imm32 too large" die } rep
+
+      1 /none mem .idx mem .base rex
+      %81
+      modrmOpcode mem .encode
+      i imm32
+    } mnemonic /qImm32 variant cat defOp
   } each
 } /defAsmAddImm deff
 
@@ -515,6 +534,14 @@
 /bsf %0F %BC defAsmBsfq
 /bsr %0F %BD defAsmBsfq
 
+{ ==reg
+  reg bit64assert
+
+  1 /none /none reg rex
+  %0F
+  %C8 reg regno %07 band add
+} /bswapqReg deff
+
 { ==off
   %E8
   off imm32
@@ -1343,6 +1370,32 @@ memoryAddressingVariants keys { ==variant memoryAddressingVariants variant . =*p
   i imm8
 } /rolqImm8Reg deff
 
+{ ==reg
+  reg bit8assert
+
+  reg regno %07 gt reg rexreqbyte or { 0 reg /none /none rex } rep
+  %D2
+  /one reg modrm11
+} /rorbClReg deff
+
+{ ==reg
+  reg bit64assert
+
+  1 /none /none reg rex
+  %D3
+  /one reg modrm11
+} /rorqClReg deff
+
+{ ==reg ==i
+  reg bit64assert
+  i 64 lt not { "Shift immediate too large" die } rep
+
+  1 /none /none reg rex
+  %C1
+  /one reg modrm11
+  i imm8
+} /rorqImm8Reg deff
+
 {
   %AE
 } /scasb deff
diff --git a/compiler/elymasGlobalSysAsm.ey b/compiler/elymasGlobalSysAsm.ey
index 9fe2f2d..112b440 100644
--- a/compiler/elymasGlobalSysAsm.ey
+++ b/compiler/elymasGlobalSysAsm.ey
@@ -356,7 +356,7 @@
 
       @referencesCopyLoop
       /rsi /rax :movqMemReg
-      8 /rax /rax :movqMemDisp8Reg
+      8 /rax /rax :movqMemDisp8Reg # FIXME: this should be parallel to replace
       :stosq
       8 /rsi :addqImm8Reg
       /referencesCopyLoop :loopLbl8
diff --git a/elymas/lib/crypt.ey b/elymas/lib/crypt.ey
new file mode 100644
index 0000000..c476827
--- /dev/null
+++ b/elymas/lib/crypt.ey
@@ -0,0 +1,341 @@
+<
+  sys .asm "::" via
+  sys .asm .ops ":" via
+  sys .asm .ops .|label "@" deff
+  { :labelRecord [ } "[[" deff
+  { ] :labelResolve } "]]" deff
+  txt .consume .|hu "%" defq
+
+  64 8 mul str .alloc ==:SCHEDULE
+
+  <
+    [
+      %428a2f98d728ae22 %7137449123ef65cd %b5c0fbcfec4d3b2f %e9b5dba58189dbbc %3956c25bf348b538
+      %59f111f1b605d019 %923f82a4af194f9b %ab1c5ed5da6d8118 %d807aa98a3030242 %12835b0145706fbe
+      %243185be4ee4b28c %550c7dc3d5ffb4e2 %72be5d74f27b896f %80deb1fe3b1696b1 %9bdc06a725c71235
+      %c19bf174cf692694 %e49b69c19ef14ad2 %efbe4786384f25e3 %0fc19dc68b8cd5b5 %240ca1cc77ac9c65
+      %2de92c6f592b0275 %4a7484aa6ea6e483 %5cb0a9dcbd41fbd4 %76f988da831153b5 %983e5152ee66dfab
+      %a831c66d2db43210 %b00327c898fb213f %bf597fc7beef0ee4 %c6e00bf33da88fc2 %d5a79147930aa725
+      %06ca6351e003826f %142929670a0e6e70 %27b70a8546d22ffc %2e1b21385c26c926 %4d2c6dfc5ac42aed
+      %53380d139d95b3df %650a73548baf63de %766a0abb3c77b2a8 %81c2c92e47edaee6 %92722c851482353b
+      %a2bfe8a14cf10364 %a81a664bbc423001 %c24b8b70d0f89791 %c76c51a30654be30 %d192e819d6ef5218
+      %d69906245565a910 %f40e35855771202a %106aa07032bbd1b8 %19a4c116b8d2d0c8 %1e376c085141ab53
+      %2748774cdf8eeb99 %34b0bcb5e19b48a8 %391c0cb3c5c95a63 %4ed8aa4ae3418acb %5b9cca4f7763e373
+      %682e6ff3d6b2b8a3 %748f82ee5defb2fc %78a5636f43172f60 %84c87814a1f0ab72 %8cc702081a6439ec
+      %90befffa23631e28 %a4506cebde82bde9 %bef9a3f7b2c67915 %c67178f2e372532b %ca273eceea26619c
+      %d186b8c721c0c207 %eada7dd6cde0eb1e %f57d4f7fee6ed178 %06f067aa72176fba %0a637dc5a2c898a6
+      %113f9804bef90dae %1b710b35131c471b %28db77f523047d84 %32caab7b40c72493 %3c9ebe0a15c9bebc
+      %431d67c49c100d4c %4cc5d4becb3e42b6 %597f299cfc657e2a %5fcb6fab3ad6faec %6c44198c4a475817
+    ] /roundConstant deffd
+
+    # 0 -> string to hash
+    # 0 <- SHA512 of the argument (as a binary string)
+    [[
+      128 8 add /r15 :subqImm32Reg
+      128 /r15 :popqMemDisp32 # save return address
+
+      64 /rdi :movqImmReg
+      ::internalAllocateString /rax :movqImmReg
+      /rax :callqReg # allocate storage for resulting hash
+      
+      /rdx :popqReg  # load argument string
+      /rax :pushqReg # save result string
+      24 /rax /rdi :leaqMemDisp8Reg # rdi == hash content address
+
+      /r8 :pushqReg
+      /r9 :pushqReg
+      /r10 :pushqReg
+      /r11 :pushqReg
+      /r12 :pushqReg
+      /r13 :pushqReg
+      /r14 :pushqReg
+
+      # load initial hash state
+      %F3BCC908 0 /rdi :movlImmMemDisp8
+      %6A09E667 4 /rdi :movlImmMemDisp8
+      %BB67AE85 12 /rdi :movlImmMemDisp8
+      %84CAA73B 8 /rdi :movlImmMemDisp8
+      %3C6EF372 20 /rdi :movlImmMemDisp8
+      %FE94F82B 16 /rdi :movlImmMemDisp8
+      %A54FF53A 28 /rdi :movlImmMemDisp8
+      %5F1D36F1 24 /rdi :movlImmMemDisp8
+      %510E527F 36 /rdi :movlImmMemDisp8
+      %ADE682D1 32 /rdi :movlImmMemDisp8
+      %9B05688C 44 /rdi :movlImmMemDisp8
+      %2B3E6C1F 40 /rdi :movlImmMemDisp8
+      %1F83D9AB 52 /rdi :movlImmMemDisp8
+      %FB41BD6B 48 /rdi :movlImmMemDisp8
+      %5BE0CD19 60 /rdi :movlImmMemDisp8
+      %137E2179 56 /rdi :movlImmMemDisp8
+
+      16 /rdx /rcx :movqMemDisp8Reg # load argument length
+      16 /rdx /rbp :movqMemDisp8Reg # load argument length (backup)
+      24 /rdx /rsi :leaqMemDisp8Reg # rsi == stuff to hash address
+
+      @initialHashingLoop
+      128 /rcx :cmpqImm32Reg
+      /initialHashingDone :jbLbl8
+      /hashBlock :callqLbl32
+      128 /rsi :addqImm32Reg
+      128 /rcx :subqImm32Reg
+      /initialHashingLoop :jmpLbl8
+      @initialHashingDone
+
+      /r15 /rdx :movqRegReg
+
+      /rcx /rcx :testqRegReg
+      /tailCopyDone :jzLbl8
+      @tailCopyLoop
+      /rsi /bl :movbMemReg
+      /bl /rdx :movbRegMem
+      1 /rdx :addqImm8Reg
+      1 /rsi :addqImm8Reg
+      /tailCopyLoop :loopLbl8
+      @tailCopyDone
+
+      %80 /rdx :movbImmMem
+      1 /rdx :addqImm8Reg
+
+      /r15 /rsi :movqRegReg
+      /rsi /rdx :subqRegReg # rdx == number of bytes in temporary block
+
+      112 /rdx :cmpqImm8Reg
+      /lengthNeedsNewBlock :jaLbl8
+
+      @singleBlockClearLoop
+      120 /rdx :cmpqImm8Reg
+      /singleBlockCleared :jeLbl8
+      0 1 /rdx /rsi :andbImmMemIndexScale
+      1 /rdx :addqImm8Reg
+      /singleBlockClearLoop :jmpLbl8
+      @singleBlockCleared
+
+      /hashFinalBlock :jmpLbl8
+
+      @lengthNeedsNewBlock
+
+      @firstBlockClearLoop
+      128 /rdx :cmpqImm32Reg
+      /firstBlockCleared :jeLbl8
+      0 /rdx /rsi :andbImmMemIndex
+      1 /rdx :addqImm8Reg
+      /firstBlockClearLoop :jmpLbl8
+      @firstBlockCleared
+
+      /hashBlock :callqLbl32
+
+      0 0 /r15 :andqImm8MemDisp8
+      0 8 /r15 :andqImm8MemDisp8
+      0 16 /r15 :andqImm8MemDisp8
+      0 24 /r15 :andqImm8MemDisp8
+      0 32 /r15 :andqImm8MemDisp8
+      0 40 /r15 :andqImm8MemDisp8
+      0 48 /r15 :andqImm8MemDisp8
+      0 56 /r15 :andqImm8MemDisp8
+      0 64 /r15 :andqImm8MemDisp8
+      0 72 /r15 :andqImm8MemDisp8
+      0 80 /r15 :andqImm8MemDisp8
+      0 88 /r15 :andqImm8MemDisp8
+      0 96 /r15 :andqImm8MemDisp8
+      0 104 /r15 :andqImm8MemDisp8
+      0 112 /r15 :andqImm8MemDisp8
+
+      @hashFinalBlock
+
+      3 /rbp :shlqImm8Reg
+      /rbp :bswapqReg
+      /rbp 120 /r15 :movqRegMemDisp8
+
+      /hashBlock :callqLbl32
+
+      /r14 :popqReg
+      /r13 :popqReg
+      /r12 :popqReg
+      /r11 :popqReg
+      /r10 :popqReg
+      /r9 :popqReg
+      /r8 :popqReg
+
+      128 /r15 :pushqMemDisp32
+      128 8 add /r15 :addqImm32Reg
+      :retn
+
+      @hashBlock
+      # rsi == block to hash
+      # rdi == address of hash state
+      # rcx, rbp, rsi, rdi must not be changed     
+
+      { ==target ==i
+        i 16 lt {
+          i 8 mul /rsi target :movqMemDisp32Reg
+          target :bswapqReg
+        } {
+          i 8 mul /rax target :movqMemDisp32Reg
+        } ? *
+      } /scheduleMem deffst
+
+      SCHEDULE ::rawAddress 24 add /rax :movqImmReg
+
+      16 80 range { ==i
+        # s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+        # s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+        # w[i] := w[i-16] + s0 + w[i-7] + s1
+
+        i 15 sub /r8 scheduleMem
+        i 2 sub /r11 scheduleMem
+        i 16 sub /r14 scheduleMem
+        i 7 sub /rdx scheduleMem
+
+        /r8 /r9 :movqRegReg
+        /r8 /r10 :movqRegReg
+        /r11 /r12 :movqRegReg
+        /r11 /r13 :movqRegReg
+
+        1 /r8 :rorqImm8Reg
+        8 /r9 :rorqImm8Reg
+        7 /r10 :shrqImm8Reg
+        19 /r11 :rorqImm8Reg
+        61 /r12 :rorqImm8Reg
+        6 /r13 :shrqImm8Reg
+
+        /r9 /r8 :xorqRegReg
+        /r10 /r8 :xorqRegReg
+        /r12 /r11 :xorqRegReg
+        /r13 /r11 :xorqRegReg
+
+        /rdx /r14 :addqRegReg
+        /r11 /r8 :addqRegReg
+        /r14 /r8 :addqRegReg
+
+        /r8 i 8 mul /rax :movqRegMemDisp32
+      } each
+
+      # rcx, rbp, rsi, rdi must not be changed     
+      /r15 :pushqReg
+      /rcx :pushqReg
+      /rbp :pushqReg
+      /rdi :pushqReg
+
+      0 /rdi /r8 :movqMemDisp8Reg   # a
+      8 /rdi /r9 :movqMemDisp8Reg   # b
+      16 /rdi /r10 :movqMemDisp8Reg # c
+      24 /rdi /r11 :movqMemDisp8Reg # d
+      32 /rdi /r12 :movqMemDisp8Reg # e
+      40 /rdi /r13 :movqMemDisp8Reg # f
+      48 /rdi /r14 :movqMemDisp8Reg # g
+      56 /rdi /r15 :movqMemDisp8Reg # h
+
+      0 80 range { ==i
+        # S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+        /r12 /rdx :movqRegReg
+        /r12 /rbx :movqRegReg
+        /r12 /rcx :movqRegReg
+
+        14 /rdx :rorqImm8Reg
+        18 /rbx :rorqImm8Reg
+        41 /rcx :rorqImm8Reg
+
+        /rbx /rdx :xorqRegReg
+        /rcx /rdx :xorqRegReg
+
+        # ch := (e and f) xor ((not e) and g)
+        /r12 /rbp :movqRegReg
+        /r12 /rbx :movqRegReg
+
+        /r13 /rbp :andqRegReg
+        /rbx :notqReg
+        /r14 /rbx :andqRegReg
+        /rbx /rbp :xorqRegReg
+
+        # temp1 := h + S1 + ch + k[i] + w[i]
+        /rbp /rdx :addqRegReg
+        /r15 /rdx :addqRegReg
+
+        SCHEDULE ::rawAddress 24 add /rax :movqImmReg
+        i /rax scheduleMem # w[i]
+        /rax /rdx :addqRegReg
+        
+        i roundConstant /rbp :movqImmReg
+        /rbp /rdx :addqRegReg
+
+        # S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+        /r8 /rax :movqRegReg
+        /r8 /rbx :movqRegReg
+        /r8 /rcx :movqRegReg
+
+        28 /rax :rorqImm8Reg
+        34 /rbx :rorqImm8Reg
+        39 /rcx :rorqImm8Reg
+
+        /rbx /rax :xorqRegReg
+        /rcx /rax :xorqRegReg
+
+        # maj := (a and b) xor (a and c) xor (b and c)
+        /r8 /rcx :movqRegReg
+        /r8 /rdi :movqRegReg
+        /r9 /rbp :movqRegReg
+        /r9 /rcx :andqRegReg
+        /r10 /rdi :andqRegReg
+        /r10 /rbp :andqRegReg
+        /rbp /rcx :xorqRegReg
+        /rdi /rcx :xorqRegReg
+
+        # temp2 := S0 + maj
+        /rcx /rax :addqRegReg
+
+        # h := g
+        /r14 /r15 :movqRegReg
+        # g := f
+        /r13 /r14 :movqRegReg
+        # f := e
+        /r12 /r13 :movqRegReg
+        # e := d + temp1
+        /rdx /r11 /r12 :leaqMemIndexReg
+        # d := c
+        /r10 /r11 :movqRegReg
+        # c := b
+        /r9 /r10 :movqRegReg
+        # b := a
+        /r8 /r9 :movqRegReg
+        # a := temp1 + temp2
+        /rax /rdx /r8 :leaqMemIndexReg
+      } each
+
+      /rdi :popqReg
+      /rbp :popqReg
+      /rcx :popqReg
+      
+      # add a-h to hash state
+      /r8 0 /rdi :addqRegMemDisp8   # a
+      /r9 8 /rdi :addqRegMemDisp8   # b
+      /r10 16 /rdi :addqRegMemDisp8 # c
+      /r11 24 /rdi :addqRegMemDisp8 # d
+      /r12 32 /rdi :addqRegMemDisp8 # e
+      /r13 40 /rdi :addqRegMemDisp8 # f
+      /r14 48 /rdi :addqRegMemDisp8 # g
+      /r15 56 /rdi :addqRegMemDisp8 # h
+
+      /r15 :popqReg
+
+      :retn
+    ]] [ ] ::createFunction /bin deffd
+
+  
+    [
+      0 8 range { ==i
+        i 8 mul _ 8 add range reverse 8 dearray
+      } each
+    ] ==:hexPositions
+
+    { bin =*hash
+      [
+        hexPositions { hash
+           _ 16 div
+             -01 16 mod
+        } each
+      ] { "0123456789abcdef" * } '*0.0 str .fromArray
+    } /hex deffd
+  > /sha512 defvd
+> /crypt defvd
+
+# vim: syn=elymas
diff --git a/elymas/loaded.ey b/elymas/loaded.ey
index 53f8ab1..7fa3945 100644
--- a/elymas/loaded.ey
+++ b/elymas/loaded.ey
@@ -20,6 +20,7 @@
   "lib/map.ey"
   "lib/tree.ey"
   "lib/sort.ey"
+  "lib/crypt.ey"
 ] { _ dump include }' each
 
 {
diff --git a/elymas/shared.ey b/elymas/shared.ey
index 152e4df..06f18f9 100644
--- a/elymas/shared.ey
+++ b/elymas/shared.ey
@@ -21,6 +21,7 @@
   "lib/map.ey"
   "lib/tree.ey"
   "lib/sort.ey"
+  "lib/crypt.ey"
 ] { _ dump include }' each
 
 {