kempe 0.1.1.2 → 0.1.1.3

raw patch · 12 files changed

+721/−436 lines, 12 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• LICENSE +1/−1
• bench/Bench.hs +2/−1
• docs/manual.pdf binary
• kempe.cabal +55/−51
• lib/gaussian.kmp +11/−0
• src/Kempe/Asm/Liveness.hs +0/−2
• src/Kempe/Asm/X86.hs +0/−375
• src/Kempe/Asm/X86/Trans.hs +375/−0
• src/Kempe/Pipeline.hs +1/−1
• src/Kempe/TyAssign.hs +2/−2
• test/golden/gaussian.ir +268/−3

@@ -1,5 +1,11 @@ # kempe +## 0.1.1.3++  * Tweak some RTS flags for faster performance+  * `lib/gaussian.kmp` has `mult` function+  * A couple inefficiencies under the hood+ ## 0.1.1.2    * Case statements with a single branch are plain and efficient.

@@ -1,4 +1,4 @@-Copyright Vanessa McHale (c) 2020+Copyright Vanessa McHale (c) 2020-2021  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 

@@ -6,9 +6,9 @@ import qualified Data.ByteString.Lazy      as BSL import qualified Data.Text                 as T import           Kempe.Asm.Liveness-import           Kempe.Asm.X86 import           Kempe.Asm.X86.ControlFlow import           Kempe.Asm.X86.Linear+import           Kempe.Asm.X86.Trans import           Kempe.Check.Pattern import           Kempe.File import           Kempe.IR@@ -95,6 +95,7 @@                         , bench "Generate assembly (examples/factorial.kmp)" $ nfIO (writeAsm "examples/factorial.kmp")                         , bench "Generate assembly (examples/splitmix.kmp)" $ nfIO (writeAsm "examples/splitmix.kmp")                         , bench "Generate assembly (lib/numbertheory.kmp)" $ nfIO (writeAsm "lib/numbertheory.kmp")+                        , bench "Generate assembly (lib/gaussian.kmp)" $ nfIO (writeAsm "lib/gaussian.kmp")                         -- , bench "Generate assembly (lib/rational.kmp)" $ nfIO (writeAsm "lib/rational.kmp")                         , bench "Object file (examples/factorial.kmp)" $ nfIO (compile "examples/factorial.kmp" "/tmp/factorial.o" False)                         , bench "Object file (lib/numbertheory.kmp)" $ nfIO (compile "lib/numbertheory.kmp" "/tmp/numbertheory.o" False)

binary file changed (214002 → 214002 bytes)

@@ -1,9 +1,9 @@ cabal-version:   3.0 name:            kempe-version:         0.1.1.2+version:         0.1.1.3 license:         BSD-3-Clause license-file:    LICENSE-copyright:       Copyright: (c) 2020 Vanessa McHale+copyright:       Copyright: (c) 2020-2021 Vanessa McHale maintainer:      vamchale@gmail.com author:          Vanessa McHale synopsis:        Kempe compiler@@ -30,10 +30,6 @@     type:     git     location: https://github.com/vmchale/kempe -flag no-par-    description: Disable concurrent build-    manual:      True- flag cross     description: Enable to ease cross-compiling     default:     False@@ -54,7 +50,7 @@         Kempe.Check.Pattern         Kempe.IR         Kempe.IR.Opt-        Kempe.Asm.X86+        Kempe.Asm.X86.Trans         Kempe.Asm.X86.ControlFlow         Kempe.Asm.Liveness         Kempe.Asm.X86.Linear@@ -86,26 +82,37 @@     ghc-options:      -Wall     build-depends:         base >=4.9 && <5,-        array -any,-        bytestring -any,+        array,+        bytestring,         containers >=0.6.0.0,-        deepseq -any,-        text -any,-        mtl -any,-        microlens -any,-        transformers -any,+        deepseq,+        text,+        mtl,+        microlens,+        transformers,         extra >=1.7.4,         prettyprinter >=1.7.0,         composition-prelude >=2.0.2.0,-        microlens-mtl -any,+        microlens-mtl,         process >=1.2.3.0,-        temporary -any+        temporary -    if !flag(no-par)-        ghc-options: -j +RTS -A32m -RTS+    if impl(ghc >=8.0)+        ghc-options:+            -Wincomplete-uni-patterns -Wincomplete-record-updates+            -Wredundant-constraints -Widentities +    if impl(ghc >=8.4)+        ghc-options: -Wmissing-export-lists++    if impl(ghc >=8.2)+        ghc-options: -Wcpp-undef++    if impl(ghc >=8.10)+        ghc-options: -Wunused-packages+     if !flag(cross)-        build-tool-depends: alex:alex -any, happy:happy -any+        build-tool-depends: alex:alex, happy:happy      if impl(ghc >=8.0)         ghc-options:@@ -127,13 +134,13 @@     other-modules:    Paths_kempe     autogen-modules:  Paths_kempe     default-language: Haskell2010-    ghc-options:      -Wall+    ghc-options:      -Wall -rtsopts -with-rtsopts=-A4m     build-depends:-        base -any,-        optparse-applicative -any,-        kempe-modules -any,+        base,+        optparse-applicative,+        kempe-modules,         prettyprinter >=1.7.0,-        bytestring -any+        bytestring      if impl(ghc >=8.0)         ghc-options:@@ -162,19 +169,16 @@     default-language: Haskell2010     ghc-options:      -threaded -rtsopts "-with-rtsopts=-N -K1K" -Wall     build-depends:-        base -any,-        kempe-modules -any,-        tasty -any,-        tasty-hunit -any,-        bytestring -any,+        base,+        kempe-modules,+        tasty,+        tasty-hunit,+        bytestring,         prettyprinter >=1.7.0,-        deepseq -any,-        tasty-golden -any,-        text -any,-        composition-prelude -any--    if !flag(no-par)-        ghc-options: -j +RTS -A32m -RTS+        deepseq,+        tasty-golden,+        text,+        composition-prelude      if impl(ghc >=8.0)         ghc-options:@@ -198,14 +202,14 @@     default-language: Haskell2010     ghc-options:      -threaded -rtsopts "-with-rtsopts=-N -K1K" -Wall     build-depends:-        base -any,-        kempe-modules -any,-        tasty -any,-        bytestring -any,-        process -any,-        temporary -any,-        filepath -any,-        tasty-golden -any+        base,+        kempe-modules,+        tasty,+        bytestring,+        process,+        temporary,+        filepath,+        tasty-golden      if impl(ghc >=8.0)         ghc-options:@@ -226,14 +230,14 @@     main-is:          Bench.hs     hs-source-dirs:   bench     default-language: Haskell2010-    ghc-options:      -Wall+    ghc-options:      -Wall -rtsopts -with-rtsopts=-A4m     build-depends:-        base -any,-        kempe-modules -any,-        bytestring -any,-        criterion -any,-        prettyprinter -any,-        text -any+        base,+        kempe-modules,+        bytestring,+        criterion,+        prettyprinter,+        text      if impl(ghc >=8.0)         ghc-options:

