[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.arch / s390-multiarch.c

/* Copyright 2013-2017 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 <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct
{
  unsigned char	e_ident[16];
  uint16_t	e_type;
  uint16_t	e_machine;
  uint32_t	e_version;
  uint32_t	e_entry;
  uint32_t	e_phoff;
  uint32_t	e_shoff;
  uint32_t	e_flags;
  uint16_t	e_ehsize;
  uint16_t	e_phentsize;
  uint16_t	e_phnum;
  uint16_t	e_shentsize;
  uint16_t	e_shnum;
  uint16_t	e_shstrndx;
} Elf32_Ehdr;

typedef struct
{
  unsigned char	e_ident[16];
  uint16_t	e_type;
  uint16_t	e_machine;
  uint32_t	e_version;
  uint64_t	e_entry;
  uint64_t	e_phoff;
  uint64_t	e_shoff;
  uint32_t	e_flags;
  uint16_t	e_ehsize;
  uint16_t	e_phentsize;
  uint16_t	e_phnum;
  uint16_t	e_shentsize;
  uint16_t	e_shnum;
  uint16_t	e_shstrndx;
} Elf64_Ehdr;

typedef struct
{
  uint32_t	p_type;
  uint32_t	p_offset;
  uint32_t	p_vaddr;
  uint32_t	p_paddr;
  uint32_t	p_filesz;
  uint32_t	p_memsz;
  uint32_t	p_flags;
  uint32_t	p_align;
} Elf32_Phdr;

typedef struct
{
  uint32_t	p_type;
  uint32_t	p_flags;
  uint64_t	p_offset;
  uint64_t	p_vaddr;
  uint64_t	p_paddr;
  uint64_t	p_filesz;
  uint64_t	p_memsz;
  uint64_t	p_align;
} Elf64_Phdr;

struct elfbuf
{
  const char *path;
  unsigned char *buf;
  size_t len;
  enum { ELFCLASS32 = 1,
	 ELFCLASS64 = 2 } ei_class;
};

#define ELFBUF_EHDR_LEN(elf)					\
  ((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Ehdr) :	\
   sizeof (Elf64_Ehdr))

#define ELFBUF_EHDR(elf, memb)			\
  ((elf)->ei_class == ELFCLASS32 ?		\
   ((Elf32_Ehdr *) (elf)->buf)->memb		\
   : ((Elf64_Ehdr *) (elf)->buf)->memb)

#define ELFBUF_PHDR_LEN(elf)					\
  ((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Phdr) :	\
   sizeof (Elf64_Phdr))

#define ELFBUF_PHDR(elf, idx, memb)				\
  ((elf)->ei_class == ELFCLASS32 ?				\
   ((Elf32_Phdr *) &(elf)->buf[((Elf32_Ehdr *)(elf)->buf)	\
			       ->e_phoff])[idx].memb		\
   : ((Elf64_Phdr *) &(elf)->buf[((Elf64_Ehdr *)(elf)->buf)	\
				 ->e_phoff])[idx].memb)

static void
exit_with_msg(const char *fmt, ...)
{
  va_list ap;

  fflush (stdout);
  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);

  if (errno)
    {
      fputs (": ", stderr);
      perror (NULL);
    }
  else
    fputc ('\n', stderr);
  exit (1);
}

static void
read_file (unsigned char **buf_ptr, size_t *len_ptr, FILE *fp)
{
  size_t len = 0;
  size_t size = 1024;
  size_t chunk;
  unsigned char *buf = malloc (size);

  while ((chunk = fread (buf + len, 1, size - len, fp)) == size - len)
    {
      len = size;
      size *= 2;
      buf = realloc (buf, size);
    }
  len += chunk;
  *buf_ptr = buf;
  *len_ptr = len;
}

static void
write_file (unsigned char *buf, size_t len, FILE *fp)
{
  fwrite (buf, 1, len, fp);
}

static void
elfbuf_init_from_file (struct elfbuf *elf, const char *path)
{
  FILE *fp = fopen (path, "rb");
  unsigned char *buf;
  size_t len;

  if (fp == NULL)
    exit_with_msg ("%s", path);

  read_file (&buf, &len, fp);
  fclose (fp);

  /* Validate ELF identification. */
  if (len < 16
      || buf[0] != 0x7f || buf[1] != 0x45 || buf[2] != 0x4c || buf[3] != 0x46
      || buf[4] < 1 || buf[4] > 2 || buf[5] < 1 || buf[5] > 2)
    exit_with_msg ("%s: unsupported or invalid ELF file", path);

  elf->path = path;
  elf->buf = buf;
  elf->len = len;
  elf->ei_class = buf[4];

  if (ELFBUF_EHDR_LEN (elf) > len
      || ELFBUF_EHDR (elf, e_phoff) > len
      || ELFBUF_EHDR (elf, e_phnum) > ((len - ELFBUF_EHDR (elf, e_phoff))
				       / ELFBUF_PHDR_LEN (elf)) )
    exit_with_msg ("%s: unexpected end of data", path);

  if (ELFBUF_EHDR (elf, e_phentsize) != ELFBUF_PHDR_LEN (elf))
    exit_with_msg ("%s: inconsistent ELF header", path);
}

