{-# 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 ()]))
-> ByteString -> IO (Either (Err AlexPosn) Text)
forall {a} {a} {a}.
(a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a]))
-> a -> IO (Either a Text)
asmTxt ByteString
-> Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
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 ()]))
-> E a -> IO (Either (Err a) Text)
forall {a} {a} {a}.
(a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a]))
-> a -> IO (Either a Text)
asmTxt (Int
-> E a -> Either (Err a) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
forall a.
Int
-> E a -> Either (Err a) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
ex86G Int
k)

asmTxt :: (a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a]))
-> a -> IO (Either a Text)
asmTxt a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a])
f = (Either a ([X86 X86Reg FX86Reg a], [ByteString]) -> Either a Text)
-> IO (Either a ([X86 X86Reg FX86Reg 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 a], [ByteString]) -> Text)
-> Either a ([X86 X86Reg FX86Reg 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 a], [ByteString]) -> [Text])
-> ([X86 X86Reg FX86Reg a], [ByteString])
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((X86 X86Reg FX86Reg a, ByteString) -> Text)
-> [(X86 X86Reg FX86Reg 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 a, ByteString) -> Text
forall a. Pretty a => (a, ByteString) -> Text
present([(X86 X86Reg FX86Reg a, ByteString)] -> [Text])
-> (([X86 X86Reg FX86Reg a], [ByteString])
    -> [(X86 X86Reg FX86Reg a, ByteString)])
-> ([X86 X86Reg FX86Reg a], [ByteString])
-> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([X86 X86Reg FX86Reg a]
 -> [ByteString] -> [(X86 X86Reg FX86Reg a, ByteString)])
-> ([X86 X86Reg FX86Reg a], [ByteString])
-> [(X86 X86Reg FX86Reg a, ByteString)]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [X86 X86Reg FX86Reg a]
-> [ByteString] -> [(X86 X86Reg FX86Reg a, ByteString)]
forall {reg} {freg} {a}.
[X86 reg freg a] -> [ByteString] -> [(X86 reg freg a, ByteString)]
zipS)) (IO (Either a ([X86 X86Reg FX86Reg a], [ByteString]))
 -> IO (Either a Text))
-> (a -> IO (Either a ([X86 X86Reg FX86Reg a], [ByteString])))
-> a
-> IO (Either a Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either a (IO ([X86 X86Reg FX86Reg a], [ByteString]))
-> IO (Either a ([X86 X86Reg FX86Reg a], [ByteString]))
forall a b. Either a (IO b) -> IO (Either a b)
comm (Either a (IO ([X86 X86Reg FX86Reg a], [ByteString]))
 -> IO (Either a ([X86 X86Reg FX86Reg a], [ByteString])))
-> (a -> Either a (IO ([X86 X86Reg FX86Reg a], [ByteString])))
-> a
-> IO (Either a ([X86 X86Reg FX86Reg a], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((IntMap [Word64], [X86 X86Reg FX86Reg a])
 -> IO ([X86 X86Reg FX86Reg a], [ByteString]))
-> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a])
-> Either a (IO ([X86 X86Reg FX86Reg 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 a]) -> IO [ByteString])
-> (IntMap [Word64], [X86 X86Reg FX86Reg a])
-> IO ([X86 X86Reg FX86Reg a], [ByteString])
forall (m :: * -> *) c a b.
Functor m =>
((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM (IntMap [Word64], [X86 X86Reg FX86Reg a]) -> IO [ByteString]
forall {a}.
(IntMap [Word64], [X86 X86Reg FX86Reg a]) -> IO [ByteString]
dbgFp) (Either a (IntMap [Word64], [X86 X86Reg FX86Reg a])
 -> Either a (IO ([X86 X86Reg FX86Reg a], [ByteString])))
-> (a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a]))
-> a
-> Either a (IO ([X86 X86Reg FX86Reg a], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a (IntMap [Word64], [X86 X86Reg FX86Reg a])
f
    where zipS :: [X86 reg freg a] -> [ByteString] -> [(X86 reg freg a, ByteString)]
zipS [] []                 = []
          zipS (x :: X86 reg freg a
x@X86.Label{}:[X86 reg freg a]
xs) [ByteString]
ys = (X86 reg freg a
x,ByteString
BS.empty)(X86 reg freg a, ByteString)
-> [(X86 reg freg a, ByteString)] -> [(X86 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[X86 reg freg a] -> [ByteString] -> [(X86 reg freg a, ByteString)]
zipS [X86 reg freg a]
xs [ByteString]
ys
          zipS (X86 reg freg a
x:[X86 reg freg a]
xs) (ByteString
y:[ByteString]
ys)         = (X86 reg freg a
x,ByteString
y)(X86 reg freg a, ByteString)
-> [(X86 reg freg a, ByteString)] -> [(X86 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[X86 reg freg a] -> [ByteString] -> [(X86 reg freg a, ByteString)]
zipS [X86 reg freg 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 ()]))
-> E a -> IO (Either (Err a) Text)
forall {a} {a}.
(a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()]))
-> a -> IO (Either a Text)
aAsmTxt (Int
-> E a -> Either (Err a) (IntMap [Word64], [AArch64 AReg FAReg ()])
forall a.
Int
-> E a -> Either (Err a) (IntMap [Word64], [AArch64 AReg FAReg ()])
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 ()]))
-> ByteString -> IO (Either (Err AlexPosn) Text)
forall {a} {a}.
(a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()]))
-> a -> IO (Either a Text)
aAsmTxt ByteString
-> Either (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg ()])
aarch64

