libdrgn: debug_info: implement creating objects from DWARF location descriptions

Add support for evaluating a DWARF location description and translating
it into a drgn object. In this commit, this is just used for global
variables, but an upcoming commit will wire this up to stack traces for
parameters and local variables.

There are a few locations that drgn's object model can't represent yet.
DW_OP_piece/DW_OP_bit_piece can describe objects that are only partially
known or partially in memory; we approximate these where we can. We
don't have a good way to support DW_OP_implicit_pointer at all yet.

This also adds test cases for DWARF expressions, which we couldn't
easily test before.

Signed-off-by: Omar Sandoval <[email protected]>

Author: osandov

libdrgn/debug_info.c

@@ -318,7 +318,7 @@ drgn_object_set_from_buffer(struct drgn_object *res,
 						    bit_offset);
 }
 
-static struct drgn_error *
+struct drgn_error *
 drgn_object_set_reference_internal(struct drgn_object *res,
 				   const struct drgn_object_type *type,
 				   uint64_t address, uint64_t bit_offset)

libdrgn/object.c

@@ -12,6 +12,9 @@
 #ifndef DRGN_OBJECT_H
 #define DRGN_OBJECT_H
 
+#include <stdlib.h>
+#include <string.h>
+
 #include "drgn.h"
 #include "type.h"
 
@@ -31,6 +34,24 @@
  * @{
  */
 
+/** Allocate a zero-initialized @ref drgn_value. */
+static inline bool drgn_value_zalloc(uint64_t size, union drgn_value *value_ret,
+				     char **buf_ret)
+{
+	if (size <= sizeof(value_ret->ibuf)) {
+		memset(value_ret->ibuf, 0, sizeof(value_ret->ibuf));
+		*buf_ret = value_ret->ibuf;
+	} else {
+		if (size > SIZE_MAX)
+			return false;
+		char *buf = calloc(1, size);
+		if (!buf)
+			return false;
+		value_ret->bufp = *buf_ret = buf;
+	}
+	return true;
+}
+
 /**
  * Get whether an object is zero.
  *
@@ -139,6 +160,15 @@ drgn_object_set_from_buffer_internal(struct drgn_object *res,
 				     const struct drgn_object_type *type,
 				     const void *buf, uint64_t bit_offset);
 
+/**
+ * Like @ref drgn_object_set_reference() but @ref drgn_object_type() was already
+ * called.
+ */
+struct drgn_error *
+drgn_object_set_reference_internal(struct drgn_object *res,
+				   const struct drgn_object_type *type,
+				   uint64_t address, uint64_t bit_offset);
+
 /**
  * Binary operator implementation.
  *

libdrgn/object.h

@@ -6,6 +6,86 @@
 
 #include "serialize.h"
 
+static inline uint8_t copy_bits_step(const uint8_t *s, unsigned int src_bit_offset,
+				     unsigned int bit_size,
+				     unsigned int dst_bit_offset, bool lsb0)
+{
+	uint8_t result;
+	if (lsb0) {
+		result = s[0] >> src_bit_offset;
+		if (bit_size > 8 - src_bit_offset)
+			result |= s[1] << (8 - src_bit_offset);
+		result <<= dst_bit_offset;
+	} else {
+		result = s[0] << src_bit_offset;
+		if (bit_size > 8 - src_bit_offset)
+			result |= s[1] >> (8 - src_bit_offset);
+		result >>= dst_bit_offset;
+	}
+	return result;
+}
+
+void copy_bits(void *dst, unsigned int dst_bit_offset, const void *src,
+	       unsigned int src_bit_offset, uint64_t bit_size, bool lsb0)
+{
+	assert(dst_bit_offset < 8);
+	assert(src_bit_offset < 8);
+
+	if (bit_size == 0)
+		return;
+
+	uint8_t *d = dst;
+	const uint8_t *s = src;
+	uint64_t dst_last_bit = dst_bit_offset + bit_size - 1;
+	uint8_t dst_first_mask = copy_bits_first_mask(dst_bit_offset, lsb0);
+	uint8_t dst_last_mask = copy_bits_last_mask(dst_last_bit, lsb0);
+
+	if (dst_bit_offset == src_bit_offset) {
+		/*
+		 * In the common case that the source and destination have the
+		 * same offset, we can use memcpy(), preserving bits at the
+		 * start and/or end if necessary.
+		 */
+		uint8_t first_byte = d[0];
+		uint8_t last_byte = d[dst_last_bit / 8];
+		memcpy(d, s, dst_last_bit / 8 + 1);
+		if (dst_bit_offset != 0) {
+			d[0] = ((first_byte & ~dst_first_mask)
+				| (d[0] & dst_first_mask));
+		}
+		if (dst_last_bit % 8 != 7) {
+			d[dst_last_bit / 8] = ((last_byte & ~dst_last_mask)
+					       | (d[dst_last_bit / 8] & dst_last_mask));
+		}
+	} else if (bit_size <= 8 - dst_bit_offset) {
+		/* Destination is only one byte. */
+		uint8_t dst_mask = dst_first_mask & dst_last_mask;
+		d[0] = ((d[0] & ~dst_mask)
+			| (copy_bits_step(&s[0], src_bit_offset, bit_size,
+					  dst_bit_offset, lsb0) & dst_mask));
+	} else {
+		/* Destination is two or more bytes. */
+		d[0] = ((d[0] & ~dst_first_mask)
+			 | (copy_bits_step(&s[0], src_bit_offset,
+					   8 - dst_bit_offset, dst_bit_offset,
+					   lsb0) & dst_first_mask));
+		src_bit_offset += 8 - dst_bit_offset;
+		size_t si = src_bit_offset / 8;
+		src_bit_offset %= 8;
+		size_t di = 1;
+		while (di < dst_last_bit / 8) {
+			d[di] = copy_bits_step(&s[si], src_bit_offset, 8, 0,
+					       lsb0);
+			di++;
+			si++;
+		}
+		d[di] = ((d[di] & ~dst_last_mask)
+			 | (copy_bits_step(&s[si], src_bit_offset,
+					   dst_last_bit % 8 + 1, 0, lsb0)
+			    & dst_last_mask));
+	}
+}
+
 void serialize_bits(void *buf, uint64_t bit_offset, uint64_t uvalue,
 		    uint8_t bit_size, bool little_endian)
 {

libdrgn/serialize.c

@@ -73,6 +73,45 @@ static inline void copy_lsbytes(void *dst, size_t dst_size,
 	}
 }
 
