diff --git a/Makefile.inc1 b/Makefile.inc1 index 5f76d3ac5978..acd117a43e42 100644 --- a/Makefile.inc1 +++ b/Makefile.inc1 @@ -661,8 +661,9 @@ build-tools: _elf2exe= usr.sbin/elf2exe .endif -.if ${TARGET_ARCH} == "i386" && ${MACHINE_ARCH} != "i386" +.if ${TARGET_ARCH} == "i386" _btxld= usr.sbin/btxld +_kgzip= usr.sbin/kgzip .endif .if ${TARGET_ARCH} == "sparc64" @@ -674,7 +675,7 @@ _xlint= usr.bin/xlint/lint1 usr.bin/xlint/lint2 usr.bin/xlint/xlint cross-tools: .for _tool in ${_btxld} ${_elf2aout} ${_elf2exe} \ gnu/usr.bin/binutils usr.sbin/crunch/crunchide \ - gnu/usr.bin/cc ${_xlint} + gnu/usr.bin/cc ${_xlint} ${_kgzip} ${ECHODIR} "===> ${_tool}"; \ cd ${.CURDIR}/${_tool}; \ ${MAKE} DIRPRFX=${_tool}/ obj; \ diff --git a/usr.sbin/kgzip/elfhdr.c b/usr.sbin/kgzip/elfhdr.c index d3abec77cbf0..50bb0b79f103 100644 --- a/usr.sbin/kgzip/elfhdr.c +++ b/usr.sbin/kgzip/elfhdr.c @@ -28,6 +28,7 @@ #include #include "elfhdr.h" +#include "endian.h" #define KGZ_FIX_NSIZE 0 /* Run-time fixup */ @@ -42,80 +43,80 @@ const struct kgz_elfhdr elfhdr = { ELFCLASS32, ELFDATA2LSB, EV_CURRENT, 0, 'F', 'r', 'e', 'e', 'B', 'S', 'D', 0 }, - ET_EXEC, /* e_type */ - EM_386, /* e_machine */ - EV_CURRENT, /* e_version */ + HTOLE16(ET_EXEC), /* e_type */ + HTOLE16(EM_386), /* e_machine */ + HTOLE32(EV_CURRENT), /* e_version */ 0, /* e_entry */ 0, /* e_phoff */ - offsetof(struct kgz_elfhdr, sh), /* e_shoff */ + HTOLE32(offsetof(struct kgz_elfhdr, sh)), /* e_shoff */ 0, /* e_flags */ - sizeof(Elf32_Ehdr), /* e_ehsize */ + HTOLE16(sizeof(Elf32_Ehdr)), /* e_ehsize */ 0, /* e_phentsize */ 0, /* e_phnum */ - sizeof(Elf32_Shdr), /* e_shentsize */ - KGZ_SHNUM, /* e_shnum */ - KGZ_SH_SHSTRTAB /* e_shstrndx */ + HTOLE16(sizeof(Elf32_Shdr)), /* e_shentsize */ + HTOLE16(KGZ_SHNUM), /* e_shnum */ + HTOLE16(KGZ_SH_SHSTRTAB) /* e_shstrndx */ }, /* Section header */ { { 0, /* sh_name */ - SHT_NULL, /* sh_type */ + HTOLE32(SHT_NULL), /* sh_type */ 0, /* sh_flags */ 0, /* sh_addr */ 0, /* sh_offset */ 0, /* sh_size */ - SHN_UNDEF, /* sh_link */ + HTOLE32(SHN_UNDEF), /* sh_link */ 0, /* sh_info */ 0, /* sh_addralign */ 0 /* sh_entsize */ }, { - offsetof(struct kgz_shstrtab, symtab), /* sh_name */ - SHT_SYMTAB, /* sh_type */ + HTOLE32(offsetof(struct kgz_shstrtab, symtab)), /* sh_name */ + HTOLE32(SHT_SYMTAB), /* sh_type */ 0, /* sh_flags */ 0, /* sh_addr */ - offsetof(struct kgz_elfhdr, st), /* sh_offset */ - sizeof(Elf32_Sym) * KGZ_STNUM, /* sh_size */ - KGZ_SH_STRTAB, /* sh_link */ - 1, /* sh_info */ - 4, /* sh_addralign */ - sizeof(Elf32_Sym) /* sh_entsize */ + HTOLE32(offsetof(struct kgz_elfhdr, st)), /* sh_offset */ + HTOLE32(sizeof(Elf32_Sym) * KGZ_STNUM), /* sh_size */ + HTOLE32(KGZ_SH_STRTAB), /* sh_link */ + HTOLE32(1), /* sh_info */ + HTOLE32(4), /* sh_addralign */ + HTOLE32(sizeof(Elf32_Sym)) /* sh_entsize */ }, { - offsetof(struct kgz_shstrtab, shstrtab), /* sh_name */ - SHT_STRTAB, /* sh_type */ + HTOLE32(offsetof(struct kgz_shstrtab, shstrtab)), /* sh_name */ + HTOLE32(SHT_STRTAB), /* sh_type */ 0, /* sh_flags */ 0, /* sh_addr */ - offsetof(struct kgz_elfhdr, shstrtab), /* sh_offset */ - sizeof(struct kgz_shstrtab), /* sh_size */ - SHN_UNDEF, /* sh_link */ + HTOLE32(offsetof(struct kgz_elfhdr, shstrtab)), /* sh_offset */ + HTOLE32(sizeof(struct kgz_shstrtab)), /* sh_size */ + HTOLE32(SHN_UNDEF), /* sh_link */ 0, /* sh_info */ - 1, /* sh_addralign */ + HTOLE32(1), /* sh_addralign */ 0 /* sh_entsize */ }, { - offsetof(struct kgz_shstrtab, strtab), /* sh_name */ - SHT_STRTAB, /* sh_type */ + HTOLE32(offsetof(struct kgz_shstrtab, strtab)), /* sh_name */ + HTOLE32(SHT_STRTAB), /* sh_type */ 0, /* sh_flags */ 0, /* sh_addr */ - offsetof(struct kgz_elfhdr, strtab), /* sh_offset */ - sizeof(struct kgz_strtab), /* sh_size */ - SHN_UNDEF, /* sh_link */ + HTOLE32(offsetof(struct kgz_elfhdr, strtab)), /* sh_offset */ + HTOLE32(sizeof(struct kgz_strtab)), /* sh_size */ + HTOLE32(SHN_UNDEF), /* sh_link */ 0, /* sh_info */ - 1, /* sh_addralign */ + HTOLE32(1), /* sh_addralign */ 0 /* sh_entsize */ }, { - offsetof(struct kgz_shstrtab, data), /* sh_name */ - SHT_PROGBITS, /* sh_type */ - SHF_ALLOC | SHF_WRITE, /* sh_flags */ + HTOLE32(offsetof(struct kgz_shstrtab, data)), /* sh_name */ + HTOLE32(SHT_PROGBITS), /* sh_type */ + HTOLE32(SHF_ALLOC | SHF_WRITE), /* sh_flags */ 0, /* sh_addr */ - sizeof(struct kgz_elfhdr), /* sh_offset */ - sizeof(struct kgz_hdr) + KGZ_FIX_NSIZE, /* sh_size */ - SHN_UNDEF, /* sh_link */ + HTOLE32(sizeof(struct kgz_elfhdr)), /* sh_offset */ + HTOLE32(sizeof(struct kgz_hdr) + KGZ_FIX_NSIZE), /* sh_size */ + HTOLE32(SHN_UNDEF), /* sh_link */ 0, /* sh_info */ - 4, /* sh_addralign */ + HTOLE32(4), /* sh_addralign */ 0 /* sh_entsize */ } }, @@ -127,23 +128,23 @@ const struct kgz_elfhdr elfhdr = { 0, /* st_size */ 0, /* st_info */ 0, /* st_other */ - SHN_UNDEF /* st_shndx */ + HTOLE16(SHN_UNDEF) /* st_shndx */ }, { - offsetof(struct kgz_strtab, kgz), /* st_name */ + HTOLE32(offsetof(struct kgz_strtab, kgz)), /* st_name */ 0, /* st_value */ - sizeof(struct kgz_hdr), /* st_size */ + HTOLE32(sizeof(struct kgz_hdr)), /* st_size */ ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT), /* st_info */ 0, /* st_other */ - KGZ_SH_DATA /* st_shndx */ + HTOLE16(KGZ_SH_DATA) /* st_shndx */ }, { - offsetof(struct kgz_strtab, kgz_ndata), /* st_name */ - sizeof(struct kgz_hdr), /* st_value */ - KGZ_FIX_NSIZE, /* st_size */ + HTOLE32(offsetof(struct kgz_strtab, kgz_ndata)), /* st_name */ + HTOLE32(sizeof(struct kgz_hdr)), /* st_value */ + HTOLE32(KGZ_FIX_NSIZE), /* st_size */ ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT), /* st_info */ 0, /* st_other */ - KGZ_SH_DATA /* st_shndx */ + HTOLE16(KGZ_SH_DATA) /* st_shndx */ } }, /* Section header string table */ diff --git a/usr.sbin/kgzip/endian.h b/usr.sbin/kgzip/endian.h new file mode 100644 index 000000000000..78c9b16a3f0b --- /dev/null +++ b/usr.sbin/kgzip/endian.h @@ -0,0 +1,52 @@ +/* + * $FreeBSD$ + */ + +#include +#include + +#define bswap16(x) (uint16_t) \ + ((x >> 8) | (x << 8)) + +#define bswap32(x) (uint32_t) \ + ((x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24)) + +#define bswap64(x) (uint64_t) \ + ((x >> 56) | ((x >> 40) & 0xff00) | ((x >> 24) & 0xff0000) | \ + ((x >> 8) & 0xff000000) | ((x << 8) & ((uint64_t)0xff << 32)) | \ + ((x << 24) & ((uint64_t)0xff << 40)) | \ + ((x << 40) & ((uint64_t)0xff << 48)) | ((x << 56))) + +/* + * Host to big endian, host to little endian, big endian to host, and little + * endian to host byte order functions as detailed in byteorder(9). + */ +#if _BYTE_ORDER == _LITTLE_ENDIAN +#define HTOBE16(x) bswap16((uint16_t)(x)) +#define HTOBE32(x) bswap32((uint32_t)(x)) +#define HTOBE64(x) bswap64((uint64_t)(x)) +#define HTOLE16(x) ((uint16_t)(x)) +#define HTOLE32(x) ((uint32_t)(x)) +#define HTOLE64(x) ((uint64_t)(x)) + +#define BE16TOH(x) bswap16((uint16_t)(x)) +#define BE32TOH(x) bswap32((uint32_t)(x)) +#define BE64TOH(x) bswap64((uint64_t)(x)) +#define LE16TOH(x) ((uint16_t)(x)) +#define LE32TOH(x) ((uint32_t)(x)) +#define LE64TOH(x) ((uint64_t)(x)) +#else /* _BYTE_ORDER != _LITTLE_ENDIAN */ +#define HTOBE16(x) ((uint16_t)(x)) +#define HTOBE32(x) ((uint32_t)(x)) +#define HTOBE64(x) ((uint64_t)(x)) +#define HTOLE16(x) bswap16((uint16_t)(x)) +#define HTOLE32(x) bswap32((uint32_t)(x)) +#define HTOLE64(x) bswap64((uint64_t)(x)) + +#define BE16TOH(x) ((uint16_t)(x)) +#define BE32TOH(x) ((uint32_t)(x)) +#define BE64TOH(x) ((uint64_t)(x)) +#define LE16TOH(x) bswap16((uint16_t)(x)) +#define LE32TOH(x) bswap32((uint32_t)(x)) +#define LE64TOH(x) bswap64((uint64_t)(x)) +#endif /* _BYTE_ORDER == _LITTLE_ENDIAN */ diff --git a/usr.sbin/kgzip/i386_a.out.h b/usr.sbin/kgzip/i386_a.out.h new file mode 100644 index 000000000000..72d930db2e69 --- /dev/null +++ b/usr.sbin/kgzip/i386_a.out.h @@ -0,0 +1,139 @@ +/*- + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * from: @(#)exec.h 8.1 (Berkeley) 6/11/93 + * from: FreeBSD: src/sys/sys/imgact_aout.h,v 1.18 2002/09/05 07:54:03 bde Exp $ + * $FreeBSD$ + */ + +#ifndef _I386_AOUT_H_ +#define _I386_AOUT_H_ + +#include +#include "endian.h" + +#define __I386_LDPGSZ 4096 + +#define I386_N_GETMAGIC(ex) \ + ( LE32TOH((ex).a_midmag) & 0xffff ) +#define I386_N_SETMAGIC(ex,mag,mid,flag) \ + ( (ex).a_midmag = HTOLE32((((flag) & 0x3f) <<26) | \ + (((mid) & 0x03ff) << 16) | \ + ((mag) & 0xffff)) ) + +#define I386_N_ALIGN(ex,x) \ + (I386_N_GETMAGIC(ex) == ZMAGIC || I386_N_GETMAGIC(ex) == QMAGIC ? \ + ((x) + __I386_LDPGSZ - 1) & ~(uint32_t)(__I386_LDPGSZ - 1) : (x)) + +/* Valid magic number check. */ +#define I386_N_BADMAG(ex) \ + (I386_N_GETMAGIC(ex) != OMAGIC && I386_N_GETMAGIC(ex) != NMAGIC && \ + I386_N_GETMAGIC(ex) != ZMAGIC && I386_N_GETMAGIC(ex) != QMAGIC) + + +/* Address of the bottom of the text segment. */ +/* + * This can not be done right. Abuse a_entry in some cases to handle kernels. + */ +#define I386_N_TXTADDR(ex) \ + ((I386_N_GETMAGIC(ex) == OMAGIC || I386_N_GETMAGIC(ex) == NMAGIC || \ + I386_N_GETMAGIC(ex) == ZMAGIC) ? \ + (LE32TOH((ex).a_entry) < LE32TOH((ex).a_text) ? 0 : \ + LE32TOH((ex).a_entry) & ~__I386_LDPGSZ) : __I386_LDPGSZ) + +/* Address of the bottom of the data segment. */ +#define I386_N_DATADDR(ex) \ + I386_N_ALIGN(ex, I386_N_TXTADDR(ex) + LE32TOH((ex).a_text)) + +/* Text segment offset. */ +#define I386_N_TXTOFF(ex) \ + (I386_N_GETMAGIC(ex) == ZMAGIC ? __I386_LDPGSZ : \ + (I386_N_GETMAGIC(ex) == QMAGIC ? 0 : sizeof(struct exec))) + +/* Data segment offset. */ +#define I386_N_DATOFF(ex) \ + I386_N_ALIGN(ex, I386_N_TXTOFF(ex) + LE32TOH((ex).a_text)) + +/* Relocation table offset. */ +#define I386_N_RELOFF(ex) \ + I386_N_ALIGN(ex, I386_N_DATOFF(ex) + LE32TOH((ex).a_data)) + +/* Symbol table offset. */ +#define I386_N_SYMOFF(ex) \ + (I386_N_RELOFF(ex) + LE32TOH((ex).a_trsize) + LE32TOH((ex).a_drsize)) + +/* String table offset. */ +#define I386_N_STROFF(ex) (I386_N_SYMOFF(ex) + LE32TOH((ex).a_syms)) + +/* + * Header prepended to each a.out file. + * only manipulate the a_midmag field via the + * N_SETMAGIC/N_GET{MAGIC,MID,FLAG} macros in a.out.h + */ + +struct i386_exec { + uint32_t a_midmag; /* flags<<26 | mid<<16 | magic */ + uint32_t a_text; /* text segment size */ + uint32_t a_data; /* initialized data size */ + uint32_t a_bss; /* uninitialized data size */ + uint32_t a_syms; /* symbol table size */ + uint32_t a_entry; /* entry point */ + uint32_t a_trsize; /* text relocation size */ + uint32_t a_drsize; /* data relocation size */ +}; +#define a_magic a_midmag /* XXX Hack to work with current kern_execve.c */ + +/* a_magic */ +#define OMAGIC 0407 /* old impure format */ +#define NMAGIC 0410 /* read-only text */ +#define ZMAGIC 0413 /* demand load format */ +#define QMAGIC 0314 /* "compact" demand load format */ + +/* a_mid */ +#define MID_ZERO 0 /* unknown - implementation dependent */ +#define MID_SUN010 1 /* sun 68010/68020 binary */ +#define MID_SUN020 2 /* sun 68020-only binary */ +#define MID_I386 134 /* i386 BSD binary */ +#define MID_SPARC 138 /* sparc */ +#define MID_HP200 200 /* hp200 (68010) BSD binary */ +#define MID_HP300 300 /* hp300 (68020+68881) BSD binary */ +#define MID_HPUX 0x20C /* hp200/300 HP-UX binary */ +#define MID_HPUX800 0x20B /* hp800 HP-UX binary */ + +/* + * a_flags + */ +#define EX_PIC 0x10 /* contains position independent code */ +#define EX_DYNAMIC 0x20 /* contains run-time link-edit info */ +#define EX_DPMASK 0x30 /* mask for the above */ + +#endif /* !_I386_AOUT_H_ */ diff --git a/usr.sbin/kgzip/kgzcmp.c b/usr.sbin/kgzip/kgzcmp.c index 01c7763efec8..e873b111fd47 100644 --- a/usr.sbin/kgzip/kgzcmp.c +++ b/usr.sbin/kgzip/kgzcmp.c @@ -36,10 +36,11 @@ #include #include -#include +#include "i386_a.out.h" #include "aouthdr.h" #include "elfhdr.h" +#include "endian.h" #include "kgzip.h" static void mk_data(const struct iodesc *i, const struct iodesc *, @@ -47,7 +48,7 @@ static void mk_data(const struct iodesc *i, const struct iodesc *, static int ld_elf(const struct iodesc *, const struct iodesc *, struct kgz_hdr *, const Elf32_Ehdr *); static int ld_aout(const struct iodesc *, const struct iodesc *, - struct kgz_hdr *, const struct exec *); + struct kgz_hdr *, const struct i386_exec *); /* * Compress executable and output it in relocatable object format. @@ -56,6 +57,7 @@ void kgzcmp(struct kgz_hdr *kh, const char *f1, const char *f2) { struct iodesc idi, ido; + struct kgz_hdr khle; if ((idi.fd = open(idi.fname = f1, O_RDONLY)) == -1) err(1, "%s", idi.fname); @@ -86,12 +88,19 @@ kgzcmp(struct kgz_hdr *kh, const char *f1, const char *f2) xwrite(&ido, &ahdr0, sizeof(ahdr0)); } else { struct kgz_elfhdr ehdr = elfhdr; - ehdr.st[KGZ_ST_KGZ_NDATA].st_size = kh->nsize; - ehdr.sh[KGZ_SH_DATA].sh_size += kh->nsize; + ehdr.st[KGZ_ST_KGZ_NDATA].st_size = HTOLE32(kh->nsize); + ehdr.sh[KGZ_SH_DATA].sh_size = + HTOLE32(LE32TOH(ehdr.sh[KGZ_SH_DATA].sh_size) + kh->nsize); xseek(&ido, 0); xwrite(&ido, &ehdr, sizeof(ehdr)); } - xwrite(&ido, kh, sizeof(*kh)); + khle = *kh; + khle.dload = HTOLE32(khle.dload); + khle.dsize = HTOLE32(khle.dsize); + khle.isize = HTOLE32(khle.isize); + khle.entry = HTOLE32(khle.entry); + khle.nsize = HTOLE32(khle.nsize); + xwrite(&ido, &khle, sizeof(khle)); xclose(&ido); xclose(&idi); } @@ -104,7 +113,7 @@ mk_data(const struct iodesc * idi, const struct iodesc * ido, struct kgz_hdr * kh, size_t off) { union { - struct exec ex; + struct i386_exec ex; Elf32_Ehdr ee; } hdr; struct stat sb; @@ -118,7 +127,7 @@ mk_data(const struct iodesc * idi, const struct iodesc * ido, fmt = 0; if (n >= sizeof(hdr.ee) && IS_ELF(hdr.ee)) fmt = F_ELF; - else if (n >= sizeof(hdr.ex) && N_GETMAGIC(hdr.ex) == ZMAGIC) + else if (n >= sizeof(hdr.ex) && I386_N_GETMAGIC(hdr.ex) == ZMAGIC) fmt = F_AOUT; if (!fmt) errx(1, "%s: Format not supported", idi->fname); @@ -207,20 +216,20 @@ ld_elf(const struct iodesc * idi, const struct iodesc * ido, */ static int ld_aout(const struct iodesc * idi, const struct iodesc * ido, - struct kgz_hdr * kh, const struct exec * a) + struct kgz_hdr * kh, const struct i386_exec * a) { size_t load, addr; - load = addr = N_TXTADDR(*a); - xcopy(idi, ido, a->a_text, N_TXTOFF(*a)); - addr += a->a_text; - if (N_DATADDR(*a) != addr) + load = addr = I386_N_TXTADDR(*a); + xcopy(idi, ido, LE32TOH(a->a_text), I386_N_TXTOFF(*a)); + addr += LE32TOH(a->a_text); + if (I386_N_DATADDR(*a) != addr) return -1; - xcopy(idi, ido, a->a_data, N_DATOFF(*a)); - addr += a->a_data; + xcopy(idi, ido, LE32TOH(a->a_data), I386_N_DATOFF(*a)); + addr += LE32TOH(a->a_data); kh->dload = load; kh->dsize = addr - load; - kh->isize = kh->dsize + a->a_bss; - kh->entry = a->a_entry; + kh->isize = kh->dsize + LE32TOH(a->a_bss); + kh->entry = LE32TOH(a->a_entry); return 0; }