From patchwork Wed Aug 9 12:17:45 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiong Wang X-Patchwork-Id: 22035 Received: (qmail 42157 invoked by alias); 9 Aug 2017 12:17:51 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 42124 invoked by uid 89); 9 Aug 2017 12:17:50 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy=finishing X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 09 Aug 2017 12:17:48 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 51A0A80D for ; Wed, 9 Aug 2017 05:17:47 -0700 (PDT) Received: from [10.2.206.198] (e104437-lin.cambridge.arm.com [10.2.206.198]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id CA1AE3F540 for ; Wed, 9 Aug 2017 05:17:46 -0700 (PDT) From: Jiong Wang Subject: [AArch64][3/6] DWARF unwinder support for signed return address References: To: GDB Message-ID: Date: Wed, 9 Aug 2017 13:17:45 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.2.1 MIME-Version: 1.0 In-Reply-To: This patch add DWARF unwinder support for signed (mangled) return address on AArch64. If return address is signed, GDB unwinders will be affected, as GDB won't be able to unwind to previous frame use the signed address. Therefore, GDB needs a mechanism to restore the original value of return address accurately. Currently, the mechanism on AArch64 is: 1. DW_CFA_AARCH64_negate_ra_state (multiplexing with DW_CFA_GNU_window_save) is generated whenever return address (LR register) is signed (mangled) or authenticated (unmangled). The unwinder can know the signing status of return address at any point after finishing scaning function FDE. 2. A new DWARF pseudo register "ra_state" is introduced, the signing status is kept in this register after unwinders finishing scaning function FDE. 3. When the unwinders unwinding PC, the value of "ra_state" needs to be referenced. If the value is "1" which means true, unwinders need to mask off the pointer signature to restore the original pointer value. The mask for return address which is a code pointer is available at "pauth_cmask" register. gdb/ 2017-08-09 Jiong Wang Yao Qi * aarch64-tdep.c: Include dwarf2.h. (aarch64_dwarf2_prev_register): Mask off signature if LR is signed. (aarch64_dwarf2_frame_init_reg): Initialize DWARF unwinding rule for "pauth" registers. (aarch64_execute_dwarf_cfa_vendor_op): New function. (aarch64_dwarf_reg_to_regnum): Map "pauth" DWARF registers. (aarch64_pseudo_register_name): Handle "pauth" registers. (aarch64_pseudo_register_type): Likewise. (aarch64_pseudo_register_reggroup_p): Likewise. (aarch64_gdbarch_init): Support the new "ra_state" pseudo register. Register execute_dwarf_cfa_vendor_op method. * aarch64-tdep.h (AARCH64_DWARF_PAUTH_RA_STATE): New define. (AARCH64_DWARF_PAUTH_DMASK): Likewise. (AARCH64_DWARF_PAUTH_CMASK): Likewise. (struct aarch64_optional_regnum) : New field. diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index 7a3493c..b505013 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -35,6 +35,7 @@ #include "frame-base.h" #include "trad-frame.h" #include "objfiles.h" +#include "dwarf2.h" #include "dwarf2-frame.h" #include "gdbtypes.h" #include "prologue-value.h" @@ -1046,12 +1047,30 @@ static struct value * aarch64_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache, int regnum) { + struct gdbarch *gdbarch = get_frame_arch (this_frame); CORE_ADDR lr; switch (regnum) { case AARCH64_PC_REGNUM: lr = frame_unwind_register_unsigned (this_frame, AARCH64_LR_REGNUM); + /* Also fetch return address signing status, mask off the signature bits + if it's signed. */ + if (aarch64_tdep_has_pauth_p (gdbarch_tdep (gdbarch))) + { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + int ra_state_column + = tdep->regnum.pauth_ra_state_regnum + gdbarch_num_regs (gdbarch); + CORE_ADDR ra_state = frame_unwind_register_unsigned (this_frame, + ra_state_column); + if (ra_state) + { + int cmask_num = tdep->regnum.pauth_reg_base + 1; + CORE_ADDR cmask + = frame_unwind_register_unsigned (this_frame, cmask_num); + lr = lr & ~cmask; + } + } return frame_unwind_got_constant (this_frame, regnum, lr); default: @@ -1067,6 +1086,33 @@ aarch64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + /* Init pauth registers. */ + if (aarch64_tdep_has_pauth_p (tdep)) + { + int ra_state_num + = tdep->regnum.pauth_ra_state_regnum + gdbarch_num_regs (gdbarch); + int dmask_num = tdep->regnum.pauth_reg_base; + int cmask_num = tdep->regnum.pauth_reg_base + 1; + + if (regnum == ra_state_num) + { + /* Initialize RA_STATE column to zero. */ + static unsigned char exp_0 = 0x30; /* DW_OP_lit0. */ + + reg->how = DWARF2_FRAME_REG_SAVED_VAL_EXP; + reg->loc.exp = &exp_0; + reg->exp_len = 1; + return; + } + else if (regnum == cmask_num || regnum == dmask_num) + { + reg->how = DWARF2_FRAME_REG_SAME_VALUE; + return; + } + } + switch (regnum) { case AARCH64_PC_REGNUM: @@ -1079,6 +1125,40 @@ aarch64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, } } +/* Implement the execute_dwarf_cfa_vendor_op method. */ + +static bool +aarch64_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op, + struct dwarf2_frame_state *fs) +{ + struct dwarf2_frame_state_reg *ra_state_column; + static unsigned char exp_0 = 0x30; /* DW_OP_lit0. */ + static unsigned char exp_1 = 0x31; /* DW_OP_lit1. */ + + /* Only DW_CFA_GNU_window_save is expected on AArch64. */ + if (op != DW_CFA_GNU_window_save) + return false; + + + /* Allocate RA_STATE column if it's not allocated yet. */ + dwarf2_frame_state_alloc_regs (&fs->regs, AARCH64_DWARF_PAUTH_RA_STATE + 1); + + /* Toggle the status of RA_STATE column between 0 and 1. This column is + therefore using value expression rule as currently it's the only rule to + represent constant. */ + ra_state_column = &(fs->regs.reg[AARCH64_DWARF_PAUTH_RA_STATE]); + ra_state_column->how = DWARF2_FRAME_REG_SAVED_VAL_EXP; + + if (ra_state_column->loc.exp == NULL || ra_state_column->loc.exp == &exp_0) + ra_state_column->loc.exp = &exp_1; + else + ra_state_column->loc.exp = &exp_0; + + ra_state_column->exp_len = 1; + + return true; +} + /* When arguments must be pushed onto the stack, they go on in reverse order. The code below implements a FILO (stack) to do this. */ @@ -1777,6 +1857,8 @@ aarch64_vnb_type (struct gdbarch *gdbarch) static int aarch64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + if (reg >= AARCH64_DWARF_X0 && reg <= AARCH64_DWARF_X0 + 30) return AARCH64_X0_REGNUM + reg - AARCH64_DWARF_X0; @@ -1786,6 +1868,16 @@ aarch64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) if (reg >= AARCH64_DWARF_V0 && reg <= AARCH64_DWARF_V0 + 31) return AARCH64_V0_REGNUM + reg - AARCH64_DWARF_V0; + if (aarch64_tdep_has_pauth_p (tdep)) + { + if (reg >= AARCH64_DWARF_PAUTH_DMASK && reg <= AARCH64_DWARF_PAUTH_CMASK) + return tdep->regnum.pauth_reg_base + reg - AARCH64_DWARF_PAUTH_DMASK; + + if (reg == AARCH64_DWARF_PAUTH_RA_STATE) + /* AARCH64_PAUTH_RA_STATE_REGNUM is a pseudo register. */ + return tdep->regnum.pauth_ra_state_regnum + gdbarch_num_regs (gdbarch); + } + return -1; } @@ -2120,6 +2212,8 @@ aarch64_gen_return_address (struct gdbarch *gdbarch, static const char * aarch64_pseudo_register_name (struct gdbarch *gdbarch, int regnum) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + static const char *const q_name[] = { "q0", "q1", "q2", "q3", @@ -2197,6 +2291,21 @@ aarch64_pseudo_register_name (struct gdbarch *gdbarch, int regnum) if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32) return b_name[regnum - AARCH64_B0_REGNUM]; + if (aarch64_tdep_has_pauth_p (tdep)) + { + /* RA_STATE is the first pseudo register for pointer authentication + feature. */ + int ra_state = tdep->regnum.pauth_ra_state_regnum; + + /* RA_STATE is a pseudo register whose value will be initialized and + referenced only during frame unwinding. GDB should not read its + value from low level methods. In some functions, GDB will read a + register if it has a name. For example, mi_cmd_trace_frame_collected. + Therefore, we make RA_STATE anonymous to avoid such reading. */ + if (regnum == ra_state) + return ""; + } + internal_error (__FILE__, __LINE__, _("aarch64_pseudo_register_name: bad register number %d"), regnum); @@ -2207,6 +2316,8 @@ aarch64_pseudo_register_name (struct gdbarch *gdbarch, int regnum) static struct type * aarch64_pseudo_register_type (struct gdbarch *gdbarch, int regnum) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + regnum -= gdbarch_num_regs (gdbarch); if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32) @@ -2224,6 +2335,10 @@ aarch64_pseudo_register_type (struct gdbarch *gdbarch, int regnum) if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32) return aarch64_vnb_type (gdbarch); + if (aarch64_tdep_has_pauth_p (tdep) + && regnum == tdep->regnum.pauth_ra_state_regnum) + return builtin_type (gdbarch)->builtin_uint64; + internal_error (__FILE__, __LINE__, _("aarch64_pseudo_register_type: bad register number %d"), regnum); @@ -2235,6 +2350,8 @@ static int aarch64_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *group) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + regnum -= gdbarch_num_regs (gdbarch); if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32) @@ -2249,6 +2366,11 @@ aarch64_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum, return group == all_reggroup || group == vector_reggroup; else if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32) return group == all_reggroup || group == vector_reggroup; + /* Don't assign RA_STATE to any group. This pseudo register is supposed to be + used during unwinding only. Don't display it for "info register". */ + if (aarch64_tdep_has_pauth_p (tdep) + && regnum == tdep->regnum.pauth_ra_state_regnum) + return 0; return group == all_reggroup; } @@ -2891,6 +3013,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) int num_pseudo_regs = 0; struct aarch64_optional_regnum *regnum; int first_pauth_regnum = -1; + int pauth_ra_state_regnum = -1; /* Ensure we always have a target descriptor. */ if (!tdesc_has_registers (tdesc)) @@ -2939,6 +3062,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) if (feature_pauth) { first_pauth_regnum = num_regs; + pauth_ra_state_regnum = num_pseudo_regs; /* Validate the descriptor provides the mandatory PAUTH registers and allocate their numbers. */ for (i = 0; i < ARRAY_SIZE (aarch64_pauth_register_names); i++) @@ -2948,6 +3072,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) aarch64_pauth_register_names[i]); num_regs += i; + num_pseudo_regs += 1; /* Count RA_STATE pseudo register. */ } if (!valid_p) @@ -2988,6 +3113,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->jb_pc = -1; /* Longjump support not enabled by default. */ tdep->jb_elt_size = 8; tdep->regnum.pauth_reg_base = first_pauth_regnum; + tdep->regnum.pauth_ra_state_regnum = pauth_ra_state_regnum; set_gdbarch_push_dummy_call (gdbarch, aarch64_push_dummy_call); set_gdbarch_frame_align (gdbarch, aarch64_frame_align); @@ -3059,6 +3185,9 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) gdbarch_init_osabi (info, gdbarch); dwarf2_frame_set_init_reg (gdbarch, aarch64_dwarf2_frame_init_reg); + /* Register DWARF CFA vendor handler. */ + set_gdbarch_execute_dwarf_cfa_vendor_op (gdbarch, + aarch64_execute_dwarf_cfa_vendor_op); /* Add some default predicates. */ frame_unwind_append_unwinder (gdbarch, &aarch64_stub_unwind); diff --git a/gdb/aarch64-tdep.h b/gdb/aarch64-tdep.h index 5ece079..88b77b8 100644 --- a/gdb/aarch64-tdep.h +++ b/gdb/aarch64-tdep.h @@ -29,6 +29,9 @@ struct regset; /* AArch64 Dwarf register numbering. */ #define AARCH64_DWARF_X0 0 #define AARCH64_DWARF_SP 31 +#define AARCH64_DWARF_PAUTH_RA_STATE 34 +#define AARCH64_DWARF_PAUTH_DMASK 35 +#define AARCH64_DWARF_PAUTH_CMASK 36 #define AARCH64_DWARF_V0 64 /* Register numbers of various important registers. */ @@ -80,6 +83,8 @@ struct aarch64_optional_regnum { /* First pauth register number. */ int pauth_reg_base; + /* pauth ra_state register number. */ + int pauth_ra_state_regnum; }; /* Target-dependent structure in gdbarch. */