{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections     #-}

module Dbg ( dumpAAbs
           , dumpAarch64
           , dumpAAss
           , dumpX86G
           , dumpX86Abs
           , dumpX86Liveness
           , dumpC
           , dumpCI
           , dumpIR
           , dumpDomTree
           , dumpLoop
           , dumpX86Intervals
           , dumpALiveness
           , dumpAIntervals
           , dumpX86Ass
           , printParsed
           , printTypes
           , topt
           , nasm
           , pBIO, dtxt, dAtxt
           , edAtxt, eDtxt
           , module P
           ) where

import           A
import qualified Asm.Aarch64          as Aarch64
import qualified Asm.Aarch64.Byte     as Aarch64
import qualified Asm.Aarch64.P        as Aarch64
import           Asm.Aarch64.T
import           Asm.L
import           Asm.LI
import           Asm.M
import qualified Asm.X86              as X86
import           Asm.X86.Byte
import           Asm.X86.P
import           Asm.X86.Trans
import           C
import           C.Alloc
import qualified C.Trans              as C
import           CF
import           Control.Exception    (throw, throwIO)
import           Control.Monad        ((<=<))
import           Data.Bifunctor       (second)
import qualified Data.ByteString      as BS
import qualified Data.ByteString.Lazy as BSL
import qualified Data.IntMap          as IM
import qualified Data.IntSet          as IS
import qualified Data.Text            as T
import qualified Data.Text.IO         as TIO
import           Data.Tree            (drawTree)
import           Data.Tuple           (swap)
import           Data.Tuple.Extra     (fst3)
import           Data.Word            (Word64)
import           IR
import           IR.Hoist
import           L
import           Numeric              (showHex)
import           P
import           Prettyprinter        (Doc, Pretty (..), comma, concatWith, punctuate, space, (<+>))
import           Prettyprinter.Ext
import           Ty

pBIO :: BSL.ByteString -> IO ()
pBIO :: ByteString -> IO ()
pBIO = (Err AlexPosn -> IO ())
-> (Text -> IO ()) -> Either (Err AlexPosn) Text -> IO ()
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Err AlexPosn -> IO ()
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO Text -> IO ()
TIO.putStr (Either (Err AlexPosn) Text -> IO ())
-> (ByteString -> IO (Either (Err AlexPosn) Text))
-> ByteString
-> IO ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ByteString -> IO (Either (Err AlexPosn) Text)
dtxt

comm :: Either a (IO b) -> IO (Either a b)
comm :: forall a b. Either a (IO b) -> IO (Either a b)
comm (Left a
err) = Either a b -> IO (Either a b)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure(a -> Either a b
forall a b. a -> Either a b
Left a
err)
comm (Right IO b
x)  = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> IO b -> IO (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO b
x

wIdM :: Functor m => ((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM :: forall (m :: * -> *) c a b.
Functor m =>
((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM (c, a) -> m b
f (c
d, a
x) = (a
x,)(b -> (a, b)) -> m b -> m (a, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>(c, a) -> m b
f (c
d, a
x)

dtxt :: BSL.ByteString -> IO (Either (Err AlexPosn) T.Text)
dtxt :: ByteString -> IO (Either (Err AlexPosn) Text)
dtxt = (ByteString
 -> Either
      (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> ByteString -> IO (Either (Err AlexPosn) Text)
forall {a} {a} {a}.
(a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]))
-> a -> IO (Either a Text)
asmTxt ByteString
-> Either
     (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
x86G

eDtxt :: Int -> E a -> IO (Either (Err a) T.Text)
eDtxt :: forall a. Int -> E a -> IO (Either (Err a) Text)
eDtxt Int
k = (E a
 -> Either (Err a) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> E a -> IO (Either (Err a) Text)
forall {a} {a} {a}.
(a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]))
-> a -> IO (Either a Text)
asmTxt (Int
-> E a
-> Either (Err a) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
forall a.
Int
-> E a
-> Either (Err a) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
ex86G Int
k)

asmTxt :: (a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]))
-> a -> IO (Either a Text)
asmTxt a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
f = (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
 -> Either a Text)
-> IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
-> IO (Either a Text)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((([X86 X86Reg FX86Reg F2X86 a], [ByteString]) -> Text)
-> Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
-> Either a Text
forall a b. (a -> b) -> Either a a -> Either a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Text] -> Text
T.unlines([Text] -> Text)
-> (([X86 X86Reg FX86Reg F2X86 a], [ByteString]) -> [Text])
-> ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((X86 X86Reg FX86Reg F2X86 a, ByteString) -> Text)
-> [(X86 X86Reg FX86Reg F2X86 a, ByteString)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (X86 X86Reg FX86Reg F2X86 a, ByteString) -> Text
forall a. Pretty a => (a, ByteString) -> Text
present([(X86 X86Reg FX86Reg F2X86 a, ByteString)] -> [Text])
-> (([X86 X86Reg FX86Reg F2X86 a], [ByteString])
    -> [(X86 X86Reg FX86Reg F2X86 a, ByteString)])
-> ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
-> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([X86 X86Reg FX86Reg F2X86 a]
 -> [ByteString] -> [(X86 X86Reg FX86Reg F2X86 a, ByteString)])
-> ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
-> [(X86 X86Reg FX86Reg F2X86 a, ByteString)]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [X86 X86Reg FX86Reg F2X86 a]
-> [ByteString] -> [(X86 X86Reg FX86Reg F2X86 a, ByteString)]
forall {reg} {freg} {f2} {a}.
[X86 reg freg f2 a]
-> [ByteString] -> [(X86 reg freg f2 a, ByteString)]
zipS)) (IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
 -> IO (Either a Text))
-> (a
    -> IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString])))
-> a
-> IO (Either a Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
-> IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
forall a b. Either a (IO b) -> IO (Either a b)
comm (Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
 -> IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString])))
