Skip to content

Commit

Permalink
Changed "binary" to "record".
Browse files Browse the repository at this point in the history
  • Loading branch information
@icculus
icculus committed Sep 7, 2009
1 parent 88be35a commit 8d26453
Show file tree
Hide file tree
Showing 5 changed files with 47 additions and 47 deletions.
8 changes: 4 additions & 4 deletions include/fatelf.h
View file
Expand Up @@ -18,24 +18,24 @@
#define FATELF_DISK_FORMAT_SIZE(bins) (8 + (24 * (bins)))

/* Values on disk are always littleendian, and align like Elf64. */
typedef struct FATELF_binary_info
typedef struct FATELF_record
{
uint16_t osabi;
uint16_t osabi_version;
uint16_t machine;
uint16_t reserved0;
uint64_t offset;
uint64_t size;
} FATELF_binary_info;
} FATELF_record;

/* Values on disk are always littleendian, and align like Elf64. */
typedef struct FATELF_header
{
uint32_t magic; /* always FATELF_MAGIC */
uint16_t version; /* latest is always FATELF_FORMAT_VERSION */
uint8_t num_binaries;
uint8_t num_records;
uint8_t reserved0;
FATELF_binary_info binaries[];
FATELF_record records[];
} FATELF_header;

#endif
Expand Down
20 changes: 10 additions & 10 deletions utils/fatelf-glue.c
View file
Expand Up @@ -26,34 +26,34 @@ static int fatelf_glue(const char *out, const char **bins, const int bincount)

header->magic = FATELF_MAGIC;
header->version = FATELF_FORMAT_VERSION;
header->num_binaries = bincount;
header->num_records = bincount;

for (i = 0; i < bincount; i++)
{
int j = 0;
const uint64_t binary_offset = align_to_page(offset);
const char *fname = bins[i];
const int fd = xopen(fname, O_RDONLY, 0755);
FATELF_binary_info *info = &header->binaries[i];
FATELF_record *record = &header->records[i];

info->offset = binary_offset;
xread_elf_header(fname, fd, info);
record->offset = binary_offset;
xread_elf_header(fname, fd, record);

// make sure we don't have a duplicate target.
for (j = 0; j < i; j++)
{
const FATELF_binary_info *other = &header->binaries[j];
const int same = (other->machine == info->machine) &&
(other->osabi == info->osabi) &&
(other->osabi_version == info->osabi_version);
const FATELF_record *other = &header->records[j];
const int same = (other->machine == record->machine) &&
(other->osabi == record->osabi) &&
(other->osabi_version == record->osabi_version);
if (same)
xfail("'%s' and '%s' are for the same target.", bins[j], fname);
} // for

// append this binary to the final file, padded to page alignment.
xwrite_zeros(out, outfd, (size_t) (binary_offset - offset));
info->size = xcopyfile(fname, fd, out, outfd);
offset = binary_offset + info->size;
record->size = xcopyfile(fname, fd, out, outfd);
offset = binary_offset + record->size;

// done with this binary!
xclose(fname, fd);
Expand Down
20 changes: 10 additions & 10 deletions utils/fatelf-info.c
View file
Expand Up @@ -16,24 +16,24 @@ static int fatelf_info(const char *fname)
unsigned int i = 0;

printf("%s: FatELF format version %d\n", fname, (int) header->version);
printf("%d binaries.\n", (int) header->num_binaries);
printf("%d records.\n", (int) header->num_records);

for (i = 0; i < header->num_binaries; i++)
for (i = 0; i < header->num_records; i++)
{
const FATELF_binary_info *bin = &header->binaries[i];
const fatelf_machine_info *machine = get_machine_by_id(bin->machine);
const fatelf_osabi_info *osabi = get_osabi_by_id(bin->osabi);
const FATELF_record *rec = &header->records[i];
const fatelf_machine_info *machine = get_machine_by_id(rec->machine);
const fatelf_osabi_info *osabi = get_osabi_by_id(rec->osabi);

printf("Binary at index #%d:\n", i);
printf(" OSABI %u (%s%s%s) version %u,\n",
(unsigned int) bin->osabi, osabi ? osabi->name : "???",
(unsigned int) rec->osabi, osabi ? osabi->name : "???",
osabi ? ": " : "", osabi ? osabi->desc : "",
(unsigned int) bin->osabi_version);
(unsigned int) rec->osabi_version);
printf(" Machine %u (%s%s%s)\n",
(unsigned int) bin->machine, machine ? machine->name : "???",
(unsigned int) rec->machine, machine ? machine->name : "???",
machine ? ": " : "", machine ? machine->desc : "");
printf(" Offset %llu\n", (unsigned long long) bin->offset);
printf(" Size %llu\n", (unsigned long long) bin->size);
printf(" Offset %llu\n", (unsigned long long) rec->offset);
printf(" Size %llu\n", (unsigned long long) rec->size);
} // for

xclose(fname, fd);
Expand Down
44 changes: 22 additions & 22 deletions utils/fatelf-utils.c
View file
Expand Up @@ -125,28 +125,28 @@ uint64_t xcopyfile(const char *in, const int infd,
} // xcopyfile


