path: root/modules/objfmts/elf/elf.c

/*
 * ELF object format helpers
 *
 *  Copyright (C) 2003-2007  Michael Urman
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER 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 AUTHOR OR OTHER 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.
 */

#include <util.h>

#include <libyasm.h>
#define YASM_OBJFMT_ELF_INTERNAL
#include "elf.h"
#include "elf-machine.h"

static void elf_section_data_destroy(void *data);
static void elf_secthead_print(void *data, FILE *f, int indent_level);

const yasm_assoc_data_callback elf_section_data = {
    elf_section_data_destroy,
    elf_secthead_print
};

static void elf_symrec_data_destroy(/*@only@*/ void *d);
static void elf_symtab_entry_print(void *data, FILE *f, int indent_level);
static void elf_ssym_symtab_entry_print(void *data, FILE *f, int indent_level);

const yasm_assoc_data_callback elf_symrec_data = {
    elf_symrec_data_destroy,
    elf_symtab_entry_print
};

const yasm_assoc_data_callback elf_ssym_symrec_data = {
    elf_symrec_data_destroy,
    elf_ssym_symtab_entry_print
};

extern elf_machine_handler
    elf_machine_handler_x86_x86,
    elf_machine_handler_x86_amd64,
    elf_machine_handler_x86_x32;

static const elf_machine_handler *elf_machine_handlers[] =
{
    &elf_machine_handler_x86_x86,
    &elf_machine_handler_x86_amd64,
    &elf_machine_handler_x86_x32,
    NULL
};
static const elf_machine_handler elf_null_machine = {0, 0, 0, 0, 0, 0, 0, 0,
                                                     0, 0, 0, 0, 0, 0, 0, 0,
                                                     0, 0, 0};
static elf_machine_handler const *elf_march = &elf_null_machine;
static yasm_symrec **elf_ssyms;

const elf_machine_handler *
elf_set_arch(yasm_arch *arch, yasm_symtab *symtab, int bits_pref)
{
    const char *machine = yasm_arch_get_machine(arch);
    int i;

    for (i=0, elf_march = elf_machine_handlers[0];
         elf_march != NULL;
         elf_march = elf_machine_handlers[++i])
    {
        if (yasm__strcasecmp(yasm_arch_keyword(arch), elf_march->arch)==0)
            if (yasm__strcasecmp(machine, elf_march->machine)==0) {
                if (bits_pref == 0 || bits_pref == elf_march->bits)
                    break;
            } else if (bits_pref == elf_march->bits
                       && yasm__strcasecmp(machine, "amd64") == 0
                       && yasm__strcasecmp(elf_march->machine, "x32") == 0)
                break;
    }

    if (elf_march && elf_march->num_ssyms > 0)
    {
        /* Allocate "special" syms */
        elf_ssyms =
            yasm_xmalloc(elf_march->num_ssyms * sizeof(yasm_symrec *));
        for (i=0; (unsigned int)i<elf_march->num_ssyms; i++)
        {
            /* FIXME: misuse of NULL bytecode */
            elf_ssyms[i] = yasm_symtab_define_label(symtab,
                                                    elf_march->ssyms[i].name,
                                                    NULL, 0, 0);
            yasm_symrec_add_data(elf_ssyms[i], &elf_ssym_symrec_data,
                                 (void*)&elf_march->ssyms[i]);
        }
    }

    return elf_march;
}

yasm_symrec *
elf_get_special_sym(const char *name, const char *parser)
{
    int i;
    for (i=0; (unsigned int)i<elf_march->num_ssyms; i++) {
        if (yasm__strcasecmp(name, elf_march->ssyms[i].name) == 0)
            return elf_ssyms[i];
    }
    return NULL;
}

/* reloc functions */
int elf_ssym_has_flag(yasm_symrec *wrt, int flag);

int
elf_is_wrt_sym_relative(yasm_symrec *wrt)
{
    return elf_ssym_has_flag(wrt, ELF_SSYM_SYM_RELATIVE);
}

int
elf_is_wrt_pos_adjusted(yasm_symrec *wrt)
{
    return elf_ssym_has_flag(wrt, ELF_SSYM_CURPOS_ADJUST);
}

int
elf_ssym_has_flag(yasm_symrec *wrt, int flag)
{
    int i;
    for (i=0; (unsigned int)i<elf_march->num_ssyms; i++) {
        if (elf_ssyms[i] == wrt)
            return (elf_march->ssyms[i].sym_rel & flag) != 0;
    }
    return 0;
}