static void
elfbuf_write_to_file (struct elfbuf *elf, const char *path)
{
  FILE *fp = fopen (path, "wb");

  if (fp == NULL)
    exit_with_msg ("%s", path);

  write_file (elf->buf, elf->len, fp);
  fclose (fp);
}

/* In the auxv note starting at OFFSET with size LEN, mask the hwcap
   field using the HWCAP_MASK. */

static void
elfbuf_handle_auxv (struct elfbuf *elf, size_t offset, size_t len,
		    unsigned long hwcap_mask)
{
  size_t i;
  uint32_t *auxv32 = (uint32_t *) (elf->buf + offset);
  uint64_t *auxv64 = (uint64_t *) auxv32;
  size_t entry_size = elf->ei_class == ELFCLASS32 ?
    sizeof (auxv32[0]) : sizeof (auxv64[0]);

  for (i = 0; i < len / entry_size; i++)
    {
      uint64_t auxv_type = elf->ei_class == ELFCLASS32 ?
	auxv32[2 * i] : auxv64[2 * i];

      if (auxv_type == 0)
	break;
      if (auxv_type != 16)
	continue;

      if (elf->ei_class == ELFCLASS32)
	auxv32[2 * i + 1] &= (uint32_t) hwcap_mask;
      else
	auxv64[2 * i + 1] &= (uint64_t) hwcap_mask;
    }
}

/* In the note segment starting at OFFSET with size LEN, make notes
   with type NOTE_TYPE unrecognizable by GDB.  Also, mask the hwcap
   field of any auxv notes using the HWCAP_MASK. */

static void
elfbuf_handle_note_segment (struct elfbuf *elf, size_t offset, size_t len,
			    unsigned note_type, unsigned long hwcap_mask)
{
  size_t pos = 0;

  while (pos + 12 < len)
    {
      uint32_t *note = (uint32_t *) (elf->buf + offset + pos);
      size_t desc_pos = pos + 12 + ((note[0] + 3) & ~3);
      size_t next_pos = desc_pos + ((note[1] + 3) & ~3);

      if (desc_pos > len || next_pos > len)
	exit_with_msg ("%s: corrupt notes data", elf->path);

      if (note[2] == note_type)
	note[2] |= 0xff000000;
      else if (note[2] == 6 && hwcap_mask != 0)
	elfbuf_handle_auxv (elf, offset + desc_pos, note[1],
			    hwcap_mask);
      pos = next_pos;
    }
}

