diff --git a/README.md b/README.md index e24179d8..b0ec6689 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -## mcsema2 +## remill [![Build Status](https://travis-ci.com/trailofbits/mcsema2.svg?token=T1UToSpCvaMxn511Cddb)](https://travis-ci.com/trailofbits/mcsema2) ### Setup @@ -29,9 +29,9 @@ like `/tmp/tmp.E3RWcczulG.cfg`. Lets assume that `/path/to/binary` is a 32-bit ELF file. Now you can do the following: ``` -/path/to/mcsema2/build/cfg_to_bc \ +/path/to/remill/build/cfg_to_bc \ --arch_in=x86 --arch_out=x86 --os_in=linux --os_out=linux \ - --bc_in=/path/to/mcsema2/generated/sem_x86.bc --bc_out=$BIN.bc --cfg=$CFG + --bc_in=/path/to/remill/generated/sem_x86.bc --bc_out=$BIN.bc --cfg=$CFG ``` For 64-bit x86 programs, specificy `--arch_in=amd64`. If you intend to run a 32-bit @@ -52,7 +52,7 @@ right thing. #### Optimizing the bitcode There are a few ways to optimize the produced bitcode. The first is to tell -mcsema2 to perform a data flow analysis and to try to kill things like dead +remill to perform a data flow analysis and to try to kill things like dead registers. The data flow analyzer is enabled by specifying a maximum number of data flow @@ -60,7 +60,7 @@ analysis iterations to perform. By default, the maximum number is `0` (disabled) For a comprehensive analysis, specify a large number, e.g.: ``` -/path/to/mcsema2/build/cfg_to_bc ... --max_dataflow_analysis_iterations=99999 ... +/path/to/remill/build/cfg_to_bc ... --max_dataflow_analysis_iterations=99999 ... ``` In order to maintain correctness, the data-flow analysis is conservative. @@ -69,7 +69,7 @@ agressive analysis can be performed. This analysis will try to propagate data flow information across function returns, for instance. It is enabled with the `--aggressive_dataflow_analysis` flag. -Once bitcode has been produced, it can be optimized using the mcsema2-specific +Once bitcode has been produced, it can be optimized using the remill-specific LLVM optimization plugin. The following will produce optimized bitcode in a file named by `$OPT`. diff --git a/mcsema/Arch/Analysis.h b/mcsema/Arch/Analysis.h deleted file mode 100644 index 6e4a40f7..00000000 --- a/mcsema/Arch/Analysis.h +++ /dev/null @@ -1,6 +0,0 @@ -/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#ifndef MCSEMA_ARCH_ANALYSIS_H_ -#define MCSEMA_ARCH_ANALYSIS_H_ - -#endif // MCSEMA_ARCH_ANALYSIS_H_ diff --git a/mcsema/Arch/Runtime/Intrinsics.cpp b/mcsema/Arch/Runtime/Intrinsics.cpp deleted file mode 100644 index 19dcaa5a..00000000 --- a/mcsema/Arch/Runtime/Intrinsics.cpp +++ /dev/null @@ -1,98 +0,0 @@ -/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#ifndef MCSEMA_ARCH_SEMANTICS_INSTRINSICS_CPP_ -#define MCSEMA_ARCH_SEMANTICS_INSTRINSICS_CPP_ - -#include "mcsema/Arch/Runtime/Intrinsics.h" - -#define USED(sym) \ - __mcsema_mark_as_used(reinterpret_cast(&sym)) - -extern "C" order_t __mcsema_memory_order = 0; - -// This is two big hacks: -// 1) This makes sure that a symbol is treated as used and prevents it -// from being optimized away. -// 2) This makes sure that some functions are marked has having their -// addresses taken, and so this prevents dead argument elimination. -extern "C" void __mcsema_mark_as_used(void *); - -// This is just a hack to make sure all these functions appear in the bitcode -// file! -[[gnu::used]] - extern "C" void __mcsema_intrinsics(void) { - USED(__mcsema_create_program_counter); - - USED(__mcsema_read_memory_8); - USED(__mcsema_read_memory_16); - USED(__mcsema_read_memory_32); - USED(__mcsema_read_memory_64); - - USED(__mcsema_read_memory_v8); - USED(__mcsema_read_memory_v16); - USED(__mcsema_read_memory_v32); - USED(__mcsema_read_memory_v64); - USED(__mcsema_read_memory_v128); - USED(__mcsema_read_memory_v256); - USED(__mcsema_read_memory_v512); - - USED(__mcsema_write_memory_8); - USED(__mcsema_write_memory_16); - USED(__mcsema_write_memory_32); - USED(__mcsema_write_memory_64); - - USED(__mcsema_write_memory_v8); - USED(__mcsema_write_memory_v16); - USED(__mcsema_write_memory_v32); - USED(__mcsema_write_memory_v64); - USED(__mcsema_write_memory_v128); - USED(__mcsema_write_memory_v256); - USED(__mcsema_write_memory_v512); - - USED(__mcsema_read_memory_f32); - USED(__mcsema_read_memory_f64); - USED(__mcsema_read_memory_f80); - - USED(__mcsema_write_memory_f32); - USED(__mcsema_write_memory_f64); - USED(__mcsema_write_memory_f80); - - USED(__mcsema_barrier_load_load); - USED(__mcsema_barrier_load_store); - USED(__mcsema_barrier_store_load); - USED(__mcsema_barrier_store_store); - - USED(__mcsema_atomic_begin); - USED(__mcsema_atomic_end); - - USED(__mcsema_compute_address); // Used for segmented addresses. - - USED(__mcsema_defer_inlining); - - USED(__mcsema_error); - - USED(__mcsema_function_call); - USED(__mcsema_function_return); - USED(__mcsema_jump); - USED(__mcsema_system_call); - USED(__mcsema_system_return); - USED(__mcsema_interrupt_call); - USED(__mcsema_interrupt_return); - USED(__mcsema_conditional_branch); - USED(__mcsema_missing_block); - - USED(__mcsema_undefined_bool); - USED(__mcsema_undefined_8); - USED(__mcsema_undefined_16); - USED(__mcsema_undefined_32); - USED(__mcsema_undefined_64); - USED(__mcsema_undefined_f32); - USED(__mcsema_undefined_f64); - - USED(__mcsema_read_f80); - USED(__mcsema_write_f80); - - USED(__mcsema_read_cpu_features); -} - -#endif // MCSEMA_ARCH_SEMANTICS_INSTRINSICS_CPP_ diff --git a/mcsema/Arch/Runtime/Intrinsics.h b/mcsema/Arch/Runtime/Intrinsics.h deleted file mode 100644 index 1ae7d52a..00000000 --- a/mcsema/Arch/Runtime/Intrinsics.h +++ /dev/null @@ -1,216 +0,0 @@ -/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#ifndef MCSEMA_ARCH_SEMANTICS_INSTRINSICS_H_ -#define MCSEMA_ARCH_SEMANTICS_INSTRINSICS_H_ - -#include "mcsema/Arch/Runtime/Types.h" - -extern "C" { - -extern order_t __mcsema_memory_order; - -// The basic block "template". -[[gnu::used]] -void __mcsema_basic_block(State &state, addr_t); - -// Address computation intrinsic. This is only used for non-zero -// `address_space`d memory accesses. -[[gnu::used]] -extern addr_t __mcsema_compute_address( - const State &state, addr_t address, int address_space); - -// Semantics, describes that some value is now a possible program counter. -[[gnu::used]] -extern addr_t __mcsema_create_program_counter(addr_t); - -// Memory read intrinsics. -[[gnu::used]] -extern uint8_t __mcsema_read_memory_8(order_t, addr_t); - -[[gnu::used]] -extern uint16_t __mcsema_read_memory_16(order_t, addr_t); - -[[gnu::used]] -extern uint32_t __mcsema_read_memory_32(order_t, addr_t); - -[[gnu::used]] -extern uint64_t __mcsema_read_memory_64(order_t, addr_t); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v8(order_t, addr_t, vec8_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v16(order_t, addr_t, vec16_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v32(order_t, addr_t, vec32_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v64(order_t, addr_t, vec64_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v128(order_t, addr_t, vec128_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v256(order_t, addr_t, vec256_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_v512(order_t, addr_t, vec512_t &); - -// Memory write intrinsics. -[[gnu::used]] -extern order_t __mcsema_write_memory_8(order_t, addr_t, uint8_t); - -[[gnu::used]] -extern order_t __mcsema_write_memory_16(order_t, addr_t, uint16_t); - -[[gnu::used]] -extern order_t __mcsema_write_memory_32(order_t, addr_t, uint32_t); - -[[gnu::used]] -extern order_t __mcsema_write_memory_64(order_t, addr_t, uint64_t); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v8(order_t, addr_t, const vec8_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v16(order_t, addr_t, const vec16_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v32(order_t, addr_t, const vec32_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v64(order_t, addr_t, const vec64_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v128(order_t, addr_t, const vec128_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v256(order_t, addr_t, const vec256_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_v512(order_t, addr_t, const vec512_t &); - - -[[gnu::used]] -extern order_t __mcsema_read_memory_f32(order_t, addr_t, float32_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_f64(order_t, addr_t, float64_t &); - -[[gnu::used]] -extern order_t __mcsema_read_memory_f80(order_t, addr_t, float80_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_f32(order_t, addr_t, const float32_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_f64(order_t, addr_t, const float64_t &); - -[[gnu::used]] -extern order_t __mcsema_write_memory_f80(order_t, addr_t, const float80_t &); - -[[gnu::used]] -extern bool __mcsema_undefined_bool(void); - -[[gnu::used]] -extern uint8_t __mcsema_undefined_8(void); - -[[gnu::used]] -extern uint16_t __mcsema_undefined_16(void); - -[[gnu::used]] -extern uint32_t __mcsema_undefined_32(void); - -[[gnu::used]] -extern uint64_t __mcsema_undefined_64(void); - -[[gnu::used]] -extern float32_t __mcsema_undefined_f32(void); - -[[gnu::used]] -extern float64_t __mcsema_undefined_f64(void); - -// Inlining control. The idea here is that sometimes we want to defer inlining -// until a later time, and we need to communicate what should eventually be -// inlined, even if it's not currently inlined. -[[gnu::used]] -extern void __mcsema_defer_inlining(void); - -// Generic error. -[[gnu::used]] -extern void __mcsema_error(State &, addr_t addr); - -// Control-flow intrinsics. -[[gnu::used]] -extern void __mcsema_function_call(State &, addr_t addr); - -[[gnu::used]] -extern void __mcsema_function_return(State &, addr_t addr); - -[[gnu::used]] -extern void __mcsema_jump(State &, addr_t addr); - -[[gnu::used]] -extern void __mcsema_system_call(State &, addr_t ret_addr); - -[[gnu::used]] -extern void __mcsema_system_return(State &, addr_t addr); - -[[gnu::used]] -extern void __mcsema_interrupt_call(State &, addr_t ret_addr); - -[[gnu::used]] -extern void __mcsema_interrupt_return(State &, addr_t addr); - -// Represents a known unknown block. -[[gnu::used]] -extern void __mcsema_missing_block(State &, addr_t); - -[[gnu::used]] -extern addr_t __mcsema_conditional_branch( - bool condition, addr_t if_true, addr_t if_false); - -// Memory barriers types, see: http://g.oswego.edu/dl/jmm/cookbook.html -[[gnu::used]] -extern order_t __mcsema_barrier_load_load(order_t); - -[[gnu::used]] -extern order_t __mcsema_barrier_load_store(order_t); - -[[gnu::used]] -extern order_t __mcsema_barrier_store_load(order_t); - -[[gnu::used]] -extern order_t __mcsema_barrier_store_store(order_t); - -// Atomic operations. The address/size are hints, but the granularity of the -// access can be bigger. These have implicit StoreLoad semantics. -[[gnu::used]] -extern order_t __mcsema_atomic_begin(order_t); - -[[gnu::used]] -extern order_t __mcsema_atomic_end(order_t); - -// Arch-specific feature lookup. Implemented as a pseudo control-flow -// intrinsic. -[[gnu::used]] -extern void __mcsema_read_cpu_features(State &, addr_t addr); - -// Arch-specific. Marshal a float80_t into a float64_t. -// -// TODO(pag): https://stackoverflow.com/questions/2963055/msvc-win32-convert-extended-precision-float-80-bit-to-double-64-bit -extern void __mcsema_read_f80(const float80_t &, float64_t &); - -// Arch-specific. Marshal a float64_t into a float64_t. -extern void __mcsema_write_f80(const float64_t &, float80_t &); - -#define __mcsema_barrier_compiler() -// __asm__ __volatile__ ("" ::: "memory") - -[[gnu::used]] -extern void __mcsema_intrinsics(void); - -} // extern C - -#endif // MCSEMA_ARCH_SEMANTICS_INSTRINSICS_H_ diff --git a/mcsema/Arch/Runtime/Runtime.h b/mcsema/Arch/Runtime/Runtime.h deleted file mode 100644 index d4ece23c..00000000 --- a/mcsema/Arch/Runtime/Runtime.h +++ /dev/null @@ -1,15 +0,0 @@ -/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#ifndef MCSEMA_ARCH_RUNTIME_RUNTIME_H_ -#define MCSEMA_ARCH_RUNTIME_RUNTIME_H_ - -#ifndef ADDRESS_SIZE_BITS -# define ADDRESS_SIZE_BITS 64 -#endif - -#include "mcsema/Arch/Runtime/Intrinsics.h" -#include "mcsema/Arch/Runtime/Operators.h" -#include "mcsema/Arch/Runtime/Types.h" -#include "mcsema/Arch/Runtime/Util.h" - -#endif // MCSEMA_ARCH_RUNTIME_RUNTIME_H_ diff --git a/mcsema/Arch/X86/Runtime/Instructions.cpp b/mcsema/Arch/X86/Runtime/Instructions.cpp deleted file mode 100644 index 4d9d600c..00000000 --- a/mcsema/Arch/X86/Runtime/Instructions.cpp +++ /dev/null @@ -1,30 +0,0 @@ -/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#include "mcsema/Arch/Runtime/Types.cpp" - -#include "mcsema/Arch/X86/Runtime/State.h" -#include "mcsema/Arch/X86/Runtime/Types.h" - -// Define the `PushValue` and `PopValue` helpers. -#include "mcsema/Arch/X86/Semantics/POP.h" -#include "mcsema/Arch/X86/Semantics/PUSH.h" - -#include "mcsema/Arch/X86/Semantics/FLAGS.h" -#include "mcsema/Arch/X86/Semantics/BINARY.h" -#include "mcsema/Arch/X86/Semantics/BITBYTE.h" -#include "mcsema/Arch/X86/Semantics/CALL_RET.h" -#include "mcsema/Arch/X86/Semantics/CMOV.h" -#include "mcsema/Arch/X86/Semantics/COND_BR.h" -#include "mcsema/Arch/X86/Semantics/CONVERT.h" -#include "mcsema/Arch/X86/Semantics/DATAXFER.h" -#include "mcsema/Arch/X86/Semantics/INTERRUPT.h" -#include "mcsema/Arch/X86/Semantics/FMA.h" -#include "mcsema/Arch/X86/Semantics/LOGICAL.h" -#include "mcsema/Arch/X86/Semantics/MISC.h" -#include "mcsema/Arch/X86/Semantics/ROTATE.h" -#include "mcsema/Arch/X86/Semantics/SHIFT.h" -#include "mcsema/Arch/X86/Semantics/SSE.h" -#include "mcsema/Arch/X86/Semantics/STRINGOP.h" -#include "mcsema/Arch/X86/Semantics/UNCOND_BR.h" -#include "mcsema/Arch/X86/Semantics/XOP.h" -#include "mcsema/Arch/X86/Semantics/X87.h" diff --git a/mcsema/BC/IntrinsicTable.cpp b/mcsema/BC/IntrinsicTable.cpp deleted file mode 100644 index 95338afe..00000000 --- a/mcsema/BC/IntrinsicTable.cpp +++ /dev/null @@ -1,160 +0,0 @@ -/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ - -#include - -#include - -#include -#include -#include - -#include "mcsema/BC/IntrinsicTable.h" -#include "mcsema/BC/Util.h" - -namespace mcsema { -namespace { - -// Find a specific function. -static llvm::Function *FindIntrinsic(const llvm::Module *module, - const char *name) { - auto function = FindFunction(module, name); - CHECK(nullptr != function) - << "Unable to find intrinsic: " << name; - - // We don't want calls to memory intrinsics to be duplicated because then - // they might have the wrong side effects! - function->addFnAttr(llvm::Attribute::NoDuplicate); - - InitFunctionAttributes(function); - return function; -} - -// Find a specific function. -static llvm::Function *FindPureIntrinsic(const llvm::Module *module, - const char *name) { - auto function = FindIntrinsic(module, name); - - // We want memory intrinsics to be marked as not accessing memory so that - // they don't interfere with dead store elimination. - function->addFnAttr(llvm::Attribute::ReadNone); - return function; -} - -// Find a specific function. -static llvm::Function *FindReadOnlyIntrinsic(const llvm::Module *module, - const char *name) { - auto function = FindIntrinsic(module, name); - - // We want memory intrinsics to be marked as not accessing memory so that - // they don't interfere with dead store elimination. - function->addFnAttr(llvm::Attribute::ReadOnly); - return function; -} - -} // namespace - -IntrinsicTable::IntrinsicTable(const llvm::Module *module) - : error(FindIntrinsic(module, "__mcsema_error")), - - // Control-flow. - function_call(FindIntrinsic(module, "__mcsema_function_call")), - function_return(FindIntrinsic(module, "__mcsema_function_return")), - jump(FindIntrinsic(module, "__mcsema_jump")), - - // Signaling control-flow. - create_program_counter(FindPureIntrinsic( - module, "__mcsema_create_program_counter")), - conditional_branch(FindPureIntrinsic( - module, "__mcsema_conditional_branch")), - - // OS interaction. - system_call(FindIntrinsic(module, "__mcsema_system_call")), - system_return(FindIntrinsic(module, "__mcsema_system_return")), - interrupt_call(FindIntrinsic(module, "__mcsema_interrupt_call")), - interrupt_return(FindIntrinsic(module, "__mcsema_interrupt_return")), - - // Arch interaction. - read_cpu_features(FindIntrinsic(module, "__mcsema_read_cpu_features")), - - // Block that can't be found. - missing_block(FindIntrinsic(module, "__mcsema_missing_block")), - - // Memory access. - read_memory_8(FindPureIntrinsic(module, "__mcsema_read_memory_8")), - read_memory_16(FindPureIntrinsic(module, "__mcsema_read_memory_16")), - read_memory_32(FindPureIntrinsic(module, "__mcsema_read_memory_32")), - read_memory_64(FindPureIntrinsic(module, "__mcsema_read_memory_64")), - - // These take in a value by reference and modify it, therefore they are - // NOT pure. - read_memory_v8(FindIntrinsic(module, "__mcsema_read_memory_v8")), - read_memory_v16(FindIntrinsic(module, "__mcsema_read_memory_v16")), - read_memory_v32(FindIntrinsic(module, "__mcsema_read_memory_v32")), - read_memory_v64(FindIntrinsic(module, "__mcsema_read_memory_v64")), - read_memory_v128(FindIntrinsic(module, "__mcsema_read_memory_v128")), - read_memory_v256(FindIntrinsic(module, "__mcsema_read_memory_v256")), - read_memory_v512(FindIntrinsic(module, "__mcsema_read_memory_v512")), - - write_memory_8(FindPureIntrinsic(module, "__mcsema_write_memory_8")), - write_memory_16(FindPureIntrinsic(module, "__mcsema_write_memory_16")), - write_memory_32(FindPureIntrinsic(module, "__mcsema_write_memory_32")), - write_memory_64(FindPureIntrinsic(module, "__mcsema_write_memory_64")), - - write_memory_v8(FindReadOnlyIntrinsic(module, "__mcsema_write_memory_v8")), - write_memory_v16(FindReadOnlyIntrinsic(module, "__mcsema_write_memory_v16")), - write_memory_v32(FindReadOnlyIntrinsic(module, "__mcsema_write_memory_v32")), - write_memory_v64(FindReadOnlyIntrinsic(module, "__mcsema_write_memory_v64")), - write_memory_v128(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_v128")), - write_memory_v256(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_v256")), - write_memory_v512(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_v512")), - - read_memory_f32(FindIntrinsic(module, "__mcsema_read_memory_f32")), - read_memory_f64(FindIntrinsic(module, "__mcsema_read_memory_f64")), - read_memory_f80(FindIntrinsic(module, "__mcsema_read_memory_f80")), - - write_memory_f32(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_f32")), - write_memory_f64(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_f64")), - write_memory_f80(FindReadOnlyIntrinsic( - module, "__mcsema_write_memory_f80")), - - read_f80(FindIntrinsic(module, "__mcsema_read_f80")), - write_f80(FindIntrinsic(module, "__mcsema_write_f80")), - - compute_address(FindPureIntrinsic(module, "__mcsema_compute_address")), - - // Memory barriers. - barrier_load_load(FindPureIntrinsic( - module, "__mcsema_barrier_load_load")), - barrier_load_store(FindPureIntrinsic( - module, "__mcsema_barrier_load_store")), - barrier_store_load(FindPureIntrinsic( - module, "__mcsema_barrier_store_load")), - barrier_store_store(FindPureIntrinsic( - module, "__mcsema_barrier_store_store")), - atomic_begin(FindPureIntrinsic(module, "__mcsema_atomic_begin")), - atomic_end(FindPureIntrinsic(module, "__mcsema_atomic_end")), - - // Optimization guides. - // - // Note: NOT pure! This is a total hack: we call an unpure function - // within a pure one so that it is not optimized out! - defer_inlining(FindIntrinsic(module, "__mcsema_defer_inlining")), - - // Optimization enablers. - undefined_bool(FindPureIntrinsic(module, "__mcsema_undefined_bool")), - undefined_8(FindPureIntrinsic(module, "__mcsema_undefined_8")), - undefined_16(FindPureIntrinsic(module, "__mcsema_undefined_16")), - undefined_32(FindPureIntrinsic(module, "__mcsema_undefined_32")), - undefined_64(FindPureIntrinsic(module, "__mcsema_undefined_64")), - undefined_f32(FindPureIntrinsic(module, "__mcsema_undefined_f32")), - undefined_f64(FindPureIntrinsic(module, "__mcsema_undefined_f64")), - - // Used for the global ordering of memory instructions. - memory_order(FindGlobaVariable(module, "__mcsema_memory_order")) {} - -} // namespace mcsema diff --git a/remill/Arch/Analysis.h b/remill/Arch/Analysis.h new file mode 100644 index 00000000..a244bb00 --- /dev/null +++ b/remill/Arch/Analysis.h @@ -0,0 +1,6 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef REMILL_ARCH_ANALYSIS_H_ +#define REMILL_ARCH_ANALYSIS_H_ + +#endif // REMILL_ARCH_ANALYSIS_H_ diff --git a/mcsema/Arch/Arch.cpp b/remill/Arch/Arch.cpp similarity index 93% rename from mcsema/Arch/Arch.cpp rename to remill/Arch/Arch.cpp index 1d76e8fa..c4f28222 100644 --- a/mcsema/Arch/Arch.cpp +++ b/remill/Arch/Arch.cpp @@ -2,8 +2,8 @@ #include -#include "mcsema/Arch/Arch.h" -#include "mcsema/Arch/X86/Arch.h" +#include "remill/Arch/Arch.h" +#include "remill/Arch/X86/Arch.h" #ifndef _WIN64 # define _WIN64 0 @@ -17,7 +17,7 @@ # define __x86_64__ 0 #endif -namespace mcsema { +namespace remill { Arch::Arch(OSName os_name_, ArchName arch_name_, unsigned address_size_) : os_name(os_name_), diff --git a/mcsema/Arch/Arch.h b/remill/Arch/Arch.h similarity index 90% rename from mcsema/Arch/Arch.h rename to remill/Arch/Arch.h index 8336d738..528dc2fd 100644 --- a/mcsema/Arch/Arch.h +++ b/remill/Arch/Arch.h @@ -1,12 +1,12 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_ARCH_H_ -#define MCSEMA_ARCH_ARCH_H_ +#ifndef REMILL_ARCH_ARCH_H_ +#define REMILL_ARCH_ARCH_H_ #include -#include "mcsema/CFG/AutoAnalysis.h" -#include "mcsema/OS/OS.h" +#include "remill/CFG/AutoAnalysis.h" +#include "remill/OS/OS.h" namespace llvm { class Module; @@ -14,7 +14,7 @@ class BasicBlock; class Function; } // namespace llvm. -namespace mcsema { +namespace remill { namespace cfg { class Instr; } // namespace cfg @@ -68,6 +68,6 @@ class Arch { Arch(void) = delete; }; -} // namespace mcsema +} // namespace remill #endif // MC_SEMA_ARCH_ARCH_H_ diff --git a/remill/Arch/Runtime/Intrinsics.cpp b/remill/Arch/Runtime/Intrinsics.cpp new file mode 100644 index 00000000..443d2b55 --- /dev/null +++ b/remill/Arch/Runtime/Intrinsics.cpp @@ -0,0 +1,98 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef REMILL_ARCH_SEMANTICS_INSTRINSICS_CPP_ +#define REMILL_ARCH_SEMANTICS_INSTRINSICS_CPP_ + +#include "remill/Arch/Runtime/Intrinsics.h" + +#define USED(sym) \ + __remill_mark_as_used(reinterpret_cast(&sym)) + +extern "C" order_t __remill_memory_order = 0; + +// This is two big hacks: +// 1) This makes sure that a symbol is treated as used and prevents it +// from being optimized away. +// 2) This makes sure that some functions are marked has having their +// addresses taken, and so this prevents dead argument elimination. +extern "C" void __remill_mark_as_used(void *); + +// This is just a hack to make sure all these functions appear in the bitcode +// file! +[[gnu::used]] + extern "C" void __remill_intrinsics(void) { + USED(__remill_create_program_counter); + + USED(__remill_read_memory_8); + USED(__remill_read_memory_16); + USED(__remill_read_memory_32); + USED(__remill_read_memory_64); + + USED(__remill_read_memory_v8); + USED(__remill_read_memory_v16); + USED(__remill_read_memory_v32); + USED(__remill_read_memory_v64); + USED(__remill_read_memory_v128); + USED(__remill_read_memory_v256); + USED(__remill_read_memory_v512); + + USED(__remill_write_memory_8); + USED(__remill_write_memory_16); + USED(__remill_write_memory_32); + USED(__remill_write_memory_64); + + USED(__remill_write_memory_v8); + USED(__remill_write_memory_v16); + USED(__remill_write_memory_v32); + USED(__remill_write_memory_v64); + USED(__remill_write_memory_v128); + USED(__remill_write_memory_v256); + USED(__remill_write_memory_v512); + + USED(__remill_read_memory_f32); + USED(__remill_read_memory_f64); + USED(__remill_read_memory_f80); + + USED(__remill_write_memory_f32); + USED(__remill_write_memory_f64); + USED(__remill_write_memory_f80); + + USED(__remill_barrier_load_load); + USED(__remill_barrier_load_store); + USED(__remill_barrier_store_load); + USED(__remill_barrier_store_store); + + USED(__remill_atomic_begin); + USED(__remill_atomic_end); + + USED(__remill_compute_address); // Used for segmented addresses. + + USED(__remill_defer_inlining); + + USED(__remill_error); + + USED(__remill_function_call); + USED(__remill_function_return); + USED(__remill_jump); + USED(__remill_system_call); + USED(__remill_system_return); + USED(__remill_interrupt_call); + USED(__remill_interrupt_return); + USED(__remill_conditional_branch); + USED(__remill_missing_block); + + USED(__remill_undefined_bool); + USED(__remill_undefined_8); + USED(__remill_undefined_16); + USED(__remill_undefined_32); + USED(__remill_undefined_64); + USED(__remill_undefined_f32); + USED(__remill_undefined_f64); + + USED(__remill_read_f80); + USED(__remill_write_f80); + + USED(__remill_read_cpu_features); +} + +#endif // REMILL_ARCH_SEMANTICS_INSTRINSICS_CPP_ diff --git a/remill/Arch/Runtime/Intrinsics.h b/remill/Arch/Runtime/Intrinsics.h new file mode 100644 index 00000000..51c67825 --- /dev/null +++ b/remill/Arch/Runtime/Intrinsics.h @@ -0,0 +1,216 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef REMILL_ARCH_SEMANTICS_INSTRINSICS_H_ +#define REMILL_ARCH_SEMANTICS_INSTRINSICS_H_ + +#include "remill/Arch/Runtime/Types.h" + +extern "C" { + +extern order_t __remill_memory_order; + +// The basic block "template". +[[gnu::used]] +void __remill_basic_block(State &state, addr_t); + +// Address computation intrinsic. This is only used for non-zero +// `address_space`d memory accesses. +[[gnu::used]] +extern addr_t __remill_compute_address( + const State &state, addr_t address, int address_space); + +// Semantics, describes that some value is now a possible program counter. +[[gnu::used]] +extern addr_t __remill_create_program_counter(addr_t); + +// Memory read intrinsics. +[[gnu::used]] +extern uint8_t __remill_read_memory_8(order_t, addr_t); + +[[gnu::used]] +extern uint16_t __remill_read_memory_16(order_t, addr_t); + +[[gnu::used]] +extern uint32_t __remill_read_memory_32(order_t, addr_t); + +[[gnu::used]] +extern uint64_t __remill_read_memory_64(order_t, addr_t); + +[[gnu::used]] +extern order_t __remill_read_memory_v8(order_t, addr_t, vec8_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v16(order_t, addr_t, vec16_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v32(order_t, addr_t, vec32_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v64(order_t, addr_t, vec64_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v128(order_t, addr_t, vec128_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v256(order_t, addr_t, vec256_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_v512(order_t, addr_t, vec512_t &); + +// Memory write intrinsics. +[[gnu::used]] +extern order_t __remill_write_memory_8(order_t, addr_t, uint8_t); + +[[gnu::used]] +extern order_t __remill_write_memory_16(order_t, addr_t, uint16_t); + +[[gnu::used]] +extern order_t __remill_write_memory_32(order_t, addr_t, uint32_t); + +[[gnu::used]] +extern order_t __remill_write_memory_64(order_t, addr_t, uint64_t); + +[[gnu::used]] +extern order_t __remill_write_memory_v8(order_t, addr_t, const vec8_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v16(order_t, addr_t, const vec16_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v32(order_t, addr_t, const vec32_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v64(order_t, addr_t, const vec64_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v128(order_t, addr_t, const vec128_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v256(order_t, addr_t, const vec256_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_v512(order_t, addr_t, const vec512_t &); + + +[[gnu::used]] +extern order_t __remill_read_memory_f32(order_t, addr_t, float32_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_f64(order_t, addr_t, float64_t &); + +[[gnu::used]] +extern order_t __remill_read_memory_f80(order_t, addr_t, float80_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_f32(order_t, addr_t, const float32_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_f64(order_t, addr_t, const float64_t &); + +[[gnu::used]] +extern order_t __remill_write_memory_f80(order_t, addr_t, const float80_t &); + +[[gnu::used]] +extern bool __remill_undefined_bool(void); + +[[gnu::used]] +extern uint8_t __remill_undefined_8(void); + +[[gnu::used]] +extern uint16_t __remill_undefined_16(void); + +[[gnu::used]] +extern uint32_t __remill_undefined_32(void); + +[[gnu::used]] +extern uint64_t __remill_undefined_64(void); + +[[gnu::used]] +extern float32_t __remill_undefined_f32(void); + +[[gnu::used]] +extern float64_t __remill_undefined_f64(void); + +// Inlining control. The idea here is that sometimes we want to defer inlining +// until a later time, and we need to communicate what should eventually be +// inlined, even if it's not currently inlined. +[[gnu::used]] +extern void __remill_defer_inlining(void); + +// Generic error. +[[gnu::used]] +extern void __remill_error(State &, addr_t addr); + +// Control-flow intrinsics. +[[gnu::used]] +extern void __remill_function_call(State &, addr_t addr); + +[[gnu::used]] +extern void __remill_function_return(State &, addr_t addr); + +[[gnu::used]] +extern void __remill_jump(State &, addr_t addr); + +[[gnu::used]] +extern void __remill_system_call(State &, addr_t ret_addr); + +[[gnu::used]] +extern void __remill_system_return(State &, addr_t addr); + +[[gnu::used]] +extern void __remill_interrupt_call(State &, addr_t ret_addr); + +[[gnu::used]] +extern void __remill_interrupt_return(State &, addr_t addr); + +// Represents a known unknown block. +[[gnu::used]] +extern void __remill_missing_block(State &, addr_t); + +[[gnu::used]] +extern addr_t __remill_conditional_branch( + bool condition, addr_t if_true, addr_t if_false); + +// Memory barriers types, see: http://g.oswego.edu/dl/jmm/cookbook.html +[[gnu::used]] +extern order_t __remill_barrier_load_load(order_t); + +[[gnu::used]] +extern order_t __remill_barrier_load_store(order_t); + +[[gnu::used]] +extern order_t __remill_barrier_store_load(order_t); + +[[gnu::used]] +extern order_t __remill_barrier_store_store(order_t); + +// Atomic operations. The address/size are hints, but the granularity of the +// access can be bigger. These have implicit StoreLoad semantics. +[[gnu::used]] +extern order_t __remill_atomic_begin(order_t); + +[[gnu::used]] +extern order_t __remill_atomic_end(order_t); + +// Arch-specific feature lookup. Implemented as a pseudo control-flow +// intrinsic. +[[gnu::used]] +extern void __remill_read_cpu_features(State &, addr_t addr); + +// Arch-specific. Marshal a float80_t into a float64_t. +// +// TODO(pag): https://stackoverflow.com/questions/2963055/msvc-win32-convert-extended-precision-float-80-bit-to-double-64-bit +extern void __remill_read_f80(const float80_t &, float64_t &); + +// Arch-specific. Marshal a float64_t into a float64_t. +extern void __remill_write_f80(const float64_t &, float80_t &); + +#define __remill_barrier_compiler() +// __asm__ __volatile__ ("" ::: "memory") + +[[gnu::used]] +extern void __remill_intrinsics(void); + +} // extern C + +#endif // REMILL_ARCH_SEMANTICS_INSTRINSICS_H_ diff --git a/mcsema/Arch/Runtime/Operators.h b/remill/Arch/Runtime/Operators.h similarity index 89% rename from mcsema/Arch/Runtime/Operators.h rename to remill/Arch/Runtime/Operators.h index d01be95b..0907544d 100644 --- a/mcsema/Arch/Runtime/Operators.h +++ b/remill/Arch/Runtime/Operators.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_RUNTIME_OPERATORS_H_ -#define MCSEMA_ARCH_RUNTIME_OPERATORS_H_ +#ifndef REMILL_ARCH_RUNTIME_OPERATORS_H_ +#define REMILL_ARCH_RUNTIME_OPERATORS_H_ namespace { @@ -92,8 +92,8 @@ struct VecWriter { #define MAKE_VEC_ACCESSORS(T, size) \ struct MemoryWriter ## T { \ ALWAYS_INLINE void operator=(T val) const { \ - __mcsema_memory_order = __mcsema_write_memory_v ## size (\ - __mcsema_memory_order, addr, val); \ + __remill_memory_order = __remill_write_memory_v ## size (\ + __remill_memory_order, addr, val); \ } \ template ::VecType, \ @@ -101,8 +101,8 @@ struct VecWriter { ALWAYS_INLINE void operator=(V val) const { \ T vec; \ VectorAssign::BaseType, T, V>::assign(vec, val);\ - __mcsema_memory_order = __mcsema_write_memory_v ## size ( \ - __mcsema_memory_order, addr, vec); \ + __remill_memory_order = __remill_write_memory_v ## size ( \ + __remill_memory_order, addr, vec); \ } \ \ addr_t addr; \ @@ -110,8 +110,8 @@ struct VecWriter { \ ALWAYS_INLINE static T R(const Mn mem) { \ T ret_val; \ - __mcsema_memory_order = __mcsema_read_memory_v ## size ( \ - __mcsema_memory_order, mem.addr, ret_val); \ + __remill_memory_order = __remill_read_memory_v ## size ( \ + __remill_memory_order, mem.addr, ret_val); \ return ret_val; \ } \ ALWAYS_INLINE static MemoryWriter ## T W(MnW mem) { \ @@ -233,13 +233,13 @@ inline static U DownCast(T in) { #define MAKE_ACCESSORS(T, size) \ struct MemoryWriter ## T { \ ALWAYS_INLINE void operator=(T val) const { \ - __mcsema_memory_order = __mcsema_write_memory_ ## size ( \ - __mcsema_memory_order, addr, val);\ + __remill_memory_order = __remill_write_memory_ ## size ( \ + __remill_memory_order, addr, val);\ } \ addr_t addr; \ }; \ ALWAYS_INLINE static T R(Mn mem) { \ - return __mcsema_read_memory_ ## size (__mcsema_memory_order, mem.addr); \ + return __remill_read_memory_ ## size (__remill_memory_order, mem.addr); \ } \ ALWAYS_INLINE static MemoryWriter ## T W(MnW mem) { \ return MemoryWriter ## T {mem.addr}; \ @@ -259,19 +259,19 @@ inline static U DownCast(T in) { return imm; \ } \ ALWAYS_INLINE static T U(RnW) { \ - return __mcsema_undefined_ ## size (); \ + return __remill_undefined_ ## size (); \ } \ ALWAYS_INLINE static T U(MnW) { \ - return __mcsema_undefined_ ## size (); \ + return __remill_undefined_ ## size (); \ } \ ALWAYS_INLINE static T U(Rn) { \ - return __mcsema_undefined_ ## size (); \ + return __remill_undefined_ ## size (); \ } \ ALWAYS_INLINE static T U(Mn) { \ - return __mcsema_undefined_ ## size (); \ + return __remill_undefined_ ## size (); \ } \ ALWAYS_INLINE static T U(In) { \ - return __mcsema_undefined_ ## size (); \ + return __remill_undefined_ ## size (); \ } MAKE_ACCESSORS(uint8_t, 8) @@ -283,15 +283,15 @@ MAKE_ACCESSORS(uint64_t, 64) #define MAKE_FLOAT_ACCESSORS(T, base_type, acc, size) \ struct MemoryWriter ## T { \ ALWAYS_INLINE void operator=(const T &val) const { \ - __mcsema_memory_order = __mcsema_write_memory_f ## size ( \ - __mcsema_memory_order, addr, val);\ + __remill_memory_order = __remill_write_memory_f ## size ( \ + __remill_memory_order, addr, val);\ } \ addr_t addr; \ }; \ ALWAYS_INLINE static T R(Mn mem) { \ T val; \ - __mcsema_memory_order = __mcsema_read_memory_f ## size ( \ - __mcsema_memory_order, mem.addr, val); \ + __remill_memory_order = __remill_read_memory_f ## size ( \ + __remill_memory_order, mem.addr, val); \ return val; \ } \ ALWAYS_INLINE static MemoryWriter ## T W(MnW mem) { \ @@ -337,4 +337,4 @@ MAKE_FLOAT_ACCESSORS(float64_t, double, doubles, 64) } // namespace -#endif // MCSEMA_ARCH_RUNTIME_OPERATORS_H_ +#endif // REMILL_ARCH_RUNTIME_OPERATORS_H_ diff --git a/remill/Arch/Runtime/Runtime.h b/remill/Arch/Runtime/Runtime.h new file mode 100644 index 00000000..a15d4aac --- /dev/null +++ b/remill/Arch/Runtime/Runtime.h @@ -0,0 +1,15 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef REMILL_ARCH_RUNTIME_RUNTIME_H_ +#define REMILL_ARCH_RUNTIME_RUNTIME_H_ + +#ifndef ADDRESS_SIZE_BITS +# define ADDRESS_SIZE_BITS 64 +#endif + +#include "remill/Arch/Runtime/Intrinsics.h" +#include "remill/Arch/Runtime/Operators.h" +#include "remill/Arch/Runtime/Types.h" +#include "remill/Arch/Runtime/Util.h" + +#endif // REMILL_ARCH_RUNTIME_RUNTIME_H_ diff --git a/mcsema/Arch/Runtime/Types.cpp b/remill/Arch/Runtime/Types.cpp similarity index 92% rename from mcsema/Arch/Runtime/Types.cpp rename to remill/Arch/Runtime/Types.cpp index 2509f3d6..5b175bb2 100644 --- a/mcsema/Arch/Runtime/Types.cpp +++ b/remill/Arch/Runtime/Types.cpp @@ -1,9 +1,9 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_RUNTIME_TYPES_CPP_ -#define MCSEMA_ARCH_RUNTIME_TYPES_CPP_ +#ifndef REMILL_ARCH_RUNTIME_TYPES_CPP_ +#define REMILL_ARCH_RUNTIME_TYPES_CPP_ -#include "mcsema/Arch/Runtime/Intrinsics.h" +#include "remill/Arch/Runtime/Intrinsics.h" vec8_t::vec8_t(void) : iwords{0} {} @@ -133,7 +133,7 @@ vec512_t::vec512_t(vec256_t sub_vec) } float32_t::float32_t(void) { - *this = __mcsema_undefined_f32(); + *this = __remill_undefined_f32(); } float32_t::float32_t(float val_) @@ -179,7 +179,7 @@ float32_t::operator float(void) const { } float64_t::float64_t(void) { - *this = __mcsema_undefined_f64(); + *this = __remill_undefined_f64(); } float64_t::float64_t(double val_) @@ -237,21 +237,21 @@ float80_t::float80_t(void) fraction(0) {} float80_t::float80_t(float64_t new_val) { - __mcsema_write_f80(new_val, *this); + __remill_write_f80(new_val, *this); } float80_t::float80_t(float32_t new_val) : float80_t(float64_t(new_val)) {} float80_t &float80_t::operator=(float64_t new_val) { - __mcsema_write_f80(new_val, *this); + __remill_write_f80(new_val, *this); return *this; } float80_t &float80_t::operator=(float32_t new_val_) { float64_t new_val = new_val_; - __mcsema_write_f80(new_val, *this); + __remill_write_f80(new_val, *this); return *this; } -#endif // MCSEMA_ARCH_RUNTIME_TYPES_CPP_ +#endif // REMILL_ARCH_RUNTIME_TYPES_CPP_ diff --git a/mcsema/Arch/Runtime/Types.h b/remill/Arch/Runtime/Types.h similarity index 99% rename from mcsema/Arch/Runtime/Types.h rename to remill/Arch/Runtime/Types.h index a316cdb0..3c590bca 100644 --- a/mcsema/Arch/Runtime/Types.h +++ b/remill/Arch/Runtime/Types.h @@ -1,9 +1,9 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_RUNTIME_TYPES_H_ -#define MCSEMA_ARCH_RUNTIME_TYPES_H_ +#ifndef REMILL_ARCH_RUNTIME_TYPES_H_ +#define REMILL_ARCH_RUNTIME_TYPES_H_ -#include "mcsema/Arch/Runtime/Util.h" +#include "remill/Arch/Runtime/Util.h" #include #include @@ -671,4 +671,4 @@ inline int32_t operator "" _s32(unsigned long long value) { inline int64_t operator "" _s64(unsigned long long value) { return static_cast(value); } -#endif // MCSEMA_ARCH_RUNTIME_TYPES_H_ +#endif // REMILL_ARCH_RUNTIME_TYPES_H_ diff --git a/mcsema/Arch/Runtime/Util.h b/remill/Arch/Runtime/Util.h similarity index 98% rename from mcsema/Arch/Runtime/Util.h rename to remill/Arch/Runtime/Util.h index 7e7d50a9..b525f816 100644 --- a/mcsema/Arch/Runtime/Util.h +++ b/remill/Arch/Runtime/Util.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_RUNTIME_UTIL_H_ -#define MCSEMA_ARCH_RUNTIME_UTIL_H_ +#ifndef REMILL_ARCH_RUNTIME_UTIL_H_ +#define REMILL_ARCH_RUNTIME_UTIL_H_ #if 64 == ADDRESS_SIZE_BITS # define IF_32BIT(...) @@ -207,4 +207,4 @@ #define DEF_ISEL_RnW_Rn_Rn_Rn(name, tpl_func) \ _DEF_ISEL_XnW_Xn_Yn_Zn(R, R, R, name, tpl_func) -#endif // MCSEMA_ARCH_RUNTIME_UTIL_H_ +#endif // REMILL_ARCH_RUNTIME_UTIL_H_ diff --git a/mcsema/Arch/X86/Arch.cpp b/remill/Arch/X86/Arch.cpp similarity index 90% rename from mcsema/Arch/X86/Arch.cpp rename to remill/Arch/X86/Arch.cpp index 8fbe7bf0..b4b42752 100644 --- a/mcsema/Arch/X86/Arch.cpp +++ b/remill/Arch/X86/Arch.cpp @@ -6,13 +6,13 @@ #include -#include "mcsema/Arch/X86/Arch.h" -#include "mcsema/Arch/X86/Decode.h" -#include "mcsema/Arch/X86/Translator.h" -#include "mcsema/BC/Translator.h" -#include "mcsema/CFG/CFG.h" +#include "remill/Arch/X86/Arch.h" +#include "remill/Arch/X86/Decode.h" +#include "remill/Arch/X86/Translator.h" +#include "remill/BC/Translator.h" +#include "remill/CFG/CFG.h" -namespace mcsema { +namespace remill { namespace x86 { X86Arch::X86Arch(OSName os_name_, ArchName arch_name_, unsigned address_size_) @@ -70,5 +70,5 @@ AutoAnalysis &X86Arch::CFGAnalyzer(void) const { } } // namespace x86 -} // namespace mcsema +} // namespace remill diff --git a/mcsema/Arch/X86/Arch.h b/remill/Arch/X86/Arch.h similarity index 79% rename from mcsema/Arch/X86/Arch.h rename to remill/Arch/X86/Arch.h index f0719c6a..be5992f7 100644 --- a/mcsema/Arch/X86/Arch.h +++ b/remill/Arch/X86/Arch.h @@ -1,12 +1,12 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_ARCH_H_ -#define MCSEMA_ARCH_X86_ARCH_H_ +#ifndef REMILL_ARCH_X86_ARCH_H_ +#define REMILL_ARCH_X86_ARCH_H_ -#include "mcsema/Arch/Arch.h" -#include "mcsema/Arch/X86/AutoAnalysis.h" +#include "remill/Arch/Arch.h" +#include "remill/Arch/X86/AutoAnalysis.h" -namespace mcsema { +namespace remill { namespace x86 { class X86Arch : public Arch { @@ -37,6 +37,6 @@ class X86Arch : public Arch { }; } // namespace x86 -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_ARCH_X86_ARCH_H_ +#endif // REMILL_ARCH_X86_ARCH_H_ diff --git a/mcsema/Arch/X86/AutoAnalysis.h b/remill/Arch/X86/AutoAnalysis.h similarity index 88% rename from mcsema/Arch/X86/AutoAnalysis.h rename to remill/Arch/X86/AutoAnalysis.h index bdf5e0af..b17c1572 100644 --- a/mcsema/Arch/X86/AutoAnalysis.h +++ b/remill/Arch/X86/AutoAnalysis.h @@ -1,14 +1,14 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_AUTOANALYSIS_H_ -#define MCSEMA_ARCH_X86_AUTOANALYSIS_H_ +#ifndef REMILL_ARCH_X86_AUTOANALYSIS_H_ +#define REMILL_ARCH_X86_AUTOANALYSIS_H_ #include #include -#include "mcsema/CFG/AutoAnalysis.h" +#include "remill/CFG/AutoAnalysis.h" -namespace mcsema { +namespace remill { enum ArchName : unsigned; @@ -54,6 +54,6 @@ class RegisterAnalysis : public AutoAnalysis { }; } // namespace x86 -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_ARCH_X86_AUTOANALYSIS_H_ +#endif // REMILL_ARCH_X86_AUTOANALYSIS_H_ diff --git a/mcsema/Arch/X86/Decode.cpp b/remill/Arch/X86/Decode.cpp similarity index 91% rename from mcsema/Arch/X86/Decode.cpp rename to remill/Arch/X86/Decode.cpp index 7a017bb3..ded52bd1 100644 --- a/mcsema/Arch/X86/Decode.cpp +++ b/remill/Arch/X86/Decode.cpp @@ -2,11 +2,11 @@ #include -#include "mcsema/Arch/X86/Arch.h" -#include "mcsema/Arch/X86/Decode.h" -#include "mcsema/CFG/CFG.h" +#include "remill/Arch/X86/Arch.h" +#include "remill/Arch/X86/Decode.h" +#include "remill/CFG/CFG.h" -namespace mcsema { +namespace remill { namespace x86 { namespace { @@ -55,4 +55,4 @@ xed_decoded_inst_t DecodeInstruction(const cfg::Instr &instr, } } // namespace x86 -} // namespace mcsema +} // namespace remill diff --git a/mcsema/Arch/X86/Decode.h b/remill/Arch/X86/Decode.h similarity index 61% rename from mcsema/Arch/X86/Decode.h rename to remill/Arch/X86/Decode.h index 4b7d5cdc..251b212f 100644 --- a/mcsema/Arch/X86/Decode.h +++ b/remill/Arch/X86/Decode.h @@ -1,11 +1,11 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_DECODE_H_ -#define MCSEMA_ARCH_X86_DECODE_H_ +#ifndef REMILL_ARCH_X86_DECODE_H_ +#define REMILL_ARCH_X86_DECODE_H_ -#include "mcsema/Arch/X86/XED.h" +#include "remill/Arch/X86/XED.h" -namespace mcsema { +namespace remill { namespace cfg { class Instr; } // namespace @@ -18,6 +18,6 @@ xed_decoded_inst_t DecodeInstruction( const cfg::Instr &instr, ArchName arch_name); } // namespace x86 -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_ARCH_X86_DECODE_H_ +#endif // REMILL_ARCH_X86_DECODE_H_ diff --git a/mcsema/Arch/X86/RegisterAnalysis.cpp b/remill/Arch/X86/RegisterAnalysis.cpp similarity index 98% rename from mcsema/Arch/X86/RegisterAnalysis.cpp rename to remill/Arch/X86/RegisterAnalysis.cpp index b2941c38..d67dcbb1 100644 --- a/mcsema/Arch/X86/RegisterAnalysis.cpp +++ b/remill/Arch/X86/RegisterAnalysis.cpp @@ -3,13 +3,13 @@ #include #include -#include "mcsema/Arch/X86/Decode.h" -#include "mcsema/Arch/X86/RegisterAnalysis.h" -#include "mcsema/CFG/CFG.h" +#include "remill/Arch/X86/Decode.h" +#include "remill/Arch/X86/RegisterAnalysis.h" +#include "remill/CFG/CFG.h" DECLARE_bool(aggressive_dataflow_analysis); -namespace mcsema { +namespace remill { namespace x86 { struct Function { @@ -485,4 +485,4 @@ void BasicBlockRegs::UpdateEntryLive(const xed_decoded_inst_t *xedd) { } } // namespace x86 -} // namespace mcsema +} // namespace remill diff --git a/mcsema/Arch/X86/RegisterAnalysis.h b/remill/Arch/X86/RegisterAnalysis.h similarity index 85% rename from mcsema/Arch/X86/RegisterAnalysis.h rename to remill/Arch/X86/RegisterAnalysis.h index d4195d86..6dee0e4a 100644 --- a/mcsema/Arch/X86/RegisterAnalysis.h +++ b/remill/Arch/X86/RegisterAnalysis.h @@ -1,15 +1,15 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_REGISTERANALYSIS_H_ -#define MCSEMA_ARCH_X86_REGISTERANALYSIS_H_ +#ifndef REMILL_ARCH_X86_REGISTERANALYSIS_H_ +#define REMILL_ARCH_X86_REGISTERANALYSIS_H_ -// Note: This file is split away so that `mcsema/Arch/Arch.cpp` doesn't need +// Note: This file is split away so that `remill/Arch/Arch.cpp` doesn't need // to bring in all of XED. -#include "mcsema/Arch/X86/AutoAnalysis.h" -#include "mcsema/Arch/X86/XED.h" +#include "remill/Arch/X86/AutoAnalysis.h" +#include "remill/Arch/X86/XED.h" -namespace mcsema { +namespace remill { namespace x86 { // Flow type for function analysis. @@ -84,6 +84,6 @@ struct BasicBlockRegs { }; } // namespace x86 -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_ARCH_X86_REGISTERANALYSIS_H_ +#endif // REMILL_ARCH_X86_REGISTERANALYSIS_H_ diff --git a/mcsema/Arch/X86/Runtime/BasicBlock.cpp b/remill/Arch/X86/Runtime/BasicBlock.cpp similarity index 99% rename from mcsema/Arch/X86/Runtime/BasicBlock.cpp rename to remill/Arch/X86/Runtime/BasicBlock.cpp index 7d991cb5..c2b71639 100644 --- a/mcsema/Arch/X86/Runtime/BasicBlock.cpp +++ b/remill/Arch/X86/Runtime/BasicBlock.cpp @@ -1,13 +1,13 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#include "mcsema/Arch/X86/Runtime/State.h" +#include "remill/Arch/X86/Runtime/State.h" extern "C" { // Method that will implement a basic block. We will clone this method for // each basic block in the code being lifted. [[gnu::used]] -void __mcsema_basic_block(State &state, addr_t curr_pc) { +void __remill_basic_block(State &state, addr_t curr_pc) { // Define read- and write-specific aliases of each register. We will // reference these variables from the bitcode side of things so that, @@ -498,4 +498,4 @@ void __mcsema_basic_block(State &state, addr_t curr_pc) { } // extern C -#include "mcsema/Arch/Runtime/Intrinsics.cpp" +#include "remill/Arch/Runtime/Intrinsics.cpp" diff --git a/remill/Arch/X86/Runtime/Instructions.cpp b/remill/Arch/X86/Runtime/Instructions.cpp new file mode 100644 index 00000000..88e72e58 --- /dev/null +++ b/remill/Arch/X86/Runtime/Instructions.cpp @@ -0,0 +1,30 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#include "remill/Arch/Runtime/Types.cpp" + +#include "remill/Arch/X86/Runtime/State.h" +#include "remill/Arch/X86/Runtime/Types.h" + +// Define the `PushValue` and `PopValue` helpers. +#include "remill/Arch/X86/Semantics/POP.h" +#include "remill/Arch/X86/Semantics/PUSH.h" + +#include "remill/Arch/X86/Semantics/FLAGS.h" +#include "remill/Arch/X86/Semantics/BINARY.h" +#include "remill/Arch/X86/Semantics/BITBYTE.h" +#include "remill/Arch/X86/Semantics/CALL_RET.h" +#include "remill/Arch/X86/Semantics/CMOV.h" +#include "remill/Arch/X86/Semantics/COND_BR.h" +#include "remill/Arch/X86/Semantics/CONVERT.h" +#include "remill/Arch/X86/Semantics/DATAXFER.h" +#include "remill/Arch/X86/Semantics/INTERRUPT.h" +#include "remill/Arch/X86/Semantics/FMA.h" +#include "remill/Arch/X86/Semantics/LOGICAL.h" +#include "remill/Arch/X86/Semantics/MISC.h" +#include "remill/Arch/X86/Semantics/ROTATE.h" +#include "remill/Arch/X86/Semantics/SHIFT.h" +#include "remill/Arch/X86/Semantics/SSE.h" +#include "remill/Arch/X86/Semantics/STRINGOP.h" +#include "remill/Arch/X86/Semantics/UNCOND_BR.h" +#include "remill/Arch/X86/Semantics/XOP.h" +#include "remill/Arch/X86/Semantics/X87.h" diff --git a/mcsema/Arch/X86/Runtime/State.h b/remill/Arch/X86/Runtime/State.h similarity index 98% rename from mcsema/Arch/X86/Runtime/State.h rename to remill/Arch/X86/Runtime/State.h index 69d16e46..65f2e807 100644 --- a/mcsema/Arch/X86/Runtime/State.h +++ b/remill/Arch/X86/Runtime/State.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_RUNTIME_STATE_H_ -#define MCSEMA_ARCH_X86_RUNTIME_STATE_H_ +#ifndef REMILL_ARCH_X86_RUNTIME_STATE_H_ +#define REMILL_ARCH_X86_RUNTIME_STATE_H_ // !!! RULES FOR STATE STRUCTURE TYPES !!! // @@ -18,7 +18,7 @@ // to bitcode for one architecture, then change its `DataLayout` to // match another architecture. -#include "mcsema/Arch/Runtime/Runtime.h" +#include "remill/Arch/Runtime/Runtime.h" #ifndef HAS_FEATURE_AVX # define HAS_FEATURE_AVX 1 @@ -288,7 +288,7 @@ static_assert(0 == __builtin_offsetof(VectorReg, zmm), // Named the same way as the 64-bit version to keep names the same // across architectures. All registers are here, even the 64-bit ones. The // 64-bit ones are inaccessible in lifted 32-bit code because they will -// not be referenced by named variables in the `__mcsema_basic_block` +// not be referenced by named variables in the `__remill_basic_block` // function. struct alignas(16) GPR final { // Prevents LLVM from casting a `GPR` into an `i64` to access `rax`. @@ -411,4 +411,4 @@ static_assert(3136 == __builtin_offsetof(State, interrupt_vector), static_assert(3200 == sizeof(State), "Invalid packing of `State`."); -#endif // MCSEMA_ARCH_X86_RUNTIME_STATE_H_ +#endif // REMILL_ARCH_X86_RUNTIME_STATE_H_ diff --git a/mcsema/Arch/X86/Runtime/Types.h b/remill/Arch/X86/Runtime/Types.h similarity index 88% rename from mcsema/Arch/X86/Runtime/Types.h rename to remill/Arch/X86/Runtime/Types.h index db0d002f..e7243a34 100644 --- a/mcsema/Arch/X86/Runtime/Types.h +++ b/remill/Arch/X86/Runtime/Types.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_RUNTIME_TYPES_H_ -#define MCSEMA_ARCH_X86_RUNTIME_TYPES_H_ +#ifndef REMILL_ARCH_X86_RUNTIME_TYPES_H_ +#define REMILL_ARCH_X86_RUNTIME_TYPES_H_ typedef RnW R8W; typedef RnW R16W; @@ -96,17 +96,17 @@ typedef RnW RF80W; struct MemoryWriterfloat80_t { ALWAYS_INLINE void operator=(const float32_t &val_) const { float80_t val = val_; - __mcsema_memory_order = __mcsema_write_memory_f80(__mcsema_memory_order, + __remill_memory_order = __remill_write_memory_f80(__remill_memory_order, addr, val); } ALWAYS_INLINE void operator=(const float64_t &val_) const { float80_t val = val_; - __mcsema_memory_order = __mcsema_write_memory_f80(__mcsema_memory_order, + __remill_memory_order = __remill_write_memory_f80(__remill_memory_order, addr, val); } ALWAYS_INLINE void operator=(const float80_t &val) const { - __mcsema_memory_order = __mcsema_write_memory_f80(__mcsema_memory_order, + __remill_memory_order = __remill_write_memory_f80(__remill_memory_order, addr, val); } addr_t addr; @@ -114,10 +114,10 @@ struct MemoryWriterfloat80_t { ALWAYS_INLINE static float64_t R(MF80 mem) { float80_t val; - __mcsema_memory_order = __mcsema_read_memory_f80(__mcsema_memory_order, + __remill_memory_order = __remill_read_memory_f80(__remill_memory_order, mem.addr, val); float64_t out_val; - __mcsema_read_f80(val, out_val); + __remill_read_f80(val, out_val); return out_val; } @@ -126,4 +126,4 @@ ALWAYS_INLINE static MemoryWriterfloat80_t W(MF80W mem) { } -#endif // MCSEMA_ARCH_X86_RUNTIME_TYPES_H_ +#endif // REMILL_ARCH_X86_RUNTIME_TYPES_H_ diff --git a/mcsema/Arch/X86/Semantics/BINARY.h b/remill/Arch/X86/Semantics/BINARY.h similarity index 96% rename from mcsema/Arch/X86/Semantics/BINARY.h rename to remill/Arch/X86/Semantics/BINARY.h index c9ff68d0..bc77cc63 100644 --- a/mcsema/Arch/X86/Semantics/BINARY.h +++ b/remill/Arch/X86/Semantics/BINARY.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_BINARY_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_BINARY_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_BINARY_H_ +#define REMILL_ARCH_X86_SEMANTICS_BINARY_H_ namespace { @@ -27,7 +27,7 @@ DEF_SEM(ADD, D dst, const S1 src1_, const S2 src2_) { const T src2 = R(src2_); const T res = src1 + src2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsAddSub(state, src1, src2, res); } @@ -56,16 +56,16 @@ DEF_SEM(XADD, MW mdst, const M msrc_, const RW rdst, const RT rsrc_) { // but this instruction is a full memory barrier, even when registers are // accessed. if (IsRegister::kValue) { - __mcsema_memory_order = __mcsema_barrier_store_load(__mcsema_memory_order); + __remill_memory_order = __remill_barrier_store_load(__remill_memory_order); } const T src1 = R(msrc_); const T src2 = R(rsrc_); const T res = src1 + src2; W(mdst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); W(rdst) = src1; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsAddSub(state, src1, src2, res); } @@ -128,7 +128,7 @@ DEF_SEM(SUB, D dst, const S1 src1_, const S2 src2_) { const T src2 = R(src2_); const T res = src1 - src2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsAddSub(state, src1, src2, res); } @@ -201,7 +201,7 @@ DEF_SEM(CMP, const S1 src1_, const S2 src2_) { const T src1 = R(src1_); const T src2 = R(src2_); const T res = src1 - src2; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsAddSub(state, src1, src2, res); } @@ -233,12 +233,12 @@ ALWAYS_INLINE void SetFlagsMul(State &state, T lhs, T rhs, U res, V res_trunc) { const auto new_of = Overflow::Flag(lhs, rhs, res); state.aflag.cf = new_of; - state.aflag.pf = __mcsema_undefined_bool(); - state.aflag.af = __mcsema_undefined_bool(); - state.aflag.zf = __mcsema_undefined_bool(); + state.aflag.pf = __remill_undefined_bool(); + state.aflag.af = __remill_undefined_bool(); + state.aflag.zf = __remill_undefined_bool(); state.aflag.sf = std::is_signed::value ? SignFlag(res_trunc) : - __mcsema_undefined_bool(); + __remill_undefined_bool(); state.aflag.of = new_of; } @@ -267,7 +267,7 @@ struct DivMul { const auto res_trunc = static_cast(res); W(dst) = static_cast(res_trunc); - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsMul(state, src1, src2, res, res_trunc); } @@ -304,7 +304,7 @@ struct DivMul { const auto res_trunc = static_cast(res); W(state.gpr.rax.word) = static_cast(res); - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsMul(state, src1, src2, res, res_trunc); } @@ -326,7 +326,7 @@ struct DivMul { \ W(state.gpr.rax.write_sel) = static_cast(res_trunc); \ W(state.gpr.rdx.write_sel) = static_cast(static_cast(res) >> size); \ - __mcsema_barrier_compiler(); \ + __remill_barrier_compiler(); \ SetFlagsMul(state, src1, src2, res, res_trunc); \ } @@ -352,7 +352,7 @@ IF_64BIT(MAKE_MULTIPLIER(64, qword, qword)) const CWT quot = src1 / src2; if (quot != static_cast(quot)) { - __mcsema_error(state, R(state.gpr.rip)); + __remill_error(state, R(state.gpr.rip)); __builtin_unreachable(); } @@ -381,7 +381,7 @@ IF_64BIT(MAKE_MULTIPLIER(64, qword, qword)) const CWT quot = src1 / src2; \ \ if (quot != static_cast(quot)) { \ - __mcsema_error(state, R(state.gpr.rip)); \ + __remill_error(state, R(state.gpr.rip)); \ __builtin_unreachable(); \ } \ \ @@ -552,7 +552,7 @@ DEF_SEM(INC, D dst, const S1 src) { const T val2 = 1; const T res = val1 + val2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsIncDec(state, val1, val2, res); } @@ -563,7 +563,7 @@ DEF_SEM(DEC, D dst, const S1 src) { const T val2 = 1; const T res = val1 - val2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsIncDec(state, val1, val2, res); } @@ -574,7 +574,7 @@ DEF_SEM(NEG, D dst, const S1 src) { const auto val = R(src); const auto res = static_cast(-static_cast(val)); W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = NotZeroFlag(val); SetFlagsIncDec(state, 0, val, res); } @@ -604,7 +604,7 @@ template NEVER_INLINE static bool CarryFlag(T a, T b, T ab, T c, T abc) { static_assert(std::is_unsigned::value, "Invalid specialization of `CarryFlag` for addition."); - __mcsema_defer_inlining(); + __remill_defer_inlining(); return Carry::Flag(a, b, ab) || Carry::Flag(ab, c, abc); } @@ -617,7 +617,7 @@ DEF_SEM(ADC, D dst, const S1 src1_, const S2 src2_) { const T res_add = src1 + src2; const T res = res_add + carry; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = CarryFlag(src1, src2, res_add, carry, res); SetFlagsIncDec(state, src1, src2, res); } @@ -631,7 +631,7 @@ DEF_SEM(SBB, D dst, const S1 src1_, const S2 src2_) { const T res_sub = src1 - src2; const T res = res_sub - borrow; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = CarryFlag(src1, src2, res_sub, borrow, res); SetFlagsIncDec(state, src1, src2, res); } @@ -676,4 +676,4 @@ DEF_ISEL_RnW_Rn_Rn(ADC_GPRv_GPRv_13, ADC); DEF_ISEL(ADC_AL_IMMb) = ADC; DEF_ISEL_RnW_Rn_In(ADC_OrAX_IMMz, ADC); -#endif // MCSEMA_ARCH_X86_SEMANTICS_BINARY_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_BINARY_H_ diff --git a/mcsema/Arch/X86/Semantics/BITBYTE.h b/remill/Arch/X86/Semantics/BITBYTE.h similarity index 97% rename from mcsema/Arch/X86/Semantics/BITBYTE.h rename to remill/Arch/X86/Semantics/BITBYTE.h index 1264d445..bbb733e4 100644 --- a/mcsema/Arch/X86/Semantics/BITBYTE.h +++ b/remill/Arch/X86/Semantics/BITBYTE.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_BITBYTE_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_BITBYTE_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_BITBYTE_H_ +#define REMILL_ARCH_X86_SEMANTICS_BITBYTE_H_ namespace { @@ -272,11 +272,11 @@ DEF_SEM(BTCmem, S1, S2 src_dst_mem, S3 bit_) { if (T(0) != (mem & mask)) { W(dst_mem) = mem & ~mask; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = true; } else { W(dst_mem) = mem | mask; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = false; } } @@ -303,4 +303,4 @@ DEF_ISEL_RnW_Rn_In(BTC_GPRv_IMMb, BTCreg); DEF_ISEL_MnW_Mn_Rn(BTC_MEMv_GPRv, BTCmem); DEF_ISEL_RnW_Rn_Rn(BTC_GPRv_GPRv, BTCreg); -#endif // MCSEMA_ARCH_X86_SEMANTICS_BITBYTE_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_BITBYTE_H_ diff --git a/mcsema/Arch/X86/Semantics/CALL_RET.h b/remill/Arch/X86/Semantics/CALL_RET.h similarity index 87% rename from mcsema/Arch/X86/Semantics/CALL_RET.h rename to remill/Arch/X86/Semantics/CALL_RET.h index 4468af27..54860ae5 100644 --- a/mcsema/Arch/X86/Semantics/CALL_RET.h +++ b/remill/Arch/X86/Semantics/CALL_RET.h @@ -1,15 +1,15 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_CALL_RET_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_CALL_RET_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_CALL_RET_H_ +#define REMILL_ARCH_X86_SEMANTICS_CALL_RET_H_ namespace { template DEF_SEM(CALL, T target_pc) { auto target = R(target_pc); - __mcsema_barrier_compiler(); - PushValue(state, __mcsema_create_program_counter(next_pc)); + __remill_barrier_compiler(); + PushValue(state, __remill_create_program_counter(next_pc)); W(state.gpr.rip) = target; } @@ -54,7 +54,7 @@ DEF_ISEL_32or64(RET_NEAR, RET); */ DEF_ISEL_SEM(IRETD_32) { - W(state.gpr.rip) = __mcsema_create_program_counter(PopValue(state)); + W(state.gpr.rip) = __remill_create_program_counter(PopValue(state)); W(state.seg.cs) = static_cast(PopValue(state)); Flags flags; @@ -72,7 +72,7 @@ DEF_ISEL_SEM(IRETD_32) { #if 64 == ADDRESS_SIZE_BITS DEF_ISEL_SEM(IRETQ_64) { - W(state.gpr.rip) = __mcsema_create_program_counter(PopValue(state)); + W(state.gpr.rip) = __remill_create_program_counter(PopValue(state)); W(state.seg.cs) = static_cast(PopValue(state)); Flags flags; @@ -89,4 +89,4 @@ DEF_ISEL_SEM(IRETQ_64) { } #endif // 64 == ADDRESS_SIZE_BITS -#endif // MCSEMA_ARCH_X86_SEMANTICS_CALL_RET_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_CALL_RET_H_ diff --git a/mcsema/Arch/X86/Semantics/CMOV.h b/remill/Arch/X86/Semantics/CMOV.h similarity index 97% rename from mcsema/Arch/X86/Semantics/CMOV.h rename to remill/Arch/X86/Semantics/CMOV.h index dfc69dc2..da572ca6 100644 --- a/mcsema/Arch/X86/Semantics/CMOV.h +++ b/remill/Arch/X86/Semantics/CMOV.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_CMOV_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_CMOV_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_CMOV_H_ +#define REMILL_ARCH_X86_SEMANTICS_CMOV_H_ namespace { @@ -152,4 +152,4 @@ DEF_ISEL(FCMOVU_ST0_X87_80) = CMOVP; DEF_ISEL(FCMOVE_ST0_X87_80) = CMOVZ; DEF_ISEL(FCMOVB_ST0_X87_80) = CMOVB; -#endif // MCSEMA_ARCH_X86_SEMANTICS_CMOV_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_CMOV_H_ diff --git a/mcsema/Arch/X86/Semantics/COND_BR.h b/remill/Arch/X86/Semantics/COND_BR.h similarity index 79% rename from mcsema/Arch/X86/Semantics/COND_BR.h rename to remill/Arch/X86/Semantics/COND_BR.h index ac14a763..38f8ce93 100644 --- a/mcsema/Arch/X86/Semantics/COND_BR.h +++ b/remill/Arch/X86/Semantics/COND_BR.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_COND_BR_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_COND_BR_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_COND_BR_H_ +#define REMILL_ARCH_X86_SEMANTICS_COND_BR_H_ namespace { @@ -15,89 +15,89 @@ namespace { // XOR operations might make things harder rather than easier). // // TODO(pag): - Add in an conditional branch intrinsic, e.g. -// W(state.gpr.rip) = __mcsema_conditional_branch(a, b, c); +// W(state.gpr.rip) = __remill_conditional_branch(a, b, c); // The goal here would be to informa a concolic/symbolic executor // about the difference between a conditional branch within the // lifted program and the program itself. DEF_SEM(JNLE, PC target_pc) { const auto cond = !state.aflag.zf && state.aflag.sf == state.aflag.of; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNS, PC target_pc) { const auto cond = !state.aflag.sf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JL, PC target_pc) { const auto cond = state.aflag.sf != state.aflag.of; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNP, PC target_pc) { const auto cond = !state.aflag.pf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNZ, PC target_pc) { const auto cond = !state.aflag.zf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNB, PC target_pc) { const auto cond = !state.aflag.cf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNO, PC target_pc) { const auto cond = !state.aflag.of; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNL, PC target_pc) { const auto cond = state.aflag.sf == state.aflag.of; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JNBE, PC target_pc) { const auto cond = !state.aflag.cf && !state.aflag.zf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JBE, PC target_pc) { const auto cond = state.aflag.cf || state.aflag.zf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JZ, PC target_pc) { const auto cond = state.aflag.zf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JP, PC target_pc) { const auto cond = state.aflag.pf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JS, PC target_pc) { const auto cond = state.aflag.sf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JO, PC target_pc) { const auto cond = state.aflag.of; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JB, PC target_pc) { const auto cond = state.aflag.cf; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_SEM(JLE, PC target_pc) { const auto cond = state.aflag.zf || (state.aflag.sf != state.aflag.of); - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } } // namespace @@ -216,38 +216,38 @@ DEF_ISEL(JLE_RELBRd) = JLE; DEF_ISEL_SEM(JCXZ_RELBRb, PC target_pc) { const auto cond = !state.gpr.rcx.word; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_ISEL_SEM(JECXZ_RELBRb, PC target_pc) { const auto cond = !state.gpr.rcx.dword; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_ISEL_SEM(JRCXZ_RELBRb, PC target_pc) { const auto cond = !R(state.gpr.rcx); - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_ISEL_SEM(LOOP_RELBRb, PC target_pc) { const auto count = R(state.gpr.rcx) - 1; const auto cond = 0 != count; W(state.gpr.rcx) = count; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_ISEL_SEM(LOOPE_RELBRb, PC target_pc) { const auto count = R(state.gpr.rcx) - 1; const auto cond = 0 != count && state.aflag.zf; W(state.gpr.rcx) = count; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } DEF_ISEL_SEM(LOOPNE_RELBRb, PC target_pc) { const auto count = R(state.gpr.rcx) - 1; const auto cond = 0 != count && !state.aflag.zf; W(state.gpr.rcx) = count; - W(state.gpr.rip) = __mcsema_conditional_branch(cond, target_pc, next_pc); + W(state.gpr.rip) = __remill_conditional_branch(cond, target_pc, next_pc); } /* @@ -256,4 +256,4 @@ DEF_ISEL_SEM(LOOPNE_RELBRb, PC target_pc) { 1465 XBEGIN XBEGIN_RELBRz COND_BR RTM RTM ATTRIBUTES: SCALABLE */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_COND_BR_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_COND_BR_H_ diff --git a/mcsema/Arch/X86/Semantics/CONVERT.h b/remill/Arch/X86/Semantics/CONVERT.h similarity index 99% rename from mcsema/Arch/X86/Semantics/CONVERT.h rename to remill/Arch/X86/Semantics/CONVERT.h index 8ea05024..7eeebc30 100644 --- a/mcsema/Arch/X86/Semantics/CONVERT.h +++ b/remill/Arch/X86/Semantics/CONVERT.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_CONVERT_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_CONVERT_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_CONVERT_H_ +#define REMILL_ARCH_X86_SEMANTICS_CONVERT_H_ DEF_ISEL_SEM(CBW) { W(state.gpr.rax.word) = static_cast(static_cast( @@ -456,4 +456,4 @@ DEF_ISEL_SEM(CQO) { 6402 VCVTPS2PD VCVTPS2PD_YMMf64_MASKmskw_MEMf32_AVX512 CONVERT AVX512EVEX AVX512F_256 ATTRIBUTES: BROADCAST_ENABLED DISP8_HALF MASKOP_EVEX MEMORY_FAULT_SUPPRESSION MXCSR */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_CONVERT_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_CONVERT_H_ diff --git a/mcsema/Arch/X86/Semantics/DATAXFER.h b/remill/Arch/X86/Semantics/DATAXFER.h similarity index 99% rename from mcsema/Arch/X86/Semantics/DATAXFER.h rename to remill/Arch/X86/Semantics/DATAXFER.h index 09170513..5d9292a1 100644 --- a/mcsema/Arch/X86/Semantics/DATAXFER.h +++ b/remill/Arch/X86/Semantics/DATAXFER.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_DATAXFER_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_DATAXFER_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_DATAXFER_H_ +#define REMILL_ARCH_X86_SEMANTICS_DATAXFER_H_ namespace { @@ -800,4 +800,4 @@ IF_64BIT(DEF_ISEL(MOVSX_GPRv_GPR16_64) = MOVSX;) IF_64BIT(DEF_ISEL(MOVSXD_GPRv_MEMd_64) = MOVSX;) IF_64BIT(DEF_ISEL(MOVSXD_GPRv_GPR32_64) = MOVSX;) -#endif // MCSEMA_ARCH_X86_SEMANTICS_DATAXFER_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_DATAXFER_H_ diff --git a/mcsema/Arch/X86/Semantics/FLAGS.h b/remill/Arch/X86/Semantics/FLAGS.h similarity index 85% rename from mcsema/Arch/X86/Semantics/FLAGS.h rename to remill/Arch/X86/Semantics/FLAGS.h index e40dfbf1..970143d8 100644 --- a/mcsema/Arch/X86/Semantics/FLAGS.h +++ b/remill/Arch/X86/Semantics/FLAGS.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_FLAGS_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_FLAGS_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_FLAGS_H_ +#define REMILL_ARCH_X86_SEMANTICS_FLAGS_H_ namespace { @@ -16,7 +16,7 @@ enum : uint32_t { template [[gnu::const]] NEVER_INLINE static bool ZeroFlag(T res) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return T(0) == res; } @@ -24,7 +24,7 @@ NEVER_INLINE static bool ZeroFlag(T res) { template [[gnu::const]] NEVER_INLINE static bool NotZeroFlag(T res) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return T(0) != res; } @@ -33,7 +33,7 @@ template [[gnu::const]] NEVER_INLINE static bool SignFlag(T res) { typedef TO_SIGNED_INTEGER_TYPE(T) ST; - __mcsema_defer_inlining(); + __remill_defer_inlining(); return ST(0) > static_cast(res); } @@ -42,7 +42,7 @@ NEVER_INLINE static bool SignFlag(T res) { template [[gnu::const]] NEVER_INLINE static bool AuxCarryFlag(T lhs, T rhs, T res) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return ((res ^ lhs ^ rhs) & T(0x10)); } @@ -51,14 +51,14 @@ NEVER_INLINE static bool AuxCarryFlag(T lhs, T rhs, T res) { template [[gnu::const]] NEVER_INLINE static bool AuxCarryFlag(T lhs, T rhs, T carry, T res) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return ((res ^ lhs ^ carry ^ rhs) & T(0x10)); } // Tests whether there is an even number of bits in the low order byte. [[gnu::const]] NEVER_INLINE static bool ParityFlag(uint8_t r0) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); auto r1 = r0 >> 1_u8; auto r2 = r1 >> 1_u8; auto r3 = r2 >> 1_u8; @@ -98,7 +98,7 @@ struct Overflow { kSignShift = sizeof(T) * 8 - 1 }; - __mcsema_defer_inlining(); + __remill_defer_inlining(); const T sign_lhs = lhs >> kSignShift; const T sign_rhs = rhs >> kSignShift; const T sign_res = res >> kSignShift; @@ -119,7 +119,7 @@ struct Overflow { kSignShift = sizeof(T) * 8 - 1 }; - __mcsema_defer_inlining(); + __remill_defer_inlining(); const T sign_lhs = lhs >> kSignShift; const T sign_rhs = rhs >> kSignShift; const T sign_res = res >> kSignShift; @@ -139,7 +139,7 @@ struct Overflow { T, T, R res, typename std::enable_if::type=0) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return static_cast(static_cast(res)) != res; } @@ -152,7 +152,7 @@ struct Overflow { typename std::enable_if::value,int>::type=0) { typedef WIDEN_INTEGER_TYPE(T) WT; - __mcsema_defer_inlining(); + __remill_defer_inlining(); auto lhs_wide = static_cast(lhs); auto rhs_wide = static_cast(rhs); return Flag(lhs, rhs, lhs_wide * rhs_wide); @@ -171,7 +171,7 @@ struct Carry { NEVER_INLINE static bool Flag(T lhs, T rhs, T res) { static_assert(std::is_unsigned::value, "Invalid specialization of `Carry::Flag` for addition."); - __mcsema_defer_inlining(); + __remill_defer_inlining(); return res < lhs || res < rhs; } }; @@ -184,7 +184,7 @@ struct Carry { NEVER_INLINE static bool Flag(T lhs, T rhs, T) { static_assert(std::is_unsigned::value, "Invalid specialization of `Carry::Flag` for addition."); - __mcsema_defer_inlining(); + __remill_defer_inlining(); return lhs < rhs; } }; @@ -192,12 +192,12 @@ struct Carry { } // namespace #define CLEAR_AFLAGS() \ - { __mcsema_barrier_compiler(); \ - state.aflag.cf = __mcsema_undefined_bool(); \ - state.aflag.pf = __mcsema_undefined_bool(); \ - state.aflag.af = __mcsema_undefined_bool(); \ - state.aflag.zf = __mcsema_undefined_bool(); \ - state.aflag.sf = __mcsema_undefined_bool(); \ - state.aflag.of = __mcsema_undefined_bool(); } + { __remill_barrier_compiler(); \ + state.aflag.cf = __remill_undefined_bool(); \ + state.aflag.pf = __remill_undefined_bool(); \ + state.aflag.af = __remill_undefined_bool(); \ + state.aflag.zf = __remill_undefined_bool(); \ + state.aflag.sf = __remill_undefined_bool(); \ + state.aflag.of = __remill_undefined_bool(); } -#endif // MCSEMA_ARCH_X86_SEMANTICS_FLAGS_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_FLAGS_H_ diff --git a/mcsema/Arch/X86/Semantics/FMA.h b/remill/Arch/X86/Semantics/FMA.h similarity index 99% rename from mcsema/Arch/X86/Semantics/FMA.h rename to remill/Arch/X86/Semantics/FMA.h index f50507dd..cd5c4e43 100644 --- a/mcsema/Arch/X86/Semantics/FMA.h +++ b/remill/Arch/X86/Semantics/FMA.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_FMA_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_FMA_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_FMA_H_ +#define REMILL_ARCH_X86_SEMANTICS_FMA_H_ /* 50 PFMAX PFMAX_MMXq_MEMq 3DNOW 3DNOW 3DNOW ATTRIBUTES: @@ -328,4 +328,4 @@ 3380 VFMSUB231PD VFMSUB231PD_YMMqq_YMMqq_YMMqq VFMA FMA FMA ATTRIBUTES: MXCSR */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_FMA_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_FMA_H_ diff --git a/mcsema/Arch/X86/Semantics/INTERRUPT.h b/remill/Arch/X86/Semantics/INTERRUPT.h similarity index 77% rename from mcsema/Arch/X86/Semantics/INTERRUPT.h rename to remill/Arch/X86/Semantics/INTERRUPT.h index c3e09090..2d5b383a 100644 --- a/mcsema/Arch/X86/Semantics/INTERRUPT.h +++ b/remill/Arch/X86/Semantics/INTERRUPT.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_INTERRUPT_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_INTERRUPT_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_INTERRUPT_H_ +#define REMILL_ARCH_X86_SEMANTICS_INTERRUPT_H_ namespace { @@ -13,7 +13,7 @@ DEF_SEM(BOUND, S1 idx_, S2 bounds) { const auto ub = R(S2{A(bounds) + sizeof(idx)}); if (idx < lb || ub < idx) { state.interrupt_vector = 5; - __mcsema_interrupt_call(state, next_pc); + __remill_interrupt_call(state, next_pc); } } #endif @@ -36,7 +36,7 @@ DEF_ISEL_SEM(INT3) { DEF_ISEL_SEM(INTO) { if (state.aflag.of) { state.interrupt_vector = 4; - __mcsema_interrupt_call(state, next_pc); + __remill_interrupt_call(state, next_pc); } } @@ -44,4 +44,4 @@ DEF_ISEL(BOUND_GPRv_MEMa16_16) = BOUND; DEF_ISEL(BOUND_GPRv_MEMa32_32) = BOUND; #endif // 32 == ADDRESS_SIZE_BITS -#endif // MCSEMA_ARCH_X86_SEMANTICS_INTERRUPT_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_INTERRUPT_H_ diff --git a/mcsema/Arch/X86/Semantics/LOGICAL.h b/remill/Arch/X86/Semantics/LOGICAL.h similarity index 97% rename from mcsema/Arch/X86/Semantics/LOGICAL.h rename to remill/Arch/X86/Semantics/LOGICAL.h index 42f3fb33..04486c78 100644 --- a/mcsema/Arch/X86/Semantics/LOGICAL.h +++ b/remill/Arch/X86/Semantics/LOGICAL.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_LOGICAL_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_LOGICAL_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_LOGICAL_H_ +#define REMILL_ARCH_X86_SEMANTICS_LOGICAL_H_ namespace { @@ -21,7 +21,7 @@ DEF_SEM(AND, D dst, S1 src1_, S2 src2_) { const T src2 = R(src2_); const T res = src1 & src2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsLogical(state, src1, src2, res); } @@ -32,7 +32,7 @@ DEF_SEM(OR, D dst, S1 src1_, S2 src2_) { const T src2 = R(src2_); const T res = src1 | src2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsLogical(state, src1, src2, res); } @@ -43,7 +43,7 @@ DEF_SEM(XOR, D dst, S1 src1_, S2 src2_) { const T src2 = R(src2_); const T res = src1 ^ src2; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); SetFlagsLogical(state, src1, src2, res); } @@ -183,7 +183,7 @@ DEF_SEM(PTEST, S1 src1_, S2 src2_) { const T src1 = R(src1_); const T src2 = R(src2_); - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); T zero; zero.iwords = {0U}; @@ -303,4 +303,4 @@ IF_AVX( DEF_ISEL(VPTEST_YMMqq_YMMqq) = PTEST; ) 1737 XTEST XTEST LOGICAL RTM RTM ATTRIBUTES: */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_LOGICAL_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_LOGICAL_H_ diff --git a/mcsema/Arch/X86/Semantics/MISC.h b/remill/Arch/X86/Semantics/MISC.h similarity index 89% rename from mcsema/Arch/X86/Semantics/MISC.h rename to remill/Arch/X86/Semantics/MISC.h index 6bf6ca4f..d32502bd 100644 --- a/mcsema/Arch/X86/Semantics/MISC.h +++ b/remill/Arch/X86/Semantics/MISC.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_MISC_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_MISC_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_MISC_H_ +#define REMILL_ARCH_X86_SEMANTICS_MISC_H_ namespace { @@ -57,7 +57,7 @@ DEF_SEM(ENTER, I16 alloc_size_, I8 nesting_level_) { MnW next_write = {next_rsp}; W(next_write) = R(next_read); - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); auto rbp_temp = R(state.gpr.rbp); PushValue(state, static_cast(rbp_temp)); @@ -92,15 +92,15 @@ DEF_ISEL_SEM(CLFLUSH_MEMmprefetch, M8) {} // http://g.oswego.edu/dl/jmm/cookbook.html DEF_ISEL_SEM(MFENCE) { - __mcsema_memory_order = __mcsema_barrier_store_load(__mcsema_memory_order); + __remill_memory_order = __remill_barrier_store_load(__remill_memory_order); } DEF_ISEL_SEM(SFENCE) { - __mcsema_memory_order = __mcsema_barrier_store_store(__mcsema_memory_order); + __remill_memory_order = __remill_barrier_store_store(__remill_memory_order); } DEF_ISEL_SEM(LFENCE) { - __mcsema_memory_order = __mcsema_barrier_load_load(__mcsema_memory_order); + __remill_memory_order = __remill_barrier_load_load(__remill_memory_order); } DEF_ISEL_SEM(XLAT) { @@ -110,7 +110,7 @@ DEF_ISEL_SEM(XLAT) { W(state.gpr.rax.byte.low) = R(val); } -// Implemented via the `__mcsema_read_cpu_features` intrinsic. +// Implemented via the `__remill_read_cpu_features` intrinsic. DEF_ISEL_SEM(CPUID) { W(state.gpr.rip) = R(next_pc); } @@ -122,4 +122,4 @@ DEF_ISEL_SEM(CPUID) { 1924 MWAIT MWAIT MISC SSE3 SSE3 ATTRIBUTES: NOTSX RING0 */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_MISC_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_MISC_H_ diff --git a/mcsema/Arch/X86/Semantics/POP.h b/remill/Arch/X86/Semantics/POP.h similarity index 96% rename from mcsema/Arch/X86/Semantics/POP.h rename to remill/Arch/X86/Semantics/POP.h index 3a62b847..2b7a071c 100644 --- a/mcsema/Arch/X86/Semantics/POP.h +++ b/remill/Arch/X86/Semantics/POP.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_POP_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_POP_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_POP_H_ +#define REMILL_ARCH_X86_SEMANTICS_POP_H_ namespace { @@ -117,4 +117,4 @@ DEF_ISEL_SEM(POPFQ) { 1396 POP POP_GS POP BASE I86 ATTRIBUTES: FIXED_BASE0 NOTSX SCALABLE STACKPOP0 */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_POP_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_POP_H_ diff --git a/mcsema/Arch/X86/Semantics/PUSH.h b/remill/Arch/X86/Semantics/PUSH.h similarity index 96% rename from mcsema/Arch/X86/Semantics/PUSH.h rename to remill/Arch/X86/Semantics/PUSH.h index 8064f770..8d8343a7 100644 --- a/mcsema/Arch/X86/Semantics/PUSH.h +++ b/remill/Arch/X86/Semantics/PUSH.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_PUSH_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_PUSH_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_PUSH_H_ +#define REMILL_ARCH_X86_SEMANTICS_PUSH_H_ namespace { @@ -126,5 +126,5 @@ DEF_ISEL_SEM(PUSHFQ) { */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_PUSH_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_PUSH_H_ diff --git a/mcsema/Arch/X86/Semantics/ROTATE.h b/remill/Arch/X86/Semantics/ROTATE.h similarity index 95% rename from mcsema/Arch/X86/Semantics/ROTATE.h rename to remill/Arch/X86/Semantics/ROTATE.h index c9919535..edc93196 100644 --- a/mcsema/Arch/X86/Semantics/ROTATE.h +++ b/remill/Arch/X86/Semantics/ROTATE.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_ROTATE_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_ROTATE_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_ROTATE_H_ +#define REMILL_ARCH_X86_SEMANTICS_ROTATE_H_ namespace { @@ -20,7 +20,7 @@ DEF_SEM(ROL, D dst, S1 src1, S2 src2) { if (temp_count) { new_val = (val << temp_count) | (val >> (kSize - temp_count)); W(dst) = new_val; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = new_val & 1; state.aflag.of = SignFlag(new_val) != state.aflag.cf; // OF undefined for `1 == temp_count`. @@ -44,7 +44,7 @@ DEF_SEM(ROR, D dst, S1 src1, S2 src2) { if (temp_count) { new_val = (val >> temp_count) | (val << (kSize - temp_count)); W(dst) = new_val; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = SignFlag(new_val); state.aflag.of = state.aflag.cf != SignFlag(new_val << 1); // OF undefined for `1 == temp_count`. @@ -123,7 +123,7 @@ DEF_SEM(RCL, D dst, S1 src1, S2 src2) { T(carry << T(temp_count - 1)) | T(right >> 1); W(dst) = new_val; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = SignFlag(val << (temp_count - 1)); state.aflag.of = SignFlag(new_val) != state.aflag.cf; // OF undefined for `1 == temp_count`. @@ -153,7 +153,7 @@ DEF_SEM(RCR, D dst, S1 src1, S2 src2) { (carry << (kSize - temp_count)) | (right << 1); W(dst) = new_val; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = left & 1; state.aflag.of = SignFlag(new_val) != SignFlag(new_val << 1); // OF undefined for `1 == temp_count`. @@ -190,4 +190,4 @@ DEF_ISEL(RCR_GPR8_CL) = RCR; DEF_ISEL_MnW_Mn_Rn(RCR_MEMv_CL, RCR); DEF_ISEL_RnW_Rn_Rn(RCR_GPRv_CL, RCR); -#endif // MCSEMA_ARCH_X86_SEMANTICS_ROTATE_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_ROTATE_H_ diff --git a/mcsema/Arch/X86/Semantics/SHIFT.h b/remill/Arch/X86/Semantics/SHIFT.h similarity index 91% rename from mcsema/Arch/X86/Semantics/SHIFT.h rename to remill/Arch/X86/Semantics/SHIFT.h index 9bdad03c..156de8b8 100644 --- a/mcsema/Arch/X86/Semantics/SHIFT.h +++ b/remill/Arch/X86/Semantics/SHIFT.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_SHIFT_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_SHIFT_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_SHIFT_H_ +#define REMILL_ARCH_X86_SEMANTICS_SHIFT_H_ namespace { @@ -43,13 +43,13 @@ struct ShiftRight { } else if (shift < kNumBits) { const T res = val >> (shift - 1); - new_of = __mcsema_undefined_bool(); + new_of = __remill_undefined_bool(); new_cf = res & 1; new_val = res >> 1; } else { - new_of = __mcsema_undefined_bool(); - new_cf = __mcsema_undefined_bool(); + new_of = __remill_undefined_bool(); + new_cf = __remill_undefined_bool(); if (std::is_signed::value) { if (SignFlag(val)) { new_val = static_cast(std::numeric_limits::max()); @@ -63,11 +63,11 @@ struct ShiftRight { W(dst) = static_cast(new_val); - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = new_cf; state.aflag.pf = ParityFlag(new_val); - state.aflag.af = __mcsema_undefined_bool(); + state.aflag.af = __remill_undefined_bool(); state.aflag.zf = ZeroFlag(new_val); state.aflag.sf = std::is_signed::value ? SignFlag(new_val) : false; state.aflag.of = new_of; @@ -109,23 +109,23 @@ DEF_SEM(SHL, D dst, S1 src1_, S2 src2_) { const T res = val << (shift - 1); const auto msb = SignFlag(res); - new_of = __mcsema_undefined_bool(); + new_of = __remill_undefined_bool(); new_cf = msb; new_val = res << 1; } else { - new_of = __mcsema_undefined_bool(); - new_cf = __mcsema_undefined_bool(); + new_of = __remill_undefined_bool(); + new_cf = __remill_undefined_bool(); new_val = 0; } W(dst) = new_val; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = new_cf; state.aflag.pf = ParityFlag(new_val); - state.aflag.af = __mcsema_undefined_bool(); + state.aflag.af = __remill_undefined_bool(); state.aflag.zf = ZeroFlag(new_val); state.aflag.sf = SignFlag(new_val); state.aflag.of = new_of; @@ -188,7 +188,7 @@ namespace { template NEVER_INLINE static bool SHRDCarryFlag(T val, T count) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return (val >> (count - 1)) & 1; } @@ -213,12 +213,12 @@ DEF_SEM(SHRD, D dst, S1 src1, S2 src2, S3 count_) { const T left = R(src2) << (kSize - count); const T res = left | right; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = SHRDCarryFlag(src, count); state.aflag.sf = SignFlag(res); state.aflag.zf = ZeroFlag(res); state.aflag.pf = ParityFlag(res); - state.aflag.af = __mcsema_undefined_bool(); + state.aflag.af = __remill_undefined_bool(); state.aflag.of = SignFlag(src) != state.aflag.sf; // OF undefined for `1 == temp_count`. } @@ -234,7 +234,7 @@ namespace { template NEVER_INLINE static bool SHLDCarryFlag(T val, T count) { - __mcsema_defer_inlining(); + __remill_defer_inlining(); return (val >> ((8 * sizeof(T)) - count)) & 1; } @@ -259,12 +259,12 @@ DEF_SEM(SHLD, D dst, S1 src1, S2 src2, S3 count_) { const T right = R(src2) >> (kSize - count); const T res = left | right; W(dst) = res; - __mcsema_barrier_compiler(); + __remill_barrier_compiler(); state.aflag.cf = SHLDCarryFlag(src, count); state.aflag.sf = SignFlag(res); state.aflag.zf = ZeroFlag(res); state.aflag.pf = ParityFlag(res); - state.aflag.af = __mcsema_undefined_bool(); + state.aflag.af = __remill_undefined_bool(); state.aflag.of = SignFlag(src) != state.aflag.sf; // OF undefined for `1 == temp_count`. } @@ -276,4 +276,4 @@ DEF_ISEL_RnW_Rn_Rn_In(SHLD_GPRv_GPRv_IMMb, SHLD); DEF_ISEL_MnW_Mn_Rn_Rn(SHLD_MEMv_GPRv_CL, SHLD); DEF_ISEL_RnW_Rn_Rn_Rn(SHLD_GPRv_GPRv_CL, SHLD); -#endif // MCSEMA_ARCH_X86_SEMANTICS_SHIFT_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_SHIFT_H_ diff --git a/mcsema/Arch/X86/Semantics/SSE.h b/remill/Arch/X86/Semantics/SSE.h similarity index 96% rename from mcsema/Arch/X86/Semantics/SSE.h rename to remill/Arch/X86/Semantics/SSE.h index 622669ce..76323ea6 100644 --- a/mcsema/Arch/X86/Semantics/SSE.h +++ b/remill/Arch/X86/Semantics/SSE.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_SSE_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_SSE_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_SSE_H_ +#define REMILL_ARCH_X86_SEMANTICS_SSE_H_ namespace { @@ -85,4 +85,4 @@ DEF_ISEL(VUCOMISS_XMMdq_XMMd) = COMISx; */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_SSE_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_SSE_H_ diff --git a/mcsema/Arch/X86/Semantics/STRINGOP.h b/remill/Arch/X86/Semantics/STRINGOP.h similarity index 97% rename from mcsema/Arch/X86/Semantics/STRINGOP.h rename to remill/Arch/X86/Semantics/STRINGOP.h index cebdd42d..4888dcc1 100644 --- a/mcsema/Arch/X86/Semantics/STRINGOP.h +++ b/remill/Arch/X86/Semantics/STRINGOP.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_STRINGOP_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_STRINGOP_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_STRINGOP_H_ +#define REMILL_ARCH_X86_SEMANTICS_STRINGOP_H_ #define MAKE_STOS(name, type, read_sel) \ DEF_ISEL_SEM(name) { \ @@ -215,4 +215,4 @@ IF_64BIT(MAKE_REPNE(SCASQ)) 1366 INSW INSW IOSTRINGOP BASE I186 ATTRIBUTES: FIXED_BASE0 NOTSX */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_STRINGOP_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_STRINGOP_H_ diff --git a/mcsema/Arch/X86/Semantics/UNCOND_BR.h b/remill/Arch/X86/Semantics/UNCOND_BR.h similarity index 100% rename from mcsema/Arch/X86/Semantics/UNCOND_BR.h rename to remill/Arch/X86/Semantics/UNCOND_BR.h diff --git a/mcsema/Arch/X86/Semantics/X87.h b/remill/Arch/X86/Semantics/X87.h similarity index 92% rename from mcsema/Arch/X86/Semantics/X87.h rename to remill/Arch/X86/Semantics/X87.h index 14635cc8..7c46dbdf 100644 --- a/mcsema/Arch/X86/Semantics/X87.h +++ b/remill/Arch/X86/Semantics/X87.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_X87_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_X87_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_X87_H_ +#define REMILL_ARCH_X86_SEMANTICS_X87_H_ #define PUSH_X87_STACK(x) \ state.st.element[7].val = state.st.element[6].val ; \ @@ -22,7 +22,7 @@ state.st.element[4].val = state.st.element[5].val ; \ state.st.element[5].val = state.st.element[6].val ; \ state.st.element[6].val = state.st.element[7].val ; \ - state.st.element[7].val = __mcsema_undefined_f64(); \ + state.st.element[7].val = __remill_undefined_f64(); \ x; }) DEF_ISEL_SEM(FILD_ST0_MEMmem16int, RF80W, M16 val_) { @@ -83,4 +83,4 @@ DEF_ISEL_SEM(FLDPI_ST0, RF80W) { 1404 FLDCW FLDCW_MEMmem16 X87_ALU X87 X87 ATTRIBUTES: NOTSX X87_CONTROL */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_X87_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_X87_H_ diff --git a/mcsema/Arch/X86/Semantics/XOP.h b/remill/Arch/X86/Semantics/XOP.h similarity index 84% rename from mcsema/Arch/X86/Semantics/XOP.h rename to remill/Arch/X86/Semantics/XOP.h index 53a24786..67e6e82e 100644 --- a/mcsema/Arch/X86/Semantics/XOP.h +++ b/remill/Arch/X86/Semantics/XOP.h @@ -1,7 +1,7 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_SEMANTICS_XOP_H_ -#define MCSEMA_ARCH_X86_SEMANTICS_XOP_H_ +#ifndef REMILL_ARCH_X86_SEMANTICS_XOP_H_ +#define REMILL_ARCH_X86_SEMANTICS_XOP_H_ /* * See https://en.wikipedia.org/wiki/XOP_instruction_set @@ -16,4 +16,4 @@ 1997 VPCMOV VPCMOV_YMMqq_YMMqq_YMMqq_YMMqq XOP XOP XOP ATTRIBUTES: */ -#endif // MCSEMA_ARCH_X86_SEMANTICS_XOP_H_ +#endif // REMILL_ARCH_X86_SEMANTICS_XOP_H_ diff --git a/mcsema/Arch/X86/Translator.cpp b/remill/Arch/X86/Translator.cpp similarity index 99% rename from mcsema/Arch/X86/Translator.cpp rename to remill/Arch/X86/Translator.cpp index 7527dbe7..7f2498af 100644 --- a/mcsema/Arch/X86/Translator.cpp +++ b/remill/Arch/X86/Translator.cpp @@ -11,15 +11,15 @@ #include #include -#include "mcsema/Arch/X86/Arch.h" -#include "mcsema/Arch/X86/RegisterAnalysis.h" -#include "mcsema/Arch/X86/Translator.h" -#include "mcsema/BC/IntrinsicTable.h" -#include "mcsema/BC/Translator.h" -#include "mcsema/BC/Util.h" -#include "mcsema/CFG/CFG.h" +#include "remill/Arch/X86/Arch.h" +#include "remill/Arch/X86/RegisterAnalysis.h" +#include "remill/Arch/X86/Translator.h" +#include "remill/BC/IntrinsicTable.h" +#include "remill/BC/Translator.h" +#include "remill/BC/Util.h" +#include "remill/CFG/CFG.h" -namespace mcsema { +namespace remill { namespace x86 { enum { @@ -855,4 +855,4 @@ uintptr_t InstructionTranslator::NextPC(void) const { } } // namespace x86 -} // namespace mcsema +} // namespace remill diff --git a/mcsema/Arch/X86/Translator.h b/remill/Arch/X86/Translator.h similarity index 93% rename from mcsema/Arch/X86/Translator.h rename to remill/Arch/X86/Translator.h index 8308df9b..9e945784 100644 --- a/mcsema/Arch/X86/Translator.h +++ b/remill/Arch/X86/Translator.h @@ -1,12 +1,12 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_TRANSLATOR_H_ -#define MCSEMA_ARCH_X86_TRANSLATOR_H_ +#ifndef REMILL_ARCH_X86_TRANSLATOR_H_ +#define REMILL_ARCH_X86_TRANSLATOR_H_ #include #include -#include "mcsema/Arch/X86/XED.h" +#include "remill/Arch/X86/XED.h" namespace llvm { class Context; @@ -14,7 +14,7 @@ class Function; class Type; } // namespace llvm -namespace mcsema { +namespace remill { namespace cfg { class Instr; } // namespace cfg @@ -104,6 +104,6 @@ class InstructionTranslator { }; } // namespace x86 -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_ARCH_X86_TRANSLATOR_H_ +#endif // REMILL_ARCH_X86_TRANSLATOR_H_ diff --git a/mcsema/Arch/X86/XED.h b/remill/Arch/X86/XED.h similarity index 83% rename from mcsema/Arch/X86/XED.h rename to remill/Arch/X86/XED.h index 41196d6c..6d945ef7 100644 --- a/mcsema/Arch/X86/XED.h +++ b/remill/Arch/X86/XED.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_ARCH_X86_XED_H_ -#define MCSEMA_ARCH_X86_XED_H_ +#ifndef REMILL_ARCH_X86_XED_H_ +#define REMILL_ARCH_X86_XED_H_ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wsign-conversion" @@ -15,4 +15,4 @@ extern "C" { } // extern C #pragma clang diagnostic pop -#endif // MCSEMA_ARCH_X86_XED_H_ +#endif // REMILL_ARCH_X86_XED_H_ diff --git a/remill/BC/IntrinsicTable.cpp b/remill/BC/IntrinsicTable.cpp new file mode 100644 index 00000000..c48bedba --- /dev/null +++ b/remill/BC/IntrinsicTable.cpp @@ -0,0 +1,160 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#include + +#include + +#include +#include +#include + +#include "remill/BC/IntrinsicTable.h" +#include "remill/BC/Util.h" + +namespace remill { +namespace { + +// Find a specific function. +static llvm::Function *FindIntrinsic(const llvm::Module *module, + const char *name) { + auto function = FindFunction(module, name); + CHECK(nullptr != function) + << "Unable to find intrinsic: " << name; + + // We don't want calls to memory intrinsics to be duplicated because then + // they might have the wrong side effects! + function->addFnAttr(llvm::Attribute::NoDuplicate); + + InitFunctionAttributes(function); + return function; +} + +// Find a specific function. +static llvm::Function *FindPureIntrinsic(const llvm::Module *module, + const char *name) { + auto function = FindIntrinsic(module, name); + + // We want memory intrinsics to be marked as not accessing memory so that + // they don't interfere with dead store elimination. + function->addFnAttr(llvm::Attribute::ReadNone); + return function; +} + +// Find a specific function. +static llvm::Function *FindReadOnlyIntrinsic(const llvm::Module *module, + const char *name) { + auto function = FindIntrinsic(module, name); + + // We want memory intrinsics to be marked as not accessing memory so that + // they don't interfere with dead store elimination. + function->addFnAttr(llvm::Attribute::ReadOnly); + return function; +} + +} // namespace + +IntrinsicTable::IntrinsicTable(const llvm::Module *module) + : error(FindIntrinsic(module, "__remill_error")), + + // Control-flow. + function_call(FindIntrinsic(module, "__remill_function_call")), + function_return(FindIntrinsic(module, "__remill_function_return")), + jump(FindIntrinsic(module, "__remill_jump")), + + // Signaling control-flow. + create_program_counter(FindPureIntrinsic( + module, "__remill_create_program_counter")), + conditional_branch(FindPureIntrinsic( + module, "__remill_conditional_branch")), + + // OS interaction. + system_call(FindIntrinsic(module, "__remill_system_call")), + system_return(FindIntrinsic(module, "__remill_system_return")), + interrupt_call(FindIntrinsic(module, "__remill_interrupt_call")), + interrupt_return(FindIntrinsic(module, "__remill_interrupt_return")), + + // Arch interaction. + read_cpu_features(FindIntrinsic(module, "__remill_read_cpu_features")), + + // Block that can't be found. + missing_block(FindIntrinsic(module, "__remill_missing_block")), + + // Memory access. + read_memory_8(FindPureIntrinsic(module, "__remill_read_memory_8")), + read_memory_16(FindPureIntrinsic(module, "__remill_read_memory_16")), + read_memory_32(FindPureIntrinsic(module, "__remill_read_memory_32")), + read_memory_64(FindPureIntrinsic(module, "__remill_read_memory_64")), + + // These take in a value by reference and modify it, therefore they are + // NOT pure. + read_memory_v8(FindIntrinsic(module, "__remill_read_memory_v8")), + read_memory_v16(FindIntrinsic(module, "__remill_read_memory_v16")), + read_memory_v32(FindIntrinsic(module, "__remill_read_memory_v32")), + read_memory_v64(FindIntrinsic(module, "__remill_read_memory_v64")), + read_memory_v128(FindIntrinsic(module, "__remill_read_memory_v128")), + read_memory_v256(FindIntrinsic(module, "__remill_read_memory_v256")), + read_memory_v512(FindIntrinsic(module, "__remill_read_memory_v512")), + + write_memory_8(FindPureIntrinsic(module, "__remill_write_memory_8")), + write_memory_16(FindPureIntrinsic(module, "__remill_write_memory_16")), + write_memory_32(FindPureIntrinsic(module, "__remill_write_memory_32")), + write_memory_64(FindPureIntrinsic(module, "__remill_write_memory_64")), + + write_memory_v8(FindReadOnlyIntrinsic(module, "__remill_write_memory_v8")), + write_memory_v16(FindReadOnlyIntrinsic(module, "__remill_write_memory_v16")), + write_memory_v32(FindReadOnlyIntrinsic(module, "__remill_write_memory_v32")), + write_memory_v64(FindReadOnlyIntrinsic(module, "__remill_write_memory_v64")), + write_memory_v128(FindReadOnlyIntrinsic( + module, "__remill_write_memory_v128")), + write_memory_v256(FindReadOnlyIntrinsic( + module, "__remill_write_memory_v256")), + write_memory_v512(FindReadOnlyIntrinsic( + module, "__remill_write_memory_v512")), + + read_memory_f32(FindIntrinsic(module, "__remill_read_memory_f32")), + read_memory_f64(FindIntrinsic(module, "__remill_read_memory_f64")), + read_memory_f80(FindIntrinsic(module, "__remill_read_memory_f80")), + + write_memory_f32(FindReadOnlyIntrinsic( + module, "__remill_write_memory_f32")), + write_memory_f64(FindReadOnlyIntrinsic( + module, "__remill_write_memory_f64")), + write_memory_f80(FindReadOnlyIntrinsic( + module, "__remill_write_memory_f80")), + + read_f80(FindIntrinsic(module, "__remill_read_f80")), + write_f80(FindIntrinsic(module, "__remill_write_f80")), + + compute_address(FindPureIntrinsic(module, "__remill_compute_address")), + + // Memory barriers. + barrier_load_load(FindPureIntrinsic( + module, "__remill_barrier_load_load")), + barrier_load_store(FindPureIntrinsic( + module, "__remill_barrier_load_store")), + barrier_store_load(FindPureIntrinsic( + module, "__remill_barrier_store_load")), + barrier_store_store(FindPureIntrinsic( + module, "__remill_barrier_store_store")), + atomic_begin(FindPureIntrinsic(module, "__remill_atomic_begin")), + atomic_end(FindPureIntrinsic(module, "__remill_atomic_end")), + + // Optimization guides. + // + // Note: NOT pure! This is a total hack: we call an unpure function + // within a pure one so that it is not optimized out! + defer_inlining(FindIntrinsic(module, "__remill_defer_inlining")), + + // Optimization enablers. + undefined_bool(FindPureIntrinsic(module, "__remill_undefined_bool")), + undefined_8(FindPureIntrinsic(module, "__remill_undefined_8")), + undefined_16(FindPureIntrinsic(module, "__remill_undefined_16")), + undefined_32(FindPureIntrinsic(module, "__remill_undefined_32")), + undefined_64(FindPureIntrinsic(module, "__remill_undefined_64")), + undefined_f32(FindPureIntrinsic(module, "__remill_undefined_f32")), + undefined_f64(FindPureIntrinsic(module, "__remill_undefined_f64")), + + // Used for the global ordering of memory instructions. + memory_order(FindGlobaVariable(module, "__remill_memory_order")) {} + +} // namespace remill diff --git a/mcsema/BC/IntrinsicTable.h b/remill/BC/IntrinsicTable.h similarity index 95% rename from mcsema/BC/IntrinsicTable.h rename to remill/BC/IntrinsicTable.h index 239ca0a5..26ced836 100644 --- a/mcsema/BC/IntrinsicTable.h +++ b/remill/BC/IntrinsicTable.h @@ -1,13 +1,13 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_BC_INTRINSICTABLE_H_ -#define MCSEMA_BC_INTRINSICTABLE_H_ +#ifndef REMILL_BC_INTRINSICTABLE_H_ +#define REMILL_BC_INTRINSICTABLE_H_ namespace llvm { class Function; class Module; } // namespace llvm -namespace mcsema { +namespace remill { class IntrinsicTable { public: @@ -107,6 +107,6 @@ class IntrinsicTable { IntrinsicTable(void) = delete; }; -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_BC_INTRINSICTABLE_H_ +#endif // REMILL_BC_INTRINSICTABLE_H_ diff --git a/mcsema/BC/Translator.cpp b/remill/BC/Translator.cpp similarity index 97% rename from mcsema/BC/Translator.cpp rename to remill/BC/Translator.cpp index c482c884..bfa26089 100644 --- a/mcsema/BC/Translator.cpp +++ b/remill/BC/Translator.cpp @@ -23,11 +23,11 @@ #include #include -#include "mcsema/Arch/Arch.h" -#include "mcsema/BC/IntrinsicTable.h" -#include "mcsema/BC/Translator.h" -#include "mcsema/CFG/CFG.h" -#include "mcsema/OS/OS.h" +#include "remill/Arch/Arch.h" +#include "remill/BC/IntrinsicTable.h" +#include "remill/BC/Translator.h" +#include "remill/CFG/CFG.h" +#include "remill/OS/OS.h" DEFINE_int32(max_dataflow_analysis_iterations, 0, "Maximum number of iterations of a data flow pass to perform " @@ -42,13 +42,13 @@ namespace llvm { class ReturnInst; } // namespace -namespace mcsema { +namespace remill { namespace { // Name of some meta-data that we use to distinguish between external symbols // and private symbols. static std::string NamedSymbolMetaId(std::string func_name) { - return "mcsema_external:" + func_name; + return "remill_external:" + func_name; } // Returns the ID for this binary. We prefix every basic block function added to @@ -56,7 +56,7 @@ static std::string NamedSymbolMetaId(std::string func_name) { // linearly. static int GetBinaryId(llvm::Module *module) { for (auto i = 1; ; ++i) { - std::string id = "mcsema_binary:" + std::to_string(i); + std::string id = "remill_binary:" + std::to_string(i); if (!module->getNamedMetadata(id)) { module->getOrInsertNamedMetadata(id); return i; @@ -74,7 +74,7 @@ Translator::Translator(const Arch *arch_, llvm::Module *module_) functions(), symbols(), binary_id(GetBinaryId(module)), - basic_block(FindFunction(module, "__mcsema_basic_block")), + basic_block(FindFunction(module, "__remill_basic_block")), intrinsics(new IntrinsicTable(module)) { EnableDeferredInlining(); @@ -152,7 +152,7 @@ static void SetMetaDataAddress(llvm::Module *module, const std::string &block_name, uint64_t block_addr) { std::stringstream ss; - ss << "mcsema_address:" << block_name; + ss << "remill_address:" << block_name; auto &context = module->getContext(); auto int64_type = llvm::Type::getInt64Ty(context); auto block_addr_val = llvm::ConstantInt::get(int64_type, block_addr, false); @@ -470,4 +470,4 @@ llvm::Function *Translator::GetLiftedBlockForPC(uintptr_t pc) const { return block_func; } -} // namespace mcsema +} // namespace remill diff --git a/mcsema/BC/Translator.h b/remill/BC/Translator.h similarity index 94% rename from mcsema/BC/Translator.h rename to remill/BC/Translator.h index cea8089e..01f15c21 100644 --- a/mcsema/BC/Translator.h +++ b/remill/BC/Translator.h @@ -1,11 +1,11 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_BC_TRANSLATOR_H_ -#define MCSEMA_BC_TRANSLATOR_H_ +#ifndef REMILL_BC_TRANSLATOR_H_ +#define REMILL_BC_TRANSLATOR_H_ #include -#include "mcsema/BC/Util.h" +#include "remill/BC/Util.h" namespace llvm { class Function; @@ -13,7 +13,7 @@ class Module; class GlobalVariable; } // namespace llvm -namespace mcsema { +namespace remill { namespace cfg { class Block; class Instr; @@ -105,6 +105,6 @@ class Translator { const IntrinsicTable * const intrinsics; }; -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_BC_TRANSLATOR_H_ +#endif // REMILL_BC_TRANSLATOR_H_ diff --git a/mcsema/BC/Util.cpp b/remill/BC/Util.cpp similarity index 99% rename from mcsema/BC/Util.cpp rename to remill/BC/Util.cpp index c724ae44..b37f4ff5 100644 --- a/mcsema/BC/Util.cpp +++ b/remill/BC/Util.cpp @@ -21,9 +21,9 @@ #include #include -#include "mcsema/BC/Util.h" +#include "remill/BC/Util.h" -namespace mcsema { +namespace remill { llvm::Function *&BlockMap::operator[](uintptr_t pc) { return this->std::unordered_map::operator[](pc); @@ -201,4 +201,4 @@ void StoreModuleToFile(llvm::Module *module, std::string file_name) { << "Error writing bitcode to file: " << file_name; } -} // namespace mcsema +} // namespace remill diff --git a/mcsema/BC/Util.h b/remill/BC/Util.h similarity index 94% rename from mcsema/BC/Util.h rename to remill/BC/Util.h index 5016775b..78f4216c 100644 --- a/mcsema/BC/Util.h +++ b/remill/BC/Util.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_BC_UTIL_H_ -#define MCSEMA_BC_UTIL_H_ +#ifndef REMILL_BC_UTIL_H_ +#define REMILL_BC_UTIL_H_ #include #include @@ -13,7 +13,7 @@ class GlobalVariable; class Module; class Value; } // namespace llvm -namespace mcsema { +namespace remill { using FunctionMap = std::unordered_map; using SymbolMap = std::unordered_map; @@ -57,6 +57,6 @@ llvm::Module *LoadModuleFromFile(std::string file_name); // Store an LLVM module into a file. void StoreModuleToFile(llvm::Module *module, std::string file_name); -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_BC_UTIL_H_ +#endif // REMILL_BC_UTIL_H_ diff --git a/mcsema/CFG/AutoAnalysis.cpp b/remill/CFG/AutoAnalysis.cpp similarity index 60% rename from mcsema/CFG/AutoAnalysis.cpp rename to remill/CFG/AutoAnalysis.cpp index 298773c7..cb87a579 100644 --- a/mcsema/CFG/AutoAnalysis.cpp +++ b/remill/CFG/AutoAnalysis.cpp @@ -1,9 +1,9 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#include "mcsema/CFG/AutoAnalysis.h" +#include "remill/CFG/AutoAnalysis.h" -namespace mcsema { +namespace remill { AutoAnalysis::~AutoAnalysis(void) {} -} // namespace mcsema +} // namespace remill diff --git a/mcsema/CFG/AutoAnalysis.h b/remill/CFG/AutoAnalysis.h similarity index 86% rename from mcsema/CFG/AutoAnalysis.h rename to remill/CFG/AutoAnalysis.h index 634d5f36..fb631dad 100644 --- a/mcsema/CFG/AutoAnalysis.h +++ b/remill/CFG/AutoAnalysis.h @@ -1,12 +1,12 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_CFG_AUTOANALYSIS_H_ -#define MCSEMA_CFG_AUTOANALYSIS_H_ +#ifndef REMILL_CFG_AUTOANALYSIS_H_ +#define REMILL_CFG_AUTOANALYSIS_H_ #include #include -namespace mcsema { +namespace remill { namespace cfg { class Block; class Function; @@ -39,6 +39,6 @@ class AutoAnalysis { }; -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_CFG_AUTOANALYSIS_H_ +#endif // REMILL_CFG_AUTOANALYSIS_H_ diff --git a/mcsema/CFG/CFG.cpp b/remill/CFG/CFG.cpp similarity index 88% rename from mcsema/CFG/CFG.cpp rename to remill/CFG/CFG.cpp index 54edcfc1..491e1a53 100644 --- a/mcsema/CFG/CFG.cpp +++ b/remill/CFG/CFG.cpp @@ -3,9 +3,9 @@ #include #include -#include "mcsema/CFG/CFG.h" +#include "remill/CFG/CFG.h" -namespace mcsema { +namespace remill { const cfg::Module *ReadCFG(std::string cfg_file_name) { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -20,6 +20,6 @@ const cfg::Module *ReadCFG(std::string cfg_file_name) { return cfg_pb; } -} // namespace mcsema +} // namespace remill #include "generated/CFG/CFG.pb.cc" diff --git a/mcsema/CFG/CFG.h b/remill/CFG/CFG.h similarity index 69% rename from mcsema/CFG/CFG.h rename to remill/CFG/CFG.h index bb52e2c9..45af009c 100644 --- a/mcsema/CFG/CFG.h +++ b/remill/CFG/CFG.h @@ -1,7 +1,7 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_CFG_CFG_H_ -#define MCSEMA_CFG_CFG_H_ +#ifndef REMILL_CFG_CFG_H_ +#define REMILL_CFG_CFG_H_ #include @@ -13,12 +13,12 @@ namespace llvm { class Module; } // namespace llvm -namespace mcsema { +namespace remill { class Arch; const cfg::Module *ReadCFG(std::string cfg_file_name); -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_CFG_CFG_H_ +#endif // REMILL_CFG_CFG_H_ diff --git a/mcsema/CFG/CFG.proto b/remill/CFG/CFG.proto similarity index 97% rename from mcsema/CFG/CFG.proto rename to remill/CFG/CFG.proto index e222c526..3d3e3b44 100644 --- a/mcsema/CFG/CFG.proto +++ b/remill/CFG/CFG.proto @@ -1,5 +1,5 @@ -package mcsema.cfg; +package remill.cfg; message Instr { required uint64 address = 1; diff --git a/mcsema/Finalize.cpp b/remill/Finalize.cpp similarity index 91% rename from mcsema/Finalize.cpp rename to remill/Finalize.cpp index 95015d03..8b3caeec 100644 --- a/mcsema/Finalize.cpp +++ b/remill/Finalize.cpp @@ -1,6 +1,6 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#define DEBUG_TYPE "mcsema_finalize" +#define DEBUG_TYPE "remill_finalize" #include #include @@ -17,7 +17,7 @@ #include -namespace mcsema { +namespace remill { namespace { static llvm::Function *GetFunction(llvm::Module &module, const char *name) { @@ -86,9 +86,9 @@ bool FinalizeModulePass::runOnModule(llvm::Module &module) { for (llvm::Function &function : module) { RemoveNakedAttribute(function); } - RemoveFunction(module, "__mcsema_intrinsics"); - RemoveFunction(module, "__mcsema_mark_as_used"); - RemoveFunction(module, "__mcsema_defer_inlining"); + RemoveFunction(module, "__remill_intrinsics"); + RemoveFunction(module, "__remill_mark_as_used"); + RemoveFunction(module, "__remill_defer_inlining"); return true; } @@ -101,4 +101,4 @@ static llvm::RegisterPass X( false); // Analysis Pass. -} // namespace mcsema +} // namespace remill diff --git a/mcsema/OS/OS.cpp b/remill/OS/OS.cpp similarity index 83% rename from mcsema/OS/OS.cpp rename to remill/OS/OS.cpp index c5c90d8b..4610b42f 100644 --- a/mcsema/OS/OS.cpp +++ b/remill/OS/OS.cpp @@ -2,9 +2,9 @@ #include -#include "mcsema/OS/OS.h" +#include "remill/OS/OS.h" -namespace mcsema { +namespace remill { OSName GetOSName(std::string name) { if (name == "mac") { @@ -17,4 +17,4 @@ OSName GetOSName(std::string name) { } } -} // namespace mcsema +} // namespace remill diff --git a/mcsema/OS/OS.h b/remill/OS/OS.h similarity index 62% rename from mcsema/OS/OS.h rename to remill/OS/OS.h index 1a6077cf..5a4a1e4d 100644 --- a/mcsema/OS/OS.h +++ b/remill/OS/OS.h @@ -1,11 +1,11 @@ /* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#ifndef MCSEMA_OS_OS_H_ -#define MCSEMA_OS_OS_H_ +#ifndef REMILL_OS_OS_H_ +#define REMILL_OS_OS_H_ #include -namespace mcsema { +namespace remill { enum OSName { kOSInvalid, @@ -15,6 +15,6 @@ enum OSName { OSName GetOSName(std::string name_); -} // namespace mcsema +} // namespace remill -#endif // MCSEMA_OS_OS_H_ +#endif // REMILL_OS_OS_H_ diff --git a/mcsema/Optimize.cpp b/remill/Optimize.cpp similarity index 84% rename from mcsema/Optimize.cpp rename to remill/Optimize.cpp index 8f74a0e7..be39d1b5 100644 --- a/mcsema/Optimize.cpp +++ b/remill/Optimize.cpp @@ -1,6 +1,6 @@ /* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ -#define DEBUG_TYPE "mcsema_optimize" +#define DEBUG_TYPE "remill_optimize" #include #include @@ -15,7 +15,7 @@ #include -namespace mcsema { +namespace remill { namespace { // Require that if `function` is invoked, then it is treated as a tail call. @@ -92,19 +92,19 @@ static void ReplaceIntrinsic(llvm::Module &module, const char *name) { // Remove calls to the undefined intrinsics. The goal here is to improve dead // store elimination by peppering the instruction semantics with assignments -// to the return values of special `__mcsema_undefined_*` intrinsics. It's hard +// to the return values of special `__remill_undefined_*` intrinsics. It's hard // to reliably produce an `undef` LLVM value from C/C++, so we use our trick // of declaring (but never defining) a special "intrinsic" and then we replace // all such uses with `undef` values. void RemoveUndefinedIntrinsics(llvm::Module &module) { - ReplaceIntrinsic(module, "__mcsema_undefined_bool"); - ReplaceIntrinsic(module, "__mcsema_undefined_8"); - ReplaceIntrinsic(module, "__mcsema_undefined_16"); - ReplaceIntrinsic(module, "__mcsema_undefined_32"); - ReplaceIntrinsic(module, "__mcsema_undefined_64"); + ReplaceIntrinsic(module, "__remill_undefined_bool"); + ReplaceIntrinsic(module, "__remill_undefined_8"); + ReplaceIntrinsic(module, "__remill_undefined_16"); + ReplaceIntrinsic(module, "__remill_undefined_32"); + ReplaceIntrinsic(module, "__remill_undefined_64"); - ReplaceIntrinsic(module, "__mcsema_undefined_f32"); - ReplaceIntrinsic(module, "__mcsema_undefined_f64"); + ReplaceIntrinsic(module, "__remill_undefined_f32"); + ReplaceIntrinsic(module, "__remill_undefined_f64"); // Eliminate stores of undefined values. for (auto &function : module) { @@ -126,7 +126,7 @@ void RemoveUndefinedIntrinsics(llvm::Module &module) { } } - auto mem_order = module.getGlobalVariable("__mcsema_memory_order"); + auto mem_order = module.getGlobalVariable("__remill_memory_order"); // Remove globals that we don't need. std::vector remove_globals; @@ -151,7 +151,7 @@ void RemoveUndefinedIntrinsics(llvm::Module &module) { // Enable inlining of functions whose inlining has been deferred. static void EnableInlining(llvm::Module &module) { - auto defer_inlining_func = GetFunction(module, "__mcsema_defer_inlining"); + auto defer_inlining_func = GetFunction(module, "__remill_defer_inlining"); if (!defer_inlining_func) return; std::vector call_instrs; @@ -195,8 +195,8 @@ static void EnableInlining(llvm::Module &module) { } // namespace -// Implements the deferred inlining optimization. McSema2 uses a special -// `__mcsema_defer_inlining` intrinsic to mark functions as needing to be +// Implements the deferred inlining optimization. Remill uses a special +// `__remill_defer_inlining` intrinsic to mark functions as needing to be // "late" inlined. The idea is that we want some functions to be optimized // away (flag computation functions), but the ones that stick around should // then be inlined into their callers for further optimization. @@ -224,15 +224,15 @@ const char *IntrinsicOptimizer::getPassName(void) const { bool IntrinsicOptimizer::runOnModule(llvm::Module &module) { RemoveUndefinedIntrinsics(module); - ForceTailCall(GetFunction(module, "__mcsema_error")); - ForceTailCall(GetFunction(module, "__mcsema_jump")); - ForceTailCall(GetFunction(module, "__mcsema_function_call")); - ForceTailCall(GetFunction(module, "__mcsema_function_return")); - ForceTailCall(GetFunction(module, "__mcsema_system_call")); - ForceTailCall(GetFunction(module, "__mcsema_system_return")); - ForceTailCall(GetFunction(module, "__mcsema_interrupt_call")); - ForceTailCall(GetFunction(module, "__mcsema_interrupt_return")); - ForceTailCall(GetFunction(module, "__mcsema_missing_block")); + ForceTailCall(GetFunction(module, "__remill_error")); + ForceTailCall(GetFunction(module, "__remill_jump")); + ForceTailCall(GetFunction(module, "__remill_function_call")); + ForceTailCall(GetFunction(module, "__remill_function_return")); + ForceTailCall(GetFunction(module, "__remill_system_call")); + ForceTailCall(GetFunction(module, "__remill_system_return")); + ForceTailCall(GetFunction(module, "__remill_interrupt_call")); + ForceTailCall(GetFunction(module, "__remill_interrupt_return")); + ForceTailCall(GetFunction(module, "__remill_missing_block")); EnableInlining(module); return true; @@ -242,9 +242,9 @@ char IntrinsicOptimizer::ID = 0; static llvm::RegisterPass X( DEBUG_TYPE, - "Removes `__mcsema_defer_inlining` and `__mcsema_undefined_*` intrinsics.", + "Removes `__remill_defer_inlining` and `__remill_undefined_*` intrinsics.", false, // Only looks at CFG. false); // Analysis Pass. -} // namespace mcsema +} // namespace remill diff --git a/mcsema/Translate.cpp b/remill/Translate.cpp similarity index 72% rename from mcsema/Translate.cpp rename to remill/Translate.cpp index c65d6100..0adad884 100644 --- a/mcsema/Translate.cpp +++ b/remill/Translate.cpp @@ -9,16 +9,16 @@ #include #include -#include "mcsema/BC/Translator.h" -#include "mcsema/BC/Util.h" -#include "mcsema/Arch/Arch.h" -#include "mcsema/CFG/CFG.h" +#include "remill/BC/Translator.h" +#include "remill/BC/Util.h" +#include "remill/Arch/Arch.h" +#include "remill/CFG/CFG.h" -#ifndef MCSEMA_OS +#ifndef REMILL_OS # if defined(__APPLE__) -# define MCSEMA_OS "mac" +# define REMILL_OS "mac" # elif defined(__linux__) -# define MCSEMA_OS "linux" +# define REMILL_OS "linux" # endif #endif @@ -30,8 +30,8 @@ DEFINE_string(arch_out, "", "Architecture of the target architecture on " "which the translated code will run. Valid " "architectures: x86, amd64."); -DEFINE_string(os_in, MCSEMA_OS, "Source OS. Valid OSes: linux, mac."); -DEFINE_string(os_out, MCSEMA_OS, "Target OS. Valid OSes: linux, mac."); +DEFINE_string(os_in, REMILL_OS, "Source OS. Valid OSes: linux, mac."); +DEFINE_string(os_out, REMILL_OS, "Target OS. Valid OSes: linux, mac."); DEFINE_string(cfg, "", "Path to the CFG file containing code to lift."); @@ -50,7 +50,7 @@ extern "C" int main(int argc, char *argv[]) { google::InitGoogleLogging(argv[0]); // GFlags will have removed everything that it recognized from argc/argv. - llvm::cl::ParseCommandLineOptions(argc, argv, "McSema CFG to LLVM"); + llvm::cl::ParseCommandLineOptions(argc, argv, "Remill CFG to LLVM"); CHECK(!FLAGS_os_out.empty()) << "Need to specify a target operating system with --os."; @@ -70,21 +70,21 @@ extern "C" int main(int argc, char *argv[]) { CHECK(!FLAGS_bc_out.empty()) << "Please specify an output bitcode file with --bc_out."; - auto source_os = mcsema::GetOSName(FLAGS_os_in); - auto target_os = mcsema::GetOSName(FLAGS_os_out); + auto source_os = remill::GetOSName(FLAGS_os_in); + auto target_os = remill::GetOSName(FLAGS_os_out); - auto source_arch = mcsema::Arch::Create(source_os, FLAGS_arch_in); - auto target_arch = mcsema::Arch::Create(target_os, FLAGS_arch_out); + auto source_arch = remill::Arch::Create(source_os, FLAGS_arch_in); + auto target_arch = remill::Arch::Create(target_os, FLAGS_arch_out); - //auto target_arch = mcsema::Arch::Create(FLAGS_target_arch); - auto cfg = mcsema::ReadCFG(FLAGS_cfg); - auto source_module = mcsema::LoadModuleFromFile(FLAGS_bc_in); + //auto target_arch = remill::Arch::Create(FLAGS_target_arch); + auto cfg = remill::ReadCFG(FLAGS_cfg); + auto source_module = remill::LoadModuleFromFile(FLAGS_bc_in); auto target_module = target_arch->PrepareModule(source_module); - mcsema::Translator lifter(source_arch, target_module); + remill::Translator lifter(source_arch, target_module); lifter.LiftCFG(cfg); - mcsema::StoreModuleToFile(target_module, FLAGS_bc_out); + remill::StoreModuleToFile(target_module, FLAGS_bc_out); delete cfg; delete source_arch; diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh index 45bc33e0..017b9840 100755 --- a/scripts/bootstrap.sh +++ b/scripts/bootstrap.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash # Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. -# Directory in which the script dir resides (i.e. McSema root dir). +# Directory in which the script dir resides (i.e. Remill root dir). DIR=$(dirname $( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )) RED=`tput setaf 1` @@ -24,7 +24,7 @@ LLVM_RELEASE_DIR=releases/${LLVM_RELEASE} if [[ "$OSTYPE" == "linux-gnu" ]]; then XED_VERSION=xed-install-base-${XED_RELEASE}-lin-x86-64 LLVM_VERSION=clang+llvm-${LLVM_RELEASE}-x86_64-linux-gnu-ubuntu-14.04 - MCSEMA_OS_NAME="linux" + REMILL_OS_NAME="linux" LIB_EXT=so STDLIB="libstdc++" LIB_LINK_FLAGS= @@ -33,7 +33,7 @@ elif [[ "$OSTYPE" == "darwin"* ]]; then XED_VERSION=xed-install-base-${XED_RELEASE}-mac-x86-64 LLVM_RELEASE=3.8.0 LLVM_VERSION=clang+llvm-${LLVM_RELEASE}-x86_64-apple-darwin - MCSEMA_OS_NAME="mac" + REMILL_OS_NAME="mac" LIB_EXT=dylib STDLIB="libc++" LIB_LINK_FLAGS="-lc++ -lc++abi" @@ -300,7 +300,7 @@ function generate_files() # read in CFG protobuf files and output LLVM bitcode files. sub_category "Generating protocol buffers." cd $DIR/generated/CFG - cp $DIR/mcsema/CFG/CFG.proto $DIR/generated/CFG + cp $DIR/remill/CFG/CFG.proto $DIR/generated/CFG $DIR/third_party/bin/protoc --cpp_out=. CFG.proto $DIR/third_party/bin/protoc --python_out=. CFG.proto @@ -310,13 +310,13 @@ function generate_files() popd } -function build_mcsema() +function build_remill() { - category "Compiling McSema." + category "Compiling Remill" python $DIR/scripts/build.py } create_directory_tree download_dependencies generate_files -build_mcsema +build_remill diff --git a/scripts/build.py b/scripts/build.py index 744ecec2..84188ff4 100755 --- a/scripts/build.py +++ b/scripts/build.py @@ -12,12 +12,12 @@ if OS not in ("mac", "linux"): # Find all source code. source_paths = FileFinder("cpp") -source_paths.AddFile(os.path.join(MCSEMA_SRC_DIR, "Translate.cpp")) -source_paths.SearchDir(os.path.join(MCSEMA_SRC_DIR, "Arch")) -source_paths.SearchDir(os.path.join(MCSEMA_SRC_DIR, "Arch", "X86")) -source_paths.SearchDir(os.path.join(MCSEMA_SRC_DIR, "CFG")) -source_paths.SearchDir(os.path.join(MCSEMA_SRC_DIR, "BC")) -source_paths.SearchDir(os.path.join(MCSEMA_SRC_DIR, "OS")) +source_paths.AddFile(os.path.join(REMILL_SRC_DIR, "Translate.cpp")) +source_paths.SearchDir(os.path.join(REMILL_SRC_DIR, "Arch")) +source_paths.SearchDir(os.path.join(REMILL_SRC_DIR, "Arch", "X86")) +source_paths.SearchDir(os.path.join(REMILL_SRC_DIR, "CFG")) +source_paths.SearchDir(os.path.join(REMILL_SRC_DIR, "BC")) +source_paths.SearchDir(os.path.join(REMILL_SRC_DIR, "OS")) # Find the pre-existing static libraries to link in. object_files = [ @@ -36,27 +36,27 @@ system_libraries = [ # Find the LLVM libraries to link in. libraries = [ConfigLibraries( - os.path.join(MCSEMA_BIN_DIR, "llvm-config"), "--libs")] + os.path.join(REMILL_BIN_DIR, "llvm-config"), "--libs")] libraries.extend(system_libraries) # Create a program that lifts a CFG protobuf file into cfg_to_bc = TargetExecutable( - os.path.join(MCSEMA_BUILD_DIR, "cfg_to_bc"), + os.path.join(REMILL_BUILD_DIR, "cfg_to_bc"), source_files=[SourceFile(f) for f in source_paths], object_files=object_files, libraries=libraries) # Create an LLVM plugin for optimizing lifted bitcode files. libOptimize = TargetLibrary( - os.path.join(MCSEMA_BUILD_DIR, "libOptimize.{}".format(SHARED_LIB_EXT)), + os.path.join(REMILL_BUILD_DIR, "libOptimize.{}".format(SHARED_LIB_EXT)), source_files=[ - SourceFile(os.path.join(MCSEMA_DIR, "mcsema", "Optimize.cpp"))]) + SourceFile(os.path.join(REMILL_DIR, "remill", "Optimize.cpp"))]) # Create an LLVM plugin for optimizing lifted bitcode files. libFinalize = TargetLibrary( - os.path.join(MCSEMA_BUILD_DIR, "libFinalize.{}".format(SHARED_LIB_EXT)), + os.path.join(REMILL_BUILD_DIR, "libFinalize.{}".format(SHARED_LIB_EXT)), source_files=[ - SourceFile(os.path.join(MCSEMA_DIR, "mcsema", "Finalize.cpp"))]) + SourceFile(os.path.join(REMILL_DIR, "remill", "Finalize.cpp"))]) # Build the test cases for a particular arch. def BuildTests(arch, bits, suffix, has_avx, has_avx512): @@ -75,32 +75,32 @@ def BuildTests(arch, bits, suffix, has_avx, has_avx512): # Create an executable that will create a CFG file describing all of # the testcases for this arch/config. gen_cfg = TargetExecutable( - os.path.join(MCSEMA_BUILD_DIR, "gen_cfg_{}{}".format(arch, suffix)), + os.path.join(REMILL_BUILD_DIR, "gen_cfg_{}{}".format(arch, suffix)), source_files=[ SourceFile( - os.path.join(MCSEMA_TEST_DIR, "X86", "Generate.cpp"), + os.path.join(REMILL_TEST_DIR, "X86", "Generate.cpp"), extra_args=macro_args), # The `Tests.S` file needs to be compiled with extra arguments # that enable Clang to assemble code with extra features. SourceFile( - os.path.join(MCSEMA_TEST_DIR, "X86", "Tests.S"), + os.path.join(REMILL_TEST_DIR, "X86", "Tests.S"), extra_args=macro_args+target_args+["-DIN_TEST_GENERATOR"]), - SourceFile(os.path.join(MCSEMA_SRC_DIR, "CFG", "CFG.cpp"))], + SourceFile(os.path.join(REMILL_SRC_DIR, "CFG", "CFG.cpp"))], object_files=object_files, libraries=libraries) # CFG protobuf that will describe the test cases. cfg_file = os.path.join( - MCSEMA_GEN_DIR, "tests", "cfg_{}{}".format(arch, suffix)) + REMILL_GEN_DIR, "tests", "cfg_{}{}".format(arch, suffix)) # Lifted bitcode of the test cases. bc_file = os.path.join( - MCSEMA_GEN_DIR, "tests", "bc_{}{}".format(arch, suffix)) + REMILL_GEN_DIR, "tests", "bc_{}{}".format(arch, suffix)) sem_file = os.path.join( - MCSEMA_GEN_DIR, "sem_{}{}.bc".format(arch, suffix)) + REMILL_GEN_DIR, "sem_{}{}.bc".format(arch, suffix)) MakeDirsForFile(cfg_file) @@ -118,21 +118,21 @@ def BuildTests(arch, bits, suffix, has_avx, has_avx512): "--bc_out={}.bc".format(bc_file)) final_bc_file = OutputFileNameOfCommand( - os.path.join(MCSEMA_SCRIPTS_DIR, "finalize_bitcode.sh"), + os.path.join(REMILL_SCRIPTS_DIR, "finalize_bitcode.sh"), "{}.bc".format(bc_file)) # Build the test runner. run_tests = TargetExecutable( - os.path.join(MCSEMA_BUILD_DIR, "run_tests_{}{}".format(arch, suffix)), + os.path.join(REMILL_BUILD_DIR, "run_tests_{}{}".format(arch, suffix)), source_files=[ SourceFile( final_bc_file, extra_args=["-O3", "-mno-avx", "-mno-sse"]), SourceFile( - os.path.join(MCSEMA_TEST_DIR, "X86", "Tests.S"), + os.path.join(REMILL_TEST_DIR, "X86", "Tests.S"), extra_args=macro_args+target_args), SourceFile( - os.path.join(MCSEMA_TEST_DIR, "X86", "Run.cpp"), + os.path.join(REMILL_TEST_DIR, "X86", "Run.cpp"), extra_args=macro_args)], object_files=[ StaticLibrary("gflags"), diff --git a/scripts/buildsystem.py b/scripts/buildsystem.py index 2ec78613..eecdff38 100644 --- a/scripts/buildsystem.py +++ b/scripts/buildsystem.py @@ -43,9 +43,9 @@ PARSER.add_argument( default="debug") ARGS = PARSER.parse_args() -MCSEMA_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) -CC = os.path.join(MCSEMA_DIR, "third_party", "bin", "clang") -CXX = os.path.join(MCSEMA_DIR, "third_party", "bin", "clang++") +REMILL_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) +CC = os.path.join(REMILL_DIR, "third_party", "bin", "clang") +CXX = os.path.join(REMILL_DIR, "third_party", "bin", "clang++") # If we're not actually executing the commands then don't parallelize # anything. @@ -65,14 +65,14 @@ SHARED_LIB_EXT = { "win": "dll", }[OS] -MCSEMA_SRC_DIR = os.path.join(MCSEMA_DIR, "mcsema") -MCSEMA_BUILD_DIR = os.path.join(MCSEMA_DIR, "build") -MCSEMA_TEST_DIR = os.path.join(MCSEMA_DIR, "tests") -MCSEMA_GEN_DIR = os.path.join(MCSEMA_DIR, "generated") -MCSEMA_SCRIPTS_DIR = os.path.join(MCSEMA_DIR, "scripts") -MCSEMA_INCLUDE_DIR = os.path.join(MCSEMA_DIR, "third_party", "include") -MCSEMA_BIN_DIR = os.path.join(MCSEMA_DIR, "third_party", "bin") -MCSEMA_LIB_DIR = os.path.join(MCSEMA_DIR, "third_party", "lib") +REMILL_SRC_DIR = os.path.join(REMILL_DIR, "remill") +REMILL_BUILD_DIR = os.path.join(REMILL_DIR, "build") +REMILL_TEST_DIR = os.path.join(REMILL_DIR, "tests") +REMILL_GEN_DIR = os.path.join(REMILL_DIR, "generated") +REMILL_SCRIPTS_DIR = os.path.join(REMILL_DIR, "scripts") +REMILL_INCLUDE_DIR = os.path.join(REMILL_DIR, "third_party", "include") +REMILL_BIN_DIR = os.path.join(REMILL_DIR, "third_party", "bin") +REMILL_LIB_DIR = os.path.join(REMILL_DIR, "third_party", "lib") try: if 1 >= ARGS.num_workers: @@ -127,15 +127,15 @@ CXX_FLAGS = [ "-std=gnu++11", # Macros. - '-DMCSEMA_DIR="{}"'.format(MCSEMA_DIR), - '-DMCSEMA_OS="{}"'.format(OS), + '-DREMILL_DIR="{}"'.format(REMILL_DIR), + '-DREMILL_OS="{}"'.format(OS), "-D__STDC_LIMIT_MACROS", "-D__STDC_CONSTANT_MACROS", "-DGOOGLE_PROTOBUF_NO_RTTI", # Includes. - "-isystem", MCSEMA_INCLUDE_DIR, - "-I{}".format(MCSEMA_DIR), + "-isystem", REMILL_INCLUDE_DIR, + "-I{}".format(REMILL_DIR), # Output info. "-fPIC", @@ -279,7 +279,7 @@ def SourceFile(path, extra_args=[]): class StaticLibrary(_File): """Pre-compiled library within the source/library dirs.""" - SEARCH_PATHS = [MCSEMA_LIB_DIR, MCSEMA_BUILD_DIR] + SEARCH_PATHS = [REMILL_LIB_DIR, REMILL_BUILD_DIR] def __init__(self, name): super(StaticLibrary, self).__init__(self._FindLib(name)) @@ -357,18 +357,18 @@ class _Target(_File): args.extend([ "-o", path, - "-L{}".format(MCSEMA_LIB_DIR)]) + "-L{}".format(REMILL_LIB_DIR)]) if "linux" == OS: args.extend([ "-Wl,-z,now", - "-Wl,-rpath={}".format(MCSEMA_LIB_DIR), + "-Wl,-rpath={}".format(REMILL_LIB_DIR), "-Wl,-gc-sections", "-Wl,-E"]) elif "mac" == OS: args.extend([ - "-Xlinker", "-rpath", "-Xlinker", MCSEMA_LIB_DIR, + "-Xlinker", "-rpath", "-Xlinker", REMILL_LIB_DIR, "-Wl,-dead_strip",]) for src in source_files: diff --git a/scripts/compile_semantics.sh b/scripts/compile_semantics.sh index 2d8426f2..32342678 100755 --- a/scripts/compile_semantics.sh +++ b/scripts/compile_semantics.sh @@ -38,13 +38,13 @@ function compile_x86() $DIR/third_party/bin/clang++ -x c++ \ -emit-llvm -O0 -g0 -m$1 -mtune=generic $MACROS $CXXFLAGS \ -ffunction-sections -fdata-sections \ - -c $DIR/mcsema/Arch/X86/Runtime/Instructions.cpp \ + -c $DIR/remill/Arch/X86/Runtime/Instructions.cpp \ -o $DIR/generated/Arch/X86/Runtime/${FILE_NAME}_instr.bc $DIR/third_party/bin/clang++ -x c++ \ -emit-llvm -O0 -g0 -m$1 -mtune=generic $MACROS $CXXFLAGS \ -ffunction-sections -fdata-sections \ - -c $DIR/mcsema/Arch/X86/Runtime/BasicBlock.cpp \ + -c $DIR/remill/Arch/X86/Runtime/BasicBlock.cpp \ -o $DIR/generated/Arch/X86/Runtime/${FILE_NAME}_block.bc $DIR/third_party/bin/clang \ diff --git a/scripts/finalize_bitcode.sh b/scripts/finalize_bitcode.sh index 3d588de9..56fa6567 100755 --- a/scripts/finalize_bitcode.sh +++ b/scripts/finalize_bitcode.sh @@ -21,11 +21,11 @@ else exit 1 fi -BIN=`mktemp -t mcsema2_XXXXXXXXXX` +BIN=`mktemp -t remill_XXXXXXXXXX` $DIR/third_party/bin/opt \ -load $DIR/build/libFinalize.$DYLIB_SUFFIX \ - -mcsema_finalize \ + -remill_finalize \ -o=$BIN.bc $1 || { printf "${RED}Could not finalize $1${RESET}\n" > /dev/stderr exit 1 diff --git a/scripts/ida_get_cfg.py b/scripts/ida_get_cfg.py index 0e206ed2..6bc09c67 100644 --- a/scripts/ida_get_cfg.py +++ b/scripts/ida_get_cfg.py @@ -11,9 +11,9 @@ import syslog import traceback SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -MCSEMA_DIR = os.path.dirname(SCRIPT_DIR) +REMILL_DIR = os.path.dirname(SCRIPT_DIR) -sys.path.append(MCSEMA_DIR) +sys.path.append(REMILL_DIR) sys.path.append('/usr/lib/python2.7/dist-packages') sys.path.append('/usr/local/lib/python2.7/site-packages/protobuf-2.6.1-py2.7.egg') from generated.CFG import CFG_pb2 diff --git a/scripts/ida_get_cfg.sh b/scripts/ida_get_cfg.sh index 9214d8f4..ae03f953 100755 --- a/scripts/ida_get_cfg.sh +++ b/scripts/ida_get_cfg.sh @@ -1,8 +1,8 @@ #!/usr/bin/env bash -# Directory in which this script resides (i.e. McSema scripts dir). +# Directory in which this script resides (i.e. Remill scripts dir). SCRIPTS_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd ) -MCSEMA_DIR=$(dirname ${SCRIPTS_DIR}) +REMILL_DIR=$(dirname ${SCRIPTS_DIR}) RED=`tput setaf 1` RESET=`tput sgr0` @@ -26,7 +26,7 @@ elif [[ "$OSTYPE" == "darwin"* ]]; then fi fi -BIN=`mktemp -t mcsema2_XXXXXXXXXX` +BIN=`mktemp -t remill2_XXXXXXXXXX` if [[ ! -e $IDA ]] ; then printf "${RED}Could not find IDA.${RESET}\n" > /dev/stderr @@ -35,7 +35,7 @@ fi cp $1 $BIN -export PYTHONPATH=${MCSEMA_DIR}:${PYTHONPATH} +export PYTHONPATH=${REMILL_DIR}:${PYTHONPATH} export TVHEADLESS=1 "$IDA" -B -S"${SCRIPTS_DIR}/ida_get_cfg.py --output=${BIN}.cfg" $BIN &> /dev/null || { diff --git a/scripts/install.sh b/scripts/install.sh index 7cdce95a..ca243ba4 100755 --- a/scripts/install.sh +++ b/scripts/install.sh @@ -18,10 +18,10 @@ fi mkdir -p $PREFIX/bin mkdir -p $PREFIX/include -mkdir -p $PREFIX/lib/mcsema2 -mkdir -p $PREFIX/share/mcsema2 +mkdir -p $PREFIX/lib/remill +mkdir -p $PREFIX/share/remill cp $DIR/build/cfg_to_bc $PREFIX/bin -cp $DIR/build/libOptimize.* $PREFIX/lib/mcsema2 -cp $DIR/generated/sem_* $PREFIX/share/mcsema2 +cp $DIR/build/libOptimize.* $PREFIX/lib/remill +cp $DIR/generated/sem_* $PREFIX/share/remill diff --git a/scripts/optimize_bitcode.sh b/scripts/optimize_bitcode.sh index 4394c2c8..ebd3aa65 100755 --- a/scripts/optimize_bitcode.sh +++ b/scripts/optimize_bitcode.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash # Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. -# Directory in which the script dir resides (i.e. McSema root dir). +# Directory in which the script dir resides (i.e. Remill root dir). DIR=$(dirname $( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )) RED=`tput setaf 1` RESET=`tput sgr0` @@ -22,7 +22,7 @@ else exit 1 fi -BIN=`mktemp -t mcsema2_XXXXXXXXXX` +BIN=`mktemp -t remill_XXXXXXXXXX` $DIR/third_party/bin/opt -O3 -o=$BIN.opt0.bc $1 || { printf "${RED}Could not optimize $1${RESET}\n" > /dev/stderr @@ -30,7 +30,7 @@ $DIR/third_party/bin/opt -O3 -o=$BIN.opt0.bc $1 || { } $DIR/third_party/bin/opt \ - -load $DIR/build/libOptimize.$DYLIB_SUFFIX -mcsema_optimize \ + -load $DIR/build/libOptimize.$DYLIB_SUFFIX -remill_optimize \ -o=$BIN.opt1.bc $BIN.opt0.bc || { printf "${RED}Could not optimize $BIN.opt0.bc${RESET}\n" > /dev/stderr exit 1 diff --git a/scripts/run_tests_x86.sh b/scripts/run_tests_x86.sh index fedb093a..2c5de514 100755 --- a/scripts/run_tests_x86.sh +++ b/scripts/run_tests_x86.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash # Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. -# Directory in which the script dir resides (i.e. McSema root dir). +# Directory in which the script dir resides (i.e. Remill root dir). DIR=$(dirname $( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )) if [[ "$OSTYPE" == "linux-gnu" ]]; then diff --git a/tests/X86/Generate.cpp b/tests/X86/Generate.cpp index 5d7571cb..2b3f53e6 100644 --- a/tests/X86/Generate.cpp +++ b/tests/X86/Generate.cpp @@ -8,8 +8,8 @@ #include #include -#include "mcsema/Arch/X86/XED.h" -#include "mcsema/CFG/CFG.h" +#include "remill/Arch/X86/XED.h" +#include "remill/CFG/CFG.h" #include "tests/X86/Test.h" @@ -59,7 +59,7 @@ unsigned InstructionLength(const uint8_t *bytes, unsigned num_bytes) { // Decode a test and add it as a basic block to the module. // // TODO(pag): Eventually handle control-flow. -static void AddFunctionToModule(mcsema::cfg::Module *module, +static void AddFunctionToModule(remill::cfg::Module *module, const test::TestInfo &test) { const char *test_name = reinterpret_cast(test.test_name); @@ -108,7 +108,7 @@ extern "C" int main(int argc, char *argv[]) { LOG(INFO) << "Generating tests."; - auto module = new mcsema::cfg::Module; + auto module = new remill::cfg::Module; module->set_binary_path(__FILE__); for (auto i = 0U; ; ++i) { diff --git a/tests/X86/PrintSaveState.cpp b/tests/X86/PrintSaveState.cpp index dc985366..b4094d42 100644 --- a/tests/X86/PrintSaveState.cpp +++ b/tests/X86/PrintSaveState.cpp @@ -3,11 +3,11 @@ #include #include -#include "mcsema/Arch/X86/Runtime/State.h" +#include "remill/Arch/X86/Runtime/State.h" // This is used by `print_x86_save_state_asm.sh` script. The below code was // butchered together by copying the variable definitions from -// `mcsema/Arch/X86/Runtime/State.h` in `__mcsema_basic_block` and then +// `remill/Arch/X86/Runtime/State.h` in `__remill_basic_block` and then // turned into these print statements. This is mostly for writing the code for // saving native register state to somewhere that we can read it from. The code // generated by this is `#include`d into `Test.S`. This code, as well as the diff --git a/tests/X86/Run.cpp b/tests/X86/Run.cpp index f712d016..06ce5bee 100644 --- a/tests/X86/Run.cpp +++ b/tests/X86/Run.cpp @@ -18,7 +18,7 @@ #include "tests/X86/Test.h" -#include "mcsema/Arch/X86/Runtime/State.h" +#include "remill/Arch/X86/Runtime/State.h" namespace { @@ -105,47 +105,47 @@ extern void InvokeTestCase(uint64_t, uint64_t, uint64_t); // Address computation intrinsic. This is only used for non-zero // `address_space`d memory accesses. -NEVER_INLINE addr_t __mcsema_compute_address(const State &state, addr_t addr, +NEVER_INLINE addr_t __remill_compute_address(const State &state, addr_t addr, int address_space) { (void) state; (void) address_space; return addr; } -NEVER_INLINE addr_t __mcsema_create_program_counter(addr_t pc) { +NEVER_INLINE addr_t __remill_create_program_counter(addr_t pc) { return pc; } #define MAKE_RW_MEMORY(size) \ - NEVER_INLINE uint ## size ## _t __mcsema_read_memory_ ## size( \ + NEVER_INLINE uint ## size ## _t __remill_read_memory_ ## size( \ order_t, addr_t addr) {\ return AccessMemory(addr); \ } \ - NEVER_INLINE order_t __mcsema_write_memory_ ## size ( \ + NEVER_INLINE order_t __remill_write_memory_ ## size ( \ order_t order, addr_t addr, const uint ## size ## _t in) { \ AccessMemory(addr) = in; \ return order + 1; \ } #define MAKE_RW_FP_MEMORY(size) \ - NEVER_INLINE order_t __mcsema_read_memory_f ## size( \ + NEVER_INLINE order_t __remill_read_memory_f ## size( \ order_t order, addr_t addr, float ## size ## _t &vec) { \ vec = AccessMemory(addr); \ return order + 1; \ } \ - NEVER_INLINE order_t __mcsema_write_memory_f ## size (\ + NEVER_INLINE order_t __remill_write_memory_f ## size (\ order_t order, addr_t addr, const float ## size ## _t &in) { \ AccessMemory(addr) = in; \ return order + 1; \ } #define MAKE_RW_VEC_MEMORY(size) \ - NEVER_INLINE order_t __mcsema_read_memory_v ## size( \ + NEVER_INLINE order_t __remill_read_memory_v ## size( \ order_t order, addr_t addr, vec ## size ## _t &vec) { \ vec = AccessMemory(addr); \ return order + 1; \ } \ - NEVER_INLINE order_t __mcsema_write_memory_v ## size (\ + NEVER_INLINE order_t __remill_write_memory_v ## size (\ order_t order, addr_t addr, const vec ## size ## _t &in) { \ AccessMemory(addr) = in; \ return order + 1; \ @@ -169,26 +169,26 @@ MAKE_RW_VEC_MEMORY(256) MAKE_RW_VEC_MEMORY(512) -order_t __mcsema_barrier_load_load(order_t) { return 0; } -order_t __mcsema_barrier_load_store(order_t) { return 0; } -order_t __mcsema_barrier_store_load(order_t) { return 0; } -order_t __mcsema_barrier_store_store(order_t) { return 0; } -order_t __mcsema_atomic_begin(order_t) { return 0; } -order_t __mcsema_atomic_end(order_t) { return 0; } +order_t __remill_barrier_load_load(order_t) { return 0; } +order_t __remill_barrier_load_store(order_t) { return 0; } +order_t __remill_barrier_store_load(order_t) { return 0; } +order_t __remill_barrier_store_store(order_t) { return 0; } +order_t __remill_atomic_begin(order_t) { return 0; } +order_t __remill_atomic_end(order_t) { return 0; } -void __mcsema_defer_inlining(void) {} +void __remill_defer_inlining(void) {} // Control-flow intrinsics. -void __mcsema_missing_block(State &, addr_t) { +void __remill_missing_block(State &, addr_t) { // This is where we want to end up. } -void __mcsema_error(State &, addr_t) { +void __remill_error(State &, addr_t) { std::cerr << "Caught error!" << std::endl; siglongjmp(gJmpBuf, 0); } -void __mcsema_read_cpu_features(State &state, addr_t) { +void __remill_read_cpu_features(State &state, addr_t) { asm volatile( "cpuid" : "=a"(state.gpr.rax.qword), @@ -202,68 +202,68 @@ void __mcsema_read_cpu_features(State &state, addr_t) { ); } -void __mcsema_function_call(State &, addr_t) { +void __remill_function_call(State &, addr_t) { __builtin_unreachable(); } -void __mcsema_function_return(State &, addr_t) { +void __remill_function_return(State &, addr_t) { __builtin_unreachable(); } -void __mcsema_jump(State &, addr_t) { +void __remill_jump(State &, addr_t) { __builtin_unreachable(); } -addr_t __mcsema_conditional_branch( +addr_t __remill_conditional_branch( bool cond, addr_t addr_true, addr_t addr_false) { return cond ? addr_true : addr_false; } -void __mcsema_system_call(State &, addr_t) { +void __remill_system_call(State &, addr_t) { __builtin_unreachable(); } -void __mcsema_system_return(State &, addr_t) { +void __remill_system_return(State &, addr_t) { __builtin_unreachable(); } -void __mcsema_interrupt_call(State &, addr_t) { +void __remill_interrupt_call(State &, addr_t) { __builtin_unreachable(); } -void __mcsema_interrupt_return(State &, addr_t) { +void __remill_interrupt_return(State &, addr_t) { __builtin_unreachable(); } -bool __mcsema_undefined_bool(void) { +bool __remill_undefined_bool(void) { return false; } -uint8_t __mcsema_undefined_8(void) { +uint8_t __remill_undefined_8(void) { return 0; } -uint16_t __mcsema_undefined_16(void) { +uint16_t __remill_undefined_16(void) { return 0; } -uint32_t __mcsema_undefined_32(void) { +uint32_t __remill_undefined_32(void) { return 0; } -uint64_t __mcsema_undefined_64(void) { +uint64_t __remill_undefined_64(void) { return 0; } -float32_t __mcsema_undefined_f32(void) { +float32_t __remill_undefined_f32(void) { return 0.0; } -float64_t __mcsema_undefined_f64(void) { +float64_t __remill_undefined_f64(void) { return 0.0; } -void __mcsema_read_f80(const float80_t &in, float64_t &out) { +void __remill_read_f80(const float80_t &in, float64_t &out) { struct alignas(16) LongDoubleStorage { uint8_t bytes[16]; } storage; @@ -273,7 +273,7 @@ void __mcsema_read_f80(const float80_t &in, float64_t &out) { out.val = static_cast(*reinterpret_cast(&storage)); } -void __mcsema_write_f80(const float64_t &in, float80_t &out) { +void __remill_write_f80(const float64_t &in, float80_t &out) { struct alignas(16) LongDoubleStorage { uint8_t bytes[16]; } storage; @@ -286,7 +286,7 @@ void __mcsema_write_f80(const float64_t &in, float80_t &out) { // Marks `mem` as being used. This is used for making sure certain symbols are // kept around through optimization, and makes sure that optimization doesn't // perform dead-argument elimination on any of the intrinsics. -void __mcsema_mark_as_used(void *mem) { +void __remill_mark_as_used(void *mem) { asm("" :: "m"(mem)); } diff --git a/tests/X86/Tests.S b/tests/X86/Tests.S index 29e848c5..4a86abeb 100644 --- a/tests/X86/Tests.S +++ b/tests/X86/Tests.S @@ -98,7 +98,7 @@ TEST_FUNC(instr_name, num_args): ; \ /* Note: The test end address is placed *before* the `RET` so that we can * make sure that the end of a test marker is actually - * `__mcsema_error`. This is kind of a hack. + * `__remill_error`. This is kind of a hack. */ #ifdef IN_TEST_GENERATOR # define TEST_END \