-> (a
    -> Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString])))
-> a
-> IO (Either a ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
 -> IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
-> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
-> Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
forall a b. (a -> b) -> Either a a -> Either a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
 -> IO [ByteString])
-> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
-> IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString])
forall (m :: * -> *) c a b.
Functor m =>
((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]) -> IO [ByteString]
forall {a}.
(IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]) -> IO [ByteString]
dbgFp) (Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
 -> Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString])))
-> (a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a]))
-> a
-> Either a (IO ([X86 X86Reg FX86Reg F2X86 a], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 a])
f
    where zipS :: [X86 reg freg f2 a]
-> [ByteString] -> [(X86 reg freg f2 a, ByteString)]
zipS [] []                 = []
          zipS (x :: X86 reg freg f2 a
x@X86.Label{}:[X86 reg freg f2 a]
xs) [ByteString]
ys = (X86 reg freg f2 a
x,ByteString
BS.empty)(X86 reg freg f2 a, ByteString)
-> [(X86 reg freg f2 a, ByteString)]
-> [(X86 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[X86 reg freg f2 a]
-> [ByteString] -> [(X86 reg freg f2 a, ByteString)]
zipS [X86 reg freg f2 a]
xs [ByteString]
ys
          zipS (X86 reg freg f2 a
x:[X86 reg freg f2 a]
xs) (ByteString
y:[ByteString]
ys)         = (X86 reg freg f2 a
x,ByteString
y)(X86 reg freg f2 a, ByteString)
-> [(X86 reg freg f2 a, ByteString)]
-> [(X86 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[X86 reg freg f2 a]
-> [ByteString] -> [(X86 reg freg f2 a, ByteString)]
zipS [X86 reg freg f2 a]
xs [ByteString]
ys

edAtxt :: Int -> E a -> IO (Either (Err a) T.Text)
edAtxt :: forall a. Int -> E a -> IO (Either (Err a) Text)
edAtxt Int
k = (E a
 -> Either (Err a) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> E a -> IO (Either (Err a) Text)
forall {a} {a}.
(a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> a -> IO (Either a Text)
aAsmTxt (Int
-> E a
-> Either (Err a) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
forall a.
Int
-> E a
-> Either (Err a) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
eAarch64 Int
k)

dAtxt :: BSL.ByteString -> IO (Either (Err AlexPosn) T.Text)
dAtxt :: ByteString -> IO (Either (Err AlexPosn) Text)
dAtxt = (ByteString
 -> Either
      (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> ByteString -> IO (Either (Err AlexPosn) Text)
forall {a} {a}.
(a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> a -> IO (Either a Text)
aAsmTxt ByteString
-> Either
     (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
aarch64

aAsmTxt :: (a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> a -> IO (Either a Text)
aAsmTxt a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
f = (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString])
 -> Either a Text)
-> IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
-> IO (Either a Text)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((([AArch64 AReg FAReg F2Reg ()], [ByteString]) -> Text)
-> Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString])
-> Either a Text
forall a b. (a -> b) -> Either a a -> Either a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Text] -> Text
T.unlines([Text] -> Text)
-> (([AArch64 AReg FAReg F2Reg ()], [ByteString]) -> [Text])
-> ([AArch64 AReg FAReg F2Reg ()], [ByteString])
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((AArch64 AReg FAReg F2Reg (), ByteString) -> Text)
-> [(AArch64 AReg FAReg F2Reg (), ByteString)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (AArch64 AReg FAReg F2Reg (), ByteString) -> Text
forall a. Pretty a => (a, ByteString) -> Text
present([(AArch64 AReg FAReg F2Reg (), ByteString)] -> [Text])
-> (([AArch64 AReg FAReg F2Reg ()], [ByteString])
    -> [(AArch64 AReg FAReg F2Reg (), ByteString)])
-> ([AArch64 AReg FAReg F2Reg ()], [ByteString])
-> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([AArch64 AReg FAReg F2Reg ()]
 -> [ByteString] -> [(AArch64 AReg FAReg F2Reg (), ByteString)])
-> ([AArch64 AReg FAReg F2Reg ()], [ByteString])
-> [(AArch64 AReg FAReg F2Reg (), ByteString)]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [AArch64 AReg FAReg F2Reg ()]
-> [ByteString] -> [(AArch64 AReg FAReg F2Reg (), ByteString)]
forall {reg} {freg} {f2} {a}.
[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS)) (IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
 -> IO (Either a Text))
-> (a
    -> IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString])))
-> a
-> IO (Either a Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
-> IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
forall a b. Either a (IO b) -> IO (Either a b)
comm (Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
 -> IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString])))
-> (a
    -> Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString])))
