1/*
2 * Copyright 2015 Mentor Graphics Corporation.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; version 2 of the
7 * License.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 *
17 *
18 * vdsomunge - Host program which produces a shared object
19 * architecturally specified to be usable by both soft- and hard-float
20 * programs.
21 *
22 * The Procedure Call Standard for the ARM Architecture (ARM IHI
23 * 0042E) says:
24 *
25 *	6.4.1 VFP and Base Standard Compatibility
26 *
27 *	Code compiled for the VFP calling standard is compatible with
28 *	the base standard (and vice-versa) if no floating-point or
29 *	containerized vector arguments or results are used.
30 *
31 * And ELF for the ARM Architecture (ARM IHI 0044E) (Table 4-2) says:
32 *
33 *	If both EF_ARM_ABI_FLOAT_XXXX bits are clear, conformance to the
34 *	base procedure-call standard is implied.
35 *
36 * The VDSO is built with -msoft-float, as with the rest of the ARM
37 * kernel, and uses no floating point arguments or results.  The build
38 * process will produce a shared object that may or may not have the
39 * EF_ARM_ABI_FLOAT_SOFT flag set (it seems to depend on the binutils
40 * version; binutils starting with 2.24 appears to set it).  The
41 * EF_ARM_ABI_FLOAT_HARD flag should definitely not be set, and this
42 * program will error out if it is.
43 *
44 * If the soft-float flag is set, this program clears it.  That's all
45 * it does.
46 */
47
48#include <elf.h>
49#include <errno.h>
50#include <fcntl.h>
51#include <stdarg.h>
52#include <stdbool.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <sys/mman.h>
57#include <sys/stat.h>
58#include <sys/types.h>
59#include <unistd.h>
60
61#define swab16(x) \
62	((((x) & 0x00ff) << 8) | \
63	 (((x) & 0xff00) >> 8))
64
65#define swab32(x) \
66	((((x) & 0x000000ff) << 24) | \
67	 (((x) & 0x0000ff00) <<  8) | \
68	 (((x) & 0x00ff0000) >>  8) | \
69	 (((x) & 0xff000000) >> 24))
70
71#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
72#define HOST_ORDER ELFDATA2LSB
73#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
74#define HOST_ORDER ELFDATA2MSB
75#endif
76
77/* Some of the ELF constants we'd like to use were added to <elf.h>
78 * relatively recently.
79 */
80#ifndef EF_ARM_EABI_VER5
81#define EF_ARM_EABI_VER5 0x05000000
82#endif
83
84#ifndef EF_ARM_ABI_FLOAT_SOFT
85#define EF_ARM_ABI_FLOAT_SOFT 0x200
86#endif
87
88#ifndef EF_ARM_ABI_FLOAT_HARD
89#define EF_ARM_ABI_FLOAT_HARD 0x400
90#endif
91
92static int failed;
93static const char *argv0;
94static const char *outfile;
95
96static void fail(const char *fmt, ...)
97{
98	va_list ap;
99
100	failed = 1;
101	fprintf(stderr, "%s: ", argv0);
102	va_start(ap, fmt);
103	vfprintf(stderr, fmt, ap);
104	va_end(ap);
105	exit(EXIT_FAILURE);
106}
107
108static void cleanup(void)
109{
110	if (failed && outfile != NULL)
111		unlink(outfile);
112}
113
114static Elf32_Word read_elf_word(Elf32_Word word, bool swap)
115{
116	return swap ? swab32(word) : word;
117}
118
119static Elf32_Half read_elf_half(Elf32_Half half, bool swap)
120{
121	return swap ? swab16(half) : half;
122}
123
124static void write_elf_word(Elf32_Word val, Elf32_Word *dst, bool swap)
125{
126	*dst = swap ? swab32(val) : val;
127}
128
129int main(int argc, char **argv)
130{
131	const Elf32_Ehdr *inhdr;
132	bool clear_soft_float;
133	const char *infile;
134	Elf32_Word e_flags;
135	const void *inbuf;
136	struct stat stat;
137	void *outbuf;
138	bool swap;
139	int outfd;
140	int infd;
141
142	atexit(cleanup);
143	argv0 = argv[0];
144
145	if (argc != 3)
146		fail("Usage: %s [infile] [outfile]\n", argv[0]);
147
148	infile = argv[1];
149	outfile = argv[2];
150
151	infd = open(infile, O_RDONLY);
152	if (infd < 0)
153		fail("Cannot open %s: %s\n", infile, strerror(errno));
154
155	if (fstat(infd, &stat) != 0)
156		fail("Failed stat for %s: %s\n", infile, strerror(errno));
157
158	inbuf = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, infd, 0);
159	if (inbuf == MAP_FAILED)
160		fail("Failed to map %s: %s\n", infile, strerror(errno));
161
162	close(infd);
163
164	inhdr = inbuf;
165
166	if (memcmp(&inhdr->e_ident, ELFMAG, SELFMAG) != 0)
167		fail("Not an ELF file\n");
168
169	if (inhdr->e_ident[EI_CLASS] != ELFCLASS32)
170		fail("Unsupported ELF class\n");
171
172	swap = inhdr->e_ident[EI_DATA] != HOST_ORDER;
173
174	if (read_elf_half(inhdr->e_type, swap) != ET_DYN)
175		fail("Not a shared object\n");
176
177	if (read_elf_half(inhdr->e_machine, swap) != EM_ARM)
178		fail("Unsupported architecture %#x\n", inhdr->e_machine);
179
180	e_flags = read_elf_word(inhdr->e_flags, swap);
181
182	if (EF_ARM_EABI_VERSION(e_flags) != EF_ARM_EABI_VER5) {
183		fail("Unsupported EABI version %#x\n",
184		     EF_ARM_EABI_VERSION(e_flags));
185	}
186
187	if (e_flags & EF_ARM_ABI_FLOAT_HARD)
188		fail("Unexpected hard-float flag set in e_flags\n");
189
190	clear_soft_float = !!(e_flags & EF_ARM_ABI_FLOAT_SOFT);
191
192	outfd = open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
193	if (outfd < 0)
194		fail("Cannot open %s: %s\n", outfile, strerror(errno));
195
196	if (ftruncate(outfd, stat.st_size) != 0)
197		fail("Cannot truncate %s: %s\n", outfile, strerror(errno));
198
199	outbuf = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
200		      outfd, 0);
201	if (outbuf == MAP_FAILED)
202		fail("Failed to map %s: %s\n", outfile, strerror(errno));
203
204	close(outfd);
205
206	memcpy(outbuf, inbuf, stat.st_size);
207
208	if (clear_soft_float) {
209		Elf32_Ehdr *outhdr;
210
211		outhdr = outbuf;
212		e_flags &= ~EF_ARM_ABI_FLOAT_SOFT;
213		write_elf_word(e_flags, &outhdr->e_flags, swap);
214	}
215
216	if (msync(outbuf, stat.st_size, MS_SYNC) != 0)
217		fail("Failed to sync %s: %s\n", outfile, strerror(errno));
218
219	return EXIT_SUCCESS;
220}
221