+/**
+ * Return a bit mask with bits `[bit_offset, 7]` set.
+ *
+ * @param[in] lsb0 See @ref copy_bits().
+ */
+static inline uint8_t copy_bits_first_mask(unsigned int bit_offset, bool lsb0)
+{
+	return lsb0 ? 0xff << bit_offset : 0xff >> bit_offset;
+}
+
+/**
+ * Return a bit mask with bits `[0, last_bit % 8]` set.
+ *
+ * @param[in] lsb0 See @ref copy_bits().
+ */
+static inline uint8_t copy_bits_last_mask(uint64_t last_bit, bool lsb0)
+{
+	return lsb0 ? 0xff >> (7 - last_bit % 8) : 0x7f80 >> (last_bit % 8);
+}
+
+/**
+ * Copy @p bit_size bits from @p src at bit offset @p src_bit_offset to @p dst
+ * at bit offset @p dst_bit_offset.
+ *
+ * @param[in] dst Destination buffer.
+ * @param[in] dst_bit_offset Offset in bits from the beginning of @p dst to copy
+ * to. Must be < 8.
+ * @param[in] src Source buffer.
+ * @param[in] src_bit_offset Offset in bits from the beginning of @p src to copy
+ * from. Must be < 8.
+ * @param[in] bit_size Number of bits to copy.
+ * @param[in] lsb0 If @c true, bits within a byte are numbered from least
+ * significant (0) to most significant (7); if @c false, they are numbered from
+ * most significant (0) to least significant (7). This determines the
+ * interpretation of @p dst_bit_offset and @p src_bit_offset.
+ */
+void copy_bits(void *dst, unsigned int dst_bit_offset, const void *src,
+	       unsigned int src_bit_offset, uint64_t bit_size, bool lsb0);
+
 /**
  * Serialize bits to a memory buffer.
  *

libdrgn/serialize.h

@@ -41,6 +41,23 @@ def mock_memory_read(data, address, count, offset, physical):
     return data[offset : offset + count]
 
 
+def add_mock_memory_segments(prog, segments):
+    for segment in segments:
+        if segment.virt_addr is not None:
+            prog.add_memory_segment(
+                segment.virt_addr,
+                len(segment.buf),
+                functools.partial(mock_memory_read, segment.buf),
+            )
+        if segment.phys_addr is not None:
+            prog.add_memory_segment(
+                segment.phys_addr,
+                len(segment.buf),
+                functools.partial(mock_memory_read, segment.buf),
+                True,
+            )
+
+
 class MockObject(NamedTuple):
     name: str
     type: Type
@@ -84,20 +101,7 @@ def mock_object_find(prog, name, flags, filename):
 
     prog = Program(platform)
     if segments is not None:
-        for segment in segments:
-            if segment.virt_addr is not None:
-                prog.add_memory_segment(
-                    segment.virt_addr,
-                    len(segment.buf),
-                    functools.partial(mock_memory_read, segment.buf),
-                )
-            if segment.phys_addr is not None:
-                prog.add_memory_segment(
-                    segment.phys_addr,
-                    len(segment.buf),
-                    functools.partial(mock_memory_read, segment.buf),
-                    True,
-                )
+        add_mock_memory_segments(prog, segments)
     if types is not None:
         prog.add_type_finder(mock_find_type)
     if objects is not None:

tests/__init__.py

@@ -0,0 +1,62 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from collections import namedtuple
+
+
+def _append_uleb128(buf, value):
+    while True:
+        byte = value & 0x7F
+        value >>= 7
+        if value:
+            buf.append(byte | 0x80)
+        else:
+            buf.append(byte)
+            break
+
+
+def _append_sleb128(buf, value):
+    while True:
+        byte = value & 0x7F
+        value >>= 7
+        if (not value and not (byte & 0x40)) or (value == -1 and (byte & 0x40)):
+            buf.append(byte)
+            break
+        else:
+            buf.append(byte | 0x80)
+
+
+U8 = namedtuple("U8", ["value"])
+U8._append = lambda self, buf, byteorder: buf.append(self.value)
+S8 = namedtuple("S8", ["value"])
+S8._append = lambda self, buf, byteorder: buf.append(self.value & 0xFF)
+U16 = namedtuple("U16", ["value"])
+U16._append = lambda self, buf, byteorder: buf.extend(self.value.to_bytes(2, byteorder))
+S16 = namedtuple("S16", ["value"])
+S16._append = lambda self, buf, byteorder: buf.extend(
+    self.value.to_bytes(2, byteorder, signed=True)
+)
+U32 = namedtuple("U32", ["value"])
+U32._append = lambda self, buf, byteorder: buf.extend(self.value.to_bytes(4, byteorder))
+S32 = namedtuple("S32", ["value"])
+S32._append = lambda self, buf, byteorder: buf.extend(
+    self.value.to_bytes(4, byteorder, signed=True)
+)
+U64 = namedtuple("U64", ["value"])
+U64._append = lambda self, buf, byteorder: buf.extend(self.value.to_bytes(8, byteorder))
+S64 = namedtuple("S64", ["value"])
+S64._append = lambda self, buf, byteorder: buf.extend(
+    self.value.to_bytes(8, byteorder, signed=True)
+)
+ULEB128 = namedtuple("ULEB128", ["value"])
+ULEB128._append = lambda self, buf, byteorder: _append_uleb128(buf, self.value)
+SLEB128 = namedtuple("SLEB128", ["value"])
+SLEB128._append = lambda self, buf, byteorder: _append_sleb128(buf, self.value)
+
+
+def assemble(*args, little_endian=True):
+    byteorder = "little" if little_endian else "big"
+    buf = bytearray()
+    for arg in args:
+        arg._append(buf, byteorder)
+    return buf

tests/assembler.py

@@ -4,6 +4,7 @@
 from collections import namedtuple
 import os.path
 
+from tests.assembler import _append_sleb128, _append_uleb128
 from tests.dwarf import DW_AT, DW_FORM, DW_TAG
 from tests.elf import ET, PT, SHT
 from tests.elfwriter import ElfSection, create_elf_file
@@ -13,28 +14,6 @@
 DwarfDie.__new__.__defaults__ = (None,)
 
 
-def _append_uleb128(buf, value):
-    while True:
-        byte = value & 0x7F
-        value >>= 7
-        if value:
-            buf.append(byte | 0x80)
-        else:
-            buf.append(byte)
-            break
-
-
-def _append_sleb128(buf, value):
-    while True:
-        byte = value & 0x7F
-        value >>= 7
-        if (not value and not (byte & 0x40)) or (value == -1 and (byte & 0x40)):
-            buf.append(byte)
-            break
-        else:
-            buf.append(byte | 0x80)
-
-
 def _compile_debug_abbrev(unit_dies, use_dw_form_indirect):
     buf = bytearray()
     code = 1