riscv support

bindings/gumjs/generate-bindings.py

@@ -24,6 +24,7 @@ def generate_and_write_bindings(output_dir, source_dir):
         ("arm", "thumb"),
         ("arm64", "arm64"),
         ("mips", "mips"),
+        ("riscv", "riscv"),
     ]
 
     tsds = {}
@@ -82,6 +83,7 @@ def generate_umbrella(runtime, name, section, flavor_combos):
         "arm": "HAVE_ARM",
         "arm64": "HAVE_ARM64",
         "mips": "HAVE_MIPS",
+        "riscv": "HAVE_RISCV",
     }
 
     current_arch = None
@@ -2327,6 +2329,21 @@ def generate_v8_enum_parser(name, type, prefix, values):
             "30", "31",
         ]),
     ],
+    "riscv": [
+        ("riscv_register", "riscv_reg", "RISCV_REG_", [
+            "zero", "ra", "sp", "gp", "tp",
+            "t0", "t1", "t2",
+            "s0", "s1",
+            "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
+            "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11",
+            "t3", "t4", "t5", "t6",
+            "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
+            "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
+            "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
+            "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
+            "pc",
+        ]),
+    ],
 }
 
 def generate_conversion_methods(component, generate_parser):
@@ -3028,7 +3045,7 @@ def __init__(self, type, name, arch):
         name_raw = None
         converter = None
 
-        if type in ("GumX86Reg", "arm_reg", "arm64_reg", "mips_reg"):
+        if type in ("GumX86Reg", "arm_reg", "arm64_reg", "mips_reg", "riscv_reg"):
             self.type_raw = "const gchar *"
             self.type_format = "s"
             self.type_ts = to_camel_case("x86_register" if type == "GumX86Reg" else type.replace("_reg", "_register"), start_high=True)

bindings/gumjs/generate-runtime.py

@@ -225,6 +225,8 @@ def generate_runtime_cmodule(
         writer_arch = "x86"
     elif arch.startswith("mips"):
         writer_arch = "mips"
+    elif arch.startswith("riscv"):
+        writer_arch = "riscv"
     else:
         writer_arch = arch
     capstone_arch = writer_arch

bindings/gumjs/gumcmodule.c

@@ -296,6 +296,8 @@ gum_cmodule_enumerate_builtin_defines (GumFoundCDefineFunc func,
   gum_emit_builtin_define ("HAVE_ARM64", NULL, func, user_data);
 #elif defined (HAVE_MIPS)
   gum_emit_builtin_define ("HAVE_MIPS", NULL, func, user_data);
+#elif defined (HAVE_RISCV)
+  gum_emit_builtin_define ("HAVE_RISCV", NULL, func, user_data);
 #endif
 
   gum_emit_builtin_define_str ("G_GINT16_MODIFIER", G_GINT16_MODIFIER,

bindings/gumjs/gumquickcore.c

@@ -1101,6 +1101,41 @@ GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (s7)
 
 GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (k0)
 GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (k1)
+#elif defined (HAVE_RISCV)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (pc)
+
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x0)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x1)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x2)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x3)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x4)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x5)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x6)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x7)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x8)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x9)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x10)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x11)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x12)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x13)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x14)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x15)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x16)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x17)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x18)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x19)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x20)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x21)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x22)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x23)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x24)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x25)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x26)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x27)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x28)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x29)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x30)
+GUM_DEFINE_CPU_CONTEXT_ACCESSOR_GPR (x31)
 #endif
 
 static const JSCFunctionListEntry gumjs_cpu_context_entries[] =
@@ -1425,6 +1460,41 @@ static const JSCFunctionListEntry gumjs_cpu_context_entries[] =
 
   GUM_EXPORT_CPU_CONTEXT_ACCESSOR (k0),
   GUM_EXPORT_CPU_CONTEXT_ACCESSOR (k1),
+#elif defined (HAVE_RISCV)
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (pc),
+
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x0),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x1),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x2),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x3),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x4),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x5),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x6),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x7),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x8),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x9),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x10),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x11),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x12),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x13),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x14),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x15),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x16),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x17),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x18),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x19),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x20),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x21),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x22),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x23),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x24),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x25),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x26),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x27),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x28),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x29),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x30),
+  GUM_EXPORT_CPU_CONTEXT_ACCESSOR (x31),
 #endif
 
   JS_CFUNC_DEF ("toJSON", 0, gumjs_cpu_context_to_json),
