[deliverable/binutils-gdb.git] / gdb / obsd-tdep.c

/* Target-dependent code for OpenBSD.

   Copyright (C) 2005-2020 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "frame.h"
#include "symtab.h"
#include "objfiles.h"

#include "obsd-tdep.h"

CORE_ADDR
obsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
{
  struct bound_minimal_symbol msym;

  msym = lookup_minimal_symbol("_dl_bind", NULL, NULL);
  if (msym.minsym && BMSYMBOL_VALUE_ADDRESS (msym) == pc)
    return frame_unwind_caller_pc (get_current_frame ());
  else
    return find_solib_trampoline_target (get_current_frame (), pc);
}

/* OpenBSD signal numbers.  From <sys/signal.h>. */

enum
  {
    OBSD_SIGHUP = 1,
    OBSD_SIGINT = 2,
    OBSD_SIGQUIT = 3,
    OBSD_SIGILL = 4,
    OBSD_SIGTRAP = 5,
    OBSD_SIGABRT = 6,
    OBSD_SIGEMT = 7,
    OBSD_SIGFPE = 8,
    OBSD_SIGKILL = 9,
    OBSD_SIGBUS = 10,
    OBSD_SIGSEGV = 11,
    OBSD_SIGSYS = 12,
    OBSD_SIGPIPE = 13,
    OBSD_SIGALRM = 14,
    OBSD_SIGTERM = 15,
    OBSD_SIGURG = 16,
    OBSD_SIGSTOP = 17,
    OBSD_SIGTSTP = 18,
    OBSD_SIGCONT = 19,
    OBSD_SIGCHLD = 20,
    OBSD_SIGTTIN = 21,
    OBSD_SIGTTOU = 22,
    OBSD_SIGIO = 23,
    OBSD_SIGXCPU = 24,
    OBSD_SIGXFSZ = 25,
    OBSD_SIGVTALRM = 26,
    OBSD_SIGPROF = 27,
    OBSD_SIGWINCH = 28,
    OBSD_SIGINFO = 29,
    OBSD_SIGUSR1 = 30,
    OBSD_SIGUSR2 = 31,
    OBSD_SIGTHR = 32,
  };

/* Implement the "gdb_signal_from_target" gdbarch method.  */

static enum gdb_signal
obsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
{
  switch (signal)
    {
    case 0:
      return GDB_SIGNAL_0;

    case OBSD_SIGHUP:
      return GDB_SIGNAL_HUP;

    case OBSD_SIGINT:
      return GDB_SIGNAL_INT;

    case OBSD_SIGQUIT:
      return GDB_SIGNAL_QUIT;

    case OBSD_SIGILL:
      return GDB_SIGNAL_ILL;

    case OBSD_SIGTRAP:
      return GDB_SIGNAL_TRAP;

    case OBSD_SIGABRT:
      return GDB_SIGNAL_ABRT;

    case OBSD_SIGEMT:
      return GDB_SIGNAL_EMT;

    case OBSD_SIGFPE:
      return GDB_SIGNAL_FPE;

    case OBSD_SIGKILL:
      return GDB_SIGNAL_KILL;

    case OBSD_SIGBUS:
      return GDB_SIGNAL_BUS;

    case OBSD_SIGSEGV:
      return GDB_SIGNAL_SEGV;

    case OBSD_SIGSYS:
      return GDB_SIGNAL_SYS;

    case OBSD_SIGPIPE:
      return GDB_SIGNAL_PIPE;

    case OBSD_SIGALRM:
      return GDB_SIGNAL_ALRM;

    case OBSD_SIGTERM:
      return GDB_SIGNAL_TERM;

    case OBSD_SIGURG:
      return GDB_SIGNAL_URG;

    case OBSD_SIGSTOP:
      return GDB_SIGNAL_STOP;

    case OBSD_SIGTSTP:
      return GDB_SIGNAL_TSTP;

    case OBSD_SIGCONT:
      return GDB_SIGNAL_CONT;

    case OBSD_SIGCHLD:
      return GDB_SIGNAL_CHLD;

    case OBSD_SIGTTIN:
      return GDB_SIGNAL_TTIN;

    case OBSD_SIGTTOU:
      return GDB_SIGNAL_TTOU;

    case OBSD_SIGIO:
      return GDB_SIGNAL_IO;

    case OBSD_SIGXCPU:
      return GDB_SIGNAL_XCPU;

    case OBSD_SIGXFSZ:
      return GDB_SIGNAL_XFSZ;

    case OBSD_SIGVTALRM:
      return GDB_SIGNAL_VTALRM;

    case OBSD_SIGPROF:
      return GDB_SIGNAL_PROF;

    case OBSD_SIGWINCH:
      return GDB_SIGNAL_WINCH;

    case OBSD_SIGINFO:
      return GDB_SIGNAL_INFO;

    case OBSD_SIGUSR1:
      return GDB_SIGNAL_USR1;

    case OBSD_SIGUSR2:
      return GDB_SIGNAL_USR2;
    }

  return GDB_SIGNAL_UNKNOWN;
}

