From: Thiago Jung Bauermann <thiago.bauermann@linaro.org>
With the implementation of that gdbarch function we can remove
the arch specific function aarch64_linux_dwarf2_prev_gcspr and
use the generalized function dwarf2_prev_ssp instead.
Co-Authored-By: Christina Joos <christina.joos@intel.com>
---
gdb/aarch64-linux-tdep.c | 51 ++--------------------------------------
gdb/aarch64-tdep.c | 31 ++++++++++++++++++++++--
2 files changed, 31 insertions(+), 51 deletions(-)
Christina Joos <christina.joos@intel.com> writes:
> From: Thiago Jung Bauermann <thiago.bauermann@linaro.org>
>
> With the implementation of that gdbarch function we can remove
> the arch specific function aarch64_linux_dwarf2_prev_gcspr and
> use the generalized function dwarf2_prev_ssp instead.
>
> Co-Authored-By: Christina Joos <christina.joos@intel.com>
> ---
> gdb/aarch64-linux-tdep.c | 51 ++--------------------------------------
> gdb/aarch64-tdep.c | 31 ++++++++++++++++++++++--
> 2 files changed, 31 insertions(+), 51 deletions(-)
I guess I don't need to approve this one. :)
Though for the avoidance of doubt, it is.
@@ -66,6 +66,7 @@
#include "elf/common.h"
#include "elf/aarch64.h"
#include "arch/aarch64-insn.h"
+#include "shadow-stack.h"
/* For std::pow */
#include <cmath>
@@ -2617,54 +2618,6 @@ aarch64_linux_get_shadow_stack_pointer (gdbarch *gdbarch, regcache *regcache,
return gcspr;
}
-/* Implement Guarded Control Stack Pointer Register unwinding. For each
- previous GCS pointer check if its address is still in the GCS memory
- range. If it's outside the range set the returned value to unavailable,
- otherwise return a value containing the new GCS pointer. */
-
-static value *
-aarch64_linux_dwarf2_prev_gcspr (const frame_info_ptr &this_frame,
- void **this_cache, int regnum)
-{
- value *v = frame_unwind_got_register (this_frame, regnum, regnum);
- gdb_assert (v != nullptr);
-
- gdbarch *gdbarch = get_frame_arch (this_frame);
-
- if (v->entirely_available () && !v->optimized_out ())
- {
- int size = register_size (gdbarch, regnum);
- bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- CORE_ADDR gcspr = extract_unsigned_integer (v->contents_all ().data (),
- size, byte_order);
-
- /* Starting with v6.13, the Linux kernel supports Guarded Control
- Stack. Using /proc/PID/smaps we can only check if the current
- GCSPR points to GCS memory. Only if this is the case a valid
- previous GCS pointer can be calculated. */
- std::pair<CORE_ADDR, CORE_ADDR> range;
- if (linux_address_in_shadow_stack_mem_range (gcspr, &range))
- {
- /* The GCS grows downwards. To compute the previous GCS pointer,
- we need to increment the GCSPR. */
- CORE_ADDR new_gcspr = gcspr + 8;
-
- /* If NEW_GCSPR still points within the current GCS memory range
- we consider it to be valid. */
- if (new_gcspr < range.second)
- return frame_unwind_got_address (this_frame, regnum, new_gcspr);
- }
- }
-
- /* Return a value which is marked as unavailable in case we could not
- calculate a valid previous GCS pointer. */
- value *retval
- = value::allocate_register (get_next_frame_sentinel_okay (this_frame),
- regnum, register_type (gdbarch, regnum));
- retval->mark_bytes_unavailable (0, retval->type ()->length ());
- return retval;
-}
-
/* AArch64 Linux implementation of the report_signal_info gdbarch
hook. Displays information about possible memory tag violations. */
@@ -3245,7 +3198,7 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
set_gdbarch_get_shadow_stack_pointer (gdbarch,
aarch64_linux_get_shadow_stack_pointer);
- tdep->fn_prev_gcspr = aarch64_linux_dwarf2_prev_gcspr;
+ tdep->fn_prev_gcspr = dwarf2_prev_ssp;
}
}
@@ -1908,6 +1908,26 @@ aarch64_pop_gcs_entry (regcache *regs)
regcache_cooked_write_unsigned (regs, tdep->gcs_reg_base, gcs_addr + 8);
}
+/* Implement the "top_addr_empty_shadow_stack" gdbarch method. */
+
+static bool
+aarch64_top_addr_empty_shadow_stack
+ (const CORE_ADDR addr,
+ const std::pair<CORE_ADDR, CORE_ADDR> range)
+{
+ gdb_assert (addr >= range.first);
+
+ /* For AArch64, addr must be strictly less than the upper address in the
+ range, but other architectures allow it to be equal to the upper
+ address when the stack is empty so GDB core works with those addresses
+ and can send them our way. */
+ gdb_assert (addr <= range.second);
+
+ /* The GCS grows down, and the oldest entry is the value '0', not an
+ address. */
+ return addr >= range.second - 8;
+}
+
/* Implement the "push_dummy_call" gdbarch method. */
static CORE_ADDR
@@ -4783,9 +4803,16 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* Register a hook for converting a memory tag to a string. */
set_gdbarch_memtag_to_string (gdbarch, aarch64_memtag_to_string);
- /* AArch64's shadow stack pointer is the GCSPR. */
if (tdep->has_gcs ())
- set_gdbarch_ssp_regnum (gdbarch, tdep->gcs_reg_base);
+ {
+ /* AArch64's shadow stack pointer is the GCSPR. */
+ set_gdbarch_ssp_regnum (gdbarch, tdep->gcs_reg_base);
+ }
+
+ /* Implementing this hook is required to allow the unwinding of
+ the shadow stack pointer in shadow-stack.c:dwarf2_prev_ssp. */
+ set_gdbarch_top_addr_empty_shadow_stack
+ (gdbarch, aarch64_top_addr_empty_shadow_stack);
/* ABI */
set_gdbarch_short_bit (gdbarch, 16);