/* takes ownership of addr */
elf_reloc_entry *
elf_reloc_entry_create(yasm_symrec *sym,
                       yasm_symrec *wrt,
                       yasm_intnum *addr,
                       int rel,
                       size_t valsize,
                       int is_GOT_sym)
{
    elf_reloc_entry *entry;

    if (!elf_march->accepts_reloc)
        yasm_internal_error(N_("Unsupported machine for ELF output"));

    if (!elf_march->accepts_reloc(valsize, wrt))
    {
        if (addr)
            yasm_intnum_destroy(addr);
        return NULL;
    }

    if (sym == NULL)
        yasm_internal_error("sym is null");

    entry = yasm_xmalloc(sizeof(elf_reloc_entry));
    entry->reloc.sym = sym;
    entry->reloc.addr = addr;
    entry->rtype_rel = rel;
    entry->valsize = valsize;
    entry->addend = NULL;
    entry->wrt = wrt;
    entry->is_GOT_sym = is_GOT_sym;

    return entry;
}

void
elf_reloc_entry_destroy(void *entry)
{
    if (((elf_reloc_entry*)entry)->addend)
        yasm_intnum_destroy(((elf_reloc_entry*)entry)->addend);
    yasm_xfree(entry);
}

/* strtab functions */
elf_strtab_entry *
elf_strtab_entry_create(const char *str)
{
    elf_strtab_entry *entry = yasm_xmalloc(sizeof(elf_strtab_entry));
    entry->str = yasm__xstrdup(str);
    entry->index = 0;
    return entry;
}

void
elf_strtab_entry_set_str(elf_strtab_entry *entry, const char *str)
{
    elf_strtab_entry *last;
    if (entry->str)
        yasm_xfree(entry->str);
    entry->str = yasm__xstrdup(str);

    /* Update all following indices since string length probably changes */
    last = entry;
    entry = STAILQ_NEXT(last, qlink);
    while (entry) {
        entry->index = last->index + (unsigned long)strlen(last->str) + 1;
        last = entry;
        entry = STAILQ_NEXT(last, qlink);
    }
}

elf_strtab_head *
elf_strtab_create()
{
    elf_strtab_head *strtab = yasm_xmalloc(sizeof(elf_strtab_head));
    elf_strtab_entry *entry = yasm_xmalloc(sizeof(elf_strtab_entry));

    STAILQ_INIT(strtab);
    entry->index = 0;
    entry->str = yasm__xstrdup("");

    STAILQ_INSERT_TAIL(strtab, entry, qlink);
    return strtab;
}

elf_strtab_entry *
elf_strtab_append_str(elf_strtab_head *strtab, const char *str)
{
    elf_strtab_entry *last, *entry;

    if (strtab == NULL)
        yasm_internal_error("strtab is null");
    if (STAILQ_EMPTY(strtab))
        yasm_internal_error("strtab is missing initial dummy entry");

    last = STAILQ_LAST(strtab, elf_strtab_entry, qlink);

    entry = elf_strtab_entry_create(str);
    entry->index = last->index + (unsigned long)strlen(last->str) + 1;

    STAILQ_INSERT_TAIL(strtab, entry, qlink);
    return entry;
}

void
elf_strtab_destroy(elf_strtab_head *strtab)
{
    elf_strtab_entry *s1, *s2;

    if (strtab == NULL)
        yasm_internal_error("strtab is null");
    if (STAILQ_EMPTY(strtab))
        yasm_internal_error("strtab is missing initial dummy entry");

    s1 = STAILQ_FIRST(strtab);
    while (s1 != NULL) {
        s2 = STAILQ_NEXT(s1, qlink);
        yasm_xfree(s1->str);
        yasm_xfree(s1);
        s1 = s2;
    }
    yasm_xfree(strtab);
}

unsigned long
elf_strtab_output_to_file(FILE *f, elf_strtab_head *strtab)
{
    unsigned long size = 0;
    elf_strtab_entry *entry;

    if (strtab == NULL)
        yasm_internal_error("strtab is null");

    /* consider optimizing tables here */
    STAILQ_FOREACH(entry, strtab, qlink) {
        size_t len = 1 + strlen(entry->str);
        fwrite(entry->str, len, 1, f);
        size += (unsigned long)len;
    }
    return size;
}



