/*@null@*/ yasm_intnum *
yasm_calc_bc_dist(yasm_bytecode *precbc1, yasm_bytecode *precbc2)
{
unsigned long dist2, dist1;
yasm_intnum *intn;
if (precbc1->section != precbc2->section)
return NULL;
dist1 = yasm_bc_next_offset(precbc1);
dist2 = yasm_bc_next_offset(precbc2);
if (dist2 < dist1) {
intn = yasm_intnum_create_uint(dist1 - dist2);
yasm_intnum_calc(intn, YASM_EXPR_NEG, NULL);
return intn;
}
dist2 -= dist1;
return yasm_intnum_create_uint(dist2);
}
int
yasm_value_output_basic(yasm_value *value, /*@out@*/ unsigned char *buf,
size_t destsize, yasm_bytecode *bc, int warn,
yasm_arch *arch)
{
/*@dependent@*/ /*@null@*/ yasm_intnum *intn = NULL;
/*@only@*/ yasm_intnum *outval;
int sym_local;
int retval = 1;
unsigned int valsize = value->size;
if (value->no_warn)
warn = 0;
if (value->abs) {
/* Handle floating point expressions */
if (!value->rel && value->abs->op == YASM_EXPR_IDENT
&& value->abs->terms[0].type == YASM_EXPR_FLOAT) {
if (yasm_arch_floatnum_tobytes(arch, value->abs->terms[0].data.flt,
buf, destsize, valsize, 0, warn))
return -1;
else
return 1;
}
/* Check for complex float expressions */
if (yasm_expr__contains(value->abs, YASM_EXPR_FLOAT)) {
yasm_error_set(YASM_ERROR_FLOATING_POINT,
N_("floating point expression too complex"));
return -1;
}
/* Handle normal integer expressions */
intn = yasm_expr_get_intnum(&value->abs, 1);
if (!intn) {
/* Second try before erroring: yasm_expr_get_intnum doesn't handle
* SEG:OFF, so try simplifying out any to just the OFF portion,
* then getting the intnum again.
*/
yasm_expr *seg = yasm_expr_extract_deep_segoff(&value->abs);
if (seg)
yasm_expr_destroy(seg);
intn = yasm_expr_get_intnum(&value->abs, 1);
}
if (!intn) {
/* Still don't have an integer! */
yasm_error_set(YASM_ERROR_TOO_COMPLEX,
N_("expression too complex"));
return -1;
}
}
/* Adjust warn for signed/unsigned integer warnings */
if (warn != 0)
warn = value->sign ? -1 : 1;
if (value->rel) {
/* If relative portion is not in bc section, don't try to handle it
* here. Otherwise get the relative portion's offset.
*/
/*@dependent@*/ yasm_bytecode *rel_prevbc;
unsigned long dist;
sym_local = yasm_symrec_get_label(value->rel, &rel_prevbc);
if (value->wrt || value->seg_of || value->section_rel || !sym_local)
return 0; /* we can't handle SEG, WRT, or external symbols */
if (rel_prevbc->section != bc->section)
return 0; /* not in this section */
if (!value->curpos_rel)
return 0; /* not PC-relative */
/* Calculate value relative to current assembly position */
dist = yasm_bc_next_offset(rel_prevbc);
if (dist < bc->offset) {
outval = yasm_intnum_create_uint(bc->offset - dist);
yasm_intnum_calc(outval, YASM_EXPR_NEG, NULL);
} else {
dist -= bc->offset;
outval = yasm_intnum_create_uint(dist);
}
if (value->rshift > 0) {
/*@only@*/ yasm_intnum *shamt =
yasm_intnum_create_uint((unsigned long)value->rshift);
yasm_intnum_calc(outval, YASM_EXPR_SHR, shamt);
yasm_intnum_destroy(shamt);
}
/* Add in absolute portion */
if (intn)
yasm_intnum_calc(outval, YASM_EXPR_ADD, intn);
/* Output! */
if (yasm_arch_intnum_tobytes(arch, outval, buf, destsize, valsize, 0,
bc, warn))
retval = -1;
yasm_intnum_destroy(outval);
return retval;
}
if (value->seg_of || value->rshift || value->curpos_rel || value->ip_rel
|| value->section_rel)
return 0; /* We can't handle this with just an absolute */
if (intn) {
/* Output just absolute portion */
if (yasm_arch_intnum_tobytes(arch, intn, buf, destsize, valsize, 0, bc,
warn))
retval = -1;
} else {
/* No absolute or relative portions: output 0 */
outval = yasm_intnum_create_uint(0);
if (yasm_arch_intnum_tobytes(arch, outval, buf, destsize, valsize, 0,
bc, warn))
retval = -1;
yasm_intnum_destroy(outval);
}
return retval;
}
static int
xdf_objfmt_output_sym(yasm_symrec *sym, /*@null@*/ void *d)
{
/*@null@*/ xdf_objfmt_output_info *info = (xdf_objfmt_output_info *)d;
yasm_sym_vis vis = yasm_symrec_get_visibility(sym);
assert(info != NULL);
if (info->all_syms || vis != YASM_SYM_LOCAL) {
/*@only@*/ char *name = yasm_symrec_get_global_name(sym, info->object);
const yasm_expr *equ_val;
const yasm_intnum *intn;
size_t len = strlen(name);
unsigned long value = 0;
long scnum = -3; /* -3 = debugging symbol */
/*@dependent@*/ /*@null@*/ yasm_section *sect;
/*@dependent@*/ /*@null@*/ yasm_bytecode *precbc;
unsigned long flags = 0;
unsigned char *localbuf;
if (vis & YASM_SYM_GLOBAL)
flags = XDF_SYM_GLOBAL;
/* Look at symrec for value/scnum/etc. */
if (yasm_symrec_get_label(sym, &precbc)) {
if (precbc)
sect = yasm_bc_get_section(precbc);
else
sect = NULL;
/* it's a label: get value and offset.
* If there is not a section, leave as debugging symbol.
*/
if (sect) {
/*@dependent@*/ /*@null@*/ xdf_section_data *csectd;
csectd = yasm_section_get_data(sect, &xdf_section_data_cb);
if (csectd)
scnum = csectd->scnum;
else
yasm_internal_error(N_("didn't understand section"));
if (precbc)
value += yasm_bc_next_offset(precbc);
}
} else if ((equ_val = yasm_symrec_get_equ(sym))) {
yasm_expr *equ_val_copy = yasm_expr_copy(equ_val);
intn = yasm_expr_get_intnum(&equ_val_copy, 1);
if (!intn) {
if (vis & YASM_SYM_GLOBAL) {
yasm_error_set(YASM_ERROR_NOT_CONSTANT,
N_("global EQU value not an integer expression"));
yasm_errwarn_propagate(info->errwarns, equ_val->line);
}
} else
value = yasm_intnum_get_uint(intn);
yasm_expr_destroy(equ_val_copy);
flags |= XDF_SYM_EQU;
scnum = -2; /* -2 = absolute symbol */
} else {
if (vis & YASM_SYM_EXTERN) {
flags = XDF_SYM_EXTERN;
scnum = -1;
}
}
localbuf = info->buf;
YASM_WRITE_32_L(localbuf, scnum); /* section number */
YASM_WRITE_32_L(localbuf, value); /* value */
YASM_WRITE_32_L(localbuf, info->strtab_offset);
info->strtab_offset += (unsigned long)(len+1);
YASM_WRITE_32_L(localbuf, flags); /* flags */
fwrite(info->buf, 16, 1, info->f);
yasm_xfree(name);
}
return 0;
}
yasm_intnum *
yasm_value_get_intnum(yasm_value *value, yasm_bytecode *bc, int calc_bc_dist)
{
/*@dependent@*/ /*@null@*/ yasm_intnum *intn = NULL;
/*@only@*/ yasm_intnum *outval;
int sym_local;
if (value->abs) {
/* Handle integer expressions, if non-integer or too complex, return
* NULL.
*/
intn = yasm_expr_get_intnum(&value->abs, calc_bc_dist);
if (!intn)
return NULL;
}
if (value->rel) {
/* If relative portion is not in bc section, return NULL.
* Otherwise get the relative portion's offset.
*/
/*@dependent@*/ yasm_bytecode *rel_prevbc;
unsigned long dist;
if (!bc)
return NULL; /* Can't calculate relative value */
sym_local = yasm_symrec_get_label(value->rel, &rel_prevbc);
if (value->wrt || value->seg_of || value->section_rel || !sym_local)
return NULL; /* we can't handle SEG, WRT, or external symbols */
if (rel_prevbc->section != bc->section)
return NULL; /* not in this section */
if (!value->curpos_rel)
return NULL; /* not PC-relative */
/* Calculate value relative to current assembly position */
dist = yasm_bc_next_offset(rel_prevbc);
if (dist < bc->offset) {
outval = yasm_intnum_create_uint(bc->offset - dist);
yasm_intnum_calc(outval, YASM_EXPR_NEG, NULL);
} else {
dist -= bc->offset;
outval = yasm_intnum_create_uint(dist);
}
if (value->rshift > 0) {
/*@only@*/ yasm_intnum *shamt =
yasm_intnum_create_uint((unsigned long)value->rshift);
yasm_intnum_calc(outval, YASM_EXPR_SHR, shamt);
yasm_intnum_destroy(shamt);
}
/* Add in absolute portion */
if (intn)
yasm_intnum_calc(outval, YASM_EXPR_ADD, intn);
return outval;
}
if (intn)
return yasm_intnum_copy(intn);
/* No absolute or relative portions: output 0 */
return yasm_intnum_create_uint(0);
}
static int
xdf_objfmt_output_section(yasm_section *sect, /*@null@*/ void *d)
{
/*@null@*/ xdf_objfmt_output_info *info = (xdf_objfmt_output_info *)d;
/*@dependent@*/ /*@null@*/ xdf_section_data *xsd;
long pos;
xdf_reloc *reloc;
assert(info != NULL);
xsd = yasm_section_get_data(sect, &xdf_section_data_cb);
assert(xsd != NULL);
if (xsd->flags & XDF_SECT_BSS) {
/* Don't output BSS sections.
* TODO: Check for non-reserve bytecodes?
*/
pos = 0; /* position = 0 because it's not in the file */
xsd->size = yasm_bc_next_offset(yasm_section_bcs_last(sect));
} else {
pos = ftell(info->f);
if (pos == -1) {
yasm__fatal(N_("could not get file position on output file"));
/*@notreached@*/
return 1;
}
info->sect = sect;
info->xsd = xsd;
yasm_section_bcs_traverse(sect, info->errwarns, info,
xdf_objfmt_output_bytecode);
/* Sanity check final section size */
if (xsd->size != yasm_bc_next_offset(yasm_section_bcs_last(sect)))
yasm_internal_error(
N_("xdf: section computed size did not match actual size"));
}
/* Empty? Go on to next section */
if (xsd->size == 0)
return 0;
xsd->scnptr = (unsigned long)pos;
/* No relocations to output? Go on to next section */
if (xsd->nreloc == 0)
return 0;
pos = ftell(info->f);
if (pos == -1) {
yasm__fatal(N_("could not get file position on output file"));
/*@notreached@*/
return 1;
}
xsd->relptr = (unsigned long)pos;
reloc = (xdf_reloc *)yasm_section_relocs_first(sect);
while (reloc) {
unsigned char *localbuf = info->buf;
/*@null@*/ xdf_symrec_data *xsymd;
xsymd = yasm_symrec_get_data(reloc->reloc.sym, &xdf_symrec_data_cb);
if (!xsymd)
yasm_internal_error(
N_("xdf: no symbol data for relocated symbol"));
yasm_intnum_get_sized(reloc->reloc.addr, localbuf, 4, 32, 0, 0, 0);
localbuf += 4; /* address of relocation */
YASM_WRITE_32_L(localbuf, xsymd->index); /* relocated symbol */
if (reloc->base) {
xsymd = yasm_symrec_get_data(reloc->base, &xdf_symrec_data_cb);
if (!xsymd)
yasm_internal_error(
N_("xdf: no symbol data for relocated base symbol"));
YASM_WRITE_32_L(localbuf, xsymd->index); /* base symbol */
} else {
if (reloc->type == XDF_RELOC_WRT)
yasm_internal_error(
N_("xdf: no base symbol for WRT relocation"));
YASM_WRITE_32_L(localbuf, 0); /* no base symbol */
}
YASM_WRITE_8(localbuf, reloc->type); /* type of relocation */
YASM_WRITE_8(localbuf, reloc->size); /* size of relocation */
YASM_WRITE_8(localbuf, reloc->shift); /* relocation shift */
YASM_WRITE_8(localbuf, 0); /* flags */
fwrite(info->buf, 16, 1, info->f);
reloc = (xdf_reloc *)yasm_section_reloc_next((yasm_reloc *)reloc);
}
return 0;
}