aAsmTxt :: (a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()]))
-> a -> IO (Either a Text)
aAsmTxt a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()])
f = (Either a ([AArch64 AReg FAReg ()], [ByteString]) -> Either a Text)
-> IO (Either a ([AArch64 AReg FAReg ()], [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 ()], [ByteString]) -> Text)
-> Either a ([AArch64 AReg FAReg ()], [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 ()], [ByteString]) -> [Text])
-> ([AArch64 AReg FAReg ()], [ByteString])
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((AArch64 AReg FAReg (), ByteString) -> Text)
-> [(AArch64 AReg FAReg (), 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 (), ByteString) -> Text
forall a. Pretty a => (a, ByteString) -> Text
present([(AArch64 AReg FAReg (), ByteString)] -> [Text])
-> (([AArch64 AReg FAReg ()], [ByteString])
    -> [(AArch64 AReg FAReg (), ByteString)])
-> ([AArch64 AReg FAReg ()], [ByteString])
-> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([AArch64 AReg FAReg ()]
 -> [ByteString] -> [(AArch64 AReg FAReg (), ByteString)])
-> ([AArch64 AReg FAReg ()], [ByteString])
-> [(AArch64 AReg FAReg (), ByteString)]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [AArch64 AReg FAReg ()]
-> [ByteString] -> [(AArch64 AReg FAReg (), ByteString)]
forall {reg} {freg} {a}.
[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS)) (IO (Either a ([AArch64 AReg FAReg ()], [ByteString]))
 -> IO (Either a Text))