/* symtab functions */
elf_symtab_entry *
elf_symtab_entry_create(elf_strtab_entry *name,
                        yasm_symrec *sym)
{
    elf_symtab_entry *entry = yasm_xmalloc(sizeof(elf_symtab_entry));
    entry->in_table = 0;
    entry->sym = sym;
    entry->sect = NULL;
    entry->name = name;
    entry->value = 0;

    entry->xsize = NULL;
    entry->size = 0;
    entry->index = 0;
    entry->bind = 0;
    entry->type = STT_NOTYPE;
    entry->vis = STV_DEFAULT;

    return entry;
}

static void
elf_symtab_entry_destroy(elf_symtab_entry *entry)
{
    if (entry == NULL)
        yasm_internal_error("symtab entry is null");

    yasm_xfree(entry);
}

static void
elf_symrec_data_destroy(void *data)
{
    /* do nothing, as this stuff is in the symtab anyway...  this speaks of bad
     * design/use or this stuff, i fear */

    /* watch for double-free here ... */
    /*elf_symtab_entry_destroy((elf_symtab_entry *)data);*/
}

static void
elf_symtab_entry_print(void *data, FILE *f, int indent_level)
{
    elf_symtab_entry *entry = data;
    if (entry == NULL)
        yasm_internal_error("symtab entry is null");

    fprintf(f, "%*sbind=", indent_level, "");
    switch (entry->bind) {
        case STB_LOCAL:         fprintf(f, "local\n");  break;
        case STB_GLOBAL:        fprintf(f, "global\n"); break;
        case STB_WEAK:          fprintf(f, "weak\n");   break;
        default:                fprintf(f, "undef\n");  break;
    }
    fprintf(f, "%*stype=", indent_level, "");
    switch (entry->type) {
        case STT_NOTYPE:        fprintf(f, "notype\n"); break;
        case STT_OBJECT:        fprintf(f, "object\n"); break;
        case STT_FUNC:          fprintf(f, "func\n");   break;
        case STT_SECTION:       fprintf(f, "section\n");break;
        case STT_FILE:          fprintf(f, "file\n");   break;
        default:                fprintf(f, "undef\n");  break;
    }
    fprintf(f, "%*ssize=", indent_level, "");
    if (entry->xsize)
        yasm_expr_print(entry->xsize, f);
    else
        fprintf(f, "%ld", entry->size);
    fprintf(f, "\n");
}

static void
elf_ssym_symtab_entry_print(void *data, FILE *f, int indent_level)
{
    /* TODO */
}

elf_symtab_head *
elf_symtab_create()
{
    elf_symtab_head *symtab = yasm_xmalloc(sizeof(elf_symtab_head));
    elf_symtab_entry *entry = yasm_xmalloc(sizeof(elf_symtab_entry));

    STAILQ_INIT(symtab);
    entry->in_table = 1;
    entry->sym = NULL;
    entry->sect = NULL;
    entry->name = NULL;
    entry->value = 0;
    entry->xsize = NULL;
    entry->size = 0;
    entry->index = SHN_UNDEF;
    entry->bind = STB_LOCAL;
    entry->type = STT_NOTYPE;
    entry->vis = STV_DEFAULT;
    entry->symindex = 0;
    STAILQ_INSERT_TAIL(symtab, entry, qlink);
    return symtab;
}

void
elf_symtab_append_entry(elf_symtab_head *symtab, elf_symtab_entry *entry)
{
    if (symtab == NULL)
        yasm_internal_error("symtab is null");
    if (entry == NULL)
        yasm_internal_error("symtab entry is null");
    if (STAILQ_EMPTY(symtab))
        yasm_internal_error(N_("symtab is missing initial dummy entry"));

    STAILQ_INSERT_TAIL(symtab, entry, qlink);
    entry->in_table = 1;
}

void
elf_symtab_insert_local_sym(elf_symtab_head *symtab, elf_symtab_entry *entry)
{
    elf_symtab_entry *after = STAILQ_FIRST(symtab);
    elf_symtab_entry *before = NULL;

    while (after && (after->bind == STB_LOCAL)) {
        before = after;
        if (before->type == STT_FILE) break;
        after = STAILQ_NEXT(after, qlink);
    }
    STAILQ_INSERT_AFTER(symtab, before, entry, qlink);
    entry->in_table = 1;
}

