jit: Implement arm32 instruction decoding logic

Introduces the core Arm32 decoder, including the instruction parsing
mechanism and an initial set of defined instructions.

Signed-off-by: Ronald Caesar <github43132@proton.me>

Author: GloriousTacoo

CMakeLists.txt

@@ -97,7 +97,6 @@ add_executable(Pound
 
 add_subdirectory(3rd_Party)
 add_subdirectory(src/common)
-add_subdirectory(src/frontend)
 add_subdirectory(src/host)
 add_subdirectory(src/jit)
 add_subdirectory(src/pvm)
@@ -110,7 +109,7 @@ add_subdirectory(src/targets/switch1/hardware)
 include(TestBigEndian)
 TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
 
-list(APPEND POUND_PROJECT_TARGETS common frontend host pvm)
+list(APPEND POUND_PROJECT_TARGETS common host pvm)
 foreach(TARGET ${POUND_PROJECT_TARGETS})
     # Apply Endianness definitions to all our targets.
     if(WORDS_BIGENDIAN)
@@ -149,7 +148,6 @@ set_property(TARGET Pound PROPERTY CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TR
 
 target_link_libraries(Pound PRIVATE
     common
-    frontend
     host
     jit
     pvm

src/jit/decoder/arm32.cpp

@@ -7,17 +7,16 @@
 
 namespace pound::jit::decoder
 {
-/* Increase value as more instructions get implemented */
-#define INSTRUCTION_ARRAY_CAPACITY 4
-arm32_decoder_t g_arm32_decoder = {};
+#define INSTRUCTION_ARRAY_CAPACITY 261
+
+#define HASH_TABLE_INVALID_INDEX 0xFFFF
 
 /*
  * ============================================================================
  *                              Foward Declarations
  * ============================================================================
  */
-void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring, arm32_handler_fn handler);
-void arm32_ADD_imm_handler(arm32_decoder_t* decoder, arm32_instruction_t instruction);
+void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring);
 
 void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expected);
 void arm32_grow_instructions_array(arm32_decoder_t* decoder, size_t new_capacity);
@@ -38,7 +37,7 @@ void arm32_init(pound::host::memory::arena_t allocator, arm32_decoder_t* decoder
     /* Setup Instructions array.*/
     size_t instructions_array_size = INSTRUCTION_ARRAY_CAPACITY * sizeof(arm32_instruction_info_t);
     PVM_ASSERT(instructions_array_size <= decoder->allocator.capacity);
-    LOG_TRACE("Growing instructions array to %d bytes", instructions_array_size);
+    LOG_TRACE("Allocated %d bytes to instructions array", instructions_array_size);
 
     void* new_ptr = pound::host::memory::arena_allocate(&decoder->allocator, instructions_array_size);
     PVM_ASSERT(nullptr != new_ptr);
@@ -47,57 +46,55 @@ void arm32_init(pound::host::memory::arena_t allocator, arm32_decoder_t* decoder
     decoder->instruction_capacity = INSTRUCTION_ARRAY_CAPACITY;
 
     /* Add all Arm32 instructions */
-#define INST(fn, name, bitstring) arm32_add_instruction(decoder, name, bitstring, &arm32_##fn##_handler);
+#define INST(fn, name, bitstring) arm32_add_instruction(decoder, name, bitstring);
 #include "./arm32.inc"
 #undef INST
 }
 
-void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring, arm32_handler_fn handler)
+arm32_instruction_info_t* arm32_decode(arm32_decoder_t* decoder, uint32_t instruction)
+{
+    for (size_t i = 0; i < decoder->instruction_count; ++i)
+    {
+        arm32_instruction_info_t* info = &decoder->instructions[i];
+        if ((instruction & info->mask) == info->expected)
+        {
+            LOG_TRACE("Instruction found for 0x%08X: %s", instruction, info->name);
+            return info;
+        }
+    }
+    PVM_ASSERT_MSG(false, "No instruction found for 0x%08X", instruction);
+}
+
+/*
+ * ============================================================================
+ *                          Private Functions
+ * ============================================================================
+ */
+
+void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring)
 {
     PVM_ASSERT(nullptr != decoder);
     PVM_ASSERT(nullptr != decoder->allocator.data);
     PVM_ASSERT(nullptr != name);
     PVM_ASSERT(nullptr != bitstring);
     PVM_ASSERT(decoder->instruction_count < decoder->instruction_capacity);
 
-    arm32_opcode_t mask = 0;
-    arm32_opcode_t expected = 0;
+    uint32_t mask = 0;
+    uint32_t expected = 0;
     arm32_parse_bitstring(bitstring, &mask, &expected);
 
     arm32_instruction_info_t* info = &decoder->instructions[decoder->instruction_count];
+    PVM_ASSERT(nullptr != info);
     info->name = name;
     info->mask = mask;
     info->expected = expected;
-    info->handler = handler;
-
-    /* Calculate priority based on number of fixed bits. */
-    info->priority = 0;
-    for (int i = 0; i < 32; ++i)
-    {
-        if ((mask >> i) & 1)
-        {
-            ++info->priority;
-        }
-    }
 
     ++decoder->instruction_count;
-    LOG_TRACE("========================================");
+
     LOG_TRACE("Instruction Registered: %s", info->name);
     LOG_TRACE("Mask:      0x%08X", info->mask);
     LOG_TRACE("Expected:  0x%08X", info->expected);
-    LOG_TRACE("Priority:  %d", info->priority);
-    LOG_TRACE("========================================");
-
-
-    /* TODO(GloriousTacoo:jit): Add instruction to lookup table. */
 }