-> (a -> IO (Either a ([AArch64 AReg FAReg ()], [ByteString])))
-> a
-> IO (Either a Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either a (IO ([AArch64 AReg FAReg ()], [ByteString]))
-> IO (Either a ([AArch64 AReg FAReg ()], [ByteString]))
forall a b. Either a (IO b) -> IO (Either a b)
comm (Either a (IO ([AArch64 AReg FAReg ()], [ByteString]))
 -> IO (Either a ([AArch64 AReg FAReg ()], [ByteString])))
-> (a -> Either a (IO ([AArch64 AReg FAReg ()], [ByteString])))
-> a
-> IO (Either a ([AArch64 AReg FAReg ()], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((IntMap [Word64], [AArch64 AReg FAReg ()])
 -> IO ([AArch64 AReg FAReg ()], [ByteString]))
-> Either a (IntMap [Word64], [AArch64 AReg FAReg ()])
-> Either a (IO ([AArch64 AReg FAReg ()], [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 ()]) -> IO [ByteString])
-> (IntMap [Word64], [AArch64 AReg FAReg ()])
-> IO ([AArch64 AReg FAReg ()], [ByteString])
forall (m :: * -> *) c a b.
Functor m =>
((c, a) -> m b) -> (c, a) -> m (a, b)
wIdM (IntMap [Word64], [AArch64 AReg FAReg ()]) -> IO [ByteString]
Aarch64.dbgFp) (Either a (IntMap [Word64], [AArch64 AReg FAReg ()])
 -> Either a (IO ([AArch64 AReg FAReg ()], [ByteString])))
-> (a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()]))
-> a
-> Either a (IO ([AArch64 AReg FAReg ()], [ByteString]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a (IntMap [Word64], [AArch64 AReg FAReg ()])
f
    where zipS :: [AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [] []                                    = []
          zipS (x :: AArch64 reg freg a
x@Aarch64.C{}:[AArch64 reg freg a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:ByteString
y4:[ByteString]
ys)   = (AArch64 reg freg a
x,ByteString
y0)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y1)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y2)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y3)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y4)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [AArch64 reg freg a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg a
x@Aarch64.MovRCf{}:[AArch64 reg freg a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:[ByteString]
ys) = (AArch64 reg freg a
x,ByteString
y0)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y1)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y2)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y3)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [AArch64 reg freg a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg a
x@Aarch64.LdrRL{}:[AArch64 reg freg a]
xs) (ByteString
y0:ByteString
y1:ByteString
y2:ByteString
y3:[ByteString]
ys)  = (AArch64 reg freg a
x,ByteString
y0)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y1)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y2)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:(AArch64 reg freg a
x,ByteString
y3)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [AArch64 reg freg a]
xs [ByteString]
ys
          zipS (x :: AArch64 reg freg a
x@Aarch64.Label{}:[AArch64 reg freg a]
xs) [ByteString]
ys                = (AArch64 reg freg a
x,ByteString
BS.empty)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [AArch64 reg freg a]
xs [ByteString]
ys
          zipS (AArch64 reg freg a
x:[AArch64 reg freg a]
xs) (ByteString
y:[ByteString]
ys)                            = (AArch64 reg freg a
x,ByteString
y)(AArch64 reg freg a, ByteString)
-> [(AArch64 reg freg a, ByteString)]
-> [(AArch64 reg freg a, ByteString)]
forall a. a -> [a] -> [a]
:[AArch64 reg freg a]
-> [ByteString] -> [(AArch64 reg freg a, ByteString)]
zipS [AArch64 reg freg 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 ()] -> Doc ann)
-> (IntMap [Word64], [X86 X86Reg FX86Reg ()])
-> (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 ()] -> Doc ann)
-> [X86 X86Reg FX86Reg ()]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.[X86 X86Reg FX86Reg ()] -> Doc ann
forall isn ann. Pretty isn => [isn] -> Doc ann
pAsm) ((IntMap [Word64], [X86 X86Reg FX86Reg ()])
 -> (IntMap [Word64], Doc ann))
-> (ByteString -> (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> ByteString
-> (IntMap [Word64], Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Err AlexPosn -> (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> ((IntMap [Word64], [X86 X86Reg FX86Reg ()])
    -> (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
-> (IntMap [Word64], [X86 X86Reg FX86Reg ()])
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Err AlexPosn -> (IntMap [Word64], [X86 X86Reg FX86Reg ()])
forall a e. (HasCallStack, Exception e) => e -> a
throw (IntMap [Word64], [X86 X86Reg FX86Reg ()])
-> (IntMap [Word64], [X86 X86Reg FX86Reg ()])
forall a. a -> a
id (Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
 -> (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> ByteString
-> (IntMap [Word64], [X86 X86Reg FX86Reg ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
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 ()]
_) -> 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 ()])
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Int
 -> [X86 AbsReg FAbsReg ()]
 -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()]))
-> (Int, [X86 AbsReg FAbsReg ()])
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()])
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int
-> [X86 AbsReg FAbsReg ()]
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()])
gallocOn((Int, [X86 AbsReg FAbsReg ()])
 -> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()]))
-> (([Stmt], IntMap [Word64], WSt)
    -> (Int, [X86 AbsReg FAbsReg ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> (IntMap X86Reg, IntMap FX86Reg, [X86 AbsReg FAbsReg ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg ()])
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 ()]
_) -> 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 ()])
 -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Int
 -> [AArch64 AbsReg FAbsReg ()]
 -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()]))
-> (Int, [AArch64 AbsReg FAbsReg ()])
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()])
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int
-> [AArch64 AbsReg FAbsReg ()]
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()])
Aarch64.gallocOn((Int, [AArch64 AbsReg FAbsReg ()])
 -> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()]))