-> a
-> IO (Either a ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
 -> IO ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
-> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
-> Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
forall a b. (a -> b) -> Either a a -> Either a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
 -> IO [ByteString])
-> (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
-> IO ([AArch64 AReg FAReg F2Reg ()], [ByteString])
forall (m :: * -> *) c a b.
Functor m =>
((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]) -> IO [ByteString]
Aarch64.dbgFp) (Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
 -> Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString])))
-> (a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> a
-> Either a (IO ([AArch64 AReg FAReg F2Reg ()], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
f
    where zipS :: [AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [] []                                    = []
          zipS (x :: AArch64 reg freg f2 a
x@Aarch64.C{}:[AArch64 reg freg f2 a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:ByteString
y4:[ByteString]
ys)   = (AArch64 reg freg f2 a
x,ByteString
y0)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y1)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y2)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y3)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y4)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [AArch64 reg freg f2 a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg f2 a
x@Aarch64.MovRCf{}:[AArch64 reg freg f2 a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:[ByteString]
ys) = (AArch64 reg freg f2 a
x,ByteString
y0)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y1)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y2)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y3)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [AArch64 reg freg f2 a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg f2 a
x@Aarch64.LdrRL{}:[AArch64 reg freg f2 a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:[ByteString]
ys)  = (AArch64 reg freg f2 a
x,ByteString
y0)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y1)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y2)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg f2 a
x,ByteString
y3)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [AArch64 reg freg f2 a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg f2 a
x@Aarch64.Label{}:[AArch64 reg freg f2 a]
xs) [ByteString]
ys                = (AArch64 reg freg f2 a
x,ByteString
BS.empty)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [AArch64 reg freg f2 a]
xs [ByteString]
ys
          zipS (AArch64 reg freg f2 a
x:[AArch64 reg freg f2 a]
xs) (ByteString
y:[ByteString]
ys)                            = (AArch64 reg freg f2 a
x,ByteString
y)(AArch64 reg freg f2 a, ByteString)
-> [(AArch64 reg freg f2 a, ByteString)]
-> [(AArch64 reg freg f2 a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg f2 a]
-> [ByteString] -> [(AArch64 reg freg f2 a, ByteString)]
zipS [AArch64 reg freg f2 a]
xs [ByteString]
ys

rightPad :: Int -> T.Text -> T.Text
rightPad :: Int -> Text -> Text
rightPad Int
n Text
str = Int -> Text -> Text
T.take Int
n (Text
str Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text -> Text
T.replicate Int
n Text
" ")

present :: Pretty a => (a, BS.ByteString) -> T.Text
present :: forall a. Pretty a => (a, ByteString) -> Text
present (a
x, ByteString
b) = Int -> Text -> Text
rightPad Int
45 (a -> Text
forall a. Pretty a => a -> Text
ptxt a
x) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ByteString -> Text
he ByteString
b
    where he :: ByteString -> Text
he = [Text] -> Text
T.unwords([Text] -> Text) -> (ByteString -> [Text]) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Word8 -> Text) -> [Word8] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Text
pad(Text -> Text) -> (Word8 -> Text) -> Word8 -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> Text
T.pack(String -> Text) -> (Word8 -> String) -> Word8 -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$String
"")((String -> String) -> String)
-> (Word8 -> String -> String) -> Word8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Word8 -> String -> String
forall a. Integral a => a -> String -> String
showHex)([Word8] -> [Text])
-> (ByteString -> [Word8]) -> ByteString -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString -> [Word8]
BS.unpack
          pad :: Text -> Text
pad Text
s | Text -> Int
T.length Text
s Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Char -> Text -> Text
T.cons Char
'0' Text
s | Bool
otherwise = Text
s