void
elf_symtab_destroy(elf_symtab_head *symtab)
{
    elf_symtab_entry *s1, *s2;

    if (symtab == NULL)
        yasm_internal_error("symtab is null");
    if (STAILQ_EMPTY(symtab))
        yasm_internal_error(N_("symtab is missing initial dummy entry"));

    s1 = STAILQ_FIRST(symtab);
    while (s1 != NULL) {
        s2 = STAILQ_NEXT(s1, qlink);
        elf_symtab_entry_destroy(s1);
        s1 = s2;
    }
    yasm_xfree(symtab);
}

unsigned long
elf_symtab_assign_indices(elf_symtab_head *symtab)
{
    elf_symtab_entry *entry, *prev=NULL;
    unsigned long last_local=0;

    if (symtab == NULL)
        yasm_internal_error("symtab is null");
    if (STAILQ_EMPTY(symtab))
        yasm_internal_error(N_("symtab is missing initial dummy entry"));

    STAILQ_FOREACH(entry, symtab, qlink) {
        if (prev)
            entry->symindex = prev->symindex + 1;
        if (entry->bind == STB_LOCAL)
            last_local = entry->symindex;
        prev = entry;
    }
    return last_local + 1;
}

unsigned long
elf_symtab_write_to_file(FILE *f, elf_symtab_head *symtab,
                         yasm_errwarns *errwarns)
{
    unsigned char buf[SYMTAB_MAXSIZE], *bufp;
    elf_symtab_entry *entry, *prev;
    unsigned long size = 0;

    if (!symtab)
        yasm_internal_error(N_("symtab is null"));

    prev = NULL;
    STAILQ_FOREACH(entry, symtab, qlink) {

        yasm_intnum *size_intn=NULL, *value_intn=NULL;
        bufp = buf;

        /* get size (if specified); expr overrides stored integer */
        if (entry->xsize) {
            size_intn = yasm_intnum_copy(
                yasm_expr_get_intnum(&entry->xsize, 1));
            if (!size_intn) {
                yasm_error_set(YASM_ERROR_VALUE,
                               N_("size specifier not an integer expression"));
                yasm_errwarn_propagate(errwarns, entry->xsize->line);
            }
        }
        else
            size_intn = yasm_intnum_create_uint(entry->size);

        /* get EQU value for constants */
        if (entry->sym) {
            const yasm_expr *equ_expr_c;
            equ_expr_c = yasm_symrec_get_equ(entry->sym);

            if (equ_expr_c != NULL) {
                const yasm_intnum *equ_intn;
                yasm_expr *equ_expr = yasm_expr_copy(equ_expr_c);
                equ_intn = yasm_expr_get_intnum(&equ_expr, 1);

                if (equ_intn == NULL) {
                    yasm_error_set(YASM_ERROR_VALUE,
                                   N_("EQU value not an integer expression"));
                    yasm_errwarn_propagate(errwarns, equ_expr->line);
                } else
                    value_intn = yasm_intnum_copy(equ_intn);
                entry->index = SHN_ABS;
                yasm_expr_destroy(equ_expr);
            }
        }
        if (value_intn == NULL)
            value_intn = yasm_intnum_create_uint(entry->value);

        /* If symbol is in a TLS section, force its type to TLS. */
        if (entry->sym) {
            yasm_bytecode *precbc;
            yasm_section *sect;
            elf_secthead *shead;
            if (yasm_symrec_get_label(entry->sym, &precbc) &&
                (sect = yasm_bc_get_section(precbc)) &&
                (shead = yasm_section_get_data(sect, &elf_section_data)) &&
                shead->flags & SHF_TLS) {
                entry->type = STT_TLS;
            }
        }

        if (!elf_march->write_symtab_entry || !elf_march->symtab_entry_size)
            yasm_internal_error(N_("Unsupported machine for ELF output"));
        elf_march->write_symtab_entry(bufp, entry, value_intn, size_intn);
        fwrite(buf, elf_march->symtab_entry_size, 1, f);
        size += elf_march->symtab_entry_size;

        yasm_intnum_destroy(size_intn);
        yasm_intnum_destroy(value_intn);

        prev = entry;
    }
    return size;
}

