libdrgn: replace arch frame_registers with callbacks

We currently unwind from pt_regs and NT_PRSTATUS using an array of
register definitions. It's more flexible and more efficient to do this
with an architecture-specific callback. For x86-64, this change also
makes us depend on the binary layout rather than member names of struct
pt_regs, but that shouldn't matter unless people are defining their own,
weird struct pt_regs.

Author: osandov

libdrgn/arch_x86_64.c.in

@@ -107,25 +107,76 @@ bnd2
 bnd3
 %%
 
-static const struct drgn_frame_register frame_registers_x86_64[] = {
-	{ DRGN_REGISTER_X86_64_rax, 8, 192, "ax", "rax", },
-	{ DRGN_REGISTER_X86_64_rdx, 8, 208, "dx", "rdx", },
-	{ DRGN_REGISTER_X86_64_rcx, 8, 200, "cx", "rcx", },
-	{ DRGN_REGISTER_X86_64_rbx, 8, 152, "bx", "rbx", },
-	{ DRGN_REGISTER_X86_64_rsi, 8, 216, "si", "rsi", },
-	{ DRGN_REGISTER_X86_64_rdi, 8, 224, "di", "rdi", },
-	{ DRGN_REGISTER_X86_64_rbp, 8, 144, "bp", "rbp", },
-	{ DRGN_REGISTER_X86_64_rsp, 8, 264, "sp", "rsp", },
-	{ DRGN_REGISTER_X86_64_r8, 8, 184, "r8", },
-	{ DRGN_REGISTER_X86_64_r9, 8, 176, "r9", },
-	{ DRGN_REGISTER_X86_64_r10, 8, 168, "r10", },
-	{ DRGN_REGISTER_X86_64_r11, 8, 160, "r11", },
-	{ DRGN_REGISTER_X86_64_r12, 8, 136, "r12", },
-	{ DRGN_REGISTER_X86_64_r13, 8, 128, "r13", },
-	{ DRGN_REGISTER_X86_64_r14, 8, 120, "r14", },
-	{ DRGN_REGISTER_X86_64_r15, 8, 112, "r15", },
-	{ DRGN_REGISTER_X86_64_rip, 8, 240, "ip", "rip", },
-};
+/*
+ * The in-kernel struct pt_regs, UAPI struct pt_regs, elf_gregset_t, and struct
+ * user_regs_struct all have the same layout.
+ */
+static struct drgn_error *
+set_initial_registers_from_struct_x86_64(Dwfl_Thread *thread, const void *regs,
+					 size_t size, bool bswap)
+{
+	Dwarf_Word dwarf_regs[17];
+
+	if (size < 160) {
+		return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
+					 "registers are truncated");
+	}
+
+#define READ_REGISTER(n) ({					\
+	uint64_t reg;						\
+	memcpy(&reg, (uint64_t *)regs + n, sizeof(reg));	\
+	bswap ? bswap_64(reg) : reg;				\
+})
+	dwarf_regs[0] = READ_REGISTER(10); /* rax */
+	dwarf_regs[1] = READ_REGISTER(12); /* rdx */
+	dwarf_regs[2] = READ_REGISTER(11); /* rcx */
+	dwarf_regs[3] = READ_REGISTER(5); /* rbx */
+	dwarf_regs[4] = READ_REGISTER(13); /* rsi */
+	dwarf_regs[5] = READ_REGISTER(14); /* rdi */
+	dwarf_regs[6] = READ_REGISTER(4); /* rbp */
+	dwarf_regs[7] = READ_REGISTER(19); /* rsp */
+	dwarf_regs[8] = READ_REGISTER(9); /* r8 */
+	dwarf_regs[9] = READ_REGISTER(8); /* r9 */
+	dwarf_regs[10] = READ_REGISTER(7); /* r10 */
+	dwarf_regs[11] = READ_REGISTER(6); /* r11 */
+	dwarf_regs[12] = READ_REGISTER(3); /* r12 */
+	dwarf_regs[13] = READ_REGISTER(2); /* r13 */
+	dwarf_regs[14] = READ_REGISTER(1); /* r14 */
+	dwarf_regs[15] = READ_REGISTER(0); /* r15 */
+	dwarf_regs[16] = READ_REGISTER(16); /* rip */
+#undef READ_REGISTER
+
+	if (!dwfl_thread_state_registers(thread, 0, 17, dwarf_regs))
+		return drgn_error_libdwfl();
+	return NULL;
+}
+
+static struct drgn_error *
+pt_regs_set_initial_registers_x86_64(Dwfl_Thread *thread,
+				     const struct drgn_object *obj)
+{
+	bool bswap = (obj->value.little_endian !=
+		      (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__));
+	return set_initial_registers_from_struct_x86_64(thread,
+							drgn_object_buffer(obj),
+							drgn_buffer_object_size(obj),
+							bswap);
+}
+
+static struct drgn_error *
+prstatus_set_initial_registers_x86_64(struct drgn_program *prog,
+				      Dwfl_Thread *thread, const void *prstatus,
+				      size_t size)
+{
+	if (size < 112) {
+		return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
+					 "NT_PRSTATUS is truncated");
+	}
+	return set_initial_registers_from_struct_x86_64(thread,
+							(char *)prstatus + 112,
+							size - 112,
+							drgn_program_bswap(prog));
+}
 
 static inline struct drgn_error *read_register(struct drgn_object *reg_obj,
 					       struct drgn_object *frame_obj,
@@ -485,8 +536,8 @@ const struct drgn_architecture_info arch_info_x86_64 = {
 	ARCHITECTURE_INFO,
 	.default_flags = (DRGN_PLATFORM_IS_64_BIT |
 			  DRGN_PLATFORM_IS_LITTLE_ENDIAN),
-	.frame_registers = frame_registers_x86_64,
-	.num_frame_registers = ARRAY_SIZE(frame_registers_x86_64),
+	.pt_regs_set_initial_registers = pt_regs_set_initial_registers_x86_64,
+	.prstatus_set_initial_registers = prstatus_set_initial_registers_x86_64,
 	.linux_kernel_set_initial_registers =
 		linux_kernel_set_initial_registers_x86_64,
 	.linux_kernel_get_page_offset = linux_kernel_get_page_offset_x86_64,

libdrgn/platform.h

@@ -13,17 +13,6 @@ struct drgn_register {
 	enum drgn_register_number number;
 };
 
-/* Register in NT_PRSTATUS note or struct pt_regs used for stack unwinding. */
-struct drgn_frame_register {
-	enum drgn_register_number number;
-	size_t size;
-	size_t prstatus_offset;
-	/* Name used in the kernel. */
-	const char *pt_regs_name;
-	/* Name used for the UAPI, if different from above. */
-	const char *pt_regs_name2;
-};
-
 /* Page table iterator. */
 struct pgtable_iterator {
 	struct drgn_program *prog;
@@ -69,8 +58,13 @@ struct drgn_architecture_info {
 	const struct drgn_register *registers;
 	size_t num_registers;
 	const struct drgn_register *(*register_by_name)(const char *name);
-	const struct drgn_frame_register *frame_registers;
-	size_t num_frame_registers;
+	/* Given pt_regs as a value buffer object. */
+	struct drgn_error *(*pt_regs_set_initial_registers)(Dwfl_Thread *,
+							    const struct drgn_object *);
+	struct drgn_error *(*prstatus_set_initial_registers)(struct drgn_program *,
+							     Dwfl_Thread *,
+							     const void *,
+							     size_t);
 	struct drgn_error *(*linux_kernel_set_initial_registers)(Dwfl_Thread *,
 								 const struct drgn_object *);
 	struct drgn_error *(*linux_kernel_get_page_offset)(struct drgn_program *,

libdrgn/stack_trace.c

@@ -241,51 +241,6 @@ drgn_get_stack_trace_obj(struct drgn_object *res, struct drgn_program *prog,
 				 ", struct task_struct *" : "");
 }
 
-static struct drgn_error *
-drgn_pt_regs_set_initial_registers(Dwfl_Thread *thread,
-				   struct drgn_platform *platform,
-				   const struct drgn_object *pt_regs)
-{
-	struct drgn_error *err;
-	struct drgn_object obj;
-	size_t i;
-
-	drgn_object_init(&obj, pt_regs->prog);
-
-	if (!platform->arch->num_frame_registers) {
-		return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
-					 "pt_regs stack unwinding is not supported for %s architecture",
-					 platform->arch->name);
-	}
-
-	for (i = 0; i < platform->arch->num_frame_registers; i++) {
-		const struct drgn_frame_register *reg;
-		union drgn_value value;
-		Dwarf_Word word;
-
-		reg = &platform->arch->frame_registers[i];
-		err = drgn_object_member(&obj, pt_regs, reg->pt_regs_name);
-		if (err && err->code == DRGN_ERROR_LOOKUP &&
-		    reg->pt_regs_name2) {
-			drgn_error_destroy(err);
-			err = drgn_object_member(&obj, pt_regs,
-						 reg->pt_regs_name2);
-		}
-		if (err)
-			goto out;
-		err = drgn_object_read_integer(&obj, &value);
-		if (err)
-			goto out;
-		word = value.uvalue;
-		if (!dwfl_thread_state_registers(thread, reg->number, 1, &word))
-			return drgn_error_libdwfl();
-	}
-	err = NULL;
-out:
-	drgn_object_deinit(&obj);
-	return err;
-}
-
 static struct drgn_error *
 drgn_get_task_pid(const struct drgn_object *task, uint32_t *ret)
 {
@@ -306,60 +261,6 @@ drgn_get_task_pid(const struct drgn_object *task, uint32_t *ret)
 	return err;
 }
 
-static struct drgn_error *
-drgn_prstatus_set_initial_registers(Dwfl_Thread *thread,
-				    struct drgn_platform *platform,
-				    struct string *prstatus)
-{
-	bool bswap = (!!(platform->flags & DRGN_PLATFORM_IS_LITTLE_ENDIAN) !=
-		      (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__));
-	size_t i;
-
-	if (!platform->arch->num_frame_registers) {
-		return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
-					 "core dump stack unwinding is not supported for %s architecture",
-					 platform->arch->name);
-	}
-
-	for (i = 0; i < platform->arch->num_frame_registers; i++) {
-		const struct drgn_frame_register *reg;
-		const char *p;
-		Dwarf_Word word;
-
-		reg = &platform->arch->frame_registers[i];
-		if (prstatus->len < reg->prstatus_offset + reg->size) {
-			return drgn_error_create(DRGN_ERROR_OTHER,
-						 "NT_PRSTATUS is truncated");
-		}
-		p = prstatus->str + reg->prstatus_offset;
-		switch (reg->size) {
-		case 4: {
-			uint32_t tmp;
-
-			memcpy(&tmp, p, sizeof(tmp));
-			if (bswap)
-				tmp = bswap_32(tmp);
-			word = tmp;
-			break;
-		}
-		case 8: {
-			uint64_t tmp;
-
-			memcpy(&tmp, p, sizeof(tmp));
-			if (bswap)
-				tmp = bswap_64(tmp);
-			word = tmp;
-			break;
-		}
-		default:
-			UNREACHABLE();
-		}
-		if (!dwfl_thread_state_registers(thread, reg->number, 1, &word))
-			return drgn_error_libdwfl();
-	}
-	return NULL;
-}
-
 static bool drgn_thread_set_initial_registers(Dwfl_Thread *thread,
 					      void *thread_arg)
 {
@@ -380,10 +281,16 @@ static bool drgn_thread_set_initial_registers(Dwfl_Thread *thread,
 			goto out;
 
 		if (is_pt_regs) {
-			assert(obj.kind == DRGN_OBJECT_BUFFER);
-			err = drgn_pt_regs_set_initial_registers(thread,
-								 &prog->platform,
-								 &obj);
+			assert(obj.kind == DRGN_OBJECT_BUFFER &&
+			       !obj.is_reference);
+			if (!prog->platform.arch->pt_regs_set_initial_registers) {
+				err = drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
+							"pt_regs stack unwinding is not supported for %s architecture",
+							prog->platform.arch->name);
+				goto out;
+			}
+			err = prog->platform.arch->pt_regs_set_initial_registers(thread,
+										 &obj);
 			goto out;
 		}
 	}
@@ -408,9 +315,16 @@ static bool drgn_thread_set_initial_registers(Dwfl_Thread *thread,
 		if (err)
 			goto out;
 		if (prstatus.str) {
-			err = drgn_prstatus_set_initial_registers(thread,
-								  &prog->platform,
-								  &prstatus);
+			if (!prog->platform.arch->prstatus_set_initial_registers) {
+				err = drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
+							"core dump stack unwinding is not supported for %s architecture",
+							prog->platform.arch->name);
+				goto out;
+			}
+			err = prog->platform.arch->prstatus_set_initial_registers(prog,
+										  thread,
+										  prstatus.str,
+										  prstatus.len);
 			goto out;
 		}
 	}