nasm :: T.Text -> BSL.ByteString -> Doc ann
nasm :: forall ann. Text -> ByteString -> Doc ann
nasm Text
f = (\(IntMap [Word64]
d,Doc ann
i) -> Doc ann
"section .data\n\n" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [(Int, [Word64])] -> Doc ann
forall ann. [(Int, [Word64])] -> Doc ann
nasmD (IntMap [Word64] -> [(Int, [Word64])]
forall a. IntMap a -> [(Int, a)]
IM.toList IntMap [Word64]
d) Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<#> Doc ann
i) ((IntMap [Word64], Doc ann) -> Doc ann)
-> (ByteString -> (IntMap [Word64], Doc ann))
-> ByteString
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([X86 X86Reg FX86Reg F2X86 ()] -> Doc ann)
-> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
-> (IntMap [Word64], Doc ann)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ((Doc ann
forall {a}. Doc a
prolegomena Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<#>)(Doc ann -> Doc ann)
-> ([X86 X86Reg FX86Reg F2X86 ()] -> Doc ann)
-> [X86 X86Reg FX86Reg F2X86 ()]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.[X86 X86Reg FX86Reg F2X86 ()] -> Doc ann
forall isn ann. Pretty isn => [isn] -> Doc ann
pAsm) ((IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
 -> (IntMap [Word64], Doc ann))
-> (ByteString -> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> ByteString
-> (IntMap [Word64], Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Err AlexPosn -> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> ((IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
    -> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> Either
     (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
-> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Err AlexPosn -> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
forall a e. (HasCallStack, Exception e) => e -> a
throw (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
-> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
forall a. a -> a
id (Either
   (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
 -> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> ByteString
-> (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either
     (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
x86G
    where prolegomena :: Doc a
prolegomena = Doc a
"section .text\n\nextern malloc\n\nextern free\n\nglobal " Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
f Doc a -> Doc a -> Doc a
forall a. Doc a -> Doc a -> Doc a
<#> Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
f Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
":"

nasmD :: [(Int, [Word64])] -> Doc ann
nasmD :: forall ann. [(Int, [Word64])] -> Doc ann
nasmD = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
prettyLines ([Doc ann] -> Doc ann)
-> ([(Int, [Word64])] -> [Doc ann]) -> [(Int, [Word64])] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, [Word64]) -> Doc ann) -> [(Int, [Word64])] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, [Word64]) -> Doc ann
forall {a} {ann}. Pretty a => (a, [Word64]) -> Doc ann
nasmArr
    where nasmArr :: (a, [Word64]) -> Doc ann
nasmArr (a
i, [Word64]
ds) = Doc ann
"arr_" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
i Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"dq" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> (Doc ann -> Doc ann -> Doc ann) -> [Doc ann] -> Doc ann
forall (t :: * -> *) ann.
Foldable t =>
(Doc ann -> Doc ann -> Doc ann) -> t (Doc ann) -> Doc ann
concatWith Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
(<>) (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall {a}. Doc a
comma ((Word64 -> Doc ann) -> [Word64] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> Doc ann
forall {ann}. Word64 -> Doc ann
hexn [Word64]
ds))
          hexn :: Word64 -> Doc ann
hexn = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty(String -> Doc ann) -> (Word64 -> String) -> Word64 -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$String
"")((String -> String) -> String)
-> (Word64 -> String -> String) -> Word64 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((String
"0x"String -> String -> String
forall a. [a] -> [a] -> [a]
++)(String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)((String -> String) -> String -> String)
-> (Word64 -> String -> String) -> Word64 -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Word64 -> String -> String
forall a. Integral a => a -> String -> String
showHex

dumpX86Ass :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Ass :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Ass = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((\(IntMap X86Reg
regs, IntMap FX86Reg
fregs, [X86 AbsReg FAbsReg X2Abs ()]
_) -> IntMap X86Reg -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
pR IntMap X86Reg
regs Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<#> IntMap FX86Reg -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
pR IntMap FX86Reg
fregs)((IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()])
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Int
 -> [X86 AbsReg FAbsReg X2Abs ()]
 -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()]))
-> (Int, [X86 AbsReg FAbsReg X2Abs ()])
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()])
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int
-> [X86 AbsReg FAbsReg X2Abs ()]
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()])
gallocOn((Int, [X86 AbsReg FAbsReg X2Abs ()])
 -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()]))
-> (([Stmt], IntMap [Word64], WSt)
    -> (Int, [X86 AbsReg FAbsReg X2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg X2Abs ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
irToX86 WSt
st [Stmt]
x)) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir
    where pR :: Pretty b => IM.IntMap b -> Doc ann; pR :: forall b ann. Pretty b => IntMap b -> Doc ann
pR = IntMap b -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
prettyDumpBinds (IntMap b -> Doc ann)
-> (IntMap b -> IntMap b) -> IntMap b -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int) -> IntMap b -> IntMap b
forall a. (Int -> Int) -> IntMap a -> IntMap a
IM.mapKeys (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
16)

dumpAAss :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAAss :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAAss = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((\(IntMap AReg
regs, IntMap FAReg
fregs, [AArch64 AbsReg FAbsReg F2Abs ()]
_) -> IntMap AReg -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
pR IntMap AReg
regs Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<#> IntMap FAReg -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
pR IntMap FAReg
fregs)((IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()])
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Int
 -> [AArch64 AbsReg FAbsReg F2Abs ()]
 -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()]))
-> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()])
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int
-> [AArch64 AbsReg FAbsReg F2Abs ()]
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()])
Aarch64.gallocOn((Int, [AArch64 AbsReg FAbsReg F2Abs ()])
 -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()]))
-> (([Stmt], IntMap [Word64], WSt)
    -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg F2Abs ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
irToAarch64 WSt
st [Stmt]
x)) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir
    where pR :: Pretty b => IM.IntMap b -> Doc ann; pR :: forall b ann. Pretty b => IntMap b -> Doc ann