void elf_symtab_set_nonzero(elf_symtab_entry *entry,
                            yasm_section *sect,
                            elf_section_index sectidx,
                            elf_symbol_binding bind,
                            elf_symbol_type type,
                            yasm_expr *xsize,
                            elf_address *value)
{
    if (!entry)
        yasm_internal_error("NULL entry");
    if (sect) entry->sect = sect;
    if (sectidx) entry->index = sectidx;
    if (bind) entry->bind = bind;
    if (type) entry->type = type;
    if (xsize) entry->xsize = xsize;
    if (value) entry->value = *value;
}

void
elf_sym_set_visibility(elf_symtab_entry *entry,
                       elf_symbol_vis    vis)
{
    entry->vis = ELF_ST_VISIBILITY(vis);
}                            

void
elf_sym_set_type(elf_symtab_entry *entry,
                 elf_symbol_type   type)
{
    entry->type = type;
}                            

void
elf_sym_set_size(elf_symtab_entry *entry,
                 struct yasm_expr *size)
{
    if (entry->xsize)
        yasm_expr_destroy(entry->xsize);
    entry->xsize = size;
}                            

int
elf_sym_in_table(elf_symtab_entry *entry)
{
    return entry->in_table;
}

elf_secthead *
elf_secthead_create(elf_strtab_entry    *name,
                    elf_section_type     type,
                    elf_section_flags    flags,
                    elf_address          offset,
                    elf_size             size)
{
    elf_secthead *esd = yasm_xmalloc(sizeof(elf_secthead));

    esd->type = type;
    esd->flags = flags;
    esd->offset = offset;
    esd->size = yasm_intnum_create_uint(size);
    esd->link = 0;
    esd->info = 0;
    esd->align = 0;
    esd->entsize = 0;
    esd->index = 0;

    esd->sym = NULL;
    esd->name = name;
    esd->index = 0;
    esd->rel_name = NULL;
    esd->rel_index = 0;
    esd->rel_offset = 0;
    esd->nreloc = 0;

    if (name && (strcmp(name->str, ".symtab") == 0)) {
        if (!elf_march->symtab_entry_size || !elf_march->symtab_entry_align)
            yasm_internal_error(N_("unsupported ELF format"));
        esd->entsize = elf_march->symtab_entry_size;
        esd->align = elf_march->symtab_entry_align;
    }

    return esd;
}

void
elf_secthead_destroy(elf_secthead *shead)
{
    if (shead == NULL)
        yasm_internal_error(N_("shead is null"));

    yasm_intnum_destroy(shead->size);

    yasm_xfree(shead);
}

static void
elf_section_data_destroy(void *data)
{
    elf_secthead_destroy((elf_secthead *)data);
}

static void
elf_secthead_print(void *data, FILE *f, int indent_level)
{
    elf_secthead *sect = data;
    fprintf(f, "%*sname=%s\n", indent_level, "",
            sect->name ? sect->name->str : "<undef>");
    fprintf(f, "%*ssym=\n", indent_level, "");
    yasm_symrec_print(sect->sym, f, indent_level+1);
    fprintf(f, "%*sindex=0x%x\n", indent_level, "", sect->index);
    fprintf(f, "%*sflags=", indent_level, "");
    if (sect->flags & SHF_WRITE)
        fprintf(f, "WRITE ");
    if (sect->flags & SHF_ALLOC)
        fprintf(f, "ALLOC ");
    if (sect->flags & SHF_EXECINSTR)
        fprintf(f, "EXEC ");
    /*if (sect->flags & SHF_MASKPROC)
        fprintf(f, "PROC-SPECIFIC"); */
    fprintf(f, "%*soffset=0x%lx\n", indent_level, "", sect->offset);
    fprintf(f, "%*ssize=0x%lx\n", indent_level, "",
            yasm_intnum_get_uint(sect->size));
    fprintf(f, "%*slink=0x%x\n", indent_level, "", sect->link);
    fprintf(f, "%*salign=%lu\n", indent_level, "", sect->align);
    fprintf(f, "%*snreloc=%ld\n", indent_level, "", sect->nreloc);
}

