tools/elf2hunk/elf2hunk.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define PROTOTYPES
   7 #define HAVE_STDARG_H
   8
   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>
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23
  24 #define F_VERBOSE       (1 << 0)
  25 #define F_NOCONVERT     (1 << 1)
  26
  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;
  40
  41 #if !defined(FALSE)&&!defined(TRUE)
  42 #define FALSE 0
  43 #define TRUE (!FALSE)
  44 #endif
  45
  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)
  63
  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)
  68
  69
  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
  77
  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
  85
  86 #define ET_REL          1
  87 #define ET_EXEC         2
  88
  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 */
  94
  95 #define R_386_NONE      0
  96 #define R_386_32        1
  97 #define R_386_PC32      2
  98
  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
 105
 106 #define R_68k_NONE      0
 107 #define R_68K_32        1
 108 #define R_68K_PC32      4
 109 #define R_68K_PC16      5
 110
 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
 119
 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
 129
 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
 137
 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
 144
 145 #define SHF_WRITE       (1 << 0)
 146 #define SHF_ALLOC       (1 << 1)
 147 #define SHF_EXECINSTR   (1 << 2)
 148
 149 #define ELF_ST_TYPE(i)    ((i) & 0x0F)
 150
 151 #define EI_VERSION      6
 152 #define EV_CURRENT      1
 153
 154 #define EI_DATA         5
 155 #define ELFDATA2LSB     1
 156 #define ELFDATA2MSB     2
 157
 158 #define EI_CLASS        4
 159 #define ELFCLASS32      1
 160 #define ELFCLASS64      2               /* 64-bit objects */
 161
 162 #define EI_OSABI        7
 163 #define EI_ABIVERSION   8
 164
 165 #define ELFOSABI_AROS   15
 166
 167 #define PF_X            (1 << 0)
 168
 169 struct elfheader
 170 {
 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));
 186
 187 struct sheader
 188 {
 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));
 200
 201 #define PT_LOAD 1
 202
 203 struct pheader
 204 {
 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));
 214
 215 struct symbol
 216 {
 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));
 224
 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))
 228
 229 struct relo
 230 {
 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 */
 234 };
 235
 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
 238  */
 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)))*/
 242
 243 /* convert section header array index to section number */
 244 /*#define SHNUM(i) \
 245     ((i) < SHN_LORESERVE ? (i) : (i) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))*/
 246
 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
 252
 253
 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
 261
 262 #ifdef PROTOTYPES
 263 #   define PARAMS(x) x
 264 #else
 265 #   define PARAMS(x) ()
 266 #endif /* PROTOTYPES */
 267
 268 static void set_error(int err)
 269 {
 270     errno = err;
 271 }
 272
 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 )
 281
 282 static int must_swap = -1;
 283
 284 static void eh_fixup(struct elfheader *eh)
 285 {
 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;
 304     }
 305 }
 306
 307 static void sh_fixup(struct sheader *sh, int n)
 308 {
 309     if (must_swap == 0)
 310         return;
 311
 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);
 323     }
 324 }
 325
 326 static void rel_fixup(struct relo *rel)
 327 {
 328     if (must_swap == 0)
 329         return;
 330
 331     rel->offset = ntohl(rel->offset);
 332     rel->info   = ntohl(rel->info);
 333     rel->addend = ntohl(rel->addend);
 334 }
 335
 336 void sym_fixup(struct symbol *sym)
 337 {
 338     if (must_swap == 0)
 339         return;
 340
 341     sym->name = ntohl(sym->name);
 342     sym->value = ntohl(sym->value);
 343     sym->size = ntohl(sym->size);
 344     sym->shindex = ntohs(sym->shindex);
 345 }
 346
 347 static void *load_block (int file,ULONG offset,ULONG size)
 348 {
 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;
 357         }
 358
 359         free(block);
 360         set_error(EIO);
 361     } else
 362         set_error(ENOMEM);
 363
 364     return NULL;
 365 }
 366
 367 static ULONG read_shnum(int file, struct elfheader *eh)
 368 {
 369     ULONG shnum = eh->shnum;
 370
 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).
 375      *
 376      * similarly, if the string table index is SHN_XINDEX, then the actual
 377      * index is found in the first section header also.
 378      *
 379      * see the System V ABI 2001-04-24 draft for more details.
 380      */
 381     if (eh->shnum == 0)
 382     {
 383         struct sheader sh;
 384
 385         if (eh->shoff == 0) {
 386             set_error(ENOEXEC);
 387             return 0;
 388         }
 389
 390         lseek(file, eh->shoff, SEEK_SET);
 391         if (read(file, &sh, sizeof(sh)) != sizeof(sh))
 392             return 0;
 393
 394         sh_fixup(&sh, 1);
 395
 396         /* wider section header count is in the size field */
 397         shnum = sh.size;
 398
 399         /* sanity, if they're still invalid then this isn't elf */
 400         if (shnum == 0)
 401             set_error(ENOEXEC);
 402     }
 403
 404     return shnum;
 405 }
 406
 407 static int load_header(int file, struct elfheader *eh)
 408 {
 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;
 413     }
 414
 415     eh_fixup(eh);
 416
 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;
 421     }
 422     D(bug("[ELF2HUNK] ELF object\n"));
 423
 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)
 430     {
 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));
 437
 438         set_error(ENOEXEC);
 439         return 0;
 440     }
 441
 442     return 1;
 443 }
 444
 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;
 457 };
 458
 459 static int relocate
 460 (
 461     struct elfheader  *eh,
 462     struct sheader    *sh,
 463     ULONG              shrel_idx,
 464     int                symtab_shndx,
 465     struct relo       *rel,
 466     struct hunkheader **hh
 467 )
 468 {
 469     struct sheader *shrel    = &sh[shrel_idx];
 470     struct sheader *shsymtab = &sh[shrel->link];
 471     struct sheader *toreloc  = &sh[shrel->info];
 472
 473     struct symbol *symtab   = (struct symbol *)hh[shrel->link]->data;
 474     struct hunkheader *h    = hh[shrel->info];
 475
 476     /*
 477      * Ignore relocs if the target section has no allocation. that can happen
 478      * eg. with a .debug PROGBITS and a .rel.debug section
 479      */
 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;
 483
 484     ULONG numrel = shrel->size / shrel->entsize;
 485     ULONG i;
 486     ULONG hrels;
 487
 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];
 492
 493     for (i=0; i<numrel; i++, rel++)
 494     {
 495         struct symbol sym;
 496         ULONG offset;
 497         ULONG shindex;
 498         ULONG hunk = 0;
 499         ULONG value = 0;
 500         const char *symname;
 501
 502         rel_fixup(rel);
 503
 504 #ifdef __arm__
 505         /*
 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.
 509          */
 510         if (ELF_R_TYPE(rel->info) == R_ARM_V4BX)
 511             continue;
 512 #endif
 513
 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);
 518
 519         if (sym.shindex != SHN_XINDEX)
 520             shindex = sym.shindex;
 521
 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;
 527             }
 528             shindex = ntohl(((ULONG *)hh[symtab_shndx]->data)[ELF_R_SYM(rel->info)]);
 529         }
 530
 531         D(bug("[ELF2HUNK] Processing %d symbol %s\n", (int)shindex, symname));
 532
 533         switch (shindex)
 534         {
 535
 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;
 541                 }
 542                 break;
 543
 544             case SHN_COMMON:
 545                 bug("[ELF2HUNK] SHN_COMMON symbol '%s' unsupported\n", symname);
 546                       set_error(EINVAL);
 547
 548                 return 0;
 549
 550             case SHN_ABS:
 551                 hunk = ~0; value = sym.value;
 552                 break;
 553
 554             default:
 555                 hunk = shindex;
 556                 value = sym.value;
 557                 break;
 558         }
 559
 560         switch (ELF_R_TYPE(rel->info))
 561         {
 562             case R_68K_32:
 563                 value += rel->addend;
 564                 break;
 565
 566             case R_68K_PC32:
 567                 value += rel->addend - offset;
 568                 break;
 569
 570             case R_68K_PC16:
 571                 bug("[ELF2HUNK] Unsupported relocation type R_68K_PC16\n");
 572                 set_error(EINVAL);
 573                 return 0;
 574                 break;
 575
 576             case R_68k_NONE:
 577                 break;
 578
 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;
 583         }
 584
 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;
 590         }
 591         hrel->shid = hunk;
 592         hrel->offset = offset;
 593         hrel->symbol = symname;
 594         hrel++;
 595     }
 596
 597     return 1;
 598 }
 599
 600 int reloc_cmp(const void *a, const void *b)
 601 {
 602     const struct hunkreloc *ha = a, *hb = b;
 603
 604     if (ha->shid != hb->shid)
 605         return hb->shid - ha->shid;
 606     return hb->offset - ha->offset;
 607 }
 608
 609 static int wlong(int fd, ULONG val)
 610 {
 611     val = htonl(val);
 612     return write(fd, &val, sizeof(val));
 613 }
 614
 615 int sym_dump(int hunk_fd, struct sheader *sh, struct hunkheader **hh, int shid, int symtabndx)
 616 {
 617     int i, err, syms;
 618     struct symbol *sym = hh[symtabndx]->data;
 619     struct sheader *symtab = &sh[symtabndx];
 620
 621     syms = symtab->size / sizeof(struct symbol);
 622
 623     if (syms == 0)
 624         return 1;
 625
 626     wlong(hunk_fd, HUNK_SYMBOL);
 627     wlong(hunk_fd, syms);
 628
 629     /* Dump symbols for this hunk */
 630     for (i = 0; i < syms ; i++) {
 631         struct symbol s;
 632         const char *name;
 633         int lsize;
 634
 635         s = sym[i];
 636         sym_fixup(&s);
 637
 638         if (s.shindex != shid)
 639             continue;
 640
 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);
 649     }
 650     wlong(hunk_fd, 0);
 651
 652     return 1;
 653 }
 654
 655 static void reloc_dump(int hunk_fd, struct hunkheader **hh, int h)
 656 {
 657     int i;
 658
 659     if (hh[h]->relocs == 0)
 660         return;
 661
 662     /* Sort the relocations by reference hunk id */
 663     qsort(hh[h]->reloc, hh[h]->relocs, sizeof(hh[h]->reloc[0]), reloc_cmp);
 664
 665     wlong(hunk_fd, HUNK_RELOC32);
 666     D(bug("\tHUNK_RELOC32: %d relocations\n", (int)hh[h]->relocs));
 667
 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);
 682         }
 683     }
 684     wlong(hunk_fd, 0);
 685 }
 686
 687 static int copy_to(int in, int out)
 688 {
 689     static char buff[64*1024];
 690     int len, err = 0;
 691
 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;
 697         }
 698         if (len == 0)
 699             break;
 700     } while ((err = write(out, buff, len)) == len);
 701
 702     if (err < 0) {
 703             perror("Can't write to output file\n");
 704             return -errno;
 705     }
 706
 707     return 0;
 708 }
 709
 710 int elf2hunk(int file, int hunk_fd, const char *libname, int flags)
 711 {
 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;
 723
 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.
 728          *
 729          * This simplifies a number of mmakefiles
 730          * for the m68k-amiga boot and ISO creation
 731          */
 732         lseek(file, 0, SEEK_SET);
 733         return (copy_to(file, hunk_fd) == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 734     }
 735
 736     D(bug("Read SHNum\n"));
 737     int_shnum = read_shnum(file, &eh);
 738     if (!int_shnum)
 739         return EXIT_FAILURE;
 740
 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;
 745
 746     sh_fixup(sh, int_shnum);
 747
 748     /* Looks like we have a valid executable. Generate a
 749      * HUNK header set. Not all may be filled in.
 750      */
 751     hh = calloc(sizeof(*hh), int_shnum);
 752
 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;
 759         }
 760     }
 761
 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++)
 765     {
 766         /*
 767            Load the symbol and string table(s).
 768
 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.
 772         */
 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)
 776         {
 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;
 784
 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"));
 790             }
 791         }
 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)
 795         {
 796             hh[i] = calloc(sizeof(struct hunkheader), 1);
 797             hh[i]->size = sh[i].size;
 798             hh[i]->hunk = hunks++;
 799
 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;
 811                 }
 812                 hh[i]->data = load_block(file, sh[i].offset, sh[i].size);
 813             }
 814
 815             if (strtab) {
 816                 const char *nameext;
 817
 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;
 829                     }
 830                 }
 831             }
 832         }
 833     }
 834
 835     /* Relocate the sections */
 836     D(bug("Convert relocation tables\n"));
 837     for (i = 0; i < int_shnum; i++)
 838     {
 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)
 843         {
 844             void *reloc = load_block(file, sh[i].offset, sh[i].size);
 845
 846             if (!relocate(&eh, sh, i, symtab_shndx, reloc, hh))
 847                     return EXIT_FAILURE;
 848
 849             free(reloc);
 850         }
 851     }
 852
 853     D(bug("HUNK_HEADER: \"%s\", hunks=%d, first=%d, last=%d\n", libname, hunks, 0, hunks-1));
 854
 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;
 864     }
 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 */
 868
 869     /* Write all allocatable hunk sizes */
 870     for (i = 0; i < int_shnum; i++) {
 871         ULONG count;
 872
 873         if (hh[i]==NULL || hh[i]->hunk < 0)
 874             continue;
 875
 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;
 889         }
 890
 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);
 893
 894         if ((count & HUNKF_MEMFLAGS) == HUNKF_MEMFLAGS)
 895             wlong(hunk_fd, hh[i]->memflags | MEMF_PUBLIC | MEMF_CLEAR);
 896     }
 897
 898     /* Write all hunks */
 899     for (i = hunks = 0; i < int_shnum; i++) {
 900         int s;
 901
 902         if (hh[i]==NULL || hh[i]->hunk < 0)
 903             continue;
 904
 905         wlong(hunk_fd, hh[i]->type);
 906         wlong(hunk_fd, (hh[i]->size + 4) / 4);
 907
 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);
 915             }
 916 }
 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);
 930             }
 931 }
 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;
 939         }
 940     }
 941
 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]);
 950         }
 951     }
 952     free(hh);
 953     free(sh);
 954
 955     if (strtab)
 956         free(strtab);
 957
 958     D(bug("All good, all done.\n"));
 959     return EXIT_SUCCESS;
 960
 961 error:
 962     return EXIT_FAILURE;
 963 }
 964
 965 static int copy(const char *src, const char *dst, int flags);
 966
 967 static int copy_dir(const char *src, const char *dst, int flags)
 968 {
 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;
 975
 976     sdir = opendir(src);
 977     if (sdir == NULL) {
 978         perror(src);
 979         return EXIT_FAILURE;
 980     }
 981
 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;
 986
 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;
 991
 992     while ((de = readdir(sdir)) != NULL) {
 993         int eflags = 0;
 994
 995         if ((strcmp(de->d_name, ".") == 0) ||
 996             (strcmp(de->d_name, "..") == 0))
 997             continue;
 998
 999         /* Don't convert anything in a Development directory */
1000         if (strcasecmp(de->d_name, "Development") == 0)
1001             eflags |= F_NOCONVERT;
1002
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;
1010     }
1011
1012     closedir(sdir);
1013
1014     return err;
1015 }
1016
1017 static int copy(const char *src, const char *dst, int flags)
1018 {
1019     int src_fd, hunk_fd;
1020     struct stat st;
1021     int mode, ret;
1022
1023     if (flags & F_VERBOSE)
1024        printf("%s ->\n  %s\n", src, dst);
1025
1026     if (stat(src, &st) >= 0) {
1027         mode = st.st_mode;
1028     } else {
1029         mode = 0755;
1030     }
1031
1032     if (S_ISDIR(mode)) {
1033         unlink(dst);
1034         mkdir(dst, mode);
1035         return copy_dir(src, dst, flags);
1036     }
1037
1038     src_fd = open(src, O_RDONLY);
1039     if (src_fd < 0) {
1040         perror(src);
1041         return EXIT_FAILURE;
1042     }
1043
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);
1049     }
1050     if (hunk_fd < 0) {
1051         perror(dst);
1052         return EXIT_FAILURE;
1053     }
1054
1055     ret = elf2hunk(src_fd, hunk_fd, NULL, flags);
1056     if (ret != 0)
1057         perror(src);
1058
1059     close(src_fd);
1060     if (hunk_fd != 1)
1061         close(hunk_fd);
1062
1063     return ret;
1064 }
1065
1066 int main(int argc, char **argv)
1067 {
1068     int flags = 0;
1069
1070     if (argc == 4 && strcmp(argv[1],"-v") == 0) {
1071         flags |= F_VERBOSE;
1072         argc--;
1073         argv++;
1074     }
1075
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;
1080     }
1081
1082     return copy(argv[1], argv[2], flags);
1083 }