pR = IntMap b -> Doc ann
forall b ann. Pretty b => IntMap b -> Doc ann
prettyDumpBinds (IntMap b -> Doc ann)
-> (IntMap b -> IntMap b) -> IntMap b -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int) -> IntMap b -> IntMap b
forall a. (Int -> Int) -> IntMap a -> IntMap a
IM.mapKeys (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
19)

dumpX86G :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86G :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86G = ((IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]) -> Doc ann)
-> Either
     (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm (Either
   (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()]))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either
     (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg F2X86 ()])
x86G

dumpAarch64 :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAarch64 :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAarch64 = ((IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]) -> Doc ann)
-> Either
     (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm (Either
   (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()]))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either
     (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg F2Reg ()])
aarch64

dumpX86Abs :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Abs :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Abs = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((IntMap [Word64], [X86 AbsReg FAbsReg X2Abs ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm((IntMap [Word64], [X86 AbsReg FAbsReg X2Abs ()]) -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap [Word64], [X86 AbsReg FAbsReg X2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
aa,WSt
st) -> (IntMap [Word64]
aa,(Int, [X86 AbsReg FAbsReg X2Abs ()])
-> [X86 AbsReg FAbsReg X2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
irToX86 WSt
st [Stmt]
x)))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

dumpAAbs :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAAbs :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAAbs = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((IntMap [Word64], [AArch64 AbsReg FAbsReg F2Abs ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm((IntMap [Word64], [AArch64 AbsReg FAbsReg F2Abs ()]) -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap [Word64], [AArch64 AbsReg FAbsReg F2Abs ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
aa,WSt
st) -> (IntMap [Word64]
aa,(Int, [AArch64 AbsReg FAbsReg F2Abs ()])
-> [AArch64 AbsReg FAbsReg F2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
irToAarch64 WSt
st [Stmt]
x)))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

dumpC :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpC :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpC = (([CS Liveness], IntMap [Word64]) -> Doc ann)
-> Either (Err AlexPosn) ([CS Liveness], IntMap [Word64])
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((IntMap [Word64], [CS Liveness]) -> Doc ann
forall a ann. (IntMap [Word64], [CS a]) -> Doc ann
prettyCS((IntMap [Word64], [CS Liveness]) -> Doc ann)
-> (([CS Liveness], IntMap [Word64])
    -> (IntMap [Word64], [CS Liveness]))
-> ([CS Liveness], IntMap [Word64])
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([CS Liveness], IntMap [Word64])
-> (IntMap [Word64], [CS Liveness])
forall a b. (a, b) -> (b, a)
swap)(Either (Err AlexPosn) ([CS Liveness], IntMap [Word64])
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([CS Liveness], IntMap [Word64]))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString
-> Either (Err AlexPosn) ([CS Liveness], IntMap [Word64])
cmm

dumpCI :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpCI :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpCI = (E (T ()) -> Doc ann)
-> Either (Err AlexPosn) (E (T ()))
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([CS Liveness] -> Doc ann
forall ann. [CS Liveness] -> Doc ann
prettyCI([CS Liveness] -> Doc ann)
-> (E (T ()) -> [CS Liveness]) -> E (T ()) -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.[CS ()] -> [CS Liveness]
live([CS ()] -> [CS Liveness])
-> (E (T ()) -> [CS ()]) -> E (T ()) -> [CS Liveness]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([CS ()], LSt, IntMap [Word64], IntMap Temp) -> [CS ()]
forall {a} {b} {c} {d}. (a, b, c, d) -> a
f(([CS ()], LSt, IntMap [Word64], IntMap Temp) -> [CS ()])
-> (E (T ()) -> ([CS ()], LSt, IntMap [Word64], IntMap Temp))
-> E (T ())
-> [CS ()]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.E (T ()) -> ([CS ()], LSt, IntMap [Word64], IntMap Temp)
C.writeC)(Either (Err AlexPosn) (E (T ()))
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString -> Either (Err AlexPosn) (E (T ())))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString -> Either (Err AlexPosn) (E (T ()))
opt where f :: (a, b, c, d) -> a
f (a
cs,b
_,c
_,d
_) = a
cs

prettyCI :: [CS Liveness] -> Doc ann
prettyCI :: forall ann. [CS Liveness] -> Doc ann
prettyCI = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
prettyLines([Doc ann] -> Doc ann)
-> ([CS Liveness] -> [Doc ann]) -> [CS Liveness] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(CS Liveness -> Doc ann) -> [CS Liveness] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Liveness -> Doc ann) -> CS Liveness -> Doc ann
forall {a} {ann}. (a -> Doc ann) -> CS a -> Doc ann
pL ((Doc ann
forall {a}. Doc a
spaceDoc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>)(Doc ann -> Doc ann)
-> (Liveness -> Doc ann) -> Liveness -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Liveness -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Liveness -> Doc ann
pretty))

dumpLoop :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpLoop :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpLoop = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([(Int, IntSet)], [(Stmt, ControlAnn)],
 Array Int (Stmt, ControlAnn))
-> Doc ann
forall {f :: * -> *} {c} {a}.
(Pretty (f [Int]), Functor f) =>
(f (Int, IntSet), [(Stmt, ControlAnn)], c) -> Doc a
pg(([(Int, IntSet)], [(Stmt, ControlAnn)],
  Array Int (Stmt, ControlAnn))
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> ([(Int, IntSet)], [(Stmt, ControlAnn)],
        Array Int (Stmt, ControlAnn)))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.[Stmt]
-> ([(Int, IntSet)], [(Stmt, ControlAnn)],
    Array Int (Stmt, ControlAnn))
loop([Stmt]
 -> ([(Int, IntSet)], [(Stmt, ControlAnn)],
     Array Int (Stmt, ControlAnn)))
-> (([Stmt], IntMap [Word64], WSt) -> [Stmt])
-> ([Stmt], IntMap [Word64], WSt)
-> ([(Int, IntSet)], [(Stmt, ControlAnn)],
    Array Int (Stmt, ControlAnn))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([Stmt], IntMap [Word64], WSt) -> [Stmt]
forall {a} {b} {c}. (a, b, c) -> a
π)(Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir where π :: (a, b, c) -> a
π (a
a,b
_,c
_)=a
a; pg :: (f (Int, IntSet), [(Stmt, ControlAnn)], c) -> Doc a
pg (f (Int, IntSet)
t,[(Stmt, ControlAnn)]
ss,c
_) = [(Stmt, ControlAnn)] -> Doc a
forall {ann}. [(Stmt, ControlAnn)] -> Doc ann
pS [(Stmt, ControlAnn)]
ssDoc a -> Doc a -> Doc a
forall a. Doc a -> Doc a -> Doc a
<#>f [Int] -> Doc a
forall ann. f [Int] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (((Int, IntSet) -> [Int]) -> f (Int, IntSet) -> f [Int]
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Int
nϵ,IntSet
ns) -> Int
nϵInt -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:IntSet -> [Int]
IS.toList IntSet
ns) f (Int, IntSet)
t); pS :: [(Stmt, ControlAnn)] -> Doc ann
pS=[Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
prettyLines([Doc ann] -> Doc ann)
-> ([(Stmt, ControlAnn)] -> [Doc ann])
-> [(Stmt, ControlAnn)]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((Stmt, ControlAnn) -> Doc ann)
-> [(Stmt, ControlAnn)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Stmt
s,ControlAnn
l) -> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ControlAnn -> Int
node ControlAnn
l) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Stmt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Stmt -> Doc ann
pretty Stmt
s)

dumpDomTree :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpDomTree :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpDomTree = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Graph, Tree Int, [(Stmt, ControlAnn)],
 Array Int (Stmt, ControlAnn))
