delint/fix to build with paranoia flags
[AROS.git] / tools / elf2hunk / elf2hunk.c
blob960c6b395c3f01f4dfb0c12b864ab9e80b398468
1 /*
2 Copyright © 1995-2001, The AROS Development Team. All rights reserved.
3 $Id$
4 */
6 #define PROTOTYPES
7 #define HAVE_STDARG_H
9 #include <stdio.h>
10 #include <string.h>
11 #include <stdlib.h>
12 #include <stdint.h>
13 #include <assert.h>
14 #include <ctype.h>
15 #include <errno.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <limits.h>
19 #include <dirent.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
24 #define F_VERBOSE (1 << 0)
25 #define F_NOCONVERT (1 << 1)
27 #if defined(__GNUC__)&&defined(WIN32)
28 #include <winsock2.h>
29 #define mkdir(path, mode) mkdir(path)
30 #else
31 #include <arpa/inet.h>
32 typedef uint32_t ULONG;
33 typedef int BOOL;
34 #endif
35 typedef uint8_t UBYTE;
36 typedef uint16_t UWORD;
37 typedef uint32_t IPTR;
38 typedef int32_t SIPTR;
39 typedef char * STRPTR;
41 #if !defined(FALSE)&&!defined(TRUE)
42 #define FALSE 0
43 #define TRUE (!FALSE)
44 #endif
46 /* Memory allocation flags */
47 #define MEMF_ANY 0L
48 #define MEMF_PUBLIC (1L<<0)
49 #define MEMF_CHIP (1L<<1)
50 #define MEMF_FAST (1L<<2)
51 #define MEMF_EXECUTABLE (1L<<4) /* AmigaOS v4 compatible */
52 #define MEMF_LOCAL (1L<<8)
53 #define MEMF_24BITDMA (1L<<9)
54 #define MEMF_KICK (1L<<10)
55 #define MEMF_31BIT (1L<<12) /* Low address space (<2GB). Effective only on 64 bit machines. */
56 #define MEMF_CLEAR (1L<<16) /* Explicitly clear memory after allocation */
57 #define MEMF_LARGEST (1L<<17)
58 #define MEMF_REVERSE (1L<<18)
59 #define MEMF_TOTAL (1L<<19)
60 #define MEMF_HWALIGNED (1L<<20) /* For AllocMem() - align address and size to physical page boundary */
61 #define MEMF_SEM_PROTECTED (1L<<20) /* For CreatePool() - add semaphore protection to the pool */
62 #define MEMF_NO_EXPUNGE (1L<<31)
64 #define HUNKF_ADVISORY (1L<<29)
65 #define HUNKF_CHIP (1L<<30)
66 #define HUNKF_FAST (1L<<31)
67 #define HUNKF_MEMFLAGS (HUNKF_CHIP | HUNKF_FAST)
70 #define HUNK_CODE 1001
71 #define HUNK_DATA 1002
72 #define HUNK_BSS 1003
73 #define HUNK_RELOC32 1004
74 #define HUNK_SYMBOL 1008
75 #define HUNK_END 1010
76 #define HUNK_HEADER 1011
78 #define SHT_PROGBITS 1
79 #define SHT_SYMTAB 2
80 #define SHT_STRTAB 3
81 #define SHT_RELA 4
82 #define SHT_NOBITS 8
83 #define SHT_REL 9
84 #define SHT_SYMTAB_SHNDX 18
86 #define ET_REL 1
87 #define ET_EXEC 2
89 #define EM_386 3
90 #define EM_68K 4
91 #define EM_PPC 20
92 #define EM_ARM 40
93 #define EM_X86_64 62 /* AMD x86-64 */
95 #define R_386_NONE 0
96 #define R_386_32 1
97 #define R_386_PC32 2
99 /* AMD x86-64 relocations. */
100 #define R_X86_64_NONE 0 /* No reloc */
101 #define R_X86_64_64 1 /* Direct 64 bit */
102 #define R_X86_64_PC32 2 /* PC relative 32 bit signed */
103 #define R_X86_64_32 10
104 #define R_X86_64_32S 11
106 #define R_68k_NONE 0
107 #define R_68K_32 1
108 #define R_68K_PC32 4
109 #define R_68K_PC16 5
111 #define R_PPC_NONE 0
112 #define R_PPC_ADDR32 1
113 #define R_PPC_ADDR16_LO 4
114 #define R_PPC_ADDR16_HA 6
115 #define R_PPC_REL24 10
116 #define R_PPC_REL32 26
117 #define R_PPC_REL16_LO 250
118 #define R_PPC_REL16_HA 252
120 #define R_ARM_NONE 0
121 #define R_ARM_PC24 1
122 #define R_ARM_ABS32 2
123 #define R_ARM_CALL 28
124 #define R_ARM_JUMP24 29
125 #define R_ARM_V4BX 40
126 #define R_ARM_PREL31 42
127 #define R_ARM_MOVW_ABS_NC 43
128 #define R_ARM_MOVT_ABS 44
130 #define STT_NOTYPE 0
131 #define STT_OBJECT 1
132 #define STT_FUNC 2
133 #define STT_SECTION 3
134 #define STT_FILE 4
135 #define STT_LOPROC 13
136 #define STT_HIPROC 15
138 #define SHN_UNDEF 0
139 #define SHN_LORESERVE 0xff00
140 #define SHN_ABS 0xfff1
141 #define SHN_COMMON 0xfff2
142 #define SHN_XINDEX 0xffff
143 #define SHN_HIRESERVE 0xffff
145 #define SHF_WRITE (1 << 0)
146 #define SHF_ALLOC (1 << 1)
147 #define SHF_EXECINSTR (1 << 2)
149 #define ELF_ST_TYPE(i) ((i) & 0x0F)
151 #define EI_VERSION 6
152 #define EV_CURRENT 1
154 #define EI_DATA 5
155 #define ELFDATA2LSB 1
156 #define ELFDATA2MSB 2
158 #define EI_CLASS 4
159 #define ELFCLASS32 1
160 #define ELFCLASS64 2 /* 64-bit objects */
162 #define EI_OSABI 7
163 #define EI_ABIVERSION 8
165 #define ELFOSABI_AROS 15
167 #define PF_X (1 << 0)
169 struct elfheader
171 UBYTE ident[16];
172 UWORD type;
173 UWORD machine;
174 ULONG version;
175 IPTR entry;
176 IPTR phoff;
177 IPTR shoff;
178 ULONG flags;
179 UWORD ehsize;
180 UWORD phentsize;
181 UWORD phnum;
182 UWORD shentsize;
183 UWORD shnum;
184 UWORD shstrndx;
185 } __attribute__((packed));
187 struct sheader
189 ULONG name;
190 ULONG type;
191 IPTR flags;
192 IPTR addr;
193 IPTR offset;
194 IPTR size;
195 ULONG link;
196 ULONG info;
197 IPTR addralign;
198 IPTR entsize;
199 } __attribute__((packed));
201 #define PT_LOAD 1
203 struct pheader
205 ULONG type;
206 ULONG offset;
207 IPTR vaddr;
208 IPTR paddr;
209 ULONG filesz;
210 ULONG memsz;
211 ULONG flags;
212 ULONG align;
213 } __attribute__((packed));
215 struct symbol
217 ULONG name; /* Offset of the name string in the string table */
218 IPTR value; /* Varies; eg. the offset of the symbol in its hunk */
219 IPTR size; /* How much memory does the symbol occupy */
220 UBYTE info; /* What kind of symbol is this ? (global, variable, etc) */
221 UBYTE other; /* undefined */
222 UWORD shindex; /* In which section is the symbol defined ? */
223 } __attribute__((packed));
225 #define ELF_R_SYM(val) ((val) >> 8)
226 #define ELF_R_TYPE(val) ((val) & 0xff)
227 #define ELF_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff))
229 struct relo
231 IPTR offset; /* Address of the relocation relative to the section it refers to */
232 IPTR info; /* Type of the relocation */
233 SIPTR addend; /* Constant addend used to compute value */
236 /* Note: the conversion below is not in line with ELF specification and is fixed in GNU binutils since 2008
237 * See: https://sourceware.org/bugzilla/show_bug.cgi?id=5900
239 /* convert section header number to array index */
240 /*#define SHINDEX(n) \
241 ((n) < SHN_LORESERVE ? (n) : ((n) <= SHN_HIRESERVE ? 0 : (n) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))*/
243 /* convert section header array index to section number */
244 /*#define SHNUM(i) \
245 ((i) < SHN_LORESERVE ? (i) : (i) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))*/
247 /* m68k Machine's native values */
248 #define AROS_ELF_CLASS ELFCLASS32
249 #define AROS_ELF_DATA ELFDATA2MSB
250 #define AROS_ELF_MACHINE EM_68K
251 #define AROS_ELF_REL SHT_RELA
254 #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
255 # include <stdarg.h>
256 # define VA_START(args, lastarg) va_start(args, lastarg)
257 #else
258 # include <varargs.h>
259 # define VA_START(args, lastarg) va_start(args)
260 #endif
262 #ifdef PROTOTYPES
263 # define PARAMS(x) x
264 #else
265 # define PARAMS(x) ()
266 #endif /* PROTOTYPES */
268 static void set_error(int err)
270 errno = err;
273 #if defined(DEBUG) && DEBUG
274 #define D(x) x
275 #define DB2(x) x
276 #else
277 #define D(x)
278 #define DB2(x)
279 #endif
280 #define bug(fmt,args...) fprintf(stderr, fmt ,##args )
282 static int must_swap = -1;
284 static void eh_fixup(struct elfheader *eh)
286 /* Endian swaps */
287 if (eh->type == 256) {
288 must_swap = 1;
289 eh->type = ntohs(eh->type);
290 eh->machine = ntohs(eh->machine);
291 eh->version = ntohl(eh->version);
292 eh->entry = ntohl(eh->entry);
293 eh->phoff = ntohl(eh->phoff);
294 eh->shoff = ntohl(eh->shoff);
295 eh->flags = ntohl(eh->flags);
296 eh->ehsize = ntohs(eh->ehsize);
297 eh->phentsize = ntohs(eh->phentsize);
298 eh->phnum = ntohs(eh->phnum);
299 eh->shentsize = ntohs(eh->shentsize);
300 eh->shnum = ntohs(eh->shnum);
301 eh->shstrndx = ntohs(eh->shstrndx);
302 } else {
303 must_swap = 0;
307 static void sh_fixup(struct sheader *sh, int n)
309 if (must_swap == 0)
310 return;
312 for (; n > 0; n--, sh++) {
313 sh->name = ntohl(sh->name);
314 sh->type = ntohl(sh->type);
315 sh->flags = ntohl(sh->flags);
316 sh->addr = ntohl(sh->addr);
317 sh->offset = ntohl(sh->offset);
318 sh->size = ntohl(sh->size);
319 sh->link = ntohl(sh->link);
320 sh->info = ntohl(sh->info);
321 sh->addralign = ntohl(sh->addralign);
322 sh->entsize = ntohl(sh->entsize);
326 static void rel_fixup(struct relo *rel)
328 if (must_swap == 0)
329 return;
331 rel->offset = ntohl(rel->offset);
332 rel->info = ntohl(rel->info);
333 rel->addend = ntohl(rel->addend);
336 void sym_fixup(struct symbol *sym)
338 if (must_swap == 0)
339 return;
341 sym->name = ntohl(sym->name);
342 sym->value = ntohl(sym->value);
343 sym->size = ntohl(sym->size);
344 sym->shindex = ntohs(sym->shindex);
347 static void *load_block (int file,ULONG offset,ULONG size)
349 ULONG lsize = (size + sizeof(ULONG) - 1) / sizeof(ULONG);
350 D(bug("[ELF2HUNK] Load Block\n"));
351 D(bug("[ELF2HUNK] (size=%d)\n",(int)size));
352 void *block = malloc(lsize * sizeof(ULONG));
353 if (block) {
354 lseek(file, offset, SEEK_SET);
355 if (read(file, block, size) == size) {
356 return block;
359 free(block);
360 set_error(EIO);
361 } else
362 set_error(ENOMEM);
364 return NULL;
367 static ULONG read_shnum(int file, struct elfheader *eh)
369 ULONG shnum = eh->shnum;
371 /* the ELF header only uses 16 bits to store the count of section headers,
372 * so it can't handle more than 65535 headers. if the count is 0, and an
373 * offset is defined, then the real count can be found in the first
374 * section header (which always exists).
376 * similarly, if the string table index is SHN_XINDEX, then the actual
377 * index is found in the first section header also.
379 * see the System V ABI 2001-04-24 draft for more details.
381 if (eh->shnum == 0)
383 struct sheader sh;
385 if (eh->shoff == 0) {
386 set_error(ENOEXEC);
387 return 0;
390 lseek(file, eh->shoff, SEEK_SET);
391 if (read(file, &sh, sizeof(sh)) != sizeof(sh))
392 return 0;
394 sh_fixup(&sh, 1);
396 /* wider section header count is in the size field */
397 shnum = sh.size;
399 /* sanity, if they're still invalid then this isn't elf */
400 if (shnum == 0)
401 set_error(ENOEXEC);
404 return shnum;
407 static int load_header(int file, struct elfheader *eh)
409 lseek(file, 0, SEEK_SET);
410 if (read(file, eh, sizeof(struct elfheader)) != sizeof(struct elfheader)) {
411 D(bug("[ELF2HUNK] Can't read the %d byte ELF header\n", (int)sizeof(struct elfheader)));
412 return 0;
415 eh_fixup(eh);
417 if (eh->ident[0] != 0x7f || eh->ident[1] != 'E' ||
418 eh->ident[2] != 'L' || eh->ident[3] != 'F') {
419 D(bug("[ELF2HUNK] Not an ELF object\n"));
420 return 0;
422 D(bug("[ELF2HUNK] ELF object\n"));
424 /* WANT_CLASS should be defined for your target */
425 if (eh->ident[EI_CLASS] != AROS_ELF_CLASS ||
426 eh->ident[EI_VERSION] != EV_CURRENT ||
427 eh->type != ET_REL ||
428 eh->ident[EI_DATA] != AROS_ELF_DATA ||
429 eh->machine != AROS_ELF_MACHINE)
431 D(bug("[ELF2HUNK] Object is of wrong type\n"));
432 D(bug("[ELF2HUNK] EI_CLASS is %d - should be %d\n", eh->ident[EI_CLASS] , AROS_ELF_CLASS ));
433 D(bug("[ELF2HUNK] EI_VERSION is %d - should be %d\n", eh->ident[EI_VERSION], EV_CURRENT ));
434 D(bug("[ELF2HUNK] type is %d - should be %d\n", eh->type , ET_REL ));
435 D(bug("[ELF2HUNK] EI_DATA is %d - should be %d\n", eh->ident[EI_DATA] , AROS_ELF_DATA ));
436 D(bug("[ELF2HUNK] machine is %d - should be %d\n", eh->machine , AROS_ELF_MACHINE));
438 set_error(ENOEXEC);
439 return 0;
442 return 1;
445 struct hunkheader {
446 ULONG type;
447 ULONG memflags; /* Memory flags */
448 ULONG size; /* Size in ULONGs */
449 void *data;
450 ULONG relocs;
451 int hunk; /* Allocatable hunk ID */
452 struct hunkreloc {
453 ULONG shid; /* ELF hunk base to add to... */
454 ULONG offset; /* offset in this hunk. */
455 const char *symbol;
456 } *reloc;
459 static int relocate
461 struct elfheader *eh,
462 struct sheader *sh,
463 ULONG shrel_idx,
464 int symtab_shndx,
465 struct relo *rel,
466 struct hunkheader **hh
469 struct sheader *shrel = &sh[shrel_idx];
470 struct sheader *shsymtab = &sh[shrel->link];
471 struct sheader *toreloc = &sh[shrel->info];
473 struct symbol *symtab = (struct symbol *)hh[shrel->link]->data;
474 struct hunkheader *h = hh[shrel->info];
477 * Ignore relocs if the target section has no allocation. that can happen
478 * eg. with a .debug PROGBITS and a .rel.debug section
480 D(bug("[ELF2HUNK] sh[%d].flags = 0x%x\n", (int)(shrel->info), (int)toreloc->flags));
481 if (!(toreloc->flags & SHF_ALLOC))
482 return 1;
484 ULONG numrel = shrel->size / shrel->entsize;
485 ULONG i;
486 ULONG hrels;
488 hrels = h->relocs;
489 h->relocs += numrel;
490 h->reloc = realloc(h->reloc, h->relocs * sizeof(struct hunkreloc));
491 struct hunkreloc *hrel = &h->reloc[hrels];
493 for (i=0; i<numrel; i++, rel++)
495 struct symbol sym;
496 ULONG offset;
497 ULONG shindex;
498 ULONG hunk = 0;
499 ULONG value = 0;
500 const char *symname;
502 rel_fixup(rel);
504 #ifdef __arm__
506 * R_ARM_V4BX are actually special marks for the linker.
507 * They even never have a target (shindex == SHN_UNDEF),
508 * so we simply ignore them before doing any checks.
510 if (ELF_R_TYPE(rel->info) == R_ARM_V4BX)
511 continue;
512 #endif
514 sym = symtab[ELF_R_SYM(rel->info)];
515 sym_fixup(&sym);
516 offset = rel->offset;
517 symname = (const char *)(hh[shsymtab->link]->data + sym.name);
519 if (sym.shindex != SHN_XINDEX)
520 shindex = sym.shindex;
522 else {
523 if (symtab_shndx < 0) {
524 bug("[ELF2HUNK] got symbol with shndx 0xfff, but there's no symtab shndx table\n");
525 set_error(EINVAL);
526 return 0;
528 shindex = ntohl(((ULONG *)hh[symtab_shndx]->data)[ELF_R_SYM(rel->info)]);
531 D(bug("[ELF2HUNK] Processing %d symbol %s\n", (int)shindex, symname));
533 switch (shindex)
536 case SHN_UNDEF:
537 if (ELF_R_TYPE(rel->info) != 0) {
538 bug("[ELF2HUNK] SHN_UNDEF symbol '%s', type %d unsupported\n", symname, (int)ELF_R_TYPE(rel->info));
539 set_error(EINVAL);
540 return 0;
542 break;
544 case SHN_COMMON:
545 bug("[ELF2HUNK] SHN_COMMON symbol '%s' unsupported\n", symname);
546 set_error(EINVAL);
548 return 0;
550 case SHN_ABS:
551 hunk = ~0; value = sym.value;
552 break;
554 default:
555 hunk = shindex;
556 value = sym.value;
557 break;
560 switch (ELF_R_TYPE(rel->info))
562 case R_68K_32:
563 value += rel->addend;
564 break;
566 case R_68K_PC32:
567 value += rel->addend - offset;
568 break;
570 case R_68K_PC16:
571 bug("[ELF2HUNK] Unsupported relocation type R_68K_PC16\n");
572 set_error(EINVAL);
573 return 0;
574 break;
576 case R_68k_NONE:
577 break;
579 default:
580 bug("[ELF2HUNK] Unrecognized relocation type %d %d\n", (int)i, (int)ELF_R_TYPE(rel->info));
581 set_error(EINVAL);
582 return 0;
585 D(bug("[ELF2HUNK] Hunk %d, offset 0x%x: base 0x%x\n", (int)hunk, (int)offset, (int)value));
586 *(ULONG *)(h->data + offset) = htonl(value + ntohl(*(ULONG *)(h->data + offset)));
587 if (hunk == ~0) {
588 h->relocs--;
589 continue;
591 hrel->shid = hunk;
592 hrel->offset = offset;
593 hrel->symbol = symname;
594 hrel++;
597 return 1;
600 int reloc_cmp(const void *a, const void *b)
602 const struct hunkreloc *ha = a, *hb = b;
604 if (ha->shid != hb->shid)
605 return hb->shid - ha->shid;
606 return hb->offset - ha->offset;
609 static int wlong(int fd, ULONG val)
611 val = htonl(val);
612 return write(fd, &val, sizeof(val));
615 int sym_dump(int hunk_fd, struct sheader *sh, struct hunkheader **hh, int shid, int symtabndx)
617 int i, err, syms;
618 struct symbol *sym = hh[symtabndx]->data;
619 struct sheader *symtab = &sh[symtabndx];
621 syms = symtab->size / sizeof(struct symbol);
623 if (syms == 0)
624 return 1;
626 wlong(hunk_fd, HUNK_SYMBOL);
627 wlong(hunk_fd, syms);
629 /* Dump symbols for this hunk */
630 for (i = 0; i < syms ; i++) {
631 struct symbol s;
632 const char *name;
633 int lsize;
635 s = sym[i];
636 sym_fixup(&s);
638 if (s.shindex != shid)
639 continue;
641 name = (const char *)(hh[symtab->link]->data + s.name);
642 D(bug("\t0x%08x: %s\n", (int)s.value, name));
643 lsize = (strlen(name) + 4) / 4;
644 wlong(hunk_fd, lsize);
645 err = write(hunk_fd, name, lsize * 4);
646 if (err < 0)
647 return 0;
648 wlong(hunk_fd, s.value);
650 wlong(hunk_fd, 0);
652 return 1;
655 static void reloc_dump(int hunk_fd, struct hunkheader **hh, int h)
657 int i;
659 if (hh[h]->relocs == 0)
660 return;
662 /* Sort the relocations by reference hunk id */
663 qsort(hh[h]->reloc, hh[h]->relocs, sizeof(hh[h]->reloc[0]), reloc_cmp);
665 wlong(hunk_fd, HUNK_RELOC32);
666 D(bug("\tHUNK_RELOC32: %d relocations\n", (int)hh[h]->relocs));
668 for (i = 0; i < hh[h]->relocs; ) {
669 int count;
670 int shid = hh[h]->reloc[i].shid;
671 for (count = i; count < hh[h]->relocs; count++)
672 if (hh[h]->reloc[count].shid != shid)
673 break;
674 count -= i;
675 wlong(hunk_fd, count);
676 D(bug("\t %d relocations relative to Hunk %d\n", count, hh[shid]->hunk));
677 /* Convert from ELF hunk ID to AOS hunk ID */
678 wlong(hunk_fd, hh[shid]->hunk);
679 for (; count > 0; i++, count--) {
680 D(bug("\t\t%d: 0x%08x %s\n", i, (int)hh[h]->reloc[i].offset, hh[h]->reloc[i].symbol));
681 wlong(hunk_fd, hh[h]->reloc[i].offset);
684 wlong(hunk_fd, 0);
687 static int copy_to(int in, int out)
689 static char buff[64*1024];
690 int len, err = 0;
692 do {
693 len = read(in, buff, sizeof(buff));
694 if (len < 0) {
695 perror("Can't read from input file\n");
696 err = len;
698 if (len == 0)
699 break;
700 } while ((err = write(out, buff, len)) == len);
702 if (err < 0) {
703 perror("Can't write to output file\n");
704 return -errno;
707 return 0;
710 int elf2hunk(int file, int hunk_fd, const char *libname, int flags)
712 const __attribute__((unused)) char *names[3]={ "CODE", "DATA", "BSS" };
713 struct hunkheader **hh;
714 struct elfheader eh;
715 struct sheader *sh;
716 char *strtab = NULL;
717 int symtab_shndx = -1;
718 int err;
719 ULONG i;
720 BOOL exec_hunk_seen __attribute__ ((unused)) = FALSE;
721 ULONG int_shnum;
722 int hunks = 0;
724 /* load and validate ELF header */
725 D(bug("Load header\n"));
726 if ((flags & F_NOCONVERT) || !load_header(file, &eh)) {
727 /* If it's not an ELF, just copy it.
729 * This simplifies a number of mmakefiles
730 * for the m68k-amiga boot and ISO creation
732 lseek(file, 0, SEEK_SET);
733 return (copy_to(file, hunk_fd) == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
736 D(bug("Read SHNum\n"));
737 int_shnum = read_shnum(file, &eh);
738 if (!int_shnum)
739 return EXIT_FAILURE;
741 /* load section headers */
742 D(bug("Load %d Section Headers @0x%08x\n", int_shnum, (int)eh.shoff));
743 if (!(sh = load_block(file, eh.shoff, int_shnum * eh.shentsize)))
744 return EXIT_FAILURE;
746 sh_fixup(sh, int_shnum);
748 /* Looks like we have a valid executable. Generate a
749 * HUNK header set. Not all may be filled in.
751 hh = calloc(sizeof(*hh), int_shnum);
753 /* Look for the string table */
754 D(bug("Look for string table\n"));
755 for (i = 0; i < int_shnum; i++) {
756 if (sh[i].type == SHT_STRTAB) {
757 strtab = load_block(file, sh[i].offset, sh[i].size);
758 break;
762 /* Iterate over the section headers in order to do some stuff... */
763 D(bug("Look for symbol tables\n"));
764 for (i = 0; i < int_shnum; i++)
767 Load the symbol and string table(s).
769 NOTICE: the ELF standard, at the moment (Nov 2002) explicitely states
770 that only one symbol table per file is allowed. However, it
771 also states that this may change in future... we already handle it.
773 D(bug("sh[%d].type = 0x%08x, .offset = 0x%08x, .size = 0x%08x\n",
774 (int)i, (int)sh[i].type, (int)sh[i].offset, (int)sh[i].size));
775 if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB || sh[i].type == SHT_SYMTAB_SHNDX)
777 hh[i] = calloc(sizeof(struct hunkheader), 1);
778 hh[i]->type = (sh[i].type == SHT_SYMTAB) ? HUNK_SYMBOL : 0;
779 hh[i]->memflags = 0;
780 hh[i]->hunk = -1;
781 hh[i]->data = load_block(file, sh[i].offset, sh[i].size);
782 if (!hh[i]->data)
783 goto error;
785 if (sh[i].type == SHT_SYMTAB_SHNDX) {
786 if (symtab_shndx == -1)
787 symtab_shndx = i;
788 else
789 D(bug("[ELF2HUNK] file contains multiple symtab shndx tables. only using the first one\n"));
792 else
793 /* Load the section in memory if needed, and make an hunk out of it */
794 if (sh[i].flags & SHF_ALLOC && sh[i].size > 0)
796 hh[i] = calloc(sizeof(struct hunkheader), 1);
797 hh[i]->size = sh[i].size;
798 hh[i]->hunk = hunks++;
800 if (sh[i].type == SHT_NOBITS) {
801 /* BSS area */
802 hh[i]->type = HUNK_BSS;
803 hh[i]->memflags = 0;
804 hh[i]->data = NULL;
805 } else {
806 if (sh[i].flags & SHF_EXECINSTR) {
807 hh[i]->type = HUNK_CODE;
808 exec_hunk_seen = TRUE;
809 } else {
810 hh[i]->type = HUNK_DATA;
812 hh[i]->data = load_block(file, sh[i].offset, sh[i].size);
815 if (strtab) {
816 const char *nameext;
818 D(bug("section %s\n", strtab + sh[i].name));
819 nameext = strrchr(strtab + sh[i].name, '.');
820 if (nameext) {
821 if (strcmp(nameext, ".MEMF_CHIP")==0) {
822 hh[i]->memflags |= MEMF_CHIP;
823 } else if (strcmp(nameext, ".MEMF_LOCAL")==0) {
824 hh[i]->memflags |= MEMF_LOCAL;
825 } else if (strcmp(nameext, ".MEMF_KICK")==0) {
826 hh[i]->memflags |= MEMF_KICK;
827 } else if (strcmp(nameext, ".MEMF_FAST")==0) {
828 hh[i]->memflags |= MEMF_FAST;
835 /* Relocate the sections */
836 D(bug("Convert relocation tables\n"));
837 for (i = 0; i < int_shnum; i++)
839 /* Does this relocation section refer to a hunk? If so, addr must be != 0 */
840 if ((sh[i].type == AROS_ELF_REL)
841 && hh[sh[i].info]
842 && hh[sh[i].info]->data)
844 void *reloc = load_block(file, sh[i].offset, sh[i].size);
846 if (!relocate(&eh, sh, i, symtab_shndx, reloc, hh))
847 return EXIT_FAILURE;
849 free(reloc);
853 D(bug("HUNK_HEADER: \"%s\", hunks=%d, first=%d, last=%d\n", libname, hunks, 0, hunks-1));
855 wlong(hunk_fd, HUNK_HEADER);
856 if (libname == NULL) {
857 wlong(hunk_fd, 0); /* No name */
858 } else {
859 int lsize = (strlen(libname) + 4) / 4;
860 wlong(hunk_fd, lsize);
861 err = write(hunk_fd, libname, lsize * 4);
862 if (err < 0)
863 return EXIT_FAILURE;
865 wlong(hunk_fd, hunks);
866 wlong(hunk_fd, 0); /* First hunk is #0 */
867 wlong(hunk_fd, hunks - 1); /* Last hunk is hunks-1 */
869 /* Write all allocatable hunk sizes */
870 for (i = 0; i < int_shnum; i++) {
871 ULONG count;
873 if (hh[i]==NULL || hh[i]->hunk < 0)
874 continue;
876 count = (hh[i]->size + 4) / 4;
877 switch (hh[i]->memflags) {
878 case MEMF_CHIP:
879 count |= HUNKF_CHIP;
880 break;
881 case MEMF_FAST:
882 count |= HUNKF_FAST;
883 break;
884 case 0:
885 break;
886 default:
887 count |= HUNKF_MEMFLAGS;
888 break;
891 D(bug("\tHunk #%d, %s, lsize=%d\n", hh[i]->hunk, names[hh[i]->type - HUNK_CODE], (int)(hh[i]->size+4)/4));
892 wlong(hunk_fd, count);
894 if ((count & HUNKF_MEMFLAGS) == HUNKF_MEMFLAGS)
895 wlong(hunk_fd, hh[i]->memflags | MEMF_PUBLIC | MEMF_CLEAR);
898 /* Write all hunks */
899 for (i = hunks = 0; i < int_shnum; i++) {
900 int s;
902 if (hh[i]==NULL || hh[i]->hunk < 0)
903 continue;
905 wlong(hunk_fd, hh[i]->type);
906 wlong(hunk_fd, (hh[i]->size + 4) / 4);
908 switch (hh[i]->type) {
909 case HUNK_BSS:
910 D(bug("HUNK_BSS: %d longs\n", (int)((hh[i]->size + 4) / 4)));
911 if (0) {
912 for (s = 0; s < int_shnum; s++) {
913 if (hh[s] && hh[s]->type == HUNK_SYMBOL)
914 sym_dump(hunk_fd, sh, hh, i, s);
917 wlong(hunk_fd, HUNK_END);
918 hunks++;
919 break;
920 case HUNK_CODE:
921 case HUNK_DATA:
922 D(bug("#%d HUNK_%s: %d longs\n", hh[i]->hunk, hh[i]->type == HUNK_CODE ? "CODE" : "DATA", (int)((hh[i]->size + 4) / 4)));
923 err = write(hunk_fd, hh[i]->data, ((hh[i]->size + 4)/4)*4);
924 if (err < 0)
925 return EXIT_FAILURE;
926 if (0) {
927 for (s = 0; s < int_shnum; s++) {
928 if (hh[s] && hh[s]->type == HUNK_SYMBOL)
929 sym_dump(hunk_fd, sh, hh, i, s);
932 reloc_dump(hunk_fd, hh, i);
933 wlong(hunk_fd, HUNK_END);
934 D(bug("\tHUNK_END\n"));
935 break;
936 default:
937 D(bug("Unsupported allocatable hunk type %d\n", (int)hh[i]->type));
938 return EXIT_FAILURE;
942 /* Free all blocks */
943 for (i = 0; i < int_shnum; i++) {
944 if (hh[i]) {
945 if (hh[i]->data)
946 free(hh[i]->data);
947 if (hh[i]->reloc)
948 free(hh[i]->reloc);
949 free(hh[i]);
952 free(hh);
953 free(sh);
955 if (strtab)
956 free(strtab);
958 D(bug("All good, all done.\n"));
959 return EXIT_SUCCESS;
961 error:
962 return EXIT_FAILURE;
965 static int copy(const char *src, const char *dst, int flags);
967 static int copy_dir(const char *src, const char *dst, int flags)
969 DIR *sdir;
970 struct dirent *de;
971 char spath[PATH_MAX], dpath[PATH_MAX];
972 char *sp, *dp;
973 int sleft, dleft;
974 int err = EXIT_SUCCESS;
976 sdir = opendir(src);
977 if (sdir == NULL) {
978 perror(src);
979 return EXIT_FAILURE;
982 snprintf(spath, sizeof(spath), "%s/", src);
983 spath[sizeof(spath)-1] = 0;
984 sp = &spath[strlen(spath)];
985 sleft = &spath[sizeof(spath)-1] - sp;
987 snprintf(dpath, sizeof(dpath), "%s/", dst);
988 dpath[sizeof(dpath)-1] = 0;
989 dp = &dpath[strlen(dpath)];
990 dleft = &dpath[sizeof(dpath)-1] - dp;
992 while ((de = readdir(sdir)) != NULL) {
993 int eflags = 0;
995 if ((strcmp(de->d_name, ".") == 0) ||
996 (strcmp(de->d_name, "..") == 0))
997 continue;
999 /* Don't convert anything in a Development directory */
1000 if (strcasecmp(de->d_name, "Development") == 0)
1001 eflags |= F_NOCONVERT;
1003 strncpy(sp, de->d_name, sleft);
1004 sp[sleft-1] = 0;
1005 strncpy(dp, de->d_name, dleft);
1006 dp[dleft-1] = 0;
1007 err = copy(spath, dpath, flags | eflags);
1008 if (err != EXIT_SUCCESS)
1009 break;
1012 closedir(sdir);
1014 return err;
1017 static int copy(const char *src, const char *dst, int flags)
1019 int src_fd, hunk_fd;
1020 struct stat st;
1021 int mode, ret;
1023 if (flags & F_VERBOSE)
1024 printf("%s ->\n %s\n", src, dst);
1026 if (stat(src, &st) >= 0) {
1027 mode = st.st_mode;
1028 } else {
1029 mode = 0755;
1032 if (S_ISDIR(mode)) {
1033 unlink(dst);
1034 mkdir(dst, mode);
1035 return copy_dir(src, dst, flags);
1038 src_fd = open(src, O_RDONLY);
1039 if (src_fd < 0) {
1040 perror(src);
1041 return EXIT_FAILURE;
1044 if (strcmp(dst,"-") == 0)
1045 hunk_fd = 1; /* stdout */
1046 else {
1047 unlink(dst);
1048 hunk_fd = open(dst, O_RDWR | O_CREAT | O_TRUNC, mode);
1050 if (hunk_fd < 0) {
1051 perror(dst);
1052 return EXIT_FAILURE;
1055 ret = elf2hunk(src_fd, hunk_fd, NULL, flags);
1056 if (ret != 0)
1057 perror(src);
1059 close(src_fd);
1060 if (hunk_fd != 1)
1061 close(hunk_fd);
1063 return ret;
1066 int main(int argc, char **argv)
1068 int flags = 0;
1070 if (argc == 4 && strcmp(argv[1],"-v") == 0) {
1071 flags |= F_VERBOSE;
1072 argc--;
1073 argv++;
1076 if (argc != 3) {
1077 fprintf(stderr, "Usage:\n%s file.elf file.hunk\n", argv[0]);
1078 fprintf(stderr, "%s src-dir dest-dir\n", argv[0]);
1079 return EXIT_FAILURE;
1082 return copy(argv[1], argv[2], flags);