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 <byteswap.h> 49 #include <elf.h> 50 #include <errno.h> 51 #include <fcntl.h> 52 #include <stdarg.h> 53 #include <stdbool.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <sys/mman.h> 58 #include <sys/stat.h> 59 #include <sys/types.h> 60 #include <unistd.h> 61 62 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 63 #define HOST_ORDER ELFDATA2LSB 64 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 65 #define HOST_ORDER ELFDATA2MSB 66 #endif 67 68 /* Some of the ELF constants we'd like to use were added to <elf.h> 69 * relatively recently. 70 */ 71 #ifndef EF_ARM_EABI_VER5 72 #define EF_ARM_EABI_VER5 0x05000000 73 #endif 74 75 #ifndef EF_ARM_ABI_FLOAT_SOFT 76 #define EF_ARM_ABI_FLOAT_SOFT 0x200 77 #endif 78 79 #ifndef EF_ARM_ABI_FLOAT_HARD 80 #define EF_ARM_ABI_FLOAT_HARD 0x400 81 #endif 82 83 static int failed; 84 static const char *argv0; 85 static const char *outfile; 86 87 static void fail(const char *fmt, ...) 88 { 89 va_list ap; 90 91 failed = 1; 92 fprintf(stderr, "%s: ", argv0); 93 va_start(ap, fmt); 94 vfprintf(stderr, fmt, ap); 95 va_end(ap); 96 exit(EXIT_FAILURE); 97 } 98 99 static void cleanup(void) 100 { 101 if (failed && outfile != NULL) 102 unlink(outfile); 103 } 104 105 static Elf32_Word read_elf_word(Elf32_Word word, bool swap) 106 { 107 return swap ? bswap_32(word) : word; 108 } 109 110 static Elf32_Half read_elf_half(Elf32_Half half, bool swap) 111 { 112 return swap ? bswap_16(half) : half; 113 } 114 115 static void write_elf_word(Elf32_Word val, Elf32_Word *dst, bool swap) 116 { 117 *dst = swap ? bswap_32(val) : val; 118 } 119 120 int main(int argc, char **argv) 121 { 122 const Elf32_Ehdr *inhdr; 123 bool clear_soft_float; 124 const char *infile; 125 Elf32_Word e_flags; 126 const void *inbuf; 127 struct stat stat; 128 void *outbuf; 129 bool swap; 130 int outfd; 131 int infd; 132 133 atexit(cleanup); 134 argv0 = argv[0]; 135 136 if (argc != 3) 137 fail("Usage: %s [infile] [outfile]\n", argv[0]); 138 139 infile = argv[1]; 140 outfile = argv[2]; 141 142 infd = open(infile, O_RDONLY); 143 if (infd < 0) 144 fail("Cannot open %s: %s\n", infile, strerror(errno)); 145 146 if (fstat(infd, &stat) != 0) 147 fail("Failed stat for %s: %s\n", infile, strerror(errno)); 148 149 inbuf = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, infd, 0); 150 if (inbuf == MAP_FAILED) 151 fail("Failed to map %s: %s\n", infile, strerror(errno)); 152 153 close(infd); 154 155 inhdr = inbuf; 156 157 if (memcmp(&inhdr->e_ident, ELFMAG, SELFMAG) != 0) 158 fail("Not an ELF file\n"); 159 160 if (inhdr->e_ident[EI_CLASS] != ELFCLASS32) 161 fail("Unsupported ELF class\n"); 162 163 swap = inhdr->e_ident[EI_DATA] != HOST_ORDER; 164 165 if (read_elf_half(inhdr->e_type, swap) != ET_DYN) 166 fail("Not a shared object\n"); 167 168 if (read_elf_half(inhdr->e_machine, swap) != EM_ARM) 169 fail("Unsupported architecture %#x\n", inhdr->e_machine); 170 171 e_flags = read_elf_word(inhdr->e_flags, swap); 172 173 if (EF_ARM_EABI_VERSION(e_flags) != EF_ARM_EABI_VER5) { 174 fail("Unsupported EABI version %#x\n", 175 EF_ARM_EABI_VERSION(e_flags)); 176 } 177 178 if (e_flags & EF_ARM_ABI_FLOAT_HARD) 179 fail("Unexpected hard-float flag set in e_flags\n"); 180 181 clear_soft_float = !!(e_flags & EF_ARM_ABI_FLOAT_SOFT); 182 183 outfd = open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); 184 if (outfd < 0) 185 fail("Cannot open %s: %s\n", outfile, strerror(errno)); 186 187 if (ftruncate(outfd, stat.st_size) != 0) 188 fail("Cannot truncate %s: %s\n", outfile, strerror(errno)); 189 190 outbuf = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, 191 outfd, 0); 192 if (outbuf == MAP_FAILED) 193 fail("Failed to map %s: %s\n", outfile, strerror(errno)); 194 195 close(outfd); 196 197 memcpy(outbuf, inbuf, stat.st_size); 198 199 if (clear_soft_float) { 200 Elf32_Ehdr *outhdr; 201 202 outhdr = outbuf; 203 e_flags &= ~EF_ARM_ABI_FLOAT_SOFT; 204 write_elf_word(e_flags, &outhdr->e_flags, swap); 205 } 206 207 if (msync(outbuf, stat.st_size, MS_SYNC) != 0) 208 fail("Failed to sync %s: %s\n", outfile, strerror(errno)); 209 210 return EXIT_SUCCESS; 211 } 212