out.c

/* neatcc ELF object generation */
#include <elf.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "ncc.h"

#define ALIGN(x, a)		(((x) + (a) - 1) & ~((a) - 1))

#define SEC_TEXT		1
#define SEC_REL			2
#define SEC_SYMS		3
#define SEC_SYMSTR		4
#define SEC_DAT			5
#define SEC_DATREL		6
#define SEC_BSS			7
#define NSECS			8

/* simplified elf struct and macro names */
#if LONGSZ == 8
#  define USERELA	1
#  define Elf_Ehdr	Elf64_Ehdr
#  define Elf_Shdr	Elf64_Shdr
#  define Elf_Sym	Elf64_Sym
#  define Elf_Rel	Elf64_Rela
#  define ELF_ST_INFO	ELF64_ST_INFO
#  define ELF_ST_BIND	ELF64_ST_BIND
#  define ELF_R_SYM	ELF64_R_SYM
#  define ELF_R_TYPE	ELF64_R_TYPE
#  define ELF_R_INFO	ELF64_R_INFO
#else
#  define USERELA	0
#  define Elf_Ehdr	Elf32_Ehdr
#  define Elf_Shdr	Elf32_Shdr
#  define Elf_Sym	Elf32_Sym
#  define Elf_Rel	Elf32_Rel
#  define ELF_ST_INFO	ELF32_ST_INFO
#  define ELF_ST_BIND	ELF32_ST_BIND
#  define ELF_R_SYM	ELF32_R_SYM
#  define ELF_R_TYPE	ELF32_R_TYPE
#  define ELF_R_INFO	ELF32_R_INFO
#endif

static Elf_Ehdr ehdr;
static Elf_Shdr shdr[NSECS];
static Elf_Sym *syms;
static long syms_n, syms_sz;
static char *symstr;
static long symstr_n, symstr_sz;

static Elf_Rel *dsrel;
static long dsrel_n, dsrel_sz;
static Elf_Rel *csrel;
static long csrel_n, csrel_sz;

void err(char *msg, ...);
static int rel_type(int flags);
static void ehdr_init(Elf_Ehdr *ehdr);

static long symstr_add(char *name)
{
	long len = strlen(name) + 1;
	if (symstr_n + len >= symstr_sz) {
		symstr_sz = MAX(512, symstr_sz * 2);
		symstr = mextend(symstr, symstr_n, symstr_sz, sizeof(symstr[0]));
	}
	strcpy(symstr + symstr_n, name);
	symstr_n += len;
	return symstr_n - len;
}

static long sym_find(char *name)
{
	int i;
	for (i = 0; i < syms_n; i++)
		if (!strcmp(name, symstr + syms[i].st_name))
			return i;
	return -1;
}

static Elf_Sym *put_sym(char *name)
{
	long found = sym_find(name);
	Elf_Sym *sym;
	if (found >= 0)
		return &syms[found];
	if (syms_n >= syms_sz) {
		syms_sz = MAX(128, syms_sz * 2);
		syms = mextend(syms, syms_n, syms_sz, sizeof(syms[0]));
	}
	sym = &syms[syms_n++];
	sym->st_name = symstr_add(name);
	sym->st_shndx = SHN_UNDEF;
	sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC);
	return sym;
}

#define SYMLOCAL(i)		(ELF_ST_BIND(syms[i].st_info) == STB_LOCAL)

static void mvrela(long *mv, Elf_Rel *rels, long n)
{
	long i;
	for (i = 0; i < n; i++) {
		int sym = ELF_R_SYM(rels[i].r_info);
		int type = ELF_R_TYPE(rels[i].r_info);
		rels[i].r_info = ELF_R_INFO(mv[sym], type);
	}
}

static int syms_sort(void)
{
	long *mv;
	int i, j;
	int glob_beg = 1;
	mv = malloc(syms_n * sizeof(mv[0]));
	for (i = 0; i < syms_n; i++)
		mv[i] = i;
	i = 1;
	j = syms_n - 1;
	while (1) {
		Elf_Sym t;
		while (i < j && SYMLOCAL(i))
			i++;
		while (j >= i && !SYMLOCAL(j))
			j--;
		if (i >= j)
			break;
		t = syms[j];
		syms[j] = syms[i];
		syms[i] = t;
		mv[i] = j;
		mv[j] = i;
	}
	glob_beg = j + 1;
	mvrela(mv, csrel, csrel_n);
	mvrela(mv, dsrel, dsrel_n);
	free(mv);
	return glob_beg;
}

