-- Sample code to demonstrate how to emulate X86 code import Unicorn import Unicorn.Hook import qualified Unicorn.CPU.X86 as X86 import Control.Monad.Trans.Class (lift) import qualified Data.ByteString as BS import Data.Word import qualified Numeric as N (showHex) import System.Environment -- Code to be emulated -- -- inc ecx; dec edx x86Code32 :: BS.ByteString x86Code32 = BS.pack [0x41, 0x4a] -- jmp 4; nop; nop; nop; nop; nop; nop x86Code32Jump :: BS.ByteString x86Code32Jump = BS.pack [0xeb, 0x02, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90] -- inc ecx; dec edx; jmp self-loop x86Code32Loop :: BS.ByteString x86Code32Loop = BS.pack [0x41, 0x4a, 0xeb, 0xfe] -- mov [0xaaaaaaaa], ecx; inc ecx; dec edx x86Code32MemWrite :: BS.ByteString x86Code32MemWrite = BS.pack [0x89, 0x0d, 0xaa, 0xaa, 0xaa, 0xaa, 0x41, 0x4a] -- mov ecx, [0xaaaaaaaa]; inc ecx; dec edx x86Code32MemRead :: BS.ByteString x86Code32MemRead = BS.pack [0x8b, 0x0d, 0xaa, 0xaa, 0xaa, 0xaa, 0x41, 0x4a] -- jmp ouside; inc ecx; dec edx x86Code32JmpInvalid :: BS.ByteString x86Code32JmpInvalid = BS.pack [0xe9, 0xe9, 0xee, 0xee, 0xee, 0x41, 0x4a] -- inc ecx; in al, 0x3f; dec edx; out 0x46, al; inc ebx x86Code32InOut :: BS.ByteString x86Code32InOut = BS.pack [0x41, 0xe4, 0x3f, 0x4a, 0xe6, 0x46, 0x43] -- inc eax x86Code32Inc :: BS.ByteString x86Code32Inc = BS.pack [0x40] x86Code64 :: BS.ByteString x86Code64 = BS.pack [0x41, 0xbc, 0x3b, 0xb0, 0x28, 0x2a, 0x49, 0x0f, 0xc9, 0x90, 0x4d, 0x0f, 0xad, 0xcf, 0x49, 0x87, 0xfd, 0x90, 0x48, 0x81, 0xd2, 0x8a, 0xce, 0x77, 0x35, 0x48, 0xf7, 0xd9, 0x4d, 0x29, 0xf4, 0x49, 0x81, 0xc9, 0xf6, 0x8a, 0xc6, 0x53, 0x4d, 0x87, 0xed, 0x48, 0x0f, 0xad, 0xd2, 0x49, 0xf7, 0xd4, 0x48, 0xf7, 0xe1, 0x4d, 0x19, 0xc5, 0x4d, 0x89, 0xc5, 0x48, 0xf7, 0xd6, 0x41, 0xb8, 0x4f, 0x8d, 0x6b, 0x59, 0x4d, 0x87, 0xd0, 0x68, 0x6a, 0x1e, 0x09, 0x3c, 0x59] -- add byte ptr [bx + si], al x86Code16 :: BS.ByteString x86Code16 = BS.pack [0x00, 0x00] -- SYSCALL x86Code64Syscall :: BS.ByteString x86Code64Syscall = BS.pack [0x0f, 0x05] -- Memory address where emulation starts address :: Word64 address = 0x1000000 -- Pretty-print integral as hex showHex :: (Integral a, Show a) => a -> String showHex i = N.showHex (fromIntegral i :: Word64) "" -- Pretty-print byte string as hex showHexBS :: BS.ByteString -> String showHexBS = concatMap (flip N.showHex "") . reverse . BS.unpack -- Write a string (with a newline character) to standard output in the emulator emuPutStrLn :: String -> Emulator () emuPutStrLn = lift . putStrLn -- Calculate code length codeLength :: Num a => BS.ByteString -> a codeLength = fromIntegral . BS.length -- Callback for tracing basic blocks hookBlock :: BlockHook () hookBlock _ addr size _ = putStrLn $ ">>> Tracing basic block at 0x" ++ showHex addr ++ ", block size = 0x" ++ (maybe "0" showHex size) -- Callback for tracing instruction hookCode :: CodeHook () hookCode uc addr size _ = do runEmulator $ do emuPutStrLn $ ">>> Tracing instruction at 0x" ++ showHex addr ++ ", instruction size = 0x" ++ maybe "0" showHex size eflags <- regRead uc X86.Eflags emuPutStrLn $ ">>> --- EFLAGS is 0x" ++ showHex eflags return () -- Callback for tracing instruction hookCode64 :: CodeHook () hookCode64 uc addr size _ = do runEmulator $ do rip <- regRead uc X86.Rip emuPutStrLn $ ">>> Tracing instruction at 0x" ++ showHex addr ++ ", instruction size = 0x" ++ (maybe "0" showHex size) emuPutStrLn $ ">>> RIP is 0x" ++ showHex rip return () -- Callback for tracing memory access (READ or WRITE) hookMemInvalid :: MemoryEventHook () hookMemInvalid uc MemWriteUnmapped addr size (Just value) _ = do runEmulator $ do emuPutStrLn $ ">>> Missing memory is being WRITE at 0x" ++ showHex addr ++ ", data size = " ++ show size ++ ", data value = 0x" ++ showHex value memMap uc 0xaaaa0000 (2 * 1024 * 1024) [ProtAll] return True hookMemInvalid _ _ _ _ _ _ = return False hookMem64 :: MemoryHook () hookMem64 _ MemRead addr size _ _ = putStrLn $ ">>> Memory is being READ at 0x" ++ showHex addr ++ ", data size = " ++ show size hookMem64 _ MemWrite addr size (Just value) _ = putStrLn $ ">>> Memory is being WRITE at 0x" ++ showHex addr ++ ", data size = " ++ show size ++ ", data value = 0x" ++ showHex value -- Callback for IN instruction (X86) -- This returns the data read from the port hookIn :: InHook () hookIn uc port size _ = do result <- runEmulator $ do eip <- regRead uc X86.Eip emuPutStrLn $ "--- reading from port 0x" ++ showHex port ++ ", size: " ++ show size ++ ", address: 0x" ++ showHex eip case size of -- Read 1 byte to AL 1 -> return 0xf1 -- Read 2 byte to AX 2 -> return 0xf2 -- Read 4 byte to EAX 4 -> return 0xf4 -- Should never reach this _ -> return 0 case result of Right r -> return r Left _ -> return 0 -- Callback for OUT instruction (X86) hookOut :: OutHook () hookOut uc port size value _ = do runEmulator $ do eip <- regRead uc X86.Eip emuPutStrLn $ "--- writing to port 0x" ++ showHex port ++ ", size: " ++ show size ++ ", value: 0x" ++ showHex value ++ ", address: 0x" ++ showHex eip -- Confirm that value is indeed the value of AL/AX/EAX case size of 1 -> do tmp <- regRead uc X86.Al emuPutStrLn $ "--- register value = 0x" ++ showHex tmp 2 -> do tmp <- regRead uc X86.Ax emuPutStrLn $ "--- register value = 0x" ++ showHex tmp 4 -> do tmp <- regRead uc X86.Eax emuPutStrLn $ "--- register value = 0x" ++ showHex tmp -- Should never reach this _ -> return () return () -- Callback for SYSCALL instruction (X86) hookSyscall :: SyscallHook () hookSyscall uc _ = do runEmulator $ do rax <- regRead uc X86.Rax if rax == 0x100 then regWrite uc X86.Rax 0x200 else emuPutStrLn $ "ERROR: was not expecting rax=0x" ++ showHex rax ++ " in syscall" return () testI386 :: IO () testI386 = do putStrLn "Emulate i386 code" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32 -- Initialize machine registers regWrite uc X86.Ecx 0x1234 regWrite uc X86.Edx 0x7890 -- Tracing all basic blocks with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instruction by having @begin > @end codeHookAdd uc hookCode () 1 0 -- Emulate machine code in infinite time let codeLen = codeLength x86Code32 start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" ecx <- regRead uc X86.Ecx edx <- regRead uc X86.Edx emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx emuPutStrLn $ ">>> EDX = 0x" ++ showHex edx -- Read from memory tmp <- memRead uc address 4 emuPutStrLn $ ">>> Read 4 bytes from [0x" ++ showHex address ++ "] = 0x" ++ showHexBS tmp case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err testI386Jump :: IO () testI386Jump = do putStrLn "===================================" putStrLn "Emulate i386 code with jump" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32Jump -- Tracing 1 basic block with customized callback blockHookAdd uc hookBlock () address address -- Tracing 1 instruction at address codeHookAdd uc hookCode () address address -- Emulate machine code ininfinite time let codeLen = codeLength x86Code32Jump start uc address (address + codeLen) Nothing Nothing emuPutStrLn ">>> Emulation done. Below is the CPU context" case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err -- Emulate code that loop forever testI386Loop :: IO () testI386Loop = do putStrLn "===================================" putStrLn "Emulate i386 code that loop forever" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated in memory memWrite uc address x86Code32Loop -- Initialize machine registers regWrite uc X86.Ecx 0x1234 regWrite uc X86.Edx 0x7890 -- Emulate machine code in 2 seconds, so we can quit even if the code -- loops let codeLen = codeLength x86Code32Loop start uc address (address + codeLen) (Just $ 2 * 1000000) Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" ecx <- regRead uc X86.Ecx edx <- regRead uc X86.Edx emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx emuPutStrLn $ ">>> EDX = 0x" ++ showHex edx case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err -- Emulate code that read invalid memory testI386InvalidMemRead :: IO () testI386InvalidMemRead = do putStrLn "===================================" putStrLn "Emulate i386 code that read from invalid memory" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32MemRead -- Initialize machine registers regWrite uc X86.Ecx 0x1234 regWrite uc X86.Edx 0x7890 -- Tracing all basic block with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instructions by having @beegin > @end codeHookAdd uc hookCode () 1 0 -- Emulate machine code in infinite time let codeLen = codeLength x86Code32MemRead start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" ecx <- regRead uc X86.Ecx edx <- regRead uc X86.Edx emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx emuPutStrLn $ ">>> EDX = 0x" ++ showHex edx case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err -- Emulate code that write invalid memory testI386InvalidMemWrite :: IO () testI386InvalidMemWrite = do putStrLn "===================================" putStrLn "Emulate i386 code that write to invalid memory" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32MemWrite -- Initialize machine registers regWrite uc X86.Ecx 0x1234 regWrite uc X86.Edx 0x7890 -- Tracing all basic blocks with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instruction by having @begin > @end codeHookAdd uc hookCode () 1 0 -- Intercept invalid memory events memoryEventHookAdd uc HookMemReadUnmapped hookMemInvalid () 1 0 memoryEventHookAdd uc HookMemWriteUnmapped hookMemInvalid () 1 0 -- Emulate machine code in infinite time let codeLen = codeLength x86Code32MemWrite start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" ecx <- regRead uc X86.Ecx edx <- regRead uc X86.Edx emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx emuPutStrLn $ ">>> EDX = 0x" ++ showHex edx -- Read from memory tmp <- memRead uc 0xaaaaaaaa 4 emuPutStrLn $ ">>> Read 4 bytes from [0x" ++ showHex 0xaaaaaaaa ++ "] = 0x" ++ showHexBS tmp tmp <- memRead uc 0xffffffaa 4 emuPutStrLn $ ">>> Read 4 bytes from [0x" ++ showHex 0xffffffaa ++ "] = 0x" ++ showHexBS tmp case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err -- Emulate code that jump to invalid memory testI386JumpInvalid :: IO () testI386JumpInvalid = do putStrLn "===================================" putStrLn "Emulate i386 code that jumps to invalid memory" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32JmpInvalid -- Initialize machine registers regWrite uc X86.Ecx 0x1234 regWrite uc X86.Edx 0x7890 -- Tracing all basic blocks with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instructions by having @begin > @end codeHookAdd uc hookCode () 1 0 -- Emulate machine code in infinite time let codeLen = codeLength x86Code32JmpInvalid start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" ecx <- regRead uc X86.Ecx edx <- regRead uc X86.Edx emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx emuPutStrLn $ ">>> EDX = 0x" ++ showHex edx case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err testI386InOut :: IO () testI386InOut = do putStrLn "===================================" putStrLn "Emulate i386 code with IN/OUT instructions" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32InOut -- Initialize machine registers regWrite uc X86.Eax 0x1234 regWrite uc X86.Ecx 0x6789 -- Tracing all basic blocks with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instructions codeHookAdd uc hookCode () 1 0 -- uc IN instruction inHookAdd uc hookIn () 1 0 -- uc OUT instruction outHookAdd uc hookOut () 1 0 -- Emulate machine code in infinite time let codeLen = codeLength x86Code32InOut start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" eax <- regRead uc X86.Eax ecx <- regRead uc X86.Ecx emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax emuPutStrLn $ ">>> ECX = 0x" ++ showHex ecx case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err -- Emulate code and save/restore the CPU context testI386ContextSave :: IO () testI386ContextSave = do putStrLn "===================================" putStrLn "Save/restore CPU context in opaque blob" result <- runEmulator $ do -- Initialize emulator in X86-32bit mode uc <- open ArchX86 [Mode32] -- Map 8KB memory for this emulation memMap uc address (8 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code32Inc -- Initialize machine registers regWrite uc X86.Eax 0x1 -- Emulate machine code in infinite time emuPutStrLn ">>> Running emulation for the first time" let codeLen = codeLength x86Code32Inc start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" eax <- regRead uc X86.Eax emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax -- Allocate and save the CPU context emuPutStrLn ">>> Saving CPU context" context <- contextAllocate uc contextSave uc context -- Emulate machine code again emuPutStrLn ">>> Running emulation for the second time" start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" eax <- regRead uc X86.Eax emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax -- Restore CPU context contextRestore uc context -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" eax <- regRead uc X86.Eax emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err testX8664 :: IO () testX8664 = do putStrLn "Emulate x86_64 code" result <- runEmulator $ do -- Initialize emualator in X86-64bit mode uc <- open ArchX86 [Mode64] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code64 -- Initialize machine registers regWrite uc X86.Rsp (fromIntegral address + 0x200000) regWrite uc X86.Rax 0x71f3029efd49d41d regWrite uc X86.Rbx 0xd87b45277f133ddb regWrite uc X86.Rcx 0xab40d1ffd8afc461 regWrite uc X86.Rdx 0x919317b4a733f01 regWrite uc X86.Rsi 0x4c24e753a17ea358 regWrite uc X86.Rdi 0xe509a57d2571ce96 regWrite uc X86.R8 0xea5b108cc2b9ab1f regWrite uc X86.R9 0x19ec097c8eb618c1 regWrite uc X86.R10 0xec45774f00c5f682 regWrite uc X86.R11 0xe17e9dbec8c074aa regWrite uc X86.R12 0x80f86a8dc0f6d457 regWrite uc X86.R13 0x48288ca5671c5492 regWrite uc X86.R14 0x595f72f6e4017f6e regWrite uc X86.R15 0x1efd97aea331cccc -- Tracing all basic blocks with customized callback blockHookAdd uc hookBlock () 1 0 -- Tracing all instructions in the range [address, address+20] codeHookAdd uc hookCode64 () address (address + 20) -- Tracing all memory WRITE access (with @begin > @end) memoryHookAdd uc HookMemWrite hookMem64 () 1 0 -- Tracing all memory READ access (with @begin > @end) memoryHookAdd uc HookMemRead hookMem64 () 1 0 -- Emulate machine code in infinite time (last param = Nothing), or -- when finishing all the code let codeLen = codeLength x86Code64 start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" rax <- regRead uc X86.Rax rbx <- regRead uc X86.Rbx rcx <- regRead uc X86.Rcx rdx <- regRead uc X86.Rdx rsi <- regRead uc X86.Rsi rdi <- regRead uc X86.Rdi r8 <- regRead uc X86.R8 r9 <- regRead uc X86.R9 r10 <- regRead uc X86.R10 r11 <- regRead uc X86.R11 r12 <- regRead uc X86.R12 r13 <- regRead uc X86.R13 r14 <- regRead uc X86.R14 r15 <- regRead uc X86.R15 emuPutStrLn $ ">>> RAX = 0x" ++ showHex rax emuPutStrLn $ ">>> RBX = 0x" ++ showHex rbx emuPutStrLn $ ">>> RCX = 0x" ++ showHex rcx emuPutStrLn $ ">>> RDX = 0x" ++ showHex rdx emuPutStrLn $ ">>> RSI = 0x" ++ showHex rsi emuPutStrLn $ ">>> RDI = 0x" ++ showHex rdi emuPutStrLn $ ">>> R8 = 0x" ++ showHex r8 emuPutStrLn $ ">>> R9 = 0x" ++ showHex r9 emuPutStrLn $ ">>> R10 = 0x" ++ showHex r10 emuPutStrLn $ ">>> R11 = 0x" ++ showHex r11 emuPutStrLn $ ">>> R12 = 0x" ++ showHex r12 emuPutStrLn $ ">>> R13 = 0x" ++ showHex r13 emuPutStrLn $ ">>> R14 = 0x" ++ showHex r14 emuPutStrLn $ ">>> R15 = 0x" ++ showHex r15 case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err testX8664Syscall :: IO () testX8664Syscall = do putStrLn "===================================" putStrLn "Emulate x86_64 code with 'syscall' instruction" result <- runEmulator $ do -- Initialize emulator in X86-64bit mode uc <- open ArchX86 [Mode64] -- Map 2MB memory for this emulation memMap uc address (2 * 1024 * 1024) [ProtAll] -- Write machine code to be emulated to memory memWrite uc address x86Code64Syscall -- Hook interrupts for syscall syscallHookAdd uc hookSyscall () 1 0 -- Initialize machine registers regWrite uc X86.Rax 0x100 -- Emulate machine code in infinite time (last param = Nothing), or -- when finishing all code let codeLen = codeLength x86Code64Syscall start uc address (address + codeLen) Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" rax <- regRead uc X86.Rax emuPutStrLn $ ">>> RAX = 0x" ++ showHex rax case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err testX8616 :: IO () testX8616 = do putStrLn "Emulate x86 16-bit code" result <- runEmulator $ do -- Initialize emulator in X86-16bit mode uc <- open ArchX86 [Mode16] -- Map 8KB memory for this emulation memMap uc 0 (8 * 1024) [ProtAll] -- Write machine code to be emulated in memory memWrite uc 0 x86Code16 -- Initialize machine registers regWrite uc X86.Eax 7 regWrite uc X86.Ebx 5 regWrite uc X86.Esi 6 -- Emulate machine code in infinite time (last param = Nothing), or -- when finishing all the code let codeLen = codeLength x86Code16 start uc 0 codeLen Nothing Nothing -- Now print out some registers emuPutStrLn ">>> Emulation done. Below is the CPU context" -- Read from memory tmp <- memRead uc 11 1 emuPutStrLn $ ">>> Read 1 bytes from [0x" ++ showHex 11 ++ "] = 0x" ++ showHexBS tmp case result of Right _ -> return () Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++ strerror err main :: IO () main = do progName <- getProgName args <- getArgs case args of ["-32"] -> do testI386 testI386InOut testI386ContextSave testI386Jump testI386Loop testI386InvalidMemRead testI386InvalidMemWrite testI386JumpInvalid ["-64"] -> do testX8664 testX8664Syscall ["-16"] -> testX8616 -- Test memleak ["-0"] -> testI386 _ -> putStrLn $ "Syntax: " ++ progName ++ " <-16|-32|-64>"