/* Implement the "gdb_signal_to_target" gdbarch method.  */

static int
obsd_gdb_signal_to_target (struct gdbarch *gdbarch,
			   enum gdb_signal signal)
{
  switch (signal)
    {
    case GDB_SIGNAL_0:
      return 0;

    case GDB_SIGNAL_HUP:
      return OBSD_SIGHUP;

    case GDB_SIGNAL_INT:
      return OBSD_SIGINT;

    case GDB_SIGNAL_QUIT:
      return OBSD_SIGQUIT;

    case GDB_SIGNAL_ILL:
      return OBSD_SIGILL;

    case GDB_SIGNAL_TRAP:
      return OBSD_SIGTRAP;

    case GDB_SIGNAL_ABRT:
      return OBSD_SIGABRT;

    case GDB_SIGNAL_EMT:
      return OBSD_SIGEMT;

    case GDB_SIGNAL_FPE:
      return OBSD_SIGFPE;

    case GDB_SIGNAL_KILL:
      return OBSD_SIGKILL;

    case GDB_SIGNAL_BUS:
      return OBSD_SIGBUS;

    case GDB_SIGNAL_SEGV:
      return OBSD_SIGSEGV;

    case GDB_SIGNAL_SYS:
      return OBSD_SIGSYS;

    case GDB_SIGNAL_PIPE:
      return OBSD_SIGPIPE;

    case GDB_SIGNAL_ALRM:
      return OBSD_SIGALRM;

    case GDB_SIGNAL_TERM:
      return OBSD_SIGTERM;

    case GDB_SIGNAL_URG:
      return OBSD_SIGURG;

    case GDB_SIGNAL_STOP:
      return OBSD_SIGSTOP;

    case GDB_SIGNAL_TSTP:
      return OBSD_SIGTSTP;

    case GDB_SIGNAL_CONT:
      return OBSD_SIGCONT;

    case GDB_SIGNAL_CHLD:
      return OBSD_SIGCHLD;

    case GDB_SIGNAL_TTIN:
      return OBSD_SIGTTIN;

    case GDB_SIGNAL_TTOU:
      return OBSD_SIGTTOU;

    case GDB_SIGNAL_IO:
      return OBSD_SIGIO;

    case GDB_SIGNAL_XCPU:
      return OBSD_SIGXCPU;

    case GDB_SIGNAL_XFSZ:
      return OBSD_SIGXFSZ;

    case GDB_SIGNAL_VTALRM:
      return OBSD_SIGVTALRM;

    case GDB_SIGNAL_PROF:
      return OBSD_SIGPROF;

    case GDB_SIGNAL_WINCH:
      return OBSD_SIGWINCH;

    case GDB_SIGNAL_USR1:
      return OBSD_SIGUSR1;

    case GDB_SIGNAL_USR2:
      return OBSD_SIGUSR2;

    case GDB_SIGNAL_INFO:
      return OBSD_SIGINFO;
    }