void out_init(long flags)
{
	put_sym("");
}

/* return a symbol identifier */
void out_def(char *name, long flags, long off, long len)
{
	Elf_Sym *sym = put_sym(name);
	int type = (flags & OUT_CS) ? STT_FUNC : STT_OBJECT;
	int bind = (flags & OUT_GLOB) ? STB_GLOBAL : STB_LOCAL;
	if (flags & OUT_CS)
		sym->st_shndx = SEC_TEXT;
	if (flags & OUT_DS)
		sym->st_shndx = SEC_DAT;
	if (flags & OUT_BSS)
		sym->st_shndx = SEC_BSS;
	sym->st_info = ELF_ST_INFO(bind, type);
	sym->st_value = off;
	sym->st_size = len;
}

long out_sym(char *name)
{
	return put_sym(name) - syms;
}

static void out_csrel(long idx, long off, int flags)
{
	Elf_Rel *r;
	if (csrel_n >= csrel_sz) {
		csrel_sz = MAX(128, csrel_sz * 2);
		csrel = mextend(csrel, csrel_n, csrel_sz, sizeof(csrel[0]));
	}
	r = &csrel[csrel_n++];
	r->r_offset = off;
	r->r_info = ELF_R_INFO(idx, rel_type(flags));
}

static void out_dsrel(long idx, long off, int flags)
{
	Elf_Rel *r;
	if (dsrel_n >= dsrel_sz) {
		dsrel_sz = MAX(128, dsrel_sz * 2);
		dsrel = mextend(dsrel, dsrel_n, dsrel_sz, sizeof(dsrel[0]));
	}
	r = &dsrel[dsrel_n++];
	r->r_offset = off;
	r->r_info = ELF_R_INFO(idx, rel_type(flags));
}

void out_rel(long idx, long flags, long off)
{
	if (flags & OUT_DS)
		out_dsrel(idx, off, flags);
	else
		out_csrel(idx, off, flags);
}

static long bss_len(void)
{
	long len = 0;
	int i;
	for (i = 0; i < syms_n; i++) {
		long end = syms[i].st_value + syms[i].st_size;
		if (syms[i].st_shndx == SEC_BSS)
			if (len < end)
				len = end;
	}
	return len;
}