-> Doc ann
forall {a} {a} {d} {a}.
Show a =>
(a, Tree a, [(Stmt, ControlAnn)], d) -> Doc a
pg((Graph, Tree Int, [(Stmt, ControlAnn)],
  Array Int (Stmt, ControlAnn))
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (Graph, Tree Int, [(Stmt, ControlAnn)],
        Array Int (Stmt, ControlAnn)))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.[Stmt]
-> (Graph, Tree Int, [(Stmt, ControlAnn)],
    Array Int (Stmt, ControlAnn))
hoist([Stmt]
 -> (Graph, Tree Int, [(Stmt, ControlAnn)],
     Array Int (Stmt, ControlAnn)))
-> (([Stmt], IntMap [Word64], WSt) -> [Stmt])
-> ([Stmt], IntMap [Word64], WSt)
-> (Graph, Tree Int, [(Stmt, ControlAnn)],
    Array Int (Stmt, ControlAnn))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([Stmt], IntMap [Word64], WSt) -> [Stmt]
forall {a} {b} {c}. (a, b, c) -> a
π)(Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir where π :: (a, b, c) -> a
π (a
a,b
_,c
_)=a
a; pg :: (a, Tree a, [(Stmt, ControlAnn)], d) -> Doc a
pg (a
_,Tree a
t,[(Stmt, ControlAnn)]
asϵ,d
_) = [(Stmt, ControlAnn)] -> Doc a
forall {ann}. [(Stmt, ControlAnn)] -> Doc ann
pS [(Stmt, ControlAnn)]
asϵDoc a -> Doc a -> Doc a
forall a. Doc a -> Doc a -> Doc a
<#>String -> Doc a
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Tree String -> String
drawTree (a -> String
forall a. Show a => a -> String
show(a -> String) -> Tree a -> Tree String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>Tree a
t)); pS :: [(Stmt, ControlAnn)] -> Doc ann
pS=[Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
prettyLines([Doc ann] -> Doc ann)
-> ([(Stmt, ControlAnn)] -> [Doc ann])
-> [(Stmt, ControlAnn)]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((Stmt, ControlAnn) -> Doc ann)
-> [(Stmt, ControlAnn)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Stmt
s,ControlAnn
l) -> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ControlAnn -> Int
node ControlAnn
l) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Stmt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Stmt -> Doc ann
pretty Stmt
s)