unsigned long
elf_secthead_write_to_file(FILE *f, elf_secthead *shead,
                           elf_section_index sindex)
{
    unsigned char buf[SHDR_MAXSIZE], *bufp = buf;
    shead->index = sindex;

    if (shead == NULL)
        yasm_internal_error("shead is null");

    if (!elf_march->write_secthead || !elf_march->secthead_size)
        yasm_internal_error(N_("Unsupported machine for ELF output"));
    elf_march->write_secthead(bufp, shead);
    if (fwrite(buf, elf_march->secthead_size, 1, f))
        return elf_march->secthead_size;
    yasm_internal_error(N_("Failed to write an elf section header"));
    return 0;
}

void
elf_secthead_append_reloc(yasm_section *sect, elf_secthead *shead,
                          elf_reloc_entry *reloc)
{
    if (sect == NULL)
        yasm_internal_error("sect is null");
    if (shead == NULL)
        yasm_internal_error("shead is null");
    if (reloc == NULL)
        yasm_internal_error("reloc is null");

    shead->nreloc++;
    yasm_section_add_reloc(sect, (yasm_reloc *)reloc, elf_reloc_entry_destroy);
}

char *
elf_secthead_name_reloc_section(const char *basesect)
{
    if (!elf_march->reloc_section_prefix)
    {
        yasm_internal_error(N_("Unsupported machine for ELF output"));
        return NULL;
    }
    else
    {
        size_t prepend_length = strlen(elf_march->reloc_section_prefix);
        char *sectname = yasm_xmalloc(prepend_length + strlen(basesect) + 1);
        strcpy(sectname, elf_march->reloc_section_prefix);
        strcat(sectname, basesect);
        return sectname;
    }
}

void
elf_handle_reloc_addend(yasm_intnum *intn,
                        elf_reloc_entry *reloc,
                        unsigned long offset)
{
    if (!elf_march->handle_reloc_addend)
        yasm_internal_error(N_("Unsupported machine for ELF output"));
    elf_march->handle_reloc_addend(intn, reloc, offset);
}

unsigned long
elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab_idx,
                               yasm_section *sect, elf_secthead *shead,
                               elf_section_index sindex)
{
    unsigned char buf[SHDR_MAXSIZE], *bufp = buf;

    if (shead == NULL)
        yasm_internal_error("shead is null");

    if (!yasm_section_relocs_first(sect))
        return 0;       /* no relocations, no .rel.* section header */

    shead->rel_index = sindex;

    if (!elf_march->write_secthead_rel || !elf_march->secthead_size)
        yasm_internal_error(N_("Unsupported machine for ELF output"));
    elf_march->write_secthead_rel(bufp, shead, symtab_idx, sindex);
    if (fwrite(buf, elf_march->secthead_size, 1, f))
        return elf_march->secthead_size;
    yasm_internal_error(N_("Failed to write an elf section header"));
    return 0;
}

unsigned long
elf_secthead_write_relocs_to_file(FILE *f, yasm_section *sect,
                                  elf_secthead *shead, yasm_errwarns *errwarns)
{
    elf_reloc_entry *reloc;
    unsigned char buf[RELOC_MAXSIZE], *bufp;
    unsigned long size = 0;
    long pos;

    if (shead == NULL)
        yasm_internal_error("shead is null");

    reloc = (elf_reloc_entry *)yasm_section_relocs_first(sect);
    if (!reloc)
        return 0;

    /* first align section to multiple of 4 */
    pos = ftell(f);
    if (pos == -1) {
        yasm_error_set(YASM_ERROR_IO,
                       N_("couldn't read position on output stream"));
        yasm_errwarn_propagate(errwarns, 0);
    }
    pos = (pos + 3) & ~3;
    if (fseek(f, pos, SEEK_SET) < 0) {
        yasm_error_set(YASM_ERROR_IO, N_("couldn't seek on output stream"));
        yasm_errwarn_propagate(errwarns, 0);
    }
    shead->rel_offset = (unsigned long)pos;


    while (reloc) {
        yasm_sym_vis vis;
        unsigned int r_type=0, r_sym;
        elf_symtab_entry *esym;

        esym = yasm_symrec_get_data(reloc->reloc.sym, &elf_symrec_data);
        if (esym)
            r_sym = esym->symindex;
        else
            r_sym = STN_UNDEF;

        vis = yasm_symrec_get_visibility(reloc->reloc.sym);
        if (!elf_march->map_reloc_info_to_type)
            yasm_internal_error(N_("Unsupported arch/machine for elf output"));
        r_type = elf_march->map_reloc_info_to_type(reloc);

        bufp = buf;
        if (!elf_march->write_reloc || !elf_march->reloc_entry_size)
            yasm_internal_error(N_("Unsupported arch/machine for elf output"));
        elf_march->write_reloc(bufp, reloc, r_type, r_sym);
        fwrite(buf, elf_march->reloc_entry_size, 1, f);
        size += elf_march->reloc_entry_size;

        reloc = (elf_reloc_entry *)
            yasm_section_reloc_next((yasm_reloc *)reloc);
    }
    return size;
}