-> (([Stmt], IntMap [Word64], WSt)
    -> (Int, [AArch64 AbsReg FAbsReg ()]))
-> ([Stmt], IntMap [Word64], WSt)
-> (IntMap AReg, IntMap FAReg, [AArch64 AbsReg FAbsReg ()])
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg ()])
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 ()]) -> Doc ann)
-> Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
-> 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 ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm (Either (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()])
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [X86 X86Reg FX86Reg ()]))
-> 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 ()])
x86G

dumpAarch64 :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAarch64 :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAarch64 = ((IntMap [Word64], [AArch64 AReg FAReg ()]) -> Doc ann)
-> Either (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg ()])
-> 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 ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm (Either (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg ()])
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either
         (Err AlexPosn) (IntMap [Word64], [AArch64 AReg FAReg ()]))
-> 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 ()])
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 ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm((IntMap [Word64], [X86 AbsReg FAbsReg ()]) -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap [Word64], [X86 AbsReg FAbsReg ()]))
-> ([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 ()]) -> [X86 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg ()])
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 ()]) -> Doc ann
forall isn ann. Pretty isn => (IntMap [Word64], [isn]) -> Doc ann
prettyAsm((IntMap [Word64], [AArch64 AbsReg FAbsReg ()]) -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> (IntMap [Word64], [AArch64 AbsReg FAbsReg ()]))
-> ([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 ()]) -> [AArch64 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg ()])
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 :: * -> *} {a} {c} {a}.
(Pretty (f [Int]), Functor f) =>
(f (a, 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 (a, IntSet), [(Stmt, ControlAnn)], c) -> Doc a
pg (f (a, 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 (((a, IntSet) -> [Int]) -> f (a, 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 (IntSet -> [Int]
IS.toList (IntSet -> [Int])
-> ((a, IntSet) -> IntSet) -> (a, IntSet) -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, IntSet) -> IntSet
forall a b. (a, b) -> b
snd) f (a, 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 Live] -> Doc ann)
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg 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 Live] -> Doc ann
forall freg reg o ann.
(Pretty freg, Pretty reg, Pretty o) =>
[X86 reg freg o] -> Doc ann
X86.prettyDebugX86 (Either (Err AlexPosn) [X86 AbsReg FAbsReg Live]
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString -> Either (Err AlexPosn) [X86 AbsReg FAbsReg Live])
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) [X86 AbsReg FAbsReg Live]
x86Iv

dumpAIntervals :: BSL.ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAIntervals :: forall ann. ByteString -> Either (Err AlexPosn) (Doc ann)
dumpAIntervals = ([AArch64 AbsReg FAbsReg Live] -> Doc ann)
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg 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 Live] -> Doc ann
forall freg reg o ann.
(Pretty freg, Pretty reg, Pretty o) =>
[AArch64 reg freg o] -> Doc ann
Aarch64.prettyDebug (Either (Err AlexPosn) [AArch64 AbsReg FAbsReg Live]
 -> Either (Err AlexPosn) (Doc ann))
-> (ByteString
    -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg Live])
-> ByteString
-> Either (Err AlexPosn) (Doc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg 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 Liveness] -> Doc ann
forall freg reg o ann.
(Pretty freg, Pretty reg, Pretty o) =>
[X86 reg freg o] -> Doc ann
X86.prettyDebugX86 ([X86 AbsReg FAbsReg Liveness] -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> [X86 AbsReg FAbsReg Liveness])
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [X86 AbsReg FAbsReg ()] -> [X86 AbsReg FAbsReg Liveness]
forall (arch :: * -> * -> * -> *) reg freg.
Arch arch reg freg =>
[arch reg freg ()] -> [arch reg freg Liveness]
mkLive ([X86 AbsReg FAbsReg ()] -> [X86 AbsReg FAbsReg Liveness])
-> (([Stmt], IntMap [Word64], WSt) -> [X86 AbsReg FAbsReg ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [X86 AbsReg FAbsReg Liveness]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [X86 AbsReg FAbsReg ()]) -> [X86 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg ()])
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 Liveness] -> Doc ann
forall freg reg o ann.
(Pretty freg, Pretty reg, Pretty o) =>
[AArch64 reg freg o] -> Doc ann
Aarch64.prettyDebug ([AArch64 AbsReg FAbsReg Liveness] -> Doc ann)
-> (([Stmt], IntMap [Word64], WSt)
    -> [AArch64 AbsReg FAbsReg Liveness])
