CalvinBackup/ghostgram
1
1
Fork 0
mirror of https://github.com/ichmagmaus111/ghostgram.git synced 2026-07-16 20:47:21 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
ghostgram/third-party/yasm/yasm-1.3.0/modules/objfmts/bin/bin-objfmt.c
T

1973 lines
64 KiB
C
Raw Permalink Blame History

/*
* Flat-format binary object format
*
* Copyright (C) 2002-2007 Peter Johnson
*
* 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>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <libyasm.h>
#define REGULAR_OUTBUF_SIZE 1024
typedef struct bin_section_data {
int bss; /* aka nobits */
/* User-provided alignment */
yasm_intnum *align, *valign;
/* User-provided starts */
/*@null@*/ /*@owned@*/ yasm_expr *start, *vstart;
/* User-provided follows */
/*@null@*/ /*@owned@*/ char *follows, *vfollows;
/* Calculated (final) starts, used only during output() */
/*@null@*/ /*@owned@*/ yasm_intnum *istart, *ivstart;
/* Calculated (final) length, used only during output() */
/*@null@*/ /*@owned@*/ yasm_intnum *length;
} bin_section_data;
typedef struct yasm_objfmt_bin {
yasm_objfmt_base objfmt; /* base structure */
enum {
NO_MAP = 0,
MAP_NONE = 0x01,
MAP_BRIEF = 0x02,
MAP_SECTIONS = 0x04,
MAP_SYMBOLS = 0x08
} map_flags;
/*@null@*/ /*@only@*/ char *map_filename;
/*@null@*/ /*@only@*/ yasm_expr *org;
} yasm_objfmt_bin;
/* symrec data is used only for the special symbols section<sectname>.start,
* section<sectname>.vstart, and section<sectname>.length
*/
typedef struct bin_symrec_data {
yasm_section *section; /* referenced section */
enum bin_ssym {
SSYM_START,
SSYM_VSTART,
SSYM_LENGTH
} which;
} bin_symrec_data;
static void bin_section_data_destroy(/*@only@*/ void *d);
static void bin_section_data_print(void *data, FILE *f, int indent_level);
static const yasm_assoc_data_callback bin_section_data_cb = {
bin_section_data_destroy,
bin_section_data_print
};
static void bin_symrec_data_destroy(/*@only@*/ void *d);
static void bin_symrec_data_print(void *data, FILE *f, int indent_level);
static const yasm_assoc_data_callback bin_symrec_data_cb = {
bin_symrec_data_destroy,
bin_symrec_data_print
};
yasm_objfmt_module yasm_bin_LTX_objfmt;
static yasm_objfmt *
bin_objfmt_create(yasm_object *object)
{
yasm_objfmt_bin *objfmt_bin = yasm_xmalloc(sizeof(yasm_objfmt_bin));
objfmt_bin->objfmt.module = &yasm_bin_LTX_objfmt;
objfmt_bin->map_flags = NO_MAP;
objfmt_bin->map_filename = NULL;
objfmt_bin->org = NULL;
return (yasm_objfmt *)objfmt_bin;
}
typedef TAILQ_HEAD(bin_group_head, bin_group) bin_groups;
typedef struct bin_group {
TAILQ_ENTRY(bin_group) link;
yasm_section *section;
bin_section_data *bsd;
/* Groups that (in parallel) logically come immediately after this
* group's section.
*/
bin_groups follow_groups;
} bin_group;
/* Recursive function to find group containing named section. */
static bin_group *
find_group_by_name(bin_groups *groups, const char *name)
{
bin_group *group, *found;
TAILQ_FOREACH(group, groups, link) {
if (strcmp(yasm_section_get_name(group->section), name) == 0)
return group;
/* Recurse to loop through follow groups */
found = find_group_by_name(&group->follow_groups, name);
if (found)
return found;
}
return NULL;
}
/* Recursive function to find group. Returns NULL if not found. */
static bin_group *
find_group_by_section(bin_groups *groups, yasm_section *section)
{
bin_group *group, *found;
TAILQ_FOREACH(group, groups, link) {
if (group->section == section)
return group;
/* Recurse to loop through follow groups */
found = find_group_by_section(&group->follow_groups, section);
if (found)
return found;
}
return NULL;
}
#if 0
/* Debugging function */
static void
print_groups(const bin_groups *groups, int indent_level)
{
bin_group *group;
TAILQ_FOREACH(group, groups, link) {
printf("%*sSection `%s':\n", indent_level, "",
yasm_section_get_name(group->section));
bin_section_data_print(group->bsd, stdout, indent_level+1);
if (!TAILQ_EMPTY(&group->follow_groups)) {
printf("%*sFollowing groups:\n", indent_level, "");
print_groups(&group->follow_groups, indent_level+1);
}
}
}
#endif
static void
bin_group_destroy(/*@only@*/ bin_group *group)
{
bin_group *follow, *group_temp;
TAILQ_FOREACH_SAFE(follow, &group->follow_groups, link, group_temp)
bin_group_destroy(follow);
yasm_xfree(group);
}
typedef struct bin_objfmt_output_info {
yasm_object *object;
yasm_errwarns *errwarns;
/*@dependent@*/ FILE *f;
/*@only@*/ unsigned char *buf;
/*@observer@*/ const yasm_section *sect;
unsigned long start; /* what normal variables go against */
yasm_intnum *origin;
yasm_intnum *tmp_intn; /* temporary working intnum */
bin_groups lma_groups, vma_groups;
} bin_objfmt_output_info;
static int
bin_objfmt_check_sym(yasm_symrec *sym, /*@null@*/ void *d)
{
/*@null@*/ bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
yasm_sym_vis vis = yasm_symrec_get_visibility(sym);
assert(info != NULL);
/* Don't check internally-generated symbols. Only internally generated
* symbols have symrec data, so simply check for its presence.
*/
if (yasm_symrec_get_data(sym, &bin_symrec_data_cb))
return 0;
if (vis & YASM_SYM_EXTERN) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("binary object format does not support extern variables"));
yasm_errwarn_propagate(info->errwarns, yasm_symrec_get_decl_line(sym));
} else if (vis & YASM_SYM_GLOBAL) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("binary object format does not support global variables"));
yasm_errwarn_propagate(info->errwarns, yasm_symrec_get_decl_line(sym));
} else if (vis & YASM_SYM_COMMON) {
yasm_error_set(YASM_ERROR_TYPE,
N_("binary object format does not support common variables"));
yasm_errwarn_propagate(info->errwarns, yasm_symrec_get_decl_line(sym));
}
return 0;
}
static int
bin_lma_create_group(yasm_section *sect, /*@null@*/ void *d)
{
bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
bin_section_data *bsd = yasm_section_get_data(sect, &bin_section_data_cb);
unsigned long align = yasm_section_get_align(sect);
bin_group *group;
assert(info != NULL);
assert(bsd != NULL);
group = yasm_xmalloc(sizeof(bin_group));
group->section = sect;
group->bsd = bsd;
TAILQ_INIT(&group->follow_groups);
/* Determine section alignment as necessary. */
if (!bsd->align)
bsd->align = yasm_intnum_create_uint(align > 4 ? align : 4);
else {
yasm_intnum *align_intn = yasm_intnum_create_uint(align);
if (yasm_intnum_compare(align_intn, bsd->align) > 0) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("section `%s' internal align of %lu is greater than `%s' of %lu; using `%s'"),
yasm_section_get_name(sect),
yasm_intnum_get_uint(align_intn),
N_("align"),
yasm_intnum_get_uint(bsd->align),
N_("align"));
yasm_errwarn_propagate(info->errwarns, 0);
}
yasm_intnum_destroy(align_intn);
}
/* Calculate section integer start. */
if (bsd->start) {
bsd->istart = yasm_expr_get_intnum(&bsd->start, 0);
if (!bsd->istart) {
yasm_error_set(YASM_ERROR_TOO_COMPLEX,
N_("start expression is too complex"));
yasm_errwarn_propagate(info->errwarns, bsd->start->line);
return 1;
} else
bsd->istart = yasm_intnum_copy(bsd->istart);
} else
bsd->istart = NULL;
/* Calculate section integer vstart. */
if (bsd->vstart) {
bsd->ivstart = yasm_expr_get_intnum(&bsd->vstart, 0);
if (!bsd->ivstart) {
yasm_error_set(YASM_ERROR_TOO_COMPLEX,
N_("vstart expression is too complex"));
yasm_errwarn_propagate(info->errwarns, bsd->vstart->line);
return 1;
} else
bsd->ivstart = yasm_intnum_copy(bsd->ivstart);
} else
bsd->ivstart = NULL;
/* Calculate section integer length. */
bsd->length = yasm_calc_bc_dist(yasm_section_bcs_first(sect),
yasm_section_bcs_last(sect));
TAILQ_INSERT_TAIL(&info->lma_groups, group, link);
return 0;
}
static int
bin_vma_create_group(yasm_section *sect, /*@null@*/ void *d)
{
bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
bin_section_data *bsd = yasm_section_get_data(sect, &bin_section_data_cb);
bin_group *group;
assert(info != NULL);
assert(bsd != NULL);
group = yasm_xmalloc(sizeof(bin_group));
group->section = sect;
group->bsd = bsd;
TAILQ_INIT(&group->follow_groups);
TAILQ_INSERT_TAIL(&info->vma_groups, group, link);
return 0;
}
/* Calculates new start address based on alignment constraint.
* Start is modified (rounded up) to the closest aligned value greater than
* what was passed in.
* Align must be a power of 2.
*/
static void
bin_objfmt_align(yasm_intnum *start, const yasm_intnum *align)
{
/* Because alignment is always a power of two, we can use some bit
* trickery to do this easily.
*/
yasm_intnum *align_intn =
yasm_intnum_create_uint(yasm_intnum_get_uint(align)-1);
yasm_intnum_calc(align_intn, YASM_EXPR_AND, start);
if (!yasm_intnum_is_zero(align_intn)) {
/* start = (start & ~(align-1)) + align; */
yasm_intnum_set_uint(align_intn, yasm_intnum_get_uint(align)-1);
yasm_intnum_calc(align_intn, YASM_EXPR_NOT, NULL);
yasm_intnum_calc(align_intn, YASM_EXPR_AND, start);
yasm_intnum_set(start, align);
yasm_intnum_calc(start, YASM_EXPR_ADD, align_intn);
}
yasm_intnum_destroy(align_intn);
}
/* Recursive function to assign start addresses.
* Updates start, last, and vdelta parameters as it goes along.
* The tmp parameter is just a working intnum so one doesn't have to be
* locally allocated for this purpose.
*/
static void
group_assign_start_recurse(bin_group *group, yasm_intnum *start,
yasm_intnum *last, yasm_intnum *vdelta,
yasm_intnum *tmp, yasm_errwarns *errwarns)
{
bin_group *follow_group;
/* Determine LMA */
if (group->bsd->istart) {
yasm_intnum_set(group->bsd->istart, start);
if (group->bsd->align) {
bin_objfmt_align(group->bsd->istart, group->bsd->align);
if (yasm_intnum_compare(start, group->bsd->istart) != 0) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("start inconsistent with align; using aligned value"));
yasm_errwarn_propagate(errwarns, group->bsd->start->line);
}
}
} else {
group->bsd->istart = yasm_intnum_copy(start);
if (group->bsd->align != 0)
bin_objfmt_align(group->bsd->istart, group->bsd->align);
}
/* Determine VMA if either just valign specified or if no v* specified */
if (!group->bsd->vstart) {
if (!group->bsd->vfollows && !group->bsd->valign) {
/* No v* specified, set VMA=LMA+vdelta. */
group->bsd->ivstart = yasm_intnum_copy(group->bsd->istart);
yasm_intnum_calc(group->bsd->ivstart, YASM_EXPR_ADD, vdelta);
} else if (!group->bsd->vfollows) {
/* Just valign specified: set VMA=LMA+vdelta, align VMA, then add
* delta between unaligned and aligned to vdelta parameter.
*/
group->bsd->ivstart = yasm_intnum_copy(group->bsd->istart);
yasm_intnum_calc(group->bsd->ivstart, YASM_EXPR_ADD, vdelta);
yasm_intnum_set(tmp, group->bsd->ivstart);
bin_objfmt_align(group->bsd->ivstart, group->bsd->valign);
yasm_intnum_calc(vdelta, YASM_EXPR_ADD, group->bsd->ivstart);
yasm_intnum_calc(vdelta, YASM_EXPR_SUB, tmp);
}
}
/* Find the maximum end value */
yasm_intnum_set(tmp, group->bsd->istart);
yasm_intnum_calc(tmp, YASM_EXPR_ADD, group->bsd->length);
if (yasm_intnum_compare(tmp, last) > 0) /* tmp > last */
yasm_intnum_set(last, tmp);
/* Recurse for each following group. */
TAILQ_FOREACH(follow_group, &group->follow_groups, link) {
/* Following sections have to follow this one,
* so add length to start.
*/
yasm_intnum_set(start, group->bsd->istart);
yasm_intnum_calc(start, YASM_EXPR_ADD, group->bsd->length);
group_assign_start_recurse(follow_group, start, last, vdelta, tmp,
errwarns);
}
}
/* Recursive function to assign start addresses.
* Updates start parameter as it goes along.
* The tmp parameter is just a working intnum so one doesn't have to be
* locally allocated for this purpose.
*/
static void
group_assign_vstart_recurse(bin_group *group, yasm_intnum *start,
yasm_errwarns *errwarns)
{
bin_group *follow_group;
/* Determine VMA section alignment as necessary.
* Default to LMA alignment if not specified.
*/
if (!group->bsd->valign)
group->bsd->valign = yasm_intnum_copy(group->bsd->align);
else {
unsigned long align = yasm_section_get_align(group->section);
yasm_intnum *align_intn = yasm_intnum_create_uint(align);
if (yasm_intnum_compare(align_intn, group->bsd->valign) > 0) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("section `%s' internal align of %lu is greater than `%s' of %lu; using `%s'"),
yasm_section_get_name(group->section),
yasm_intnum_get_uint(align_intn),
N_("valign"),
yasm_intnum_get_uint(group->bsd->valign),
N_("valign"));
yasm_errwarn_propagate(errwarns, 0);
}
yasm_intnum_destroy(align_intn);
}
/* Determine VMA */
if (group->bsd->ivstart) {
yasm_intnum_set(group->bsd->ivstart, start);
if (group->bsd->valign) {
bin_objfmt_align(group->bsd->ivstart, group->bsd->valign);
if (yasm_intnum_compare(start, group->bsd->ivstart) != 0) {
yasm_error_set(YASM_ERROR_VALUE,
N_("vstart inconsistent with valign"));
yasm_errwarn_propagate(errwarns, group->bsd->vstart->line);
}
}
} else {
group->bsd->ivstart = yasm_intnum_copy(start);
if (group->bsd->valign)
bin_objfmt_align(group->bsd->ivstart, group->bsd->valign);
}
/* Recurse for each following group. */
TAILQ_FOREACH(follow_group, &group->follow_groups, link) {
/* Following sections have to follow this one,
* so add length to start.
*/
yasm_intnum_set(start, group->bsd->ivstart);
yasm_intnum_calc(start, YASM_EXPR_ADD, group->bsd->length);
group_assign_vstart_recurse(follow_group, start, errwarns);
}
}
static /*@null@*/ const yasm_intnum *
get_ssym_value(yasm_symrec *sym)
{
bin_symrec_data *bsymd = yasm_symrec_get_data(sym, &bin_symrec_data_cb);
bin_section_data *bsd;
if (!bsymd)
return NULL;
bsd = yasm_section_get_data(bsymd->section, &bin_section_data_cb);
assert(bsd != NULL);
switch (bsymd->which) {
case SSYM_START: return bsd->istart;
case SSYM_VSTART: return bsd->ivstart;
case SSYM_LENGTH: return bsd->length;
}
return NULL;
}
static /*@only@*/ yasm_expr *
bin_objfmt_expr_xform(/*@returned@*/ /*@only@*/ yasm_expr *e,
/*@unused@*/ /*@null@*/ void *d)
{
int i;
for (i=0; i<e->numterms; i++) {
/*@dependent@*/ yasm_section *sect;
/*@dependent@*/ /*@null@*/ yasm_bytecode *precbc;
/*@null@*/ yasm_intnum *dist;
/*@null@*/ const yasm_intnum *ssymval;
/* Transform symrecs or precbcs that reference sections into
* vstart + intnum(dist).
*/
if (((e->terms[i].type == YASM_EXPR_SYM &&
yasm_symrec_get_label(e->terms[i].data.sym, &precbc)) ||
(e->terms[i].type == YASM_EXPR_PRECBC &&
(precbc = e->terms[i].data.precbc))) &&
(sect = yasm_bc_get_section(precbc)) &&
(dist = yasm_calc_bc_dist(yasm_section_bcs_first(sect), precbc))) {
bin_section_data *bsd;
bsd = yasm_section_get_data(sect, &bin_section_data_cb);
assert(bsd != NULL);
yasm_intnum_calc(dist, YASM_EXPR_ADD, bsd->ivstart);
e->terms[i].type = YASM_EXPR_INT;
e->terms[i].data.intn = dist;
}
/* Transform our special symrecs into the appropriate value */
if (e->terms[i].type == YASM_EXPR_SYM &&
(ssymval = get_ssym_value(e->terms[i].data.sym))) {
e->terms[i].type = YASM_EXPR_INT;
e->terms[i].data.intn = yasm_intnum_copy(ssymval);
}
}
return e;
}
typedef struct map_output_info {
/* address width */
int bytes;
/* intnum output static data areas */
unsigned char *buf;
yasm_intnum *intn;
/* symrec output information */
unsigned long count;
yasm_section *section; /* NULL for EQUs */
yasm_object *object; /* object */
FILE *f; /* map output file */
} map_output_info;
static int
map_prescan_bytes(yasm_section *sect, void *d)
{
bin_section_data *bsd = yasm_section_get_data(sect, &bin_section_data_cb);
map_output_info *info = (map_output_info *)d;
assert(bsd != NULL);
assert(info != NULL);
while (!yasm_intnum_check_size(bsd->length, info->bytes * 8, 0, 0))
info->bytes *= 2;
while (!yasm_intnum_check_size(bsd->istart, info->bytes * 8, 0, 0))
info->bytes *= 2;
while (!yasm_intnum_check_size(bsd->ivstart, info->bytes * 8, 0, 0))
info->bytes *= 2;
return 0;
}
static void
map_print_intnum(const yasm_intnum *intn, map_output_info *info)
{
size_t i;
yasm_intnum_get_sized(intn, info->buf, info->bytes, info->bytes*8, 0, 0,
0);
for (i=info->bytes; i != 0; i--)
fprintf(info->f, "%02X", info->buf[i-1]);
}
static void
map_sections_summary(bin_groups *groups, map_output_info *info)
{
bin_group *group;
TAILQ_FOREACH(group, groups, link) {
bin_section_data *bsd = group->bsd;
assert(bsd != NULL);
assert(info != NULL);
map_print_intnum(bsd->ivstart, info);
fprintf(info->f, " ");
yasm_intnum_set(info->intn, bsd->ivstart);
yasm_intnum_calc(info->intn, YASM_EXPR_ADD, bsd->length);
map_print_intnum(info->intn, info);
fprintf(info->f, " ");
map_print_intnum(bsd->istart, info);
fprintf(info->f, " ");
yasm_intnum_set(info->intn, bsd->istart);
yasm_intnum_calc(info->intn, YASM_EXPR_ADD, bsd->length);
map_print_intnum(info->intn, info);
fprintf(info->f, " ");
map_print_intnum(bsd->length, info);
fprintf(info->f, " ");
fprintf(info->f, "%-*s", 10, bsd->bss ? "nobits" : "progbits");
fprintf(info->f, "%s\n", yasm_section_get_name(group->section));
/* Recurse to loop through follow groups */
map_sections_summary(&group->follow_groups, info);
}
}
static void
map_sections_detail(bin_groups *groups, map_output_info *info)
{
bin_group *group;
TAILQ_FOREACH(group, groups, link) {
bin_section_data *bsd = group->bsd;
size_t i;
const char *s;
s = yasm_section_get_name(group->section);
fprintf(info->f, "---- Section %s ", s);
for (i=0; i<(65-strlen(s)); i++)
fputc('-', info->f);
fprintf(info->f, "\n\nclass: %s",
bsd->bss ? "nobits" : "progbits");
fprintf(info->f, "\nlength: ");
map_print_intnum(bsd->length, info);
fprintf(info->f, "\nstart: ");
map_print_intnum(bsd->istart, info);
fprintf(info->f, "\nalign: ");
map_print_intnum(bsd->align, info);
fprintf(info->f, "\nfollows: %s",
bsd->follows ? bsd->follows : "not defined");
fprintf(info->f, "\nvstart: ");
map_print_intnum(bsd->ivstart, info);
fprintf(info->f, "\nvalign: ");
map_print_intnum(bsd->valign, info);
fprintf(info->f, "\nvfollows: %s\n\n",
bsd->vfollows ? bsd->vfollows : "not defined");
/* Recurse to loop through follow groups */
map_sections_detail(&group->follow_groups, info);
}
}
static int
map_symrec_count(yasm_symrec *sym, void *d)
{
map_output_info *info = (map_output_info *)d;
/*@dependent@*/ yasm_bytecode *precbc;
assert(info != NULL);
/* TODO: autodetect wider size */
if (!info->section && yasm_symrec_get_equ(sym)) {
info->count++;
} else if (yasm_symrec_get_label(sym, &precbc) &&
yasm_bc_get_section(precbc) == info->section) {
info->count++;
}
return 0;
}
static int
map_symrec_output(yasm_symrec *sym, void *d)
{
map_output_info *info = (map_output_info *)d;
const yasm_expr *equ;
/*@dependent@*/ yasm_bytecode *precbc;
/*@only@*/ char *name = yasm_symrec_get_global_name(sym, info->object);
assert(info != NULL);
if (!info->section && (equ = yasm_symrec_get_equ(sym))) {
yasm_expr *realequ = yasm_expr_copy(equ);
realequ = yasm_expr__level_tree
(realequ, 1, 1, 1, 0, bin_objfmt_expr_xform, NULL);
yasm_intnum_set(info->intn, yasm_expr_get_intnum(&realequ, 0));
yasm_expr_destroy(realequ);
map_print_intnum(info->intn, info);
fprintf(info->f, " %s\n", name);
} else if (yasm_symrec_get_label(sym, &precbc) &&
yasm_bc_get_section(precbc) == info->section) {
bin_section_data *bsd =
yasm_section_get_data(info->section, &bin_section_data_cb);
/* Real address */
yasm_intnum_set_uint(info->intn, yasm_bc_next_offset(precbc));
yasm_intnum_calc(info->intn, YASM_EXPR_ADD, bsd->istart);
map_print_intnum(info->intn, info);
fprintf(info->f, " ");
/* Virtual address */
yasm_intnum_set_uint(info->intn, yasm_bc_next_offset(precbc));
yasm_intnum_calc(info->intn, YASM_EXPR_ADD, bsd->ivstart);
map_print_intnum(info->intn, info);
/* Name */
fprintf(info->f, " %s\n", name);
}
yasm_xfree(name);
return 0;
}
static void
map_sections_symbols(bin_groups *groups, map_output_info *info)
{
bin_group *group;
TAILQ_FOREACH(group, groups, link) {
info->count = 0;
info->section = group->section;
yasm_symtab_traverse(info->object->symtab, info, map_symrec_count);
if (info->count > 0) {
const char *s = yasm_section_get_name(group->section);
size_t i;
fprintf(info->f, "---- Section %s ", s);
for (i=0; i<(65-strlen(s)); i++)
fputc('-', info->f);
fprintf(info->f, "\n\n%-*s%-*s%s\n",
info->bytes*2+2, "Real",
info->bytes*2+2, "Virtual",
"Name");
yasm_symtab_traverse(info->object->symtab, info,
map_symrec_output);
fprintf(info->f, "\n\n");
}
/* Recurse to loop through follow groups */
map_sections_symbols(&group->follow_groups, info);
}
}
static void
output_map(bin_objfmt_output_info *info)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)info->object->objfmt;
FILE *f;
int i;
map_output_info mapinfo;
if (objfmt_bin->map_flags == NO_MAP)
return;
if (objfmt_bin->map_flags == MAP_NONE)
objfmt_bin->map_flags = MAP_BRIEF; /* default to brief */
if (!objfmt_bin->map_filename)
f = stdout; /* default to stdout */
else {
f = fopen(objfmt_bin->map_filename, "wt");
if (!f) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("unable to open map file `%s'"),
objfmt_bin->map_filename);
yasm_errwarn_propagate(info->errwarns, 0);
return;
}
}
mapinfo.object = info->object;
mapinfo.f = f;
/* Temporary intnum */
mapinfo.intn = info->tmp_intn;
/* Prescan all values to figure out what width we should make the output
* fields. Start with a minimum of 4.
*/
mapinfo.bytes = 4;
while (!yasm_intnum_check_size(info->origin, mapinfo.bytes * 8, 0, 0))
mapinfo.bytes *= 2;
yasm_object_sections_traverse(info->object, &mapinfo, map_prescan_bytes);
mapinfo.buf = yasm_xmalloc(mapinfo.bytes);
fprintf(f, "\n- YASM Map file ");
for (i=0; i<63; i++)
fputc('-', f);
fprintf(f, "\n\nSource file: %s\n", info->object->src_filename);
fprintf(f, "Output file: %s\n\n", info->object->obj_filename);
fprintf(f, "-- Program origin ");
for (i=0; i<61; i++)
fputc('-', f);
fprintf(f, "\n\n");
map_print_intnum(info->origin, &mapinfo);
fprintf(f, "\n\n");
if (objfmt_bin->map_flags & MAP_BRIEF) {
fprintf(f, "-- Sections (summary) ");
for (i=0; i<57; i++)
fputc('-', f);
fprintf(f, "\n\n%-*s%-*s%-*s%-*s%-*s%-*s%s\n",
mapinfo.bytes*2+2, "Vstart",
mapinfo.bytes*2+2, "Vstop",
mapinfo.bytes*2+2, "Start",
mapinfo.bytes*2+2, "Stop",
mapinfo.bytes*2+2, "Length",
10, "Class", "Name");
map_sections_summary(&info->lma_groups, &mapinfo);
fprintf(f, "\n");
}
if (objfmt_bin->map_flags & MAP_SECTIONS) {
fprintf(f, "-- Sections (detailed) ");
for (i=0; i<56; i++)
fputc('-', f);
fprintf(f, "\n\n");
map_sections_detail(&info->lma_groups, &mapinfo);
}
if (objfmt_bin->map_flags & MAP_SYMBOLS) {
fprintf(f, "-- Symbols ");
for (i=0; i<68; i++)
fputc('-', f);
fprintf(f, "\n\n");
/* We do two passes for EQU and each section; the first pass
* determines the byte width to use for the value and whether any
* symbols are present, the second pass actually outputs the text.
*/
/* EQUs */
mapinfo.count = 0;
mapinfo.section = NULL;
yasm_symtab_traverse(info->object->symtab, &mapinfo, map_symrec_count);
if (mapinfo.count > 0) {
fprintf(f, "---- No Section ");
for (i=0; i<63; i++)
fputc('-', f);
fprintf(f, "\n\n%-*s%s\n", mapinfo.bytes*2+2, "Value", "Name");
yasm_symtab_traverse(info->object->symtab, &mapinfo,
map_symrec_output);
fprintf(f, "\n\n");
}
/* Other sections */
map_sections_symbols(&info->lma_groups, &mapinfo);
}
if (f != stdout)
fclose(f);
yasm_xfree(mapinfo.buf);
}
/* Check for LMA overlap using a simple N^2 algorithm. */
static int
check_lma_overlap(yasm_section *sect, /*@null@*/ void *d)
{
bin_section_data *bsd, *bsd2;
yasm_section *other = (yasm_section *)d;
yasm_intnum *overlap;
if (!d)
return yasm_object_sections_traverse(yasm_section_get_object(sect),
sect, check_lma_overlap);
if (sect == other)
return 0;
bsd = yasm_section_get_data(sect, &bin_section_data_cb);
bsd2 = yasm_section_get_data(other, &bin_section_data_cb);
if (yasm_intnum_is_zero(bsd->length) ||
yasm_intnum_is_zero(bsd2->length))
return 0;
if (yasm_intnum_compare(bsd->istart, bsd2->istart) <= 0) {
overlap = yasm_intnum_copy(bsd->istart);
yasm_intnum_calc(overlap, YASM_EXPR_ADD, bsd->length);
yasm_intnum_calc(overlap, YASM_EXPR_SUB, bsd2->istart);
} else {
overlap = yasm_intnum_copy(bsd2->istart);
yasm_intnum_calc(overlap, YASM_EXPR_ADD, bsd2->length);
yasm_intnum_calc(overlap, YASM_EXPR_SUB, bsd->istart);
}
if (yasm_intnum_sign(overlap) > 0) {
yasm_error_set(YASM_ERROR_GENERAL,
N_("sections `%s' and `%s' overlap by %lu bytes"),
yasm_section_get_name(sect),
yasm_section_get_name(other),
yasm_intnum_get_uint(overlap));
yasm_intnum_destroy(overlap);
return -1;
}
yasm_intnum_destroy(overlap);
return 0;
}
static int
bin_objfmt_output_value(yasm_value *value, unsigned char *buf,
unsigned int destsize,
/*@unused@*/ unsigned long offset, yasm_bytecode *bc,
int warn, /*@null@*/ void *d)
{
/*@null@*/ bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
/*@dependent@*/ /*@null@*/ yasm_bytecode *precbc;
/*@dependent@*/ yasm_section *sect;
assert(info != NULL);
/* Binary objects we need to resolve against object, not against section. */
if (value->rel) {
unsigned int rshift = (unsigned int)value->rshift;
yasm_expr *syme;
/*@null@*/ const yasm_intnum *ssymval;
if (yasm_symrec_is_abs(value->rel)) {
syme = yasm_expr_create_ident(yasm_expr_int(
yasm_intnum_create_uint(0)), bc->line);
} else if (yasm_symrec_get_label(value->rel, &precbc)
&& (sect = yasm_bc_get_section(precbc))) {
syme = yasm_expr_create_ident(yasm_expr_sym(value->rel), bc->line);
} else if ((ssymval = get_ssym_value(value->rel))) {
syme = yasm_expr_create_ident(yasm_expr_int(
yasm_intnum_copy(ssymval)), bc->line);
} else
goto done;
/* Handle PC-relative */
if (value->curpos_rel) {
yasm_expr *sube;
sube = yasm_expr_create(YASM_EXPR_SUB, yasm_expr_precbc(bc),
yasm_expr_int(yasm_intnum_create_uint(bc->len*bc->mult_int)),
bc->line);
syme = yasm_expr_create(YASM_EXPR_SUB, yasm_expr_expr(syme),
yasm_expr_expr(sube), bc->line);
value->curpos_rel = 0;
value->ip_rel = 0;
}
if (value->rshift > 0)
syme = yasm_expr_create(YASM_EXPR_SHR, yasm_expr_expr(syme),
yasm_expr_int(yasm_intnum_create_uint(rshift)), bc->line);
/* Add into absolute portion */
if (!value->abs)
value->abs = syme;
else
value->abs =
yasm_expr_create(YASM_EXPR_ADD, yasm_expr_expr(value->abs),
yasm_expr_expr(syme), bc->line);
value->rel = NULL;
value->rshift = 0;
}
done:
/* Simplify absolute portion of value, transforming symrecs */
if (value->abs)
value->abs = yasm_expr__level_tree
(value->abs, 1, 1, 1, 0, bin_objfmt_expr_xform, NULL);
/* Output */
switch (yasm_value_output_basic(value, buf, destsize, bc, warn,
info->object->arch)) {
case -1:
return 1;
case 0:
break;
default:
return 0;
}
/* Couldn't output, assume it contains an external reference. */
yasm_error_set(YASM_ERROR_GENERAL,
N_("binary object format does not support external references"));
return 1;
}
static int
bin_objfmt_output_bytecode(yasm_bytecode *bc, /*@null@*/ void *d)
{
/*@null@*/ bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
/*@null@*/ /*@only@*/ unsigned char *bigbuf;
unsigned long size = REGULAR_OUTBUF_SIZE;
int gap;
assert(info != NULL);
bigbuf = yasm_bc_tobytes(bc, info->buf, &size, &gap, info,
bin_objfmt_output_value, NULL);
/* Don't bother doing anything else if size ended up being 0. */
if (size == 0) {
if (bigbuf)
yasm_xfree(bigbuf);
return 0;
}
/* Warn that gaps are converted to 0 and write out the 0's. */
if (gap) {
unsigned long left;
yasm_warn_set(YASM_WARN_UNINIT_CONTENTS,
N_("uninitialized space declared in code/data section: zeroing"));
/* Write out in chunks */
memset(info->buf, 0, REGULAR_OUTBUF_SIZE);
left = size;
while (left > REGULAR_OUTBUF_SIZE) {
fwrite(info->buf, REGULAR_OUTBUF_SIZE, 1, info->f);
left -= REGULAR_OUTBUF_SIZE;
}
fwrite(info->buf, left, 1, info->f);
} else {
/* Output buf (or bigbuf if non-NULL) to file */
fwrite(bigbuf ? bigbuf : info->buf, (size_t)size, 1, info->f);
}
/* If bigbuf was allocated, free it */
if (bigbuf)
yasm_xfree(bigbuf);
return 0;
}
/* Check to ensure bytecode is res* (for BSS sections) */
static int
bin_objfmt_no_output_bytecode(yasm_bytecode *bc, /*@null@*/ void *d)
{
/*@null@*/ bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
/*@null@*/ /*@only@*/ unsigned char *bigbuf;
unsigned long size = REGULAR_OUTBUF_SIZE;
int gap;
assert(info != NULL);
bigbuf = yasm_bc_tobytes(bc, info->buf, &size, &gap, info,
bin_objfmt_output_value, NULL);
/* If bigbuf was allocated, free it */
if (bigbuf)
yasm_xfree(bigbuf);
/* Don't bother doing anything else if size ended up being 0. */
if (size == 0)
return 0;
/* Warn if not a gap. */
if (!gap) {
yasm_warn_set(YASM_WARN_GENERAL,
N_("initialized space declared in nobits section: ignoring"));
}
return 0;
}
static int
bin_objfmt_output_section(yasm_section *sect, /*@null@*/ void *d)
{
bin_section_data *bsd = yasm_section_get_data(sect, &bin_section_data_cb);
/*@null@*/ bin_objfmt_output_info *info = (bin_objfmt_output_info *)d;
assert(bsd != NULL);
assert(info != NULL);
if (bsd->bss) {
yasm_section_bcs_traverse(sect, info->errwarns,
info, bin_objfmt_no_output_bytecode);
} else {
yasm_intnum_set(info->tmp_intn, bsd->istart);
yasm_intnum_calc(info->tmp_intn, YASM_EXPR_SUB, info->origin);
if (yasm_intnum_sign(info->tmp_intn) < 0) {
yasm_error_set(YASM_ERROR_VALUE,
N_("section `%s' starts before origin (ORG)"),
yasm_section_get_name(sect));
yasm_errwarn_propagate(info->errwarns, 0);
return 0;
}
if (!yasm_intnum_check_size(info->tmp_intn, sizeof(long)*8, 0, 1)) {
yasm_error_set(YASM_ERROR_VALUE,
N_("section `%s' start value too large"),
yasm_section_get_name(sect));
yasm_errwarn_propagate(info->errwarns, 0);
return 0;
}
if (fseek(info->f, yasm_intnum_get_int(info->tmp_intn) + info->start,
SEEK_SET) < 0)
yasm__fatal(N_("could not seek on output file"));
yasm_section_bcs_traverse(sect, info->errwarns,
info, bin_objfmt_output_bytecode);
}
return 0;
}
static void
bin_objfmt_cleanup(bin_objfmt_output_info *info)
{
bin_group *group, *group_temp;
yasm_xfree(info->buf);
yasm_intnum_destroy(info->origin);
yasm_intnum_destroy(info->tmp_intn);
TAILQ_FOREACH_SAFE(group, &info->lma_groups, link, group_temp)
bin_group_destroy(group);
TAILQ_FOREACH_SAFE(group, &info->vma_groups, link, group_temp)
bin_group_destroy(group);
}
static void
bin_objfmt_output(yasm_object *object, FILE *f, /*@unused@*/ int all_syms,
yasm_errwarns *errwarns)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)object->objfmt;
bin_objfmt_output_info info;
bin_group *group, *lma_group, *vma_group, *group_temp;
yasm_intnum *start, *last, *vdelta;
bin_groups unsorted_groups, bss_groups;
info.start = ftell(f);
/* Set ORG to 0 unless otherwise specified */
if (objfmt_bin->org) {
info.origin = yasm_expr_get_intnum(&objfmt_bin->org, 0);
if (!info.origin) {
yasm_error_set(YASM_ERROR_TOO_COMPLEX,
N_("ORG expression is too complex"));
yasm_errwarn_propagate(errwarns, objfmt_bin->org->line);
return;
}
if (yasm_intnum_sign(info.origin) < 0) {
yasm_error_set(YASM_ERROR_VALUE, N_("ORG expression is negative"));
yasm_errwarn_propagate(errwarns, objfmt_bin->org->line);
return;
}
info.origin = yasm_intnum_copy(info.origin);
} else
info.origin = yasm_intnum_create_uint(0);
info.object = object;
info.errwarns = errwarns;
info.f = f;
info.buf = yasm_xmalloc(REGULAR_OUTBUF_SIZE);
info.tmp_intn = yasm_intnum_create_uint(0);
TAILQ_INIT(&info.lma_groups);
TAILQ_INIT(&info.vma_groups);
/* Check symbol table */
yasm_symtab_traverse(object->symtab, &info, bin_objfmt_check_sym);
/* Create section groups */
if (yasm_object_sections_traverse(object, &info, bin_lma_create_group)) {
bin_objfmt_cleanup(&info);
return; /* error detected */
}
/* Determine section order according to LMA.
* Sections can be ordered either by (priority):
* - follows
* - start
* - progbits/nobits setting
* - order in the input file
*/
/* Look at each group with follows specified, and find the section
* that group is supposed to follow.
*/
TAILQ_FOREACH_SAFE(lma_group, &info.lma_groups, link, group_temp) {
if (lma_group->bsd->follows) {
bin_group *found;
/* Need to find group containing section this section follows. */
found =
find_group_by_name(&info.lma_groups, lma_group->bsd->follows);
if (!found) {
yasm_error_set(YASM_ERROR_VALUE,
N_("section `%s' follows an invalid or unknown section `%s'"),
yasm_section_get_name(lma_group->section),
lma_group->bsd->follows);
yasm_errwarn_propagate(errwarns, 0);
bin_objfmt_cleanup(&info);
return;
}
/* Check for loops */
if (lma_group->section == found->section ||
find_group_by_section(&lma_group->follow_groups,
found->section)) {
yasm_error_set(YASM_ERROR_VALUE,
N_("follows loop between section `%s' and section `%s'"),
yasm_section_get_name(lma_group->section),
yasm_section_get_name(found->section));
yasm_errwarn_propagate(errwarns, 0);
bin_objfmt_cleanup(&info);
return;
}
/* Remove this section from main lma groups list */
TAILQ_REMOVE(&info.lma_groups, lma_group, link);
/* Add it after the section it's supposed to follow. */
TAILQ_INSERT_TAIL(&found->follow_groups, lma_group, link);
}
}
/* Sort the top-level groups according to their start address.
* Use Shell sort for ease of implementation.
* If no start address is specified for a section, don't change the order,
* and move BSS sections to a separate list so they can be moved to the
* end of the lma list after all other sections are sorted.
*/
unsorted_groups = info.lma_groups; /* structure copy */
TAILQ_INIT(&info.lma_groups);
TAILQ_INIT(&bss_groups);
TAILQ_FOREACH_SAFE(lma_group, &unsorted_groups, link, group_temp) {
bin_group *before;
if (!lma_group->bsd->istart) {
if (lma_group->bsd->bss)
TAILQ_INSERT_TAIL(&bss_groups, lma_group, link);
else
TAILQ_INSERT_TAIL(&info.lma_groups, lma_group, link);
continue;
}
before = NULL;
TAILQ_FOREACH(group, &info.lma_groups, link) {
if (!group->bsd->istart)
continue;
if (yasm_intnum_compare(group->bsd->istart,
lma_group->bsd->istart) > 0) {
before = group;
break;
}
}
if (before)
TAILQ_INSERT_BEFORE(before, lma_group, link);
else
TAILQ_INSERT_TAIL(&info.lma_groups, lma_group, link);
}
/* Move the pure-BSS sections to the end of the LMA list. */
TAILQ_FOREACH_SAFE(group, &bss_groups, link, group_temp)
TAILQ_INSERT_TAIL(&info.lma_groups, group, link);
TAILQ_INIT(&bss_groups); /* For sanity */
/* Assign a LMA start address to every section.
* Also assign VMA=LMA unless otherwise specified.
*
* We need to assign VMA=LMA here (while walking the tree) for the case:
* sect1 start=0 (size=0x11)
* sect2 follows=sect1 valign=16 (size=0x104)
* sect3 follows=sect2 valign=16
* Where the valign of sect2 will result in a sect3 vaddr higher than a
* naive segment-by-segment interpretation (where sect3 and sect2 would
* have a VMA overlap).
*
* Algorithm for VMA=LMA setting:
* Start with delta=0.
* If there's no virtual attributes, we simply set VMA = LMA+delta.
* If there's only valign specified, we set VMA = aligned LMA, and add
* any new alignment difference to delta.
*
* We could do the LMA start and VMA=LMA steps in two separate steps,
* but it's easier to just recurse once.
*/
start = yasm_intnum_copy(info.origin);
last = yasm_intnum_copy(info.origin);
vdelta = yasm_intnum_create_uint(0);
TAILQ_FOREACH(lma_group, &info.lma_groups, link) {
if (lma_group->bsd->istart)
yasm_intnum_set(start, lma_group->bsd->istart);
group_assign_start_recurse(lma_group, start, last, vdelta,
info.tmp_intn, errwarns);
yasm_intnum_set(start, last);
}
yasm_intnum_destroy(last);
yasm_intnum_destroy(vdelta);
/*
* Determine section order according to VMA
*/
/* Create section groups */
if (yasm_object_sections_traverse(object, &info, bin_vma_create_group)) {
yasm_intnum_destroy(start);
bin_objfmt_cleanup(&info);
return; /* error detected */
}
/* Look at each group with vfollows specified, and find the section
* that group is supposed to follow.
*/
TAILQ_FOREACH_SAFE(vma_group, &info.vma_groups, link, group_temp) {
if (vma_group->bsd->vfollows) {
bin_group *found;
/* Need to find group containing section this section follows. */
found = find_group_by_name(&info.vma_groups,
vma_group->bsd->vfollows);
if (!found) {
yasm_error_set(YASM_ERROR_VALUE,
N_("section `%s' vfollows an invalid or unknown section `%s'"),
yasm_section_get_name(vma_group->section),
vma_group->bsd->vfollows);
yasm_errwarn_propagate(errwarns, 0);
yasm_intnum_destroy(start);
bin_objfmt_cleanup(&info);
return;
}
/* Check for loops */
if (vma_group->section == found->section ||
find_group_by_section(&vma_group->follow_groups,
found->section)) {
yasm_error_set(YASM_ERROR_VALUE,
N_("vfollows loop between section `%s' and section `%s'"),
yasm_section_get_name(vma_group->section),
yasm_section_get_name(found->section));
yasm_errwarn_propagate(errwarns, 0);
bin_objfmt_cleanup(&info);
return;
}
/* Remove this section from main lma groups list */
TAILQ_REMOVE(&info.vma_groups, vma_group, link);
/* Add it after the section it's supposed to follow. */
TAILQ_INSERT_TAIL(&found->follow_groups, vma_group, link);
}
}
/* Due to the combination of steps above, we now know that all top-level
* groups have integer ivstart:
* Vstart Vfollows Valign Handled by
* No No No group_assign_start_recurse()
* No No Yes group_assign_start_recurse()
* No Yes - vfollows loop (above)
* Yes - - bin_lma_create_group()
*/
TAILQ_FOREACH(vma_group, &info.vma_groups, link) {
yasm_intnum_set(start, vma_group->bsd->ivstart);
group_assign_vstart_recurse(vma_group, start, errwarns);
}
/* Output map file */
output_map(&info);
/* Ensure we don't have overlapping progbits LMAs.
* Use a dumb O(N^2) algorithm as the number of sections is essentially
* always low.
*/
if (yasm_object_sections_traverse(object, NULL, check_lma_overlap)) {
yasm_errwarn_propagate(errwarns, 0);
yasm_intnum_destroy(start);
bin_objfmt_cleanup(&info);
return;
}
/* Output sections */
yasm_object_sections_traverse(object, &info, bin_objfmt_output_section);
/* Clean up */
yasm_intnum_destroy(start);
bin_objfmt_cleanup(&info);
}
static void
bin_objfmt_destroy(yasm_objfmt *objfmt)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)objfmt;
if (objfmt_bin->map_filename)
yasm_xfree(objfmt_bin->map_filename);
yasm_expr_destroy(objfmt_bin->org);
yasm_xfree(objfmt);
}
static void
define_section_symbol(yasm_symtab *symtab, yasm_section *sect,
const char *sectname, const char *suffix,
enum bin_ssym which, unsigned long line)
{
yasm_symrec *sym;
bin_symrec_data *bsymd = yasm_xmalloc(sizeof(bin_symrec_data));
char *symname = yasm_xmalloc(8+strlen(sectname)+strlen(suffix)+1);
strcpy(symname, "section.");
strcat(symname, sectname);
strcat(symname, suffix);
bsymd->section = sect;
bsymd->which = which;
sym = yasm_symtab_declare(symtab, symname, YASM_SYM_EXTERN, line);
yasm_xfree(symname);
yasm_symrec_add_data(sym, &bin_symrec_data_cb, bsymd);
}
static void
bin_objfmt_init_new_section(yasm_section *sect, unsigned long line)
{
yasm_object *object = yasm_section_get_object(sect);
const char *sectname = yasm_section_get_name(sect);
/*yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)object->objfmt;*/
bin_section_data *data;
data = yasm_xmalloc(sizeof(bin_section_data));
data->bss = 0;
data->align = NULL;
data->valign = NULL;
data->start = NULL;
data->vstart = NULL;
data->follows = NULL;
data->vfollows = NULL;
data->istart = NULL;
data->ivstart = NULL;
data->length = NULL;
yasm_section_add_data(sect, &bin_section_data_cb, data);
define_section_symbol(object->symtab, sect, sectname, ".start",
SSYM_START, line);
define_section_symbol(object->symtab, sect, sectname, ".vstart",
SSYM_VSTART, line);
define_section_symbol(object->symtab, sect, sectname, ".length",
SSYM_LENGTH, line);
}
static yasm_section *
bin_objfmt_add_default_section(yasm_object *object)
{
yasm_section *retval;
int isnew;
retval = yasm_object_get_general(object, ".text", 0, 1, 0, &isnew, 0);
if (isnew)
yasm_section_set_default(retval, 1);
return retval;
}
/* GAS-style flags */
static int
bin_helper_gasflags(void *obj, yasm_valparam *vp, unsigned long line, void *d,
/*@unused@*/ uintptr_t arg)
{
/* TODO */
return 0;
}
static /*@observer@*/ /*@null@*/ yasm_section *
bin_objfmt_section_switch(yasm_object *object, yasm_valparamhead *valparams,
/*@unused@*/ /*@null@*/
yasm_valparamhead *objext_valparams,
unsigned long line)
{
yasm_valparam *vp;
yasm_section *retval;
int isnew;
int flags_override = 0;
const char *sectname;
bin_section_data *bsd = NULL;
struct bin_section_switch_data {
/*@only@*/ /*@null@*/ char *follows;
/*@only@*/ /*@null@*/ char *vfollows;
/*@only@*/ /*@null@*/ yasm_expr *start;
/*@only@*/ /*@null@*/ yasm_expr *vstart;
/*@only@*/ /*@null@*/ yasm_intnum *align;
/*@only@*/ /*@null@*/ yasm_intnum *valign;
unsigned long bss;
unsigned long code;
} data;
static const yasm_dir_help help[] = {
{ "follows", 1, yasm_dir_helper_string,
offsetof(struct bin_section_switch_data, follows), 0 },
{ "vfollows", 1, yasm_dir_helper_string,
offsetof(struct bin_section_switch_data, vfollows), 0 },
{ "start", 1, yasm_dir_helper_expr,
offsetof(struct bin_section_switch_data, start), 0 },
{ "vstart", 1, yasm_dir_helper_expr,
offsetof(struct bin_section_switch_data, vstart), 0 },
{ "align", 1, yasm_dir_helper_intn,
offsetof(struct bin_section_switch_data, align), 0 },
{ "valign", 1, yasm_dir_helper_intn,
offsetof(struct bin_section_switch_data, valign), 0 },
{ "nobits", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, bss), 1 },
{ "progbits", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, bss), 0 },
{ "code", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, code), 1 },
{ "data", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, code), 0 },
{ "execute", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, code), 1 },
{ "noexecute", 0, yasm_dir_helper_flag_set,
offsetof(struct bin_section_switch_data, code), 0 },
{ "gasflags", 1, bin_helper_gasflags, 0, 0 }
};
vp = yasm_vps_first(valparams);
sectname = yasm_vp_string(vp);
if (!sectname)
return NULL;
vp = yasm_vps_next(vp);
retval = yasm_object_find_general(object, sectname);
if (retval) {
bsd = yasm_section_get_data(retval, &bin_section_data_cb);
assert(bsd != NULL);
data.follows = bsd->follows;
data.vfollows = bsd->vfollows;
data.start = bsd->start;
data.vstart = bsd->vstart;
data.align = NULL;
data.valign = NULL;
data.bss = bsd->bss;
data.code = yasm_section_is_code(retval);
} else {
data.follows = NULL;
data.vfollows = NULL;
data.start = NULL;
data.vstart = NULL;
data.align = NULL;
data.valign = NULL;
data.bss = strcmp(sectname, ".bss") == 0;
data.code = strcmp(sectname, ".text") == 0;
}
flags_override = yasm_dir_helper(object, vp, line, help, NELEMS(help),
&data, yasm_dir_helper_valparam_warn);
if (flags_override < 0)
return NULL; /* error occurred */
if (data.start && data.follows) {
yasm_error_set(YASM_ERROR_GENERAL,
N_("cannot combine `start' and `follows' section attributes"));
return NULL;
}
if (data.vstart && data.vfollows) {
yasm_error_set(YASM_ERROR_GENERAL,
N_("cannot combine `vstart' and `vfollows' section attributes"));
return NULL;
}
if (data.align) {
unsigned long align = yasm_intnum_get_uint(data.align);
/* Alignments must be a power of two. */
if (!is_exp2(align)) {
yasm_error_set(YASM_ERROR_VALUE,
N_("argument to `%s' is not a power of two"),
"align");
return NULL;
}
} else
data.align = bsd ? bsd->align : NULL;
if (data.valign) {
unsigned long valign = yasm_intnum_get_uint(data.valign);
/* Alignments must be a power of two. */
if (!is_exp2(valign)) {
yasm_error_set(YASM_ERROR_VALUE,
N_("argument to `%s' is not a power of two"),
"valign");
return NULL;
}
} else
data.valign = bsd ? bsd->valign : NULL;
retval = yasm_object_get_general(object, sectname, 0, (int)data.code,
(int)data.bss, &isnew, line);
bsd = yasm_section_get_data(retval, &bin_section_data_cb);
if (isnew || yasm_section_is_default(retval)) {
yasm_section_set_default(retval, 0);
}
/* Update section flags */
bsd->bss = data.bss;
bsd->align = data.align;
bsd->valign = data.valign;
bsd->start = data.start;
bsd->vstart = data.vstart;
bsd->follows = data.follows;
bsd->vfollows = data.vfollows;
return retval;
}
static /*@observer@*/ /*@null@*/ yasm_symrec *
bin_objfmt_get_special_sym(yasm_object *object, const char *name,
const char *parser)
{
return NULL;
}
static void
bin_objfmt_dir_org(yasm_object *object,
/*@null@*/ yasm_valparamhead *valparams,
/*@unused@*/ /*@null@*/
yasm_valparamhead *objext_valparams, unsigned long line)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)object->objfmt;
yasm_valparam *vp;
/* We only allow a single ORG in a program. */
if (objfmt_bin->org) {
yasm_error_set(YASM_ERROR_GENERAL, N_("program origin redefined"));
return;
}
/* ORG takes just a simple expression as param */
vp = yasm_vps_first(valparams);
objfmt_bin->org = yasm_vp_expr(vp, object->symtab, line);
if (!objfmt_bin->org) {
yasm_error_set(YASM_ERROR_SYNTAX,
N_("argument to ORG must be expression"));
return;
}
}
struct bin_dir_map_data {
unsigned long flags;
/*@only@*/ /*@null@*/ char *filename;
};
static int
dir_map_filename(void *obj, yasm_valparam *vp, unsigned long line, void *data)
{
struct bin_dir_map_data *mdata = (struct bin_dir_map_data *)data;
const char *filename;
if (mdata->filename) {
yasm_warn_set(YASM_WARN_GENERAL, N_("map file already specified"));
return 0;
}
filename = yasm_vp_string(vp);
if (!filename) {
yasm_error_set(YASM_ERROR_SYNTAX,
N_("unexpected expression in [map]"));
return -1;
}
mdata->filename = yasm__xstrdup(filename);
return 1;
}
static void
bin_objfmt_dir_map(yasm_object *object,
/*@null@*/ yasm_valparamhead *valparams,
/*@unused@*/ /*@null@*/
yasm_valparamhead *objext_valparams, unsigned long line)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *)object->objfmt;
struct bin_dir_map_data data;
static const yasm_dir_help help[] = {
{ "all", 0, yasm_dir_helper_flag_or,
offsetof(struct bin_dir_map_data, flags),
MAP_BRIEF|MAP_SECTIONS|MAP_SYMBOLS },
{ "brief", 0, yasm_dir_helper_flag_or,
offsetof(struct bin_dir_map_data, flags), MAP_BRIEF },
{ "sections", 0, yasm_dir_helper_flag_or,
offsetof(struct bin_dir_map_data, flags), MAP_SECTIONS },
{ "segments", 0, yasm_dir_helper_flag_or,
offsetof(struct bin_dir_map_data, flags), MAP_SECTIONS },
{ "symbols", 0, yasm_dir_helper_flag_or,
offsetof(struct bin_dir_map_data, flags), MAP_SYMBOLS }
};
data.flags = objfmt_bin->map_flags | MAP_NONE;
data.filename = objfmt_bin->map_filename;
if (valparams && yasm_dir_helper(object, yasm_vps_first(valparams), line, help,
NELEMS(help), &data, dir_map_filename) < 0)
return; /* error occurred */
objfmt_bin->map_flags = data.flags;
objfmt_bin->map_filename = data.filename;
}
static void
bin_section_data_destroy(void *data)
{
bin_section_data *bsd = (bin_section_data *)data;
if (bsd->start)
yasm_expr_destroy(bsd->start);
if (bsd->vstart)
yasm_expr_destroy(bsd->vstart);
if (bsd->follows)
yasm_xfree(bsd->follows);
if (bsd->vfollows)
yasm_xfree(bsd->vfollows);
if (bsd->istart)
yasm_intnum_destroy(bsd->istart);
if (bsd->ivstart)
yasm_intnum_destroy(bsd->ivstart);
if (bsd->length)
yasm_intnum_destroy(bsd->length);
yasm_xfree(data);
}
static void
bin_section_data_print(void *data, FILE *f, int indent_level)
{
bin_section_data *bsd = (bin_section_data *)data;
fprintf(f, "%*sbss=%d\n", indent_level, "", bsd->bss);
fprintf(f, "%*salign=", indent_level, "");
if (bsd->align)
yasm_intnum_print(bsd->align, f);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*svalign=", indent_level, "");
if (bsd->valign)
yasm_intnum_print(bsd->valign, f);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*sstart=", indent_level, "");
yasm_expr_print(bsd->start, f);
fprintf(f, "\n%*svstart=", indent_level, "");
yasm_expr_print(bsd->vstart, f);
fprintf(f, "\n%*sfollows=", indent_level, "");
if (bsd->follows)
fprintf(f, "\"%s\"", bsd->follows);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*svfollows=", indent_level, "");
if (bsd->vfollows)
fprintf(f, "\"%s\"", bsd->vfollows);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*sistart=", indent_level, "");
if (bsd->istart)
yasm_intnum_print(bsd->istart, f);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*sivstart=", indent_level, "");
if (bsd->ivstart)
yasm_intnum_print(bsd->ivstart, f);
else
fprintf(f, "(nil)");
fprintf(f, "\n%*slength=", indent_level, "");
if (bsd->length)
yasm_intnum_print(bsd->length, f);
else
fprintf(f, "(nil)");
fprintf(f, "\n");
}
static void
bin_symrec_data_destroy(void *data)
{
yasm_xfree(data);
}
static void
bin_symrec_data_print(void *data, FILE *f, int indent_level)
{
bin_symrec_data *bsymd = (bin_symrec_data *)data;
fprintf(f, "%*ssection=\"%s\"\n", indent_level, "",
yasm_section_get_name(bsymd->section));
fprintf(f, "%*swhich=", indent_level, "");
switch (bsymd->which) {
case SSYM_START: fprintf(f, "START"); break;
case SSYM_VSTART: fprintf(f, "VSTART"); break;
case SSYM_LENGTH: fprintf(f, "LENGTH"); break;
}
fprintf(f, "\n");
}
/* Define valid debug formats to use with this object format */
static const char *bin_objfmt_dbgfmt_keywords[] = {
"null",
NULL
};
static const yasm_directive bin_objfmt_directives[] = {
{ "org", "nasm", bin_objfmt_dir_org, YASM_DIR_ARG_REQUIRED },
{ "map", "nasm", bin_objfmt_dir_map, YASM_DIR_ANY },
{ NULL, NULL, NULL, 0 }
};
static const char *bin_nasm_stdmac[] = {
"%imacro org 1+.nolist",
"[org %1]",
"%endmacro",
NULL
};
static const yasm_stdmac bin_objfmt_stdmacs[] = {
{ "nasm", "nasm", bin_nasm_stdmac },
{ "tasm", "tasm", bin_nasm_stdmac },
{ NULL, NULL, NULL }
};
/* Define objfmt structure -- see objfmt.h for details */
yasm_objfmt_module yasm_bin_LTX_objfmt = {
"Flat format binary",
"bin",
NULL,
16,
0,
bin_objfmt_dbgfmt_keywords,
"null",
bin_objfmt_directives,
bin_objfmt_stdmacs,
bin_objfmt_create,
bin_objfmt_output,
bin_objfmt_destroy,
bin_objfmt_add_default_section,
bin_objfmt_init_new_section,
bin_objfmt_section_switch,
bin_objfmt_get_special_sym
};
#define EXE_HEADER_SIZE 0x200
/* DOS .EXE binaries are just raw binaries with a header */
yasm_objfmt_module yasm_dosexe_LTX_objfmt;
static yasm_objfmt *
dosexe_objfmt_create(yasm_object *object)
{
yasm_objfmt_bin *objfmt_bin = (yasm_objfmt_bin *) bin_objfmt_create(object);
objfmt_bin->objfmt.module = &yasm_dosexe_LTX_objfmt;
return (yasm_objfmt *)objfmt_bin;
}
static unsigned long
get_sym(yasm_object *object, const char *name) {
yasm_symrec *symrec = yasm_symtab_get(object->symtab, name);
yasm_bytecode *prevbc;
if (!symrec)
return 0;
if (!yasm_symrec_get_label(symrec, &prevbc))
return 0;
return prevbc->offset + prevbc->len;
}
static void
dosexe_objfmt_output(yasm_object *object, FILE *f, /*@unused@*/ int all_syms,
yasm_errwarns *errwarns)
{
unsigned long tot_size, size, bss_size;
unsigned long start, bss;
unsigned char c;
fseek(f, EXE_HEADER_SIZE, SEEK_SET);
bin_objfmt_output(object, f, all_syms, errwarns);
tot_size = ftell(f);
/* if there is a __bss_start symbol, data after it is 0, no need to write
* it. */
bss = get_sym(object, "__bss_start");
if (bss)
size = bss;
else
size = tot_size;
bss_size = tot_size - size;
#ifdef HAVE_FTRUNCATE
if (size != tot_size)
ftruncate(fileno(f), EXE_HEADER_SIZE + size);
#endif
fseek(f, 0, SEEK_SET);
/* magic */
fwrite("MZ", 1, 2, f);
/* file size */
c = size & 0xff;
fwrite(&c, 1, 1, f);
c = !!(size & 0x100);
fwrite(&c, 1, 1, f);
c = ((size + 511) >> 9) & 0xff;
fwrite(&c, 1, 1, f);
c = ((size + 511) >> 17) & 0xff;
fwrite(&c, 1, 1, f);
/* relocation # */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* header size */
c = EXE_HEADER_SIZE / 16;
fwrite(&c, 1, 1, f);
c = 0;
fwrite(&c, 1, 1, f);
/* minimum paragraph # */
bss_size = (bss_size + 15) >> 4;
c = bss_size & 0xff;
fwrite(&c, 1, 1, f);
c = (bss_size >> 8) & 0xff;
fwrite(&c, 1, 1, f);
/* maximum paragraph # */
c = 0xFF;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* relative value of stack segment */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* SP at start */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* header checksum */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* IP at start */
start = get_sym(object, "start");
if (!start) {
yasm_error_set(YASM_ERROR_GENERAL,
N_("%s: could not find symbol `start'"));
return;
}
c = start & 0xff;
fwrite(&c, 1, 1, f);
c = (start >> 8) & 0xff;
fwrite(&c, 1, 1, f);
/* CS start */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
/* reloc start */
c = 0x22;
fwrite(&c, 1, 1, f);
c = 0;
fwrite(&c, 1, 1, f);
/* Overlay number */
c = 0;
fwrite(&c, 1, 1, f);
fwrite(&c, 1, 1, f);
}
/* Define objfmt structure -- see objfmt.h for details */
yasm_objfmt_module yasm_dosexe_LTX_objfmt = {
"DOS .EXE format binary",
"dosexe",
"exe",
16,
0,
bin_objfmt_dbgfmt_keywords,
"null",
bin_objfmt_directives,
bin_objfmt_stdmacs,
dosexe_objfmt_create,
dosexe_objfmt_output,
bin_objfmt_destroy,
bin_objfmt_add_default_section,
bin_objfmt_init_new_section,
bin_objfmt_section_switch,
bin_objfmt_get_special_sym
};
Reference in New Issue View Git Blame Copy Permalink