From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ej1-x642.google.com (mail-ej1-x642.google.com [IPv6:2a00:1450:4864:20::642]) by sourceware.org (Postfix) with ESMTPS id 87B34384B13B for ; Thu, 23 Jul 2020 19:35:48 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 87B34384B13B Received: by mail-ej1-x642.google.com with SMTP id gg18so4221603ejb.6 for ; Thu, 23 Jul 2020 12:35:48 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=LtYOHISaHnv60f+Fe6JDGnpOaxnt0wOmVqCgukgCpBE=; b=SSL/OyszqbXmYS+VG2TrBmcIqJP3XD022xnEZX9GRorSoY+dEAheyWtEK2WyguGT0R OuooTwkt0S6RDHxJo5FaAIot/MHeE6jpDa+BWKH3cxp9SJc3Opx72zhsIv1Dbk3/zqTb CtE08JxEPRJldK6q3Mma/O9UADkixyg5ScKmOxXwJ/rt4PEXnbHRj8Q6BZ+1kPmoz6d2 cIAuCF7cw7DBqCrwuT3m8ixDFJyCTrpbJFYCrkyiW6iEzTs1eIzRUpG1EBmqfC11qOfV C2HP5G071LVC1KXaSizA6bRVWrBIEbS4wgUOGgNyTuM1pzSc5iQXcxGlmfGDSNmxM6DW DbAA== X-Gm-Message-State: AOAM5310gOQwVyAF7MQhCiR8YcsIS6xIHnqw4qd8iH1NiWJnZgZM8ZVB QJQV3Z+plESuzP7rmN2FVm6QiRo7bCWq6w== X-Google-Smtp-Source: ABdhPJxg47HdNnUyFooN0KTDfVWzK+uuUldjD8Q+8O2pEX15YI0V4oLyIbHK7/V4Drm6MKJU7wJbVA== X-Received: by 2002:a17:906:cd19:: with SMTP id oz25mr5827625ejb.36.1595532947063; Thu, 23 Jul 2020 12:35:47 -0700 (PDT) Received: from atlantis.home ([2a03:1b20:3:f011::6d]) by smtp.gmail.com with ESMTPSA id cw14sm2702048edb.88.2020.07.23.12.35.45 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 23 Jul 2020 12:35:46 -0700 (PDT) From: Shahab Vahedi To: gdb-patches@sourceware.org Cc: Shahab Vahedi , Shahab Vahedi , Simon Marchi , Tom Tromey , Anton Kolesov , Francois Bedard , Anton Kolesov Subject: [PATCH v4 3/3] arc: Add GNU/Linux support for ARC Date: Thu, 23 Jul 2020 21:35:32 +0200 Message-Id: <20200723193532.25812-4-shahab.vahedi@gmail.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200723193532.25812-1-shahab.vahedi@gmail.com> References: <20200713154527.13430-1-shahab.vahedi@gmail.com> <20200723193532.25812-1-shahab.vahedi@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_SHORT, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 23 Jul 2020 19:35:50 -0000 From: Anton Kolesov ARC Linux targets differences from baremetal: - No support for hardware single instruction stepping. - Different access rules to registers. - Use of another instruction for breakpoints. v2: Changes after Tom's remarks [1] arc-linux-tdep.c - Use true/false instead of TRUE/FALSE. - arc_linux_sw_breakpoint_from_kind (): Break long lines into two. - arc_linux_sw_breakpoint_from_kind (): Remove starting blank line. - Use explicit number evaluation, e.g: if (a & b) -> if ((a & b) != 0) arc-tdep.c - Use explicit number evaluation, e.g: if (a & b) -> if ((a & b) != 0) gdb/configure.tgt - arc*-*-linux*): Remove "build_gdbserver=yes". v3: Changes after Simon's remarks [2] arc-linux-tdep.c - Use "return trap_size" instead of cryptic "return 2". - Removed unnecessary curly braces. - Removed "void" from "_initialize_arc_linux_tdep (void)". [1] Tom's remarks https://sourceware.org/pipermail/gdb-patches/2020-April/167887.html [2] Simon's remarks https://sourceware.org/pipermail/gdb-patches/2020-May/168513.html 2020-07-22 Anton Kolesov * configure.tgt: ARC support for GNU/Linux. * Makefile.in (ALL_TARGET_OBJS): Likewise. * arc-linux-tdep.c: New file. * arc-tdep.h (ARC_STATUS32_L_MASK, ARC_STATUS32_DE_MASK): Declare. * arc-tdep.c (arc_write_pc): Use it. --- gdb/Makefile.in | 1 + gdb/arc-linux-tdep.c | 283 +++++++++++++++++++++++++++++++++++++++++++ gdb/arc-tdep.c | 3 +- gdb/arc-tdep.h | 5 + gdb/configure.tgt | 5 + 5 files changed, 295 insertions(+), 2 deletions(-) create mode 100644 gdb/arc-linux-tdep.c diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 9d484457397..85304b9f549 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -697,6 +697,7 @@ ALL_64_TARGET_OBS = \ # All other target-dependent objects files (used with --enable-targets=all). ALL_TARGET_OBS = \ aarch32-tdep.o \ + arc-linux-tdep.o \ arc-tdep.o \ arch/aarch32.o \ arch/arc.o \ diff --git a/gdb/arc-linux-tdep.c b/gdb/arc-linux-tdep.c new file mode 100644 index 00000000000..be24a072881 --- /dev/null +++ b/gdb/arc-linux-tdep.c @@ -0,0 +1,283 @@ +/* Target dependent code for GNU/Linux ARC. + + Copyright 2020 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* GDB header files. */ +#include "defs.h" +#include "linux-tdep.h" +#include "objfiles.h" +#include "opcode/arc.h" +#include "osabi.h" +#include "solib-svr4.h" + +/* ARC header files. */ +#include "opcodes/arc-dis.h" +#include "arc-tdep.h" + +/* Implement the "cannot_fetch_register" gdbarch method. */ + +static int +arc_linux_cannot_fetch_register (struct gdbarch *gdbarch, int regnum) +{ + /* Assume that register is readable if it is unknown. */ + switch (regnum) + { + case ARC_ILINK_REGNUM: + case ARC_RESERVED_REGNUM: + case ARC_LIMM_REGNUM: + return true; + case ARC_R30_REGNUM: + case ARC_R58_REGNUM: + case ARC_R59_REGNUM: + return !arc_mach_is_arcv2 (gdbarch); + } + if (regnum > ARC_BLINK_REGNUM && regnum < ARC_LP_COUNT_REGNUM) + return true; + return false; +} + +/* Implement the "cannot_store_register" gdbarch method. */ + +static int +arc_linux_cannot_store_register (struct gdbarch *gdbarch, int regnum) +{ + /* Assume that register is writable if it is unknown. */ + switch (regnum) + { + case ARC_ILINK_REGNUM: + case ARC_RESERVED_REGNUM: + case ARC_LIMM_REGNUM: + case ARC_PCL_REGNUM: + return true; + case ARC_R30_REGNUM: + case ARC_R58_REGNUM: + case ARC_R59_REGNUM: + return !arc_mach_is_arcv2 (gdbarch); + } + if (regnum > ARC_BLINK_REGNUM && regnum < ARC_LP_COUNT_REGNUM) + return true; + return false; +} + +/* For ARC Linux, breakpoint uses the 16-bit TRAP_S 1 instruction, which + is 0x3e78 (little endian) or 0x783e (big endian). */ + +static const gdb_byte arc_linux_trap_s_be[] = { 0x78, 0x3e }; +static const gdb_byte arc_linux_trap_s_le[] = { 0x3e, 0x78 }; +static const int trap_size = 2; /* Number of bytes to insert "trap". */ + +/* Implement the "breakpoint_kind_from_pc" gdbarch method. */ + +static int +arc_linux_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr) +{ + return trap_size; +} + +/* Implement the "sw_breakpoint_from_kind" gdbarch method. */ + +static const gdb_byte * +arc_linux_sw_breakpoint_from_kind (struct gdbarch *gdbarch, + int kind, int *size) +{ + *size = kind; + return ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) + ? arc_linux_trap_s_be + : arc_linux_trap_s_le); +} + +/* Implement the "software_single_step" gdbarch method. */ + +static std::vector +arc_linux_software_single_step (struct regcache *regcache) +{ + struct gdbarch *gdbarch = regcache->arch (); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + struct disassemble_info di = arc_disassemble_info (gdbarch); + + /* Read current instruction. */ + struct arc_instruction curr_insn; + arc_insn_decode (regcache_read_pc (regcache), &di, arc_delayed_print_insn, + &curr_insn); + CORE_ADDR next_pc = arc_insn_get_linear_next_pc (curr_insn); + + std::vector next_pcs; + + /* For instructions with delay slots, the fall thru is not the + instruction immediately after the current instruction, but the one + after that. */ + if (curr_insn.has_delay_slot) + { + struct arc_instruction next_insn; + arc_insn_decode (next_pc, &di, arc_delayed_print_insn, &next_insn); + next_pcs.push_back (arc_insn_get_linear_next_pc (next_insn)); + } + else + next_pcs.push_back (next_pc); + + ULONGEST status32; + regcache_cooked_read_unsigned (regcache, gdbarch_ps_regnum (gdbarch), + &status32); + + if (curr_insn.is_control_flow) + { + CORE_ADDR branch_pc = arc_insn_get_branch_target (curr_insn); + if (branch_pc != next_pc) + next_pcs.push_back (branch_pc); + } + /* Is current instruction the last in a loop body? */ + else if (tdep->has_hw_loops) + { + /* If STATUS32.L is 1, then ZD-loops are disabled. */ + if ((status32 & ARC_STATUS32_L_MASK) == 0) + { + ULONGEST lp_end, lp_start, lp_count; + regcache_cooked_read_unsigned (regcache, ARC_LP_START_REGNUM, + &lp_start); + regcache_cooked_read_unsigned (regcache, ARC_LP_END_REGNUM, &lp_end); + regcache_cooked_read_unsigned (regcache, ARC_LP_COUNT_REGNUM, + &lp_count); + + if (arc_debug) + { + debug_printf ("arc-linux: lp_start = %s, lp_end = %s, " + "lp_count = %s, next_pc = %s\n", + paddress (gdbarch, lp_start), + paddress (gdbarch, lp_end), + pulongest (lp_count), + paddress (gdbarch, next_pc)); + } + + if (next_pc == lp_end && lp_count > 1) + { + /* The instruction is in effect a jump back to the start of + the loop. */ + next_pcs.push_back (lp_start); + } + + } + } + + /* Is this a delay slot? Then next PC is in BTA register. */ + if ((status32 & ARC_STATUS32_DE_MASK) != 0) + { + ULONGEST bta; + regcache_cooked_read_unsigned (regcache, ARC_BTA_REGNUM, &bta); + next_pcs.push_back (bta); + } + + return next_pcs; +} + +/* Implement the "skip_solib_resolver" gdbarch method. + + See glibc_skip_solib_resolver for details. */ + +static CORE_ADDR +arc_linux_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + /* For uClibc 0.9.26+. + + An unresolved PLT entry points to "__dl_linux_resolve", which calls + "_dl_linux_resolver" to do the resolving and then eventually jumps to + the function. + + So we look for the symbol `_dl_linux_resolver', and if we are there, + gdb sets a breakpoint at the return address, and continues. */ + struct bound_minimal_symbol resolver = + lookup_minimal_symbol ("_dl_linux_resolver", NULL, NULL); + + if (arc_debug) + { + if (resolver.minsym != nullptr) + { + CORE_ADDR res_addr = BMSYMBOL_VALUE_ADDRESS (resolver); + debug_printf ("arc-linux: skip_solib_resolver (): " + "pc = %s, resolver at %s\n", + print_core_address (gdbarch, pc), + print_core_address (gdbarch, res_addr)); + } + else + { + debug_printf ("arc-linux: skip_solib_resolver (): " + "pc = %s, no resolver found\n", + print_core_address (gdbarch, pc)); + } + } + + if (resolver.minsym != nullptr && BMSYMBOL_VALUE_ADDRESS (resolver) == pc) + { + /* Find the return address. */ + return frame_unwind_caller_pc (get_current_frame ()); + } + else + { + /* No breakpoint required. */ + return 0; + } +} + +/* Initialization specific to Linux environment. */ + +static void +arc_linux_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (arc_debug) + debug_printf ("arc-linux: GNU/Linux OS/ABI initialization.\n"); + + /* If we are using Linux, we have in uClibc + (libc/sysdeps/linux/arc/bits/setjmp.h): + + typedef int __jmp_buf[13+1+1+1]; //r13-r25, fp, sp, blink + + Where "blink" is a stored PC of a caller function. + */ + tdep->jb_pc = 15; + + linux_init_abi (info, gdbarch); + + /* Set up target dependent GDB architecture entries. */ + set_gdbarch_cannot_fetch_register (gdbarch, arc_linux_cannot_fetch_register); + set_gdbarch_cannot_store_register (gdbarch, arc_linux_cannot_store_register); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, + arc_linux_breakpoint_kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, + arc_linux_sw_breakpoint_from_kind); + set_gdbarch_fetch_tls_load_module_address (gdbarch, + svr4_fetch_objfile_link_map); + set_gdbarch_software_single_step (gdbarch, arc_linux_software_single_step); + set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); + set_gdbarch_skip_solib_resolver (gdbarch, arc_linux_skip_solib_resolver); + + /* GNU/Linux uses SVR4-style shared libraries, with 32-bit ints, longs + and pointers (ILP32). */ + set_solib_svr4_fetch_link_map_offsets (gdbarch, + svr4_ilp32_fetch_link_map_offsets); +} + +/* Suppress warning from -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_arc_linux_tdep; + +void +_initialize_arc_linux_tdep () +{ + gdbarch_register_osabi (bfd_arch_arc, 0, GDB_OSABI_LINUX, + arc_linux_init_osabi); +} diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c index 59e698bb18b..aadf1889c9b 100644 --- a/gdb/arc-tdep.c +++ b/gdb/arc-tdep.c @@ -602,8 +602,7 @@ arc_write_pc (struct regcache *regcache, CORE_ADDR new_pc) regcache_cooked_read_unsigned (regcache, gdbarch_ps_regnum (gdbarch), &status32); - /* Mask for DE bit is 0x40. */ - if (status32 & 0x40) + if ((status32 & ARC_STATUS32_DE_MASK) != 0) { if (arc_debug) { diff --git a/gdb/arc-tdep.h b/gdb/arc-tdep.h index e752348a262..6331d29f402 100644 --- a/gdb/arc-tdep.h +++ b/gdb/arc-tdep.h @@ -100,6 +100,11 @@ enum arc_regnum Longer registers are represented as pairs of 32-bit registers. */ #define ARC_REGISTER_SIZE 4 +/* STATUS32 register: hardware loops disabled bit. */ +#define ARC_STATUS32_L_MASK (1 << 12) +/* STATUS32 register: current instruction is a delay slot. */ +#define ARC_STATUS32_DE_MASK (1 << 6) + #define arc_print(fmt, args...) fprintf_unfiltered (gdb_stdlog, fmt, ##args) extern int arc_debug; diff --git a/gdb/configure.tgt b/gdb/configure.tgt index d66f01bb9f7..4178eb4e773 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -157,6 +157,11 @@ arc*-*-elf32) gdb_target_obs="arc-newlib-tdep.o" ;; +arc*-*-linux*) + # Target: ARC machine running Linux + gdb_target_obs="arc-linux-tdep.o linux-tdep.o solib-svr4.o" + ;; + arm*-wince-pe | arm*-*-mingw32ce*) # Target: ARM based machine running Windows CE (win32) gdb_target_obs="arm-wince-tdep.o windows-tdep.o" -- 2.27.0