@@ -4992,6 +5062,10 @@ gum_quick_native_callback_invoke (ffi_cif * cif,
   asm ("move %0, $ra" : "=r" (return_address));
   asm ("move %0, $sp" : "=r" (stack_pointer));
   asm ("move %0, $fp" : "=r" (frame_pointer));
+#elif defined (HAVE_RISCV)
+  asm ("mv %0, ra" : "=r" (return_address));
+  asm ("mv %0, sp" : "=r" (stack_pointer));
+  asm ("mv %0, s0" : "=r" (frame_pointer));
 #endif
 
   _gum_quick_scope_enter (&scope, core);
@@ -6267,6 +6341,9 @@ gum_quick_core_setup_atoms (GumQuickCore * self)
   GUM_SETUP_ATOM (vectorIndex);
 #elif defined (HAVE_MIPS)
   GUM_SETUP_ATOM (disp);
+#elif defined (HAVE_RISCV)
+  GUM_SETUP_ATOM (base);
+  GUM_SETUP_ATOM (disp);
 #endif
 
 #undef GUM_SETUP_ATOM
@@ -6343,6 +6420,9 @@ gum_quick_core_teardown_atoms (GumQuickCore * self)
   GUM_TEARDOWN_ATOM (vectorIndex);
 #elif defined (HAVE_MIPS)
   GUM_TEARDOWN_ATOM (disp);
+#elif defined (HAVE_RISCV)
+  GUM_TEARDOWN_ATOM (base);
+  GUM_TEARDOWN_ATOM (disp);
 #endif
 
 #undef GUM_TEARDOWN_ATOM

bindings/gumjs/gumquickcore.h

@@ -191,6 +191,9 @@ struct _GumQuickCore
   GUM_DECLARE_ATOM (vectorIndex);
 #elif defined (HAVE_MIPS)
   GUM_DECLARE_ATOM (disp);
+#elif defined (HAVE_RISCV)
+  GUM_DECLARE_ATOM (base);
+  GUM_DECLARE_ATOM (disp);
 #endif
 
 #undef GUM_DECLARE_ATOM

bindings/gumjs/gumquickinstruction.c

@@ -1075,6 +1075,85 @@ gum_mips_parse_memory_operand_value (JSContext * ctx,
   return val;
 }
 
+#elif defined (HAVE_RISCV)
+
+static JSValue
+gum_parse_operands (JSContext * ctx,
+                    const cs_insn * insn,
+                    csh cs,
+                    GumQuickCore * core)
+{
+  JSValue result;
+  const cs_riscv * riscv = &insn->detail->riscv;
+  uint8_t i;
+
+  result = JS_NewArray (ctx);
+
+  for (i = 0; i != riscv->op_count; i++)
+  {
+    const cs_riscv_op * op = &riscv->operands[i];
+    JSValue op_obj;
+    const gchar * type;
+    JSValue val;
+
+    op_obj = JS_NewObject (ctx);
+
+    switch (op->type)
+    {
+      case RISCV_OP_REG:
+        type = "reg";
+        val = JS_NewString (ctx, cs_reg_name (cs, op->reg));
+        break;
+      case RISCV_OP_IMM:
+        type = "imm";
+        val = JS_NewInt64 (ctx, op->imm);
+        break;
+      case RISCV_OP_MEM:
+        type = "mem";
+        val = gum_riscv_parse_memory_operand_value (ctx, &op->mem, cs, core);
+        break;
+      default:
+        g_assert_not_reached ();
+    }
+
+    JS_DefinePropertyValue (ctx, op_obj,
+        GUM_QUICK_CORE_ATOM (core, type),
+        JS_NewString (ctx, type),
+        JS_PROP_C_W_E);
+    JS_DefinePropertyValue (ctx, op_obj,
+        GUM_QUICK_CORE_ATOM (core, value),
+        val,
+        JS_PROP_C_W_E);
+
+    JS_DefinePropertyValueUint32 (ctx, result, i, op_obj, JS_PROP_C_W_E);
+  }
+
+  return result;
+}
+
+static JSValue
+gum_riscv_parse_memory_operand_value (JSContext * ctx,
+                                      const riscv_op_mem * mem,
+                                      csh cs,
+                                      GumQuickCore * core)
+{
+  JSValue val = JS_NewObject (ctx);
+
+  if (mem->base != RISCV_REG_INVALID)
+  {
+    JS_DefinePropertyValue (ctx, val,
+        GUM_QUICK_CORE_ATOM (core, base),
+        JS_NewString (ctx, cs_reg_name (cs, mem->base)),
+        JS_PROP_C_W_E);
+  }
+  JS_DefinePropertyValue (ctx, val,
+      GUM_QUICK_CORE_ATOM (core, disp),
+      JS_NewInt64 (ctx, mem->disp),
+      JS_PROP_C_W_E);
+
+  return val;
+}
+
 #endif
 
 static JSValue

bindings/gumjs/gumquickprocess.c

@@ -26,6 +26,8 @@
 # define GUM_SCRIPT_ARCH "arm64"
 #elif defined (HAVE_MIPS)
 # define GUM_SCRIPT_ARCH "mips"
+#elif defined (HAVE_RISCV)
+# define GUM_SCRIPT_ARCH "riscv"
 #endif
 
 #if defined (HAVE_LINUX)

bindings/gumjs/gumv8core.cpp

@@ -3947,6 +3947,10 @@ gum_v8_native_callback_invoke (ffi_cif * cif,
   asm ("move %0, $ra" : "=r" (return_address));
   asm ("move %0, $sp" : "=r" (stack_pointer));
   asm ("move %0, $fp" : "=r" (frame_pointer));
+#elif defined (HAVE_RISCV)
+  asm ("mv %0, ra" : "=r" (return_address));
+  asm ("mv %0, sp" : "=r" (stack_pointer));
+  asm ("mv %0, s0" : "=r" (frame_pointer));
 #endif
 
   auto self = (GumV8NativeCallback *) user_data;
@@ -4009,6 +4013,14 @@ gum_v8_native_callback_invoke (ffi_cif * cif,
     cpu_context.lr = return_address;
     cpu_context.sp = stack_pointer;
     cpu_context.fp = frame_pointer;
+#elif defined (HAVE_MIPS)
+    cpu_context.ra = return_address;
+    cpu_context.sp = stack_pointer;
+    cpu_context.fp = frame_pointer;
+#elif defined (HAVE_RISCV)
+    cpu_context.x1 = return_address;
+    cpu_context.x2 = stack_pointer;
+    cpu_context.x8 = frame_pointer;
 #endif
 
     jcc = gum_v8_callback_context_new_persistent (self->core, &cpu_context,

bindings/gumjs/gumv8instruction.cpp

@@ -989,6 +989,77 @@ gum_mips_parse_memory_operand_value (const mips_op_mem * mem,
   return result;
 }
 
+#elif defined (HAVE_RISCV)
+
+static Local<Array>
+gum_parse_operands (const cs_insn * insn,
+                    GumV8Instruction * module)
+{
+  auto core = module->core;
+  auto isolate = core->isolate;
+  auto context = isolate->GetCurrentContext ();
+  auto capstone = module->capstone;
+  auto riscv = &insn->detail->riscv;
+
+  uint8_t op_count = riscv->op_count;
+
+  auto elements = Array::New (isolate, op_count);
+
+  for (uint8_t op_index = 0; op_index != op_count; op_index++)
+  {
+    auto op = &riscv->operands[op_index];
+
+    auto element = Object::New (isolate);
+
+    auto type_key = "type";
+    auto value_key = "value";
+
+    switch (op->type)
+    {
+      case RISCV_OP_REG:
+        _gum_v8_object_set_ascii (element, type_key, "reg", core);
+        _gum_v8_object_set_ascii (element, value_key,
+            cs_reg_name (capstone, op->reg), core);
+        break;
+      case RISCV_OP_IMM:
+        _gum_v8_object_set_ascii (element, type_key, "imm", core);
+        _gum_v8_object_set_int (element, value_key, op->imm, core);
+        break;
+      case RISCV_OP_MEM:
+        _gum_v8_object_set_ascii (element, type_key, "mem", core);
+        _gum_v8_object_set (element, value_key,
+            gum_riscv_parse_memory_operand_value (&op->mem, module), core);
+        break;
+      default:
+        g_assert_not_reached ();
+    }
+
+    elements->Set (context, op_index, element).Check ();
+  }
+
+  return elements;
+}
+
+static Local<Object>
+gum_riscv_parse_memory_operand_value (const riscv_op_mem * mem,
+                                       GumV8Instruction * module)
+{
+  auto core = module->core;
+  auto capstone = module->capstone;
+
+  auto result = Object::New (core->isolate);
+
+  if (mem->base != RISCV_REG_INVALID)
+  {
+    _gum_v8_object_set_ascii (result, "base",
+        cs_reg_name (capstone, mem->base), core);
+  }
+
+  _gum_v8_object_set_int (result, "disp", mem->disp, core);
+
+  return result;
+}
+
 #endif
 
 static Local<Array>

bindings/gumjs/gumv8process.cpp

@@ -32,6 +32,8 @@
 # define GUM_SCRIPT_ARCH "arm64"
 #elif defined (HAVE_MIPS)
 # define GUM_SCRIPT_ARCH "mips"
+#elif defined (HAVE_RISCV)
+# define GUM_SCRIPT_ARCH "riscv"
 #endif
 
 #if defined (HAVE_LINUX)