@@ -1,4 +1,5 @@ ; Gaussian integers+import"prelude/fn.kmp"  type Gaussian { Gaussian Int Int } @@ -16,8 +17,18 @@ add : Gaussian Gaussian -- Gaussian     =: [ dip(unGaussian) unGaussian grp + dip(+) Gaussian ] +multRe : Gaussian Gaussian -- Int+       =: [ dip(unGaussian) unGaussian dip(swap) * dip(*) - ]++multIm : Gaussian Gaussian -- Int+       =: [ dip(unGaussian) unGaussian dip(*) swap dip(*) + ]++mult : Gaussian Gaussian -- Gaussian+     =: [ dup2 multIm dip(multRe) Gaussian ]+ conjugate : Gaussian -- Gaussian           =: [ unGaussian ~ Gaussian ]  %foreign kabi add %foreign kabi conjugate+%foreign kabi mult

@@ -16,8 +16,6 @@ emptyLiveness :: Liveness emptyLiveness = Liveness IS.empty IS.empty --- need: succ for a node- initLiveness :: Copointed p => [p ControlAnn] -> LivenessMap initLiveness = IM.fromList . fmap (\asm -> let x = copoint asm in (node x, (x, emptyLiveness))) 

@@ -1,375 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}---- | Started out trying to implement maximal munch but ended with something--- "flatter" that works with Kempe IR and my shitty register allocator.-module Kempe.Asm.X86 ( irToX86-                     ) where--import           Control.Monad.State.Strict (State, evalState, gets, modify)-import           Data.Foldable.Ext-import           Data.List                  (scanl')-import           Data.Word                  (Word8)-import           Kempe.AST.Size-import           Kempe.Asm.X86.Type-import qualified Kempe.IR.Type              as IR--toAbsReg :: IR.Temp -> AbsReg-toAbsReg (IR.Temp8 i)   = AllocReg8 i-toAbsReg (IR.Temp64 i)  = AllocReg64 i-toAbsReg IR.DataPointer = DataPointer--type WriteM = State IR.WriteSt--irToX86 :: SizeEnv -> IR.WriteSt -> [IR.Stmt] -> [X86 AbsReg ()]-irToX86 env w = runWriteM w . foldMapA (irEmit env)--nextLabels :: IR.WriteSt -> IR.WriteSt-nextLabels (IR.WriteSt ls ts) = IR.WriteSt (tail ls) ts--nextInt :: IR.WriteSt -> IR.WriteSt-nextInt (IR.WriteSt ls ts) = IR.WriteSt ls (tail ts)--getInt :: WriteM Int-getInt = gets (head . IR.temps) <* modify nextInt--getLabel :: WriteM IR.Label-getLabel = gets (head . IR.wlabels) <* modify nextLabels--allocTemp64 :: WriteM IR.Temp-allocTemp64 = IR.Temp64 <$> getInt--allocTemp8 :: WriteM IR.Temp-allocTemp8 = IR.Temp8 <$> getInt--allocReg64 :: WriteM AbsReg-allocReg64 = AllocReg64 <$> getInt--allocReg8 :: WriteM AbsReg-allocReg8 = AllocReg8 <$> getInt--runWriteM :: IR.WriteSt -> WriteM a -> a-runWriteM = flip evalState---- | This should handle 'MovMem's of divers sizes but for now it just does--- 1 byte or 8 bytes at a time.-irEmit :: SizeEnv -> IR.Stmt -> WriteM [X86 AbsReg ()]-irEmit _ (IR.Jump l) = pure [Jump () l]-irEmit _ (IR.Labeled l) = pure [Label () l]-irEmit _ (IR.KCall l) = pure [Call () l]-irEmit _ IR.Ret = pure [Ret ()]-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () r' (toAbsReg r1), SubRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstInt i)) =-    pure [ MovAC () (Reg $ toAbsReg r) i ]-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstBool b)) =-    pure [ MovABool () (Reg $ toAbsReg r) (toByte b) ]-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstTag b)) =-    pure [ MovACTag () (Reg $ toAbsReg r) b ]-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntTimesIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () r' (toAbsReg r1), ImulRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg8-    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg8-    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg8-    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg8-    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg64-    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg64-    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do-    { r' <- allocReg64-    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntEqIR (IR.Reg r1) (IR.Reg r2))) = do -- TODO: int eq more general (Reg r1) could be e1 &c.-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Je () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntLtIR (IR.Reg r1) (IR.Reg r2))) = do-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jl () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntGtIR (IR.Reg r1) (IR.Reg r2))) = do-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jg () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntGeqIR (IR.Reg r1) (IR.Reg r2))) = do-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jge () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntNeqIR (IR.Reg r1) (IR.Reg r2))) = do-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jne () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntLeqIR (IR.Reg r1) (IR.Reg r2))) = do-    { l0 <- getLabel-    ; l1 <- getLabel-    ; l2 <- getLabel-    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jle () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]-    }-irEmit _ (IR.MovTemp r1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r2) (IR.ConstInt i))) | r1 == r2 = do-    pure [ SubRC () (toAbsReg r1) i ]-irEmit _ (IR.MovTemp r1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r2) (IR.ConstInt i))) | r1 == r2 = do-    pure [ AddRC () (toAbsReg r1) i ]-irEmit env (IR.CCall (is, []) b) | all (\i -> size' env i <= 8) is && length is <= 6 =-    pure [NasmMacro0 () "callersave", CallBS () b, NasmMacro0 () "callerrestore"]-irEmit env (IR.CCall (is, [o]) b) | all (\i -> size' env i <= 8) is && size' env o <= 8 && length is <= 6 =-    pure [NasmMacro0 () "callersave", CallBS () b, NasmMacro0 () "callerrestore"]--- For 128-bit returns we'd have to use rax and rdx-irEmit env (IR.WrapKCall Cabi (is, [o]) n l) | all (\i -> size' env i <= 8) is && size' env o <= 8 && length is <= 6 = do-    { let offs = scanl' (+) 0 (fmap (size' env) is)-    ; let totalSize = sizeStack env is-    ; let argRegs = [CArg1, CArg2, CArg3, CArg4, CArg5, CArg6]-    ; pure $ [BSLabel () n, MovRL () DataPointer "kempe_data", NasmMacro0 () "calleesave"] ++ zipWith (\r i-> MovAR () (AddrRCPlus DataPointer i) r) argRegs offs ++ [AddRC () DataPointer totalSize, Call () l, MovRA () CRet (AddrRCMinus DataPointer (size' env o)), NasmMacro0 () "calleerestore", Ret ()] -- TODO: bytes on the stack eh-    }-irEmit _ (IR.WrapKCall Kabi (_, _) n l) =-    pure [BSLabel () n, Call () l, Ret ()]-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstInt8 i)) =-    pure [ MovACi8 () (Reg $ toAbsReg r) i ]-    -- see: https://github.com/cirosantilli/x86-assembly-cheat/blob/master/x86-64/movabs.asm for why we don't do this ^ for words-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntXorIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () r' (toAbsReg r1), XorRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () r' (toAbsReg r1), AddRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.WordShiftRIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () r' (toAbsReg r1), ShiftRRR () r' ShiftExponent, MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.WordShiftLIR (IR.Reg r1) (IR.Reg r2))) = do-    { r' <- allocReg64-    ; pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () r' (toAbsReg r1), ShiftLRR () r' ShiftExponent, MovAR () (Reg $ toAbsReg r) r' ]-    }-irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntModIR (IR.Reg r1) (IR.Reg r2))) =-    -- QuotRes is rax, so move r1 to rax first-    pure [ MovRR () QuotRes (toAbsReg r1), Cqo (), IdivR () (toAbsReg r2), MovAR () (Reg $ toAbsReg r) RemRes ]-irEmit _ (IR.MovTemp r e) = evalE e r-irEmit _ (IR.MovMem (IR.Reg r) 1 e) = do-    { r' <- allocTemp8-    ; put <- evalE e r'-    ; pure $ put ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')]-    }-irEmit _ (IR.MovMem e 8 e') = do-    { r <- allocTemp64-    ; r' <- allocTemp64-    ; eEval <- evalE e r-    ; e'Eval <- evalE e' r'-    ; pure (eEval ++ e'Eval ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')])-    }-irEmit _ (IR.MovMem e 1 e') = do-    { r <- allocTemp64-    ; r' <- allocTemp8-    ; eEval <- evalE e r-    ; e'Eval <- evalE e' r'-    ; pure (eEval ++ e'Eval ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')])-    }-irEmit _ (IR.CJump (IR.Mem 1 (IR.Reg r)) l l') =-    pure [CmpAddrBool () (Reg (toAbsReg r)) 1, Je () l, Jump () l']-irEmit _ (IR.MJump (IR.Mem 1 (IR.Reg r)) l) =-    pure [CmpAddrBool () (Reg (toAbsReg r)) 1, Je () l]-irEmit _ (IR.CJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r) (IR.ConstInt i))) l l') =-    pure [CmpAddrBool () (AddrRCMinus (toAbsReg r) i) 1, Je () l, Jump () l']-irEmit _ (IR.MJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r) (IR.ConstInt i))) l) =-    pure [CmpAddrBool () (AddrRCMinus (toAbsReg r) i) 1, Je () l]-irEmit _ (IR.CJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r) (IR.ConstInt i))) l l') =-    pure [CmpAddrBool () (AddrRCPlus (toAbsReg r) i) 1, Je () l, Jump () l']-irEmit _ (IR.MJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r) (IR.ConstInt i))) l) =-    pure [CmpAddrBool () (AddrRCPlus (toAbsReg r) i) 1, Je () l]-irEmit _ (IR.CJump e l l') = do-    { r <- allocTemp8-    ; bEval <- evalE e r-    ; pure (bEval ++ [CmpRegBool () (toAbsReg r) 1, Je () l, Jump () l'])-    }-irEmit _ (IR.MJump (IR.EqByte (IR.Mem 1 (IR.Reg r)) (IR.ConstTag b)) l) =-    pure [CmpAddrBool () (Reg $ toAbsReg r) b, Je () l]-irEmit _ (IR.MJump (IR.EqByte e0 e1) l) = do-    { r0 <- allocTemp8-    ; r1 <- allocTemp8-    ; placeE0 <- evalE e0 r0-    ; placeE1 <- evalE e1 r1-    ; pure $ placeE0 ++ placeE1 ++ [CmpRegReg () (toAbsReg r0) (toAbsReg r1), Je () l]-    }-irEmit _ (IR.MJump e l) = do-    { r <- allocTemp8-    ; bEval <- evalE e r-    ; pure (bEval ++ [CmpRegBool () (toAbsReg r) 1, Je () l])-    }---- | Code to evaluate and put some expression in a chosen 'Temp'------ This more or less conforms to maximal munch.-evalE :: IR.Exp -> IR.Temp -> WriteM [X86 AbsReg ()]-evalE (IR.ConstInt i) r                                             = pure [MovRC () (toAbsReg r) i]-evalE (IR.ConstBool b) r                                            = pure [MovRCBool () (toAbsReg r) (toByte b)]-evalE (IR.ConstInt8 i) r                                            = pure [MovRCi8 () (toAbsReg r) i]-evalE (IR.ConstWord w) r                                            = pure [MovRWord () (toAbsReg r) w]-evalE (IR.ConstTag b) r                                             = pure [MovRCTag () (toAbsReg r) b]-evalE (IR.Reg r') r                                                 = pure [MovRR () (toAbsReg r) (toAbsReg r')]-evalE (IR.Mem _ (IR.Reg r1)) r                                      = pure [MovRA () (toAbsReg r) (Reg $ toAbsReg r1) ] -- TODO: sanity check reg/mem access size?-evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i)) r | r == r1 = pure [SubRC () (toAbsReg r) i]-evalE (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt i)) r  | r == r1 = pure [AddRC () (toAbsReg r) i]-evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt 0)) r = pure [MovRR () (toAbsReg r) (toAbsReg r1)]-evalE (IR.Mem 8 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i))) r =-    pure [ MovRA () (toAbsReg r) (AddrRCMinus (toAbsReg r1) i) ]-evalE (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt i))) r =-    pure [ MovRA () (toAbsReg r) (AddrRCPlus (toAbsReg r1) i) ]-evalE (IR.Mem _ e) r = do -- don't need to check size b/c we're storing in r-    { r' <- allocTemp64-    ; placeE <- evalE e r'-    ; pure $ placeE ++ [MovRA () (toAbsReg r) (Reg $ toAbsReg r')]-    }-evalE (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.Reg r2)) r =-    pure [ MovRR () (toAbsReg r) (toAbsReg r1), AddRR () (toAbsReg r) (toAbsReg r2) ]-evalE (IR.ExprIntBinOp IR.IntTimesIR (IR.Reg r1) (IR.Reg r2)) r = do-    pure [ MovRR () (toAbsReg r) (toAbsReg r1), ImulRR () (toAbsReg r) (toAbsReg r2) ]-evalE (IR.ExprIntBinOp IR.IntXorIR (IR.Reg r1) (IR.Reg r2)) r = do-    pure [ MovRR () (toAbsReg r) (toAbsReg r1), XorRR () (toAbsReg r) (toAbsReg r2) ]-evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i)) r = do-    pure [ MovRR () (toAbsReg r) (toAbsReg r1), SubRC () (toAbsReg r) i ]-evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.Reg r2)) r = do-    pure [ MovRR () (toAbsReg r) (toAbsReg r1), SubRR () (toAbsReg r) (toAbsReg r2) ]--- FIXME: because my linear register allocator is shitty, I can't keep--- registers across jumps... so evaluating = or < as an expression in--- general is hard ?-evalE (IR.ExprIntBinOp IR.WordShiftLIR (IR.Reg r1) (IR.Reg r2)) r =-    pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () (toAbsReg r) (toAbsReg r1), ShiftLRR () (toAbsReg r) ShiftExponent ]-evalE (IR.ExprIntBinOp IR.WordShiftRIR (IR.Reg r1) (IR.Reg r2)) r = -- FIXME: maximal munch use evalE recursively-    pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () (toAbsReg r) (toAbsReg r1), ShiftRRR () (toAbsReg r) ShiftExponent]-evalE (IR.ExprIntBinOp IR.WordShiftLIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp8-    ; placeE0 <- evalE e0 r0-    ; placeE1 <- evalE e1 r1-    ; pure $ placeE0 ++ placeE1 ++ [ MovRR () ShiftExponent (toAbsReg r0), MovRR () (toAbsReg r) (toAbsReg r1), ShiftLRR () (toAbsReg r) ShiftExponent ]-    }-evalE (IR.ExprIntBinOp IR.WordShiftRIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp8-    ; placeE0 <- evalE e0 r0-    ; placeE1 <- evalE e1 r1-    ; pure $ placeE0 ++ placeE1 ++ [ MovRR () ShiftExponent (toAbsReg r0), MovRR () (toAbsReg r) (toAbsReg r1), ShiftRRR () (toAbsReg r) ShiftExponent ]-    }-evalE (IR.ExprIntBinOp IR.IntModIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    -- QuotRes is rax, so move r1 to rax first-    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), Cqo (), IdivR () (toAbsReg r1), MovRR () (toAbsReg r) RemRes ]-    }-evalE (IR.ExprIntBinOp IR.IntDivIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), Cqo (), IdivR () (toAbsReg r1), MovRR () (toAbsReg r) QuotRes ]-    }-evalE (IR.ExprIntBinOp IR.WordDivIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), XorRR () RemRes RemRes, DivR () (toAbsReg r1), MovRR () (toAbsReg r) QuotRes ]-    }-evalE (IR.ExprIntBinOp IR.WordModIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), XorRR () RemRes RemRes, DivR () (toAbsReg r1), MovRR () (toAbsReg r) RemRes ]-    }-evalE (IR.BoolBinOp IR.BoolAnd e0 e1) r = do-    { r0 <- allocTemp8-    ; r1 <- allocTemp8-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), AndRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.BoolBinOp IR.BoolOr e0 e1) r = do-    { r0 <- allocTemp8-    ; r1 <- allocTemp8-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), OrRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.BoolBinOp IR.BoolXor e0 e1) r = do-    { r0 <- allocTemp8-    ; r1 <- allocTemp8-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), XorRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.ExprIntBinOp IR.IntMinusIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), SubRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.ExprIntBinOp IR.IntPlusIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), AddRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.ExprIntBinOp IR.IntTimesIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), ImulRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.ExprIntBinOp IR.IntXorIR e0 e1) r = do-    { r0 <- allocTemp64-    ; r1 <- allocTemp64-    ; placeE <- evalE e0 r0-    ; placeE' <- evalE e1 r1-    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), XorRR () (toAbsReg r) (toAbsReg r1) ]-    }-evalE (IR.PopcountIR e0) r = do-    { r' <- allocTemp64-    ; placeE <- evalE e0 r'-    ; pure $ placeE ++ [ PopcountRR () (toAbsReg r) (toAbsReg r') ]-    }-evalE (IR.IntNegIR e) r = do-    { placeE <- evalE e r-    ; pure $ placeE ++ [ NegR () (toAbsReg r) ]-    }--toByte :: Bool -> Word8-toByte False = 0-toByte True  = 1---- I wonder if I could use a hylo.?

@@ -0,0 +1,375 @@+{-# LANGUAGE OverloadedStrings #-}++-- | Started out trying to implement maximal munch but ended with something+-- "flatter" that works with Kempe IR and my shitty register allocator.+module Kempe.Asm.X86.Trans ( irToX86+                           ) where++import           Control.Monad.State.Strict (State, evalState, gets, modify)+import           Data.Foldable.Ext+import           Data.List                  (scanl')+import           Data.Word                  (Word8)+import           Kempe.AST.Size+import           Kempe.Asm.X86.Type+import qualified Kempe.IR.Type              as IR++toAbsReg :: IR.Temp -> AbsReg+toAbsReg (IR.Temp8 i)   = AllocReg8 i+toAbsReg (IR.Temp64 i)  = AllocReg64 i+toAbsReg IR.DataPointer = DataPointer++type WriteM = State IR.WriteSt++irToX86 :: SizeEnv -> IR.WriteSt -> [IR.Stmt] -> [X86 AbsReg ()]+irToX86 env w = runWriteM w . foldMapA (irEmit env)++nextLabels :: IR.WriteSt -> IR.WriteSt+nextLabels (IR.WriteSt ls ts) = IR.WriteSt (tail ls) ts++nextInt :: IR.WriteSt -> IR.WriteSt+nextInt (IR.WriteSt ls ts) = IR.WriteSt ls (tail ts)++getInt :: WriteM Int+getInt = gets (head . IR.temps) <* modify nextInt++getLabel :: WriteM IR.Label+getLabel = gets (head . IR.wlabels) <* modify nextLabels++allocTemp64 :: WriteM IR.Temp+allocTemp64 = IR.Temp64 <$> getInt++allocTemp8 :: WriteM IR.Temp+allocTemp8 = IR.Temp8 <$> getInt++allocReg64 :: WriteM AbsReg+allocReg64 = AllocReg64 <$> getInt++allocReg8 :: WriteM AbsReg+allocReg8 = AllocReg8 <$> getInt++runWriteM :: IR.WriteSt -> WriteM a -> a+runWriteM = flip evalState++-- | This should handle 'MovMem's of divers sizes but for now it just does+-- 1 byte or 8 bytes at a time.+irEmit :: SizeEnv -> IR.Stmt -> WriteM [X86 AbsReg ()]+irEmit _ (IR.Jump l) = pure [Jump () l]+irEmit _ (IR.Labeled l) = pure [Label () l]+irEmit _ (IR.KCall l) = pure [Call () l]+irEmit _ IR.Ret = pure [Ret ()]+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () r' (toAbsReg r1), SubRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstInt i)) =+    pure [ MovAC () (Reg $ toAbsReg r) i ]+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstBool b)) =+    pure [ MovABool () (Reg $ toAbsReg r) (toByte b) ]+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstTag b)) =+    pure [ MovACTag () (Reg $ toAbsReg r) b ]+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntTimesIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () r' (toAbsReg r1), ImulRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg8+    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg8+    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg8+    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg8+    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg64+    ; pure [ MovRA () r' (AddrRCMinus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg64+    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCMinus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r0) (IR.ConstInt i)) _ (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt j)))) = do+    { r' <- allocReg64+    ; pure [ MovRA () r' (AddrRCPlus (toAbsReg r1) j), MovAR () (AddrRCPlus (toAbsReg r0) i) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntEqIR (IR.Reg r1) (IR.Reg r2))) = do -- TODO: int eq more general (Reg r1) could be e1 &c.+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Je () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntLtIR (IR.Reg r1) (IR.Reg r2))) = do+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jl () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntGtIR (IR.Reg r1) (IR.Reg r2))) = do+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jg () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntGeqIR (IR.Reg r1) (IR.Reg r2))) = do+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jge () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntNeqIR (IR.Reg r1) (IR.Reg r2))) = do+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jne () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntRel IR.IntLeqIR (IR.Reg r1) (IR.Reg r2))) = do+    { l0 <- getLabel+    ; l1 <- getLabel+    ; l2 <- getLabel+    ; pure [ CmpRegReg () (toAbsReg r1) (toAbsReg r2), Jle () l0, Jump () l1, Label () l0, MovABool () (Reg $ toAbsReg r) 1, Jump () l2, Label () l1, MovABool () (Reg $ toAbsReg r) 0, Label () l2 ]+    }+irEmit _ (IR.MovTemp r1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r2) (IR.ConstInt i))) | r1 == r2 = do+    pure [ SubRC () (toAbsReg r1) i ]+irEmit _ (IR.MovTemp r1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r2) (IR.ConstInt i))) | r1 == r2 = do+    pure [ AddRC () (toAbsReg r1) i ]+irEmit env (IR.CCall (is, []) b) | all (\i -> size' env i <= 8) is && length is <= 6 =+    pure [NasmMacro0 () "callersave", CallBS () b, NasmMacro0 () "callerrestore"]+irEmit env (IR.CCall (is, [o]) b) | all (\i -> size' env i <= 8) is && size' env o <= 8 && length is <= 6 =+    pure [NasmMacro0 () "callersave", CallBS () b, NasmMacro0 () "callerrestore"]+-- For 128-bit returns we'd have to use rax and rdx+irEmit env (IR.WrapKCall Cabi (is, [o]) n l) | all (\i -> size' env i <= 8) is && size' env o <= 8 && length is <= 6 = do+    { let offs = scanl' (+) 0 (fmap (size' env) is)+    ; let totalSize = sizeStack env is+    ; let argRegs = [CArg1, CArg2, CArg3, CArg4, CArg5, CArg6]+    ; pure $ [BSLabel () n, MovRL () DataPointer "kempe_data", NasmMacro0 () "calleesave"] ++ zipWith (\r i-> MovAR () (AddrRCPlus DataPointer i) r) argRegs offs ++ [AddRC () DataPointer totalSize, Call () l, MovRA () CRet (AddrRCMinus DataPointer (size' env o)), NasmMacro0 () "calleerestore", Ret ()] -- TODO: bytes on the stack eh+    }+irEmit _ (IR.WrapKCall Kabi (_, _) n l) =+    pure [BSLabel () n, Call () l, Ret ()]+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ConstInt8 i)) =+    pure [ MovACi8 () (Reg $ toAbsReg r) i ]+    -- see: https://github.com/cirosantilli/x86-assembly-cheat/blob/master/x86-64/movabs.asm for why we don't do this ^ for words+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntXorIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () r' (toAbsReg r1), XorRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () r' (toAbsReg r1), AddRR () r' (toAbsReg r2), MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.WordShiftRIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () r' (toAbsReg r1), ShiftRRR () r' ShiftExponent, MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.WordShiftLIR (IR.Reg r1) (IR.Reg r2))) = do+    { r' <- allocReg64+    ; pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () r' (toAbsReg r1), ShiftLRR () r' ShiftExponent, MovAR () (Reg $ toAbsReg r) r' ]+    }+irEmit _ (IR.MovMem (IR.Reg r) _ (IR.ExprIntBinOp IR.IntModIR (IR.Reg r1) (IR.Reg r2))) =+    -- QuotRes is rax, so move r1 to rax first+    pure [ MovRR () QuotRes (toAbsReg r1), Cqo (), IdivR () (toAbsReg r2), MovAR () (Reg $ toAbsReg r) RemRes ]+irEmit _ (IR.MovTemp r e) = evalE e r+irEmit _ (IR.MovMem (IR.Reg r) 1 e) = do+    { r' <- allocTemp8+    ; put <- evalE e r'+    ; pure $ put ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')]+    }+irEmit _ (IR.MovMem e 8 e') = do+    { r <- allocTemp64+    ; r' <- allocTemp64+    ; eEval <- evalE e r+    ; e'Eval <- evalE e' r'+    ; pure (eEval ++ e'Eval ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')])+    }+irEmit _ (IR.MovMem e 1 e') = do+    { r <- allocTemp64+    ; r' <- allocTemp8+    ; eEval <- evalE e r+    ; e'Eval <- evalE e' r'+    ; pure (eEval ++ e'Eval ++ [MovAR () (Reg $ toAbsReg r) (toAbsReg r')])+    }+irEmit _ (IR.CJump (IR.Mem 1 (IR.Reg r)) l l') =+    pure [CmpAddrBool () (Reg (toAbsReg r)) 1, Je () l, Jump () l']+irEmit _ (IR.MJump (IR.Mem 1 (IR.Reg r)) l) =+    pure [CmpAddrBool () (Reg (toAbsReg r)) 1, Je () l]+irEmit _ (IR.CJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r) (IR.ConstInt i))) l l') =+    pure [CmpAddrBool () (AddrRCMinus (toAbsReg r) i) 1, Je () l, Jump () l']+irEmit _ (IR.MJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r) (IR.ConstInt i))) l) =+    pure [CmpAddrBool () (AddrRCMinus (toAbsReg r) i) 1, Je () l]+irEmit _ (IR.CJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r) (IR.ConstInt i))) l l') =+    pure [CmpAddrBool () (AddrRCPlus (toAbsReg r) i) 1, Je () l, Jump () l']+irEmit _ (IR.MJump (IR.Mem 1 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r) (IR.ConstInt i))) l) =+    pure [CmpAddrBool () (AddrRCPlus (toAbsReg r) i) 1, Je () l]+irEmit _ (IR.CJump e l l') = do+    { r <- allocTemp8+    ; bEval <- evalE e r+    ; pure (bEval ++ [CmpRegBool () (toAbsReg r) 1, Je () l, Jump () l'])+    }+irEmit _ (IR.MJump (IR.EqByte (IR.Mem 1 (IR.Reg r)) (IR.ConstTag b)) l) =+    pure [CmpAddrBool () (Reg $ toAbsReg r) b, Je () l]+irEmit _ (IR.MJump (IR.EqByte e0 e1) l) = do+    { r0 <- allocTemp8+    ; r1 <- allocTemp8+    ; placeE0 <- evalE e0 r0+    ; placeE1 <- evalE e1 r1+    ; pure $ placeE0 ++ placeE1 ++ [CmpRegReg () (toAbsReg r0) (toAbsReg r1), Je () l]+    }+irEmit _ (IR.MJump e l) = do+    { r <- allocTemp8+    ; bEval <- evalE e r+    ; pure (bEval ++ [CmpRegBool () (toAbsReg r) 1, Je () l])+    }++-- | Code to evaluate and put some expression in a chosen 'Temp'+--+-- This more or less conforms to maximal munch.+evalE :: IR.Exp -> IR.Temp -> WriteM [X86 AbsReg ()]+evalE (IR.ConstInt i) r                                             = pure [MovRC () (toAbsReg r) i]+evalE (IR.ConstBool b) r                                            = pure [MovRCBool () (toAbsReg r) (toByte b)]+evalE (IR.ConstInt8 i) r                                            = pure [MovRCi8 () (toAbsReg r) i]+evalE (IR.ConstWord w) r                                            = pure [MovRWord () (toAbsReg r) w]+evalE (IR.ConstTag b) r                                             = pure [MovRCTag () (toAbsReg r) b]+evalE (IR.Reg r') r                                                 = pure [MovRR () (toAbsReg r) (toAbsReg r')]+evalE (IR.Mem _ (IR.Reg r1)) r                                      = pure [MovRA () (toAbsReg r) (Reg $ toAbsReg r1) ] -- TODO: sanity check reg/mem access size?+evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i)) r | r == r1 = pure [SubRC () (toAbsReg r) i]+evalE (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt i)) r  | r == r1 = pure [AddRC () (toAbsReg r) i]+evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt 0)) r = pure [MovRR () (toAbsReg r) (toAbsReg r1)]+evalE (IR.Mem 8 (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i))) r =+    pure [ MovRA () (toAbsReg r) (AddrRCMinus (toAbsReg r1) i) ]+evalE (IR.Mem 8 (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.ConstInt i))) r =+    pure [ MovRA () (toAbsReg r) (AddrRCPlus (toAbsReg r1) i) ]+evalE (IR.Mem _ e) r = do -- don't need to check size b/c we're storing in r+    { r' <- allocTemp64+    ; placeE <- evalE e r'+    ; pure $ placeE ++ [MovRA () (toAbsReg r) (Reg $ toAbsReg r')]+    }+evalE (IR.ExprIntBinOp IR.IntPlusIR (IR.Reg r1) (IR.Reg r2)) r =+    pure [ MovRR () (toAbsReg r) (toAbsReg r1), AddRR () (toAbsReg r) (toAbsReg r2) ]+evalE (IR.ExprIntBinOp IR.IntTimesIR (IR.Reg r1) (IR.Reg r2)) r = do+    pure [ MovRR () (toAbsReg r) (toAbsReg r1), ImulRR () (toAbsReg r) (toAbsReg r2) ]+evalE (IR.ExprIntBinOp IR.IntXorIR (IR.Reg r1) (IR.Reg r2)) r = do+    pure [ MovRR () (toAbsReg r) (toAbsReg r1), XorRR () (toAbsReg r) (toAbsReg r2) ]+evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.ConstInt i)) r = do+    pure [ MovRR () (toAbsReg r) (toAbsReg r1), SubRC () (toAbsReg r) i ]+evalE (IR.ExprIntBinOp IR.IntMinusIR (IR.Reg r1) (IR.Reg r2)) r = do+    pure [ MovRR () (toAbsReg r) (toAbsReg r1), SubRR () (toAbsReg r) (toAbsReg r2) ]+-- FIXME: because my linear register allocator is shitty, I can't keep+-- registers across jumps... so evaluating = or < as an expression in+-- general is hard ?+evalE (IR.ExprIntBinOp IR.WordShiftLIR (IR.Reg r1) (IR.Reg r2)) r =+    pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () (toAbsReg r) (toAbsReg r1), ShiftLRR () (toAbsReg r) ShiftExponent ]+evalE (IR.ExprIntBinOp IR.WordShiftRIR (IR.Reg r1) (IR.Reg r2)) r = -- FIXME: maximal munch use evalE recursively+    pure [ MovRR () ShiftExponent (toAbsReg r2), MovRR () (toAbsReg r) (toAbsReg r1), ShiftRRR () (toAbsReg r) ShiftExponent]+evalE (IR.ExprIntBinOp IR.WordShiftLIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp8+    ; placeE0 <- evalE e0 r0+    ; placeE1 <- evalE e1 r1+    ; pure $ placeE0 ++ placeE1 ++ [ MovRR () ShiftExponent (toAbsReg r0), MovRR () (toAbsReg r) (toAbsReg r1), ShiftLRR () (toAbsReg r) ShiftExponent ]+    }+evalE (IR.ExprIntBinOp IR.WordShiftRIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp8+    ; placeE0 <- evalE e0 r0+    ; placeE1 <- evalE e1 r1+    ; pure $ placeE0 ++ placeE1 ++ [ MovRR () ShiftExponent (toAbsReg r0), MovRR () (toAbsReg r) (toAbsReg r1), ShiftRRR () (toAbsReg r) ShiftExponent ]+    }+evalE (IR.ExprIntBinOp IR.IntModIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    -- QuotRes is rax, so move r1 to rax first+    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), Cqo (), IdivR () (toAbsReg r1), MovRR () (toAbsReg r) RemRes ]+    }+evalE (IR.ExprIntBinOp IR.IntDivIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), Cqo (), IdivR () (toAbsReg r1), MovRR () (toAbsReg r) QuotRes ]+    }+evalE (IR.ExprIntBinOp IR.WordDivIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), XorRR () RemRes RemRes, DivR () (toAbsReg r1), MovRR () (toAbsReg r) QuotRes ]+    }+evalE (IR.ExprIntBinOp IR.WordModIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () QuotRes (toAbsReg r0), XorRR () RemRes RemRes, DivR () (toAbsReg r1), MovRR () (toAbsReg r) RemRes ]+    }+evalE (IR.BoolBinOp IR.BoolAnd e0 e1) r = do+    { r0 <- allocTemp8+    ; r1 <- allocTemp8+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), AndRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.BoolBinOp IR.BoolOr e0 e1) r = do+    { r0 <- allocTemp8+    ; r1 <- allocTemp8+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), OrRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.BoolBinOp IR.BoolXor e0 e1) r = do+    { r0 <- allocTemp8+    ; r1 <- allocTemp8+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), XorRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.ExprIntBinOp IR.IntMinusIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), SubRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.ExprIntBinOp IR.IntPlusIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), AddRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.ExprIntBinOp IR.IntTimesIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), ImulRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.ExprIntBinOp IR.IntXorIR e0 e1) r = do+    { r0 <- allocTemp64+    ; r1 <- allocTemp64+    ; placeE <- evalE e0 r0+    ; placeE' <- evalE e1 r1+    ; pure $ placeE ++ placeE' ++ [ MovRR () (toAbsReg r) (toAbsReg r0), XorRR () (toAbsReg r) (toAbsReg r1) ]+    }+evalE (IR.PopcountIR e0) r = do+    { r' <- allocTemp64+    ; placeE <- evalE e0 r'+    ; pure $ placeE ++ [ PopcountRR () (toAbsReg r) (toAbsReg r') ]+    }+evalE (IR.IntNegIR e) r = do+    { placeE <- evalE e r+    ; pure $ placeE ++ [ NegR () (toAbsReg r) ]+    }++toByte :: Bool -> Word8+toByte False = 0+toByte True  = 1++-- I wonder if I could use a hylo.?

@@ -10,9 +10,9 @@ import           Kempe.AST import           Kempe.AST.Size import           Kempe.Asm.Liveness-import           Kempe.Asm.X86 import           Kempe.Asm.X86.ControlFlow import           Kempe.Asm.X86.Linear+import           Kempe.Asm.X86.Trans import           Kempe.Asm.X86.Type import           Kempe.Check.Restrict import           Kempe.IR

@@ -503,7 +503,7 @@     pure $ StackType (S.singleton aN) [TyVar () aN] [] tyPattern PatternInt{} = pure $ StackType S.empty [TyBuiltin () TyInt] [] tyPattern PatternBool{} = pure $ StackType S.empty [TyBuiltin () TyBool] []-tyPattern (PatternCons _ tn) = renameStack =<< (flipStackType <$> consLookup (void tn))+tyPattern (PatternCons _ tn) = renameStack . flipStackType =<< consLookup (void tn)  assignPattern :: Pattern b a -> TypeM () (StackType (), Pattern (StackType ()) (StackType ())) assignPattern (PatternInt _ i) =@@ -512,7 +512,7 @@ assignPattern (PatternBool _ i) =     let sTy = StackType S.empty [TyBuiltin () TyBool] []         in pure (sTy, PatternBool sTy i)-assignPattern (PatternCons _ tn) = do { ty <- renameStack =<< (flipStackType <$> consLookup (void tn)) ; pure (ty, PatternCons ty (tn $> ty)) }+assignPattern (PatternCons _ tn) = do { ty <- renameStack . flipStackType =<< consLookup (void tn) ; pure (ty, PatternCons ty (tn $> ty)) } assignPattern PatternWildcard{} = do     aN <- dummyName "a"     let resType = StackType (S.singleton aN) [TyVar () aN] []

@@ -44,14 +44,279 @@ (ret)  kmp3:-(movtemp datapointer (- (reg datapointer) (int 25)))+(movtemp datapointer (- (reg datapointer) (int 17)))+(call kmp1)+(movmem (- (reg datapointer) (int 0)) (mem [1] (+ (reg datapointer) (int 17))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 18))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 19))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 20))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 21))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 22))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 23))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 24))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 25))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 26))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 27))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 28))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 29))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 30))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 31))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 32))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 33))))+(movmem (- (reg datapointer) (int 0)) (mem [8] (- (reg datapointer) (int 24))))+(movmem (- (reg datapointer) (int 24)) (mem [8] (- (reg datapointer) (int 16))))+(movmem (- (reg datapointer) (int 16)) (mem [8] (- (reg datapointer) (int 0))))+(movtemp datapointer (- (reg datapointer) (int 8))) (movtemp t_5 (mem [8] (reg datapointer)))-(movmem (reg datapointer) (~ (reg t_5)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_6 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (* (reg t_6) (reg t_5)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_7 (mem [8] (reg datapointer)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_8 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (* (reg t_8) (reg t_7))) (movtemp datapointer (+ (reg datapointer) (int 8)))+(movmem (- (reg datapointer) (int 0)) (mem [8] (+ (reg datapointer) (int 8))))+(movtemp t_9 (mem [8] (reg datapointer)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_10 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (- (reg t_10) (reg t_9)))+(movtemp datapointer (+ (reg datapointer) (int 8)))+(ret)++kmp4:+(movmem (- (reg datapointer) (int 0)) (mem [1] (- (reg datapointer) (int 17))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 16))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 15))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 14))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 13))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 12))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 11))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 10))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 9))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 8))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 7))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 6))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 5))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 4))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 3))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 2))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 34))))+(movmem (- (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 33))))+(movmem (- (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 32))))+(movmem (- (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 31))))+(movmem (- (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 30))))+(movmem (- (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 29))))+(movmem (- (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 28))))+(movmem (- (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 27))))+(movmem (- (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 26))))+(movmem (- (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 25))))+(movmem (- (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 24))))+(movmem (- (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 23))))+(movmem (- (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 22))))+(movmem (- (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 21))))+(movmem (- (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 20))))+(movmem (- (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 19))))+(movmem (- (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 18))))+(movtemp datapointer (+ (reg datapointer) (int 17)))+(movmem (- (reg datapointer) (int 0)) (mem [1] (- (reg datapointer) (int 34))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 33))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 32))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 31))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 30))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 29))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 28))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 27))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 26))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 25))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 24))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 23))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 22))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 21))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 20))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 19))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 18))))+(movmem (- (reg datapointer) (int 34)) (mem [1] (- (reg datapointer) (int 17))))+(movmem (- (reg datapointer) (int 33)) (mem [1] (- (reg datapointer) (int 16))))+(movmem (- (reg datapointer) (int 32)) (mem [1] (- (reg datapointer) (int 15))))+(movmem (- (reg datapointer) (int 31)) (mem [1] (- (reg datapointer) (int 14))))+(movmem (- (reg datapointer) (int 30)) (mem [1] (- (reg datapointer) (int 13))))+(movmem (- (reg datapointer) (int 29)) (mem [1] (- (reg datapointer) (int 12))))+(movmem (- (reg datapointer) (int 28)) (mem [1] (- (reg datapointer) (int 11))))+(movmem (- (reg datapointer) (int 27)) (mem [1] (- (reg datapointer) (int 10))))+(movmem (- (reg datapointer) (int 26)) (mem [1] (- (reg datapointer) (int 9))))+(movmem (- (reg datapointer) (int 25)) (mem [1] (- (reg datapointer) (int 8))))+(movmem (- (reg datapointer) (int 24)) (mem [1] (- (reg datapointer) (int 7))))+(movmem (- (reg datapointer) (int 23)) (mem [1] (- (reg datapointer) (int 6))))+(movmem (- (reg datapointer) (int 22)) (mem [1] (- (reg datapointer) (int 5))))+(movmem (- (reg datapointer) (int 21)) (mem [1] (- (reg datapointer) (int 4))))+(movmem (- (reg datapointer) (int 20)) (mem [1] (- (reg datapointer) (int 3))))+(movmem (- (reg datapointer) (int 19)) (mem [1] (- (reg datapointer) (int 2))))+(movmem (- (reg datapointer) (int 18)) (mem [1] (- (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 0))))+(movmem (- (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 2))))+(movmem (- (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 3))))+(movmem (- (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 4))))+(movmem (- (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 5))))+(movmem (- (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 6))))+(movmem (- (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 7))))+(movmem (- (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 8))))+(movmem (- (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 9))))+(movmem (- (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 10))))+(movmem (- (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 11))))+(movmem (- (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 12))))+(movmem (- (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 13))))+(movmem (- (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 14))))+(movmem (- (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 15))))+(movmem (- (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 16))))+(movmem (- (reg datapointer) (int 0)) (mem [1] (- (reg datapointer) (int 17))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 16))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 15))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 14))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 13))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 12))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 11))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 10))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 9))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 8))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 7))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 6))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 5))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 4))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 3))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 2))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 34))))+(movmem (- (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 33))))+(movmem (- (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 32))))+(movmem (- (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 31))))+(movmem (- (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 30))))+(movmem (- (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 29))))+(movmem (- (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 28))))+(movmem (- (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 27))))+(movmem (- (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 26))))+(movmem (- (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 25))))+(movmem (- (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 24))))+(movmem (- (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 23))))+(movmem (- (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 22))))+(movmem (- (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 21))))+(movmem (- (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 20))))+(movmem (- (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 19))))+(movmem (- (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 18))))+(movtemp datapointer (+ (reg datapointer) (int 17)))+(movmem (- (reg datapointer) (int 0)) (mem [1] (- (reg datapointer) (int 34))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 33))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 32))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 31))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 30))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 29))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 28))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 27))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 26))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 25))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 24))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 23))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 22))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 21))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 20))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 19))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 18))))+(movmem (- (reg datapointer) (int 34)) (mem [1] (- (reg datapointer) (int 17))))+(movmem (- (reg datapointer) (int 33)) (mem [1] (- (reg datapointer) (int 16))))+(movmem (- (reg datapointer) (int 32)) (mem [1] (- (reg datapointer) (int 15))))+(movmem (- (reg datapointer) (int 31)) (mem [1] (- (reg datapointer) (int 14))))+(movmem (- (reg datapointer) (int 30)) (mem [1] (- (reg datapointer) (int 13))))+(movmem (- (reg datapointer) (int 29)) (mem [1] (- (reg datapointer) (int 12))))+(movmem (- (reg datapointer) (int 28)) (mem [1] (- (reg datapointer) (int 11))))+(movmem (- (reg datapointer) (int 27)) (mem [1] (- (reg datapointer) (int 10))))+(movmem (- (reg datapointer) (int 26)) (mem [1] (- (reg datapointer) (int 9))))+(movmem (- (reg datapointer) (int 25)) (mem [1] (- (reg datapointer) (int 8))))+(movmem (- (reg datapointer) (int 24)) (mem [1] (- (reg datapointer) (int 7))))+(movmem (- (reg datapointer) (int 23)) (mem [1] (- (reg datapointer) (int 6))))+(movmem (- (reg datapointer) (int 22)) (mem [1] (- (reg datapointer) (int 5))))+(movmem (- (reg datapointer) (int 21)) (mem [1] (- (reg datapointer) (int 4))))+(movmem (- (reg datapointer) (int 20)) (mem [1] (- (reg datapointer) (int 3))))+(movmem (- (reg datapointer) (int 19)) (mem [1] (- (reg datapointer) (int 2))))+(movmem (- (reg datapointer) (int 18)) (mem [1] (- (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 0))))+(movmem (- (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 1))))+(movmem (- (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 2))))+(movmem (- (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 3))))+(movmem (- (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 4))))+(movmem (- (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 5))))+(movmem (- (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 6))))+(movmem (- (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 7))))+(movmem (- (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 8))))+(movmem (- (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 9))))+(movmem (- (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 10))))+(movmem (- (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 11))))+(movmem (- (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 12))))+(movmem (- (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 13))))+(movmem (- (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 14))))+(movmem (- (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 15))))+(movmem (- (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 16))))+(movtemp datapointer (- (reg datapointer) (int 17)))+(call kmp1)+(movmem (- (reg datapointer) (int 0)) (mem [1] (+ (reg datapointer) (int 17))))+(movmem (+ (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 18))))+(movmem (+ (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 19))))+(movmem (+ (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 20))))+(movmem (+ (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 21))))+(movmem (+ (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 22))))+(movmem (+ (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 23))))+(movmem (+ (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 24))))+(movmem (+ (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 25))))+(movmem (+ (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 26))))+(movmem (+ (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 27))))+(movmem (+ (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 28))))+(movmem (+ (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 29))))+(movmem (+ (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 30))))+(movmem (+ (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 31))))+(movmem (+ (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 32))))+(movmem (+ (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 33))))+(movtemp datapointer (- (reg datapointer) (int 16)))+(movtemp t_11 (mem [8] (reg datapointer)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_12 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (* (reg t_12) (reg t_11)))+(movtemp datapointer (+ (reg datapointer) (int 8)))+(movmem (- (reg datapointer) (int 0)) (mem [8] (+ (reg datapointer) (int 8))))+(movtemp datapointer (+ (reg datapointer) (int 8)))+(movmem (- (reg datapointer) (int 0)) (mem [8] (- (reg datapointer) (int 16))))+(movmem (- (reg datapointer) (int 16)) (mem [8] (- (reg datapointer) (int 8))))+(movmem (- (reg datapointer) (int 8)) (mem [8] (- (reg datapointer) (int 0))))+(movtemp datapointer (- (reg datapointer) (int 16)))+(movtemp t_13 (mem [8] (reg datapointer)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_14 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (* (reg t_14) (reg t_13)))+(movtemp datapointer (+ (reg datapointer) (int 8)))+(movmem (- (reg datapointer) (int 0)) (mem [8] (+ (reg datapointer) (int 8))))+(movtemp t_15 (mem [8] (reg datapointer)))+(movtemp datapointer (- (reg datapointer) (int 8)))+(movtemp t_16 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (+ (reg t_16) (reg t_15)))+(call kmp3)+(movmem (- (reg datapointer) (int 0)) (mem [8] (+ (reg datapointer) (int 8))))+(movtemp datapointer (+ (reg datapointer) (int 8))) (movmem (reg datapointer) (tag 0x0)) (movtemp datapointer (+ (reg datapointer) (int 1))) (ret) +kmp5:+(movtemp datapointer (- (reg datapointer) (int 25)))+(movtemp t_17 (mem [8] (reg datapointer)))+(movmem (reg datapointer) (~ (reg t_17)))+(movtemp datapointer (+ (reg datapointer) (int 8)))+(movmem (reg datapointer) (tag 0x0))+(movtemp datapointer (+ (reg datapointer) (int 1)))+(ret)+ export add {Gaussian_1 Gaussian_1 -- Gaussian_1} kmp2 -export conjugate {Gaussian_1 -- Gaussian_1} kmp3+export conjugate {Gaussian_1 -- Gaussian_1} kmp5++export mult {Gaussian_1 Gaussian_1 -- Gaussian_1} kmp4