  return -1;
}

static int
obsd_auxv_parse (struct gdbarch *gdbarch, gdb_byte **readptr,
		 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
  struct type *int_type = builtin_type (gdbarch)->builtin_int;
  struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
  const int sizeof_auxv_type = TYPE_LENGTH (int_type);
  const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  gdb_byte *ptr = *readptr;

  if (endptr == ptr)
    return 0;

  if (endptr - ptr < 2 * sizeof_auxv_val)
    return -1;

  *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
  ptr += sizeof_auxv_val;	/* Alignment.  */
  *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
  ptr += sizeof_auxv_val;

  *readptr = ptr;
  return 1;
}

void
obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  set_gdbarch_gdb_signal_from_target (gdbarch,
				      obsd_gdb_signal_from_target);
  set_gdbarch_gdb_signal_to_target (gdbarch,
				    obsd_gdb_signal_to_target);

  /* Unlike Linux, OpenBSD actually follows the ELF standard.  */
  set_gdbarch_auxv_parse (gdbarch, obsd_auxv_parse);
}
Commit	Line	Data
fb08a90b MK	1	/* Target-dependent code for OpenBSD.
fb08a90b MK	2
b811d2c2	3	Copyright (C) 2005-2020 Free Software Foundation, Inc.
fb08a90b MK	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
fb08a90b MK	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
fb08a90b MK	19
	20	#include "defs.h"
	21	#include "frame.h"
	22	#include "symtab.h"
77e371c0	23	#include "objfiles.h"
fb08a90b MK	24
	25	#include "obsd-tdep.h"
	26
	27	CORE_ADDR
	28	obsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
	29	{
3b7344d5	30	struct bound_minimal_symbol msym;
fb08a90b MK	31
fb08a90b MK	32	msym = lookup_minimal_symbol("_dl_bind", NULL, NULL);
77e371c0	33	if (msym.minsym && BMSYMBOL_VALUE_ADDRESS (msym) == pc)
c7ce8faa	34	return frame_unwind_caller_pc (get_current_frame ());
fb08a90b	35	else
52f729a7	36	return find_solib_trampoline_target (get_current_frame (), pc);
fb08a90b	37	}
93ffa5b9 MK	38
	39	/* OpenBSD signal numbers. From <sys/signal.h>. */
	40
	41	enum
	42	{
	43	OBSD_SIGHUP = 1,
	44	OBSD_SIGINT = 2,
	45	OBSD_SIGQUIT = 3,
	46	OBSD_SIGILL = 4,
	47	OBSD_SIGTRAP = 5,
	48	OBSD_SIGABRT = 6,
	49	OBSD_SIGEMT = 7,
	50	OBSD_SIGFPE = 8,
	51	OBSD_SIGKILL = 9,
	52	OBSD_SIGBUS = 10,
	53	OBSD_SIGSEGV = 11,
	54	OBSD_SIGSYS = 12,
	55	OBSD_SIGPIPE = 13,
	56	OBSD_SIGALRM = 14,
	57	OBSD_SIGTERM = 15,
	58	OBSD_SIGURG = 16,
	59	OBSD_SIGSTOP = 17,
	60	OBSD_SIGTSTP = 18,
	61	OBSD_SIGCONT = 19,
	62	OBSD_SIGCHLD = 20,
	63	OBSD_SIGTTIN = 21,
	64	OBSD_SIGTTOU = 22,
	65	OBSD_SIGIO = 23,
	66	OBSD_SIGXCPU = 24,
	67	OBSD_SIGXFSZ = 25,
	68	OBSD_SIGVTALRM = 26,
	69	OBSD_SIGPROF = 27,
	70	OBSD_SIGWINCH = 28,
	71	OBSD_SIGINFO = 29,
	72	OBSD_SIGUSR1 = 30,
	73	OBSD_SIGUSR2 = 31,
	74	OBSD_SIGTHR = 32,
	75	};
	76
	77	/* Implement the "gdb_signal_from_target" gdbarch method. */
	78
	79	static enum gdb_signal
	80	obsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
	81	{
	82	switch (signal)
	83	{
	84	case 0:
	85	return GDB_SIGNAL_0;
	86
	87	case OBSD_SIGHUP:
	88	return GDB_SIGNAL_HUP;
	89
	90	case OBSD_SIGINT:
	91	return GDB_SIGNAL_INT;
	92
	93	case OBSD_SIGQUIT:
	94	return GDB_SIGNAL_QUIT;
	95
	96	case OBSD_SIGILL:
	97	return GDB_SIGNAL_ILL;
	98
	99	case OBSD_SIGTRAP:
	100	return GDB_SIGNAL_TRAP;
	101
102	case OBSD_SIGABRT:
103	return GDB_SIGNAL_ABRT;
104
105	case OBSD_SIGEMT:
106	return GDB_SIGNAL_EMT;
107
108	case OBSD_SIGFPE:
109	return GDB_SIGNAL_FPE;
110
111	case OBSD_SIGKILL:
112	return GDB_SIGNAL_KILL;
113
114	case OBSD_SIGBUS:
115	return GDB_SIGNAL_BUS;
116
117	case OBSD_SIGSEGV:
118	return GDB_SIGNAL_SEGV;
119
120	case OBSD_SIGSYS:
121	return GDB_SIGNAL_SYS;
122
123	case OBSD_SIGPIPE:
124	return GDB_SIGNAL_PIPE;
125
126	case OBSD_SIGALRM:
127	return GDB_SIGNAL_ALRM;
128
129	case OBSD_SIGTERM:
130	return GDB_SIGNAL_TERM;
131
132	case OBSD_SIGURG:
133	return GDB_SIGNAL_URG;
134
135	case OBSD_SIGSTOP:
136	return GDB_SIGNAL_STOP;
137
138	case OBSD_SIGTSTP:
139	return GDB_SIGNAL_TSTP;
140
141	case OBSD_SIGCONT:
142	return GDB_SIGNAL_CONT;
143
144	case OBSD_SIGCHLD:
145	return GDB_SIGNAL_CHLD;
146
147	case OBSD_SIGTTIN:
148	return GDB_SIGNAL_TTIN;
149
150	case OBSD_SIGTTOU:
151	return GDB_SIGNAL_TTOU;
152
153	case OBSD_SIGIO:
154	return GDB_SIGNAL_IO;
155
156	case OBSD_SIGXCPU:
157	return GDB_SIGNAL_XCPU;
158
159	case OBSD_SIGXFSZ:
160	return GDB_SIGNAL_XFSZ;
161
162	case OBSD_SIGVTALRM:
163	return GDB_SIGNAL_VTALRM;
164
165	case OBSD_SIGPROF:
166	return GDB_SIGNAL_PROF;
167
168	case OBSD_SIGWINCH:
169	return GDB_SIGNAL_WINCH;
170
171	case OBSD_SIGINFO:
172	return GDB_SIGNAL_INFO;
173
174	case OBSD_SIGUSR1:
175	return GDB_SIGNAL_USR1;
176
177	case OBSD_SIGUSR2:
178	return GDB_SIGNAL_USR2;
179	}
180
181	return GDB_SIGNAL_UNKNOWN;
182	}
183
184	/* Implement the "gdb_signal_to_target" gdbarch method. */
185
186	static int
187	obsd_gdb_signal_to_target (struct gdbarch *gdbarch,
188	enum gdb_signal signal)
189	{
190	switch (signal)
191	{
192	case GDB_SIGNAL_0:
193	return 0;
194
195	case GDB_SIGNAL_HUP:
196	return OBSD_SIGHUP;
197
198	case GDB_SIGNAL_INT:
199	return OBSD_SIGINT;
200
201	case GDB_SIGNAL_QUIT:
202	return OBSD_SIGQUIT;
203
204	case GDB_SIGNAL_ILL:
205	return OBSD_SIGILL;
206
207	case GDB_SIGNAL_TRAP:
208	return OBSD_SIGTRAP;
209
210	case GDB_SIGNAL_ABRT:
211	return OBSD_SIGABRT;
212
213	case GDB_SIGNAL_EMT:
214	return OBSD_SIGEMT;
215
216	case GDB_SIGNAL_FPE:
217	return OBSD_SIGFPE;
218
219	case GDB_SIGNAL_KILL:
220	return OBSD_SIGKILL;
221
222	case GDB_SIGNAL_BUS:
223	return OBSD_SIGBUS;
224
225	case GDB_SIGNAL_SEGV:
226	return OBSD_SIGSEGV;
227
228	case GDB_SIGNAL_SYS:
229	return OBSD_SIGSYS;
230
231	case GDB_SIGNAL_PIPE:
232	return OBSD_SIGPIPE;
233
234	case GDB_SIGNAL_ALRM:
235	return OBSD_SIGALRM;
236
237	case GDB_SIGNAL_TERM:
238	return OBSD_SIGTERM;
239
240	case GDB_SIGNAL_URG:
241	return OBSD_SIGURG;
242
243	case GDB_SIGNAL_STOP:
244	return OBSD_SIGSTOP;
245
246	case GDB_SIGNAL_TSTP:
247	return OBSD_SIGTSTP;
248
249	case GDB_SIGNAL_CONT:
250	return OBSD_SIGCONT;
251
252	case GDB_SIGNAL_CHLD:
253	return OBSD_SIGCHLD;
254
255	case GDB_SIGNAL_TTIN:
256	return OBSD_SIGTTIN;
257
258	case GDB_SIGNAL_TTOU:
259	return OBSD_SIGTTOU;
260
261	case GDB_SIGNAL_IO:
262	return OBSD_SIGIO;
263
264	case GDB_SIGNAL_XCPU:
265	return OBSD_SIGXCPU;
266
267	case GDB_SIGNAL_XFSZ:
268	return OBSD_SIGXFSZ;
269
270	case GDB_SIGNAL_VTALRM:
271	return OBSD_SIGVTALRM;
272
273	case GDB_SIGNAL_PROF:
274	return OBSD_SIGPROF;
275
276	case GDB_SIGNAL_WINCH:
277	return OBSD_SIGWINCH;
278
279	case GDB_SIGNAL_USR1:
280	return OBSD_SIGUSR1;
281
282	case GDB_SIGNAL_USR2:
283	return OBSD_SIGUSR2;
284
285	case GDB_SIGNAL_INFO:
286	return OBSD_SIGINFO;
287	}
288
289	return -1;
290	}
291
bee30a64 MK	292	static int
	293	obsd_auxv_parse (struct gdbarch gdbarch, gdb_byte *readptr,
	294	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
	295	{
	296	struct type *int_type = builtin_type (gdbarch)->builtin_int;
	297	struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
	298	const int sizeof_auxv_type = TYPE_LENGTH (int_type);
	299	const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
	300	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	301	gdb_byte ptr = readptr;
	302
	303	if (endptr == ptr)
	304	return 0;
	305
	306	if (endptr - ptr < 2 * sizeof_auxv_val)
	307	return -1;
	308
	309	*typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
	310	ptr += sizeof_auxv_val; /* Alignment. */
	311	*valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
	312	ptr += sizeof_auxv_val;
	313
	314	*readptr = ptr;
	315	return 1;
	316	}
93ffa5b9 MK	317
	318	void
	319	obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	320	{
	321	set_gdbarch_gdb_signal_from_target (gdbarch,
	322	obsd_gdb_signal_from_target);
	323	set_gdbarch_gdb_signal_to_target (gdbarch,
	324	obsd_gdb_signal_to_target);
bee30a64 MK	325
	326	/* Unlike Linux, OpenBSD actually follows the ELF standard. */
	327	set_gdbarch_auxv_parse (gdbarch, obsd_auxv_parse);
93ffa5b9	328	}