void xread_elf_header(const char *fname, const int fd, FATELF_binary_info *info)
void xread_elf_header(const char *fname, const int fd, FATELF_record *record)
{
const uint8_t magic[4] = { 0x7F, 0x45, 0x4C, 0x46 };
uint8_t buf[20]; // we only care about the first 20 bytes.
xlseek(fname, fd, 0, SEEK_SET); // just in case.
xread(fname, fd, buf, sizeof (buf), 1);
if (memcmp(magic, buf, sizeof (magic)) != 0)
xfail("'%s' is not an ELF binary");
info->osabi = (uint16_t) buf[7];
info->osabi_version = (uint16_t) buf[8];
record->osabi = (uint16_t) buf[7];
record->osabi_version = (uint16_t) buf[8];
if (buf[5] == 0) // bigendian
info->machine = (((uint16_t)buf[18]) << 8) | (((uint16_t)buf[19]));
record->machine = (((uint16_t)buf[18]) << 8) | (((uint16_t)buf[19]));
else if (buf[5] == 1) // littleendian
info->machine = (((uint16_t)buf[19]) << 8) | (((uint16_t)buf[18]));
record->machine = (((uint16_t)buf[19]) << 8) | (((uint16_t)buf[18]));
else
xfail("Unexpected data encoding in '%s'", fname);
} // xread_elf_header


size_t fatelf_header_size(const int bincount)
{
return (sizeof (FATELF_header) + (sizeof (FATELF_binary_info) * bincount));
return (sizeof (FATELF_header) + (sizeof (FATELF_record) * bincount));
} // fatelf_header_size


Expand Down Expand Up @@ -238,24 +238,24 @@ static inline uint8_t *getui64(uint8_t *ptr, uint64_t *val)
void xwrite_fatelf_header(const char *fname, const int fd,
const FATELF_header *header)
{
const size_t buflen = FATELF_DISK_FORMAT_SIZE(header->num_binaries);
const size_t buflen = FATELF_DISK_FORMAT_SIZE(header->num_records);
uint8_t *buf = (uint8_t *) xmalloc(buflen);
uint8_t *ptr = buf;
int i;

ptr = putui32(ptr, header->magic);
ptr = putui16(ptr, header->version);
ptr = putui8(ptr, header->num_binaries);
ptr = putui8(ptr, header->num_records);
ptr = putui8(ptr, header->reserved0);

for (i = 0; i < header->num_binaries; i++)
for (i = 0; i < header->num_records; i++)
{
ptr = putui16(ptr, header->binaries[i].osabi);
ptr = putui16(ptr, header->binaries[i].osabi_version);
ptr = putui16(ptr, header->binaries[i].machine);
ptr = putui16(ptr, header->binaries[i].reserved0);
ptr = putui64(ptr, header->binaries[i].offset);
ptr = putui64(ptr, header->binaries[i].size);
ptr = putui16(ptr, header->records[i].osabi);
ptr = putui16(ptr, header->records[i].osabi_version);
ptr = putui16(ptr, header->records[i].machine);
ptr = putui16(ptr, header->records[i].reserved0);
ptr = putui64(ptr, header->records[i].offset);
ptr = putui64(ptr, header->records[i].size);
} // for

assert(ptr == (buf + buflen));
Expand Down Expand Up @@ -299,17 +299,17 @@ FATELF_header *xread_fatelf_header(const char *fname, const int fd)
header = (FATELF_header *) xmalloc(fatelf_header_size(bincount));
header->magic = magic;
header->version = version;
header->num_binaries = bincount;
header->num_records = bincount;
header->reserved0 = reserved0;

for (i = 0; i < bincount; i++)
{
ptr = getui16(ptr, &header->binaries[i].osabi);
ptr = getui16(ptr, &header->binaries[i].osabi_version);
ptr = getui16(ptr, &header->binaries[i].machine);
ptr = getui16(ptr, &header->binaries[i].reserved0);
ptr = getui64(ptr, &header->binaries[i].offset);
ptr = getui64(ptr, &header->binaries[i].size);
ptr = getui16(ptr, &header->records[i].osabi);
ptr = getui16(ptr, &header->records[i].osabi_version);
ptr = getui16(ptr, &header->records[i].machine);
ptr = getui16(ptr, &header->records[i].reserved0);
ptr = getui64(ptr, &header->records[i].offset);
ptr = getui64(ptr, &header->records[i].size);
} // for

assert(ptr == (fullbuf + buflen));
Expand Down
2 changes: 1 addition & 1 deletion utils/fatelf-utils.h
View file
Expand Up @@ -69,7 +69,7 @@ uint64_t xcopyfile(const char *in, const int infd,
const char *out, const int outfd);

// read the parts of an ELF header we care about.
void xread_elf_header(const char *fname, const int fd, FATELF_binary_info *i);
void xread_elf_header(const char *fname, const int fd, FATELF_record *rec);

// How many bytes to allocate for a FATELF_header.
size_t fatelf_header_size(const int bincount);
Expand Down

0 comments on commit 8d26453

Please sign in to comment.