New arch support

CMakeLists.txt

@@ -183,6 +183,7 @@ else()
 endif()
 
 set(REMILL_BUILD_SEMANTICS_DIR_X86 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/X86/Runtime")
+set(REMILL_BUILD_SEMANTICS_DIR_AARCH32 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/AArch32/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_AARCH64 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/AArch64/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_SPARC32 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/SPARC32/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_SPARC64 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/SPARC64/Runtime")
@@ -265,6 +266,7 @@ endif()
 target_compile_definitions(remill_settings INTERFACE
   "REMILL_INSTALL_SEMANTICS_DIR=\"${REMILL_INSTALL_SEMANTICS_DIR}/\""
   "REMILL_BUILD_SEMANTICS_DIR_X86=\"${REMILL_BUILD_SEMANTICS_DIR_X86}\""
+  "REMILL_BUILD_SEMANTICS_DIR_AARCH32=\"${REMILL_BUILD_SEMANTICS_DIR_AARCH32}\""
   "REMILL_BUILD_SEMANTICS_DIR_AARCH64=\"${REMILL_BUILD_SEMANTICS_DIR_AARCH64}\""
   "REMILL_BUILD_SEMANTICS_DIR_SPARC32=\"${REMILL_BUILD_SEMANTICS_DIR_SPARC32}\""
   "REMILL_BUILD_SEMANTICS_DIR_SPARC64=\"${REMILL_BUILD_SEMANTICS_DIR_SPARC64}\""
@@ -347,6 +349,7 @@ endif()
 set(REMILL_BC_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_bc.${static_lib_extension}")
 set(REMILL_ARCH_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch.${static_lib_extension}")
 set(REMILL_ARCH_X86_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch_x86.${static_lib_extension}")
+set(REMILL_ARCH_AARCH32_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch_aarch32.${static_lib_extension}")
 set(REMILL_ARCH_AARCH64_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch_aarch64.${static_lib_extension}")
 set(REMILL_ARCH_SPARC32_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch_sparc32.${static_lib_extension}")
 set(REMILL_ARCH_SPARC64_LIBRARY_LOCATION "${REMILL_INSTALL_LIB_DIR}/${static_lib_prefix}remill_arch_sparc64.${static_lib_extension}")

CMakeLists_vcpkg.txt

@@ -145,6 +145,7 @@ math(EXPR REMILL_LLVM_VERSION_NUMBER "${LLVM_MAJOR_VERSION} * 100 + ${LLVM_MINOR
 set(REMILL_INSTALL_SEMANTICS_DIR "${CMAKE_INSTALL_PREFIX}/${REMILL_INSTALL_SHARE_DIR}/remill/${REMILL_LLVM_VERSION}/semantics" CACHE PATH "Directory into which semantics are installed")
 
 set(REMILL_BUILD_SEMANTICS_DIR_X86 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/X86/Runtime")
+set(REMILL_BUILD_SEMANTICS_DIR_AARCH32 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/AArch32/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_AARCH64 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/AArch64/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_SPARC32 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/SPARC32/Runtime")
 set(REMILL_BUILD_SEMANTICS_DIR_SPARC64 "${CMAKE_CURRENT_BINARY_DIR}/lib/Arch/SPARC64/Runtime")
@@ -230,6 +231,7 @@ endif()
 target_compile_definitions(remill_settings INTERFACE
   "REMILL_INSTALL_SEMANTICS_DIR=\"${REMILL_INSTALL_SEMANTICS_DIR}\""
   "REMILL_BUILD_SEMANTICS_DIR_X86=\"${REMILL_BUILD_SEMANTICS_DIR_X86}\""
+  "REMILL_BUILD_SEMANTICS_DIR_AARCH32=\"${REMILL_BUILD_SEMANTICS_DIR_AARCH32}\""
   "REMILL_BUILD_SEMANTICS_DIR_AARCH64=\"${REMILL_BUILD_SEMANTICS_DIR_AARCH64}\""
   "REMILL_BUILD_SEMANTICS_DIR_SPARC32=\"${REMILL_BUILD_SEMANTICS_DIR_SPARC32}\""
   "REMILL_BUILD_SEMANTICS_DIR_SPARC64=\"${REMILL_BUILD_SEMANTICS_DIR_SPARC64}\""

cmake/remillConfig.cmake.in

@@ -65,6 +65,9 @@ if(NOT TARGET remill)
   add_library(remill_arch_x86 STATIC IMPORTED)
   set_property(TARGET remill_arch_x86 PROPERTY IMPORTED_LOCATION "@REMILL_ARCH_X86_LIBRARY_LOCATION@")
 
+  add_library(remill_arch_aarch32 STATIC IMPORTED)
+  set_property(TARGET remill_arch_aarch32 PROPERTY IMPORTED_LOCATION "@REMILL_ARCH_AARCH32_LIBRARY_LOCATION@")
+
   add_library(remill_arch_aarch64 STATIC IMPORTED)
   set_property(TARGET remill_arch_aarch64 PROPERTY IMPORTED_LOCATION "@REMILL_ARCH_AARCH64_LIBRARY_LOCATION@")
 
@@ -84,6 +87,7 @@ if(NOT TARGET remill)
     remill_os
     remill_arch
     remill_arch_x86
+    remill_arch_aarch32
     remill_arch_aarch64
     remill_arch_sparc32
     remill_arch_sparc64

include/remill/Arch/AArch32/Runtime/Operators.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2017 Trail of Bits, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace {
+
+// Read a register directly. Sometimes this is needed for suppressed operands.
+ALWAYS_INLINE static addr_t _Read(Memory *, Reg reg) {
+  return reg.aword;
+}
+
+// Write directly to a register. This is sometimes needed for suppressed
+// register operands.
+ALWAYS_INLINE static void _Write(Memory *, Reg &reg, addr_t val) {
+  reg.aword = val;
+}
+
+}  // namespace

include/remill/Arch/AArch32/Runtime/State.h

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2017 Trail of Bits, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#pragma clang diagnostic push
+#pragma clang diagnostic fatal "-Wpadded"
+
+#include "remill/Arch/Runtime/State.h"
+#include "remill/Arch/Runtime/Types.h"
+
+struct Reg final {
+  alignas(4) uint32_t dword;
+} __attribute__((packed));
+
+static_assert(sizeof(uint32_t) == sizeof(Reg), "Invalid packing of `Reg`.");
+static_assert(0 == __builtin_offsetof(Reg, dword),
+              "Invalid packing of `Reg::dword`.");
+
+struct alignas(8) GPR final {
+
+  // Prevents LLVM from casting a `GPR` into an `i64` to access `X0`.
+  volatile uint32_t _0;
+  Reg r0;
+  volatile uint32_t _1;
+  Reg r1;
+  volatile uint32_t _2;
+  Reg r2;
+  volatile uint32_t _3;
+  Reg r3;
+  volatile uint32_t _4;
+  Reg r4;
+  volatile uint32_t _5;
+  Reg r5;
+  volatile uint32_t _6;
+  Reg r6;
+  volatile uint32_t _7;
+  Reg r7;
+  volatile uint32_t _8;
+  Reg r8;
+  volatile uint32_t _9;
+  Reg r9;
+  volatile uint32_t _10;
+  Reg r10;
+  volatile uint32_t _11;
+  Reg r11;
+  volatile uint32_t _12;
+  Reg r12;
+  // R13 is SP (stack pointer)
+  volatile uint32_t _13;
+  Reg r13;
+  // R14 is LR (link register)
+  volatile uint32_t _14;
+  Reg r14;
+  // R15 is PC (program counter)
+  volatile uint32_t _15;
+  Reg r15;
+
+
+} __attribute__((packed));
+
+// System registers affecting control and status of the machine.
+struct alignas(8) SR final {
+
+  uint8_t _2;
+  uint8_t n;  //  Negative condition flag.
+  uint8_t _3;
+  uint8_t z;  //  Zero condition flag
+  uint8_t _4;
+  uint8_t c;  //  Carry condition flag
+  uint8_t _5;
+  uint8_t v;  //  Overflow condition flag
+
+  uint8_t _6;
+  uint8_t ixc;  // Inexact (cumulative).
+  uint8_t _7;
+  uint8_t ofc;  // Overflow (cumulative).
+  uint8_t _8;
+  uint8_t ufc;  // Underflow (cumulative).
+  uint8_t _9;
+  uint8_t idc;  // Input denormal (cumulative).
+  uint8_t _10;
+  uint8_t ioc;  // Invalid operation (cumulative).
+  uint8_t _11;
+  uint8_t q;  //  Sticky overflow bit.
+
+  uint8_t _padding[4];
+} __attribute__((packed));
+
+struct alignas(16) State final : public ArchState {
+
+
+  GPR gpr;  // 528 bytes.
+  SR sr;
+  uint64_t _0;
+
+
+} __attribute__((packed));
+
+using AArch32State = State;
+
+#pragma clang diagnostic pop

include/remill/Arch/AArch32/Runtime/Types.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2017 Trail of Bits, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+// We need this for boolean conditions, used in branch instructions.
+typedef RnW<uint8_t> R8W;
+
+typedef RnW<uint8_t> R8W;
+typedef RnW<uint16_t> R16W;
+
+// Note: AArch64 zero-extends like x86, but the smallest register size that
+// can be accessed is 32 bits.
+typedef RnW<uint32_t> R32W;
+
+typedef Rn<uint8_t> R8;
+//typedef Rn<uint16_t> R16;
+typedef Rn<uint32_t> R32;
+
+typedef Vn<vec8_t> V8;
+typedef Vn<vec16_t> V16;
+typedef Vn<vec32_t> V32;
+typedef Vn<vec64_t> V64;
+typedef Vn<vec128_t> V128;
+typedef VnW<vec128_t> V128W;
+
+typedef MnW<uint8_t> M8W;
+typedef MnW<uint16_t> M16W;
+typedef MnW<uint32_t> M32W;
+typedef MnW<uint64_t> M64W;
+
+typedef MVnW<vec8_t> MV8W;
+typedef MVnW<vec16_t> MV16W;
+typedef MVnW<vec32_t> MV32W;
+typedef MVnW<vec64_t> MV64W;
+typedef MVnW<vec128_t> MV128W;
+
+typedef Mn<uint8_t> M8;
+typedef Mn<uint16_t> M16;
+
+typedef Mn<uint32_t> M32;
+typedef Mn<uint64_t> M64;
+
+typedef MVn<vec8_t> MV8;
+typedef MVn<vec16_t> MV16;
+typedef MVn<vec32_t> MV32;
+typedef MVn<vec64_t> MV64;
+typedef MVn<vec128_t> MV128;
+typedef MVn<vec256_t> MV256;
+
+typedef In<uint8_t> I8;
+typedef In<uint16_t> I16;
+typedef In<uint32_t> I32;
+
+typedef In<float32_t> F32;
+typedef In<float64_t> F64;
+
+typedef In<addr_t> PC;
+typedef In<addr_t> ADDR;

include/remill/Arch/Arch.h

@@ -246,6 +246,7 @@ class Arch {
 
   bool IsX86(void) const;
   bool IsAMD64(void) const;
+  bool IsAArch32(void) const;
   bool IsAArch64(void) const;
   bool IsSPARC32(void) const;
   bool IsSPARC64(void) const;
@@ -287,6 +288,10 @@ class Arch {
   static ArchPtr GetX86(llvm::LLVMContext *context, OSName os,
                         ArchName arch_name);
 
+  // Defined in `lib/Arch/AArch32/Arch.cpp`.
+  static ArchPtr GetAArch32(llvm::LLVMContext *context, OSName os,
+                            ArchName arch_name);
+
   // Defined in `lib/Arch/AArch64/Arch.cpp`.
   static ArchPtr GetAArch64(llvm::LLVMContext *context, OSName os,
                             ArchName arch_name);