void out_write(int fd, char *cs, long cslen, char *ds, long dslen)
{
	Elf_Shdr *text_shdr = &shdr[SEC_TEXT];
	Elf_Shdr *rela_shdr = &shdr[SEC_REL];
	Elf_Shdr *symstr_shdr = &shdr[SEC_SYMSTR];
	Elf_Shdr *syms_shdr = &shdr[SEC_SYMS];
	Elf_Shdr *dat_shdr = &shdr[SEC_DAT];
	Elf_Shdr *datrel_shdr = &shdr[SEC_DATREL];
	Elf_Shdr *bss_shdr = &shdr[SEC_BSS];
	unsigned long offset = sizeof(ehdr);

	/* workaround for the idiotic gnuld; use neatld instead! */
	text_shdr->sh_name = symstr_add(".cs");
	rela_shdr->sh_name = symstr_add(USERELA ? ".rela.cs" : ".rels.cs");
	dat_shdr->sh_name = symstr_add(".ds");
	datrel_shdr->sh_name = symstr_add(USERELA ? ".rela.ds" : ".rels.ds");

	ehdr.e_ident[0] = 0x7f;
	ehdr.e_ident[1] = 'E';
	ehdr.e_ident[2] = 'L';
	ehdr.e_ident[3] = 'F';
	ehdr.e_ident[4] = LONGSZ == 8 ? ELFCLASS64 : ELFCLASS32;
	ehdr.e_ident[5] = ELFDATA2LSB;
	ehdr.e_ident[6] = EV_CURRENT;
	ehdr.e_type = ET_REL;
	ehdr_init(&ehdr);
	ehdr.e_version = EV_CURRENT;
	ehdr.e_ehsize = sizeof(ehdr);
	ehdr.e_shentsize = sizeof(shdr[0]);
	ehdr.e_shoff = offset;
	ehdr.e_shnum = NSECS;
	ehdr.e_shstrndx = SEC_SYMSTR;
	offset += sizeof(shdr[0]) * NSECS;

	text_shdr->sh_type = SHT_PROGBITS;
	text_shdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
	text_shdr->sh_offset = offset;
	text_shdr->sh_size = cslen;
	text_shdr->sh_entsize = 1;
	text_shdr->sh_addralign = OUT_ALIGNMENT;
	offset += text_shdr->sh_size;

	rela_shdr->sh_type = USERELA ? SHT_RELA : SHT_REL;
	rela_shdr->sh_link = SEC_SYMS;
	rela_shdr->sh_info = SEC_TEXT;
	rela_shdr->sh_offset = offset;
	rela_shdr->sh_size = csrel_n * sizeof(csrel[0]);
	rela_shdr->sh_entsize = sizeof(csrel[0]);
	offset += rela_shdr->sh_size;

	syms_shdr->sh_type = SHT_SYMTAB;
	syms_shdr->sh_offset = offset;
	syms_shdr->sh_size = syms_n * sizeof(syms[0]);
	syms_shdr->sh_entsize = sizeof(syms[0]);
	syms_shdr->sh_link = SEC_SYMSTR;
	syms_shdr->sh_info = syms_sort();
	offset += syms_shdr->sh_size;

	dat_shdr->sh_type = SHT_PROGBITS;
	dat_shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
	dat_shdr->sh_offset = offset;
	dat_shdr->sh_size = dslen;
	dat_shdr->sh_entsize = 1;
	dat_shdr->sh_addralign = OUT_ALIGNMENT;
	offset += dat_shdr->sh_size;

	datrel_shdr->sh_type = USERELA ? SHT_RELA : SHT_REL;
	datrel_shdr->sh_offset = offset;
	datrel_shdr->sh_size = dsrel_n * sizeof(dsrel[0]);
	datrel_shdr->sh_entsize = sizeof(dsrel[0]);
	datrel_shdr->sh_link = SEC_SYMS;
	datrel_shdr->sh_info = SEC_DAT;
	offset += datrel_shdr->sh_size;

	bss_shdr->sh_type = SHT_NOBITS;
	bss_shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
	bss_shdr->sh_offset = offset;
	bss_shdr->sh_size = bss_len();
	bss_shdr->sh_entsize = 1;
	bss_shdr->sh_addralign = OUT_ALIGNMENT;

	symstr_shdr->sh_type = SHT_STRTAB;
	symstr_shdr->sh_offset = offset;
	symstr_shdr->sh_size = symstr_n;
	symstr_shdr->sh_entsize = 1;
	offset += symstr_shdr->sh_size;

	write(fd, &ehdr, sizeof(ehdr));
	write(fd, shdr,  NSECS * sizeof(shdr[0]));
	write(fd, cs, cslen);
	write(fd, csrel, csrel_n * sizeof(csrel[0]));
	write(fd, syms, syms_n * sizeof(syms[0]));
	write(fd, ds, dslen);
	write(fd, dsrel, dsrel_n * sizeof(dsrel[0]));
	write(fd, symstr, symstr_n);

	free(syms);
	free(symstr);
	free(csrel);
	free(dsrel);
}

/* architecture dependent functions */

#ifdef NEATCC_ARM
static void ehdr_init(Elf_Ehdr *ehdr)
{
	ehdr->e_machine = EM_ARM;
	ehdr->e_flags = EF_ARM_EABI_VER4;
}

static int rel_type(int flags)
{
	if (flags & OUT_RL24)
		return R_ARM_PC24;
	return flags & OUT_RLREL ? R_ARM_REL32 : R_ARM_ABS32;

}
#endif

#ifdef NEATCC_X64
static void ehdr_init(Elf_Ehdr *ehdr)
{
	ehdr->e_machine = EM_X86_64;
}

static int rel_type(int flags)
{
	if (flags & OUT_RLREL)
		return R_X86_64_PC32;
	if (flags & OUT_RL32)
		return flags & OUT_RLSX ? R_X86_64_32S : R_X86_64_32;
	return R_X86_64_64;
}
#endif

#ifdef NEATCC_X86
static void ehdr_init(Elf_Ehdr *ehdr)
{
	ehdr->e_machine = EM_386;
}

static int rel_type(int flags)
{
	return flags & OUT_RLREL ? R_386_PC32 : R_386_32;
}
#endif