dumpIR :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpIR :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpIR = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((IntMap [Word64], [Stmt]) -> Doc ann
forall ann. (IntMap [Word64], [Stmt]) -> Doc ann
prettyIR((IntMap [Word64], [Stmt]) -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt) -> (IntMap [Word64], [Stmt]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([Stmt], IntMap [Word64], WSt) -> (IntMap [Word64], [Stmt])
forall {b} {a} {c}. (b, a, c) -> (a, b)
π)(Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir where π :: (b, a, c) -> (a, b)
π (b
a,a
b,c
_)=(a
b,b
a)

dumpX86Intervals :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Intervals :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Intervals = ([X86 AbsReg FAbsReg X2Abs Live] -> Doc ann)
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [X86 AbsReg FAbsReg X2Abs Live] -> Doc ann
forall freg reg f2reg o ann.
(Pretty freg, Pretty reg, Pretty f2reg, Pretty o) =>
[X86 reg freg f2reg o] -> Doc ann
X86.prettyDebugX86 (Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live])
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
x86Iv

dumpAIntervals :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAIntervals :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAIntervals = ([AArch64 AbsReg FAbsReg F2Abs Live] -> Doc ann)
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [AArch64 AbsReg FAbsReg F2Abs Live] -> Doc ann
forall freg reg f2reg o ann.
(Pretty freg, Pretty reg, SIMD f2reg, Pretty o) =>
[AArch64 reg freg f2reg o] -> Doc ann
Aarch64.prettyDebug (Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live])
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
aarch64Iv