static void
elfbuf_handle_core_notes (struct elfbuf *elf, unsigned note_type,
			  unsigned long hwcap_mask)
{
  unsigned ph_idx;

  if (ELFBUF_EHDR (elf, e_type) != 4)
    exit_with_msg ("%s: not a core file", elf->path);

  /* Iterate over program headers. */
  for (ph_idx = 0; ph_idx != ELFBUF_EHDR (elf, e_phnum); ph_idx++)
    {
      size_t offset = ELFBUF_PHDR (elf, ph_idx, p_offset);
      size_t filesz = ELFBUF_PHDR (elf, ph_idx, p_filesz);

      if (offset > elf->len || filesz > elf->len - offset)
	exit_with_msg ("%s: unexpected end of data", elf->path);

      /* Deal with NOTE segments only. */
      if (ELFBUF_PHDR (elf, ph_idx, p_type) != 4)
	continue;
      elfbuf_handle_note_segment (elf, offset, filesz, note_type,
				  hwcap_mask);
    }
}

int
main (int argc, char *argv[])
{
  unsigned note_type;
  unsigned long hwcap_mask = 0;
  struct elfbuf elf;

  if (argc < 4)
    {
      abort ();
    }

  if (sscanf (argv[3], "%u", &note_type) != 1)
    exit_with_msg ("%s: bad command line arguments\n", argv[0]);

  if (argc >= 5)
    {
      if (sscanf (argv[4], "%lu", &hwcap_mask) != 1)
	exit_with_msg ("%s: bad command line arguments\n", argv[0]);
    }

  elfbuf_init_from_file (&elf, argv[1]);
  elfbuf_handle_core_notes (&elf, note_type, hwcap_mask);
  elfbuf_write_to_file (&elf, argv[2]);

  return 0;
}
Commit	Line	Data
61baf725	1	/* Copyright 2013-2017 Free Software Foundation, Inc.
9772d074 UW	2
	3	This file is part of GDB.
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	#include <errno.h>
	19	#include <stdarg.h>
	20	#include <stdint.h>
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23
	24	typedef struct
	25	{
	26	unsigned char e_ident[16];
	27	uint16_t e_type;
	28	uint16_t e_machine;
	29	uint32_t e_version;
	30	uint32_t e_entry;
	31	uint32_t e_phoff;
	32	uint32_t e_shoff;
	33	uint32_t e_flags;
	34	uint16_t e_ehsize;
	35	uint16_t e_phentsize;
	36	uint16_t e_phnum;
	37	uint16_t e_shentsize;
	38	uint16_t e_shnum;
	39	uint16_t e_shstrndx;
	40	} Elf32_Ehdr;
	41
	42	typedef struct
	43	{
	44	unsigned char e_ident[16];
	45	uint16_t e_type;
	46	uint16_t e_machine;
	47	uint32_t e_version;
	48	uint64_t e_entry;
	49	uint64_t e_phoff;
	50	uint64_t e_shoff;
	51	uint32_t e_flags;
	52	uint16_t e_ehsize;
	53	uint16_t e_phentsize;
	54	uint16_t e_phnum;
	55	uint16_t e_shentsize;
	56	uint16_t e_shnum;
	57	uint16_t e_shstrndx;
	58	} Elf64_Ehdr;
	59
	60	typedef struct
	61	{
	62	uint32_t p_type;
	63	uint32_t p_offset;
	64	uint32_t p_vaddr;
	65	uint32_t p_paddr;
66	uint32_t p_filesz;
67	uint32_t p_memsz;
68	uint32_t p_flags;
69	uint32_t p_align;
70	} Elf32_Phdr;
71
72	typedef struct
73	{
74	uint32_t p_type;
75	uint32_t p_flags;
76	uint64_t p_offset;
77	uint64_t p_vaddr;
78	uint64_t p_paddr;
79	uint64_t p_filesz;
80	uint64_t p_memsz;
81	uint64_t p_align;
82	} Elf64_Phdr;
83
84	struct elfbuf
85	{
86	const char *path;
87	unsigned char *buf;
88	size_t len;
89	enum { ELFCLASS32 = 1,
90	ELFCLASS64 = 2 } ei_class;
91	};
92
93	#define ELFBUF_EHDR_LEN(elf) \
94	((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Ehdr) : \
95	sizeof (Elf64_Ehdr))
96
97	#define ELFBUF_EHDR(elf, memb) \
98	((elf)->ei_class == ELFCLASS32 ? \
99	((Elf32_Ehdr *) (elf)->buf)->memb \
100	: ((Elf64_Ehdr *) (elf)->buf)->memb)
101
102	#define ELFBUF_PHDR_LEN(elf) \
103	((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Phdr) : \
104	sizeof (Elf64_Phdr))
105
106	#define ELFBUF_PHDR(elf, idx, memb) \
107	((elf)->ei_class == ELFCLASS32 ? \
108	((Elf32_Phdr ) &(elf)->buf[((Elf32_Ehdr )(elf)->buf) \
109	->e_phoff])[idx].memb \
110	: ((Elf64_Phdr ) &(elf)->buf[((Elf64_Ehdr )(elf)->buf) \
111	->e_phoff])[idx].memb)
112
113	static void
114	exit_with_msg(const char *fmt, ...)
115	{
116	va_list ap;
117
118	fflush (stdout);
119	va_start (ap, fmt);
120	vfprintf (stderr, fmt, ap);
121	va_end (ap);
122
123	if (errno)
124	{
125	fputs (": ", stderr);
126	perror (NULL);
127	}
128	else
129	fputc ('\n', stderr);
130	exit (1);
131	}
132
133	static void
134	read_file (unsigned char *buf_ptr, size_t len_ptr, FILE *fp)
135	{
136	size_t len = 0;
137	size_t size = 1024;
138	size_t chunk;
139	unsigned char *buf = malloc (size);
140
141	while ((chunk = fread (buf + len, 1, size - len, fp)) == size - len)
142	{
143	len = size;
144	size *= 2;
145	buf = realloc (buf, size);
146	}
147	len += chunk;
148	*buf_ptr = buf;
149	*len_ptr = len;
150	}
151
152	static void
153	write_file (unsigned char buf, size_t len, FILE fp)
154	{
155	fwrite (buf, 1, len, fp);
156	}
157
158	static void
159	elfbuf_init_from_file (struct elfbuf elf, const char path)
160	{
161	FILE *fp = fopen (path, "rb");
162	unsigned char *buf;
163	size_t len;
164
165	if (fp == NULL)
166	exit_with_msg ("%s", path);
167
168	read_file (&buf, &len, fp);
169	fclose (fp);
170
171	/* Validate ELF identification. */
172	if (len < 16
173	\|\| buf[0] != 0x7f \|\| buf[1] != 0x45 \|\| buf[2] != 0x4c \|\| buf[3] != 0x46
174	\|\| buf[4] < 1 \|\| buf[4] > 2 \|\| buf[5] < 1 \|\| buf[5] > 2)
175	exit_with_msg ("%s: unsupported or invalid ELF file", path);
176
177	elf->path = path;
178	elf->buf = buf;
179	elf->len = len;
180	elf->ei_class = buf[4];
181
182	if (ELFBUF_EHDR_LEN (elf) > len
183	\|\| ELFBUF_EHDR (elf, e_phoff) > len
184	\|\| ELFBUF_EHDR (elf, e_phnum) > ((len - ELFBUF_EHDR (elf, e_phoff))
185	/ ELFBUF_PHDR_LEN (elf)) )
186	exit_with_msg ("%s: unexpected end of data", path);
187
188	if (ELFBUF_EHDR (elf, e_phentsize) != ELFBUF_PHDR_LEN (elf))
189	exit_with_msg ("%s: inconsistent ELF header", path);
190	}
191
192	static void
193	elfbuf_write_to_file (struct elfbuf elf, const char path)
194	{
195	FILE *fp = fopen (path, "wb");
196
197	if (fp == NULL)
198	exit_with_msg ("%s", path);
199
200	write_file (elf->buf, elf->len, fp);
201	fclose (fp);
202	}
203
204	/* In the auxv note starting at OFFSET with size LEN, mask the hwcap
205	field using the HWCAP_MASK. */
206
207	static void
208	elfbuf_handle_auxv (struct elfbuf *elf, size_t offset, size_t len,
209	unsigned long hwcap_mask)
210	{
211	size_t i;
212	uint32_t auxv32 = (uint32_t ) (elf->buf + offset);
213	uint64_t auxv64 = (uint64_t ) auxv32;
214	size_t entry_size = elf->ei_class == ELFCLASS32 ?
215	sizeof (auxv32[0]) : sizeof (auxv64[0]);
216
217	for (i = 0; i < len / entry_size; i++)
218	{
219	uint64_t auxv_type = elf->ei_class == ELFCLASS32 ?
220	auxv32[2 * i] : auxv64[2 * i];
221
222	if (auxv_type == 0)
223	break;
224	if (auxv_type != 16)
225	continue;
226
227	if (elf->ei_class == ELFCLASS32)
228	auxv32[2 * i + 1] &= (uint32_t) hwcap_mask;
229	else
230	auxv64[2 * i + 1] &= (uint64_t) hwcap_mask;
231	}
232	}
233
234	/* In the note segment starting at OFFSET with size LEN, make notes
235	with type NOTE_TYPE unrecognizable by GDB. Also, mask the hwcap
236	field of any auxv notes using the HWCAP_MASK. */
237
238	static void
239	elfbuf_handle_note_segment (struct elfbuf *elf, size_t offset, size_t len,
240	unsigned note_type, unsigned long hwcap_mask)
241	{
242	size_t pos = 0;
243
244	while (pos + 12 < len)
245	{
246	uint32_t note = (uint32_t ) (elf->buf + offset + pos);
247	size_t desc_pos = pos + 12 + ((note[0] + 3) & ~3);
248	size_t next_pos = desc_pos + ((note[1] + 3) & ~3);
249
250	if (desc_pos > len \|\| next_pos > len)
251	exit_with_msg ("%s: corrupt notes data", elf->path);
252
253	if (note[2] == note_type)
254	note[2] \|= 0xff000000;
255	else if (note[2] == 6 && hwcap_mask != 0)
256	elfbuf_handle_auxv (elf, offset + desc_pos, note[1],
257	hwcap_mask);
258	pos = next_pos;
259	}
260	}
261
262	static void
263	elfbuf_handle_core_notes (struct elfbuf *elf, unsigned note_type,
264	unsigned long hwcap_mask)
265	{
266	unsigned ph_idx;
267
268	if (ELFBUF_EHDR (elf, e_type) != 4)
269	exit_with_msg ("%s: not a core file", elf->path);
270
271	/* Iterate over program headers. */
272	for (ph_idx = 0; ph_idx != ELFBUF_EHDR (elf, e_phnum); ph_idx++)
273	{
274	size_t offset = ELFBUF_PHDR (elf, ph_idx, p_offset);
275	size_t filesz = ELFBUF_PHDR (elf, ph_idx, p_filesz);
276
277	if (offset > elf->len \|\| filesz > elf->len - offset)
278	exit_with_msg ("%s: unexpected end of data", elf->path);
279
280	/* Deal with NOTE segments only. */
281	if (ELFBUF_PHDR (elf, ph_idx, p_type) != 4)
282	continue;
283	elfbuf_handle_note_segment (elf, offset, filesz, note_type,
284	hwcap_mask);
285	}
286	}
287
288	int
289	main (int argc, char *argv[])
290	{
291	unsigned note_type;
292	unsigned long hwcap_mask = 0;
293	struct elfbuf elf;
294
295	if (argc < 4)
296	{
297	abort ();
298	}
299
300	if (sscanf (argv[3], "%u", &note_type) != 1)
301	exit_with_msg ("%s: bad command line arguments\n", argv[0]);
302
303	if (argc >= 5)
304	{
305	if (sscanf (argv[4], "%lu", &hwcap_mask) != 1)
306	exit_with_msg ("%s: bad command line arguments\n", argv[0]);
307	}
308
309	elfbuf_init_from_file (&elf, argv[1]);
310	elfbuf_handle_core_notes (&elf, note_type, hwcap_mask);
311	elfbuf_write_to_file (&elf, argv[2]);
312
313	return 0;
314	}