?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix arm compile
[AROS.git] / rom / dos / internalloadseg_elf.c
blobf0c2e5c8ff24d265f0f27b0c59da7d4757650cff
1 /*
2 Copyright © 1995-2013, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Code to dynamically load ELF executables
6 Lang: english
7 */
8
9 #define DATTR(x)
10
11 #include <aros/asmcall.h>
12 #include <aros/debug.h>
13 #include <aros/macros.h>
14 #include <exec/memory.h>
15 #include <dos/elf.h>
16 #include <dos/dosasl.h>
17 #include <libraries/debug.h>
18 #include <resources/processor.h>
19 #include <proto/dos.h>
20 #include <proto/arossupport.h>
21 #include <proto/debug.h>
22 #include <proto/exec.h>
23
24 #include <string.h>
25 #include <stddef.h>
26
27 #include "internalloadseg.h"
28 #include "dos_intern.h"
29 #include "include/loadseg.h"
30
31 struct hunk
32 {
33 ULONG size;
34 BPTR next;
35 char data[0];
36 } __attribute__((packed));
37
38 #define BPTR2HUNK(bptr) ((struct hunk *)((void *)bptr - offsetof(struct hunk, next)))
39 #define HUNK2BPTR(hunk) MKBADDR(&hunk->next)
40
41 #define LOADSEG_SMALL_READ 2048 /* Size adjusted by profiling in Callgrind */
42
43 /* [S]mall [R]eads [Buffer]
44 *
45 * Due to a fact that Seek flushes buffers, FRead that is used to do small reads
46 * cannot use the buffer. The problem is visible with C++ executables that
47 * have a big number of small sections and thus do many (in tens of thousands
48 * for Odyssey) very small reads.
49 *
50 * */
51 struct SRBuffer
52 {
53 ULONG srb_FileOffset;
54 APTR srb_Buffer;
55 };
56
57 static int elf_read_block
58 (
59 BPTR file,
60 ULONG offset,
61 APTR buffer,
62 ULONG size,
63 SIPTR *funcarray,
64 struct SRBuffer *srb,
65 struct DosLibrary *DOSBase
66 )
67 {
68 D(bug("[ELF Loader] elf_read_block (offset=%d, size=%d)\n", offset, size));
69
70 if (size <= LOADSEG_SMALL_READ && (offset >= srb->srb_FileOffset) &&
71 ((offset + size) <= (srb->srb_FileOffset + LOADSEG_SMALL_READ)) &&
72 srb->srb_Buffer != NULL)
73 {
74 CopyMem(srb->srb_Buffer + (offset - srb->srb_FileOffset), buffer, size);
75 return 0;
76 }
77 else
78 {
79 if (ilsSeek(file, offset, OFFSET_BEGINNING) < 0)
80 return 1;
81
82 if (size <= LOADSEG_SMALL_READ)
83 {
84 if (srb->srb_Buffer == NULL)
85 srb->srb_Buffer = AllocMem(LOADSEG_SMALL_READ, MEMF_ANY);
86
87 srb->srb_FileOffset = offset;
88
89 /* Fill the buffer */
90 read_block(file, srb->srb_Buffer, LOADSEG_SMALL_READ, funcarray, DOSBase);
91 /* Re-read, now srb will be used */
92 return elf_read_block(file, offset, buffer, size, funcarray, srb, DOSBase);
93 }
94 else
95 {
96 return read_block(file, buffer, size, funcarray, DOSBase);
97 }
98 }
99 }
100
101 static void *load_block
102 (
103 BPTR file,
104 ULONG offset,
105 ULONG size,
106 SIPTR *funcarray,
107 struct SRBuffer *srb,
108 struct DosLibrary *DOSBase
109 )
110 {
111 D(bug("[ELF Loader] Load Block\n"));
112 D(bug("[ELF Loader] (size=%d)\n",size));
113 D(bug("[ELF Loader] (funcarray=0x%x)\n",funcarray));
114 D(bug("[ELF Loader] (funcarray[1]=0x%x)\n",funcarray[1]));
115 void *block = ilsAllocMem(size, MEMF_ANY);
116 if (block)
117 {
118 if (!elf_read_block(file, offset, block, size, funcarray, srb, DOSBase))
119 return block;
120
121 ilsFreeMem(block, size);
122 }
123 else
124 SetIoErr(ERROR_NO_FREE_STORE);
125
126 return NULL;
127 }
128
129 static ULONG read_shnum(BPTR file, struct elfheader *eh, SIPTR *funcarray, struct SRBuffer *srb, struct DosLibrary *DOSBase)
130 {
131 ULONG shnum = eh->shnum;
132
133 /* the ELF header only uses 16 bits to store the count of section headers,
134 * so it can't handle more than 65535 headers. if the count is 0, and an
135 * offset is defined, then the real count can be found in the first
136 * section header (which always exists).
137 *
138 * similarly, if the string table index is SHN_XINDEX, then the actual
139 * index is found in the first section header also.
140 *
141 * see the System V ABI 2001-04-24 draft for more details.
142 */
143 if (eh->shnum == 0)
144 {
145 struct sheader sh;
146
147 if (eh->shoff == 0) {
148 D(bug("[ELF Loader] No section header\n"));
149 SetIoErr(ERROR_NOT_EXECUTABLE);
150 return 0;
151 }
152
153 if (elf_read_block(file, eh->shoff, &sh, sizeof(sh), funcarray, srb, DOSBase))
154 return 0;
155
156 /* wider section header count is in the size field */
157 shnum = sh.size;
158
159 /* sanity, if they're still invalid then this isn't elf */
160 if (shnum == 0) {
161 D(bug("[ELF Loader] Empty section header\n"));
162 SetIoErr(ERROR_NOT_EXECUTABLE);
163 }
164 }
165
166 return shnum;
167 }
168
169 static int load_header(BPTR file, struct elfheader *eh, SIPTR *funcarray, struct SRBuffer *srb, struct DosLibrary *DOSBase)
170 {
171 if (elf_read_block(file, 0, eh, sizeof(struct elfheader), funcarray, srb, DOSBase))
172 return 0;
173
174 if (eh->ident[0] != 0x7f || eh->ident[1] != 'E' ||
175 eh->ident[2] != 'L' || eh->ident[3] != 'F') {
176 D(bug("[ELF Loader] Not an ELF object\n"));
177 SetIoErr(ERROR_NOT_EXECUTABLE);
178 return 0;
179 }
180 D(bug("[ELF Loader] ELF object\n"));
181
182 /* WANT_CLASS should be defined for your target */
183 if (eh->ident[EI_CLASS] != AROS_ELF_CLASS ||
184 eh->ident[EI_VERSION] != EV_CURRENT ||
185 eh->type != ET_REL ||
186 eh->ident[EI_DATA] != AROS_ELF_DATA ||
187 eh->machine != AROS_ELF_MACHINE)
188 {
189 D(bug("[ELF Loader] Object is of wrong type\n"));
190 D(bug("[ELF Loader] EI_CLASS is %d - should be %d\n", eh->ident[EI_CLASS] , AROS_ELF_CLASS ));
191 D(bug("[ELF Loader] EI_VERSION is %d - should be %d\n", eh->ident[EI_VERSION], EV_CURRENT ));
192 D(bug("[ELF Loader] type is %d - should be %d\n", eh->type , ET_REL ));
193 D(bug("[ELF Loader] EI_DATA is %d - should be %d\n", eh->ident[EI_DATA] , AROS_ELF_DATA ));
194 D(bug("[ELF Loader] machine is %d - should be %d\n", eh->machine , AROS_ELF_MACHINE));
195
196 SetIoErr(ERROR_NOT_EXECUTABLE);
197 return 0;
198 }
199
200 return 1;
201 }
202
203 static int load_hunk
204 (
205 BPTR file,
206 BPTR **next_hunk_ptr,
207 struct sheader *sh,
208 CONST_STRPTR strtab,
209 SIPTR *funcarray,
210 BOOL do_align,
211 struct SRBuffer *srb,
212 struct DosLibrary *DOSBase
213 )
214 {
215 struct hunk *hunk;
216 ULONG hunk_size;
217 ULONG memflags = 0;
218
219 if (!sh->size)
220 return 1;
221
222 /* The size of the hunk is the size of the section, plus
223 the size of the hunk structure, plus the size of the alignment (if necessary)*/
224 hunk_size = sh->size + sizeof(struct hunk);
225
226 if (do_align)
227 {
228 hunk_size += sh->addralign;
229
230 /* Also create space for a trampoline, if necessary */
231 if (sh->flags & SHF_EXECINSTR)
232 hunk_size += sizeof(struct FullJumpVec);
233 }
234
235 if (strtab) {
236 CONST_STRPTR nameext;
237
238 nameext = strrchr(strtab + sh->name, '.');
239 if (nameext) {
240 if (strcmp(nameext, ".MEMF_CHIP")==0) {
241 memflags |= MEMF_CHIP;
242 } else if (strcmp(nameext, ".MEMF_LOCAL")==0) {
243 memflags |= MEMF_LOCAL;
244 } else if (strcmp(nameext, ".MEMF_KICK")==0) {
245 memflags |= MEMF_KICK;
246 } else if (strcmp(nameext, ".MEMF_FAST")==0) {
247 memflags |= MEMF_FAST;
248 } else if (strcmp(nameext, ".MEMF_PUBLIC")==0) {
249 memflags |= MEMF_PUBLIC;
250 }
251 }
252 }
253
254 hunk = ilsAllocMem(hunk_size, memflags | MEMF_PUBLIC | (sh->type == SHT_NOBITS ? MEMF_CLEAR : 0));
255 if (hunk)
256 {
257 hunk->next = 0;
258 hunk->size = hunk_size;
259
260 /* In case we are required to honour alignment, and If this section contains
261 executable code, create a trampoline to its beginning, so that even if the
262 alignment requirements make the actual code go much after the end of the
263 hunk structure, the code can still be reached in the usual way. */
264 if (do_align)
265 {
266 if (sh->flags & SHF_EXECINSTR)
267 {
268 sh->addr = (char *)AROS_ROUNDUP2
269 (
270 (IPTR)hunk->data + sizeof(struct FullJumpVec), sh->addralign
271 );
272 __AROS_SET_FULLJMP((struct FullJumpVec *)hunk->data, sh->addr);
273 }
274 else
275 sh->addr = (char *)AROS_ROUNDUP2((IPTR)hunk->data, sh->addralign);
276 }
277 else
278 sh->addr = hunk->data;
279
280 /* Link the previous one with the new one */
281 BPTR2HUNK(*next_hunk_ptr)->next = HUNK2BPTR(hunk);
282
283 D(bug("[dos] hunk @ %p, size=%08x, addr @ %p\n", hunk, hunk->size, sh->addr));
284
285 /* Update the pointer to the previous one, which is now the current one */
286 *next_hunk_ptr = &hunk->next;
287
288 if (sh->type != SHT_NOBITS)
289 return !elf_read_block(file, sh->offset, sh->addr, sh->size, funcarray, srb, DOSBase);
290
291 return 1;
292
293 }
294
295 SetIoErr(ERROR_NO_FREE_STORE);
296
297 return 0;
298 }
299
300 static int relocate
301 (
302 struct elfheader *eh,
303 struct sheader *sh,
304 ULONG shrel_idx,
305 struct sheader *symtab_shndx,
306 struct DosLibrary *DOSBase
307 )
308 {
309 struct sheader *shrel = &sh[shrel_idx];
310 struct sheader *shsymtab = &sh[shrel->link];
311 struct sheader *toreloc = &sh[shrel->info];
312
313 struct symbol *symtab = (struct symbol *)shsymtab->addr;
314 struct relo *rel = (struct relo *)shrel->addr;
315
316 /*
317 * Ignore relocs if the target section has no allocation. that can happen
318 * eg. with a .debug PROGBITS and a .rel.debug section
319 */
320 if (!(toreloc->flags & SHF_ALLOC))
321 return 1;
322
323 ULONG numrel = shrel->size / shrel->entsize;
324 ULONG i;
325
326 for (i=0; i<numrel; i++, rel++)
327 {
328 struct symbol *sym;
329 ULONG *p;
330 IPTR s;
331 ULONG shindex;
332
333 #ifdef __arm__
334 /*
335 * R_ARM_V4BX are actually special marks for the linker.
336 * They even never have a target (shindex == SHN_UNDEF),
337 * so we simply ignore them before doing any checks.
338 */
339 if (ELF_R_TYPE(rel->info) == R_ARM_V4BX)
340 continue;
341 #endif
342
343 sym = &symtab[ELF_R_SYM(rel->info)];
344 p = toreloc->addr + rel->offset;
345
346 if (sym->shindex != SHN_XINDEX)
347 shindex = sym->shindex;
348
349 else {
350 if (symtab_shndx == NULL) {
351 D(bug("[ELF Loader] got symbol with shndx 0xfff, but there's no symtab shndx table\n"));
352 SetIoErr(ERROR_BAD_HUNK);
353 return 0;
354 }
355 shindex = ((ULONG *)symtab_shndx->addr)[ELF_R_SYM(rel->info)];
356 }
357
358 DB2(bug("[ELF Loader] Processing symbol %s\n", sh[shsymtab->link].addr + sym->name));
359
360 switch (shindex)
361 {
362
363 case SHN_COMMON:
364 D(bug("[ELF Loader] COMMON symbol '%s'\n",
365 (STRPTR)sh[shsymtab->link].addr + sym->name));
366 SetIoErr(ERROR_BAD_HUNK);
367
368 return 0;
369
370 case SHN_ABS:
371 s = sym->value;
372 break;
373
374 case SHN_UNDEF:
375 if (ELF_R_TYPE(rel->info) != 0) {
376 D(bug("[ELF Loader] Undefined symbol '%s'\n",
377 (STRPTR)sh[shsymtab->link].addr + sym->name));
378 SetIoErr(ERROR_BAD_HUNK);
379 return 0;
380 }
381 /* fall through */
382
383 default:
384 s = (IPTR)sh[shindex].addr + sym->value;
385 }
386
387 switch (ELF_R_TYPE(rel->info))
388 {
389 #if defined(__i386__)
390
391 case R_386_32: /* 32bit absolute */
392 *p += s;
393 break;
394
395 case R_386_PC32: /* 32bit PC relative */
396 *p += s - (ULONG)p;
397 break;
398
399 case R_386_NONE:
400 break;
401
402 #elif defined(__x86_64__)
403 case R_X86_64_64: /* 64bit direct/absolute */
404 *(UQUAD *)p = s + rel->addend;
405 break;
406
407 case R_X86_64_PC32: /* PC relative 32 bit signed */
408 *(ULONG *)p = s + rel->addend - (IPTR) p;
409 break;
410
411 case R_X86_64_32:
412 *(ULONG *)p = (UQUAD)s + (UQUAD)rel->addend;
413 break;
414
415 case R_X86_64_32S:
416 *(LONG *)p = (QUAD)s + (QUAD)rel->addend;
417 break;
418
419 case R_X86_64_NONE: /* No reloc */
420 break;
421
422 #elif defined(__mc68000__)
423
424 case R_68K_32:
425 *p = s + rel->addend;
426 break;
427
428 case R_68K_16:
429 *(UWORD *)p = s + rel->addend;
430 break;
431
432 case R_68K_8:
433 *(UBYTE *)p = s + rel->addend;
434 break;
435
436 case R_68K_PC32:
437 *p = s + rel->addend - (ULONG)p;
438 break;
439
440 case R_68K_PC16:
441 *(UWORD *)p = s + rel->addend - (ULONG)p;
442 break;
443
444 case R_68K_PC8:
445 *(UBYTE *)p = s + rel->addend - (ULONG)p;
446 break;
447
448 case R_68K_NONE:
449 break;
450
451 #elif defined(__ppc__) || defined(__powerpc__)
452
453 case R_PPC_ADDR32:
454 *p = s + rel->addend;
455 break;
456
457 case R_PPC_ADDR16_LO:
458 {
459 unsigned short *c = (unsigned short *) p;
460 *c = (s + rel->addend) & 0xffff;
461 }
462 break;
463
464 case R_PPC_ADDR16_HA:
465 {
466 unsigned short *c = (unsigned short *) p;
467 ULONG temp = s + rel->addend;
468 *c = temp >> 16;
469 if ((temp & 0x8000) != 0)
470 (*c)++;
471 }
472 break;
473
474 case R_PPC_REL16_LO:
475 {
476 unsigned short *c = (unsigned short *) p;
477 *c = (s + rel->addend - (ULONG) p) & 0xffff;
478 }
479 break;
480
481 case R_PPC_REL16_HA:
482 {
483 unsigned short *c = (unsigned short *) p;
484 ULONG temp = s + rel->addend - (ULONG) p;
485 *c = temp >> 16;
486 if ((temp & 0x8000) != 0)
487 (*c)++;
488 }
489 break;
490
491 case R_PPC_REL24:
492 *p &= ~0x3fffffc;
493 *p |= (s + rel->addend - (ULONG) p) & 0x3fffffc;
494 break;
495
496 case R_PPC_REL32:
497 *p = s + rel->addend - (ULONG) p;
498 break;
499
500 case R_PPC_NONE:
501 break;
502
503 #elif defined(__arm__)
504 case R_ARM_CALL:
505 case R_ARM_JUMP24:
506 case R_ARM_PC24:
507 case R_ARM_PREL31:
508 {
509 /* On ARM the 24 bit offset is shifted by 2 to the right */
510 signed long offset = (*p & 0x00ffffff) << 2;
511 /* If highest bit set, make offset negative */
512 if (offset & 0x02000000)
513 offset -= 0x04000000;
514
515 if (offset >= 0x02000000 ||
516 offset <= -0x02000000)
517 {
518 bug("[ELF Loader] Relocation type %d %d out of range!\n", i, ELF_R_TYPE(rel->info));
519 SetIoErr(ERROR_BAD_HUNK);
520 return 0;
521 }
522 offset += s - (ULONG)p;
523
524 offset >>= 2;
525 *p &= 0xff000000;
526 *p |= offset & 0x00ffffff;
527 }
528 break;
529
530 case R_ARM_THM_CALL:
531 case R_ARM_THM_JUMP24:
532 {
533 ULONG upper,lower,sign,j1,j2;
534 LONG offset;
535
536 upper = *((UWORD *)p);
537 lower = *((UWORD *)p+1);
538
539 sign = (upper >> 10) & 1;
540 j1 = (lower >> 13) & 1;
541 j2 = (lower >> 11) & 1;
542
543 offset = (sign << 24) | ((~(j1 ^ sign) & 1) << 23) |
544 ((~(j2 ^ sign) & 1) << 22) |
545 ((upper & 0x03ff) << 12) |
546 ((lower & 0x07ff) << 1);
547
548 if (offset & 0x01000000)
549 offset -= 0x02000000;
550
551 if (offset >= 0x01000000 ||
552 offset <= -0x01000000)
553 {
554 bug("[ELF Loader] Relocation type %d %d out of range!\n", i, ELF_R_TYPE(rel->info));
555 SetIoErr(ERROR_BAD_HUNK);
556 return 0;
557 }
558 offset += s - (ULONG)p;
559
560 sign = (offset >> 24) & 1;
561 j1 = sign ^ (~(offset >> 23) & 1);
562 j2 = sign ^ (~(offset >> 22) & 1);
563
564 *(UWORD *)p = (UWORD)((upper & 0xf800) | (sign << 10) |
565 ((offset >> 12) & 0x03ff));
566 *((UWORD *)p + 1) = (UWORD)((lower & 0xd000) |
567 (j1 << 13) | (j2 << 11) | ((offset >> 1) & 0x07ff));
568
569 }
570 break;
571
572 case R_ARM_THM_MOVW_ABS_NC:
573 case R_ARM_THM_MOVT_ABS:
574 {
575 ULONG upper,lower;
576 LONG offset;
577
578 upper = *((UWORD *)p);
579 lower = *((UWORD *)p+1);
580
581 offset = ((upper & 0x000f) << 12) |
582 ((upper & 0x0400) << 1) |
583 ((lower & 0x7000) >> 4) |
584 (lower & 0x00ff);
585
586 offset = (offset ^ 0x8000) - 0x8000;
587
588 offset += s;
589
590 if (ELF_R_TYPE(rel->info) == R_ARM_THM_MOVT_ABS)
591 offset >>= 16;
592
593 *(UWORD *)p = (UWORD)((upper & 0xfbf0) |
594 ((offset & 0xf000) >> 12) |
595 ((offset & 0x0800) >> 1));
596 *((UWORD *)p + 1) = (UWORD)((lower & 0x8f00) |
597 ((offset & 0x0700)<< 4) |
598 (offset & 0x00ff));
599 }
600 break;
601
602 case R_ARM_MOVW_ABS_NC:
603 case R_ARM_MOVT_ABS:
604 {
605 signed long offset = *p;
606 offset = ((offset & 0xf0000) >> 4) | (offset & 0xfff);
607 offset = (offset ^ 0x8000) - 0x8000;
608
609 offset += s;
610
611 if (ELF_R_TYPE(rel->info) == R_ARM_MOVT_ABS)
612 offset >>= 16;
613
614 *p &= 0xfff0f000;
615 *p |= ((offset & 0xf000) << 4) | (offset & 0x0fff);
616 }
617 break;
618
619 case R_ARM_TARGET2: /* maps to R_ARM_ABS32 under EABI for AROS*/
620 case R_ARM_TARGET1: /* use for constructors/destructors; maps to
621 R_ARM_ABS32 */
622 case R_ARM_ABS32:
623 *p += s;
624 break;
625
626 case R_ARM_NONE:
627 break;
628
629 #else
630 # error Your architecture is not supported
631 #endif
632
633 default:
634 D(bug("[ELF Loader] Unrecognized relocation type %d %d\n", i, ELF_R_TYPE(rel->info)));
635 SetIoErr(ERROR_BAD_HUNK);
636 return 0;
637 }
638 }
639
640 return 1;
641 }
642
643 #ifdef __arm__
644
645 /*
646 * On ARM < v6 all LONG accesses must be LONG-aligned
647 * TODO: This is useful and can be moved to some public include file.
648 */
649 #if (__ARM_ARCH__ > 5)
650
651 #define READLONG_UNALIGNED(src) src
652
653 #else
654
655 static inline ULONG readlong_unaligned(ULONG *src)
656 {
657 ULONG res, tmp;
658
659 asm volatile(
660 "ldrb %0, [%2, #0]\n\t"
661 "ldrb %1, [%2, #1]\n\t"
662 "orr %0, %0, %1, lsl #8\n\t"
663 "ldrb %1, [%2, #2]\n\t"
664 "orr %0, %0, %1, lsl #16\n\t"
665 "ldrb %1, [%2, #3]\n\t"
666 "orr %0, %0, %1, lsl #24"
667 :"=&r"(res), "=&r"(tmp) : "r"(src)
668 );
669
670 return res;
671 }
672
673 #define READLONG_UNALIGNED(src) readlong_unaligned(&src);
674 #endif
675
676 /*
677 * This code parses special .ARM.Attributes section and
678 * extracts system requirements from it. Things like float ABI,
679 * minimum CPU and FPU version are described there.
680 */
681
682 static UBYTE arm_cpus[] =
683 {
684 CPUFAMILY_ARM_3,
685 CPUFAMILY_ARM_4,
686 CPUFAMILY_ARM_4T,
687 CPUFAMILY_ARM_5T,
688 CPUFAMILY_ARM_5TE,
689 CPUFAMILY_ARM_5TEJ,
690 CPUFAMILY_ARM_6,
691 CPUFAMILY_ARM_6,
692 CPUFAMILY_ARM_6, /* 6KZ */
693 CPUFAMILY_ARM_6, /* 6T2 */
694 CPUFAMILY_ARM_6, /* 6K */
695 CPUFAMILY_ARM_7,
696 CPUFAMILY_ARM_6, /* 6-M */
697 CPUFAMILY_ARM_6, /* 6S-M */
698 CPUFAMILY_ARM_7 /* 7E-M */
699 };
700
701 static BOOL ARM_ParseAttrs(UBYTE *data, ULONG len, struct DosLibrary *DOSBase)
702 {
703 struct attrs_section *attrs;
704
705 if (data[0] != ATTR_VERSION_CURRENT)
706 {
707 DATTR(bug("[ELF.ARM] Unknown attributes version: 0x%02\n", data[0]));
708 return FALSE;
709 }
710
711 attrs = (void *)data + 1;
712 while (len > 0)
713 {
714 ULONG attrs_size = READLONG_UNALIGNED(attrs->size);
715
716 if (!strcmp(attrs->vendor, "aeabi"))
717 {
718 struct attrs_subsection *aeabi_attrs = (void *)attrs->vendor + 6;
719 ULONG aeabi_len = attrs_size - 10;
720
721 DATTR(bug("[ELF.ARM] Found aeabi attributes @ 0x%p (length %u)\n", aeabi_attrs, aeabi_len));
722
723 while (aeabi_len > 0)
724 {
725 ULONG aeabi_attrs_size = READLONG_UNALIGNED(aeabi_attrs->size);
726
727 if (aeabi_attrs->tag == Tag_File)
728 {
729 UBYTE *file_subsection = (void *)aeabi_attrs + sizeof(struct attrs_subsection);
730 UBYTE file_len = aeabi_attrs_size - sizeof(struct attrs_subsection);
731
732 DATTR(bug("[ELF.ARM] Found file-wide attributes @ 0x%p (length %u)\n", file_subsection, file_len));
733
734 while (file_len > 0)
735 {
736 UBYTE tag, shift;
737 ULONG val = 0;
738
739 tag = *file_subsection++;
740 file_len--;
741
742 if (file_len == 0)
743 {
744 DATTR(bug("[ELF.ARM] Mailformed attribute tag %d (no data)\n", tag));
745 return FALSE;
746 }
747
748 switch (tag)
749 {
750 case Tag_CPU_raw_name:
751 case Tag_CPU_name:
752 case Tag_compatibility:
753 case Tag_also_compatible_with:
754 case Tag_conformance:
755 /* These two are NULL-terminated strings. Just skip. */
756 while (file_len)
757 {
758 file_len--;
759 if (*file_subsection++ == 0)
760 break;
761 }
762 break;
763
764 default:
765 /* Read ULEB128 value */
766 shift = 0;
767 while (file_len)
768 {
769 UBYTE byte;
770
771 byte = *file_subsection++;
772 file_len--;
773
774 val |= (byte & 0x7F) << shift;
775 if (!(byte & 0x80))
776 break;
777
778 shift += 7;
779 }
780 }
781
782 switch (tag)
783 {
784 case Tag_CPU_arch:
785 DATTR(bug("[ELF.ARM] ARM CPU architecture set to %d\n", val));
786
787 if (val > ELF_CPU_ARMv7EM)
788 {
789 DATTR(bug("[ELF.ARM] Unknown CPU tag value (%d)\n", val));
790 return FALSE;
791 }
792
793 if (arm_cpus[val] > IDosBase(DOSBase)->arm_Arch)
794 {
795 DATTR(bug("[ELF.ARM] CPU Requirements too high (system %d, file %d)\n", IDosBase(DOSBase)->arm_Arch, arm_cpus[val]));
796 return FALSE;
797 }
798 break;
799
800 case Tag_FP_arch:
801 DATTR(bug("[ELF.ARM] ARM FPU architecture set to %d\n", val));
802
803 switch (val)
804 {
805 case ELF_FP_None:
806 break;
807
808 case ELF_FP_v1:
809 case ELF_FP_v2:
810 if (!IDosBase(DOSBase)->arm_VFP)
811 {
812 DATTR(bug("[ELF.ARM] VFP required but missing\n"));
813 return FALSE;
814 }
815 break;
816
817 case ELF_FP_v3:
818 case ELF_FP_v3_Short:
819 if (!IDosBase(DOSBase)->arm_VFP_v3)
820 {
821 DATTR(bug("[ELF.ARM] VFPv3 required but missing\n"));
822 return FALSE;
823 }
824 break;
825
826 default:
827 /* This includes VFPv4 for now */
828 DATTR(bug("[ELF.ARM] VFP %d required -- unsupported\n", val));
829 return FALSE;
830 }
831
832 break;
833 }
834 }
835
836 /* We allow to execute only files which contain attributes section */
837 return TRUE;
838 }
839 aeabi_attrs = (void *)aeabi_attrs + aeabi_attrs_size;
840 aeabi_len -= aeabi_attrs_size;
841 }
842
843 return FALSE;
844 }
845 attrs = (void *)attrs + attrs_size;
846 len -= attrs_size;
847 }
848 return FALSE;
849 }
850
851 #endif
852
853 BPTR InternalLoadSeg_ELF
854 (
855 BPTR file,
856 BPTR table __unused,
857 SIPTR *funcarray,
858 LONG *stack __unused,
859 struct DosLibrary *DOSBase
860 )
861 {
862 struct elfheader eh;
863 struct sheader *sh;
864 struct sheader *symtab_shndx = NULL;
865 struct sheader *strtab = NULL;
866 BPTR hunks = 0;
867 BPTR *next_hunk_ptr = &hunks;
868 ULONG i;
869 BOOL exec_hunk_seen = FALSE;
870 ULONG int_shnum;
871 struct SRBuffer srb;
872 srb.srb_Buffer = NULL;
873
874 /* load and validate ELF header */
875 if (!load_header(file, &eh, funcarray, &srb, DOSBase))
876 return 0;
877
878 int_shnum = read_shnum(file, &eh, funcarray, &srb, DOSBase);
879 if (!int_shnum)
880 return 0;
881
882 /* load section headers */
883 if (!(sh = load_block(file, eh.shoff, int_shnum * eh.shentsize, funcarray, &srb, DOSBase)))
884 return 0;
885
886 #ifdef __arm__
887 for (i = 0; i < int_shnum; i++)
888 {
889 if (sh[i].type == SHT_ARM_ATTRIBUTES)
890 {
891 ULONG len = sh[i].size;
892 UBYTE *data = load_block(file, sh[i].offset, len, funcarray, &srb, DOSBase);
893
894 if (data)
895 {
896 BOOL res = ARM_ParseAttrs(data, len, DOSBase);
897
898 ilsFreeMem(data, len);
899
900 if (!res)
901 {
902 D(bug("[ELF Loader] Can't parse ARM attributes\n"));
903 SetIoErr(ERROR_NOT_EXECUTABLE);
904 goto error;
905 }
906 }
907 }
908 }
909 #endif
910
911 /* Iterate over the section headers in order to do some stuff... */
912 for (i = 0; i < int_shnum; i++)
913 {
914 /*
915 Load the symbol and string table(s).
916
917 NOTICE: the ELF standard, at the moment (Nov 2002) explicitely states
918 that only one symbol table per file is allowed. However, it
919 also states that this may change in future... we already handle it.
920 */
921 if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB || sh[i].type == SHT_SYMTAB_SHNDX)
922 {
923 sh[i].addr = load_block(file, sh[i].offset, sh[i].size, funcarray, &srb, DOSBase);
924 if (!sh[i].addr)
925 goto error;
926
927 if (sh[i].type == SHT_STRTAB) {
928 if (strtab == NULL) {
929 strtab = &sh[i];
930 } else {
931 D(bug("[ELF Loader] file contains multiple strtab tables. only using the first one\n"));
932 }
933 }
934
935 if (sh[i].type == SHT_SYMTAB_SHNDX) {
936 if (symtab_shndx == NULL)
937 symtab_shndx = &sh[i];
938 else
939 D(bug("[ELF Loader] file contains multiple symtab shndx tables. only using the first one\n"));
940 }
941 }
942 }
943
944 /* Now that we have the string and symbol tables loaded,
945 * load the rest of the hunks.
946 */
947 for (i = 0; i < int_shnum; i++)
948 {
949 /* Skip the already loaded hunks */
950 if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB || sh[i].type == SHT_SYMTAB_SHNDX)
951 continue;
952
953 /* Load the section in memory if needed, and make a hunk out of it */
954 if (sh[i].flags & SHF_ALLOC)
955 {
956 if (sh[i].size)
957 {
958 /* Only allow alignment if this is an executable hunk
959 or if an executable hunk has been loaded already,
960 so to avoid the situation in which a data hunk has its
961 content displaced from the hunk's header in case it's the
962 first hunk (this happens with Keymaps, for instance). */
963 if (sh[i].flags & SHF_EXECINSTR)
964 exec_hunk_seen = TRUE;
965
966 if (!load_hunk(file, &next_hunk_ptr, &sh[i], strtab ? strtab->addr : NULL, funcarray, exec_hunk_seen, &srb, DOSBase))
967 goto error;
968 }
969 }
970 }
971
972 /* Relocate the sections */
973 for (i = 0; i < int_shnum; i++)
974 {
975 /* Does this relocation section refer to a hunk? If so, addr must be != 0 */
976 if ((sh[i].type == AROS_ELF_REL) && sh[sh[i].info].addr)
977 {
978 sh[i].addr = load_block(file, sh[i].offset, sh[i].size, funcarray, &srb, DOSBase);
979 if (!sh[i].addr || !relocate(&eh, sh, i, symtab_shndx, DOSBase))
980 goto error;
981
982 ilsFreeMem(sh[i].addr, sh[i].size);
983 sh[i].addr = NULL;
984 }
985 }
986
987 /* Everything is loaded now. Register the module at kernel.resource */
988 register_elf(file, hunks, &eh, sh, DOSBase);
989 goto end;
990
991 error:
992
993 /* There were some errors, deallocate The hunks */
994
995 InternalUnLoadSeg(hunks, (VOID_FUNC)funcarray[2]);
996 hunks = 0;
997
998 end:
999
1000 /*
1001 * Clear the caches to let the CPU see the new data and instructions.
1002 * We check for SysBase's lib_Version, since this code is also built
1003 * as linklib for AmigaOS version of AROS bootstrap, and it can be
1004 * running on AOS 1.3 or lower.
1005 */
1006 if (SysBase->LibNode.lib_Version >= 36)
1007 {
1008 BPTR curr = hunks;
1009
1010 while (curr)
1011 {
1012 struct hunk *hunk = BPTR2HUNK(BADDR(curr));
1013
1014 CacheClearE(hunk->data, hunk->size, CACRF_ClearD | CACRF_ClearI);
1015
1016 curr = hunk->next;
1017 }
1018 }
1019
1020 /* deallocate the symbol tables */
1021 for (i = 0; i < int_shnum; i++)
1022 {
1023 if (((sh[i].type == SHT_SYMTAB) || (sh[i].type == SHT_STRTAB)) && (sh[i].addr != NULL))
1024 ilsFreeMem(sh[i].addr, sh[i].size);
1025 }
1026
1027 /* Free the section headers */
1028 ilsFreeMem(sh, int_shnum * eh.shentsize);
1029
1030 if (srb.srb_Buffer) FreeMem(srb.srb_Buffer, LOADSEG_SMALL_READ);
1031
1032 return hunks;
1033 }
Mirror of AROS' svn.