-> ([Stmt], IntMap [Word64], WSt)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [AArch64 AbsReg FAbsReg ()] -> [AArch64 AbsReg FAbsReg Liveness]
forall (arch :: * -> * -> * -> *) reg freg.
Arch arch reg freg =>
[arch reg freg ()] -> [arch reg freg Liveness]
mkLive ([AArch64 AbsReg FAbsReg ()] -> [AArch64 AbsReg FAbsReg Liveness])
-> (([Stmt], IntMap [Word64], WSt) -> [AArch64 AbsReg FAbsReg ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [AArch64 AbsReg FAbsReg Liveness]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [AArch64 AbsReg FAbsReg ()]) -> [AArch64 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg ()])
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 Live]
x86Iv :: ByteString -> Either (Err AlexPosn) [X86 AbsReg FAbsReg Live]
x86Iv = (([Stmt], IntMap [Word64], WSt) -> [X86 AbsReg FAbsReg Live])
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg 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 ()] -> [X86 AbsReg FAbsReg Live]
forall (arch :: * -> * -> * -> *) reg freg.
(Arch arch reg freg, Copointed (arch reg freg)) =>
[arch reg freg ()] -> [arch reg freg Live]
mkIntervals ([X86 AbsReg FAbsReg ()] -> [X86 AbsReg FAbsReg Live])
-> (([Stmt], IntMap [Word64], WSt) -> [X86 AbsReg FAbsReg ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [X86 AbsReg FAbsReg Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [X86 AbsReg FAbsReg ()]) -> [X86 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [X86 AbsReg FAbsReg ()])
irToX86 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) [X86 AbsReg FAbsReg Live])
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) [X86 AbsReg FAbsReg 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 Live]
aarch64Iv :: ByteString -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg Live]
aarch64Iv = (([Stmt], IntMap [Word64], WSt) -> [AArch64 AbsReg FAbsReg Live])
-> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg 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 ()] -> [AArch64 AbsReg FAbsReg Live]
forall (arch :: * -> * -> * -> *) reg freg.
(Arch arch reg freg, Copointed (arch reg freg)) =>
[arch reg freg ()] -> [arch reg freg Live]
mkIntervals ([AArch64 AbsReg FAbsReg ()] -> [AArch64 AbsReg FAbsReg Live])
-> (([Stmt], IntMap [Word64], WSt) -> [AArch64 AbsReg FAbsReg ()])
-> ([Stmt], IntMap [Word64], WSt)
-> [AArch64 AbsReg FAbsReg Live]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([Stmt]
x,IntMap [Word64]
_,WSt
st) -> (Int, [AArch64 AbsReg FAbsReg ()]) -> [AArch64 AbsReg FAbsReg ()]
forall a b. (a, b) -> b
snd (WSt -> [Stmt] -> (Int, [AArch64 AbsReg FAbsReg ()])
irToAarch64 WSt
st [Stmt]
x))) (Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt)
 -> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg Live])
-> (ByteString
    -> Either (Err AlexPosn) ([Stmt], IntMap [Word64], WSt))
-> ByteString
-> Either (Err AlexPosn) [AArch64 AbsReg FAbsReg 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 AlexPosn -> (E AlexPosn, Int))
-> ((E AlexPosn, Int) -> (E AlexPosn, Int))
-> Either (ParseE AlexPosn) (E AlexPosn, Int)
-> (E AlexPosn, Int)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ParseE AlexPosn -> (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 AlexPosn) (E AlexPosn, Int) -> (E AlexPosn, Int))
-> (ByteString -> Either (ParseE AlexPosn) (E AlexPosn, Int))
-> ByteString
-> (E AlexPosn, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either (ParseE AlexPosn) (E AlexPosn, Int)
parseRename

-- throws exception
printTypes :: BSL.ByteString -> Doc ann
printTypes :: forall ann. ByteString -> Doc ann
printTypes ByteString
bsl =
    case ByteString -> Either (ParseE AlexPosn) (E AlexPosn, Int)
parseRename ByteString
bsl of
        Left ParseE AlexPosn
err       -> ParseE AlexPosn -> Doc ann
forall a e. (HasCallStack, Exception e) => e -> a
throw ParseE AlexPosn
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