summaryrefslogtreecommitdiffstats
path: root/meta/recipes-devtools/gdb
diff options
context:
space:
mode:
authorAlexey Brodkin <abrodkin@synopsys.com>2021-06-15 09:00:33 -0700
committerRichard Purdie <richard.purdie@linuxfoundation.org>2021-06-17 13:42:31 +0100
commit4052a66ba3f6ebf68390af1230d04c56459bfb44 (patch)
treeb8501a5ca604249a6884d3ef9de9f22280e82aac /meta/recipes-devtools/gdb
parenta5517f5021a31dd426dc71ad84b21f325d49978a (diff)
downloadpoky-4052a66ba3f6ebf68390af1230d04c56459bfb44.tar.gz
gdb: Add native GDB support for ARC
This adds support of so-called "native" GDB for ARC processors. It was submitted upstream a bit late for inclusion in v10.x, but already in the upstream "master" branch and will be an essential part of v11.1 whenever it happens. These are the changes from upstream "master": * https://sourceware.org/git?p=binutils-gdb.git;a=commit;h=b4e3cd0440109d0a5552d3313ccbd35c8103335b * https://sourceware.org/git?p=binutils-gdb.git;a=commit;h=d4af727286e3a9f177ba11677fbd3a012d36558a * https://sourceware.org/git?p=binutils-gdb.git;a=commit;h=46023bbe81355230b4e7b76d3084337823d02362 * https://sourceware.org/git?p=binutils-gdb.git;a=commit;h=04c9f85efcd8df5fc482ce97c0104cc7dd5d19e6 Thanks a bunch to Anton & Shahab who made it possible! (From OE-Core rev: 3429acea0f4a0b59f233947defecdf919c7b1799) Signed-off-by: Alexey Brodkin <abrodkin@synopsys.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
Diffstat (limited to 'meta/recipes-devtools/gdb')
-rw-r--r--meta/recipes-devtools/gdb/gdb-10.2.inc4
-rw-r--r--meta/recipes-devtools/gdb/gdb/0012-arc-Add-support-for-signal-handlers.patch218
-rw-r--r--meta/recipes-devtools/gdb/gdb/0013-arc-Add-support-for-signal-frames-for-Linux-targets.patch232
-rw-r--r--meta/recipes-devtools/gdb/gdb/0014-arc-Take-into-account-the-REGNUM-in-supply-collect-g.patch104
-rw-r--r--meta/recipes-devtools/gdb/gdb/0015-gdb-Add-native-support-for-ARC-in-GNU-Linux.patch414
5 files changed, 972 insertions, 0 deletions
diff --git a/meta/recipes-devtools/gdb/gdb-10.2.inc b/meta/recipes-devtools/gdb/gdb-10.2.inc
index 0a7df54e9f..0d275075e6 100644
--- a/meta/recipes-devtools/gdb/gdb-10.2.inc
+++ b/meta/recipes-devtools/gdb/gdb-10.2.inc
@@ -15,5 +15,9 @@ SRC_URI = "${GNU_MIRROR}/gdb/gdb-${PV}.tar.xz \
15 file://0009-resolve-restrict-keyword-conflict.patch \ 15 file://0009-resolve-restrict-keyword-conflict.patch \
16 file://0010-Fix-invalid-sigprocmask-call.patch \ 16 file://0010-Fix-invalid-sigprocmask-call.patch \
17 file://0011-gdbserver-ctrl-c-handling.patch \ 17 file://0011-gdbserver-ctrl-c-handling.patch \
18 file://0012-arc-Add-support-for-signal-handlers.patch \
19 file://0013-arc-Add-support-for-signal-frames-for-Linux-targets.patch \
20 file://0014-arc-Take-into-account-the-REGNUM-in-supply-collect-g.patch \
21 file://0015-gdb-Add-native-support-for-ARC-in-GNU-Linux.patch \
18 " 22 "
19SRC_URI[sha256sum] = "aaa1223d534c9b700a8bec952d9748ee1977513f178727e1bee520ee000b4f29" 23SRC_URI[sha256sum] = "aaa1223d534c9b700a8bec952d9748ee1977513f178727e1bee520ee000b4f29"
diff --git a/meta/recipes-devtools/gdb/gdb/0012-arc-Add-support-for-signal-handlers.patch b/meta/recipes-devtools/gdb/gdb/0012-arc-Add-support-for-signal-handlers.patch
new file mode 100644
index 0000000000..6a98b65766
--- /dev/null
+++ b/meta/recipes-devtools/gdb/gdb/0012-arc-Add-support-for-signal-handlers.patch
@@ -0,0 +1,218 @@
1From bfee93403b46ae4f050282b7721ba39073905c69 Mon Sep 17 00:00:00 2001
2From: Anton Kolesov <Anton.Kolesov@synopsys.com>
3Date: Mon, 22 Aug 2016 19:39:46 +0300
4Subject: [PATCH 1/4] arc: Add support for signal handlers
5
6This patch adds the necessary infrastructure to handle signal frames for
7ARC architecture. It is fairly similar to what any other architecture
8would have. Linux specific parts will be in a separate patch.
9
10v2 [1]:
11- Make the logic of "arc_sigtramp_frame_sniffer ()" simpler.
12
13[1] Tom's remark for the first version
14https://sourceware.org/pipermail/gdb-patches/2020-November/173221.html
15
16gdb/ChangeLog:
17
18 * arc-tdep.c (arc_make_sigtramp_frame_cache): New function.
19 (arc_sigtramp_frame_this_id): Likewise.
20 (arc_sigtramp_frame_prev_register): Likewise.
21 (arc_sigtramp_frame_sniffer): Likewise.
22 (arc_siftramp_frame_unwind): New global variable.
23 (arc_gdbarch_init): Use sigtramp capabilities.
24 (arc_dump_tdep): Print sigtramp fields.
25 * arc-tdep.h (gdbarch_tdep): Add sigtramp fields.
26
27Upstream-Status: Backport [https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=b4e3cd0440109d0a5552d3313ccbd35c8103335b]
28
29Signed-off-by: Anton Kolesov <Anton.Kolesov@synopsys.com>
30Signed-off-by: Shahab Vahedi <shahab@synopsys.com>
31Signed-off-by: Alexey Brodkin <abrodkin@synopsys.com>
32---
33 gdb/arc-tdep.c | 123 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
34 gdb/arc-tdep.h | 13 ++++++
35 2 files changed, 136 insertions(+)
36
37diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
38index 93e2fd88a9a..3356252525d 100644
39--- a/gdb/arc-tdep.c
40+++ b/gdb/arc-tdep.c
41@@ -1843,6 +1843,104 @@ arc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
42 reg->how = DWARF2_FRAME_REG_CFA;
43 }
44
45+/* Signal trampoline frame unwinder. Allows frame unwinding to happen
46+ from within signal handlers. */
47+
48+static struct arc_frame_cache *
49+arc_make_sigtramp_frame_cache (struct frame_info *this_frame)
50+{
51+ if (arc_debug)
52+ debug_printf ("arc: sigtramp_frame_cache\n");
53+
54+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
55+
56+ /* Allocate new frame cache instance and space for saved register info. */
57+ struct arc_frame_cache *cache = FRAME_OBSTACK_ZALLOC (struct arc_frame_cache);
58+ cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
59+
60+ /* Get the stack pointer and use it as the frame base. */
61+ cache->prev_sp = arc_frame_base_address (this_frame, NULL);
62+
63+ /* If the ARC-private target-dependent info doesn't have a table of
64+ offsets of saved register contents within an OS signal context
65+ structure, then there is nothing to analyze. */
66+ if (tdep->sc_reg_offset == NULL)
67+ return cache;
68+
69+ /* Find the address of the sigcontext structure. */
70+ CORE_ADDR addr = tdep->sigcontext_addr (this_frame);
71+
72+ /* For each register, if its contents have been saved within the
73+ sigcontext structure, determine the address of those contents. */
74+ gdb_assert (tdep->sc_num_regs <= (ARC_LAST_REGNUM + 1));
75+ for (int i = 0; i < tdep->sc_num_regs; i++)
76+ {
77+ if (tdep->sc_reg_offset[i] != ARC_OFFSET_NO_REGISTER)
78+ cache->saved_regs[i].addr = addr + tdep->sc_reg_offset[i];
79+ }
80+
81+ return cache;
82+}
83+
84+/* Implement the "this_id" frame_unwind method for signal trampoline
85+ frames. */
86+
87+static void
88+arc_sigtramp_frame_this_id (struct frame_info *this_frame,
89+ void **this_cache, struct frame_id *this_id)
90+{
91+ if (arc_debug)
92+ debug_printf ("arc: sigtramp_frame_this_id\n");
93+
94+ if (*this_cache == NULL)
95+ *this_cache = arc_make_sigtramp_frame_cache (this_frame);
96+
97+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
98+ struct arc_frame_cache *cache = (struct arc_frame_cache *) *this_cache;
99+ CORE_ADDR stack_addr = cache->prev_sp;
100+ CORE_ADDR code_addr
101+ = get_frame_register_unsigned (this_frame, gdbarch_pc_regnum (gdbarch));
102+ *this_id = frame_id_build (stack_addr, code_addr);
103+}
104+
105+/* Get a register from a signal handler frame. */
106+
107+static struct value *
108+arc_sigtramp_frame_prev_register (struct frame_info *this_frame,
109+ void **this_cache, int regnum)
110+{
111+ if (arc_debug)
112+ debug_printf ("arc: sigtramp_frame_prev_register (regnum = %d)\n", regnum);
113+
114+ /* Make sure we've initialized the cache. */
115+ if (*this_cache == NULL)
116+ *this_cache = arc_make_sigtramp_frame_cache (this_frame);
117+
118+ struct arc_frame_cache *cache = (struct arc_frame_cache *) *this_cache;
119+ return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
120+}
121+
122+/* Frame sniffer for signal handler frame. Only recognize a frame if we
123+ have a sigcontext_addr handler in the target dependency. */
124+
125+static int
126+arc_sigtramp_frame_sniffer (const struct frame_unwind *self,
127+ struct frame_info *this_frame,
128+ void **this_cache)
129+{
130+ struct gdbarch_tdep *tdep;
131+
132+ if (arc_debug)
133+ debug_printf ("arc: sigtramp_frame_sniffer\n");
134+
135+ tdep = gdbarch_tdep (get_frame_arch (this_frame));
136+
137+ /* If we have a sigcontext_addr handler, then just return 1 (same as the
138+ "default_frame_sniffer ()"). */
139+ return (tdep->sigcontext_addr != NULL && tdep->is_sigtramp != NULL
140+ && tdep->is_sigtramp (this_frame));
141+}
142+
143 /* Structure defining the ARC ordinary frame unwind functions. Since we are
144 the fallback unwinder, we use the default frame sniffer, which always
145 accepts the frame. */
146@@ -1858,6 +1956,21 @@ static const struct frame_unwind arc_frame_unwind = {
147 NULL
148 };
149
150+/* Structure defining the ARC signal frame unwind functions. Custom
151+ sniffer is used, because this frame must be accepted only in the right
152+ context. */
153+
154+static const struct frame_unwind arc_sigtramp_frame_unwind = {
155+ SIGTRAMP_FRAME,
156+ default_frame_unwind_stop_reason,
157+ arc_sigtramp_frame_this_id,
158+ arc_sigtramp_frame_prev_register,
159+ NULL,
160+ arc_sigtramp_frame_sniffer,
161+ NULL,
162+ NULL
163+};
164+
165
166 static const struct frame_base arc_normal_base = {
167 &arc_frame_unwind,
168@@ -2272,6 +2385,7 @@ arc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
169 /* Frame unwinders and sniffers. */
170 dwarf2_frame_set_init_reg (gdbarch, arc_dwarf2_frame_init_reg);
171 dwarf2_append_unwinders (gdbarch);
172+ frame_unwind_append_unwinder (gdbarch, &arc_sigtramp_frame_unwind);
173 frame_unwind_append_unwinder (gdbarch, &arc_frame_unwind);
174 frame_base_set_default (gdbarch, &arc_normal_base);
175
176@@ -2350,6 +2464,15 @@ arc_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
177 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
178
179 fprintf_unfiltered (file, "arc_dump_tdep: jb_pc = %i\n", tdep->jb_pc);
180+
181+ fprintf_unfiltered (file, "arc_dump_tdep: is_sigtramp = <%s>\n",
182+ host_address_to_string (tdep->is_sigtramp));
183+ fprintf_unfiltered (file, "arc_dump_tdep: sigcontext_addr = <%s>\n",
184+ host_address_to_string (tdep->sigcontext_addr));
185+ fprintf_unfiltered (file, "arc_dump_tdep: sc_reg_offset = <%s>\n",
186+ host_address_to_string (tdep->sc_reg_offset));
187+ fprintf_unfiltered (file, "arc_dump_tdep: sc_num_regs = %d\n",
188+ tdep->sc_num_regs);
189 }
190
191 /* This command accepts single argument - address of instruction to
192diff --git a/gdb/arc-tdep.h b/gdb/arc-tdep.h
193index 50b14905134..70fc3d95c48 100644
194--- a/gdb/arc-tdep.h
195+++ b/gdb/arc-tdep.h
196@@ -124,6 +124,19 @@ struct gdbarch_tdep
197
198 /* Whether target has hardware (aka zero-delay) loops. */
199 bool has_hw_loops;
200+
201+ /* Detect sigtramp. */
202+ bool (*is_sigtramp) (struct frame_info *);
203+
204+ /* Get address of sigcontext for sigtramp. */
205+ CORE_ADDR (*sigcontext_addr) (struct frame_info *);
206+
207+ /* Offset of registers in `struct sigcontext'. */
208+ const int *sc_reg_offset;
209+
210+ /* Number of registers in sc_reg_offsets. Most likely a ARC_LAST_REGNUM,
211+ but in theory it could be less, so it is kept separate. */
212+ int sc_num_regs;
213 };
214
215 /* Utility functions used by other ARC-specific modules. */
216--
2172.16.2
218
diff --git a/meta/recipes-devtools/gdb/gdb/0013-arc-Add-support-for-signal-frames-for-Linux-targets.patch b/meta/recipes-devtools/gdb/gdb/0013-arc-Add-support-for-signal-frames-for-Linux-targets.patch
new file mode 100644
index 0000000000..f699a5888d
--- /dev/null
+++ b/meta/recipes-devtools/gdb/gdb/0013-arc-Add-support-for-signal-frames-for-Linux-targets.patch
@@ -0,0 +1,232 @@
1From 16ddc17b4f403a38701e0108b02aff967900cc66 Mon Sep 17 00:00:00 2001
2From: Anton Kolesov <Anton.Kolesov@synopsys.com>
3Date: Thu, 22 Dec 2016 21:52:16 +0300
4Subject: [PATCH 2/4] arc: Add support for signal frames for Linux targets
5
6Implement functions needed to unwind signal frames on ARC Linux targets.
7
8gdb/ChangeLog
9
10 * arc-linux-tdep.c (arc_linux_sc_reg_offsets): New static variable.
11 (arc_linux_is_sigtramp): New function.
12 (arc_linux_sigcontext_addr): Likewise.
13 (arc_linux_init_osabi): Use them.
14
15Upstream-Status: Backport [https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=d4af727286e3a9f177ba11677fbd3a012d36558a]
16
17Signed-off-by: Anton Kolesov <Anton.Kolesov@synopsys.com>
18Signed-off-by: Shahab Vahedi <shahab@synopsys.com>
19Signed-off-by: Alexey Brodkin <abrodkin@synopsys.com>
20---
21 gdb/arc-linux-tdep.c | 181 +++++++++++++++++++++++++++++++++++++++++++++++++++
22 1 file changed, 181 insertions(+)
23
24diff --git a/gdb/arc-linux-tdep.c b/gdb/arc-linux-tdep.c
25index a7bace12623..17bb3e7b276 100644
26--- a/gdb/arc-linux-tdep.c
27+++ b/gdb/arc-linux-tdep.c
28@@ -33,6 +33,60 @@
29
30 #define REGOFF(offset) (offset * ARC_REGISTER_SIZE)
31
32+/* arc_linux_sc_reg_offsets[i] is the offset of register i in the `struct
33+ sigcontext'. Array index is an internal GDB register number, as defined in
34+ arc-tdep.h:arc_regnum.
35+
36+ From <include/uapi/asm/sigcontext.h> and <include/uapi/asm/ptrace.h>.
37+
38+ The layout of this struct is tightly bound to "arc_regnum" enum
39+ in arc-tdep.h. Any change of order in there, must be reflected
40+ here as well. */
41+static const int arc_linux_sc_reg_offsets[] = {
42+ /* R0 - R12. */
43+ REGOFF (22), REGOFF (21), REGOFF (20), REGOFF (19),
44+ REGOFF (18), REGOFF (17), REGOFF (16), REGOFF (15),
45+ REGOFF (14), REGOFF (13), REGOFF (12), REGOFF (11),
46+ REGOFF (10),
47+
48+ /* R13 - R25. */
49+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
50+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
51+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
52+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
53+ ARC_OFFSET_NO_REGISTER,
54+
55+ REGOFF (9), /* R26 (GP) */
56+ REGOFF (8), /* FP */
57+ REGOFF (23), /* SP */
58+ ARC_OFFSET_NO_REGISTER, /* ILINK */
59+ ARC_OFFSET_NO_REGISTER, /* R30 */
60+ REGOFF (7), /* BLINK */
61+
62+ /* R32 - R59. */
63+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
64+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
65+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
66+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
67+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
68+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
69+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
70+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
71+ ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER, ARC_OFFSET_NO_REGISTER,
72+ ARC_OFFSET_NO_REGISTER,
73+
74+ REGOFF (4), /* LP_COUNT */
75+ ARC_OFFSET_NO_REGISTER, /* RESERVED */
76+ ARC_OFFSET_NO_REGISTER, /* LIMM */
77+ ARC_OFFSET_NO_REGISTER, /* PCL */
78+
79+ REGOFF (6), /* PC */
80+ REGOFF (5), /* STATUS32 */
81+ REGOFF (2), /* LP_START */
82+ REGOFF (3), /* LP_END */
83+ REGOFF (1), /* BTA */
84+};
85+
86 /* arc_linux_core_reg_offsets[i] is the offset in the .reg section of GDB
87 regnum i. Array index is an internal GDB register number, as defined in
88 arc-tdep.h:arc_regnum.
89@@ -87,6 +141,127 @@ static const int arc_linux_core_reg_offsets[] = {
90 REGOFF (6) /* ERET */
91 };
92
93+/* Is THIS_FRAME a sigtramp function - the function that returns from
94+ signal handler into normal execution flow? This is the case if the PC is
95+ either at the start of, or in the middle of the two instructions:
96+
97+ mov r8, __NR_rt_sigreturn ; __NR_rt_sigreturn == 139
98+ trap_s 0 ; `swi' for ARC700
99+
100+ On ARC uClibc Linux this function is called __default_rt_sa_restorer.
101+
102+ Returns TRUE if this is a sigtramp frame. */
103+
104+static bool
105+arc_linux_is_sigtramp (struct frame_info *this_frame)
106+{
107+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
108+ CORE_ADDR pc = get_frame_pc (this_frame);
109+
110+ if (arc_debug)
111+ {
112+ debug_printf ("arc-linux: arc_linux_is_sigtramp, pc=%s\n",
113+ paddress(gdbarch, pc));
114+ }
115+
116+ static const gdb_byte insns_be_hs[] = {
117+ 0x20, 0x8a, 0x12, 0xc2, /* mov r8,nr_rt_sigreturn */
118+ 0x78, 0x1e /* trap_s 0 */
119+ };
120+ static const gdb_byte insns_be_700[] = {
121+ 0x20, 0x8a, 0x12, 0xc2, /* mov r8,nr_rt_sigreturn */
122+ 0x22, 0x6f, 0x00, 0x3f /* swi */
123+ };
124+
125+ gdb_byte arc_sigtramp_insns[sizeof (insns_be_700)];
126+ size_t insns_sz;
127+ if (arc_mach_is_arcv2 (gdbarch))
128+ {
129+ insns_sz = sizeof (insns_be_hs);
130+ memcpy (arc_sigtramp_insns, insns_be_hs, insns_sz);
131+ }
132+ else
133+ {
134+ insns_sz = sizeof (insns_be_700);
135+ memcpy (arc_sigtramp_insns, insns_be_700, insns_sz);
136+ }
137+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
138+ {
139+ /* On little endian targets, ARC code section is in what is called
140+ "middle endian", where half-words are in the big-endian order,
141+ only bytes inside the halfwords are in the little endian order.
142+ As a result it is very easy to convert big endian instruction to
143+ little endian, since it is needed to swap bytes in the halfwords,
144+ so there is no need to have information on whether that is a
145+ 4-byte instruction or 2-byte. */
146+ gdb_assert ((insns_sz % 2) == 0);
147+ for (int i = 0; i < insns_sz; i += 2)
148+ std::swap (arc_sigtramp_insns[i], arc_sigtramp_insns[i+1]);
149+ }
150+
151+ gdb_byte buf[insns_sz];
152+
153+ /* Read the memory at the PC. Since we are stopped, any breakpoint must
154+ have been removed. */
155+ if (!safe_frame_unwind_memory (this_frame, pc, buf, insns_sz))
156+ {
157+ /* Failed to unwind frame. */
158+ return FALSE;
159+ }
160+
161+ /* Is that code the sigtramp instruction sequence? */
162+ if (memcmp (buf, arc_sigtramp_insns, insns_sz) == 0)
163+ return TRUE;
164+
165+ /* No - look one instruction earlier in the code... */
166+ if (!safe_frame_unwind_memory (this_frame, pc - 4, buf, insns_sz))
167+ {
168+ /* Failed to unwind frame. */
169+ return FALSE;
170+ }
171+
172+ return (memcmp (buf, arc_sigtramp_insns, insns_sz) == 0);
173+}
174+
175+/* Get sigcontext structure of sigtramp frame - it contains saved
176+ registers of interrupted frame.
177+
178+ Stack pointer points to the rt_sigframe structure, and sigcontext can
179+ be found as in:
180+
181+ struct rt_sigframe {
182+ struct siginfo info;
183+ struct ucontext uc;
184+ ...
185+ };
186+
187+ struct ucontext {
188+ unsigned long uc_flags;
189+ struct ucontext *uc_link;
190+ stack_t uc_stack;
191+ struct sigcontext uc_mcontext;
192+ sigset_t uc_sigmask;
193+ };
194+
195+ sizeof (struct siginfo) == 0x80
196+ offsetof (struct ucontext, uc_mcontext) == 0x14
197+
198+ GDB cannot include linux headers and use offsetof () because those are
199+ target headers and GDB might be built for a different run host. There
200+ doesn't seem to be an established mechanism to figure out those offsets
201+ via gdbserver, so the only way is to hardcode values in the GDB,
202+ meaning that GDB will be broken if values will change. That seems to
203+ be a very unlikely scenario and other arches (aarch64, alpha, amd64,
204+ etc) in GDB hardcode values. */
205+
206+static CORE_ADDR
207+arc_linux_sigcontext_addr (struct frame_info *this_frame)
208+{
209+ const int ucontext_offset = 0x80;
210+ const int sigcontext_offset = 0x14;
211+ return get_frame_sp (this_frame) + ucontext_offset + sigcontext_offset;
212+}
213+
214 /* Implement the "cannot_fetch_register" gdbarch method. */
215
216 static int
217@@ -504,6 +679,12 @@ arc_linux_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
218 if (arc_debug)
219 debug_printf ("arc-linux: GNU/Linux OS/ABI initialization.\n");
220
221+ /* Fill in target-dependent info in ARC-private structure. */
222+ tdep->is_sigtramp = arc_linux_is_sigtramp;
223+ tdep->sigcontext_addr = arc_linux_sigcontext_addr;
224+ tdep->sc_reg_offset = arc_linux_sc_reg_offsets;
225+ tdep->sc_num_regs = ARRAY_SIZE (arc_linux_sc_reg_offsets);
226+
227 /* If we are using Linux, we have in uClibc
228 (libc/sysdeps/linux/arc/bits/setjmp.h):
229
230--
2312.16.2
232
diff --git a/meta/recipes-devtools/gdb/gdb/0014-arc-Take-into-account-the-REGNUM-in-supply-collect-g.patch b/meta/recipes-devtools/gdb/gdb/0014-arc-Take-into-account-the-REGNUM-in-supply-collect-g.patch
new file mode 100644
index 0000000000..a7256065cc
--- /dev/null
+++ b/meta/recipes-devtools/gdb/gdb/0014-arc-Take-into-account-the-REGNUM-in-supply-collect-g.patch
@@ -0,0 +1,104 @@
1From 5eb97d5e92ad23ee81cebc1ebd5eafe0aa55fc17 Mon Sep 17 00:00:00 2001
2From: Shahab Vahedi <shahab@synopsys.com>
3Date: Tue, 10 Nov 2020 19:34:57 +0100
4Subject: [PATCH 3/4] arc: Take into account the REGNUM in supply/collect gdb
5 hooks
6
7All the arc_linux_supply_*() target operations and the
8arc_linux_collect_v2_regset() in arc-linux-tdep.c were
9supplying/collecting all the registers in regcache as if the
10REGNUM was set to -1.
11
12The more efficient behavior is to examine the REGNUM and act
13accordingly. That is what this patch does.
14
15gdb/ChangeLog:
16
17 * arc-linux-tdep.c (supply_register): New.
18 (arc_linux_supply_gregset, arc_linux_supply_v2_regset,
19 arc_linux_collect_v2_regset): Consider REGNUM.
20
21Upstream-Status: Backport [https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=46023bbe81355230b4e7b76d3084337823d02362]
22
23Signed-off-by: Shahab Vahedi <shahab@synopsys.com>
24Signed-off-by: Alexey Brodkin <abrodkin@synopsys.com>
25---
26 gdb/arc-linux-tdep.c | 41 ++++++++++++++++++++++++++++++++---------
27 1 file changed, 32 insertions(+), 9 deletions(-)
28
29diff --git a/gdb/arc-linux-tdep.c b/gdb/arc-linux-tdep.c
30index 17bb3e7b276..e83d82b6f5c 100644
31--- a/gdb/arc-linux-tdep.c
32+++ b/gdb/arc-linux-tdep.c
33@@ -535,6 +535,18 @@ arc_linux_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
34 }
35 }
36
37+/* Populate REGCACHE with register REGNUM from BUF. */
38+
39+static void
40+supply_register (struct regcache *regcache, int regnum, const gdb_byte *buf)
41+{
42+ /* Skip non-existing registers. */
43+ if ((arc_linux_core_reg_offsets[regnum] == ARC_OFFSET_NO_REGISTER))
44+ return;
45+
46+ regcache->raw_supply (regnum, buf + arc_linux_core_reg_offsets[regnum]);
47+}
48+
49 void
50 arc_linux_supply_gregset (const struct regset *regset,
51 struct regcache *regcache,
52@@ -545,9 +557,14 @@ arc_linux_supply_gregset (const struct regset *regset,
53
54 const bfd_byte *buf = (const bfd_byte *) gregs;
55
56- for (int reg = 0; reg <= ARC_LAST_REGNUM; reg++)
57- if (arc_linux_core_reg_offsets[reg] != ARC_OFFSET_NO_REGISTER)
58- regcache->raw_supply (reg, buf + arc_linux_core_reg_offsets[reg]);
59+ /* regnum == -1 means writing all the registers. */
60+ if (regnum == -1)
61+ for (int reg = 0; reg <= ARC_LAST_REGNUM; reg++)
62+ supply_register (regcache, reg, buf);
63+ else if (regnum <= ARC_LAST_REGNUM)
64+ supply_register (regcache, regnum, buf);
65+ else
66+ gdb_assert_not_reached ("Invalid regnum in arc_linux_supply_gregset.");
67 }
68
69 void
70@@ -558,9 +575,12 @@ arc_linux_supply_v2_regset (const struct regset *regset,
71 const bfd_byte *buf = (const bfd_byte *) v2_regs;
72
73 /* user_regs_arcv2 is defined in linux arch/arc/include/uapi/asm/ptrace.h. */
74- regcache->raw_supply (ARC_R30_REGNUM, buf);
75- regcache->raw_supply (ARC_R58_REGNUM, buf + REGOFF (1));
76- regcache->raw_supply (ARC_R59_REGNUM, buf + REGOFF (2));
77+ if (regnum == -1 || regnum == ARC_R30_REGNUM)
78+ regcache->raw_supply (ARC_R30_REGNUM, buf);
79+ if (regnum == -1 || regnum == ARC_R58_REGNUM)
80+ regcache->raw_supply (ARC_R58_REGNUM, buf + REGOFF (1));
81+ if (regnum == -1 || regnum == ARC_R59_REGNUM)
82+ regcache->raw_supply (ARC_R59_REGNUM, buf + REGOFF (2));
83 }
84
85 /* Populate BUF with register REGNUM from the REGCACHE. */
86@@ -618,9 +638,12 @@ arc_linux_collect_v2_regset (const struct regset *regset,
87 {
88 bfd_byte *buf = (bfd_byte *) v2_regs;
89
90- regcache->raw_collect (ARC_R30_REGNUM, buf);
91- regcache->raw_collect (ARC_R58_REGNUM, buf + REGOFF (1));
92- regcache->raw_collect (ARC_R59_REGNUM, buf + REGOFF (2));
93+ if (regnum == -1 || regnum == ARC_R30_REGNUM)
94+ regcache->raw_collect (ARC_R30_REGNUM, buf);
95+ if (regnum == -1 || regnum == ARC_R58_REGNUM)
96+ regcache->raw_collect (ARC_R58_REGNUM, buf + REGOFF (1));
97+ if (regnum == -1 || regnum == ARC_R59_REGNUM)
98+ regcache->raw_collect (ARC_R59_REGNUM, buf + REGOFF (2));
99 }
100
101 /* Linux regset definitions. */
102--
1032.16.2
104
diff --git a/meta/recipes-devtools/gdb/gdb/0015-gdb-Add-native-support-for-ARC-in-GNU-Linux.patch b/meta/recipes-devtools/gdb/gdb/0015-gdb-Add-native-support-for-ARC-in-GNU-Linux.patch
new file mode 100644
index 0000000000..31cf0b0be2
--- /dev/null
+++ b/meta/recipes-devtools/gdb/gdb/0015-gdb-Add-native-support-for-ARC-in-GNU-Linux.patch
@@ -0,0 +1,414 @@
1From 32b366249fd42d74cbc4a91039431554ebadcfd0 Mon Sep 17 00:00:00 2001
2From: Anton Kolesov <anton.kolesov@synopsys.com>
3Date: Fri, 14 Feb 2014 11:56:23 +0400
4Subject: [PATCH 4/4] gdb: Add native support for ARC in GNU/Linux
5
6With this patch in place it is possible to build a GDB that
7can run on ARC (GNU/Linux) hosts for debugging ARC targets.
8
9The "arc-linux-nat.c" is a rather small one that mostly deals
10with registers and a few thread related hooks.
11
12v2 [1]:
13- Remove "void" from the input of "_initialize_arc_linux_nat ()"
14
15[1] Tom's remark after the first patch
16https://sourceware.org/pipermail/gdb-patches/2020-November/173223.html
17
18gdb/ChangeLog:
19
20 * Makefile.in (ALLDEPFILES): Add arc-linux-nat.c.
21 * configure.host (host to gdb names): Add arc*-*-linux*.
22 * configure.nat (gdb_host_cpu): Add arc.
23 * arc-linux-nat.c: New.
24
25Upstream-Status: Backport [https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=04c9f85efcd8df5fc482ce97c0104cc7dd5d19e6]
26
27Signed-off-by: Anton Kolesov <Anton.Kolesov@synopsys.com>
28Signed-off-by: Shahab Vahedi <shahab@synopsys.com>
29Signed-off-by: Alexey Brodkin <abrodkin@synopsys.com>
30---
31 gdb/Makefile.in | 1 +
32 gdb/arc-linux-nat.c | 320 ++++++++++++++++++++++++++++++++++++++++++++++++++++
33 gdb/configure.host | 3 +
34 gdb/configure.nat | 4 +
35 4 files changed, 328 insertions(+)
36 create mode 100644 gdb/arc-linux-nat.c
37
38diff --git a/gdb/Makefile.in b/gdb/Makefile.in
39index ec371fc7e52..c76136907ae 100644
40--- a/gdb/Makefile.in
41+++ b/gdb/Makefile.in
42@@ -2136,6 +2136,7 @@ ALLDEPFILES = \
43 amd64-obsd-tdep.c \
44 amd64-sol2-tdep.c \
45 amd64-tdep.c \
46+ arc-linux-nat.c \
47 arc-tdep.c \
48 arm.c \
49 arm-bsd-tdep.c \
50diff --git a/gdb/arc-linux-nat.c b/gdb/arc-linux-nat.c
51new file mode 100644
52index 00000000000..41301fd4fed
53--- /dev/null
54+++ b/gdb/arc-linux-nat.c
55@@ -0,0 +1,320 @@
56+/* Native-dependent code for GNU/Linux ARC.
57+
58+ Copyright 2020 Free Software Foundation, Inc.
59+
60+ This file is part of GDB.
61+
62+ This program is free software; you can redistribute it and/or modify
63+ it under the terms of the GNU General Public License as published by
64+ the Free Software Foundation; either version 3 of the License, or
65+ (at your option) any later version.
66+
67+ This program is distributed in the hope that it will be useful,
68+ but WITHOUT ANY WARRANTY; without even the implied warranty of
69+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
70+ GNU General Public License for more details.
71+
72+ You should have received a copy of the GNU General Public License
73+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
74+
75+#include "defs.h"
76+#include "frame.h"
77+#include "inferior.h"
78+#include "gdbcore.h"
79+#include "regcache.h"
80+#include "gdbsupport/gdb_assert.h"
81+#include "target.h"
82+#include "linux-nat.h"
83+#include "nat/gdb_ptrace.h"
84+
85+#include <stdint.h>
86+#include <sys/types.h>
87+#include <sys/param.h>
88+#include <signal.h>
89+#include <sys/user.h>
90+#include <sys/ioctl.h>
91+#include "gdbsupport/gdb_wait.h"
92+#include <fcntl.h>
93+#include <sys/procfs.h>
94+#include <linux/elf.h>
95+
96+#include "gregset.h"
97+#include "arc-tdep.h"
98+#include "arc-linux-tdep.h"
99+#include "arch/arc.h"
100+
101+/* Defines ps_err_e, struct ps_prochandle. */
102+#include "gdb_proc_service.h"
103+
104+/* Linux starting with 4.12 supports NT_ARC_V2 note type, which adds R30,
105+ R58 and R59 registers, which are specific to ARC HS and aren't
106+ available in ARC 700. */
107+#if defined (NT_ARC_V2) && defined (__ARCHS__)
108+#define ARC_HAS_V2_REGSET
109+#endif
110+
111+class arc_linux_nat_target final : public linux_nat_target
112+{
113+public:
114+ /* Add ARC register access methods. */
115+ void fetch_registers (struct regcache *, int) override;
116+ void store_registers (struct regcache *, int) override;
117+
118+ const struct target_desc *read_description () override;
119+
120+ /* Handle threads */
121+ void low_prepare_to_resume (struct lwp_info *lp) override;
122+};
123+
124+static arc_linux_nat_target the_arc_linux_nat_target;
125+
126+/* Read general registers from target process/thread (via ptrace)
127+ into REGCACHE. */
128+
129+static void
130+fetch_gregs (struct regcache *regcache, int regnum)
131+{
132+ const int tid = get_ptrace_pid (regcache->ptid ());
133+ struct iovec iov;
134+ gdb_gregset_t regs;
135+
136+ iov.iov_base = &regs;
137+ iov.iov_len = sizeof (gdb_gregset_t);
138+
139+ if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
140+ perror_with_name (_("Couldn't get general registers"));
141+ else
142+ arc_linux_supply_gregset (NULL, regcache, regnum, &regs, 0);
143+}
144+
145+#ifdef ARC_HAS_V2_REGSET
146+/* Read ARC v2 registers from target process/thread (via ptrace)
147+ into REGCACHE. */
148+
149+static void
150+fetch_v2_regs (struct regcache *regcache, int regnum)
151+{
152+ const int tid = get_ptrace_pid (regcache->ptid ());
153+ struct iovec iov;
154+ bfd_byte v2_buffer[ARC_LINUX_SIZEOF_V2_REGSET];
155+
156+ iov.iov_base = &v2_buffer;
157+ iov.iov_len = ARC_LINUX_SIZEOF_V2_REGSET;
158+
159+ if (ptrace (PTRACE_GETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
160+ perror_with_name (_("Couldn't get ARC HS registers"));
161+ else
162+ arc_linux_supply_v2_regset (NULL, regcache, regnum, v2_buffer, 0);
163+}
164+#endif
165+
166+/* Store general registers from REGCACHE into the target process/thread. */
167+
168+static void
169+store_gregs (const struct regcache *regcache, int regnum)
170+{
171+ const int tid = get_ptrace_pid (regcache->ptid ());
172+ struct iovec iov;
173+ gdb_gregset_t regs;
174+
175+ iov.iov_base = &regs;
176+ iov.iov_len = sizeof (gdb_gregset_t);
177+
178+ if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
179+ perror_with_name (_("Couldn't get general registers"));
180+ else
181+ {
182+ arc_linux_collect_gregset (NULL, regcache, regnum, regs, 0);
183+
184+ if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
185+ perror_with_name (_("Couldn't write general registers"));
186+ }
187+}
188+
189+#ifdef ARC_HAS_V2_REGSET
190+/* Store ARC v2 registers from REGCACHE into the target process/thread. */
191+
192+static void
193+store_v2_regs (const struct regcache *regcache, int regnum)
194+{
195+ const int tid = get_ptrace_pid (regcache->ptid ());
196+ struct iovec iov;
197+ bfd_byte v2_buffer[ARC_LINUX_SIZEOF_V2_REGSET];
198+
199+ iov.iov_base = &v2_buffer;
200+ iov.iov_len = ARC_LINUX_SIZEOF_V2_REGSET;
201+
202+ if (ptrace (PTRACE_GETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
203+ perror_with_name (_("Couldn't get ARC HS registers"));
204+ else
205+ {
206+ arc_linux_collect_v2_regset (NULL, regcache, regnum, v2_buffer, 0);
207+
208+ if (ptrace (PTRACE_SETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
209+ perror_with_name (_("Couldn't write ARC HS registers"));
210+ }
211+}
212+#endif
213+
214+/* Target operation: Read REGNUM register (all registers if REGNUM == -1)
215+ from target process into REGCACHE. */
216+
217+void
218+arc_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
219+{
220+
221+ if (regnum == -1 || regnum <= ARC_LAST_REGNUM)
222+ fetch_gregs (regcache, regnum);
223+
224+#ifdef ARC_HAS_V2_REGSET
225+ if (regnum == -1
226+ || regnum == ARC_R30_REGNUM
227+ || regnum == ARC_R58_REGNUM
228+ || regnum == ARC_R59_REGNUM)
229+ fetch_v2_regs (regcache, regnum);
230+#endif
231+}
232+
233+/* Target operation: Store REGNUM register (all registers if REGNUM == -1)
234+ to the target process from REGCACHE. */
235+
236+void
237+arc_linux_nat_target::store_registers (struct regcache *regcache, int regnum)
238+{
239+ if (regnum == -1 || regnum <= ARC_LAST_REGNUM)
240+ store_gregs (regcache, regnum);
241+
242+#ifdef ARC_HAS_V2_REGSET
243+ if (regnum == -1
244+ || regnum == ARC_R30_REGNUM
245+ || regnum == ARC_R58_REGNUM
246+ || regnum == ARC_R59_REGNUM)
247+ store_v2_regs (regcache, regnum);
248+#endif
249+}
250+
251+/* Copy general purpose register(s) from REGCACHE into regset GREGS.
252+ This function is exported to proc-service.c */
253+
254+void
255+fill_gregset (const struct regcache *regcache,
256+ gdb_gregset_t *gregs, int regnum)
257+{
258+ arc_linux_collect_gregset (NULL, regcache, regnum, gregs, 0);
259+}
260+
261+/* Copy all the general purpose registers from regset GREGS into REGCACHE.
262+ This function is exported to proc-service.c. */
263+
264+void
265+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregs)
266+{
267+ arc_linux_supply_gregset (NULL, regcache, -1, gregs, 0);
268+}
269+
270+/* ARC doesn't have separate FP registers. This function is exported
271+ to proc-service.c. */
272+
273+void
274+fill_fpregset (const struct regcache *regcache,
275+ gdb_fpregset_t *fpregsetp, int regnum)
276+{
277+ if (arc_debug)
278+ debug_printf ("arc-linux-nat: fill_fpregset called.");
279+ return;
280+}
281+
282+/* ARC doesn't have separate FP registers. This function is exported
283+ to proc-service.c. */
284+
285+void
286+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
287+{
288+ if (arc_debug)
289+ debug_printf ("arc-linux-nat: supply_fpregset called.");
290+ return;
291+}
292+
293+/* Implement the "read_description" method of linux_nat_target. */
294+
295+const struct target_desc *
296+arc_linux_nat_target::read_description ()
297+{
298+ /* This is a native target, hence description is hardcoded. */
299+#ifdef __ARCHS__
300+ arc_arch_features features (4, ARC_ISA_ARCV2);
301+#else
302+ arc_arch_features features (4, ARC_ISA_ARCV1);
303+#endif
304+ return arc_lookup_target_description (features);
305+}
306+
307+/* As described in arc_linux_collect_gregset(), we need to write resume-PC
308+ to ERET. However by default GDB for native targets doesn't write
309+ registers if they haven't been changed. This is a callback called by
310+ generic GDB, and in this callback we have to rewrite PC value so it
311+ would force rewrite of register on target. It seems that the only
312+ other arch that utilizes this hook is x86/x86-64 for HW breakpoint
313+ support. But then, AFAIK no other arch has this stop_pc/eret
314+ complexity.
315+
316+ No better way was found, other than this fake write of register value,
317+ to force GDB into writing register to target. Is there any? */
318+
319+void
320+arc_linux_nat_target::low_prepare_to_resume (struct lwp_info *lwp)
321+{
322+ /* When new processes and threads are created we do not have the address
323+ space for them and calling get_thread_regcache will cause an internal
324+ error in GDB. It looks like that checking for last_resume_kind is the
325+ sensible way to determine processes for which we cannot get regcache.
326+ Ultimately, a better way would be removing the need for
327+ low_prepare_to_resume in the first place. */
328+ if (lwp->last_resume_kind == resume_stop)
329+ return;
330+
331+ struct regcache *regcache = get_thread_regcache (this, lwp->ptid);
332+ struct gdbarch *gdbarch = regcache->arch ();
333+
334+ /* Read current PC value, then write it back. It is required to call
335+ invalidate(), otherwise GDB will note that new value is equal to old
336+ value and will skip write. */
337+ ULONGEST new_pc;
338+ regcache_cooked_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch),
339+ &new_pc);
340+ regcache->invalidate (gdbarch_pc_regnum (gdbarch));
341+ regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch),
342+ new_pc);
343+}
344+
345+/* Fetch the thread-local storage pointer for libthread_db. Note that
346+ this function is not called from GDB, but is called from libthread_db.
347+ This is required to debug multithreaded applications with NPTL. */
348+
349+ps_err_e
350+ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx,
351+ void **base)
352+{
353+ if (arc_debug >= 2)
354+ debug_printf ("arc-linux-nat: ps_get_thread_area called");
355+
356+ if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
357+ return PS_ERR;
358+
359+ /* IDX is the bias from the thread pointer to the beginning of the
360+ thread descriptor. It has to be subtracted due to implementation
361+ quirks in libthread_db. */
362+ *base = (void *) ((char *) *base - idx);
363+
364+ return PS_OK;
365+}
366+
367+/* Suppress warning from -Wmissing-prototypes. */
368+void _initialize_arc_linux_nat ();
369+void
370+_initialize_arc_linux_nat ()
371+{
372+ /* Register the target. */
373+ linux_target = &the_arc_linux_nat_target;
374+ add_inf_child_target (&the_arc_linux_nat_target);
375+}
376diff --git a/gdb/configure.host b/gdb/configure.host
377index ce528237291..e94a19b0332 100644
378--- a/gdb/configure.host
379+++ b/gdb/configure.host
380@@ -60,6 +60,7 @@ case "${host_cpu}" in
381
382 aarch64*) gdb_host_cpu=aarch64 ;;
383 alpha*) gdb_host_cpu=alpha ;;
384+arc*) gdb_host_cpu=arc ;;
385 arm*) gdb_host_cpu=arm ;;
386 hppa*) gdb_host_cpu=pa ;;
387 i[34567]86*) gdb_host_cpu=i386 ;;
388@@ -91,6 +92,8 @@ alpha*-*-netbsd* | alpha*-*-knetbsd*-gnu)
389 gdb_host=nbsd ;;
390 alpha*-*-openbsd*) gdb_host=nbsd ;;
391
392+arc*-*-linux*) gdb_host=linux ;;
393+
394 arm*-*-freebsd*) gdb_host=fbsd ;;
395 arm*-*-linux*) gdb_host=linux ;;
396 arm*-*-netbsdelf* | arm*-*-knetbsd*-gnu)
397diff --git a/gdb/configure.nat b/gdb/configure.nat
398index bb70e303384..cd11bc86dca 100644
399--- a/gdb/configure.nat
400+++ b/gdb/configure.nat
401@@ -238,6 +238,10 @@ case ${gdb_host} in
402 nat/aarch64-linux.o \
403 nat/aarch64-sve-linux-ptrace.o"
404 ;;
405+ arc)
406+ # Host: ARC based machine running GNU/Linux
407+ NATDEPFILES="${NATDEPFILES} arc-linux-nat.o"
408+ ;;
409 arm)
410 # Host: ARM based machine running GNU/Linux
411 NATDEPFILES="${NATDEPFILES} arm-linux-nat.o \
412--
4132.16.2
414
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-05-12 10:43:15 +0000