-void arm32_ADD_imm_handler(arm32_decoder_t* decoder, arm32_instruction_t instruction) {}
-
-/*
- * ============================================================================
- *                          Private Functions
- * ============================================================================
- */
 
 void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expected)
 {
@@ -109,7 +106,7 @@ void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expe
     *mask = 0;
     *expected = 0;
     uint8_t instruction_size_bits = 32;
-    for (int i = 0; (i < instruction_size_bits) && (bitstring[i] != '\0'); ++i)
+    for (unsigned int i = 0; (i < instruction_size_bits) && (bitstring[i] != '\0'); ++i)
     {
         uint32_t bit_position = 31 - i;
         switch (bitstring[i])
@@ -120,19 +117,9 @@ void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expe
             case '1':
                 *mask |= (1U << bit_position);
                 *expected |= (1U << bit_position);
-                break;
-            case 'c':
-            case 'n':
-            case 'd':
-            case 'r':
-            case 'v':
-            case 's':
-            case 'S':
-                break;
             default:
-                PVM_ASSERT_MSG(false, "Invalid bitstring character: %c", bitstring[i]);
+                break;
         }
     }
 }
-
 }  // namespace pound::jit::decoder

src/jit/decoder/arm32.h

@@ -7,22 +7,14 @@
 
 namespace pound::jit::decoder
 {
-typedef uint32_t arm32_opcode_t;
-typedef uint32_t arm32_instruction_t;
-
 typedef struct arm32_decoder arm32_decoder_t;
-typedef void (*arm32_handler_fn)(arm32_decoder_t* decoder, arm32_instruction_t instruction);
+typedef void (*arm32_handler_fn)(arm32_decoder_t* decoder, uint32_t instruction);
 
 typedef struct
 {
     const char* name;
-    arm32_opcode_t mask;
-    arm32_opcode_t expected;
-    arm32_handler_fn handler;
-
-    /* Use to order instructions in the lookup table. The more specific
-     * instructions are checked first */
-    uint8_t priority;
+    uint32_t mask;
+    uint32_t expected;
 } arm32_instruction_info_t;
 
 struct arm32_decoder
@@ -31,23 +23,11 @@ struct arm32_decoder
     arm32_instruction_info_t* instructions;
     size_t instruction_count;
     size_t instruction_capacity;
-
-    struct
-    {
-        arm32_instruction_info_t** bucket;
-        size_t count;
-        size_t capacity;
-    } lookup_table[4096]; /* 2^12 entries. */
 };
 
 extern arm32_decoder_t g_arm32_decoder;
 
 void arm32_init(pound::host::memory::arena_t allocator, arm32_decoder_t* decoder);
-
-void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, arm32_opcode_t mask, arm32_opcode_t expected,
-                           arm32_handler_fn handler);
-void arm32_ADD_imm_handler(arm32_decoder_t* decoder, arm32_instruction_t instruction);
-
-
-}  // namespace pound::jit::decoder
-#endif  // POUND_JIT_DECODER_ARM32_H
+arm32_instruction_info_t* arm32_decode(arm32_decoder_t* decoder, uint32_t instruction);
+}
+#endif  // POUND_JIT_DECODER_ARM32_H