GDB (xrefs)
Loading...
Searching...
No Matches
target.c
Go to the documentation of this file.
1/* Select target systems and architectures at runtime for GDB.
2
3 Copyright (C) 1990-2023 Free Software Foundation, Inc.
4
5 Contributed by Cygnus Support.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22#include "defs.h"
23#include "target.h"
24#include "target-dcache.h"
25#include "gdbcmd.h"
26#include "symtab.h"
27#include "inferior.h"
28#include "infrun.h"
29#include "observable.h"
30#include "bfd.h"
31#include "symfile.h"
32#include "objfiles.h"
33#include "dcache.h"
34#include <signal.h>
35#include "regcache.h"
36#include "gdbcore.h"
37#include "target-descriptions.h"
38#include "gdbthread.h"
39#include "solib.h"
40#include "exec.h"
41#include "inline-frame.h"
42#include "tracepoint.h"
43#include "gdbsupport/fileio.h"
44#include "gdbsupport/agent.h"
45#include "auxv.h"
46#include "target-debug.h"
47#include "ui.h"
48#include "event-top.h"
49#include <algorithm>
50#include "gdbsupport/byte-vector.h"
51#include "gdbsupport/search.h"
52#include "terminal.h"
53#include <unordered_map>
54#include "target-connection.h"
55#include "valprint.h"
56#include "cli/cli-decode.h"
57
58static void generic_tls_error (void) ATTRIBUTE_NORETURN;
59
60static void default_terminal_info (struct target_ops *, const char *, int);
61
63 CORE_ADDR, CORE_ADDR, int);
64
66 CORE_ADDR, int);
67
68static void default_rcmd (struct target_ops *, const char *, struct ui_file *);
69
70static ptid_t default_get_ada_task_ptid (struct target_ops *self,
71 long lwp, ULONGEST tid);
72
73static void default_mourn_inferior (struct target_ops *self);
74
75static int default_search_memory (struct target_ops *ops,
76 CORE_ADDR start_addr,
77 ULONGEST search_space_len,
78 const gdb_byte *pattern,
79 ULONGEST pattern_len,
80 CORE_ADDR *found_addrp);
81
82static int default_verify_memory (struct target_ops *self,
83 const gdb_byte *data,
84 CORE_ADDR memaddr, ULONGEST size);
85
86static void tcomplain (void) ATTRIBUTE_NORETURN;
87
88static struct target_ops *find_default_run_target (const char *);
89
90static int dummy_find_memory_regions (struct target_ops *self,
92 void *ignore2);
93
94static gdb::unique_xmalloc_ptr<char> dummy_make_corefile_notes
95 (struct target_ops *self, bfd *ignore1, int *ignore2);
96
97static std::string default_pid_to_str (struct target_ops *ops, ptid_t ptid);
98
100 (struct target_ops *self);
101
102/* Mapping between target_info objects (which have address identity)
103 and corresponding open/factory function/callback. Each add_target
104 call adds one entry to this map, and registers a "target
105 TARGET_NAME" command that when invoked calls the factory registered
106 here. The target_info object is associated with the command via
107 the command's context. */
108static std::unordered_map<const target_info *, target_open_ftype *>
109 target_factories;
110
111/* The singleton debug target. */
112
113static struct target_ops *the_debug_target;
114
115/* Command list for target. */
116
117static struct cmd_list_element *targetlist = NULL;
118
119/* See target.h. */
120
121bool trust_readonly = false;
122
123/* Nonzero if we should show true memory content including
124 memory breakpoint inserted by gdb. */
125
126static int show_memory_breakpoints = 0;
127
128/* These globals control whether GDB attempts to perform these
129 operations; they are useful for targets that need to prevent
130 inadvertent disruption, such as in non-stop mode. */
131
132bool may_write_registers = true;
133
134bool may_write_memory = true;
135
136bool may_insert_breakpoints = true;
137
138bool may_insert_tracepoints = true;
139
141
142bool may_stop = true;
143
144/* Non-zero if we want to see trace of target level stuff. */
145
146static unsigned int targetdebug = 0;
147
148static void
149set_targetdebug (const char *args, int from_tty, struct cmd_list_element *c)
150{
151 if (targetdebug)
152 current_inferior ()->push_target (the_debug_target);
153 else
154 current_inferior ()->unpush_target (the_debug_target);
155}
156
157static void
158show_targetdebug (struct ui_file *file, int from_tty,
159 struct cmd_list_element *c, const char *value)
160{
161 gdb_printf (file, _("Target debugging is %s.\n"), value);
162}
163
164int
166{
167 for (target_ops *t = current_inferior ()->top_target ();
168 t != NULL;
169 t = t->beneath ())
170 if (t->has_memory ())
171 return 1;
172
173 return 0;
174}
175
176int
178{
179 for (target_ops *t = current_inferior ()->top_target ();
180 t != NULL;
181 t = t->beneath ())
182 if (t->has_stack ())
183 return 1;
184
185 return 0;
186}
187
188int
190{
191 for (target_ops *t = current_inferior ()->top_target ();
192 t != NULL;
193 t = t->beneath ())
194 if (t->has_registers ())
195 return 1;
196
197 return 0;
198}
199
200bool
202{
203 if (inf == nullptr)
205
206 for (target_ops *t = inf->top_target ();
207 t != nullptr;
208 t = inf->find_target_beneath (t))
209 if (t->has_execution (inf))
210 return true;
211
212 return false;
213}
214
215const char *
217{
218 return current_inferior ()->top_target ()->shortname ();
219}
220
221/* See target.h. */
222
223bool
228
229/* See target.h. */
230
231void
233{
235}
236
237/* See target.h. */
238
239void
244
245/* See target.h. */
246
247bool
254
255bool
260
261/* See target.h. */
262
263bool
270
271/* See target.h. */
272
273bool
278
279/* See target.h. */
280
281void
282target_dumpcore (const char *filename)
283{
284 return current_inferior ()->top_target ()->dumpcore (filename);
285}
286
287/* See target.h. */
288
289bool
294
295/* See target.h. */
296
297void
299{
300 return current_inferior ()->top_target ()->files_info ();
301}
302
303/* See target.h. */
304
305int
310
311/* See target.h. */
312
313int
318
319/* See target.h. */
320
321int
326
327/* See target.h. */
328
329int
334
335/* See target.h. */
336
337int
342
343/* See target.h. */
344
345int
350
351/* See target.h. */
352
353int
354target_set_syscall_catchpoint (int pid, bool needed, int any_count,
355 gdb::array_view<const int> syscall_counts)
356{
357 target_ops *target = current_inferior ()->top_target ();
358
359 return target->set_syscall_catchpoint (pid, needed, any_count,
360 syscall_counts);
361}
362
363/* See target.h. */
364
365void
366target_rcmd (const char *command, struct ui_file *outbuf)
367{
368 return current_inferior ()->top_target ()->rcmd (command, outbuf);
369}
370
371/* See target.h. */
372
373bool
375{
376 target_ops *target = current_inferior ()->top_target ();
377
378 return (target->get_thread_control_capabilities ()& tc_schedlock) != 0;
379}
380
381/* See target.h. */
382
383bool
385{
386 return target_can_async_p (current_inferior ()->top_target ());
387}
388
389/* See target.h. */
390
391bool
393{
395 return false;
396 return target->can_async_p ();
397}
398
399/* See target.h. */
400
401bool
403{
404 bool result = current_inferior ()->top_target ()->is_async_p ();
405 gdb_assert (target_async_permitted || !result);
406 return result;
407}
408
414
415/* See target.h. */
416
417const char *
422
423/* See target.h. */
424
425const char *
430
431/* See target.h. */
432
433gdbarch *
435{
436 return current_inferior ()->top_target ()->thread_architecture (ptid);
437}
438
439/* See target.h. */
440
441int
446
447/* See target.h. */
448
449gdb::unique_xmalloc_ptr<char>
450target_make_corefile_notes (bfd *bfd, int *size_p)
451{
452 return current_inferior ()->top_target ()->make_corefile_notes (bfd, size_p);
453}
454
455gdb_byte *
456target_get_bookmark (const char *args, int from_tty)
457{
458 return current_inferior ()->top_target ()->get_bookmark (args, from_tty);
459}
460
461void
462target_goto_bookmark (const gdb_byte *arg, int from_tty)
463{
464 return current_inferior ()->top_target ()->goto_bookmark (arg, from_tty);
465}
466
467/* See target.h. */
468
469bool
474
475/* See target.h. */
476
477bool
482
483bool
490
491bool
496
497bool
504
505/* See target.h. */
506
507bool
512
513/* See target.h. */
514
515int
517{
518 target_ops *target = current_inferior ()->top_target ();
519
520 return target->can_use_hw_breakpoint (type, cnt, othertype);
521}
522
523/* See target.h. */
524
525int
526target_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
527{
528 target_ops *target = current_inferior ()->top_target ();
529
530 return target->region_ok_for_hw_watchpoint (addr, len);
531}
532
533
534int
539
540/* See target.h. */
541
542int
543target_insert_watchpoint (CORE_ADDR addr, int len, target_hw_bp_type type,
544 expression *cond)
545{
546 target_ops *target = current_inferior ()->top_target ();
547
548 return target->insert_watchpoint (addr, len, type, cond);
549}
550
551/* See target.h. */
552
553int
554target_remove_watchpoint (CORE_ADDR addr, int len, target_hw_bp_type type,
555 expression *cond)
556{
557 target_ops *target = current_inferior ()->top_target ();
558
559 return target->remove_watchpoint (addr, len, type, cond);
560}
561
562/* See target.h. */
563
564int
566{
567 target_ops *target = current_inferior ()->top_target ();
568
569 return target->insert_hw_breakpoint (gdbarch, bp_tgt);
570}
571
572/* See target.h. */
573
574int
576{
577 target_ops *target = current_inferior ()->top_target ();
578
579 return target->remove_hw_breakpoint (gdbarch, bp_tgt);
580}
581
582/* See target.h. */
583
584bool
585target_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int type,
586 expression *cond)
587{
588 target_ops *target = current_inferior ()->top_target ();
589
590 return target->can_accel_watchpoint_condition (addr, len, type, cond);
591}
592
593/* See target.h. */
594
595bool
600
601ptid_t
602target_get_ada_task_ptid (long lwp, ULONGEST tid)
603{
604 return current_inferior ()->top_target ()->get_ada_task_ptid (lwp, tid);
605}
606
607bool
612
613void
615{
616 return current_inferior ()->top_target ()->trace_init ();
617}
618
619void
621{
622 return current_inferior ()->top_target ()->download_tracepoint (location);
623}
624
625bool
630
631void
638
639void
644
645void
650
651void
653{
654 return current_inferior ()->top_target ()->trace_start ();
655}
656
657void
662
663int
668
669void
674
675void
677{
678 return current_inferior ()->top_target ()->trace_stop ();
679}
680
681int
683 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
684{
685 target_ops *target = current_inferior ()->top_target ();
686
687 return target->trace_find (type, num, addr1, addr2, tpp);
688}
689
690bool
692{
693 target_ops *target = current_inferior ()->top_target ();
694
695 return target->get_trace_state_variable_value (tsv, val);
696}
697
698int
699target_save_trace_data (const char *filename)
700{
701 return current_inferior ()->top_target ()->save_trace_data (filename);
702}
703
704int
709
710int
712{
713 target_ops *target = current_inferior ()->top_target ();
714
715 return target->upload_trace_state_variables (utsvp);
716}
717
718LONGEST
719target_get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
720{
721 target_ops *target = current_inferior ()->top_target ();
722
723 return target->get_raw_trace_data (buf, offset, len);
724}
725
726int
733
734void
739
740void
745
746void
748{
750}
751
752bool
753target_set_trace_notes (const char *user, const char *notes,
754 const char *stopnotes)
755{
756 target_ops *target = current_inferior ()->top_target ();
757
758 return target->set_trace_notes (user, notes, stopnotes);
759}
760
761bool
762target_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
763{
764 return current_inferior ()->top_target ()->get_tib_address (ptid, addr);
765}
766
767void
772
773bool
776{
777 target_ops *target = current_inferior ()->top_target ();
778
779 return target->static_tracepoint_marker_at (addr, marker);
780}
781
782std::vector<static_tracepoint_marker>
784{
785 target_ops *target = current_inferior ()->top_target ();
786
787 return target->static_tracepoint_markers_by_strid (marker_id);
788}
789
795
796bool
798{
799 return current_inferior ()->top_target ()->use_agent (use);
800}
801
802bool
807
808bool
813
814bool
819
820bool
821target_fetch_memtags (CORE_ADDR address, size_t len, gdb::byte_vector &tags,
822 int type)
823{
824 return current_inferior ()->top_target ()->fetch_memtags (address, len, tags, type);
825}
826
827bool
828target_store_memtags (CORE_ADDR address, size_t len,
829 const gdb::byte_vector &tags, int type)
830{
831 return current_inferior ()->top_target ()->store_memtags (address, len, tags, type);
832}
833
834x86_xsave_layout
839
840void
841target_log_command (const char *p)
842{
843 return current_inferior ()->top_target ()->log_command (p);
844}
845
846/* This is used to implement the various target commands. */
847
848static void
849open_target (const char *args, int from_tty, struct cmd_list_element *command)
850{
851 auto *ti = static_cast<target_info *> (command->context ());
852 target_open_ftype *func = target_factories[ti];
853
854 if (targetdebug)
855 gdb_printf (gdb_stdlog, "-> %s->open (...)\n",
856 ti->shortname);
857
858 func (args, from_tty);
859
860 if (targetdebug)
861 gdb_printf (gdb_stdlog, "<- %s->open (%s, %d)\n",
862 ti->shortname, args, from_tty);
863}
864
865/* See target.h. */
866
867void
870{
871 struct cmd_list_element *c;
872
873 auto &func_slot = target_factories[&t];
874 if (func_slot != nullptr)
875 internal_error (_("target already added (\"%s\")."), t.shortname);
876 func_slot = func;
877
878 if (targetlist == NULL)
879 add_basic_prefix_cmd ("target", class_run, _("\
880Connect to a target machine or process.\n\
881The first argument is the type or protocol of the target machine.\n\
882Remaining arguments are interpreted by the target protocol. For more\n\
883information on the arguments for a particular protocol, type\n\
884`help target ' followed by the protocol name."),
885 &targetlist, 0, &cmdlist);
886 c = add_cmd (t.shortname, no_class, t.doc, &targetlist);
887 c->set_context ((void *) &t);
888 c->func = open_target;
889 if (completer != NULL)
891}
892
893/* See target.h. */
894
895void
897{
898 struct cmd_list_element *c;
899
900 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
901 see PR cli/15104. */
902 c = add_cmd (alias, no_class, tinfo.doc, &targetlist);
903 c->func = open_target;
904 c->set_context ((void *) &tinfo);
905 gdb::unique_xmalloc_ptr<char> alt
906 = xstrprintf ("target %s", tinfo.shortname);
907 deprecate_cmd (c, alt.release ());
908}
909
910/* Stub functions */
911
912void
914{
915
916 /* If the commit_resume_state of the to-be-killed-inferior's process stratum
917 is true, and this inferior is the last live inferior with resumed threads
918 of that target, then we want to leave commit_resume_state to false, as the
919 target won't have any resumed threads anymore. We achieve this with
920 this scoped_disable_commit_resumed. On construction, it will set the flag
921 to false. On destruction, it will only set it to true if there are resumed
922 threads left. */
925}
926
927void
928target_load (const char *arg, int from_tty)
929{
931 current_inferior ()->top_target ()->load (arg, from_tty);
932}
933
934/* Define it. */
935
938
939/* See target/target.h. */
940
941void
948
949/* See target/target.h. */
950
951void
953{
954 struct ui *ui = current_ui;
955
956 /* A background resume (``run&'') should leave GDB in control of the
957 terminal. */
959 return;
960
961 /* Since we always run the inferior in the main console (unless "set
962 inferior-tty" is in effect), when some UI other than the main one
963 calls target_terminal::inferior, then we leave the main UI's
964 terminal settings as is. */
965 if (ui != main_ui)
966 return;
967
968 /* If GDB is resuming the inferior in the foreground, install
969 inferior's terminal modes. */
970
971 struct inferior *inf = current_inferior ();
972
973 if (inf->terminal_state != target_terminal_state::is_inferior)
974 {
976 inf->terminal_state = target_terminal_state::is_inferior;
977 }
978
980
981 /* If the user hit C-c before, pretend that it was hit right
982 here. */
983 if (check_quit_flag ())
985}
986
987/* See target/target.h. */
988
989void
991{
992 struct ui *ui = current_ui;
993
994 /* See target_terminal::inferior(). */
996 return;
997
998 /* Restore the terminal settings of inferiors that were in the
999 foreground but are now ours_for_output due to a temporary
1000 target_target::ours_for_output() call. */
1001
1002 {
1004
1005 for (::inferior *inf : all_inferiors ())
1006 {
1007 if (inf->terminal_state == target_terminal_state::is_ours_for_output)
1008 {
1011 inf->terminal_state = target_terminal_state::is_inferior;
1012 }
1013 }
1014 }
1015
1017
1018 /* If the user hit C-c before, pretend that it was hit right
1019 here. */
1020 if (check_quit_flag ())
1022}
1023
1024/* Switch terminal state to DESIRED_STATE, either is_ours, or
1025 is_ours_for_output. */
1026
1027static void
1029{
1030 scoped_restore_current_inferior restore_inferior;
1031
1032 /* Must do this in two passes. First, have all inferiors save the
1033 current terminal settings. Then, after all inferiors have add a
1034 chance to safely save the terminal settings, restore GDB's
1035 terminal settings. */
1036
1037 for (inferior *inf : all_inferiors ())
1038 {
1039 if (inf->terminal_state == target_terminal_state::is_inferior)
1040 {
1043 }
1044 }
1045
1046 for (inferior *inf : all_inferiors ())
1047 {
1048 /* Note we don't check is_inferior here like above because we
1049 need to handle 'is_ours_for_output -> is_ours' too. Careful
1050 to never transition from 'is_ours' to 'is_ours_for_output',
1051 though. */
1052 if (inf->terminal_state != target_terminal_state::is_ours
1053 && inf->terminal_state != desired_state)
1054 {
1056 if (desired_state == target_terminal_state::is_ours)
1058 else if (desired_state == target_terminal_state::is_ours_for_output)
1060 else
1061 gdb_assert_not_reached ("unhandled desired state");
1062 inf->terminal_state = desired_state;
1063 }
1064 }
1065}
1066
1067/* See target/target.h. */
1068
1069void
1071{
1072 struct ui *ui = current_ui;
1073
1074 /* See target_terminal::inferior. */
1075 if (ui != main_ui)
1076 return;
1077
1079 return;
1080
1083}
1084
1085/* See target/target.h. */
1086
1087void
1089{
1090 struct ui *ui = current_ui;
1091
1092 /* See target_terminal::inferior. */
1093 if (ui != main_ui)
1094 return;
1095
1097 return;
1098
1101}
1102
1103/* See target/target.h. */
1104
1105void
1106target_terminal::info (const char *arg, int from_tty)
1107{
1108 current_inferior ()->top_target ()->terminal_info (arg, from_tty);
1109}
1110
1111/* See target.h. */
1112
1113bool
1115{
1116 /* The current top target is the target at the top of the target
1117 stack of the current inferior. While normally there's always an
1118 inferior, we must check for nullptr here because we can get here
1119 very early during startup, before the initial inferior is first
1120 created. */
1122
1123 if (inf == nullptr)
1124 return false;
1125 return inf->top_target ()->supports_terminal_ours ();
1126}
1127
1128static void
1130{
1131 error (_("You can't do that when your target is `%s'"),
1132 current_inferior ()->top_target ()->shortname ());
1133}
1134
1135void
1137{
1138 error (_("You can't do that without a process to debug."));
1139}
1140
1141static void
1142default_terminal_info (struct target_ops *self, const char *args, int from_tty)
1143{
1144 gdb_printf (_("No saved terminal information.\n"));
1145}
1146
1147/* A default implementation for the to_get_ada_task_ptid target method.
1148
1149 This function builds the PTID by using both LWP and TID as part of
1150 the PTID lwp and tid elements. The pid used is the pid of the
1151 inferior_ptid. */
1152
1153static ptid_t
1154default_get_ada_task_ptid (struct target_ops *self, long lwp, ULONGEST tid)
1155{
1156 return ptid_t (inferior_ptid.pid (), lwp, tid);
1157}
1158
1159static enum exec_direction_kind
1161{
1163 return EXEC_FORWARD;
1164 else if (!target_can_async_p ())
1165 return EXEC_FORWARD;
1166 else
1167 gdb_assert_not_reached ("\
1168to_execution_direction must be implemented for reverse async");
1169}
1170
1171/* See target.h. */
1172
1173void
1175{
1176 t->decref ();
1177 if (t->refcount () == 0)
1178 {
1179 if (t->stratum () == process_stratum)
1181
1182 for (inferior *inf : all_inferiors ())
1183 gdb_assert (!inf->target_is_pushed (t));
1184
1186
1187 t->close ();
1188
1189 if (targetdebug)
1190 gdb_printf (gdb_stdlog, "closing target\n");
1191 }
1192}
1193
1194/* See target.h. */
1195
1196void
1198{
1199 /* We must create a new reference first. It is possible that T is
1200 already pushed on this target stack, in which case we will first
1201 unpush it below, before re-pushing it. If we don't increment the
1202 reference count now, then when we unpush it, we might end up deleting
1203 T, which is not good. */
1204 auto ref = target_ops_ref::new_reference (t);
1205
1206 strata stratum = t->stratum ();
1207
1208 /* If there's already a target at this stratum, remove it. */
1209
1210 if (m_stack[stratum].get () != nullptr)
1211 unpush (m_stack[stratum].get ());
1212
1213 /* Now add the new one. */
1214 m_stack[stratum] = std::move (ref);
1215
1216 if (m_top < stratum)
1217 m_top = stratum;
1218
1219 if (stratum == process_stratum)
1221}
1222
1223/* See target.h. */
1224
1225bool
1227{
1228 gdb_assert (t != NULL);
1229
1230 strata stratum = t->stratum ();
1231
1232 if (stratum == dummy_stratum)
1233 internal_error (_("Attempt to unpush the dummy target"));
1234
1235 /* Look for the specified target. Note that a target can only occur
1236 once in the target stack. */
1237
1238 if (m_stack[stratum] != t)
1239 {
1240 /* If T wasn't pushed, quit. Only open targets should be
1241 closed. */
1242 return false;
1243 }
1244
1245 if (m_top == stratum)
1246 m_top = this->find_beneath (t)->stratum ();
1247
1248 /* Move the target reference off the target stack, this sets the pointer
1249 held in m_stack to nullptr, and places the reference in ref. When
1250 ref goes out of scope its reference count will be decremented, which
1251 might cause the target to close.
1252
1253 We have to do it this way, and not just set the value in m_stack to
1254 nullptr directly, because doing so would decrement the reference
1255 count first, which might close the target, and closing the target
1256 does a check that the target is not on any inferiors target_stack. */
1257 auto ref = std::move (m_stack[stratum]);
1258
1259 return true;
1260}
1261
1262void
1264{
1266}
1267
1268/* Default implementation of to_get_thread_local_address. */
1269
1270static void
1271generic_tls_error (void)
1272{
1273 throw_error (TLS_GENERIC_ERROR,
1274 _("Cannot find thread-local variables on this target"));
1275}
1276
1277/* Using the objfile specified in OBJFILE, find the address for the
1278 current thread's thread-local storage with offset OFFSET. */
1279CORE_ADDR
1281{
1282 volatile CORE_ADDR addr = 0;
1283 struct target_ops *target = current_inferior ()->top_target ();
1284 struct gdbarch *gdbarch = target_gdbarch ();
1285
1286 /* If OBJFILE is a separate debug object file, look for the
1287 original object file. */
1290
1292 {
1293 ptid_t ptid = inferior_ptid;
1294
1295 try
1296 {
1297 CORE_ADDR lm_addr;
1298
1299 /* Fetch the load module address for this objfile. */
1301 objfile);
1302
1305 offset);
1306 else
1307 addr = target->get_thread_local_address (ptid, lm_addr, offset);
1308 }
1309 /* If an error occurred, print TLS related messages here. Otherwise,
1310 throw the error to some higher catcher. */
1311 catch (const gdb_exception &ex)
1312 {
1313 int objfile_is_library = (objfile->flags & OBJF_SHARED);
1314
1315 switch (ex.error)
1316 {
1317 case TLS_NO_LIBRARY_SUPPORT_ERROR:
1318 error (_("Cannot find thread-local variables "
1319 "in this thread library."));
1320 break;
1321 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
1322 if (objfile_is_library)
1323 error (_("Cannot find shared library `%s' in dynamic"
1324 " linker's load module list"), objfile_name (objfile));
1325 else
1326 error (_("Cannot find executable file `%s' in dynamic"
1327 " linker's load module list"), objfile_name (objfile));
1328 break;
1329 case TLS_NOT_ALLOCATED_YET_ERROR:
1330 if (objfile_is_library)
1331 error (_("The inferior has not yet allocated storage for"
1332 " thread-local variables in\n"
1333 "the shared library `%s'\n"
1334 "for %s"),
1336 target_pid_to_str (ptid).c_str ());
1337 else
1338 error (_("The inferior has not yet allocated storage for"
1339 " thread-local variables in\n"
1340 "the executable `%s'\n"
1341 "for %s"),
1343 target_pid_to_str (ptid).c_str ());
1344 break;
1345 case TLS_GENERIC_ERROR:
1346 if (objfile_is_library)
1347 error (_("Cannot find thread-local storage for %s, "
1348 "shared library %s:\n%s"),
1349 target_pid_to_str (ptid).c_str (),
1350 objfile_name (objfile), ex.what ());
1351 else
1352 error (_("Cannot find thread-local storage for %s, "
1353 "executable file %s:\n%s"),
1354 target_pid_to_str (ptid).c_str (),
1355 objfile_name (objfile), ex.what ());
1356 break;
1357 default:
1358 throw;
1359 break;
1360 }
1361 }
1362 }
1363 else
1364 error (_("Cannot find thread-local variables on this target"));
1365
1366 return addr;
1367}
1368
1369const char *
1371{
1372#define CASE(X) case X: return #X
1373 switch (status)
1374 {
1377 default:
1378 return "<unknown>";
1379 }
1380#undef CASE
1381};
1382
1383
1386{
1387 return target->get_section_table ();
1388}
1389
1390/* Find a section containing ADDR. */
1391
1392const struct target_section *
1393target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1394{
1395 const target_section_table *table = target_get_section_table (target);
1396
1397 if (table == NULL)
1398 return NULL;
1399
1400 for (const target_section &secp : *table)
1401 {
1402 if (addr >= secp.addr && addr < secp.endaddr)
1403 return &secp;
1404 }
1405 return NULL;
1406}
1407
1408/* See target.h. */
1409
1415
1416/* Helper for the memory xfer routines. Checks the attributes of the
1417 memory region of MEMADDR against the read or write being attempted.
1418 If the access is permitted returns true, otherwise returns false.
1419 REGION_P is an optional output parameter. If not-NULL, it is
1420 filled with a pointer to the memory region of MEMADDR. REG_LEN
1421 returns LEN trimmed to the end of the region. This is how much the
1422 caller can continue requesting, if the access is permitted. A
1423 single xfer request must not straddle memory region boundaries. */
1424
1425static int
1426memory_xfer_check_region (gdb_byte *readbuf, const gdb_byte *writebuf,
1427 ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len,
1428 struct mem_region **region_p)
1429{
1430 struct mem_region *region;
1431
1432 region = lookup_mem_region (memaddr);
1433
1434 if (region_p != NULL)
1435 *region_p = region;
1436
1437 switch (region->attrib.mode)
1438 {
1439 case MEM_RO:
1440 if (writebuf != NULL)
1441 return 0;
1442 break;
1443
1444 case MEM_WO:
1445 if (readbuf != NULL)
1446 return 0;
1447 break;
1448
1449 case MEM_FLASH:
1450 /* We only support writing to flash during "load" for now. */
1451 if (writebuf != NULL)
1452 error (_("Writing to flash memory forbidden in this context"));
1453 break;
1454
1455 case MEM_NONE:
1456 return 0;
1457 }
1458
1459 /* region->hi == 0 means there's no upper bound. */
1460 if (memaddr + len < region->hi || region->hi == 0)
1461 *reg_len = len;
1462 else
1463 *reg_len = region->hi - memaddr;
1464
1465 return 1;
1466}
1467
1468/* Read memory from more than one valid target. A core file, for
1469 instance, could have some of memory but delegate other bits to
1470 the target below it. So, we must manually try all targets. */
1471
1473raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
1474 const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1475 ULONGEST *xfered_len)
1476{
1477 enum target_xfer_status res;
1478
1479 do
1480 {
1481 res = ops->xfer_partial (TARGET_OBJECT_MEMORY, NULL,
1482 readbuf, writebuf, memaddr, len,
1483 xfered_len);
1484 if (res == TARGET_XFER_OK)
1485 break;
1486
1487 /* Stop if the target reports that the memory is not available. */
1488 if (res == TARGET_XFER_UNAVAILABLE)
1489 break;
1490
1491 /* Don't continue past targets which have all the memory.
1492 At one time, this code was necessary to read data from
1493 executables / shared libraries when data for the requested
1494 addresses weren't available in the core file. But now the
1495 core target handles this case itself. */
1496 if (ops->has_all_memory ())
1497 break;
1498
1499 ops = ops->beneath ();
1500 }
1501 while (ops != NULL);
1502
1503 /* The cache works at the raw memory level. Make sure the cache
1504 gets updated with raw contents no matter what kind of memory
1505 object was originally being written. Note we do write-through
1506 first, so that if it fails, we don't write to the cache contents
1507 that never made it to the target. */
1508 if (writebuf != NULL
1509 && inferior_ptid != null_ptid
1512 {
1513 DCACHE *dcache = target_dcache_get ();
1514
1515 /* Note that writing to an area of memory which wasn't present
1516 in the cache doesn't cause it to be loaded in. */
1517 dcache_update (dcache, res, memaddr, writebuf, *xfered_len);
1518 }
1519
1520 return res;
1521}
1522
1523/* Perform a partial memory transfer.
1524 For docs see target.h, to_xfer_partial. */
1525
1526static enum target_xfer_status
1528 gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
1529 ULONGEST len, ULONGEST *xfered_len)
1530{
1531 enum target_xfer_status res;
1532 ULONGEST reg_len;
1533 struct mem_region *region;
1534 struct inferior *inf;
1535
1536 /* For accesses to unmapped overlay sections, read directly from
1537 files. Must do this first, as MEMADDR may need adjustment. */
1538 if (readbuf != NULL && overlay_debugging)
1539 {
1540 struct obj_section *section = find_pc_overlay (memaddr);
1541
1542 if (pc_in_unmapped_range (memaddr, section))
1543 {
1545 const char *section_name = section->the_bfd_section->name;
1546
1547 memaddr = overlay_mapped_address (memaddr, section);
1548
1549 auto match_cb = [=] (const struct target_section *s)
1550 {
1551 return (strcmp (section_name, s->the_bfd_section->name) == 0);
1552 };
1553
1554 return section_table_xfer_memory_partial (readbuf, writebuf,
1555 memaddr, len, xfered_len,
1556 *table, match_cb);
1557 }
1558 }
1559
1560 /* Try the executable files, if "trust-readonly-sections" is set. */
1561 if (readbuf != NULL && trust_readonly)
1562 {
1563 const struct target_section *secp
1564 = target_section_by_addr (ops, memaddr);
1565 if (secp != NULL
1566 && (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
1567 {
1569 return section_table_xfer_memory_partial (readbuf, writebuf,
1570 memaddr, len, xfered_len,
1571 *table);
1572 }
1573 }
1574
1575 /* Try GDB's internal data cache. */
1576
1577 if (!memory_xfer_check_region (readbuf, writebuf, memaddr, len, &reg_len,
1578 &region))
1579 return TARGET_XFER_E_IO;
1580
1581 if (inferior_ptid != null_ptid)
1582 inf = current_inferior ();
1583 else
1584 inf = NULL;
1585
1586 if (inf != NULL
1587 && readbuf != NULL
1588 /* The dcache reads whole cache lines; that doesn't play well
1589 with reading from a trace buffer, because reading outside of
1590 the collected memory range fails. */
1591 && get_traceframe_number () == -1
1592 && (region->attrib.cache
1594 || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
1595 {
1596 DCACHE *dcache = target_dcache_get_or_init ();
1597
1598 return dcache_read_memory_partial (ops, dcache, memaddr, readbuf,
1599 reg_len, xfered_len);
1600 }
1601
1602 /* If none of those methods found the memory we wanted, fall back
1603 to a target partial transfer. Normally a single call to
1604 to_xfer_partial is enough; if it doesn't recognize an object
1605 it will call the to_xfer_partial of the next target down.
1606 But for memory this won't do. Memory is the only target
1607 object which can be read from more than one valid target.
1608 A core file, for instance, could have some of memory but
1609 delegate other bits to the target below it. So, we must
1610 manually try all targets. */
1611
1612 res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1613 xfered_len);
1614
1615 /* If we still haven't got anything, return the last error. We
1616 give up. */
1617 return res;
1618}
1619
1620/* Perform a partial memory transfer. For docs see target.h,
1621 to_xfer_partial. */
1622
1623static enum target_xfer_status
1625 gdb_byte *readbuf, const gdb_byte *writebuf,
1626 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1627{
1628 enum target_xfer_status res;
1629
1630 /* Zero length requests are ok and require no work. */
1631 if (len == 0)
1632 return TARGET_XFER_EOF;
1633
1634 memaddr = gdbarch_remove_non_address_bits (target_gdbarch (), memaddr);
1635
1636 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1637 breakpoint insns, thus hiding out from higher layers whether
1638 there are software breakpoints inserted in the code stream. */
1639 if (readbuf != NULL)
1640 {
1641 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1642 xfered_len);
1643
1644 if (res == TARGET_XFER_OK && !show_memory_breakpoints)
1645 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, *xfered_len);
1646 }
1647 else
1648 {
1649 /* A large write request is likely to be partially satisfied
1650 by memory_xfer_partial_1. We will continually malloc
1651 and free a copy of the entire write request for breakpoint
1652 shadow handling even though we only end up writing a small
1653 subset of it. Cap writes to a limit specified by the target
1654 to mitigate this. */
1655 len = std::min (ops->get_memory_xfer_limit (), len);
1656
1657 gdb::byte_vector buf (writebuf, writebuf + len);
1658 breakpoint_xfer_memory (NULL, buf.data (), writebuf, memaddr, len);
1659 res = memory_xfer_partial_1 (ops, object, NULL, buf.data (), memaddr, len,
1660 xfered_len);
1661 }
1662
1663 return res;
1664}
1665
1666scoped_restore_tmpl<int>
1668{
1669 return make_scoped_restore (&show_memory_breakpoints, show);
1670}
1671
1672/* For docs see target.h, to_xfer_partial. */
1673
1676 enum target_object object, const char *annex,
1677 gdb_byte *readbuf, const gdb_byte *writebuf,
1678 ULONGEST offset, ULONGEST len,
1679 ULONGEST *xfered_len)
1680{
1681 enum target_xfer_status retval;
1682
1683 /* Transfer is done when LEN is zero. */
1684 if (len == 0)
1685 return TARGET_XFER_EOF;
1686
1687 if (writebuf && !may_write_memory)
1688 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1689 core_addr_to_string_nz (offset), plongest (len));
1690
1691 *xfered_len = 0;
1692
1693 /* If this is a memory transfer, let the memory-specific code
1694 have a look at it instead. Memory transfers are more
1695 complicated. */
1696 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1697 || object == TARGET_OBJECT_CODE_MEMORY)
1698 retval = memory_xfer_partial (ops, object, readbuf,
1699 writebuf, offset, len, xfered_len);
1700 else if (object == TARGET_OBJECT_RAW_MEMORY)
1701 {
1702 /* Skip/avoid accessing the target if the memory region
1703 attributes block the access. Check this here instead of in
1704 raw_memory_xfer_partial as otherwise we'd end up checking
1705 this twice in the case of the memory_xfer_partial path is
1706 taken; once before checking the dcache, and another in the
1707 tail call to raw_memory_xfer_partial. */
1708 if (!memory_xfer_check_region (readbuf, writebuf, offset, len, &len,
1709 NULL))
1710 return TARGET_XFER_E_IO;
1711
1712 /* Request the normal memory object from other layers. */
1713 retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1714 xfered_len);
1715 }
1716 else
1717 retval = ops->xfer_partial (object, annex, readbuf,
1718 writebuf, offset, len, xfered_len);
1719
1720 if (targetdebug)
1721 {
1722 const unsigned char *myaddr = NULL;
1723
1725 "%s:target_xfer_partial "
1726 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1727 ops->shortname (),
1728 (int) object,
1729 (annex ? annex : "(null)"),
1730 host_address_to_string (readbuf),
1731 host_address_to_string (writebuf),
1732 core_addr_to_string_nz (offset),
1733 pulongest (len), retval,
1734 pulongest (*xfered_len));
1735
1736 if (readbuf)
1737 myaddr = readbuf;
1738 if (writebuf)
1739 myaddr = writebuf;
1740 if (retval == TARGET_XFER_OK && myaddr != NULL)
1741 {
1742 int i;
1743
1744 gdb_puts (", bytes =", gdb_stdlog);
1745 for (i = 0; i < *xfered_len; i++)
1746 {
1747 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1748 {
1749 if (targetdebug < 2 && i > 0)
1750 {
1751 gdb_printf (gdb_stdlog, " ...");
1752 break;
1753 }
1754 gdb_printf (gdb_stdlog, "\n");
1755 }
1756
1757 gdb_printf (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1758 }
1759 }
1760
1761 gdb_putc ('\n', gdb_stdlog);
1762 }
1763
1764 /* Check implementations of to_xfer_partial update *XFERED_LEN
1765 properly. Do assertion after printing debug messages, so that we
1766 can find more clues on assertion failure from debugging messages. */
1767 if (retval == TARGET_XFER_OK || retval == TARGET_XFER_UNAVAILABLE)
1768 gdb_assert (*xfered_len > 0);
1769
1770 return retval;
1771}
1772
1773/* Read LEN bytes of target memory at address MEMADDR, placing the
1774 results in GDB's memory at MYADDR. Returns either 0 for success or
1775 -1 if any error occurs.
1776
1777 If an error occurs, no guarantee is made about the contents of the data at
1778 MYADDR. In particular, the caller should not depend upon partial reads
1779 filling the buffer with good data. There is no way for the caller to know
1780 how much good data might have been transfered anyway. Callers that can
1781 deal with partial reads should call target_read (which will retry until
1782 it makes no progress, and then return how much was transferred). */
1783
1784int
1785target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1786{
1787 if (target_read (current_inferior ()->top_target (),
1789 myaddr, memaddr, len) == len)
1790 return 0;
1791 else
1792 return -1;
1793}
1794
1795/* See target/target.h. */
1796
1797int
1798target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
1799{
1800 gdb_byte buf[4];
1801 int r;
1802
1803 r = target_read_memory (memaddr, buf, sizeof buf);
1804 if (r != 0)
1805 return r;
1806 *result = extract_unsigned_integer (buf, sizeof buf,
1808 return 0;
1809}
1810
1811/* Like target_read_memory, but specify explicitly that this is a read
1812 from the target's raw memory. That is, this read bypasses the
1813 dcache, breakpoint shadowing, etc. */
1814
1815int
1816target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1817{
1818 if (target_read (current_inferior ()->top_target (),
1820 myaddr, memaddr, len) == len)
1821 return 0;
1822 else
1823 return -1;
1824}
1825
1826/* Like target_read_memory, but specify explicitly that this is a read from
1827 the target's stack. This may trigger different cache behavior. */
1828
1829int
1830target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1831{
1832 if (target_read (current_inferior ()->top_target (),
1834 myaddr, memaddr, len) == len)
1835 return 0;
1836 else
1837 return -1;
1838}
1839
1840/* Like target_read_memory, but specify explicitly that this is a read from
1841 the target's code. This may trigger different cache behavior. */
1842
1843int
1844target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1845{
1846 if (target_read (current_inferior ()->top_target (),
1848 myaddr, memaddr, len) == len)
1849 return 0;
1850 else
1851 return -1;
1852}
1853
1854/* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1855 Returns either 0 for success or -1 if any error occurs. If an
1856 error occurs, no guarantee is made about how much data got written.
1857 Callers that can deal with partial writes should call
1858 target_write. */
1859
1860int
1861target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1862{
1863 if (target_write (current_inferior ()->top_target (),
1865 myaddr, memaddr, len) == len)
1866 return 0;
1867 else
1868 return -1;
1869}
1870
1871/* Write LEN bytes from MYADDR to target raw memory at address
1872 MEMADDR. Returns either 0 for success or -1 if any error occurs.
1873 If an error occurs, no guarantee is made about how much data got
1874 written. Callers that can deal with partial writes should call
1875 target_write. */
1876
1877int
1878target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1879{
1880 if (target_write (current_inferior ()->top_target (),
1882 myaddr, memaddr, len) == len)
1883 return 0;
1884 else
1885 return -1;
1886}
1887
1888/* Fetch the target's memory map. */
1889
1890std::vector<mem_region>
1892{
1893 target_ops *target = current_inferior ()->top_target ();
1894 std::vector<mem_region> result = target->memory_map ();
1895 if (result.empty ())
1896 return result;
1897
1898 std::sort (result.begin (), result.end ());
1899
1900 /* Check that regions do not overlap. Simultaneously assign
1901 a numbering for the "mem" commands to use to refer to
1902 each region. */
1903 mem_region *last_one = NULL;
1904 for (size_t ix = 0; ix < result.size (); ix++)
1905 {
1906 mem_region *this_one = &result[ix];
1907 this_one->number = ix;
1908
1909 if (last_one != NULL && last_one->hi > this_one->lo)
1910 {
1911 warning (_("Overlapping regions in memory map: ignoring"));
1912 return std::vector<mem_region> ();
1913 }
1914
1915 last_one = this_one;
1916 }
1917
1918 return result;
1919}
1920
1921void
1922target_flash_erase (ULONGEST address, LONGEST length)
1923{
1924 current_inferior ()->top_target ()->flash_erase (address, length);
1925}
1926
1927void
1929{
1931}
1932
1933static void
1934show_trust_readonly (struct ui_file *file, int from_tty,
1935 struct cmd_list_element *c, const char *value)
1936{
1937 gdb_printf (file,
1938 _("Mode for reading from readonly sections is %s.\n"),
1939 value);
1940}
1941
1942/* Target vector read/write partial wrapper functions. */
1943
1944static enum target_xfer_status
1946 enum target_object object,
1947 const char *annex, gdb_byte *buf,
1948 ULONGEST offset, ULONGEST len,
1949 ULONGEST *xfered_len)
1950{
1951 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
1952 xfered_len);
1953}
1954
1955static enum target_xfer_status
1957 enum target_object object,
1958 const char *annex, const gdb_byte *buf,
1959 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
1960{
1961 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
1962 xfered_len);
1963}
1964
1965/* Wrappers to perform the full transfer. */
1966
1967/* For docs on target_read see target.h. */
1968
1969LONGEST
1971 enum target_object object,
1972 const char *annex, gdb_byte *buf,
1973 ULONGEST offset, LONGEST len)
1974{
1975 LONGEST xfered_total = 0;
1976 int unit_size = 1;
1977
1978 /* If we are reading from a memory object, find the length of an addressable
1979 unit for that architecture. */
1980 if (object == TARGET_OBJECT_MEMORY
1981 || object == TARGET_OBJECT_STACK_MEMORY
1982 || object == TARGET_OBJECT_CODE_MEMORY
1983 || object == TARGET_OBJECT_RAW_MEMORY)
1985
1986 while (xfered_total < len)
1987 {
1988 ULONGEST xfered_partial;
1990
1991 status = target_read_partial (ops, object, annex,
1992 buf + xfered_total * unit_size,
1993 offset + xfered_total, len - xfered_total,
1994 &xfered_partial);
1995
1996 /* Call an observer, notifying them of the xfer progress? */
1997 if (status == TARGET_XFER_EOF)
1998 return xfered_total;
1999 else if (status == TARGET_XFER_OK)
2000 {
2001 xfered_total += xfered_partial;
2002 QUIT;
2003 }
2004 else
2005 return TARGET_XFER_E_IO;
2006
2007 }
2008 return len;
2009}
2010
2011/* Assuming that the entire [begin, end) range of memory cannot be
2012 read, try to read whatever subrange is possible to read.
2013
2014 The function returns, in RESULT, either zero or one memory block.
2015 If there's a readable subrange at the beginning, it is completely
2016 read and returned. Any further readable subrange will not be read.
2017 Otherwise, if there's a readable subrange at the end, it will be
2018 completely read and returned. Any readable subranges before it
2019 (obviously, not starting at the beginning), will be ignored. In
2020 other cases -- either no readable subrange, or readable subrange(s)
2021 that is neither at the beginning, or end, nothing is returned.
2022
2023 The purpose of this function is to handle a read across a boundary
2024 of accessible memory in a case when memory map is not available.
2025 The above restrictions are fine for this case, but will give
2026 incorrect results if the memory is 'patchy'. However, supporting
2027 'patchy' memory would require trying to read every single byte,
2028 and it seems unacceptable solution. Explicit memory map is
2029 recommended for this case -- and target_read_memory_robust will
2030 take care of reading multiple ranges then. */
2031
2032static void
2034 const ULONGEST begin, const ULONGEST end,
2035 int unit_size,
2036 std::vector<memory_read_result> *result)
2037{
2038 ULONGEST current_begin = begin;
2039 ULONGEST current_end = end;
2040 int forward;
2041 ULONGEST xfered_len;
2042
2043 /* If we previously failed to read 1 byte, nothing can be done here. */
2044 if (end - begin <= 1)
2045 return;
2046
2047 gdb::unique_xmalloc_ptr<gdb_byte> buf ((gdb_byte *) xmalloc (end - begin));
2048
2049 /* Check that either first or the last byte is readable, and give up
2050 if not. This heuristic is meant to permit reading accessible memory
2051 at the boundary of accessible region. */
2053 buf.get (), begin, 1, &xfered_len) == TARGET_XFER_OK)
2054 {
2055 forward = 1;
2056 ++current_begin;
2057 }
2058 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2059 buf.get () + (end - begin) - 1, end - 1, 1,
2060 &xfered_len) == TARGET_XFER_OK)
2061 {
2062 forward = 0;
2063 --current_end;
2064 }
2065 else
2066 return;
2067
2068 /* Loop invariant is that the [current_begin, current_end) was previously
2069 found to be not readable as a whole.
2070
2071 Note loop condition -- if the range has 1 byte, we can't divide the range
2072 so there's no point trying further. */
2073 while (current_end - current_begin > 1)
2074 {
2075 ULONGEST first_half_begin, first_half_end;
2076 ULONGEST second_half_begin, second_half_end;
2077 LONGEST xfer;
2078 ULONGEST middle = current_begin + (current_end - current_begin) / 2;
2079
2080 if (forward)
2081 {
2082 first_half_begin = current_begin;
2083 first_half_end = middle;
2084 second_half_begin = middle;
2085 second_half_end = current_end;
2086 }
2087 else
2088 {
2089 first_half_begin = middle;
2090 first_half_end = current_end;
2091 second_half_begin = current_begin;
2092 second_half_end = middle;
2093 }
2094
2095 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2096 buf.get () + (first_half_begin - begin) * unit_size,
2097 first_half_begin,
2098 first_half_end - first_half_begin);
2099
2100 if (xfer == first_half_end - first_half_begin)
2101 {
2102 /* This half reads up fine. So, the error must be in the
2103 other half. */
2104 current_begin = second_half_begin;
2105 current_end = second_half_end;
2106 }
2107 else
2108 {
2109 /* This half is not readable. Because we've tried one byte, we
2110 know some part of this half if actually readable. Go to the next
2111 iteration to divide again and try to read.
2112
2113 We don't handle the other half, because this function only tries
2114 to read a single readable subrange. */
2115 current_begin = first_half_begin;
2116 current_end = first_half_end;
2117 }
2118 }
2119
2120 if (forward)
2121 {
2122 /* The [begin, current_begin) range has been read. */
2123 result->emplace_back (begin, current_end, std::move (buf));
2124 }
2125 else
2126 {
2127 /* The [current_end, end) range has been read. */
2128 LONGEST region_len = end - current_end;
2129
2130 gdb::unique_xmalloc_ptr<gdb_byte> data
2131 ((gdb_byte *) xmalloc (region_len * unit_size));
2132 memcpy (data.get (), buf.get () + (current_end - begin) * unit_size,
2133 region_len * unit_size);
2134 result->emplace_back (current_end, end, std::move (data));
2135 }
2136}
2137
2138std::vector<memory_read_result>
2140 const ULONGEST offset, const LONGEST len)
2141{
2142 std::vector<memory_read_result> result;
2144
2145 LONGEST xfered_total = 0;
2146 while (xfered_total < len)
2147 {
2148 struct mem_region *region = lookup_mem_region (offset + xfered_total);
2149 LONGEST region_len;
2150
2151 /* If there is no explicit region, a fake one should be created. */
2152 gdb_assert (region);
2153
2154 if (region->hi == 0)
2155 region_len = len - xfered_total;
2156 else
2157 region_len = region->hi - offset;
2158
2159 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
2160 {
2161 /* Cannot read this region. Note that we can end up here only
2162 if the region is explicitly marked inaccessible, or
2163 'inaccessible-by-default' is in effect. */
2164 xfered_total += region_len;
2165 }
2166 else
2167 {
2168 LONGEST to_read = std::min (len - xfered_total, region_len);
2169 gdb::unique_xmalloc_ptr<gdb_byte> buffer
2170 ((gdb_byte *) xmalloc (to_read * unit_size));
2171
2172 LONGEST xfered_partial =
2173 target_read (ops, TARGET_OBJECT_MEMORY, NULL, buffer.get (),
2174 offset + xfered_total, to_read);
2175 /* Call an observer, notifying them of the xfer progress? */
2176 if (xfered_partial <= 0)
2177 {
2178 /* Got an error reading full chunk. See if maybe we can read
2179 some subrange. */
2180 read_whatever_is_readable (ops, offset + xfered_total,
2181 offset + xfered_total + to_read,
2182 unit_size, &result);
2183 xfered_total += to_read;
2184 }
2185 else
2186 {
2187 result.emplace_back (offset + xfered_total,
2188 offset + xfered_total + xfered_partial,
2189 std::move (buffer));
2190 xfered_total += xfered_partial;
2191 }
2192 QUIT;
2193 }
2194 }
2195
2196 return result;
2197}
2198
2199
2200/* An alternative to target_write with progress callbacks. */
2201
2202LONGEST
2204 enum target_object object,
2205 const char *annex, const gdb_byte *buf,
2206 ULONGEST offset, LONGEST len,
2207 void (*progress) (ULONGEST, void *), void *baton)
2208{
2209 LONGEST xfered_total = 0;
2210 int unit_size = 1;
2211
2212 /* If we are writing to a memory object, find the length of an addressable
2213 unit for that architecture. */
2214 if (object == TARGET_OBJECT_MEMORY
2215 || object == TARGET_OBJECT_STACK_MEMORY
2216 || object == TARGET_OBJECT_CODE_MEMORY
2217 || object == TARGET_OBJECT_RAW_MEMORY)
2219
2220 /* Give the progress callback a chance to set up. */
2221 if (progress)
2222 (*progress) (0, baton);
2223
2224 while (xfered_total < len)
2225 {
2226 ULONGEST xfered_partial;
2228
2229 status = target_write_partial (ops, object, annex,
2230 buf + xfered_total * unit_size,
2231 offset + xfered_total, len - xfered_total,
2232 &xfered_partial);
2233
2234 if (status != TARGET_XFER_OK)
2235 return status == TARGET_XFER_EOF ? xfered_total : TARGET_XFER_E_IO;
2236
2237 if (progress)
2238 (*progress) (xfered_partial, baton);
2239
2240 xfered_total += xfered_partial;
2241 QUIT;
2242 }
2243 return len;
2244}
2245
2246/* For docs on target_write see target.h. */
2247
2248LONGEST
2250 enum target_object object,
2251 const char *annex, const gdb_byte *buf,
2252 ULONGEST offset, LONGEST len)
2253{
2254 return target_write_with_progress (ops, object, annex, buf, offset, len,
2255 NULL, NULL);
2256}
2257
2258/* Help for target_read_alloc and target_read_stralloc. See their comments
2259 for details. */
2260
2261template <typename T>
2262gdb::optional<gdb::def_vector<T>>
2264 const char *annex)
2265{
2266 gdb::def_vector<T> buf;
2267 size_t buf_pos = 0;
2268 const int chunk = 4096;
2269
2270 /* This function does not have a length parameter; it reads the
2271 entire OBJECT). Also, it doesn't support objects fetched partly
2272 from one target and partly from another (in a different stratum,
2273 e.g. a core file and an executable). Both reasons make it
2274 unsuitable for reading memory. */
2275 gdb_assert (object != TARGET_OBJECT_MEMORY);
2276
2277 /* Start by reading up to 4K at a time. The target will throttle
2278 this number down if necessary. */
2279 while (1)
2280 {
2281 ULONGEST xfered_len;
2283
2284 buf.resize (buf_pos + chunk);
2285
2286 status = target_read_partial (ops, object, annex,
2287 (gdb_byte *) &buf[buf_pos],
2288 buf_pos, chunk,
2289 &xfered_len);
2290
2291 if (status == TARGET_XFER_EOF)
2292 {
2293 /* Read all there was. */
2294 buf.resize (buf_pos);
2295 return buf;
2296 }
2297 else if (status != TARGET_XFER_OK)
2298 {
2299 /* An error occurred. */
2300 return {};
2301 }
2302
2303 buf_pos += xfered_len;
2304
2305 QUIT;
2306 }
2307}
2308
2309/* See target.h */
2310
2311gdb::optional<gdb::byte_vector>
2313 const char *annex)
2314{
2315 return target_read_alloc_1<gdb_byte> (ops, object, annex);
2316}
2317
2318/* See target.h. */
2319
2320gdb::optional<gdb::char_vector>
2322 const char *annex)
2323{
2324 gdb::optional<gdb::char_vector> buf
2325 = target_read_alloc_1<char> (ops, object, annex);
2326
2327 if (!buf)
2328 return {};
2329
2330 if (buf->empty () || buf->back () != '\0')
2331 buf->push_back ('\0');
2332
2333 /* Check for embedded NUL bytes; but allow trailing NULs. */
2334 for (auto it = std::find (buf->begin (), buf->end (), '\0');
2335 it != buf->end (); it++)
2336 if (*it != '\0')
2337 {
2338 warning (_("target object %d, annex %s, "
2339 "contained unexpected null characters"),
2340 (int) object, annex ? annex : "(none)");
2341 break;
2342 }
2343
2344 return buf;
2345}
2346
2347/* Memory transfer methods. */
2348
2349void
2350get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2351 LONGEST len)
2352{
2353 /* This method is used to read from an alternate, non-current
2354 target. This read must bypass the overlay support (as symbols
2355 don't match this target), and GDB's internal cache (wrong cache
2356 for this target). */
2357 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2358 != len)
2360}
2361
2362ULONGEST
2363get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2364 int len, enum bfd_endian byte_order)
2365{
2366 gdb_byte buf[sizeof (ULONGEST)];
2367
2368 gdb_assert (len <= sizeof (buf));
2369 get_target_memory (ops, addr, buf, len);
2370 return extract_unsigned_integer (buf, len, byte_order);
2371}
2372
2373/* See target.h. */
2374
2375int
2377 struct bp_target_info *bp_tgt)
2378{
2380 {
2381 warning (_("May not insert breakpoints"));
2382 return 1;
2383 }
2384
2385 target_ops *target = current_inferior ()->top_target ();
2386
2387 return target->insert_breakpoint (gdbarch, bp_tgt);
2388}
2389
2390/* See target.h. */
2391
2392int
2394 struct bp_target_info *bp_tgt,
2395 enum remove_bp_reason reason)
2396{
2397 /* This is kind of a weird case to handle, but the permission might
2398 have been changed after breakpoints were inserted - in which case
2399 we should just take the user literally and assume that any
2400 breakpoints should be left in place. */
2402 {
2403 warning (_("May not remove breakpoints"));
2404 return 1;
2405 }
2406
2407 target_ops *target = current_inferior ()->top_target ();
2408
2409 return target->remove_breakpoint (gdbarch, bp_tgt, reason);
2410}
2411
2412static void
2413info_target_command (const char *args, int from_tty)
2414{
2415 int has_all_mem = 0;
2416
2418 {
2420 gdb_printf (_("Symbols from \"%s\".\n"),
2421 objfile_name (objf));
2422 }
2423
2424 for (target_ops *t = current_inferior ()->top_target ();
2425 t != NULL;
2426 t = t->beneath ())
2427 {
2428 if (!t->has_memory ())
2429 continue;
2430
2431 if ((int) (t->stratum ()) <= (int) dummy_stratum)
2432 continue;
2433 if (has_all_mem)
2434 gdb_printf (_("\tWhile running this, "
2435 "GDB does not access memory from...\n"));
2436 gdb_printf ("%s:\n", t->longname ());
2437 t->files_info ();
2438 has_all_mem = t->has_all_memory ();
2439 }
2440}
2441
2442/* This function is called before any new inferior is created, e.g.
2443 by running a program, attaching, or connecting to a target.
2444 It cleans up any state from previous invocations which might
2445 change between runs. This is a subset of what target_preopen
2446 resets (things which might change between targets). */
2447
2448void
2450{
2451 /* Clear out solib state. Otherwise the solib state of the previous
2452 inferior might have survived and is entirely wrong for the new
2453 target. This has been observed on GNU/Linux using glibc 2.3. How
2454 to reproduce:
2455
2456 bash$ ./foo&
2457 [1] 4711
2458 bash$ ./foo&
2459 [1] 4712
2460 bash$ gdb ./foo
2461 [...]
2462 (gdb) attach 4711
2463 (gdb) detach
2464 (gdb) attach 4712
2465 Cannot access memory at address 0xdeadbeef
2466 */
2467
2468 /* In some OSs, the shared library list is the same/global/shared
2469 across inferiors. If code is shared between processes, so are
2470 memory regions and features. */
2472 {
2473 no_shared_libraries (NULL, from_tty);
2474
2476
2478 }
2479
2480 /* attach_flag may be set if the previous process associated with
2481 the inferior was attached to. */
2482 current_inferior ()->attach_flag = false;
2483
2485
2487
2488 agent_capability_invalidate ();
2489}
2490
2491/* This is to be called by the open routine before it does
2492 anything. */
2493
2494void
2495target_preopen (int from_tty)
2496{
2497 dont_repeat ();
2498
2499 if (current_inferior ()->pid != 0)
2500 {
2501 if (!from_tty
2503 || query (_("A program is being debugged already. Kill it? ")))
2504 {
2505 /* Core inferiors actually should be detached, not
2506 killed. */
2507 if (target_has_execution ())
2508 target_kill ();
2509 else
2511 }
2512 else
2513 error (_("Program not killed."));
2514 }
2515
2516 /* Release reference to old previous thread. */
2518
2519 /* Calling target_kill may remove the target from the stack. But if
2520 it doesn't (which seems like a win for UDI), remove it now. */
2521 /* Leave the exec target, though. The user may be switching from a
2522 live process to a core of the same program. */
2524
2525 target_pre_inferior (from_tty);
2526}
2527
2528/* See target.h. */
2529
2530void
2532{
2533 /* Thread's don't need to be resumed until the end of this function. */
2534 scoped_disable_commit_resumed disable_commit_resumed ("detaching");
2535
2536 /* After we have detached, we will clear the register cache for this inferior
2537 by calling registers_changed_ptid. We must save the pid_ptid before
2538 detaching, as the target detach method will clear inf->pid. */
2539 ptid_t save_pid_ptid = ptid_t (inf->pid);
2540
2541 /* As long as some to_detach implementations rely on the current_inferior
2542 (either directly, or indirectly, like through target_gdbarch or by
2543 reading memory), INF needs to be the current inferior. When that
2544 requirement will become no longer true, then we can remove this
2545 assertion. */
2546 gdb_assert (inf == current_inferior ());
2547
2549
2551
2552 /* Hold a strong reference because detaching may unpush the
2553 target. */
2554 auto proc_target_ref = target_ops_ref::new_reference (inf->process_target ());
2555
2556 current_inferior ()->top_target ()->detach (inf, from_tty);
2557
2558 process_stratum_target *proc_target
2559 = as_process_stratum_target (proc_target_ref.get ());
2560
2561 registers_changed_ptid (proc_target, save_pid_ptid);
2562
2563 /* We have to ensure we have no frame cache left. Normally,
2564 registers_changed_ptid (save_pid_ptid) calls reinit_frame_cache when
2565 inferior_ptid matches save_pid_ptid, but in our case, it does not
2566 call it, as inferior_ptid has been reset. */
2568
2569 disable_commit_resumed.reset_and_commit ();
2570}
2571
2572void
2573target_disconnect (const char *args, int from_tty)
2574{
2575 /* If we're in breakpoints-always-inserted mode or if breakpoints
2576 are global across processes, we have to remove them before
2577 disconnecting. */
2579
2580 current_inferior ()->top_target ()->disconnect (args, from_tty);
2581}
2582
2583/* See target/target.h. */
2584
2585ptid_t
2587 target_wait_flags options)
2588{
2589 target_ops *target = current_inferior ()->top_target ();
2591
2592 gdb_assert (!proc_target->commit_resumed_state);
2593
2594 if (!target_can_async_p (target))
2595 gdb_assert ((options & TARGET_WNOHANG) == 0);
2596
2597 try
2598 {
2599 gdb::observers::target_pre_wait.notify (ptid);
2600 ptid_t event_ptid = target->wait (ptid, status, options);
2601 gdb::observers::target_post_wait.notify (event_ptid);
2602 return event_ptid;
2603 }
2604 catch (...)
2605 {
2606 gdb::observers::target_post_wait.notify (null_ptid);
2607 throw;
2608 }
2609}
2610
2611/* See target.h. */
2612
2613ptid_t
2615 ptid_t ptid, struct target_waitstatus *status,
2616 target_wait_flags options)
2617{
2618 status->set_ignore ();
2619 return minus_one_ptid;
2620}
2621
2622std::string
2624{
2625 return current_inferior ()->top_target ()->pid_to_str (ptid);
2626}
2627
2628const char *
2630{
2631 gdb_assert (info->inf == current_inferior ());
2632
2633 return current_inferior ()->top_target ()->thread_name (info);
2634}
2635
2636struct thread_info *
2637target_thread_handle_to_thread_info (const gdb_byte *thread_handle,
2638 int handle_len,
2639 struct inferior *inf)
2640{
2641 target_ops *target = current_inferior ()->top_target ();
2642
2643 return target->thread_handle_to_thread_info (thread_handle, handle_len, inf);
2644}
2645
2646/* See target.h. */
2647
2648gdb::array_view<const gdb_byte>
2650{
2651 target_ops *target = current_inferior ()->top_target ();
2652
2653 return target->thread_info_to_thread_handle (tip);
2654}
2655
2656void
2657target_resume (ptid_t scope_ptid, int step, enum gdb_signal signal)
2658{
2660 gdb_assert (!curr_target->commit_resumed_state);
2661
2662 gdb_assert (inferior_ptid != null_ptid);
2663 gdb_assert (inferior_ptid.matches (scope_ptid));
2664
2666
2667 current_inferior ()->top_target ()->resume (scope_ptid, step, signal);
2668
2669 registers_changed_ptid (curr_target, scope_ptid);
2670 /* We only set the internal executing state here. The user/frontend
2671 running state is set at a higher level. This also clears the
2672 thread's stop_pc as side effect. */
2673 set_executing (curr_target, scope_ptid, true);
2674 clear_inline_frame_state (curr_target, scope_ptid);
2675
2676 if (target_can_async_p ())
2677 target_async (true);
2678}
2679
2680/* See target.h. */
2681
2682void
2684{
2685 gdb_assert (current_inferior ()->process_target ()->commit_resumed_state);
2687}
2688
2689/* See target.h. */
2690
2691bool
2696
2697void
2698target_pass_signals (gdb::array_view<const unsigned char> pass_signals)
2699{
2700 current_inferior ()->top_target ()->pass_signals (pass_signals);
2701}
2702
2703void
2704target_program_signals (gdb::array_view<const unsigned char> program_signals)
2705{
2706 current_inferior ()->top_target ()->program_signals (program_signals);
2707}
2708
2709static void
2710default_follow_fork (struct target_ops *self, inferior *child_inf,
2711 ptid_t child_ptid, target_waitkind fork_kind,
2712 bool follow_child, bool detach_fork)
2713{
2714 /* Some target returned a fork event, but did not know how to follow it. */
2715 internal_error (_("could not find a target to follow fork"));
2716}
2717
2718/* See target.h. */
2719
2720void
2721target_follow_fork (inferior *child_inf, ptid_t child_ptid,
2722 target_waitkind fork_kind, bool follow_child,
2723 bool detach_fork)
2724{
2725 target_ops *target = current_inferior ()->top_target ();
2726
2727 /* Check consistency between CHILD_INF, CHILD_PTID, FOLLOW_CHILD and
2728 DETACH_FORK. */
2729 if (child_inf != nullptr)
2730 {
2731 gdb_assert (follow_child || !detach_fork);
2732 gdb_assert (child_inf->pid == child_ptid.pid ());
2733 }
2734 else
2735 gdb_assert (!follow_child && detach_fork);
2736
2737 return target->follow_fork (child_inf, child_ptid, fork_kind, follow_child,
2738 detach_fork);
2739}
2740
2741/* See target.h. */
2742
2743void
2744target_follow_exec (inferior *follow_inf, ptid_t ptid,
2745 const char *execd_pathname)
2746{
2747 current_inferior ()->top_target ()->follow_exec (follow_inf, ptid,
2748 execd_pathname);
2749}
2750
2751static void
2753{
2754 internal_error (_("could not find a target to follow mourn inferior"));
2755}
2756
2757void
2759{
2760 gdb_assert (ptid.pid () == inferior_ptid.pid ());
2762
2763 /* We no longer need to keep handles on any of the object files.
2764 Make sure to release them to avoid unnecessarily locking any
2765 of them while we're not actually debugging. */
2766 bfd_cache_close_all ();
2767}
2768
2769/* Look for a target which can describe architectural features, starting
2770 from TARGET. If we find one, return its description. */
2771
2772const struct target_desc *
2774{
2775 return target->read_description ();
2776}
2777
2778
2779/* Default implementation of memory-searching. */
2780
2781static int
2783 CORE_ADDR start_addr, ULONGEST search_space_len,
2784 const gdb_byte *pattern, ULONGEST pattern_len,
2785 CORE_ADDR *found_addrp)
2786{
2787 auto read_memory = [=] (CORE_ADDR addr, gdb_byte *result, size_t len)
2788 {
2789 return target_read (current_inferior ()->top_target (),
2791 result, addr, len) == len;
2792 };
2793
2794 /* Start over from the top of the target stack. */
2795 return simple_search_memory (read_memory, start_addr, search_space_len,
2796 pattern, pattern_len, found_addrp);
2797}
2798
2799/* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2800 sequence of bytes in PATTERN with length PATTERN_LEN.
2801
2802 The result is 1 if found, 0 if not found, and -1 if there was an error
2803 requiring halting of the search (e.g. memory read error).
2804 If the pattern is found the address is recorded in FOUND_ADDRP. */
2805
2806int
2807target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2808 const gdb_byte *pattern, ULONGEST pattern_len,
2809 CORE_ADDR *found_addrp)
2810{
2811 target_ops *target = current_inferior ()->top_target ();
2812
2813 return target->search_memory (start_addr, search_space_len, pattern,
2814 pattern_len, found_addrp);
2815}
2816
2817/* Look through the currently pushed targets. If none of them will
2818 be able to restart the currently running process, issue an error
2819 message. */
2820
2821void
2823{
2824 for (target_ops *t = current_inferior ()->top_target ();
2825 t != NULL;
2826 t = t->beneath ())
2827 {
2828 /* If this target knows how to create a new program, then
2829 assume we will still be able to after killing the current
2830 one. Either killing and mourning will not pop T, or else
2831 find_default_run_target will find it again. */
2832 if (t->can_create_inferior ())
2833 return;
2834
2835 /* Do not worry about targets at certain strata that can not
2836 create inferiors. Assume they will be pushed again if
2837 necessary, and continue to the process_stratum. */
2838 if (t->stratum () > process_stratum)
2839 continue;
2840
2841 error (_("The \"%s\" target does not support \"run\". "
2842 "Try \"help target\" or \"continue\"."),
2843 t->shortname ());
2844 }
2845
2846 /* This function is only called if the target is running. In that
2847 case there should have been a process_stratum target and it
2848 should either know how to create inferiors, or not... */
2849 internal_error (_("No targets found"));
2850}
2851
2852/* Whether GDB is allowed to fall back to the default run target for
2853 "run", "attach", etc. when no target is connected yet. */
2855
2856static void
2857show_auto_connect_native_target (struct ui_file *file, int from_tty,
2858 struct cmd_list_element *c, const char *value)
2859{
2860 gdb_printf (file,
2861 _("Whether GDB may automatically connect to the "
2862 "native target is %s.\n"),
2863 value);
2864}
2865
2866/* A pointer to the target that can respond to "run" or "attach".
2867 Native targets are always singletons and instantiated early at GDB
2868 startup. */
2870
2871/* See target.h. */
2872
2873void
2875{
2876 if (the_native_target != NULL)
2877 internal_error (_("native target already set (\"%s\")."),
2879
2880 the_native_target = target;
2881}
2882
2883/* See target.h. */
2884
2885target_ops *
2887{
2888 return the_native_target;
2889}
2890
2891/* Look through the list of possible targets for a target that can
2892 execute a run or attach command without any other data. This is
2893 used to locate the default process stratum.
2894
2895 If DO_MESG is not NULL, the result is always valid (error() is
2896 called for errors); else, return NULL on error. */
2897
2898static struct target_ops *
2899find_default_run_target (const char *do_mesg)
2900{
2902 return the_native_target;
2903
2904 if (do_mesg != NULL)
2905 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2906 return NULL;
2907}
2908
2909/* See target.h. */
2910
2911struct target_ops *
2913{
2914 /* If a target on the current stack can attach, use it. */
2915 for (target_ops *t = current_inferior ()->top_target ();
2916 t != NULL;
2917 t = t->beneath ())
2918 {
2919 if (t->can_attach ())
2920 return t;
2921 }
2922
2923 /* Otherwise, use the default run target for attaching. */
2924 return find_default_run_target ("attach");
2925}
2926
2927/* See target.h. */
2928
2929struct target_ops *
2931{
2932 /* If a target on the current stack can run, use it. */
2933 for (target_ops *t = current_inferior ()->top_target ();
2934 t != NULL;
2935 t = t->beneath ())
2936 {
2937 if (t->can_create_inferior ())
2938 return t;
2939 }
2940
2941 /* Otherwise, use the default run target. */
2942 return find_default_run_target ("run");
2943}
2944
2945bool
2946target_ops::info_proc (const char *args, enum info_proc_what what)
2947{
2948 return false;
2949}
2950
2951/* Implement the "info proc" command. */
2952
2953int
2954target_info_proc (const char *args, enum info_proc_what what)
2955{
2956 struct target_ops *t;
2957
2958 /* If we're already connected to something that can get us OS
2959 related data, use it. Otherwise, try using the native
2960 target. */
2962 if (t == NULL)
2963 t = find_default_run_target (NULL);
2964
2965 for (; t != NULL; t = t->beneath ())
2966 {
2967 if (t->info_proc (args, what))
2968 {
2969 if (targetdebug)
2971 "target_info_proc (\"%s\", %d)\n", args, what);
2972
2973 return 1;
2974 }
2975 }
2976
2977 return 0;
2978}
2979
2980static int
2982{
2983 struct target_ops *t;
2984
2985 t = find_default_run_target (NULL);
2986 if (t != NULL)
2987 return t->supports_disable_randomization ();
2988 return 0;
2989}
2990
2991int
2996
2997/* See target/target.h. */
2998
2999int
3004
3005/* See target.h. */
3006
3007gdb::optional<gdb::char_vector>
3009{
3010 struct target_ops *t;
3011
3012 /* If we're already connected to something that can get us OS
3013 related data, use it. Otherwise, try using the native
3014 target. */
3016 if (t == NULL)
3017 t = find_default_run_target ("get OS data");
3018
3019 if (!t)
3020 return {};
3021
3023}
3024
3025/* Determine the current address space of thread PTID. */
3026
3027struct address_space *
3029{
3030 struct address_space *aspace;
3031
3032 aspace = current_inferior ()->top_target ()->thread_address_space (ptid);
3033 gdb_assert (aspace != NULL);
3034
3035 return aspace;
3036}
3037
3038/* See target.h. */
3039
3040target_ops *
3042{
3043 return current_inferior ()->find_target_beneath (this);
3044}
3045
3046void
3048{
3049}
3050
3051bool
3053{
3054 return 0;
3055}
3056
3057void
3058target_ops::attach (const char *, int)
3059{
3060 gdb_assert_not_reached ("target_ops::attach called");
3061}
3062
3063bool
3065{
3066 return 0;
3067}
3068
3069void
3070target_ops::create_inferior (const char *, const std::string &,
3071 char **, int)
3072{
3073 gdb_assert_not_reached ("target_ops::create_inferior called");
3074}
3075
3076bool
3078{
3079 return false;
3080}
3081
3082int
3084{
3085 for (target_ops *t = current_inferior ()->top_target ();
3086 t != NULL;
3087 t = t->beneath ())
3088 {
3089 if (t->can_run ())
3090 return 1;
3091 }
3092
3093 return 0;
3094}
3095
3096/* Target file operations. */
3097
3098static struct target_ops *
3100{
3101 struct target_ops *t;
3102
3103 /* If we're already connected to something that can perform
3104 file I/O, use it. Otherwise, try using the native target. */
3106 if (t != NULL)
3107 return t;
3108 return find_default_run_target ("file I/O");
3109}
3110
3111/* File handle for target file operations. */
3112
3114{
3115 /* The target on which this file is open. NULL if the target is
3116 meanwhile closed while the handle is open. */
3118
3119 /* The file descriptor on the target. */
3121
3122 /* Check whether this fileio_fh_t represents a closed file. */
3124 {
3125 return target_fd < 0;
3126 }
3127};
3128
3129/* Vector of currently open file handles. The value returned by
3130 target_fileio_open and passed as the FD argument to other
3131 target_fileio_* functions is an index into this vector. This
3132 vector's entries are never freed; instead, files are marked as
3133 closed, and the handle becomes available for reuse. */
3134static std::vector<fileio_fh_t> fileio_fhandles;
3135
3136/* Index into fileio_fhandles of the lowest handle that might be
3137 closed. This permits handle reuse without searching the whole
3138 list each time a new file is opened. */
3140
3141/* See target.h. */
3142
3143void
3145{
3146 for (fileio_fh_t &fh : fileio_fhandles)
3147 if (fh.target == targ)
3148 fh.target = NULL;
3149}
3150
3151/* Acquire a target fileio file descriptor. */
3152
3153static int
3154acquire_fileio_fd (target_ops *target, int target_fd)
3155{
3156 /* Search for closed handles to reuse. */
3158 {
3160
3161 if (fh.is_closed ())
3162 break;
3163 }
3164
3165 /* Push a new handle if no closed handles were found. */
3166 if (lowest_closed_fd == fileio_fhandles.size ())
3167 fileio_fhandles.push_back (fileio_fh_t {target, target_fd});
3168 else
3169 fileio_fhandles[lowest_closed_fd] = {target, target_fd};
3170
3171 /* Should no longer be marked closed. */
3172 gdb_assert (!fileio_fhandles[lowest_closed_fd].is_closed ());
3173
3174 /* Return its index, and start the next lookup at
3175 the next index. */
3176 return lowest_closed_fd++;
3177}
3178
3179/* Release a target fileio file descriptor. */
3180
3181static void
3183{
3184 fh->target_fd = -1;
3185 lowest_closed_fd = std::min (lowest_closed_fd, fd);
3186}
3187
3188/* Return a pointer to the fileio_fhandle_t corresponding to FD. */
3189
3190static fileio_fh_t *
3192{
3193 return &fileio_fhandles[fd];
3194}
3195
3196
3197/* Default implementations of file i/o methods. We don't want these
3198 to delegate automatically, because we need to know which target
3199 supported the method, in order to call it directly from within
3200 pread/pwrite, etc. */
3201
3202int
3203target_ops::fileio_open (struct inferior *inf, const char *filename,
3204 int flags, int mode, int warn_if_slow,
3205 fileio_error *target_errno)
3206{
3207 *target_errno = FILEIO_ENOSYS;
3208 return -1;
3209}
3210
3211int
3212target_ops::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3213 ULONGEST offset, fileio_error *target_errno)
3214{
3215 *target_errno = FILEIO_ENOSYS;
3216 return -1;
3217}
3218
3219int
3220target_ops::fileio_pread (int fd, gdb_byte *read_buf, int len,
3221 ULONGEST offset, fileio_error *target_errno)
3222{
3223 *target_errno = FILEIO_ENOSYS;
3224 return -1;
3225}
3226
3227int
3228target_ops::fileio_fstat (int fd, struct stat *sb, fileio_error *target_errno)
3229{
3230 *target_errno = FILEIO_ENOSYS;
3231 return -1;
3232}
3233
3234int
3235target_ops::fileio_close (int fd, fileio_error *target_errno)
3236{
3237 *target_errno = FILEIO_ENOSYS;
3238 return -1;
3239}
3240
3241int
3242target_ops::fileio_unlink (struct inferior *inf, const char *filename,
3243 fileio_error *target_errno)
3244{
3245 *target_errno = FILEIO_ENOSYS;
3246 return -1;
3247}
3248
3249gdb::optional<std::string>
3250target_ops::fileio_readlink (struct inferior *inf, const char *filename,
3251 fileio_error *target_errno)
3252{
3253 *target_errno = FILEIO_ENOSYS;
3254 return {};
3255}
3256
3257/* See target.h. */
3258
3259int
3260target_fileio_open (struct inferior *inf, const char *filename,
3261 int flags, int mode, bool warn_if_slow, fileio_error *target_errno)
3262{
3263 for (target_ops *t = default_fileio_target (); t != NULL; t = t->beneath ())
3264 {
3265 int fd = t->fileio_open (inf, filename, flags, mode,
3266 warn_if_slow, target_errno);
3267
3268 if (fd == -1 && *target_errno == FILEIO_ENOSYS)
3269 continue;
3270
3271 if (fd < 0)
3272 fd = -1;
3273 else
3274 fd = acquire_fileio_fd (t, fd);
3275
3276 if (targetdebug)
3278 "target_fileio_open (%d,%s,0x%x,0%o,%d)"
3279 " = %d (%d)\n",
3280 inf == NULL ? 0 : inf->num,
3281 filename, flags, mode,
3282 warn_if_slow, fd,
3283 fd != -1 ? 0 : *target_errno);
3284 return fd;
3285 }
3286
3287 *target_errno = FILEIO_ENOSYS;
3288 return -1;
3289}
3290
3291/* See target.h. */
3292
3293int
3294target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3295 ULONGEST offset, fileio_error *target_errno)
3296{
3297 fileio_fh_t *fh = fileio_fd_to_fh (fd);
3298 int ret = -1;
3299
3300 if (fh->is_closed ())
3301 *target_errno = FILEIO_EBADF;
3302 else if (fh->target == NULL)
3303 *target_errno = FILEIO_EIO;
3304 else
3305 ret = fh->target->fileio_pwrite (fh->target_fd, write_buf,
3306 len, offset, target_errno);
3307
3308 if (targetdebug)
3310 "target_fileio_pwrite (%d,...,%d,%s) "
3311 "= %d (%d)\n",
3312 fd, len, pulongest (offset),
3313 ret, ret != -1 ? 0 : *target_errno);
3314 return ret;
3315}
3316
3317/* See target.h. */
3318
3319int
3320target_fileio_pread (int fd, gdb_byte *read_buf, int len,
3321 ULONGEST offset, fileio_error *target_errno)
3322{
3323 fileio_fh_t *fh = fileio_fd_to_fh (fd);
3324 int ret = -1;
3325
3326 if (fh->is_closed ())
3327 *target_errno = FILEIO_EBADF;
3328 else if (fh->target == NULL)
3329 *target_errno = FILEIO_EIO;
3330 else
3331 ret = fh->target->fileio_pread (fh->target_fd, read_buf,
3332 len, offset, target_errno);
3333
3334 if (targetdebug)
3336 "target_fileio_pread (%d,...,%d,%s) "
3337 "= %d (%d)\n",
3338 fd, len, pulongest (offset),
3339 ret, ret != -1 ? 0 : *target_errno);
3340 return ret;
3341}
3342
3343/* See target.h. */
3344
3345int
3346target_fileio_fstat (int fd, struct stat *sb, fileio_error *target_errno)
3347{
3348 fileio_fh_t *fh = fileio_fd_to_fh (fd);
3349 int ret = -1;
3350
3351 if (fh->is_closed ())
3352 *target_errno = FILEIO_EBADF;
3353 else if (fh->target == NULL)
3354 *target_errno = FILEIO_EIO;
3355 else
3356 ret = fh->target->fileio_fstat (fh->target_fd, sb, target_errno);
3357
3358 if (targetdebug)
3360 "target_fileio_fstat (%d) = %d (%d)\n",
3361 fd, ret, ret != -1 ? 0 : *target_errno);
3362 return ret;
3363}
3364
3365/* See target.h. */
3366
3367int
3368target_fileio_close (int fd, fileio_error *target_errno)
3369{
3370 fileio_fh_t *fh = fileio_fd_to_fh (fd);
3371 int ret = -1;
3372
3373 if (fh->is_closed ())
3374 *target_errno = FILEIO_EBADF;
3375 else
3376 {
3377 if (fh->target != NULL)
3378 ret = fh->target->fileio_close (fh->target_fd,
3379 target_errno);
3380 else
3381 ret = 0;
3382 release_fileio_fd (fd, fh);
3383 }
3384
3385 if (targetdebug)
3387 "target_fileio_close (%d) = %d (%d)\n",
3388 fd, ret, ret != -1 ? 0 : *target_errno);
3389 return ret;
3390}
3391
3392/* See target.h. */
3393
3394int
3395target_fileio_unlink (struct inferior *inf, const char *filename,
3396 fileio_error *target_errno)
3397{
3398 for (target_ops *t = default_fileio_target (); t != NULL; t = t->beneath ())
3399 {
3400 int ret = t->fileio_unlink (inf, filename, target_errno);
3401
3402 if (ret == -1 && *target_errno == FILEIO_ENOSYS)
3403 continue;
3404
3405 if (targetdebug)
3407 "target_fileio_unlink (%d,%s)"
3408 " = %d (%d)\n",
3409 inf == NULL ? 0 : inf->num, filename,
3410 ret, ret != -1 ? 0 : *target_errno);
3411 return ret;
3412 }
3413
3414 *target_errno = FILEIO_ENOSYS;
3415 return -1;
3416}
3417
3418/* See target.h. */
3419
3420gdb::optional<std::string>
3421target_fileio_readlink (struct inferior *inf, const char *filename,
3422 fileio_error *target_errno)
3423{
3424 for (target_ops *t = default_fileio_target (); t != NULL; t = t->beneath ())
3425 {
3426 gdb::optional<std::string> ret
3427 = t->fileio_readlink (inf, filename, target_errno);
3428
3429 if (!ret.has_value () && *target_errno == FILEIO_ENOSYS)
3430 continue;
3431
3432 if (targetdebug)
3434 "target_fileio_readlink (%d,%s)"
3435 " = %s (%d)\n",
3436 inf == NULL ? 0 : inf->num,
3437 filename, ret ? ret->c_str () : "(nil)",
3438 ret ? 0 : *target_errno);
3439 return ret;
3440 }
3441
3442 *target_errno = FILEIO_ENOSYS;
3443 return {};
3444}
3445
3446/* Like scoped_fd, but specific to target fileio. */
3447
3449{
3450public:
3451 explicit scoped_target_fd (int fd) noexcept
3452 : m_fd (fd)
3453 {
3454 }
3455
3457 {
3458 if (m_fd >= 0)
3459 {
3460 fileio_error target_errno;
3461
3462 target_fileio_close (m_fd, &target_errno);
3463 }
3464 }
3465
3467
3468 int get () const noexcept
3469 {
3470 return m_fd;
3471 }
3472
3473private:
3474 int m_fd;
3475};
3476
3477/* Read target file FILENAME, in the filesystem as seen by INF. If
3478 INF is NULL, use the filesystem seen by the debugger (GDB or, for
3479 remote targets, the remote stub). Store the result in *BUF_P and
3480 return the size of the transferred data. PADDING additional bytes
3481 are available in *BUF_P. This is a helper function for
3482 target_fileio_read_alloc; see the declaration of that function for
3483 more information. */
3484
3485static LONGEST
3486target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
3487 gdb_byte **buf_p, int padding)
3488{
3489 size_t buf_alloc, buf_pos;
3490 gdb_byte *buf;
3491 LONGEST n;
3492 fileio_error target_errno;
3493
3494 scoped_target_fd fd (target_fileio_open (inf, filename, FILEIO_O_RDONLY,
3495 0700, false, &target_errno));
3496 if (fd.get () == -1)
3497 return -1;
3498
3499 /* Start by reading up to 4K at a time. The target will throttle
3500 this number down if necessary. */
3501 buf_alloc = 4096;
3502 buf = (gdb_byte *) xmalloc (buf_alloc);
3503 buf_pos = 0;
3504 while (1)
3505 {
3506 n = target_fileio_pread (fd.get (), &buf[buf_pos],
3507 buf_alloc - buf_pos - padding, buf_pos,
3508 &target_errno);
3509 if (n < 0)
3510 {
3511 /* An error occurred. */
3512 xfree (buf);
3513 return -1;
3514 }
3515 else if (n == 0)
3516 {
3517 /* Read all there was. */
3518 if (buf_pos == 0)
3519 xfree (buf);
3520 else
3521 *buf_p = buf;
3522 return buf_pos;
3523 }
3524
3525 buf_pos += n;
3526
3527 /* If the buffer is filling up, expand it. */
3528 if (buf_alloc < buf_pos * 2)
3529 {
3530 buf_alloc *= 2;
3531 buf = (gdb_byte *) xrealloc (buf, buf_alloc);
3532 }
3533
3534 QUIT;
3535 }
3536}
3537
3538/* See target.h. */
3539
3540LONGEST
3541target_fileio_read_alloc (struct inferior *inf, const char *filename,
3542 gdb_byte **buf_p)
3543{
3544 return target_fileio_read_alloc_1 (inf, filename, buf_p, 0);
3545}
3546
3547/* See target.h. */
3548
3549gdb::unique_xmalloc_ptr<char>
3550target_fileio_read_stralloc (struct inferior *inf, const char *filename)
3551{
3552 gdb_byte *buffer;
3553 char *bufstr;
3554 LONGEST i, transferred;
3555
3556 transferred = target_fileio_read_alloc_1 (inf, filename, &buffer, 1);
3557 bufstr = (char *) buffer;
3558
3559 if (transferred < 0)
3560 return gdb::unique_xmalloc_ptr<char> (nullptr);
3561
3562 if (transferred == 0)
3563 return make_unique_xstrdup ("");
3564
3565 bufstr[transferred] = 0;
3566
3567 /* Check for embedded NUL bytes; but allow trailing NULs. */
3568 for (i = strlen (bufstr); i < transferred; i++)
3569 if (bufstr[i] != 0)
3570 {
3571 warning (_("target file %s "
3572 "contained unexpected null characters"),
3573 filename);
3574 break;
3575 }
3576
3577 return gdb::unique_xmalloc_ptr<char> (bufstr);
3578}
3579
3580
3581static int
3583 CORE_ADDR addr, int len)
3584{
3585 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3586}
3587
3588static int
3590 CORE_ADDR addr,
3591 CORE_ADDR start, int length)
3592{
3593 return addr >= start && addr < start + length;
3594}
3595
3596/* See target.h. */
3597
3598target_ops *
3600{
3601 /* Look for a non-empty slot at stratum levels beneath T's. */
3602 for (int stratum = t->stratum () - 1; stratum >= 0; --stratum)
3603 if (m_stack[stratum].get () != NULL)
3604 return m_stack[stratum].get ();
3605
3606 return NULL;
3607}
3608
3609/* See target.h. */
3610
3611struct target_ops *
3613{
3614 return current_inferior ()->target_at (stratum);
3615}
3616
3617
3618
3619/* See target.h */
3620
3621void
3623{
3624 pid_t pid;
3625 const char *exec_file;
3626
3627 if (!from_tty)
3628 return;
3629
3630 pid = inferior_ptid.pid ();
3631 exec_file = get_exec_file (0);
3632 if (exec_file == nullptr)
3633 gdb_printf ("Detaching from pid %s\n",
3634 target_pid_to_str (ptid_t (pid)).c_str ());
3635 else
3636 gdb_printf (_("Detaching from program: %s, %s\n"), exec_file,
3637 target_pid_to_str (ptid_t (pid)).c_str ());
3638}
3639
3640/* See target.h */
3641
3642void
3643target_announce_attach (int from_tty, int pid)
3644{
3645 if (!from_tty)
3646 return;
3647
3648 const char *exec_file = get_exec_file (0);
3649
3650 if (exec_file != nullptr)
3651 gdb_printf ("Attaching to program: %s, %s\n", exec_file,
3652 target_pid_to_str (ptid_t (pid)).c_str ());
3653 else
3654 gdb_printf ("Attaching to %s\n",
3655 target_pid_to_str (ptid_t (pid)).c_str ());
3656}
3657
3658/* The inferior process has died. Long live the inferior! */
3659
3660void
3662{
3664
3666
3667 /* Mark breakpoints uninserted in case something tries to delete a
3668 breakpoint while we delete the inferior's threads (which would
3669 fail, since the inferior is long gone). */
3671
3672 if (inf->pid != 0)
3674
3675 /* Note this wipes step-resume breakpoints, so needs to be done
3676 after exit_inferior, which ends up referencing the step-resume
3677 breakpoints through clear_thread_inferior_resources. */
3679
3681
3684
3687}
3688
3689/* Convert a normal process ID to a string. Returns the string in a
3690 static buffer. */
3691
3692std::string
3694{
3695 return string_printf ("process %d", ptid.pid ());
3696}
3697
3698static std::string
3699default_pid_to_str (struct target_ops *ops, ptid_t ptid)
3700{
3701 return normal_pid_to_str (ptid);
3702}
3703
3704/* Error-catcher for target_find_memory_regions. */
3705static int
3707 find_memory_region_ftype ignore1, void *ignore2)
3708{
3709 error (_("Command not implemented for this target."));
3710 return 0;
3711}
3712
3713/* Error-catcher for target_make_corefile_notes. */
3714static gdb::unique_xmalloc_ptr<char>
3716 bfd *ignore1, int *ignore2)
3717{
3718 error (_("Command not implemented for this target."));
3719 return NULL;
3720}
3721
3722#include "target-delegates.c"
3723
3724/* The initial current target, so that there is always a semi-valid
3725 current target. */
3726
3728
3729/* See target.h. */
3730
3731target_ops *
3733{
3734 return &the_dummy_target;
3735}
3736
3738 "None",
3739 N_("None"),
3740 ""
3741};
3742
3743strata
3745{
3746 return dummy_stratum;
3747}
3748
3749strata
3751{
3752 return debug_stratum;
3753}
3754
3755const target_info &
3757{
3758 return dummy_target_info;
3759}
3760
3761const target_info &
3763{
3764 return beneath ()->info ();
3765}
3766
3767
3768
3769int
3771{
3772 return current_inferior ()->top_target ()->thread_alive (ptid);
3773}
3774
3775void
3780
3781void
3782target_stop (ptid_t ptid)
3783{
3785
3786 gdb_assert (!proc_target->commit_resumed_state);
3787
3788 if (!may_stop)
3789 {
3790 warning (_("May not interrupt or stop the target, ignoring attempt"));
3791 return;
3792 }
3793
3794 current_inferior ()->top_target ()->stop (ptid);
3795}
3796
3797void
3799{
3800 if (!may_stop)
3801 {
3802 warning (_("May not interrupt or stop the target, ignoring attempt"));
3803 return;
3804 }
3805
3807}
3808
3809/* See target.h. */
3810
3811void
3813{
3814 /* Pass the Ctrl-C to the first target that has a thread
3815 running. */
3816 for (inferior *inf : all_inferiors ())
3817 {
3818 target_ops *proc_target = inf->process_target ();
3819 if (proc_target == NULL)
3820 continue;
3821
3822 for (thread_info *thr : inf->non_exited_threads ())
3823 {
3824 /* A thread can be THREAD_STOPPED and executing, while
3825 running an infcall. */
3826 if (thr->state == THREAD_RUNNING || thr->executing ())
3827 {
3828 /* We can get here quite deep in target layers. Avoid
3829 switching thread context or anything that would
3830 communicate with the target (e.g., to fetch
3831 registers), or flushing e.g., the frame cache. We
3832 just switch inferior in order to be able to call
3833 through the target_stack. */
3834 scoped_restore_current_inferior restore_inferior;
3837 return;
3838 }
3839 }
3840 }
3841}
3842
3843/* See target.h. */
3844
3845void
3847{
3849}
3850
3851/* See target/target.h. */
3852
3853void
3855{
3857 bool was_non_stop = non_stop;
3858
3859 non_stop = true;
3860 target_stop (ptid);
3861
3862 target_wait (ptid, &status, 0);
3863
3864 non_stop = was_non_stop;
3865}
3866
3867/* See target/target.h. */
3868
3869void
3871{
3872 target_resume (ptid, 0, GDB_SIGNAL_0);
3873}
3874
3875/* See target/target.h. */
3876
3877void
3878target_continue (ptid_t ptid, enum gdb_signal signal)
3879{
3880 target_resume (ptid, 0, signal);
3881}
3882
3883/* Concatenate ELEM to LIST, a comma-separated list. */
3884
3885static void
3886str_comma_list_concat_elem (std::string *list, const char *elem)
3887{
3888 if (!list->empty ())
3889 list->append (", ");
3890
3891 list->append (elem);
3892}
3893
3894/* Helper for target_options_to_string. If OPT is present in
3895 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3896 OPT is removed from TARGET_OPTIONS. */
3897
3898static void
3899do_option (target_wait_flags *target_options, std::string *ret,
3900 target_wait_flag opt, const char *opt_str)
3901{
3902 if ((*target_options & opt) != 0)
3903 {
3904 str_comma_list_concat_elem (ret, opt_str);
3905 *target_options &= ~opt;
3906 }
3907}
3908
3909/* See target.h. */
3910
3911std::string
3912target_options_to_string (target_wait_flags target_options)
3913{
3914 std::string ret;
3915
3916#define DO_TARG_OPTION(OPT) \
3917 do_option (&target_options, &ret, OPT, #OPT)
3918
3920
3921 if (target_options != 0)
3922 str_comma_list_concat_elem (&ret, "unknown???");
3923
3924 return ret;
3925}
3926
3927void
3929{
3931 if (targetdebug)
3932 regcache->debug_print_register ("target_fetch_registers", regno);
3933}
3934
3935void
3937{
3939 error (_("Writing to registers is not allowed (regno %d)"), regno);
3940
3942 if (targetdebug)
3943 {
3944 regcache->debug_print_register ("target_store_registers", regno);
3945 }
3946}
3947
3948int
3950{
3951 return current_inferior ()->top_target ()->core_of_thread (ptid);
3952}
3953
3954int
3956 const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
3957{
3958 LONGEST total_xfered = 0;
3959
3960 while (total_xfered < size)
3961 {
3962 ULONGEST xfered_len;
3964 gdb_byte buf[1024];
3965 ULONGEST howmuch = std::min<ULONGEST> (sizeof (buf), size - total_xfered);
3966
3968 buf, NULL, lma + total_xfered, howmuch,
3969 &xfered_len);
3970 if (status == TARGET_XFER_OK
3971 && memcmp (data + total_xfered, buf, xfered_len) == 0)
3972 {
3973 total_xfered += xfered_len;
3974 QUIT;
3975 }
3976 else
3977 return 0;
3978 }
3979 return 1;
3980}
3981
3982/* Default implementation of memory verification. */
3983
3984static int
3986 const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3987{
3988 /* Start over from the top of the target stack. */
3989 return simple_verify_memory (current_inferior ()->top_target (),
3990 data, memaddr, size);
3991}
3992
3993int
3994target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3995{
3996 target_ops *target = current_inferior ()->top_target ();
3997
3998 return target->verify_memory (data, memaddr, size);
3999}
4000
4001/* The documentation for this function is in its prototype declaration in
4002 target.h. */
4003
4004int
4005target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask,
4006 enum target_hw_bp_type rw)
4007{
4008 target_ops *target = current_inferior ()->top_target ();
4009
4010 return target->insert_mask_watchpoint (addr, mask, rw);
4011}
4012
4013/* The documentation for this function is in its prototype declaration in
4014 target.h. */
4015
4016int
4017target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask,
4018 enum target_hw_bp_type rw)
4019{
4020 target_ops *target = current_inferior ()->top_target ();
4021
4022 return target->remove_mask_watchpoint (addr, mask, rw);
4023}
4024
4025/* The documentation for this function is in its prototype declaration
4026 in target.h. */
4027
4028int
4029target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
4030{
4031 target_ops *target = current_inferior ()->top_target ();
4032
4033 return target->masked_watch_num_registers (addr, mask);
4034}
4035
4036/* The documentation for this function is in its prototype declaration
4037 in target.h. */
4038
4039int
4044
4045/* See target.h. */
4046
4047struct btrace_target_info *
4048target_enable_btrace (thread_info *tp, const struct btrace_config *conf)
4049{
4050 return current_inferior ()->top_target ()->enable_btrace (tp, conf);
4051}
4052
4053/* See target.h. */
4054
4055void
4056target_disable_btrace (struct btrace_target_info *btinfo)
4057{
4059}
4060
4061/* See target.h. */
4062
4063void
4064target_teardown_btrace (struct btrace_target_info *btinfo)
4065{
4067}
4068
4069/* See target.h. */
4070
4071enum btrace_error
4072target_read_btrace (struct btrace_data *btrace,
4073 struct btrace_target_info *btinfo,
4074 enum btrace_read_type type)
4075{
4076 target_ops *target = current_inferior ()->top_target ();
4077
4078 return target->read_btrace (btrace, btinfo, type);
4079}
4080
4081/* See target.h. */
4082
4083const struct btrace_config *
4084target_btrace_conf (const struct btrace_target_info *btinfo)
4085{
4086 return current_inferior ()->top_target ()->btrace_conf (btinfo);
4087}
4088
4089/* See target.h. */
4090
4091void
4096
4097/* See target.h. */
4098
4099void
4100target_save_record (const char *filename)
4101{
4102 current_inferior ()->top_target ()->save_record (filename);
4103}
4104
4105/* See target.h. */
4106
4107int
4112
4113/* See target.h. */
4114
4115void
4120
4121/* See target.h. */
4122
4123enum record_method
4125{
4126 return current_inferior ()->top_target ()->record_method (ptid);
4127}
4128
4129/* See target.h. */
4130
4131int
4133{
4134 return current_inferior ()->top_target ()->record_is_replaying (ptid);
4135}
4136
4137/* See target.h. */
4138
4139int
4140target_record_will_replay (ptid_t ptid, int dir)
4141{
4142 return current_inferior ()->top_target ()->record_will_replay (ptid, dir);
4143}
4144
4145/* See target.h. */
4146
4147void
4152
4153/* See target.h. */
4154
4155void
4160
4161/* See target.h. */
4162
4163void
4168
4169/* See target.h. */
4170
4171void
4172target_goto_record (ULONGEST insn)
4173{
4175}
4176
4177/* See target.h. */
4178
4179void
4180target_insn_history (int size, gdb_disassembly_flags flags)
4181{
4183}
4184
4185/* See target.h. */
4186
4187void
4188target_insn_history_from (ULONGEST from, int size,
4189 gdb_disassembly_flags flags)
4190{
4192}
4193
4194/* See target.h. */
4195
4196void
4197target_insn_history_range (ULONGEST begin, ULONGEST end,
4198 gdb_disassembly_flags flags)
4199{
4201}
4202
4203/* See target.h. */
4204
4205void
4206target_call_history (int size, record_print_flags flags)
4207{
4209}
4210
4211/* See target.h. */
4212
4213void
4214target_call_history_from (ULONGEST begin, int size, record_print_flags flags)
4215{
4217}
4218
4219/* See target.h. */
4220
4221void
4222target_call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
4223{
4225}
4226
4227/* See target.h. */
4228
4229const struct frame_unwind *
4231{
4232 return current_inferior ()->top_target ()->get_unwinder ();
4233}
4234
4235/* See target.h. */
4236
4237const struct frame_unwind *
4242
4243/* See target.h. */
4244
4245void
4250
4251/* See target.h. */
4252
4253void
4258
4259
4260
4261static char targ_desc[] =
4262"Names of targets and files being debugged.\nShows the entire \
4263stack of targets currently in use (including the exec-file,\n\
4264core-file, and process, if any), as well as the symbol file name.";
4265
4266static void
4267default_rcmd (struct target_ops *self, const char *command,
4268 struct ui_file *output)
4269{
4270 error (_("\"monitor\" command not supported by this target."));
4271}
4272
4273static void
4274do_monitor_command (const char *cmd, int from_tty)
4275{
4276 target_rcmd (cmd, gdb_stdtarg);
4277}
4278
4279/* Erases all the memory regions marked as flash. CMD and FROM_TTY are
4280 ignored. */
4281
4282void
4283flash_erase_command (const char *cmd, int from_tty)
4284{
4285 /* Used to communicate termination of flash operations to the target. */
4286 bool found_flash_region = false;
4287 struct gdbarch *gdbarch = target_gdbarch ();
4288
4289 std::vector<mem_region> mem_regions = target_memory_map ();
4290
4291 /* Iterate over all memory regions. */
4292 for (const mem_region &m : mem_regions)
4293 {
4294 /* Is this a flash memory region? */
4295 if (m.attrib.mode == MEM_FLASH)
4296 {
4297 found_flash_region = true;
4298 target_flash_erase (m.lo, m.hi - m.lo);
4299
4300 ui_out_emit_tuple tuple_emitter (current_uiout, "erased-regions");
4301
4302 current_uiout->message (_("Erasing flash memory region at address "));
4303 current_uiout->field_core_addr ("address", gdbarch, m.lo);
4304 current_uiout->message (", size = ");
4305 current_uiout->field_string ("size", hex_string (m.hi - m.lo));
4306 current_uiout->message ("\n");
4307 }
4308 }
4309
4310 /* Did we do any flash operations? If so, we need to finalize them. */
4311 if (found_flash_region)
4313 else
4314 current_uiout->message (_("No flash memory regions found.\n"));
4315}
4316
4317/* Print the name of each layers of our target stack. */
4318
4319static void
4320maintenance_print_target_stack (const char *cmd, int from_tty)
4321{
4322 gdb_printf (_("The current target stack is:\n"));
4323
4324 for (target_ops *t = current_inferior ()->top_target ();
4325 t != NULL;
4326 t = t->beneath ())
4327 {
4328 if (t->stratum () == debug_stratum)
4329 continue;
4330 gdb_printf (" - %s (%s)\n", t->shortname (), t->longname ());
4331 }
4332}
4333
4334/* See target.h. */
4335
4336void
4338{
4339 /* If we are trying to enable async mode then it must be the case that
4340 async mode is possible for this target. */
4341 gdb_assert (!enable || target_can_async_p ());
4344}
4345
4346/* See target.h. */
4347
4348void
4353
4354/* Controls if targets can report that they can/are async. This is
4355 just for maintainers to use when debugging gdb. */
4357
4358static void
4360{
4361 if (have_live_inferiors ())
4362 error (_("Cannot change this setting while the inferior is running."));
4363
4364 target_async_permitted = permitted;
4365}
4366
4367static bool
4372
4373static void
4375 cmd_list_element *c, const char *value)
4376{
4377 gdb_printf (file,
4378 _("Controlling the inferior in "
4379 "asynchronous mode is %s.\n"), value);
4380}
4381
4382/* Return true if the target operates in non-stop mode even with "set
4383 non-stop off". */
4384
4385static int
4390
4391/* See target.h. */
4392
4393bool
4402
4403/* See target.h. */
4404
4405bool
4407{
4408 if (target_is_non_stop_p ())
4409 return true;
4410
4411 scoped_restore_current_thread restore_thread;
4412
4413 for (inferior *inf : all_inferiors ())
4414 {
4416 if (target_is_non_stop_p ())
4417 return true;
4418 }
4419
4420 return false;
4421}
4422
4423/* Controls if targets can report that they always run in non-stop
4424 mode. This is just for maintainers to use when debugging gdb. */
4426
4427/* Set callback for maint target-non-stop setting. */
4428
4429static void
4431{
4432 if (have_live_inferiors ())
4433 error (_("Cannot change this setting while the inferior is running."));
4434
4435 target_non_stop_enabled = enabled;
4436}
4437
4438/* Get callback for maint target-non-stop setting. */
4439
4440static auto_boolean
4445
4446static void
4448 cmd_list_element *c, const char *value)
4449{
4451 gdb_printf (file,
4452 _("Whether the target is always in non-stop mode "
4453 "is %s (currently %s).\n"), value,
4454 target_always_non_stop_p () ? "on" : "off");
4455 else
4456 gdb_printf (file,
4457 _("Whether the target is always in non-stop mode "
4458 "is %s.\n"), value);
4459}
4460
4461/* Temporary copies of permission settings. */
4462
4463static bool may_write_registers_1 = true;
4464static bool may_write_memory_1 = true;
4465static bool may_insert_breakpoints_1 = true;
4466static bool may_insert_tracepoints_1 = true;
4468static bool may_stop_1 = true;
4469
4470/* Make the user-set values match the real values again. */
4471
4472void
4482
4483/* The one function handles (most of) the permission flags in the same
4484 way. */
4485
4486static void
4487set_target_permissions (const char *args, int from_tty,
4488 struct cmd_list_element *c)
4489{
4490 if (target_has_execution ())
4491 {
4493 error (_("Cannot change this setting while the inferior is running."));
4494 }
4495
4496 /* Make the real values match the user-changed values. */
4502}
4503
4504/* Set some permissions independently of observer mode. */
4505
4506static void
4507set_write_memory_registers_permission (const char *args, int from_tty,
4508 struct cmd_list_element *c)
4509{
4510 /* Make the real values match the user-changed values. */
4514}
4515
4516void _initialize_target ();
4517
4518void
4520{
4521 the_debug_target = new debug_target ();
4522
4525
4526 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
4527Set target debugging."), _("\
4528Show target debugging."), _("\
4529When non-zero, target debugging is enabled. Higher numbers are more\n\
4530verbose."),
4531 set_targetdebug,
4534
4535 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
4536 &trust_readonly, _("\
4537Set mode for reading from readonly sections."), _("\
4538Show mode for reading from readonly sections."), _("\
4539When this mode is on, memory reads from readonly sections (such as .text)\n\
4540will be read from the object file instead of from the target. This will\n\
4541result in significant performance improvement for remote targets."),
4542 NULL,
4544 &setlist, &showlist);
4545
4547 _("Send a command to the remote monitor (remote targets only)."));
4548
4550 _("Print the name of each layer of the internal target stack."),
4552
4553 add_setshow_boolean_cmd ("target-async", no_class,
4554 _("\
4555Set whether gdb controls the inferior in asynchronous mode."), _("\
4556Show whether gdb controls the inferior in asynchronous mode."), _("\
4557Tells gdb whether to control the inferior in asynchronous mode."),
4563
4564 add_setshow_auto_boolean_cmd ("target-non-stop", no_class,
4565 _("\
4566Set whether gdb always controls the inferior in non-stop mode."), _("\
4567Show whether gdb always controls the inferior in non-stop mode."), _("\
4568Tells gdb whether to control the inferior in non-stop mode."),
4574
4575 add_setshow_boolean_cmd ("may-write-registers", class_support,
4577Set permission to write into registers."), _("\
4578Show permission to write into registers."), _("\
4579When this permission is on, GDB may write into the target's registers.\n\
4580Otherwise, any sort of write attempt will result in an error."),
4582 &setlist, &showlist);
4583
4584 add_setshow_boolean_cmd ("may-write-memory", class_support,
4585 &may_write_memory_1, _("\
4586Set permission to write into target memory."), _("\
4587Show permission to write into target memory."), _("\
4588When this permission is on, GDB may write into the target's memory.\n\
4589Otherwise, any sort of write attempt will result in an error."),
4591 &setlist, &showlist);
4592
4593 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
4595Set permission to insert breakpoints in the target."), _("\
4596Show permission to insert breakpoints in the target."), _("\
4597When this permission is on, GDB may insert breakpoints in the program.\n\
4598Otherwise, any sort of insertion attempt will result in an error."),
4600 &setlist, &showlist);
4601
4602 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
4604Set permission to insert tracepoints in the target."), _("\
4605Show permission to insert tracepoints in the target."), _("\
4606When this permission is on, GDB may insert tracepoints in the program.\n\
4607Otherwise, any sort of insertion attempt will result in an error."),
4609 &setlist, &showlist);
4610
4611 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
4613Set permission to insert fast tracepoints in the target."), _("\
4614Show permission to insert fast tracepoints in the target."), _("\
4615When this permission is on, GDB may insert fast tracepoints.\n\
4616Otherwise, any sort of insertion attempt will result in an error."),
4618 &setlist, &showlist);
4619
4620 add_setshow_boolean_cmd ("may-interrupt", class_support,
4621 &may_stop_1, _("\
4622Set permission to interrupt or signal the target."), _("\
4623Show permission to interrupt or signal the target."), _("\
4624When this permission is on, GDB may interrupt/stop the target's execution.\n\
4625Otherwise, any attempt to interrupt or stop will be ignored."),
4627 &setlist, &showlist);
4628
4629 add_com ("flash-erase", no_class, flash_erase_command,
4630 _("Erase all flash memory regions."));
4631
4632 add_setshow_boolean_cmd ("auto-connect-native-target", class_support,
4634Set whether GDB may automatically connect to the native target."), _("\
4635Show whether GDB may automatically connect to the native target."), _("\
4636When on, and GDB is not connected to a target yet, GDB\n\
4637attempts \"run\" and other commands with the native target."),
4639 &setlist, &showlist);
4640}
constexpr string_view get()
Definition 70483.cc:49
void * xmalloc(YYSIZE_T)
void xfree(void *)
void * xrealloc(void *ptr, size_t size)
Definition alloc.c:65
struct gdbarch * target_gdbarch(void)
void breakpoint_init_inferior(enum inf_context context)
int remove_breakpoints(void)
void breakpoint_xfer_memory(gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len)
void mark_breakpoints_out(void)
bptype
Definition breakpoint.h:84
@ inf_exited
remove_bp_reason
Definition breakpoint.h:64
target_ops * top_target()
Definition inferior.h:428
int pid
Definition inferior.h:561
void pop_all_targets_above(enum strata stratum)
Definition inferior.c:129
int unpush_target(struct target_ops *t)
Definition inferior.c:96
void push_target(struct target_ops *t)
Definition inferior.h:406
int highest_thread_num
Definition inferior.h:566
struct process_stratum_target * process_target()
Definition inferior.h:449
target_ops * find_target_beneath(const target_ops *t)
Definition inferior.h:424
bool attach_flag
Definition inferior.h:593
target_ops * target_at(enum strata stratum)
Definition inferior.h:453
void debug_print_register(const char *func, int regno)
Definition regcache.c:1401
scoped_target_fd(int fd) noexcept
Definition target.c:3451
DISABLE_COPY_AND_ASSIGN(scoped_target_fd)
int get() const noexcept
Definition target.c:3468
void push(target_ops *t)
Definition target.c:1197
bool unpush(target_ops *t)
Definition target.c:1226
target_ops * find_beneath(const target_ops *t) const
Definition target.c:3599
std::array< target_ops_ref,(int) debug_stratum+1 > m_stack
Definition target.h:1412
static void inferior()
Definition target.c:952
static void init()
Definition target.c:942
static void restore_inferior()
Definition target.c:990
static void ours_for_output()
Definition target.c:1088
static target_terminal_state m_terminal_state
Definition target.h:242
static bool is_inferior()
Definition target.h:183
static void info(const char *arg, int from_tty)
Definition target.c:1106
static void ours()
Definition target.c:1070
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * maintenanceprintlist
Definition cli-cmds.c:151
struct cmd_list_element * cmdlist
Definition cli-cmds.c:87
struct cmd_list_element * setlist
Definition cli-cmds.c:119
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:167
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * maintenance_show_cmdlist
Definition maint.c:752
struct cmd_list_element * maintenance_set_cmdlist
Definition maint.c:751
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition cli-decode.c:280
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
set_show_commands add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:752
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:391
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void completer_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition command.h:511
void dont_repeat()
Definition top.c:696
@ class_obscure
Definition command.h:64
@ class_maintenance
Definition command.h:65
@ class_support
Definition command.h:58
@ class_run
Definition command.h:54
@ no_class
Definition command.h:53
void reopen_exec_file(void)
Definition corefile.c:106
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
const char * get_exec_file(int err)
Definition corefile.c:150
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition corefile.c:186
void dcache_update(DCACHE *dcache, enum target_xfer_status status, CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len)
Definition dcache.c:529
enum target_xfer_status dcache_read_memory_partial(struct target_ops *ops, DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len, ULONGEST *xfered_len)
Definition dcache.c:473
int check_quit_flag(void)
Definition extension.c:857
void(* deprecated_detach_hook)(void)
Definition top.c:246
info_proc_what
Definition defs.h:380
auto_boolean
Definition defs.h:247
@ AUTO_BOOLEAN_TRUE
Definition defs.h:248
@ AUTO_BOOLEAN_AUTO
Definition defs.h:250
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition defs.h:350
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
#define QUIT
Definition defs.h:187
enum target_xfer_status section_table_xfer_memory_partial(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, const target_section_table &sections, gdb::function_view< bool(const struct target_section *)> match_cb)
Definition exec.c:819
void reinit_frame_cache(void)
Definition frame.c:2107
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
bool gdbarch_get_thread_local_address_p(struct gdbarch *gdbarch)
Definition gdbarch.c:2978
CORE_ADDR gdbarch_get_thread_local_address(struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset)
Definition gdbarch.c:2985
CORE_ADDR gdbarch_remove_non_address_bits(struct gdbarch *gdbarch, CORE_ADDR pointer)
Definition gdbarch.c:3169
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition gdbarch.c:4854
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition gdbarch.c:5300
bool gdbarch_fetch_tls_load_module_address_p(struct gdbarch *gdbarch)
Definition gdbarch.c:2954
CORE_ADDR gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, struct objfile *objfile)
Definition gdbarch.c:2961
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
@ THREAD_RUNNING
Definition gdbthread.h:75
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
Definition thread.c:908
void switch_to_no_thread()
Definition thread.c:1345
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1791
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
size_t size
Definition go32-nat.c:239
ptid_t inferior_ptid
Definition infcmd.c:74
void set_current_inferior(struct inferior *inf)
Definition inferior.c:61
int have_live_inferiors(void)
Definition inferior.c:462
struct inferior * current_inferior(void)
Definition inferior.c:55
void switch_to_inferior_no_thread(inferior *inf)
Definition inferior.c:712
void exit_inferior(struct inferior *inf)
Definition inferior.c:307
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:821
static bool detach_fork
Definition infrun.c:185
void infrun_async(int enable)
Definition infrun.c:121
bool non_stop
Definition infrun.c:226
void update_previous_thread()
Definition infrun.c:164
void prepare_for_detach(void)
Definition infrun.c:4059
void update_observer_mode(void)
Definition infrun.c:308
exec_direction_kind
Definition infrun.h:112
@ EXEC_FORWARD
Definition infrun.h:113
void clear_inline_frame_state(process_stratum_target *target, ptid_t filter_ptid)
struct ui_file * gdb_stdtarg
Definition main.c:80
struct mem_region * lookup_mem_region(CORE_ADDR addr)
Definition memattr.c:163
void invalidate_target_mem_regions(void)
Definition memattr.c:230
@ MEM_FLASH
Definition memattr.h:31
@ MEM_NONE
Definition memattr.h:25
@ MEM_WO
Definition memattr.h:28
@ MEM_RO
Definition memattr.h:27
observable< ptid_t > target_post_wait
observable< ptid_t > target_pre_wait
observable< struct inferior * > inferior_pre_detach
const char * alias
Definition nds32-tdep.c:114
static CORE_ADDR lm_addr(struct so_list *so)
Definition nto-tdep.c:246
@ OBJF_SHARED
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
static process_stratum_target * as_process_stratum_target(target_ops *target)
struct program_space * current_program_space
Definition progspace.c:40
record_method
Definition record.h:44
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:497
void registers_changed(void)
Definition regcache.c:580
void(* func)(remote_target *remote, char *)
#define disable()
Definition ser-go32.c:238
#define enable()
Definition ser-go32.c:239
void no_shared_libraries(const char *ignored, int from_tty)
Definition solib.c:1284
cmd_func_ftype * func
Definition cli-decode.h:175
completer_ftype * completer
Definition cli-decode.h:220
void * context() const
Definition cli-decode.h:109
void set_context(void *context)
Definition cli-decode.h:103
const target_info & info() const override
Definition target.c:3762
strata stratum() const override
Definition target.c:3750
strata stratum() const override
Definition target.c:3744
const target_info & info() const override
Definition target.c:3756
int target_fd
Definition target.c:3120
bool is_closed()
Definition target.c:3123
target_ops * target
Definition target.c:3117
Definition gnu-nat.c:153
pid_t pid
Definition gnu-nat.c:165
enum mem_access_mode mode
Definition memattr.h:65
int cache
Definition memattr.h:73
CORE_ADDR hi
Definition memattr.h:115
CORE_ADDR lo
Definition memattr.h:112
int number
Definition memattr.h:118
mem_attrib attrib
Definition memattr.h:125
struct bfd_section * the_bfd_section
Definition objfiles.h:398
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:830
objfile_flags flags
Definition objfiles.h:724
target_section_table & target_sections()
Definition progspace.h:307
struct objfile * symfile_object_file
Definition progspace.h:357
const char * shortname
Definition target.h:426
const char * doc
Definition target.h:433
static void decref(target_ops *t)
Definition target.c:1174
virtual LONGEST get_raw_trace_data(gdb_byte *buf, ULONGEST offset, LONGEST len) TARGET_DEFAULT_NORETURN(tcomplain())
virtual std::vector< mem_region > virtual memory_map() TARGET_DEFAULT_RETURN(std void flash_erase(ULONGEST address, LONGEST length) TARGET_DEFAULT_NORETURN(tcomplain())
virtual int fileio_close(int fd, fileio_error *target_errno)
Definition target.c:3235
virtual bool attach_no_wait() TARGET_DEFAULT_RETURN(0)
virtual int insert_mask_watchpoint(CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) TARGET_DEFAULT_RETURN(1)
virtual ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags options) TARGET_DEFAULT_FUNC(default_target_wait)
virtual gdb::optional< std::string > fileio_readlink(struct inferior *inf, const char *filename, fileio_error *target_errno)
Definition target.c:3250
virtual void insn_history(int size, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool have_steppable_watchpoint() TARGET_DEFAULT_RETURN(false)
virtual void goto_record(ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void set_trace_buffer_size(LONGEST val) TARGET_DEFAULT_IGNORE()
virtual void terminal_inferior() TARGET_DEFAULT_IGNORE()
virtual int core_of_thread(ptid_t ptid) TARGET_DEFAULT_RETURN(-1)
virtual struct address_space * thread_address_space(ptid_t) TARGET_DEFAULT_RETURN(NULL)
virtual void load(const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool can_async_p() TARGET_DEFAULT_RETURN(false)
virtual bool can_create_inferior()
Definition target.c:3064
virtual void goto_record_begin() TARGET_DEFAULT_NORETURN(tcomplain())
virtual int find_memory_regions(find_memory_region_ftype func, void *data) TARGET_DEFAULT_FUNC(dummy_find_memory_regions)
virtual void get_tracepoint_status(tracepoint *tp, struct uploaded_tp *utp) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void trace_init() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void prepare_to_generate_core() TARGET_DEFAULT_IGNORE()
virtual int remove_breakpoint(struct gdbarch *, struct bp_target_info *, enum remove_bp_reason) TARGET_DEFAULT_NORETURN(noprocess())
virtual int search_memory(CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp) TARGET_DEFAULT_FUNC(default_search_memory)
virtual bool static_tracepoint_marker_at(CORE_ADDR, static_tracepoint_marker *marker) TARGET_DEFAULT_RETURN(false)
virtual int remove_hw_breakpoint(struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
virtual void pass_signals(gdb::array_view< const unsigned char > TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
const char * longname() const
Definition target.h:459
virtual int fileio_pread(int fd, gdb_byte *read_buf, int len, ULONGEST offset, fileio_error *target_errno)
Definition target.c:3220
virtual std::string pid_to_str(ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
virtual void terminal_init() TARGET_DEFAULT_IGNORE()
virtual void fetch_registers(struct regcache *, int) TARGET_DEFAULT_IGNORE()
virtual bool supports_evaluation_of_breakpoint_conditions() TARGET_DEFAULT_RETURN(false)
virtual bool use_agent(bool use) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool stopped_by_sw_breakpoint() TARGET_DEFAULT_RETURN(false)
virtual void create_inferior(const char *, const std::string &, char **, int)
Definition target.c:3070
virtual bool can_download_tracepoint() TARGET_DEFAULT_RETURN(false)
virtual thread_control_capabilities get_thread_control_capabilities() TARGET_DEFAULT_RETURN(tc_none)
virtual void goto_bookmark(const gdb_byte *, int) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void detach(inferior *, int) TARGET_DEFAULT_IGNORE()
virtual void insn_history_from(ULONGEST from, int size, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual int fileio_unlink(struct inferior *inf, const char *filename, fileio_error *target_errno)
Definition target.c:3242
virtual void enable_tracepoint(struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void set_circular_trace_buffer(int val) TARGET_DEFAULT_IGNORE()
virtual thread_info * thread_handle_to_thread_info(const gdb_byte *, int, inferior *inf) TARGET_DEFAULT_RETURN(NULL)
virtual int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN(-1)
virtual void goto_record_end() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void trace_set_readonly_regions() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void terminal_ours_for_output() TARGET_DEFAULT_IGNORE()
virtual void record_stop_replaying() TARGET_DEFAULT_IGNORE()
virtual bool supports_multi_process() TARGET_DEFAULT_RETURN(false)
virtual int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN(-1)
virtual bool stopped_by_watchpoint() TARGET_DEFAULT_RETURN(false)
target_ops * beneath() const
Definition target.c:3041
virtual int can_do_single_step() TARGET_DEFAULT_RETURN(-1)
virtual bool get_trace_state_variable_value(int tsv, LONGEST *val) TARGET_DEFAULT_RETURN(false)
virtual void download_tracepoint(struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool can_attach()
Definition target.c:3052
virtual void kill() TARGET_DEFAULT_NORETURN(noprocess())
virtual bool can_execute_reverse() TARGET_DEFAULT_RETURN(false)
virtual int get_trace_status(struct trace_status *ts) TARGET_DEFAULT_RETURN(-1)
virtual int insert_hw_breakpoint(struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
virtual void set_disconnected_tracing(int val) TARGET_DEFAULT_IGNORE()
virtual void save_record(const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void program_signals(gdb::array_view< const unsigned char > TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
virtual void commit_resumed() TARGET_DEFAULT_IGNORE()
virtual enum exec_direction_kind execution_direction() TARGET_DEFAULT_FUNC(default_execution_direction)
virtual traceframe_info_up traceframe_info() TARGET_DEFAULT_NORETURN(tcomplain())
virtual int insert_fork_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual struct btrace_target_info * enable_btrace(thread_info *tp, const struct btrace_config *conf) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void store_registers(struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
virtual bool fetch_memtags(CORE_ADDR address, size_t len, gdb::byte_vector &tags, int type) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void terminal_ours() TARGET_DEFAULT_IGNORE()
virtual void trace_start() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void flash_done() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void done_generating_core() TARGET_DEFAULT_IGNORE()
virtual int save_trace_data(const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
virtual gdb_byte * get_bookmark(const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void follow_fork(inferior *, ptid_t, target_waitkind, bool, bool) TARGET_DEFAULT_FUNC(default_follow_fork)
virtual int can_use_hw_breakpoint(enum bptype, int, int) TARGET_DEFAULT_RETURN(0)
virtual enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
virtual gdb::array_view< const_gdb_byte > virtual thread_info_to_thread_handle(struct thread_info *) TARGET_DEFAULT_RETURN(gdb voi stop)(ptid_t) TARGET_DEFAULT_IGNORE()
Definition target.h:689
virtual ULONGEST get_memory_xfer_limit() TARGET_DEFAULT_RETURN(ULONGEST_MAX)
virtual bool record_is_replaying(ptid_t ptid) TARGET_DEFAULT_RETURN(false)
virtual enum record_method record_method(ptid_t ptid) TARGET_DEFAULT_RETURN(RECORD_METHOD_NONE)
virtual bool supports_stopped_by_sw_breakpoint() TARGET_DEFAULT_RETURN(false)
virtual bool stopped_by_hw_breakpoint() TARGET_DEFAULT_RETURN(false)
virtual gdb::unique_xmalloc_ptr< char > make_corefile_notes(bfd *, int *) TARGET_DEFAULT_FUNC(dummy_make_corefile_notes)
virtual bool can_run()
Definition target.c:3077
virtual bool supports_disable_randomization() TARGET_DEFAULT_FUNC(find_default_supports_disable_randomization)
virtual const char * extra_thread_info(thread_info *) TARGET_DEFAULT_RETURN(NULL)
virtual bool filesystem_is_local() TARGET_DEFAULT_RETURN(true)
virtual x86_xsave_layout fetch_x86_xsave_layout() TARGET_DEFAULT_RETURN(x86_xsave_layout())
virtual bool can_run_breakpoint_commands() TARGET_DEFAULT_RETURN(false)
virtual int fileio_fstat(int fd, struct stat *sb, fileio_error *target_errno)
Definition target.c:3228
virtual strata stratum() const =0
virtual int ranged_break_num_registers() TARGET_DEFAULT_RETURN(-1)
virtual int get_min_fast_tracepoint_insn_len() TARGET_DEFAULT_RETURN(-1)
virtual const struct frame_unwind * get_tailcall_unwinder() TARGET_DEFAULT_RETURN(NULL)
virtual ptid_t get_ada_task_ptid(long lwp, ULONGEST thread) TARGET_DEFAULT_FUNC(default_get_ada_task_ptid)
virtual int masked_watch_num_registers(CORE_ADDR, CORE_ADDR) TARGET_DEFAULT_RETURN(-1)
virtual void async(bool) TARGET_DEFAULT_NORETURN(tcomplain())
virtual std::vector< static_tracepoint_marker > static_tracepoint_markers_by_strid(const char *id) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void terminal_save_inferior() TARGET_DEFAULT_IGNORE()
const char * shortname() const
Definition target.h:456
virtual bool supports_dumpcore() TARGET_DEFAULT_RETURN(false)
virtual bool supports_stopped_by_hw_breakpoint() TARGET_DEFAULT_RETURN(false)
virtual void resume(ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
virtual bool is_async_p() TARGET_DEFAULT_RETURN(false)
virtual const char * pid_to_exec_file(int pid) TARGET_DEFAULT_RETURN(NULL)
virtual struct gdbarch * thread_architecture(ptid_t) TARGET_DEFAULT_RETURN(NULL)
virtual bool can_accel_watchpoint_condition(CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(false)
virtual void thread_events(int) TARGET_DEFAULT_IGNORE()
virtual int verify_memory(const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) TARGET_DEFAULT_FUNC(default_verify_memory)
virtual void insn_history_range(ULONGEST begin, ULONGEST end, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void log_command(const char *) TARGET_DEFAULT_IGNORE()
virtual void update_thread_list() TARGET_DEFAULT_IGNORE()
virtual const target_info & info() const =0
virtual int trace_find(enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) TARGET_DEFAULT_RETURN(-1)
virtual bool has_all_memory()
Definition target.h:705
virtual void delete_record() TARGET_DEFAULT_NORETURN(tcomplain())
virtual void teardown_btrace(struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void stop_recording() TARGET_DEFAULT_IGNORE()
virtual bool store_memtags(CORE_ADDR address, size_t len, const gdb::byte_vector &tags, int type) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void files_info() TARGET_DEFAULT_IGNORE()
virtual int upload_trace_state_variables(struct uploaded_tsv **utsvp) TARGET_DEFAULT_RETURN(0)
virtual void disable_tracepoint(struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
virtual const char * thread_name(thread_info *) TARGET_DEFAULT_RETURN(NULL)
virtual void disable_btrace(struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void pass_ctrlc() TARGET_DEFAULT_FUNC(default_target_pass_ctrlc)
virtual void prepare_to_store(struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
virtual void set_permissions() TARGET_DEFAULT_IGNORE()
virtual void interrupt() TARGET_DEFAULT_IGNORE()
virtual void trace_stop() TARGET_DEFAULT_NORETURN(tcomplain())
virtual int fileio_pwrite(int fd, const gdb_byte *write_buf, int len, ULONGEST offset, fileio_error *target_errno)
Definition target.c:3212
virtual void attach(const char *, int)
Definition target.c:3058
virtual bool can_use_agent() TARGET_DEFAULT_RETURN(false)
virtual void close()
Definition target.c:3047
virtual void call_history_from(ULONGEST begin, int size, record_print_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool augmented_libraries_svr4_read() TARGET_DEFAULT_RETURN(false)
virtual void mourn_inferior() TARGET_DEFAULT_FUNC(default_mourn_inferior)
virtual int insert_vfork_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual bool thread_alive(ptid_t ptid) TARGET_DEFAULT_RETURN(false)
virtual void download_trace_state_variable(const trace_state_variable &tsv) TARGET_DEFAULT_NORETURN(tcomplain())
virtual void disconnect(const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool set_trace_notes(const char *user, const char *notes, const char *stopnotes) TARGET_DEFAULT_RETURN(false)
virtual bool supports_enable_disable_tracepoint() TARGET_DEFAULT_RETURN(false)
virtual int insert_breakpoint(struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_NORETURN(noprocess())
virtual bool record_will_replay(ptid_t ptid, int dir) TARGET_DEFAULT_RETURN(false)
virtual int remove_fork_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual void dumpcore(const char *filename) TARGET_DEFAULT_IGNORE()
virtual const struct frame_unwind * get_unwinder() TARGET_DEFAULT_RETURN(NULL)
virtual enum btrace_error read_btrace(struct btrace_data *data, struct btrace_target_info *btinfo, enum btrace_read_type type) TARGET_DEFAULT_NORETURN(tcomplain())
virtual const struct target_desc * read_description() TARGET_DEFAULT_RETURN(NULL)
virtual void call_history_range(ULONGEST begin, ULONGEST end, record_print_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual bool supports_memory_tagging() TARGET_DEFAULT_RETURN(false)
virtual int region_ok_for_hw_watchpoint(CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_region_ok_for_hw_watchpoint)
virtual int upload_tracepoints(struct uploaded_tp **utpp) TARGET_DEFAULT_RETURN(0)
virtual int remove_mask_watchpoint(CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) TARGET_DEFAULT_RETURN(1)
virtual bool always_non_stop_p() TARGET_DEFAULT_RETURN(false)
virtual bool supports_delete_record() TARGET_DEFAULT_RETURN(false)
virtual int remove_vfork_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual const target_section_table * get_section_table() TARGET_DEFAULT_RETURN(default_get_section_table())
virtual void follow_exec(inferior *, ptid_t, const char *) TARGET_DEFAULT_IGNORE()
virtual bool supports_string_tracing() TARGET_DEFAULT_RETURN(false)
virtual void call_history(int size, record_print_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
virtual int set_syscall_catchpoint(int, bool, int, gdb::array_view< const int >) TARGET_DEFAULT_RETURN(1)
virtual bool has_pending_events() TARGET_DEFAULT_RETURN(false)
virtual void rcmd(const char *command, struct ui_file *output) TARGET_DEFAULT_FUNC(default_rcmd)
virtual void post_attach(int) TARGET_DEFAULT_IGNORE()
virtual bool info_proc(const char *, enum info_proc_what)
Definition target.c:2946
virtual bool get_tib_address(ptid_t ptid, CORE_ADDR *addr) TARGET_DEFAULT_NORETURN(tcomplain())
virtual int fileio_open(struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, fileio_error *target_errno)
Definition target.c:3203
virtual int insert_exec_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual void terminal_info(const char *, int) TARGET_DEFAULT_FUNC(default_terminal_info)
virtual int remove_exec_catchpoint(int) TARGET_DEFAULT_RETURN(1)
virtual const struct btrace_config * btrace_conf(const struct btrace_target_info *) TARGET_DEFAULT_RETURN(NULL)
virtual CORE_ADDR get_thread_local_address(ptid_t ptid, CORE_ADDR load_module_addr, CORE_ADDR offset) TARGET_DEFAULT_NORETURN(generic_tls_error())
struct bfd_section * the_bfd_section
void operator()(struct target_ops *ops) const
Definition target.c:1263
Definition ui.h:55
enum prompt_state prompt_state
Definition ui.h:136
Definition value.h:130
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition symfile.c:3174
bool pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3055
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3126
enum overlay_debugging_state overlay_debugging
Definition symfile.c:2975
void connection_list_remove(process_stratum_target *t)
void connection_list_add(process_stratum_target *t)
int target_dcache_init_p(void)
void target_dcache_invalidate(void)
DCACHE * target_dcache_get(void)
DCACHE * target_dcache_get_or_init(void)
int stack_cache_enabled_p(void)
int code_cache_enabled_p(void)
void target_clear_description(void)
std::vector< target_section > target_section_table
target_terminal_state
Definition target.h:134
std::vector< static_tracepoint_marker > target_static_tracepoint_markers_by_strid(const char *marker_id)
Definition target.c:783
void target_announce_detach(int from_tty)
Definition target.c:3622
static char targ_desc[]
Definition target.c:4261
struct target_ops * find_run_target(void)
Definition target.c:2930
LONGEST target_get_raw_trace_data(gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition target.c:719
int target_fileio_fstat(int fd, struct stat *sb, fileio_error *target_errno)
Definition target.c:3346
int target_get_min_fast_tracepoint_insn_len()
Definition target.c:727
void target_require_runnable(void)
Definition target.c:2822
void target_goto_record(ULONGEST insn)
Definition target.c:4172
bool target_get_trace_state_variable_value(int tsv, LONGEST *val)
Definition target.c:691
static void show_maint_target_async(ui_file *file, int from_tty, cmd_list_element *c, const char *value)
Definition target.c:4374
static void tcomplain(void)
Definition target.c:1129
void target_post_attach(int pid)
Definition target.c:232
bool target_have_steppable_watchpoint()
Definition target.c:508
static bool get_maint_target_async()
Definition target.c:4368
struct address_space * target_thread_address_space(ptid_t ptid)
Definition target.c:3028
gdb_byte * target_get_bookmark(const char *args, int from_tty)
Definition target.c:456
bool target_is_async_p()
Definition target.c:402
void fileio_handles_invalidate_target(target_ops *targ)
Definition target.c:3144
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, target_wait_flags options)
Definition target.c:2586
void get_target_memory(struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf, LONGEST len)
Definition target.c:2350
static ptid_t default_get_ada_task_ptid(struct target_ops *self, long lwp, ULONGEST tid)
Definition target.c:1154
static std::string default_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition target.c:3699
bool target_filesystem_is_local()
Definition target.c:608
bool target_supports_dumpcore()
Definition target.c:274
void target_set_circular_trace_buffer(int val)
Definition target.c:741
static int lowest_closed_fd
Definition target.c:3139
int target_insert_hw_breakpoint(gdbarch *gdbarch, bp_target_info *bp_tgt)
Definition target.c:565
void target_goto_bookmark(const gdb_byte *arg, int from_tty)
Definition target.c:462
void target_set_disconnected_tracing(int val)
Definition target.c:735
static void show_trust_readonly(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition target.c:1934
static void str_comma_list_concat_elem(std::string *list, const char *elem)
Definition target.c:3886
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1844
struct target_ops * find_attach_target(void)
Definition target.c:2912
int target_region_ok_for_hw_watchpoint(CORE_ADDR addr, int len)
Definition target.c:526
void default_target_pass_ctrlc(struct target_ops *ops)
Definition target.c:3846
enum record_method target_record_method(ptid_t ptid)
Definition target.c:4124
void target_call_history_from(ULONGEST begin, int size, record_print_flags flags)
Definition target.c:4214
static struct target_ops * default_fileio_target(void)
Definition target.c:3099
int target_upload_trace_state_variables(uploaded_tsv **utsvp)
Definition target.c:711
static const target_info dummy_target_info
Definition target.c:3737
int target_supports_delete_record()
Definition target.c:4108
void target_pre_inferior(int from_tty)
Definition target.c:2449
bool target_store_memtags(CORE_ADDR address, size_t len, const gdb::byte_vector &tags, int type)
Definition target.c:828
static bool may_write_registers_1
Definition target.c:4463
static void show_targetdebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition target.c:158
static struct target_ops * find_default_run_target(const char *do_mesg)
Definition target.c:2899
ptid_t target_get_ada_task_ptid(long lwp, ULONGEST tid)
Definition target.c:602
void target_insn_history_range(ULONGEST begin, ULONGEST end, gdb_disassembly_flags flags)
Definition target.c:4197
static bool auto_connect_native_target
Definition target.c:2854
bool target_has_pending_events()
Definition target.c:2692
int target_has_stack()
Definition target.c:177
int target_remove_exec_catchpoint(int pid)
Definition target.c:346
void target_log_command(const char *p)
Definition target.c:841
static void maintenance_print_target_stack(const char *cmd, int from_tty)
Definition target.c:4320
exec_direction_kind target_execution_direction()
Definition target.c:410
int target_fileio_pwrite(int fd, const gdb_byte *write_buf, int len, ULONGEST offset, fileio_error *target_errno)
Definition target.c:3294
target_ops * get_native_target()
Definition target.c:2886
int target_can_do_single_step()
Definition target.c:535
const struct target_desc * target_read_description(struct target_ops *target)
Definition target.c:2773
void target_insn_history(int size, gdb_disassembly_flags flags)
Definition target.c:4180
int target_trace_find(trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
Definition target.c:682
static void target_terminal_is_ours_kind(target_terminal_state desired_state)
Definition target.c:1028
void target_async(bool enable)
Definition target.c:4337
gdb::unique_xmalloc_ptr< char > target_fileio_read_stralloc(struct inferior *inf, const char *filename)
Definition target.c:3550
void target_stop_recording(void)
Definition target.c:4092
const struct frame_unwind * target_get_tailcall_unwinder(void)
Definition target.c:4238
int target_remove_hw_breakpoint(gdbarch *gdbarch, bp_target_info *bp_tgt)
Definition target.c:575
bool target_supports_stopped_by_hw_breakpoint()
Definition target.c:498
void target_goto_record_end(void)
Definition target.c:4164
bool target_can_run_breakpoint_commands()
Definition target.c:290
int target_remove_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, enum target_hw_bp_type rw)
Definition target.c:4017
bool target_supports_memory_tagging()
Definition target.c:815
bool target_supports_terminal_ours(void)
Definition target.c:1114
void target_trace_start()
Definition target.c:652
bool target_can_execute_reverse()
Definition target.c:596
void target_enable_tracepoint(bp_location *loc)
Definition target.c:640
void target_done_generating_core(void)
Definition target.c:4254
void target_call_history(int size, record_print_flags flags)
Definition target.c:4206
void _initialize_target()
Definition target.c:4519
gdb::optional< gdb::char_vector > target_get_osdata(const char *type)
Definition target.c:3008
gdb::optional< gdb::def_vector< T > > target_read_alloc_1(struct target_ops *ops, enum target_object object, const char *annex)
Definition target.c:2263
int target_record_is_replaying(ptid_t ptid)
Definition target.c:4132
int target_fileio_open(struct inferior *inf, const char *filename, int flags, int mode, bool warn_if_slow, fileio_error *target_errno)
Definition target.c:3260
int target_insert_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition target.c:2376
void target_trace_init()
Definition target.c:614
void target_insn_history_from(ULONGEST from, int size, gdb_disassembly_flags flags)
Definition target.c:4188
gdb::optional< gdb::char_vector > target_read_stralloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition target.c:2321
int target_remove_fork_catchpoint(int pid)
Definition target.c:314
static bool may_stop_1
Definition target.c:4468
scoped_restore_tmpl< int > make_scoped_restore_show_memory_breakpoints(int show)
Definition target.c:1667
enum auto_boolean target_non_stop_enabled
Definition target.c:4425
static bool may_insert_fast_tracepoints_1
Definition target.c:4467
static void set_target_permissions(const char *args, int from_tty, struct cmd_list_element *c)
Definition target.c:4487
void target_interrupt()
Definition target.c:3798
const char * target_pid_to_exec_file(int pid)
Definition target.c:426
void flash_erase_command(const char *cmd, int from_tty)
Definition target.c:4283
bool target_async_permitted
Definition target.c:4356
const struct target_section * target_section_by_addr(struct target_ops *target, CORE_ADDR addr)
Definition target.c:1393
void target_detach(inferior *inf, int from_tty)
Definition target.c:2531
bool target_can_download_tracepoint()
Definition target.c:626
int target_insert_watchpoint(CORE_ADDR addr, int len, target_hw_bp_type type, expression *cond)
Definition target.c:543
int simple_verify_memory(struct target_ops *ops, const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
Definition target.c:3955
void noprocess(void)
Definition target.c:1136
static dummy_target the_dummy_target
Definition target.c:3727
static bool may_insert_breakpoints_1
Definition target.c:4465
void target_fetch_registers(struct regcache *regcache, int regno)
Definition target.c:3928
std::vector< memory_read_result > read_memory_robust(struct target_ops *ops, const ULONGEST offset, const LONGEST len)
Definition target.c:2139
static void do_monitor_command(const char *cmd, int from_tty)
Definition target.c:4274
static void release_fileio_fd(int fd, fileio_fh_t *fh)
Definition target.c:3182
int target_fileio_close(int fd, fileio_error *target_errno)
Definition target.c:3368
void target_continue(ptid_t ptid, enum gdb_signal signal)
Definition target.c:3878
bool target_can_async_p()
Definition target.c:384
bool target_static_tracepoint_marker_at(CORE_ADDR addr, static_tracepoint_marker *marker)
Definition target.c:774
void target_kill(void)
Definition target.c:913
void target_disable_btrace(struct btrace_target_info *btinfo)
Definition target.c:4056
bool target_can_use_agent()
Definition target.c:803
void target_pass_signals(gdb::array_view< const unsigned char > pass_signals)
Definition target.c:2698
int target_fileio_pread(int fd, gdb_byte *read_buf, int len, ULONGEST offset, fileio_error *target_errno)
Definition target.c:3320
static void default_follow_fork(struct target_ops *self, inferior *child_inf, ptid_t child_ptid, target_waitkind fork_kind, bool follow_child, bool detach_fork)
Definition target.c:2710
enum target_xfer_status raw_memory_xfer_partial(struct target_ops *ops, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len, ULONGEST *xfered_len)
Definition target.c:1473
const char * target_xfer_status_to_string(enum target_xfer_status status)
Definition target.c:1370
bool target_can_lock_scheduler()
Definition target.c:374
gdb::unique_xmalloc_ptr< char > target_make_corefile_notes(bfd *bfd, int *size_p)
Definition target.c:450
static target_ops * the_native_target
Definition target.c:2869
int target_can_run()
Definition target.c:3083
gdbarch * target_thread_architecture(ptid_t ptid)
Definition target.c:434
traceframe_info_up target_traceframe_info()
Definition target.c:791
x86_xsave_layout target_fetch_x86_xsave_layout()
Definition target.c:835
LONGEST target_fileio_read_alloc(struct inferior *inf, const char *filename, gdb_byte **buf_p)
Definition target.c:3541
static std::vector< fileio_fh_t > fileio_fhandles
Definition target.c:3134
int target_read_stack(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1830
static int default_watchpoint_addr_within_range(struct target_ops *target, CORE_ADDR addr, CORE_ADDR start, int length)
Definition target.c:3589
int target_core_of_thread(ptid_t ptid)
Definition target.c:3949
void target_update_thread_list(void)
Definition target.c:3776
#define CASE(X)
void target_prepare_to_store(regcache *regcache)
Definition target.c:240
void target_program_signals(gdb::array_view< const unsigned char > program_signals)
Definition target.c:2704
void target_record_stop_replaying(void)
Definition target.c:4148
int target_upload_tracepoints(uploaded_tp **utpp)
Definition target.c:705
void add_deprecated_target_alias(const target_info &tinfo, const char *alias)
Definition target.c:896
bool target_stopped_by_hw_breakpoint()
Definition target.c:492
int target_can_use_hardware_watchpoint(bptype type, int cnt, int othertype)
Definition target.c:516
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1861
void target_dumpcore(const char *filename)
Definition target.c:282
bool target_use_agent(bool use)
Definition target.c:797
void target_follow_fork(inferior *child_inf, ptid_t child_ptid, target_waitkind fork_kind, bool follow_child, bool detach_fork)
Definition target.c:2721
void target_call_history_range(ULONGEST begin, ULONGEST end, record_print_flags flags)
Definition target.c:4222
static void default_mourn_inferior(struct target_ops *self)
Definition target.c:2752
void target_commit_resumed()
Definition target.c:2683
static int dummy_find_memory_regions(struct target_ops *self, find_memory_region_ftype ignore1, void *ignore2)
Definition target.c:3706
static LONGEST target_fileio_read_alloc_1(struct inferior *inf, const char *filename, gdb_byte **buf_p, int padding)
Definition target.c:3486
bool target_has_execution(inferior *inf)
Definition target.c:201
static void do_option(target_wait_flags *target_options, std::string *ret, target_wait_flag opt, const char *opt_str)
Definition target.c:3899
target_ops * get_dummy_target()
Definition target.c:3732
void target_disable_tracepoint(bp_location *loc)
Definition target.c:646
void target_trace_set_readonly_regions()
Definition target.c:658
void target_download_tracepoint(bp_location *location)
Definition target.c:620
int target_insert_exec_catchpoint(int pid)
Definition target.c:338
void target_download_trace_state_variable(const trace_state_variable &tsv)
Definition target.c:632
int target_record_will_replay(ptid_t ptid, int dir)
Definition target.c:4140
bool target_supports_stopped_by_sw_breakpoint()
Definition target.c:484
int target_get_trace_status(trace_status *ts)
Definition target.c:664
void target_trace_stop()
Definition target.c:676
int target_read_raw_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1816
const target_section_table * target_get_section_table(struct target_ops *target)
Definition target.c:1385
int target_insert_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, enum target_hw_bp_type rw)
Definition target.c:4005
int target_insert_fork_catchpoint(int pid)
Definition target.c:306
ptid_t default_target_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, target_wait_flags options)
Definition target.c:2614
void target_save_record(const char *filename)
Definition target.c:4100
static void read_whatever_is_readable(struct target_ops *ops, const ULONGEST begin, const ULONGEST end, int unit_size, std::vector< memory_read_result > *result)
Definition target.c:2033
void target_flash_erase(ULONGEST address, LONGEST length)
Definition target.c:1922
#define DO_TARG_OPTION(OPT)
int target_masked_watch_num_registers(CORE_ADDR addr, CORE_ADDR mask)
Definition target.c:4029
int target_read_uint32(CORE_ADDR memaddr, uint32_t *result)
Definition target.c:1798
static int find_default_supports_disable_randomization(struct target_ops *self)
Definition target.c:2981
struct thread_info * target_thread_handle_to_thread_info(const gdb_byte *thread_handle, int handle_len, struct inferior *inf)
Definition target.c:2637
static enum target_xfer_status memory_xfer_partial(struct target_ops *ops, enum target_object object, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition target.c:1624
static void show_maint_target_non_stop(ui_file *file, int from_tty, cmd_list_element *c, const char *value)
Definition target.c:4447
int target_supports_multi_process(void)
Definition target.c:3000
void target_disconnect(const char *args, int from_tty)
Definition target.c:2573
void generic_mourn_inferior(void)
Definition target.c:3661
int target_has_registers()
Definition target.c:189
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
Definition target.c:868
gdb::optional< gdb::byte_vector > target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition target.c:2312
void target_prepare_to_generate_core(void)
Definition target.c:4246
bool target_attach_no_wait()
Definition target.c:224
void set_native_target(target_ops *target)
Definition target.c:2874
struct btrace_target_info * target_enable_btrace(thread_info *tp, const struct btrace_config *conf)
Definition target.c:4048
int target_has_memory()
Definition target.c:165
static void generic_tls_error(void)
Definition target.c:58
void target_thread_events(int enable)
Definition target.c:4349
static void info_target_command(const char *args, int from_tty)
Definition target.c:2413
void target_stop(ptid_t ptid)
Definition target.c:3782
const char * target_thread_name(struct thread_info *info)
Definition target.c:2629
void target_announce_attach(int from_tty, int pid)
Definition target.c:3643
void target_teardown_btrace(struct btrace_target_info *btinfo)
Definition target.c:4064
std::string target_options_to_string(target_wait_flags target_options)
Definition target.c:3912
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition target.c:1970
bool target_supports_string_tracing()
Definition target.c:256
const struct frame_unwind * target_get_unwinder(void)
Definition target.c:4230
static enum target_xfer_status memory_xfer_partial_1(struct target_ops *ops, enum target_object object, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition target.c:1527
const char * target_extra_thread_info(thread_info *tp)
Definition target.c:418
void target_set_permissions()
Definition target.c:768
bool target_is_non_stop_p()
Definition target.c:4394
static void set_maint_target_non_stop(auto_boolean enabled)
Definition target.c:4430
bool exists_non_stop_target()
Definition target.c:4406
void target_flash_done(void)
Definition target.c:1928
static void show_auto_connect_native_target(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition target.c:2857
void target_set_trace_buffer_size(LONGEST val)
Definition target.c:747
bool target_fetch_memtags(CORE_ADDR address, size_t len, gdb::byte_vector &tags, int type)
Definition target.c:821
int target_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt, enum remove_bp_reason reason)
Definition target.c:2393
static enum target_xfer_status target_read_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition target.c:1945
static gdb::unique_xmalloc_ptr< char > dummy_make_corefile_notes(struct target_ops *self, bfd *ignore1, int *ignore2)
Definition target.c:3715
static int default_search_memory(struct target_ops *self, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition target.c:2782
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2623
int target_info_proc(const char *args, enum info_proc_what what)
Definition target.c:2954
bool target_can_accel_watchpoint_condition(CORE_ADDR addr, int len, int type, expression *cond)
Definition target.c:585
void target_resume(ptid_t scope_ptid, int step, enum gdb_signal signal)
Definition target.c:2657
LONGEST target_write_with_progress(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len, void(*progress)(ULONGEST, void *), void *baton)
Definition target.c:2203
gdb::array_view< const gdb_byte > target_thread_info_to_thread_handle(struct thread_info *tip)
Definition target.c:2649
static int acquire_fileio_fd(target_ops *target, int target_fd)
Definition target.c:3154
std::string normal_pid_to_str(ptid_t ptid)
Definition target.c:3693
struct target_ops * find_target_at(enum strata stratum)
Definition target.c:3612
bool target_get_tib_address(ptid_t ptid, CORE_ADDR *addr)
Definition target.c:762
static void set_maint_target_async(bool permitted)
Definition target.c:4359
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
int target_ranged_break_num_registers(void)
Definition target.c:4040
int target_fileio_unlink(struct inferior *inf, const char *filename, fileio_error *target_errno)
Definition target.c:3395
bool target_stopped_by_watchpoint()
Definition target.c:470
static void open_target(const char *args, int from_tty, struct cmd_list_element *command)
Definition target.c:849
void target_continue_no_signal(ptid_t ptid)
Definition target.c:3870
void target_stop_and_wait(ptid_t ptid)
Definition target.c:3854
std::vector< mem_region > target_memory_map(void)
Definition target.c:1891
static auto_boolean get_maint_target_non_stop()
Definition target.c:4441
static fileio_fh_t * fileio_fd_to_fh(int fd)
Definition target.c:3191
void target_preopen(int from_tty)
Definition target.c:2495
static bool may_write_memory_1
Definition target.c:4464
void target_files_info()
Definition target.c:298
void target_get_tracepoint_status(tracepoint *tp, uploaded_tp *utp)
Definition target.c:670
const target_section_table * default_get_section_table()
Definition target.c:1411
int target_search_memory(CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition target.c:2807
void target_goto_record_begin(void)
Definition target.c:4156
gdb::optional< std::string > target_fileio_readlink(struct inferior *inf, const char *filename, fileio_error *target_errno)
Definition target.c:3421
void target_rcmd(const char *command, struct ui_file *outbuf)
Definition target.c:366
enum btrace_error target_read_btrace(struct btrace_data *btrace, struct btrace_target_info *btinfo, enum btrace_read_type type)
Definition target.c:4072
int target_insert_vfork_catchpoint(int pid)
Definition target.c:322
int target_write_raw_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1878
static bool may_insert_tracepoints_1
Definition target.c:4466
LONGEST target_write(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition target.c:2249
const struct btrace_config * target_btrace_conf(const struct btrace_target_info *btinfo)
Definition target.c:4084
ULONGEST get_target_memory_unsigned(struct target_ops *ops, CORE_ADDR addr, int len, enum bfd_endian byte_order)
Definition target.c:2363
bool target_stopped_by_sw_breakpoint()
Definition target.c:478
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
Definition target.c:1280
static enum target_xfer_status target_write_partial(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
Definition target.c:1956
static enum exec_direction_kind default_execution_direction(struct target_ops *self)
Definition target.c:1160
void target_load(const char *arg, int from_tty)
Definition target.c:928
bool target_supports_evaluation_of_breakpoint_conditions()
Definition target.c:264
static void default_terminal_info(struct target_ops *self, const char *args, int from_tty)
Definition target.c:1142
static int default_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
Definition target.c:3582
bool target_supports_enable_disable_tracepoint()
Definition target.c:248
bool target_augmented_libraries_svr4_read()
Definition target.c:809
void target_delete_record(void)
Definition target.c:4116
int target_remove_vfork_catchpoint(int pid)
Definition target.c:330
void target_pass_ctrlc(void)
Definition target.c:3812
const char * target_shortname()
Definition target.c:216
void target_follow_exec(inferior *follow_inf, ptid_t ptid, const char *execd_pathname)
Definition target.c:2744
bool target_set_trace_notes(const char *user, const char *notes, const char *stopnotes)
Definition target.c:753
int target_find_memory_regions(find_memory_region_ftype func, void *data)
Definition target.c:442
void target_mourn_inferior(ptid_t ptid)
Definition target.c:2758
static int default_verify_memory(struct target_ops *self, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition target.c:3985
int target_remove_watchpoint(CORE_ADDR addr, int len, target_hw_bp_type type, expression *cond)
Definition target.c:554
int target_thread_alive(ptid_t ptid)
Definition target.c:3770
int target_supports_disable_randomization(void)
Definition target.c:2992
static int target_always_non_stop_p(void)
Definition target.c:4386
static int memory_xfer_check_region(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len, struct mem_region **region_p)
Definition target.c:1426
int target_set_syscall_catchpoint(int pid, bool needed, int any_count, gdb::array_view< const int > syscall_counts)
Definition target.c:354
int target_save_trace_data(const char *filename)
Definition target.c:699
static void default_rcmd(struct target_ops *self, const char *command, struct ui_file *output)
Definition target.c:4267
static void set_write_memory_registers_permission(const char *args, int from_tty, struct cmd_list_element *c)
Definition target.c:4507
void update_target_permissions(void)
Definition target.c:4473
int target_verify_memory(const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition target.c:3994
void target_store_registers(struct regcache *regcache, int regno)
Definition target.c:3936
target_xfer_partial_ftype target_xfer_partial
bool may_insert_fast_tracepoints
void fileio_handles_invalidate_target(target_ops *targ)
Definition target.c:3144
target_xfer_status
Definition target.h:219
@ TARGET_XFER_E_IO
Definition target.h:232
@ TARGET_XFER_EOF
Definition target.h:224
@ TARGET_XFER_OK
Definition target.h:221
@ TARGET_XFER_UNAVAILABLE
Definition target.h:227
bool trust_readonly
void target_open_ftype(const char *args, int from_tty)
Definition target.h:2362
bool may_write_registers
target_object
Definition target.h:143
@ TARGET_OBJECT_RAW_MEMORY
Definition target.h:151
@ TARGET_OBJECT_STACK_MEMORY
Definition target.h:155
@ TARGET_OBJECT_OSDATA
Definition target.h:184
@ TARGET_OBJECT_MEMORY
Definition target.h:147
@ TARGET_OBJECT_CODE_MEMORY
Definition target.h:158
bool may_insert_tracepoints
strata
Definition target.h:94
@ file_stratum
Definition target.h:96
@ process_stratum
Definition target.h:97
@ debug_stratum
Definition target.h:101
@ dummy_stratum
Definition target.h:95
@ tc_schedlock
Definition target.h:107
bool may_insert_breakpoints
bool may_write_memory
bool may_stop
int get_traceframe_number(void)
std::unique_ptr< traceframe_info > traceframe_info_up
Definition tracepoint.h:40
trace_find_type
Definition tracepoint.h:406
#define current_uiout
Definition ui-out.h:40
struct ui * main_ui
Definition ui.c:34
struct ui * current_ui
Definition ui.c:35
@ PROMPT_BLOCKED
Definition ui.h:35
int query(const char *ctlstr,...)
Definition utils.c:943
void gdb_putc(int c)
Definition utils.c:1862
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
#define gdb_stdlog
Definition utils.h:190
target_wait_flag
Definition wait.h:28
@ TARGET_WNOHANG
Definition wait.h:32
target_waitkind
Definition waitstatus.h:30