dumpX86Liveness :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Liveness :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpX86Liveness = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([X86 AbsReg FAbsReg X2Abs Liveness] -> Doc ann
forall freg reg f2reg o ann.
(Pretty freg, Pretty reg, Pretty f2reg, Pretty o) =>
[X86 reg freg f2reg o] -> Doc ann
X86.prettyDebugX86 ([X86 AbsReg FAbsReg X2Abs Liveness] -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> [X86 AbsReg FAbsReg X2Abs Liveness])
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [X86 AbsReg FAbsReg X2Abs ()]
-> [X86 AbsReg FAbsReg X2Abs Liveness]
forall (arch :: * -> * -> * -> * -> *) reg freg f2.
Arch arch reg freg f2 =>
[arch reg freg f2 ()] -> [arch reg freg f2 Liveness]
mkLive ([X86 AbsReg FAbsReg X2Abs ()]
 -> [X86 AbsReg FAbsReg X2Abs Liveness])
-> (([Stmt], IntMap [Word64], WSt)
    -> [X86 AbsReg FAbsReg X2Abs ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [X86 AbsReg FAbsReg X2Abs Liveness]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
-> [X86 AbsReg FAbsReg X2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
irToX86 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

dumpALiveness :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpALiveness :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpALiveness = (([Stmt], IntMap [Word64], WSt) -> Doc ann)
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([AArch64 AbsReg FAbsReg F2Abs Liveness] -> Doc ann
forall freg reg f2reg o ann.
(Pretty freg, Pretty reg, SIMD f2reg, Pretty o) =>
[AArch64 reg freg f2reg o] -> Doc ann
Aarch64.prettyDebug ([AArch64 AbsReg FAbsReg F2Abs Liveness] -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> [AArch64 AbsReg FAbsReg F2Abs Liveness])
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [AArch64 AbsReg FAbsReg F2Abs ()]
-> [AArch64 AbsReg FAbsReg F2Abs Liveness]
forall (arch :: * -> * -> * -> * -> *) reg freg f2.
Arch arch reg freg f2 =>
[arch reg freg f2 ()] -> [arch reg freg f2 Liveness]
mkLive ([AArch64 AbsReg FAbsReg F2Abs ()]
 -> [AArch64 AbsReg FAbsReg F2Abs Liveness])
-> (([Stmt], IntMap [Word64], WSt)
    -> [AArch64 AbsReg FAbsReg F2Abs ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [AArch64 AbsReg FAbsReg F2Abs Liveness]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
-> [AArch64 AbsReg FAbsReg F2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
irToAarch64 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

x86Iv :: BSL.ByteString -> Either (Err AlexPosn) [X86.X86 X86.AbsReg X86.FAbsReg X86.X2Abs Live]
x86Iv :: ByteString -> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
x86Iv = (([Stmt], IntMap [Word64], WSt) -> [X86 AbsReg FAbsReg X2Abs Live])
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([X86 AbsReg FAbsReg X2Abs ()] -> [X86 AbsReg FAbsReg X2Abs Live]
forall (arch :: * -> * -> * -> * -> *) reg freg f2.
(Arch arch reg freg f2, Copointed (arch reg freg f2)) =>
[arch reg freg f2 ()] -> [arch reg freg f2 Live]
mkIntervals ([X86 AbsReg FAbsReg X2Abs ()] -> [X86 AbsReg FAbsReg X2Abs Live])
-> (([Stmt], IntMap [Word64], WSt)
    -> [X86 AbsReg FAbsReg X2Abs ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [X86 AbsReg FAbsReg X2Abs Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
-> [X86 AbsReg FAbsReg X2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg X2Abs ()])
irToX86 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live])
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg X2Abs Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

aarch64Iv :: BSL.ByteString -> Either (Err AlexPosn) [Aarch64.AArch64 Aarch64.AbsReg Aarch64.FAbsReg Aarch64.F2Abs Live]
aarch64Iv :: ByteString
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
aarch64Iv = (([Stmt], IntMap [Word64], WSt)
 -> [AArch64 AbsReg FAbsReg F2Abs Live])
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([AArch64 AbsReg FAbsReg F2Abs ()]
-> [AArch64 AbsReg FAbsReg F2Abs Live]
forall (arch :: * -> * -> * -> * -> *) reg freg f2.
(Arch arch reg freg f2, Copointed (arch reg freg f2)) =>
[arch reg freg f2 ()] -> [arch reg freg f2 Live]
mkIntervals ([AArch64 AbsReg FAbsReg F2Abs ()]
 -> [AArch64 AbsReg FAbsReg F2Abs Live])
-> (([Stmt], IntMap [Word64], WSt)
    -> [AArch64 AbsReg FAbsReg F2Abs ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [AArch64 AbsReg FAbsReg F2Abs Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
-> [AArch64 AbsReg FAbsReg F2Abs ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg F2Abs ()])
irToAarch64 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live])
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg F2Abs Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
ir

printParsed :: BSL.ByteString -> Doc ann
printParsed :: forall ann. ByteString -> Doc ann
printParsed = E AlexPosn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E AlexPosn -> Doc ann
pretty (E AlexPosn -> Doc ann)
-> (ByteString -> E AlexPosn) -> ByteString -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (E AlexPosn, Int) -> E AlexPosn
forall a b. (a, b) -> a
fst ((E AlexPosn, Int) -> E AlexPosn)
-> (ByteString -> (E AlexPosn, Int)) -> ByteString -> E AlexPosn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParseE -> (E AlexPosn, Int))
-> ((E AlexPosn, Int) -> (E AlexPosn, Int))
-> Either ParseE (E AlexPosn, Int)
-> (E AlexPosn, Int)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ParseE -> (E AlexPosn, Int)
forall a e. (HasCallStack, Exception e) => e -> a
throw (E AlexPosn, Int) -> (E AlexPosn, Int)
forall a. a -> a
id (Either ParseE (E AlexPosn, Int) -> (E AlexPosn, Int))
-> (ByteString -> Either ParseE (E AlexPosn, Int))
-> ByteString
-> (E AlexPosn, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either ParseE (E AlexPosn, Int)
parseRename

-- throws exception
printTypes :: BSL.ByteString -> Doc ann
printTypes :: forall ann. ByteString -> Doc ann
printTypes ByteString
bsl =
    case ByteString -> Either ParseE (E AlexPosn, Int)
parseRename ByteString
bsl of
        Left ParseE
err       -> ParseE -> Doc ann
forall a e. (HasCallStack, Exception e) => e -> a
throw ParseE
err
        Right (E AlexPosn
ast, Int
m) -> (TyE AlexPosn -> Doc ann)
-> ((E (T ()), [(Nm AlexPosn, C)], Int) -> Doc ann)
-> Either (TyE AlexPosn) (E (T ()), [(Nm AlexPosn, C)], Int)
-> Doc ann
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either TyE AlexPosn -> Doc ann
forall a e. (HasCallStack, Exception e) => e -> a
throw (E (T ()) -> Doc ann
forall a ann. E (T a) -> Doc ann
prettyTyped(E (T ()) -> Doc ann)
-> ((E (T ()), [(Nm AlexPosn, C)], Int) -> E (T ()))
-> (E (T ()), [(Nm AlexPosn, C)], Int)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(E (T ()), [(Nm AlexPosn, C)], Int) -> E (T ())
forall {a} {b} {c}. (a, b, c) -> a
fst3) (Either (TyE AlexPosn) (E (T ()), [(Nm AlexPosn, C)], Int)
 -> Doc ann)
-> Either (TyE AlexPosn) (E (T ()), [(Nm AlexPosn, C)], Int)
-> Doc ann
forall a b. (a -> b) -> a -> b
$ Int
-> E AlexPosn
-> Either (TyE AlexPosn) (E (T ()), [(Nm AlexPosn, C)], Int)
forall a. Int -> E a -> Either (TyE a) (E (T ()), [(Nm a, C)], Int)
tyClosed Int
m E AlexPosn
ast

topt :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
topt :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
topt = (E (T ()) -> Doc ann)
-> Either (Err AlexPosn) (E (T ()))
-> Either (Err AlexPosn) (Doc ann)
forall a b.
(a -> b) -> Either (Err AlexPosn) a -> Either (Err AlexPosn) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap E (T ()) -> Doc ann
forall a ann. E (T a) -> Doc ann
prettyTyped (Either (Err AlexPosn) (E (T ()))
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString -> Either (Err AlexPosn) (E (T ())))
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) (E (T ()))
opt