elf_section_type
elf_secthead_get_type(elf_secthead *shead)
{
    return shead->type;
}

void
elf_secthead_set_typeflags(elf_secthead *shead, elf_section_type type,
                           elf_section_flags flags)
{
    shead->type = type;
    shead->flags = flags;
}

int
elf_secthead_is_empty(elf_secthead *shead)
{
    return yasm_intnum_is_zero(shead->size);
}

yasm_symrec *
elf_secthead_get_sym(elf_secthead *shead)
{
    return shead->sym;
}

elf_section_index
elf_secthead_get_index(elf_secthead *shead)
{
    return shead->index;
}

unsigned long
elf_secthead_get_align(const elf_secthead *shead)
{
    return shead->align;
}

unsigned long
elf_secthead_set_align(elf_secthead *shead, unsigned long align)
{
    return shead->align = align;
}

elf_section_info
elf_secthead_set_info(elf_secthead *shead, elf_section_info info)
{
    return shead->info = info;
}

elf_section_index
elf_secthead_set_index(elf_secthead *shead, elf_section_index sectidx)
{
    return shead->index = sectidx;
}

elf_section_index
elf_secthead_set_link(elf_secthead *shead, elf_section_index link)
{
    return shead->link = link;
}

elf_section_index
elf_secthead_set_rel_index(elf_secthead *shead, elf_section_index sectidx)
{
    return shead->rel_index = sectidx;
}

elf_strtab_entry *
elf_secthead_set_rel_name(elf_secthead *shead, elf_strtab_entry *entry)
{
    return shead->rel_name = entry;
}

elf_size
elf_secthead_set_entsize(elf_secthead *shead, elf_size size)
{
    return shead->entsize = size;
}

yasm_symrec *
elf_secthead_set_sym(elf_secthead *shead, yasm_symrec *sym)
{
    return shead->sym = sym;
}

void
elf_secthead_add_size(elf_secthead *shead, yasm_intnum *size)
{
    if (size) {
        yasm_intnum_calc(shead->size, YASM_EXPR_ADD, size);
    }
}

long
elf_secthead_set_file_offset(elf_secthead *shead, long pos)
{
    unsigned long align = shead->align;

    if (align == 0 || align == 1) {
        shead->offset = (unsigned long)pos;
        return pos;
    }
    else if (align & (align - 1))
        yasm_internal_error(
            N_("alignment %d for section `%s' is not a power of 2"));
            /*, align, sect->name->str);*/

    shead->offset = (unsigned long)((pos + align - 1) & ~(align - 1));
    return (long)shead->offset;
}

unsigned long
elf_proghead_get_size(void)
{
    if (!elf_march->proghead_size)
        yasm_internal_error(N_("Unsupported ELF format for output"));
    return elf_march->proghead_size;
}

unsigned long
elf_proghead_write_to_file(FILE *f,
                           elf_offset secthead_addr,
                           unsigned long secthead_count,
                           elf_section_index shstrtab_index)
{
    unsigned char buf[EHDR_MAXSIZE], *bufp = buf;

    YASM_WRITE_8(bufp, ELFMAG0);                /* ELF magic number */
    YASM_WRITE_8(bufp, ELFMAG1);
    YASM_WRITE_8(bufp, ELFMAG2);
    YASM_WRITE_8(bufp, ELFMAG3);

    if (!elf_march->write_proghead || !elf_march->proghead_size)
        yasm_internal_error(N_("Unsupported ELF format for output"));
    elf_march->write_proghead(&bufp, secthead_addr, secthead_count, shstrtab_index);

    if (((unsigned)(bufp - buf)) != elf_march->proghead_size)
        yasm_internal_error(N_("ELF program header is not proper length"));

    if (fwrite(buf, elf_march->proghead_size, 1, f))
        return elf_march->proghead_size;

    yasm_internal_error(N_("Failed to write ELF program header"));
    return 0;
}