uefi-ref/nasm
1
0
Fork 0
mirror of https://github.com/netwide-assembler/nasm synced 2026-08-26 16:23:04 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove function pointers in output, simplify error handling

Browse source 
Remove a bunch of function pointers in the output stage; they are
never changed and don't add any value.  Also make "ofile" a global
variable and let the backend use it directly.

All we ever did with these variables were stashing it in locals and
using them as-is anyway for no benefit.

Also change the global error function, nasm_error() into a true
function which invokes a function pointer internally.  That lets us
use direct calls to it.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
This commit is contained in:
H. Peter Anvin 2009-07-18 21:07:17 -04:00
parent 159178f2aa
commit 9bd1506d59
23 changed files with 958 additions and 1114 deletions
Download patch file Download diff file Expand all files Collapse all files

188
nasm.c
View file

@ -70,14 +70,11 @@ static int get_bits(char *value);
static uint32_t get_cpu(char *cpu_str);
static void parse_cmdline(int, char **);
static void assemble_file(char *, StrList **);
static void register_output_formats(void);
static void report_error_gnu(int severity, const char *fmt, ...);
static void report_error_vc(int severity, const char *fmt, ...);
static void report_error_common(int severity, const char *fmt,
va_list args);
static void nasm_verror_gnu(int severity, const char *fmt, va_list args);
static void nasm_verror_vc(int severity, const char *fmt, va_list args);
static void nasm_verror_common(int severity, const char *fmt, va_list args);
static bool is_suppressed_warning(int severity);
static void usage(void);
static efunc report_error;
static int using_debug_info, opt_verbose_info;
bool tasm_compatible_mode = false;
@ -85,7 +82,7 @@ int pass0, passn;
int maxbits = 0;
int globalrel = 0;
time_t official_compile_time;
static time_t official_compile_time;
static char inname[FILENAME_MAX];
static char outname[FILENAME_MAX];
@ -93,11 +90,12 @@ static char listname[FILENAME_MAX];
static char errname[FILENAME_MAX];
static int globallineno; /* for forward-reference tracking */
/* static int pass = 0; */
static struct ofmt *ofmt = NULL;
struct ofmt *ofmt = &OF_DEFAULT;
const struct dfmt *dfmt;
static FILE *error_file; /* Where to write error messages */
static FILE *ofile = NULL;
FILE *ofile = NULL;
int optimizing = -1; /* number of optimization passes to take */
static int sb, cmd_sb = 16; /* by default */
static uint32_t cmd_cpu = IF_PLEVEL; /* highest level by default */
@ -277,7 +275,7 @@ static void emit_dependencies(StrList *list)
if (depend_file && strcmp(depend_file, "-")) {
deps = fopen(depend_file, "w");
if (!deps) {
report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
nasm_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
"unable to write dependency file `%s'", depend_file);
return;
}
@ -317,13 +315,13 @@ int main(int argc, char **argv)
pass0 = 0;
want_usage = terminate_after_phase = false;
report_error = report_error_gnu;
nasm_set_verror(nasm_verror_gnu);
error_file = stderr;
tolower_init();
nasm_set_malloc_error(report_error);
nasm_init_malloc_error();
offsets = raa_init();
forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo));
@ -332,8 +330,6 @@ int main(int argc, char **argv)
seg_init();
register_output_formats();
/* Define some macros dependent on the runtime, but not
on the command line. */
define_macros_early();
@ -371,10 +367,10 @@ int main(int argc, char **argv)
if (depend_missing_ok)
pp_include_path(NULL); /* "assume generated" */
preproc->reset(inname, 0, report_error, evaluate, &nasmlist,
preproc->reset(inname, 0, nasm_error, evaluate, &nasmlist,
depend_ptr);
if (outname[0] == '\0')
ofmt->filename(inname, outname, report_error);
ofmt->filename(inname, outname);
ofile = NULL;
while ((line = preproc->getline()))
nasm_free(line);
@ -392,7 +388,7 @@ int main(int argc, char **argv)
if (*outname) {
ofile = fopen(outname, "w");
if (!ofile)
report_error(ERR_FATAL | ERR_NOFILE,
nasm_error(ERR_FATAL | ERR_NOFILE,
"unable to open output file `%s'",
outname);
} else
@ -401,7 +397,7 @@ int main(int argc, char **argv)
location.known = false;
/* pass = 1; */
preproc->reset(inname, 3, report_error, evaluate, &nasmlist,
preproc->reset(inname, 3, nasm_error, evaluate, &nasmlist,
depend_ptr);
while ((line = preproc->getline())) {
@ -443,11 +439,11 @@ int main(int argc, char **argv)
* the name of the input file and then put that inside the
* file.
*/
ofmt->filename(inname, outname, report_error);
ofmt->filename(inname, outname);
ofile = fopen(outname, (ofmt->flags & OFMT_TEXT) ? "w" : "wb");
if (!ofile) {
report_error(ERR_FATAL | ERR_NOFILE,
nasm_error(ERR_FATAL | ERR_NOFILE,
"unable to open output file `%s'", outname);
}
@ -458,8 +454,9 @@ int main(int argc, char **argv)
*/
init_labels();
ofmt->init(ofile, report_error, define_label, evaluate);
ofmt->current_dfmt->init(ofmt, NULL, ofile, report_error);
ofmt->init();
dfmt = ofmt->current_dfmt;
dfmt->init();
assemble_file(inname, depend_ptr);
@ -468,7 +465,7 @@ int main(int argc, char **argv)
cleanup_labels();
fflush(ofile);
if (ferror(ofile)) {
report_error(ERR_NONFATAL|ERR_NOFILE,
nasm_error(ERR_NONFATAL|ERR_NOFILE,
"write error on output file `%s'", outname);
}
}
@ -514,7 +511,7 @@ static char *get_param(char *p, char *q, bool *advance)
*advance = true;
return q;
}
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"option `-%c' requires an argument", p[1]);
return NULL;
}
@ -527,7 +524,7 @@ static void copy_filename(char *dst, const char *src)
size_t len = strlen(src);
if (len >= (size_t)FILENAME_MAX) {
report_error(ERR_FATAL | ERR_NOFILE, "file name too long");
nasm_error(ERR_FATAL | ERR_NOFILE, "file name too long");
return;
}
strncpy(dst, src, FILENAME_MAX);
@ -658,7 +655,7 @@ static bool process_arg(char *p, char *q)
case 'f': /* output format */
ofmt = ofmt_find(param);
if (!ofmt) {
report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
"unrecognised output format `%s' - "
"use -hf for a list", param);
}
@ -698,7 +695,7 @@ static bool process_arg(char *p, char *q)
break;
default:
report_error(ERR_FATAL,
nasm_error(ERR_FATAL,
"unknown optimization option -O%c\n",
*param);
break;
@ -739,7 +736,7 @@ static bool process_arg(char *p, char *q)
case 'F': /* specify debug format */
ofmt->current_dfmt = dfmt_find(ofmt, param);
if (!ofmt->current_dfmt) {
report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
"unrecognized debug format `%s' for"
" output format `%s'",
param, ofmt->shortname);
@ -749,11 +746,11 @@ static bool process_arg(char *p, char *q)
case 'X': /* specify error reporting format */
if (nasm_stricmp("vc", param) == 0)
report_error = report_error_vc;
nasm_set_verror(nasm_verror_vc);
else if (nasm_stricmp("gnu", param) == 0)
report_error = report_error_gnu;
nasm_set_verror(nasm_verror_gnu);
else
report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
"unrecognized error reporting format `%s'",
param);
break;
@ -843,7 +840,7 @@ static bool process_arg(char *p, char *q)
case 'w':
if (param[0] != '+' && param[0] != '-') {
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"invalid option to `-w'");
break;
}
@ -863,7 +860,7 @@ static bool process_arg(char *p, char *q)
for (i = 1; i <= ERR_WARN_MAX; i++)
warning_on_global[i] = !do_warn;
else
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"invalid warning `%s'", param);
break;
@ -892,12 +889,12 @@ static bool process_arg(char *p, char *q)
advance = true;
break;
default:
report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
nasm_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
"unknown dependency option `-M%c'", p[2]);
break;
}
if (advance && (!q || !q[0])) {
report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
nasm_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
"option `-M%c' requires a parameter", p[2]);
break;
}
@ -923,7 +920,7 @@ static bool process_arg(char *p, char *q)
case OPT_POSTFIX:
{
if (!q) {
report_error(ERR_NONFATAL | ERR_NOFILE |
nasm_error(ERR_NONFATAL | ERR_NOFILE |
ERR_USAGE,
"option `--%s' requires an argument",
p + 2);
@ -946,7 +943,7 @@ static bool process_arg(char *p, char *q)
}
default:
{
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"unrecognised option `--%s'", p + 2);
break;
}
@ -956,13 +953,13 @@ static bool process_arg(char *p, char *q)
default:
if (!ofmt->setinfo(GI_SWITCH, &p))
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"unrecognised option `-%c'", p[1]);
break;
}
} else {
if (*inname) {
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"more than one input file specified");
} else {
copy_filename(inname, p);
@ -1122,7 +1119,7 @@ static void parse_cmdline(int argc, char **argv)
process_respfile(rfile);
fclose(rfile);
} else
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"unable to open response file `%s'", p);
}
} else
@ -1133,13 +1130,13 @@ static void parse_cmdline(int argc, char **argv)
/* Look for basic command line typos. This definitely doesn't
catch all errors, but it might help cases of fumbled fingers. */
if (!*inname)
report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"no input file specified");
else if (!strcmp(inname, errname) ||
!strcmp(inname, outname) ||
!strcmp(inname, listname) ||
(depend_file && !strcmp(inname, depend_file)))
report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
"file `%s' is both input and output file",
inname);
@ -1147,7 +1144,7 @@ static void parse_cmdline(int argc, char **argv)
error_file = fopen(errname, "w");
if (!error_file) {
error_file = stderr; /* Revert to default! */
report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
nasm_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
"cannot open file `%s' for error messages",
errname);
}
@ -1169,7 +1166,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
int pass_max;
if (cmd_sb == 32 && cmd_cpu < IF_386)
report_error(ERR_FATAL, "command line: "
nasm_error(ERR_FATAL, "command line: "
"32-bit segment size requires a higher cpu");
pass_max = prev_offset_changed = (INT_MAX >> 1) + 2; /* Almost unlimited */
@ -1187,7 +1184,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
cpu = cmd_cpu;
if (pass0 == 2) {
if (*listname)
nasmlist.init(listname, report_error);
nasmlist.init(listname, nasm_error);
}
in_abs_seg = false;
global_offset_changed = 0; /* set by redefine_label */
@ -1199,7 +1196,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
raa_free(offsets);
offsets = raa_init();
}
preproc->reset(fname, pass1, report_error, evaluate, &nasmlist,
preproc->reset(fname, pass1, nasm_error, evaluate, &nasmlist,
pass1 == 2 ? depend_ptr : NULL);
memcpy(warning_on, warning_on_global, (ERR_WARN_MAX+1) * sizeof(bool));
@ -1226,7 +1223,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
case D_SECTION:
seg = ofmt->section(value, pass2, &sb);
if (seg == NO_SEG) {
report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
nasm_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
"segment name `%s' not recognized",
value);
} else {
@ -1256,7 +1253,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
q++;
}
if (!validid) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"identifier expected after EXTERN");
break;
}
@ -1269,9 +1266,9 @@ static void assemble_file(char *fname, StrList **depend_ptr)
int temp = pass0;
pass0 = 1; /* fake pass 1 in labels.c */
declare_as_global(value, special,
report_error);
nasm_error);
define_label(value, seg_alloc(), 0L, NULL,
false, true, ofmt, report_error);
false, true, ofmt, nasm_error);
pass0 = temp;
}
} /* else pass0 == 1 */
@ -1301,7 +1298,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
q++;
}
if (!validid) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"identifier expected after GLOBAL");
break;
}
@ -1310,7 +1307,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
special = q;
} else
special = NULL;
declare_as_global(value, special, report_error);
declare_as_global(value, special, nasm_error);
} /* pass == 1 */
break;
case D_COMMON: /* [COMMON symbol size:special] */
@ -1329,7 +1326,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
p++;
}
if (!validid) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"identifier expected after COMMON");
break;
}
@ -1347,13 +1344,13 @@ static void assemble_file(char *fname, StrList **depend_ptr)
}
size = readnum(p, &rn_error);
if (rn_error) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"invalid size specified"
" in COMMON declaration");
break;
}
} else {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"no size specified in"
" COMMON declaration");
break;
@ -1361,7 +1358,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
if (pass0 < 2) {
define_common(value, seg_alloc(), size,
special, ofmt, report_error);
special, ofmt, nasm_error);
} else if (pass0 == 2) {
if (special)
ofmt->symdef(value, 0L, 0L, 3, special);
@ -1373,10 +1370,10 @@ static void assemble_file(char *fname, StrList **depend_ptr)
stdscan_bufptr = value;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, pass2,
report_error, NULL);
nasm_error, NULL);
if (e) {
if (!is_reloc(e))
report_error(pass0 ==
nasm_error(pass0 ==
1 ? ERR_NONFATAL : ERR_PANIC,
"cannot use non-relocatable expression as "
"ABSOLUTE address");
@ -1387,7 +1384,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
} else if (passn == 1)
abs_offset = 0x100; /* don't go near zero in case of / */
else
report_error(ERR_PANIC, "invalid ABSOLUTE address "
nasm_error(ERR_PANIC, "invalid ABSOLUTE address "
"in pass two");
in_abs_seg = true;
location.segment = NO_SEG;
@ -1405,14 +1402,14 @@ static void assemble_file(char *fname, StrList **depend_ptr)
}
*q++ = 0;
if (!validid) {
report_error(passn == 1 ? ERR_NONFATAL : ERR_PANIC,
nasm_error(passn == 1 ? ERR_NONFATAL : ERR_PANIC,
"identifier expected after DEBUG");
break;
}
while (*p && nasm_isspace(*p))
p++;
if (pass0 == 2)
ofmt->current_dfmt->debug_directive(debugid, p);
dfmt->debug_directive(debugid, p);
break;
case D_WARNING: /* [WARNING {+|-|*}warn-name] */
while (*value && nasm_isspace(*value))
@ -1442,7 +1439,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
}
}
else
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"invalid warning id in WARNING directive");
break;
case D_CPU: /* [CPU] */
@ -1484,27 +1481,27 @@ static void assemble_file(char *fname, StrList **depend_ptr)
break;
case D_FLOAT:
if (float_option(value)) {
report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
nasm_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
"unknown 'float' directive: %s",
value);
}
break;
default:
if (!d || !ofmt->directive(d, value, pass2))
report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
nasm_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
"unrecognised directive [%s]",
directive);
break;
}
if (err) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"invalid parameter to [%s] directive",
directive);
}
} else { /* it isn't a directive */
parse_line(pass1, line, &output_ins,
report_error, evaluate, def_label);
nasm_error, evaluate, def_label);
if (optimizing > 0) {
if (forwref != NULL && globallineno == forwref->lineno) {
@ -1543,7 +1540,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
* in the normal place.
*/
if (!output_ins.label)
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"EQU not preceded by label");
else if (output_ins.label[0] != '.' ||
@ -1558,7 +1555,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
output_ins.oprs[0].segment,
output_ins.oprs[0].offset, NULL,
false, isext, ofmt,
report_error);
nasm_error);
} else if (output_ins.operands == 2
&& (output_ins.oprs[0].type & IMMEDIATE)
&& (output_ins.oprs[0].type & COLON)
@ -1571,9 +1568,9 @@ static void assemble_file(char *fname, StrList **depend_ptr)
output_ins.oprs[0].offset | SEG_ABS,
output_ins.oprs[1].offset,
NULL, false, false, ofmt,
report_error);
nasm_error);
} else
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"bad syntax for EQU");
}
} else {
@ -1590,7 +1587,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
output_ins.oprs[0].segment,
output_ins.oprs[0].offset,
NULL, false, false, ofmt,
report_error);
nasm_error);
} else if (output_ins.operands == 2
&& (output_ins.oprs[0].
type & IMMEDIATE)
@ -1606,9 +1603,9 @@ static void assemble_file(char *fname, StrList **depend_ptr)
offset | SEG_ABS,
output_ins.oprs[1].offset,
NULL, false, false, ofmt,
report_error);
nasm_error);
} else
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"bad syntax for EQU");
}
}
@ -1617,7 +1614,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
if (pass1 == 1) {
int64_t l = insn_size(location.segment, offs, sb, cpu,
&output_ins, report_error);
&output_ins, nasm_error);
/* if (using_debug_info) && output_ins.opcode != -1) */
if (using_debug_info)
@ -1690,8 +1687,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
}
ofmt->current_dfmt->debug_typevalue(typeinfo);
dfmt->debug_typevalue(typeinfo);
}
if (l != -1) {
offs += l;
@ -1704,7 +1700,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
} else {
offs += assemble(location.segment, offs, sb, cpu,
&output_ins, ofmt, report_error,
&output_ins, ofmt, nasm_error,
&nasmlist);
SET_CURR_OFFS(offs);
@ -1717,7 +1713,7 @@ static void assemble_file(char *fname, StrList **depend_ptr)
} /* end while (line = preproc->getline... */
if (pass0 == 2 && global_offset_changed && !terminate_after_phase)
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"phase error detected at end of assembly.");
if (pass1 == 1)
@ -1740,10 +1736,10 @@ static void assemble_file(char *fname, StrList **depend_ptr)
/* We get here if the labels don't converge
* Example: FOO equ FOO + 1
*/
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Can't find valid values for all labels "
"after %d passes, giving up.", passn);
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Possible causes: recursive EQUs, macro abuse.");
break;
}
@ -1820,9 +1816,8 @@ static enum directives getkw(char **directive, char **value)
* @param severity the severity of the warning or error
* @param fmt the printf style format string
*/
static void report_error_gnu(int severity, const char *fmt, ...)
static void nasm_verror_gnu(int severity, const char *fmt, va_list ap)
{
va_list ap;
char *currentfile = NULL;
int32_t lineno = 0;
@ -1839,9 +1834,7 @@ static void report_error_gnu(int severity, const char *fmt, ...)
fputs("nasm: ", error_file);
}
va_start(ap, fmt);
report_error_common(severity, fmt, ap);
va_end(ap);
nasm_verror_common(severity, fmt, ap);
}
/**
@ -1859,9 +1852,8 @@ static void report_error_gnu(int severity, const char *fmt, ...)
* @param severity the severity of the warning or error
* @param fmt the printf style format string
*/
static void report_error_vc(int severity, const char *fmt, ...)
static void nasm_verror_vc(int severity, const char *fmt, va_list ap)
{
va_list ap;
char *currentfile = NULL;
int32_t lineno = 0;
@ -1878,9 +1870,7 @@ static void report_error_vc(int severity, const char *fmt, ...)
fputs("nasm: ", error_file);
}
va_start(ap, fmt);
report_error_common(severity, fmt, ap);
va_end(ap);
nasm_verror_common(severity, fmt, ap);
}
/**
@ -1914,8 +1904,7 @@ static bool is_suppressed_warning(int severity)
* @param severity the severity of the warning or error
* @param fmt the printf style format string
*/
static void report_error_common(int severity, const char *fmt,
va_list args)
static void nasm_verror_common(int severity, const char *fmt, va_list args)
{
char msg[1024];
const char *pfx;
@ -1985,11 +1974,6 @@ static void usage(void)
fputs("type `nasm -h' for help\n", error_file);
}
static void register_output_formats(void)
{
ofmt = ofmt_register(report_error);
}
#define BUF_DELTA 512
static FILE *no_pp_fp;
@ -2119,7 +2103,7 @@ static uint32_t get_cpu(char *value)
!nasm_stricmp(value, "itanic") || !nasm_stricmp(value, "merced"))
return IF_IA64;
report_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
nasm_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
"unknown 'cpu' type");
return IF_PLEVEL; /* the maximum level */
@ -2133,24 +2117,24 @@ static int get_bits(char *value)
return i; /* set for a 16-bit segment */
else if (i == 32) {
if (cpu < IF_386) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"cannot specify 32-bit segment on processor below a 386");
i = 16;
}
} else if (i == 64) {
if (cpu < IF_X86_64) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"cannot specify 64-bit segment on processor below an x86-64");
i = 16;
}
if (i != maxbits) {
report_error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"%s output format does not support 64-bit code",
ofmt->shortname);
i = 16;
}
} else {
report_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
nasm_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
"`%s' is not a valid segment size; must be 16, 32 or 64",
value);
i = 16;

48
nasm.h
View file

@ -122,9 +122,12 @@ typedef bool (*lfunc) (char *label, int32_t *segment, int64_t *offset);
* should affect the local-label system), or something odder like
* an EQU or a segment-base symbol, which shouldn't.
*/
typedef void (*ldfunc) (char *label, int32_t segment, int64_t offset,
char *special, bool is_norm, bool isextrn,
struct ofmt * ofmt, efunc error);
typedef void (*ldfunc)(char *label, int32_t segment, int64_t offset,
char *special, bool is_norm, bool isextrn,
struct ofmt * ofmt, efunc error);
void define_label(char *label, int32_t segment, int64_t offset,
char *special, bool is_norm, bool isextrn,
struct ofmt * ofmt, efunc error);
/*
* List-file generators should look like this:
@ -786,7 +789,7 @@ struct ofmt {
* an output format, be sure to set this to whatever default you want
*
*/
struct dfmt *current_dfmt;
const struct dfmt *current_dfmt;
/*
* This, if non-NULL, is a NULL-terminated list of `char *'s
@ -798,13 +801,10 @@ struct ofmt {
macros_t *stdmac;
/*
* This procedure is called at the start of an output session.
* It tells the output format what file it will be writing to,
* what routine to report errors through, and how to interface
* to the label manager and expression evaluator if necessary.
* It also gives it a chance to do other initialisation.
* This procedure is called at the start of an output session to set
* up internal parameters.
*/
void (*init) (FILE * fp, efunc error, ldfunc ldef, evalfunc eval);
void (*init)(void);
/*
* This procedure is called to pass generic information to the
@ -924,7 +924,7 @@ struct ofmt {
* The parameter `outname' points to an area of storage
* guaranteed to be at least FILENAME_MAX in size.
*/
void (*filename) (char *inname, char *outname, efunc error);
void (*filename) (char *inname, char *outname);
/*
* This procedure is called after assembly finishes, to allow
@ -938,6 +938,8 @@ struct ofmt {
void (*cleanup) (int debuginfo);
};
extern struct ofmt *ofmt;
extern FILE *ofile;
/*
* ------------------------------------------------------------
@ -959,17 +961,15 @@ struct dfmt {
const char *shortname;
/*
* init - called initially to set up local pointer to object format,
* void pointer to implementation defined data, file pointer (which
* probably won't be used, but who knows?), and error function.
* init - called initially to set up local pointer to object format.
*/
void (*init) (struct ofmt * of, void *id, FILE * fp, efunc error);
void (*init)(void);
/*
* linenum - called any time there is output with a change of
* line number or file.
*/
void (*linenum) (const char *filename, int32_t linenumber, int32_t segto);
void (*linenum)(const char *filename, int32_t linenumber, int32_t segto);
/*
* debug_deflabel - called whenever a label is defined. Parameters
@ -977,8 +977,8 @@ struct dfmt {
* would be called before the output format version.
*/
void (*debug_deflabel) (char *name, int32_t segment, int64_t offset,
int is_global, char *special);
void (*debug_deflabel)(char *name, int32_t segment, int64_t offset,
int is_global, char *special);
/*
* debug_directive - called whenever a DEBUG directive other than 'LINE'
* is encountered. 'directive' contains the first parameter to the
@ -987,27 +987,29 @@ struct dfmt {
* function with 'directive' equal to "VAR" and 'params' equal to
* "_somevar:int".
*/
void (*debug_directive) (const char *directive, const char *params);
void (*debug_directive)(const char *directive, const char *params);
/*
* typevalue - called whenever the assembler wishes to register a type
* for the last defined label. This routine MUST detect if a type was
* already registered and not re-register it.
*/
void (*debug_typevalue) (int32_t type);
void (*debug_typevalue)(int32_t type);
/*
* debug_output - called whenever output is required
* 'type' is the type of info required, and this is format-specific
*/
void (*debug_output) (int type, void *param);
void (*debug_output)(int type, void *param);
/*
* cleanup - called after processing of file is complete
*/
void (*cleanup) (void);
void (*cleanup)(void);
};
extern const struct dfmt *dfmt;
/*
* The type definition macros
* for debugging

53
nasmlib.c
View file

@ -48,7 +48,7 @@
#include "insns.h"
int globalbits = 0; /* defined in nasm.h, works better here for ASM+DISASM */
efunc nasm_malloc_error; /* Exported for the benefit of vsnprintf.c */
static vefunc nasm_verror; /* Global error handling function */
#ifdef LOGALLOC
static FILE *logfp;
@ -72,9 +72,22 @@ void tolower_init(void)
nasm_tolower_tab[i] = tolower(i);
}
void nasm_set_malloc_error(efunc error)
void nasm_set_verror(vefunc ve)
{
nasm_verror = ve;
}
void nasm_error(int severity, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
nasm_verror(severity, fmt, ap);
va_end(ap);
}
void nasm_init_malloc_error(void)
{
nasm_malloc_error = error;
#ifdef LOGALLOC
logfp = fopen("malloc.log", "w");
setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
@ -90,7 +103,7 @@ void *nasm_malloc(size_t size)
{
void *p = malloc(size);
if (!p)
nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
@ -107,7 +120,7 @@ void *nasm_zalloc(size_t size)
{
void *p = calloc(size, 1);
if (!p)
nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
@ -124,7 +137,7 @@ void *nasm_realloc(void *q, size_t size)
{
void *p = q ? realloc(q, size) : malloc(size);
if (!p)
nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
#ifdef LOGALLOC
else if (q)
fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
@ -161,7 +174,7 @@ char *nasm_strdup(const char *s)
p = malloc(size);
if (!p)
nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
@ -182,7 +195,7 @@ char *nasm_strndup(const char *s, size_t len)
p = malloc(size);
if (!p)
nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
@ -195,8 +208,7 @@ char *nasm_strndup(const char *s, size_t len)
no_return nasm_assert_failed(const char *file, int line, const char *msg)
{
nasm_malloc_error(ERR_FATAL, "assertion %s failed at %s:%d",
msg, file, line);
nasm_error(ERR_FATAL, "assertion %s failed at %s:%d", msg, file, line);
exit(1);
}
@ -396,9 +408,9 @@ int64_t readnum(char *str, bool *error)
}
if (warn)
nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
"numeric constant %s does not fit in 64 bits",
str);
nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
"numeric constant %s does not fit in 64 bits",
str);
return result * sign;
}
@ -513,8 +525,7 @@ size_t fwritezero(size_t bytes, FILE *fp)
return count;
}
void standard_extension(char *inname, char *outname, char *extension,
efunc error)
void standard_extension(char *inname, char *outname, char *extension)
{
char *p, *q;
@ -531,13 +542,13 @@ void standard_extension(char *inname, char *outname, char *extension,
p++; /* go back to end if none found */
if (!strcmp(p, extension)) { /* is the extension already there? */
if (*extension)
error(ERR_WARNING | ERR_NOFILE,
"file name already ends in `%s': "
"output will be in `nasm.out'", extension);
nasm_error(ERR_WARNING | ERR_NOFILE,
"file name already ends in `%s': "
"output will be in `nasm.out'", extension);
else
error(ERR_WARNING | ERR_NOFILE,
"file name already has no extension: "
"output will be in `nasm.out'");
nasm_error(ERR_WARNING | ERR_NOFILE,
"file name already has no extension: "
"output will be in `nasm.out'");
strcpy(outname, "nasm.out");
} else
strcpy(p, extension);

11
nasmlib.h
View file

@ -83,7 +83,9 @@ extern unsigned char nasm_tolower_tab[256];
* An error reporting function should look like this.
*/
typedef void (*efunc) (int severity, const char *fmt, ...);
extern efunc nasm_malloc_error;
typedef void (*vefunc) (int severity, const char *fmt, va_list ap);
void nasm_error(int severity, const char *fmt, ...);
void nasm_set_verror(vefunc);
/*
* These are the error severity codes which get passed as the first
@ -133,7 +135,7 @@ extern efunc nasm_malloc_error;
* passed a NULL pointer; nasm_free will do nothing if it is passed
* a NULL pointer.
*/
void nasm_set_malloc_error(efunc);
void nasm_init_malloc_error(void);
#ifndef LOGALLOC
void *nasm_malloc(size_t);
void *nasm_zalloc(size_t);
@ -220,10 +222,7 @@ int32_t seg_alloc(void);
* many output formats will be able to make use of this: a standard
* function to add an extension to the name of the input file
*/
#ifdef NASM_NASM_H
void standard_extension(char *inname, char *outname, char *extension,
efunc error);
#endif
void standard_extension(char *inname, char *outname, char *extension);
/*
* Utility macros...

8
ndisasm.c
View file

@ -68,11 +68,8 @@ static const char *help =
static void output_ins(uint32_t, uint8_t *, int, char *);
static void skip(uint32_t dist, FILE * fp);
static void ndisasm_error(int severity, const char *fmt, ...)
static void ndisasm_verror(int severity, const char *fmt, va_list va)
{
va_list va;
va_start(va, fmt);
vfprintf(stderr, fmt, va);
if (severity & ERR_FATAL)
@ -97,7 +94,8 @@ int main(int argc, char **argv)
FILE *fp;
tolower_init();
nasm_set_malloc_error(ndisasm_error);
nasm_set_verror(ndisasm_verror);
nasm_init_malloc_error();
offset = 0;
init_sync();

12
output/nulldbg.c
View file

@ -34,19 +34,17 @@
#include "nasm.h"
#include "nasmlib.h"
void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error)
void null_debug_init(void)
{
(void)of;
(void)id;
(void)fp;
(void)error;
}
void null_debug_linenum(const char *filename, int32_t linenumber, int32_t segto)
{
(void)filename;
(void)linenumber;
(void)segto;
}
void null_debug_deflabel(char *name, int32_t segment, int64_t offset,
int is_global, char *special)
{
@ -56,20 +54,24 @@ void null_debug_deflabel(char *name, int32_t segment, int64_t offset,
(void)is_global;
(void)special;
}
void null_debug_routine(const char *directive, const char *params)
{
(void)directive;
(void)params;
}
void null_debug_typevalue(int32_t type)
{
(void)type;
}
void null_debug_output(int type, void *param)
{
(void)type;
(void)param;
}
void null_debug_cleanup(void)
{
}

145
output/outaout.c
View file

@ -49,6 +49,7 @@
#include "saa.h"
#include "raa.h"
#include "stdscan.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
@ -129,10 +130,6 @@ static uint32_t strslen;
static struct Symbol *fwds;
static FILE *aoutfp;
static efunc error;
static evalfunc evaluate;
static int bsd;
static int is_pic;
@ -153,13 +150,8 @@ static int32_t aout_gotpc_sect, aout_gotoff_sect;
static int32_t aout_got_sect, aout_plt_sect;
static int32_t aout_sym_sect;
static void aoutg_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void aoutg_init(void)
{
aoutfp = fp;
error = errfunc;
evaluate = eval;
(void)ldef; /* placate optimisers */
stext.data = saa_init(1L);
stext.head = NULL;
stext.tail = &stext.head;
@ -183,10 +175,10 @@ static void aoutg_init(FILE * fp, efunc errfunc, ldfunc ldef,
#ifdef OF_AOUT
static void aout_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void aout_init(void)
{
bsd = false;
aoutg_init(fp, errfunc, ldef, eval);
aoutg_init();
aout_gotpc_sect = aout_gotoff_sect = aout_got_sect =
aout_plt_sect = aout_sym_sect = NO_SEG;
@ -198,29 +190,28 @@ static void aout_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
extern struct ofmt of_aoutb;
static void aoutb_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void aoutb_init(void)
{
bsd = true;
aoutg_init(fp, errfunc, ldef, eval);
aoutg_init();
is_pic = 0x00; /* may become 0x40 */
aout_gotpc_sect = seg_alloc();
ldef("..gotpc", aout_gotpc_sect + 1, 0L, NULL, false, false, &of_aoutb,
error);
define_label("..gotpc", aout_gotpc_sect + 1, 0L, NULL, false, false, &of_aoutb,
nasm_error);
aout_gotoff_sect = seg_alloc();
ldef("..gotoff", aout_gotoff_sect + 1, 0L, NULL, false, false,
&of_aoutb, error);
define_label("..gotoff", aout_gotoff_sect + 1, 0L, NULL, false, false,
&of_aoutb, nasm_error);
aout_got_sect = seg_alloc();
ldef("..got", aout_got_sect + 1, 0L, NULL, false, false, &of_aoutb,
error);
define_label("..got", aout_got_sect + 1, 0L, NULL, false, false, &of_aoutb,
nasm_error);
aout_plt_sect = seg_alloc();
ldef("..plt", aout_plt_sect + 1, 0L, NULL, false, false, &of_aoutb,
error);
define_label("..plt", aout_plt_sect + 1, 0L, NULL, false, false, &of_aoutb,
nasm_error);
aout_sym_sect = seg_alloc();
ldef("..sym", aout_sym_sect + 1, 0L, NULL, false, false, &of_aoutb,
error);
define_label("..sym", aout_sym_sect + 1, 0L, NULL, false, false, &of_aoutb,
nasm_error);
}
#endif
@ -292,7 +283,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
strcmp(name, "..got") && strcmp(name, "..plt") &&
strcmp(name, "..sym"))
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
return;
}
@ -315,10 +306,10 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = p;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
(*s)->size = reloc_value(e);
@ -387,7 +378,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
!nasm_strnicmp(special, "object", n))
sym->type |= SYM_DATA;
else
error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
nasm_error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
n, special);
if (special[n]) {
struct tokenval tokval;
@ -396,7 +387,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
char *saveme = stdscan_bufptr; /* bugfix? fbk 8/10/00 */
if (!bsd) {
error(ERR_NONFATAL, "Linux a.out does not support"
nasm_error(ERR_NONFATAL, "Linux a.out does not support"
" symbol size information");
} else {
while (special[n] && nasm_isspace(special[n]))
@ -409,7 +400,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = special + n;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, error,
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, nasm_error,
NULL);
if (fwd) {
sym->nextfwd = fwds;
@ -417,7 +408,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
sym->name = nasm_strdup(name);
} else if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
sym->size = reloc_value(e);
@ -443,7 +434,7 @@ static void aout_deflabel(char *name, int32_t segment, int64_t offset,
nsyms++; /* and another for the size */
if (special && !special_used)
error(ERR_NONFATAL, "no special symbol features supported here");
nasm_error(ERR_NONFATAL, "no special symbol features supported here");
}
static void aout_add_reloc(struct Section *sect, int32_t segment,
@ -511,7 +502,7 @@ static int32_t aout_add_gsym_reloc(struct Section *sect,
shead = sbss.gsyms;
if (!shead) {
if (exact && offset != 0)
error(ERR_NONFATAL, "unable to find a suitable global symbol"
nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
" for this reference");
else
aout_add_reloc(sect, segment, type, bytes);
@ -535,7 +526,7 @@ static int32_t aout_add_gsym_reloc(struct Section *sect,
sym = sm;
}
if (!sym && exact) {
error(ERR_NONFATAL, "unable to find a suitable global symbol"
nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
" for this reference");
return 0;
}
@ -582,7 +573,7 @@ static int32_t aout_add_gotoff_reloc(struct Section *sect, int32_t segment,
else if (segment == sbss.index)
asym = sbss.asym;
if (!asym)
error(ERR_NONFATAL, "`..gotoff' relocations require a non-global"
nasm_error(ERR_NONFATAL, "`..gotoff' relocations require a non-global"
" symbol in the section");
r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
@ -612,7 +603,7 @@ static void aout_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -624,13 +615,13 @@ static void aout_out(int32_t segto, const void *data,
else if (segto == sbss.index)
s = NULL;
else {
error(ERR_WARNING, "attempt to assemble code in"
nasm_error(ERR_WARNING, "attempt to assemble code in"
" segment %d: defaulting to `.text'", segto);
s = &stext;
}
if (!s && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in the"
nasm_error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
sbss.len += realsize(type, size);
return;
@ -638,7 +629,7 @@ static void aout_out(int32_t segto, const void *data,
if (type == OUT_RESERVE) {
if (s) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
(segto == stext.index ? "code" : "data"));
aout_sect_write(s, NULL, size);
@ -646,20 +637,20 @@ static void aout_out(int32_t segto, const void *data,
sbss.len += size;
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
aout_sect_write(s, data, size);
} else if (type == OUT_ADDRESS) {
addr = *(int64_t *)data;
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "a.out format does not support"
nasm_error(ERR_NONFATAL, "a.out format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
aout_add_reloc(s, segment, RELTYPE_ABSOLUTE,
size);
} else if (!bsd) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Linux a.out format does not support"
" any use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
@ -681,11 +672,11 @@ static void aout_out(int32_t segto, const void *data,
false);
} else if (wrt == aout_plt_sect + 1) {
is_pic = 0x40;
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"a.out format cannot produce non-PC-"
"relative PLT references");
} else {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"a.out format does not support this"
" use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
@ -700,15 +691,15 @@ static void aout_out(int32_t segto, const void *data,
aout_sect_write(s, mydata, size);
} else if (type == OUT_REL2ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL2ADR");
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "a.out format does not support"
nasm_error(ERR_NONFATAL, "a.out format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
aout_add_reloc(s, segment, RELTYPE_RELATIVE, 2);
} else if (!bsd) {
error(ERR_NONFATAL, "Linux a.out format does not support"
nasm_error(ERR_NONFATAL, "Linux a.out format does not support"
" any use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
} else if (wrt == aout_plt_sect + 1) {
@ -717,10 +708,10 @@ static void aout_out(int32_t segto, const void *data,
} else if (wrt == aout_gotpc_sect + 1 ||
wrt == aout_gotoff_sect + 1 ||
wrt == aout_got_sect + 1) {
error(ERR_NONFATAL, "a.out format cannot produce PC-"
nasm_error(ERR_NONFATAL, "a.out format cannot produce PC-"
"relative GOT references");
} else {
error(ERR_NONFATAL, "a.out format does not support this"
nasm_error(ERR_NONFATAL, "a.out format does not support this"
" use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
}
@ -730,15 +721,15 @@ static void aout_out(int32_t segto, const void *data,
aout_sect_write(s, mydata, 2L);
} else if (type == OUT_REL4ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "a.out format does not support"
nasm_error(ERR_NONFATAL, "a.out format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
aout_add_reloc(s, segment, RELTYPE_RELATIVE, 4);
} else if (!bsd) {
error(ERR_NONFATAL, "Linux a.out format does not support"
nasm_error(ERR_NONFATAL, "Linux a.out format does not support"
" any use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
} else if (wrt == aout_plt_sect + 1) {
@ -747,10 +738,10 @@ static void aout_out(int32_t segto, const void *data,
} else if (wrt == aout_gotpc_sect + 1 ||
wrt == aout_gotoff_sect + 1 ||
wrt == aout_got_sect + 1) {
error(ERR_NONFATAL, "a.out format cannot produce PC-"
nasm_error(ERR_NONFATAL, "a.out format cannot produce PC-"
"relative GOT references");
} else {
error(ERR_NONFATAL, "a.out format does not support this"
nasm_error(ERR_NONFATAL, "a.out format does not support this"
" use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
}
@ -822,20 +813,20 @@ static void aout_write(void)
* Emit the a.out header.
*/
/* OMAGIC, M_386 or MID_I386, no flags */
fwriteint32_t(bsd ? 0x07018600 | is_pic : 0x640107L, aoutfp);
fwriteint32_t(stext.len, aoutfp);
fwriteint32_t(sdata.len, aoutfp);
fwriteint32_t(sbss.len, aoutfp);
fwriteint32_t(nsyms * 12, aoutfp); /* length of symbol table */
fwriteint32_t(0L, aoutfp); /* object files have no entry point */
fwriteint32_t(stext.nrelocs * 8, aoutfp); /* size of text relocs */
fwriteint32_t(sdata.nrelocs * 8, aoutfp); /* size of data relocs */
fwriteint32_t(bsd ? 0x07018600 | is_pic : 0x640107L, ofile);
fwriteint32_t(stext.len, ofile);
fwriteint32_t(sdata.len, ofile);
fwriteint32_t(sbss.len, ofile);
fwriteint32_t(nsyms * 12, ofile); /* length of symbol table */
fwriteint32_t(0L, ofile); /* object files have no entry point */
fwriteint32_t(stext.nrelocs * 8, ofile); /* size of text relocs */
fwriteint32_t(sdata.nrelocs * 8, ofile); /* size of data relocs */
/*
* Write out the code section and the data section.
*/
saa_fpwrite(stext.data, aoutfp);
saa_fpwrite(sdata.data, aoutfp);
saa_fpwrite(stext.data, ofile);
saa_fpwrite(sdata.data, ofile);
/*
* Write out the relocations.
@ -851,8 +842,8 @@ static void aout_write(void)
/*
* And the string table.
*/
fwriteint32_t(strslen + 4, aoutfp); /* length includes length count */
saa_fpwrite(strs, aoutfp);
fwriteint32_t(strslen + 4, ofile); /* length includes length count */
saa_fpwrite(strs, ofile);
}
static void aout_write_relocs(struct Reloc *r)
@ -860,7 +851,7 @@ static void aout_write_relocs(struct Reloc *r)
while (r) {
uint32_t word2;
fwriteint32_t(r->address, aoutfp);
fwriteint32_t(r->address, ofile);
if (r->symbol >= 0)
word2 = r->symbol;
@ -869,7 +860,7 @@ static void aout_write_relocs(struct Reloc *r)
word2 |= r->reltype << 24;
word2 |= (r->bytes == 1 ? 0 :
r->bytes == 2 ? 0x2000000L : 0x4000000L);
fwriteint32_t(word2, aoutfp);
fwriteint32_t(word2, ofile);
r = r->next;
}
@ -882,8 +873,8 @@ static void aout_write_syms(void)
saa_rewind(syms);
for (i = 0; i < nsyms; i++) {
struct Symbol *sym = saa_rstruct(syms);
fwriteint32_t(sym->strpos, aoutfp);
fwriteint32_t((int32_t)sym->type & ~SYM_WITH_SIZE, aoutfp);
fwriteint32_t(sym->strpos, ofile);
fwriteint32_t((int32_t)sym->type & ~SYM_WITH_SIZE, ofile);
/*
* Fix up the symbol value now we know the final section
* sizes.
@ -892,14 +883,14 @@ static void aout_write_syms(void)
sym->value += stext.len;
if ((sym->type & SECT_MASK) == SECT_BSS)
sym->value += stext.len + sdata.len;
fwriteint32_t(sym->value, aoutfp);
fwriteint32_t(sym->value, ofile);
/*
* Output a size record if necessary.
*/
if (sym->type & SYM_WITH_SIZE) {
fwriteint32_t(sym->strpos, aoutfp);
fwriteint32_t(0x0DL, aoutfp); /* special value: means size */
fwriteint32_t(sym->size, aoutfp);
fwriteint32_t(sym->strpos, ofile);
fwriteint32_t(0x0DL, ofile); /* special value: means size */
fwriteint32_t(sym->size, ofile);
i++; /* use up another of `nsyms' */
}
}
@ -917,9 +908,9 @@ static int32_t aout_segbase(int32_t segment)
return segment;
}
static void aout_filename(char *inname, char *outname, efunc error)
static void aout_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t aout_stdmac[];

124
output/outas86.c
View file

@ -107,21 +107,14 @@ static uint32_t strslen;
static int as86_reloc_size;
static FILE *as86fp;
static efunc error;
static void as86_write(void);
static void as86_write_section(struct Section *, int);
static int as86_add_string(char *name);
static void as86_sect_write(struct Section *, const uint8_t *,
uint32_t);
static void as86_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void as86_init(void)
{
as86fp = fp;
error = errfunc;
(void)ldef; /* placate optimisers */
(void)eval;
stext.data = saa_init(1L);
stext.datalen = 0L;
stext.head = stext.last = NULL;
@ -211,13 +204,13 @@ static void as86_deflabel(char *name, int32_t segment, int64_t offset,
struct Symbol *sym;
if (special)
error(ERR_NONFATAL, "as86 format does not support any"
nasm_error(ERR_NONFATAL, "as86 format does not support any"
" special symbol types");
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
if (strcmp(name, "..start")) {
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
return;
} else {
is_start = true;
@ -305,7 +298,7 @@ static void as86_out(int32_t segto, const void *data,
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
error(ERR_NONFATAL, "WRT not supported by as86 output format");
nasm_error(ERR_NONFATAL, "WRT not supported by as86 output format");
}
/*
@ -313,7 +306,7 @@ static void as86_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -325,13 +318,13 @@ static void as86_out(int32_t segto, const void *data,
else if (segto == bssindex)
s = NULL;
else {
error(ERR_WARNING, "attempt to assemble code in"
nasm_error(ERR_WARNING, "attempt to assemble code in"
" segment %d: defaulting to `.text'", segto);
s = &stext;
}
if (!s && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in the"
nasm_error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
bsslen += realsize(type, size);
return;
@ -339,7 +332,7 @@ static void as86_out(int32_t segto, const void *data,
if (type == OUT_RESERVE) {
if (s) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
(segto == stext.index ? "code" : "data"));
as86_sect_write(s, NULL, size);
@ -348,13 +341,13 @@ static void as86_out(int32_t segto, const void *data,
bsslen += size;
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
as86_sect_write(s, data, size);
as86_add_piece(s, 0, 0L, 0L, size, 0);
} else if (type == OUT_ADDRESS) {
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "as86 format does not support"
nasm_error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
@ -368,10 +361,10 @@ static void as86_out(int32_t segto, const void *data,
}
} else if (type == OUT_REL2ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL2ADR");
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "as86 format does not support"
nasm_error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
@ -381,10 +374,10 @@ static void as86_out(int32_t segto, const void *data,
}
} else if (type == OUT_REL4ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "as86 format does not support"
nasm_error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
@ -439,23 +432,23 @@ static void as86_write(void)
/*
* Emit the as86 header.
*/
fwriteint32_t(0x000186A3L, as86fp);
fputc(0x2A, as86fp);
fwriteint32_t(27 + symlen + seglen + strslen, as86fp); /* header length */
fwriteint32_t(stext.len + sdata.len + bsslen, as86fp);
fwriteint16_t(strslen, as86fp);
fwriteint16_t(0, as86fp); /* class = revision = 0 */
fwriteint32_t(0x55555555L, as86fp); /* segment max sizes: always this */
fwriteint32_t(segsize, as86fp); /* segment size descriptors */
fwriteint32_t(0x000186A3L, ofile);
fputc(0x2A, ofile);
fwriteint32_t(27 + symlen + seglen + strslen, ofile); /* header length */
fwriteint32_t(stext.len + sdata.len + bsslen, ofile);
fwriteint16_t(strslen, ofile);
fwriteint16_t(0, ofile); /* class = revision = 0 */
fwriteint32_t(0x55555555L, ofile); /* segment max sizes: always this */
fwriteint32_t(segsize, ofile); /* segment size descriptors */
if (segsize & 0x01000000L)
fwriteint32_t(stext.len, as86fp);
fwriteint32_t(stext.len, ofile);
else
fwriteint16_t(stext.len, as86fp);
fwriteint16_t(stext.len, ofile);
if (segsize & 0x40000000L)
fwriteint32_t(sdata.len + bsslen, as86fp);
fwriteint32_t(sdata.len + bsslen, ofile);
else
fwriteint16_t(sdata.len + bsslen, as86fp);
fwriteint16_t(nsyms, as86fp);
fwriteint16_t(sdata.len + bsslen, ofile);
fwriteint16_t(nsyms, ofile);
/*
* Write the symbol table.
@ -463,19 +456,19 @@ static void as86_write(void)
saa_rewind(syms);
for (i = 0; i < nsyms; i++) {
struct Symbol *sym = saa_rstruct(syms);
fwriteint16_t(sym->strpos, as86fp);
fwriteint16_t(sym->flags, as86fp);
fwriteint16_t(sym->strpos, ofile);
fwriteint16_t(sym->flags, ofile);
switch (sym->flags & (3 << 14)) {
case 0 << 14:
break;
case 1 << 14:
fputc(sym->value, as86fp);
fputc(sym->value, ofile);
break;
case 2 << 14:
fwriteint16_t(sym->value, as86fp);
fwriteint16_t(sym->value, ofile);
break;
case 3 << 14:
fwriteint32_t(sym->value, as86fp);
fwriteint32_t(sym->value, ofile);
break;
}
}
@ -483,7 +476,7 @@ static void as86_write(void)
/*
* Write out the string table.
*/
saa_fpwrite(strs, as86fp);
saa_fpwrite(strs, ofile);
/*
* Write the program text.
@ -495,17 +488,17 @@ static void as86_write(void)
* Append the BSS section to the .data section
*/
if (bsslen > 65535L) {
fputc(0x13, as86fp);
fwriteint32_t(bsslen, as86fp);
fputc(0x13, ofile);
fwriteint32_t(bsslen, ofile);
} else if (bsslen > 255) {
fputc(0x12, as86fp);
fwriteint16_t(bsslen, as86fp);
fputc(0x12, ofile);
fwriteint16_t(bsslen, ofile);
} else if (bsslen) {
fputc(0x11, as86fp);
fputc(bsslen, as86fp);
fputc(0x11, ofile);
fputc(bsslen, ofile);
}
fputc(0, as86fp); /* termination */
fputc(0, ofile); /* termination */
}
static void as86_set_rsize(int size)
@ -513,16 +506,17 @@ static void as86_set_rsize(int size)
if (as86_reloc_size != size) {
switch (as86_reloc_size = size) {
case 1:
fputc(0x01, as86fp);
fputc(0x01, ofile);
break;
case 2:
fputc(0x02, as86fp);
fputc(0x02, ofile);
break;
case 4:
fputc(0x03, as86fp);
fputc(0x03, ofile);
break;
default:
error(ERR_PANIC, "bizarre relocation size %d", size);
nasm_error(ERR_PANIC, "bizarre relocation size %d", size);
break;
}
}
}
@ -533,7 +527,7 @@ static void as86_write_section(struct Section *sect, int index)
uint32_t s;
int32_t length;
fputc(0x20 + index, as86fp); /* select the right section */
fputc(0x20 + index, ofile); /* select the right section */
saa_rewind(sect->data);
@ -548,9 +542,9 @@ static void as86_write_section(struct Section *sect, int index)
do {
char buf[64];
int32_t tmplen = (length > 64 ? 64 : length);
fputc(0x40 | (tmplen & 0x3F), as86fp);
fputc(0x40 | (tmplen & 0x3F), ofile);
saa_rnbytes(sect->data, buf, tmplen);
fwrite(buf, 1, tmplen, as86fp);
fwrite(buf, 1, tmplen, ofile);
length -= tmplen;
} while (length > 0);
break;
@ -561,11 +555,11 @@ static void as86_write_section(struct Section *sect, int index)
if (p->number == SECT_BSS)
p->number = SECT_DATA, p->offset += sdata.len;
as86_set_rsize(p->bytes);
fputc(0x80 | (p->relative ? 0x20 : 0) | p->number, as86fp);
fputc(0x80 | (p->relative ? 0x20 : 0) | p->number, ofile);
if (as86_reloc_size == 2)
fwriteint16_t(p->offset, as86fp);
fwriteint16_t(p->offset, ofile);
else
fwriteint32_t(p->offset, as86fp);
fwriteint32_t(p->offset, ofile);
break;
case 2:
/*
@ -583,22 +577,22 @@ static void as86_write_section(struct Section *sect, int index)
s = 0;
fputc(0xC0 |
(p->relative ? 0x20 : 0) |
(p->number > 255 ? 0x04 : 0) | s, as86fp);
(p->number > 255 ? 0x04 : 0) | s, ofile);
if (p->number > 255)
fwriteint16_t(p->number, as86fp);
fwriteint16_t(p->number, ofile);
else
fputc(p->number, as86fp);
fputc(p->number, ofile);
switch ((int)s) {
case 0:
break;
case 1:
fputc(p->offset, as86fp);
fputc(p->offset, ofile);
break;
case 2:
fwriteint16_t(p->offset, as86fp);
fwriteint16_t(p->offset, ofile);
break;
case 3:
fwriteint32_t(p->offset, as86fp);
fwriteint32_t(p->offset, ofile);
break;
}
break;
@ -617,7 +611,7 @@ static int32_t as86_segbase(int32_t segment)
return segment;
}
static void as86_filename(char *inname, char *outname, efunc error)
static void as86_filename(char *inname, char *outname)
{
char *p;
@ -627,7 +621,7 @@ static void as86_filename(char *inname, char *outname, efunc error)
} else
strcpy(as86_module, inname);
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t as86_stdmac[];

159
output/outbin.c
View file

@ -92,9 +92,7 @@
#ifdef OF_BIN
static FILE *fp, *rf = NULL;
static efunc error;
static struct ofmt *my_ofmt;
static FILE *rf = NULL;
static void (*do_output)(void);
/* Section flags keep track of which attributes the user has defined. */
@ -278,7 +276,7 @@ static void bin_cleanup(int debuginfo)
if (s->flags & (START_DEFINED | ALIGN_DEFINED | FOLLOWS_DEFINED)) { /* Check for a mixture of real and virtual section attributes. */
if (s->flags & (VSTART_DEFINED | VALIGN_DEFINED |
VFOLLOWS_DEFINED))
error(ERR_FATAL|ERR_NOFILE,
nasm_error(ERR_FATAL|ERR_NOFILE,
"cannot mix real and virtual attributes"
" in nobits section (%s)", s->name);
/* Real and virtual attributes mean the same thing for nobits sections. */
@ -349,11 +347,11 @@ static void bin_cleanup(int debuginfo)
s && strcmp(s->name, g->follows);
sp = &s->next, s = s->next) ;
if (!s)
error(ERR_FATAL|ERR_NOFILE, "section %s follows an invalid or"
nasm_error(ERR_FATAL|ERR_NOFILE, "section %s follows an invalid or"
" unknown section (%s)", g->name, g->follows);
if (s->next && (s->next->flags & FOLLOWS_DEFINED) &&
!strcmp(s->name, s->next->follows))
error(ERR_FATAL|ERR_NOFILE, "sections %s and %s can't both follow"
nasm_error(ERR_FATAL|ERR_NOFILE, "sections %s and %s can't both follow"
" section %s", g->name, s->next->name, s->name);
/* Find the end of the current follows group (gs). */
for (gsp = &g->next, gs = g->next;
@ -397,7 +395,7 @@ static void bin_cleanup(int debuginfo)
if (sections->flags & START_DEFINED) {
/* Make sure this section doesn't begin before the origin. */
if (sections->start < origin)
error(ERR_FATAL|ERR_NOFILE, "section %s begins"
nasm_error(ERR_FATAL|ERR_NOFILE, "section %s begins"
" before program origin", sections->name);
} else if (sections->flags & ALIGN_DEFINED) {
sections->start = ((origin + sections->align - 1) &
@ -454,13 +452,13 @@ static void bin_cleanup(int debuginfo)
/* Check for section overlap. */
if (s) {
if (s->start < origin)
error(ERR_FATAL|ERR_NOFILE, "section %s beings before program origin",
nasm_error(ERR_FATAL|ERR_NOFILE, "section %s beings before program origin",
s->name);
if (g->start > s->start)
error(ERR_FATAL|ERR_NOFILE, "sections %s ~ %s and %s overlap!",
nasm_error(ERR_FATAL|ERR_NOFILE, "sections %s ~ %s and %s overlap!",
gs->name, g->name, s->name);
if (pend > s->start)
error(ERR_FATAL|ERR_NOFILE, "sections %s and %s overlap!",
nasm_error(ERR_FATAL|ERR_NOFILE, "sections %s and %s overlap!",
g->name, s->name);
}
/* Remember this section as the latest >0 length section. */
@ -489,7 +487,7 @@ static void bin_cleanup(int debuginfo)
for (s = sections; s && strcmp(g->vfollows, s->name);
s = s->next) ;
if (!s)
error(ERR_FATAL|ERR_NOFILE,
nasm_error(ERR_FATAL|ERR_NOFILE,
"section %s vfollows unknown section (%s)",
g->name, g->vfollows);
} else if (g->ifollows != NULL)
@ -523,13 +521,13 @@ static void bin_cleanup(int debuginfo)
for (h = 0, s = sections; s; s = s->next) {
if (!(s->flags & VSTART_DEFINED)) { /* Non-fatal errors after assembly has completed are generally a
* no-no, but we'll throw a fatal one eventually so it's ok. */
error(ERR_NONFATAL, "cannot compute vstart for section %s",
nasm_error(ERR_NONFATAL, "cannot compute vstart for section %s",
s->name);
h++;
}
}
if (h)
error(ERR_FATAL|ERR_NOFILE, "circular vfollows path detected");
nasm_error(ERR_FATAL|ERR_NOFILE, "circular vfollows path detected");
#ifdef DEBUG
fprintf(stdout,
@ -756,13 +754,13 @@ static void bin_out(int32_t segto, const void *data,
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
error(ERR_NONFATAL, "WRT not supported by binary output format");
nasm_error(ERR_NONFATAL, "WRT not supported by binary output format");
}
/* Handle absolute-assembly (structure definitions). */
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in"
nasm_error(ERR_NONFATAL, "attempt to assemble code in"
" [ABSOLUTE] space");
return;
}
@ -770,7 +768,7 @@ static void bin_out(int32_t segto, const void *data,
/* Find the segment we are targeting. */
s = find_section_by_index(segto);
if (!s)
error(ERR_PANIC, "code directed to nonexistent segment?");
nasm_error(ERR_PANIC, "code directed to nonexistent segment?");
/* "Smart" section-type adaptation code. */
if (!(s->flags & TYPE_DEFINED)) {
@ -781,16 +779,16 @@ static void bin_out(int32_t segto, const void *data,
}
if ((s->flags & TYPE_NOBITS) && (type != OUT_RESERVE))
error(ERR_WARNING, "attempt to initialize memory in a"
nasm_error(ERR_WARNING, "attempt to initialize memory in a"
" nobits section: ignored");
if (type == OUT_ADDRESS) {
if (segment != NO_SEG && !find_section_by_index(segment)) {
if (segment % 2)
error(ERR_NONFATAL, "binary output format does not support"
nasm_error(ERR_NONFATAL, "binary output format does not support"
" segment base references");
else
error(ERR_NONFATAL, "binary output format does not support"
nasm_error(ERR_NONFATAL, "binary output format does not support"
" external references");
segment = NO_SEG;
}
@ -808,7 +806,7 @@ static void bin_out(int32_t segto, const void *data,
s->length += size;
} else if (type == OUT_RESERVE) {
if (s->flags & TYPE_PROGBITS) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing", s->name);
saa_wbytes(s->contents, NULL, size);
}
@ -819,10 +817,10 @@ static void bin_out(int32_t segto, const void *data,
size = realsize(type, size);
if (segment != NO_SEG && !find_section_by_index(segment)) {
if (segment % 2)
error(ERR_NONFATAL, "binary output format does not support"
nasm_error(ERR_NONFATAL, "binary output format does not support"
" segment base references");
else
error(ERR_NONFATAL, "binary output format does not support"
nasm_error(ERR_NONFATAL, "binary output format does not support"
" external references");
segment = NO_SEG;
}
@ -843,12 +841,12 @@ static void bin_deflabel(char *name, int32_t segment, int64_t offset,
(void)offset; /* Don't warn that this parameter is unused */
if (special)
error(ERR_NONFATAL, "binary format does not support any"
nasm_error(ERR_NONFATAL, "binary format does not support any"
" special symbol types");
else if (name[0] == '.' && name[1] == '.' && name[2] != '@')
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
else if (is_global == 2)
error(ERR_NONFATAL, "binary output format does not support common"
nasm_error(ERR_NONFATAL, "binary output format does not support common"
" variables");
else {
struct Section *s;
@ -964,14 +962,14 @@ static int bin_read_attribute(char **line, int *attribute,
break;
}
if (!**line) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"invalid syntax in `section' directive");
return -1;
}
++(*line);
}
if (!**line) {
error(ERR_NONFATAL, "expecting `)'");
nasm_error(ERR_NONFATAL, "expecting `)'");
return -1;
}
}
@ -980,7 +978,7 @@ static int bin_read_attribute(char **line, int *attribute,
/* Check for no value given. */
if (!*exp) {
error(ERR_WARNING, "No value given to attribute in"
nasm_error(ERR_WARNING, "No value given to attribute in"
" `section' directive");
return -1;
}
@ -989,15 +987,15 @@ static int bin_read_attribute(char **line, int *attribute,
stdscan_reset();
stdscan_bufptr = exp;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_really_simple(e)) {
error(ERR_NONFATAL, "section attribute value must be"
nasm_error(ERR_NONFATAL, "section attribute value must be"
" a critical expression");
return -1;
}
} else {
error(ERR_NONFATAL, "Invalid attribute value"
nasm_error(ERR_NONFATAL, "Invalid attribute value"
" specified in `section' directive.");
return -1;
}
@ -1028,7 +1026,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
*astring = '\0';
astring++;
}
error(ERR_WARNING, "ignoring unknown section attribute:"
nasm_error(ERR_WARNING, "ignoring unknown section attribute:"
" \"%s\"", p);
}
continue;
@ -1038,7 +1036,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
case ATTRIB_NOBITS:
if ((sec->flags & TYPE_DEFINED)
&& (sec->flags & TYPE_PROGBITS))
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"attempt to change section type"
" from progbits to nobits");
else
@ -1048,7 +1046,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle progbits attribute. */
case ATTRIB_PROGBITS:
if ((sec->flags & TYPE_DEFINED) && (sec->flags & TYPE_NOBITS))
error(ERR_NONFATAL, "attempt to change section type"
nasm_error(ERR_NONFATAL, "attempt to change section type"
" from nobits to progbits");
else
sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
@ -1057,11 +1055,11 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle align attribute. */
case ATTRIB_ALIGN:
if (!format_mode && (!strcmp(sec->name, ".text")))
error(ERR_NONFATAL, "cannot specify an alignment"
nasm_error(ERR_NONFATAL, "cannot specify an alignment"
" to the .text section");
else {
if (!value || ((value - 1) & value))
error(ERR_NONFATAL, "argument to `align' is not a"
nasm_error(ERR_NONFATAL, "argument to `align' is not a"
" power of two");
else { /* Alignment is already satisfied if the previous
* align value is greater. */
@ -1072,7 +1070,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Don't allow a conflicting align value. */
if ((sec->flags & START_DEFINED)
&& (sec->start & (value - 1)))
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`align' value conflicts "
"with section start address");
else {
@ -1086,7 +1084,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle valign attribute. */
case ATTRIB_VALIGN:
if (!value || ((value - 1) & value))
error(ERR_NONFATAL, "argument to `valign' is not a"
nasm_error(ERR_NONFATAL, "argument to `valign' is not a"
" power of two");
else { /* Alignment is already satisfied if the previous
* align value is greater. */
@ -1096,7 +1094,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Don't allow a conflicting valign value. */
if ((sec->flags & VSTART_DEFINED)
&& (sec->vstart & (value - 1)))
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`valign' value conflicts "
"with `vstart' address");
else {
@ -1109,16 +1107,16 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle start attribute. */
case ATTRIB_START:
if (sec->flags & FOLLOWS_DEFINED)
error(ERR_NONFATAL, "cannot combine `start' and `follows'"
nasm_error(ERR_NONFATAL, "cannot combine `start' and `follows'"
" section attributes");
else if ((sec->flags & START_DEFINED) && (value != sec->start))
error(ERR_NONFATAL, "section start address redefined");
nasm_error(ERR_NONFATAL, "section start address redefined");
else {
sec->start = value;
sec->flags |= START_DEFINED;
if (sec->flags & ALIGN_DEFINED) {
if (sec->start & (sec->align - 1))
error(ERR_NONFATAL, "`start' address conflicts"
nasm_error(ERR_NONFATAL, "`start' address conflicts"
" with section alignment");
sec->flags ^= ALIGN_DEFINED;
}
@ -1128,12 +1126,12 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle vstart attribute. */
case ATTRIB_VSTART:
if (sec->flags & VFOLLOWS_DEFINED)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"cannot combine `vstart' and `vfollows'"
" section attributes");
else if ((sec->flags & VSTART_DEFINED)
&& (value != sec->vstart))
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"section virtual start address"
" (vstart) redefined");
else {
@ -1141,7 +1139,7 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
sec->flags |= VSTART_DEFINED;
if (sec->flags & VALIGN_DEFINED) {
if (sec->vstart & (sec->valign - 1))
error(ERR_NONFATAL, "`vstart' address conflicts"
nasm_error(ERR_NONFATAL, "`vstart' address conflicts"
" with `valign' value");
sec->flags ^= VALIGN_DEFINED;
}
@ -1153,12 +1151,12 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
p = astring;
astring += strcspn(astring, " \t");
if (astring == p)
error(ERR_NONFATAL, "expecting section name for `follows'"
nasm_error(ERR_NONFATAL, "expecting section name for `follows'"
" attribute");
else {
*(astring++) = '\0';
if (sec->flags & START_DEFINED)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"cannot combine `start' and `follows'"
" section attributes");
sec->follows = nasm_strdup(p);
@ -1169,14 +1167,14 @@ static void bin_assign_attributes(struct Section *sec, char *astring)
/* Handle vfollows attribute. */
case ATTRIB_VFOLLOWS:
if (sec->flags & VSTART_DEFINED)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"cannot combine `vstart' and `vfollows'"
" section attributes");
else {
p = astring;
astring += strcspn(astring, " \t");
if (astring == p)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"expecting section name for `vfollows'"
" attribute");
else {
@ -1208,12 +1206,12 @@ static void bin_define_section_labels(void)
/* section.<name>.start */
strcpy(label_name + base_len, ".start");
define_label(label_name, sec->start_index, 0L,
NULL, 0, 0, my_ofmt, error);
NULL, 0, 0, ofmt, nasm_error);
/* section.<name>.vstart */
strcpy(label_name + base_len, ".vstart");
define_label(label_name, sec->vstart_index, 0L,
NULL, 0, 0, my_ofmt, error);
NULL, 0, 0, ofmt, nasm_error);
nasm_free(label_name);
}
@ -1263,7 +1261,7 @@ static int32_t bin_secname(char *name, int pass, int *bits)
sec->flags |= TYPE_DEFINED | TYPE_NOBITS;
sec->ifollows = NULL;
} else if (!format_mode) {
error(ERR_NONFATAL, "section name must be "
nasm_error(ERR_NONFATAL, "section name must be "
".text, .data, or .bss");
return current_section;
}
@ -1298,23 +1296,23 @@ static int bin_directive(enum directives directive, char *args, int pass)
stdscan_reset();
stdscan_bufptr = args;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_really_simple(e))
error(ERR_NONFATAL, "org value must be a critical"
nasm_error(ERR_NONFATAL, "org value must be a critical"
" expression");
else {
value = reloc_value(e);
/* Check for ORG redefinition. */
if (origin_defined && (value != origin))
error(ERR_NONFATAL, "program origin redefined");
nasm_error(ERR_NONFATAL, "program origin redefined");
else {
origin = value;
origin_defined = 1;
}
}
} else
error(ERR_NONFATAL, "No or invalid offset specified"
nasm_error(ERR_NONFATAL, "No or invalid offset specified"
" in ORG directive.");
return 1;
}
@ -1351,14 +1349,14 @@ static int bin_directive(enum directives directive, char *args, int pass)
else { /* Must be a filename. */
rf = fopen(p, "wt");
if (!rf) {
error(ERR_WARNING, "unable to open map file `%s'",
nasm_error(ERR_WARNING, "unable to open map file `%s'",
p);
map_control = 0;
return 1;
}
}
} else
error(ERR_WARNING, "map file already specified");
nasm_error(ERR_WARNING, "map file already specified");
}
if (map_control == 0)
map_control |= MAP_ORIGIN | MAP_SUMMARY;
@ -1371,23 +1369,23 @@ static int bin_directive(enum directives directive, char *args, int pass)
}
}
static void bin_filename(char *inname, char *outname, efunc error)
static void bin_filename(char *inname, char *outname)
{
standard_extension(inname, outname, "", error);
standard_extension(inname, outname, "");
infile = inname;
outfile = outname;
}
static void ith_filename(char *inname, char *outname, efunc error)
static void ith_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".ith", error);
standard_extension(inname, outname, ".ith");
infile = inname;
outfile = outname;
}
static void srec_filename(char *inname, char *outname, efunc error)
static void srec_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".srec", error);
standard_extension(inname, outname, ".srec");
infile = inname;
outfile = outname;
}
@ -1404,41 +1402,32 @@ static int bin_set_info(enum geninfo type, char **val)
return 0;
}
static void binfmt_init(FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval);
struct ofmt of_bin, of_ith, of_srec;
static void binfmt_init(void);
static void do_output_bin(void);
static void do_output_ith(void);
static void do_output_srec(void);
static void bin_init(FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void bin_init(void)
{
my_ofmt = &of_bin;
do_output = do_output_bin;
binfmt_init(afp, errfunc, ldef, eval);
binfmt_init();
}
static void ith_init(FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void ith_init(void)
{
my_ofmt = &of_ith;
do_output = do_output_ith;
binfmt_init(afp, errfunc, ldef, eval);
binfmt_init();
}
static void srec_init(FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void srec_init(void)
{
my_ofmt = &of_srec;
do_output = do_output_srec;
binfmt_init(afp, errfunc, ldef, eval);
binfmt_init();
}
static void binfmt_init(FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void binfmt_init(void)
{
fp = afp;
error = errfunc;
(void)eval; /* Don't warn that this parameter is unused. */
(void)ldef; /* Placate optimizers. */
maxbits = 64; /* Support 64-bit Segments */
relocs = NULL;
reloctail = &relocs;
@ -1480,10 +1469,10 @@ static void do_output_bin(void)
/* Pad the space between sections. */
nasm_assert(addr <= s->start);
fwritezero(s->start - addr, fp);
fwritezero(s->start - addr, ofile);
/* Write the section to the output file. */
saa_fpwrite(s->contents, fp);
saa_fpwrite(s->contents, ofile);
/* Keep track of the current file position */
addr = s->start + s->length;
@ -1511,7 +1500,7 @@ static int write_ith_record(unsigned int len, uint16_t addr,
p += sprintf(p, "%02X", dptr[i]);
p += sprintf(p, "%02X\n", csum);
if (fwrite(buf, 1, p-buf, fp) != (size_t)(p-buf))
if (fwrite(buf, 1, p-buf, ofile) != (size_t)(p-buf))
return -1;
return 0;
@ -1599,7 +1588,7 @@ static int write_srecord(unsigned int len, unsigned int alen,
p += sprintf(p, "%02X", dptr[i]);
p += sprintf(p, "%02X\n", csum);
if (fwrite(buf, 1, p-buf, fp) != (size_t)(p-buf))
if (fwrite(buf, 1, p-buf, ofile) != (size_t)(p-buf))
return -1;
return 0;

175
output/outcoff.c
View file

@ -49,6 +49,7 @@
#include "nasmlib.h"
#include "saa.h"
#include "raa.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
@ -135,8 +136,6 @@ struct Symbol {
int32_t namlen; /* full name length */
};
static FILE *coffp;
static efunc error;
static char coff_infile[FILENAME_MAX];
struct Section {
@ -172,7 +171,7 @@ static struct RAA *bsym, *symval;
static struct SAA *strs;
static uint32_t strslen;
static void coff_gen_init(FILE *, efunc);
static void coff_gen_init(void);
static void coff_sect_write(struct Section *, const uint8_t *,
uint32_t);
static void coff_write(void);
@ -180,43 +179,33 @@ static void coff_section_header(char *, int32_t, int32_t, int32_t, int32_t, int,
static void coff_write_relocs(struct Section *);
static void coff_write_symbols(void);
static void coff_win32_init(FILE * fp, efunc errfunc,
ldfunc ldef, evalfunc eval)
static void coff_win32_init(void)
{
win32 = true; win64 = false;
(void)ldef; /* placate optimizers */
(void)eval;
coff_gen_init(fp, errfunc);
win32 = true;
win64 = false;
coff_gen_init();
}
static void coff_win64_init(FILE * fp, efunc errfunc,
ldfunc ldef, evalfunc eval)
static void coff_win64_init(void)
{
extern struct ofmt of_win64;
maxbits = 64;
win32 = false; win64 = true;
(void)ldef; /* placate optimizers */
(void)eval;
coff_gen_init(fp, errfunc);
win32 = false;
win64 = true;
coff_gen_init();
imagebase_sect = seg_alloc()+1;
ldef(WRT_IMAGEBASE,imagebase_sect,0,NULL,false,false,&of_win64,errfunc);
define_label(WRT_IMAGEBASE, imagebase_sect, 0, NULL, false, false,
ofmt, nasm_error);
}
static void coff_std_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void coff_std_init(void)
{
win32 = win64 = false;
(void)ldef; /* placate optimizers */
(void)eval;
coff_gen_init(fp, errfunc);
coff_gen_init();
}
static void coff_gen_init(FILE * fp, efunc errfunc)
static void coff_gen_init(void)
{
coffp = fp;
error = errfunc;
sects = NULL;
nsects = sectlen = 0;
syms = saa_init(sizeof(struct Symbol));
@ -309,7 +298,7 @@ static int32_t coff_section_names(char *name, int pass, int *bits)
if (*p)
*p++ = '\0';
if (strlen(name) > 8) {
error(ERR_WARNING, "COFF section names limited to 8 characters:"
nasm_error(ERR_WARNING, "COFF section names limited to 8 characters:"
" truncating");
name[8] = '\0';
}
@ -335,7 +324,7 @@ static int32_t coff_section_names(char *name, int pass, int *bits)
flags = RDATA_FLAGS;
else {
flags = DATA_FLAGS; /* gotta do something */
error(ERR_NONFATAL, "standard COFF does not support"
nasm_error(ERR_NONFATAL, "standard COFF does not support"
" read-only data sections");
}
} else if (!nasm_stricmp(q, "bss")) {
@ -345,24 +334,24 @@ static int32_t coff_section_names(char *name, int pass, int *bits)
flags = INFO_FLAGS;
else {
flags = DATA_FLAGS; /* gotta do something */
error(ERR_NONFATAL, "standard COFF does not support"
nasm_error(ERR_NONFATAL, "standard COFF does not support"
" informational sections");
}
} else if (!nasm_strnicmp(q, "align=", 6)) {
if (!(win32 | win64))
error(ERR_NONFATAL, "standard COFF does not support"
nasm_error(ERR_NONFATAL, "standard COFF does not support"
" section alignment specification");
else {
if (q[6 + strspn(q + 6, "0123456789")])
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"argument to `align' is not numeric");
else {
unsigned int align = atoi(q + 6);
if (!align || ((align - 1) & align))
error(ERR_NONFATAL, "argument to `align' is not a"
nasm_error(ERR_NONFATAL, "argument to `align' is not a"
" power of two");
else if (align > 64)
error(ERR_NONFATAL, "Win32 cannot align sections"
nasm_error(ERR_NONFATAL, "Win32 cannot align sections"
" to better than 64-byte boundaries");
else {
align_and = ~0x00F00000L;
@ -404,7 +393,7 @@ static int32_t coff_section_names(char *name, int pass, int *bits)
sects[i]->flags |= align_or;
} else if (pass == 1) {
if (flags)
error(ERR_WARNING, "section attributes ignored on"
nasm_error(ERR_WARNING, "section attributes ignored on"
" redeclaration of section `%s'", name);
}
@ -418,12 +407,12 @@ static void coff_deflabel(char *name, int32_t segment, int64_t offset,
struct Symbol *sym;
if (special)
error(ERR_NONFATAL, "COFF format does not support any"
nasm_error(ERR_NONFATAL, "COFF format does not support any"
" special symbol types");
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
if (strcmp(name,WRT_IMAGEBASE))
error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
return;
}
@ -521,7 +510,7 @@ static void coff_out(int32_t segto, const void *data,
if (wrt != NO_SEG && !win64) {
wrt = NO_SEG; /* continue to do _something_ */
error(ERR_NONFATAL, "WRT not supported by COFF output formats");
nasm_error(ERR_NONFATAL, "WRT not supported by COFF output formats");
}
/*
@ -529,7 +518,7 @@ static void coff_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -543,7 +532,7 @@ static void coff_out(int32_t segto, const void *data,
if (!s) {
int tempint; /* ignored */
if (segto != coff_section_names(".text", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in COFF driver");
nasm_error(ERR_PANIC, "strange segment conditions in COFF driver");
else
s = sects[nsects - 1];
}
@ -554,7 +543,7 @@ static void coff_out(int32_t segto, const void *data,
wrt = imagebase_sect;
if (!s->data && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in"
nasm_error(ERR_WARNING, "attempt to initialize memory in"
" BSS section `%s': ignored", s->name);
s->len += realsize(type, size);
return;
@ -562,28 +551,28 @@ static void coff_out(int32_t segto, const void *data,
if (type == OUT_RESERVE) {
if (s->data) {
error(ERR_WARNING, "uninitialised space declared in"
nasm_error(ERR_WARNING, "uninitialised space declared in"
" non-BSS section `%s': zeroing", s->name);
coff_sect_write(s, NULL, size);
} else
s->len += size;
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
coff_sect_write(s, data, size);
} else if (type == OUT_ADDRESS) {
if (!(win64)) {
if (size != 4 && (segment != NO_SEG || wrt != NO_SEG))
error(ERR_NONFATAL, "COFF format does not support non-32-bit"
nasm_error(ERR_NONFATAL, "COFF format does not support non-32-bit"
" relocations");
else {
int32_t fix = 0;
if (segment != NO_SEG || wrt != NO_SEG) {
if (wrt != NO_SEG) {
error(ERR_NONFATAL, "COFF format does not support"
nasm_error(ERR_NONFATAL, "COFF format does not support"
" WRT types");
} else if (segment % 2) {
error(ERR_NONFATAL, "COFF format does not support"
nasm_error(ERR_NONFATAL, "COFF format does not support"
" segment base references");
} else
fix = coff_add_reloc(s, segment, IMAGE_REL_I386_DIR32);
@ -597,7 +586,7 @@ static void coff_out(int32_t segto, const void *data,
p = mydata;
if (size == 8) {
if (wrt == imagebase_sect) {
error(ERR_NONFATAL, "operand size mismatch: 'wrt "
nasm_error(ERR_NONFATAL, "operand size mismatch: 'wrt "
WRT_IMAGEBASE "' is a 32-bit operand");
}
fix = coff_add_reloc(s, segment, IMAGE_REL_AMD64_ADDR64);
@ -612,18 +601,18 @@ static void coff_out(int32_t segto, const void *data,
}
}
} else if (type == OUT_REL2ADR) {
error(ERR_NONFATAL, "COFF format does not support 16-bit"
nasm_error(ERR_NONFATAL, "COFF format does not support 16-bit"
" relocations");
} else if (type == OUT_REL4ADR) {
if (segment == segto && !(win64)) /* Acceptable for RIP-relative */
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
else if (segment == NO_SEG && win32)
error(ERR_NONFATAL, "Win32 COFF does not correctly support"
nasm_error(ERR_NONFATAL, "Win32 COFF does not correctly support"
" relative references to absolute addresses");
else {
int32_t fix = 0;
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "COFF format does not support"
nasm_error(ERR_NONFATAL, "COFF format does not support"
" segment base references");
} else
fix = coff_add_reloc(s, segment,
@ -735,11 +724,11 @@ static int coff_directives(enum directives directive, char *value, int pass)
}
if (!*name) {
error(ERR_NONFATAL, "`export' directive requires export name");
nasm_error(ERR_NONFATAL, "`export' directive requires export name");
return 1;
}
if (*q) {
error(ERR_NONFATAL, "unrecognized export qualifier `%s'", q);
nasm_error(ERR_NONFATAL, "unrecognized export qualifier `%s'", q);
return 1;
}
AddExport(name);
@ -795,7 +784,7 @@ static int coff_directives(enum directives directive, char *value, int pass)
}
}
if (n == nsyms) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`safeseh' directive requires valid symbol");
}
}
@ -849,16 +838,16 @@ static void coff_write(void)
* Output the COFF header.
*/
if (win64)
fwriteint16_t(0x8664, coffp); /* MACHINE_x86-64 */
fwriteint16_t(0x8664, ofile); /* MACHINE_x86-64 */
else
fwriteint16_t(0x014C, coffp); /* MACHINE_i386 */
fwriteint16_t(nsects, coffp); /* number of sections */
fwriteint32_t(time(NULL), coffp); /* time stamp */
fwriteint32_t(sympos, coffp);
fwriteint32_t(nsyms + initsym, coffp);
fwriteint16_t(0, coffp); /* no optional header */
fwriteint16_t(0x014C, ofile); /* MACHINE_i386 */
fwriteint16_t(nsects, ofile); /* number of sections */
fwriteint32_t(time(NULL), ofile); /* time stamp */
fwriteint32_t(sympos, ofile);
fwriteint32_t(nsyms + initsym, ofile);
fwriteint16_t(0, ofile); /* no optional header */
/* Flags: 32-bit, no line numbers. Win32 doesn't even bother with them. */
fwriteint16_t((win32 | win64) ? 0 : 0x104, coffp);
fwriteint16_t((win32 | win64) ? 0 : 0x104, ofile);
/*
* Output the section headers.
@ -876,7 +865,7 @@ static void coff_write(void)
*/
for (i = 0; i < nsects; i++)
if (sects[i]->data) {
saa_fpwrite(sects[i]->data, coffp);
saa_fpwrite(sects[i]->data, ofile);
coff_write_relocs(sects[i]);
}
@ -884,8 +873,8 @@ static void coff_write(void)
* Output the symbol and string tables.
*/
coff_write_symbols();
fwriteint32_t(strslen + 4, coffp); /* length includes length count */
saa_fpwrite(strs, coffp);
fwriteint32_t(strslen + 4, ofile); /* length includes length count */
saa_fpwrite(strs, ofile);
}
static void coff_section_header(char *name, int32_t vsize,
@ -898,16 +887,16 @@ static void coff_section_header(char *name, int32_t vsize,
memset(padname, 0, 8);
strncpy(padname, name, 8);
fwrite(padname, 8, 1, coffp);
fwriteint32_t(0, coffp); /* Virtual size field - set to 0 or vsize */
fwriteint32_t(0L, coffp); /* RVA/offset - we ignore */
fwriteint32_t(datalen, coffp);
fwriteint32_t(datapos, coffp);
fwriteint32_t(relpos, coffp);
fwriteint32_t(0L, coffp); /* no line numbers - we don't do 'em */
fwriteint16_t(nrelocs, coffp);
fwriteint16_t(0, coffp); /* again, no line numbers */
fwriteint32_t(flags, coffp);
fwrite(padname, 8, 1, ofile);
fwriteint32_t(0, ofile); /* Virtual size field - set to 0 or vsize */
fwriteint32_t(0L, ofile); /* RVA/offset - we ignore */
fwriteint32_t(datalen, ofile);
fwriteint32_t(datapos, ofile);
fwriteint32_t(relpos, ofile);
fwriteint32_t(0L, ofile); /* no line numbers - we don't do 'em */
fwriteint16_t(nrelocs, ofile);
fwriteint16_t(0, ofile); /* again, no line numbers */
fwriteint32_t(flags, ofile);
}
static void coff_write_relocs(struct Section *s)
@ -915,12 +904,12 @@ static void coff_write_relocs(struct Section *s)
struct Reloc *r;
for (r = s->head; r; r = r->next) {
fwriteint32_t(r->address, coffp);
fwriteint32_t(r->address, ofile);
fwriteint32_t(r->symbol + (r->symbase == REAL_SYMBOLS ? initsym :
r->symbase == ABS_SYMBOL ? initsym - 1 :
r->symbase == SECT_SYMBOLS ? 2 : 0),
coffp);
fwriteint16_t(r->type, coffp);
ofile);
fwriteint16_t(r->type, ofile);
}
}
@ -932,16 +921,16 @@ static void coff_symbol(char *name, int32_t strpos, int32_t value,
if (name) {
memset(padname, 0, 8);
strncpy(padname, name, 8);
fwrite(padname, 8, 1, coffp);
fwrite(padname, 8, 1, ofile);
} else {
fwriteint32_t(0, coffp);
fwriteint32_t(strpos, coffp);
fwriteint32_t(0, ofile);
fwriteint32_t(strpos, ofile);
}
fwriteint32_t(value, coffp);
fwriteint16_t(section, coffp);
fwriteint16_t(type, coffp);
fputc(storageclass, coffp);
fputc(aux, coffp);
fwriteint32_t(value, ofile);
fwriteint16_t(section, ofile);
fwriteint16_t(type, ofile);
fputc(storageclass, ofile);
fputc(aux, ofile);
}
static void coff_write_symbols(void)
@ -955,7 +944,7 @@ static void coff_write_symbols(void)
coff_symbol(".file", 0L, 0L, -2, 0, 0x67, 1);
memset(filename, 0, 18);
strncpy(filename, coff_infile, 18);
fwrite(filename, 18, 1, coffp);
fwrite(filename, 18, 1, ofile);
/*
* The section records, with their auxiliaries.
@ -964,9 +953,9 @@ static void coff_write_symbols(void)
for (i = 0; i < (uint32_t) nsects; i++) {
coff_symbol(sects[i]->name, 0L, 0L, i + 1, 0, 3, 1);
fwriteint32_t(sects[i]->len, coffp);
fwriteint16_t(sects[i]->nrelocs, coffp);
fwrite(filename, 12, 1, coffp);
fwriteint32_t(sects[i]->len, ofile);
fwriteint16_t(sects[i]->nrelocs, ofile);
fwrite(filename, 12, 1, ofile);
}
/*
@ -991,16 +980,16 @@ static int32_t coff_segbase(int32_t segment)
return segment;
}
static void coff_std_filename(char *inname, char *outname, efunc error)
static void coff_std_filename(char *inname, char *outname)
{
strcpy(coff_infile, inname);
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
static void coff_win32_filename(char *inname, char *outname, efunc error)
static void coff_win32_filename(char *inname, char *outname)
{
strcpy(coff_infile, inname);
standard_extension(inname, outname, ".obj", error);
standard_extension(inname, outname, ".obj");
}
extern macros_t coff_stdmac[];

60
output/outdbg.c
View file

@ -56,19 +56,11 @@ struct Section {
char *name;
} *dbgsect;
FILE *dbgf;
efunc dbgef;
struct ofmt of_dbg;
static void dbg_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void dbg_init(void)
{
(void)eval;
dbgf = fp;
dbgef = errfunc;
dbgsect = NULL;
(void)ldef;
fprintf(fp, "NASM Output format debug dump\n");
fprintf(ofile, "NASM Output format debug dump\n");
}
static void dbg_cleanup(int debuginfo)
@ -94,7 +86,7 @@ static int32_t dbg_section_names(char *name, int pass, int *bits)
*bits = 16;
if (!name)
fprintf(dbgf, "section_name on init: returning %d\n",
fprintf(ofile, "section_name on init: returning %d\n",
seg = seg_alloc());
else {
int n = strcspn(name, " \t");
@ -112,7 +104,7 @@ static int32_t dbg_section_names(char *name, int pass, int *bits)
s->number = seg = seg_alloc();
s->next = dbgsect;
dbgsect = s;
fprintf(dbgf, "section_name %s (pass %d): returning %d\n",
fprintf(ofile, "section_name %s (pass %d): returning %d\n",
name, pass, seg);
}
}
@ -122,7 +114,7 @@ static int32_t dbg_section_names(char *name, int pass, int *bits)
static void dbg_deflabel(char *name, int32_t segment, int64_t offset,
int is_global, char *special)
{
fprintf(dbgf, "deflabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
fprintf(ofile, "deflabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
name, segment, offset,
is_global == 2 ? "common" : is_global ? "global" : "local",
is_global, special ? ": " : "", special);
@ -135,41 +127,41 @@ static void dbg_out(int32_t segto, const void *data,
int32_t ldata;
int id;
fprintf(dbgf, "out to %"PRIx32", len = %"PRIu64": ", segto, size);
fprintf(ofile, "out to %"PRIx32", len = %"PRIu64": ", segto, size);
switch (type) {
case OUT_RESERVE:
fprintf(dbgf, "reserved.\n");
fprintf(ofile, "reserved.\n");
break;
case OUT_RAWDATA:
fprintf(dbgf, "raw data = ");
fprintf(ofile, "raw data = ");
while (size--) {
id = *(uint8_t *)data;
data = (char *)data + 1;
fprintf(dbgf, "%02x ", id);
fprintf(ofile, "%02x ", id);
}
fprintf(dbgf, "\n");
fprintf(ofile, "\n");
break;
case OUT_ADDRESS:
ldata = *(int64_t *)data;
fprintf(dbgf, "addr %08"PRIx32" (seg %08"PRIx32", wrt %08"PRIx32")\n", ldata,
fprintf(ofile, "addr %08"PRIx32" (seg %08"PRIx32", wrt %08"PRIx32")\n", ldata,
segment, wrt);
break;
case OUT_REL2ADR:
fprintf(dbgf, "rel2adr %04"PRIx16" (seg %08"PRIx32")\n",
fprintf(ofile, "rel2adr %04"PRIx16" (seg %08"PRIx32")\n",
(uint16_t)*(int64_t *)data, segment);
break;
case OUT_REL4ADR:
fprintf(dbgf, "rel4adr %08"PRIx32" (seg %08"PRIx32")\n",
fprintf(ofile, "rel4adr %08"PRIx32" (seg %08"PRIx32")\n",
(uint32_t)*(int64_t *)data,
segment);
break;
case OUT_REL8ADR:
fprintf(dbgf, "rel8adr %016"PRIx64" (seg %08"PRIx32")\n",
fprintf(ofile, "rel8adr %016"PRIx64" (seg %08"PRIx32")\n",
(uint64_t)*(int64_t *)data, segment);
break;
default:
fprintf(dbgf, "unknown\n");
fprintf(ofile, "unknown\n");
break;
}
}
@ -181,14 +173,14 @@ static int32_t dbg_segbase(int32_t segment)
static int dbg_directive(enum directives directive, char *value, int pass)
{
fprintf(dbgf, "directive [%s] value [%s] (pass %d)\n",
fprintf(ofile, "directive [%s] value [%s] (pass %d)\n",
directives[directive], value, pass);
return 1;
}
static void dbg_filename(char *inname, char *outname, efunc error)
static void dbg_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".dbg", error);
standard_extension(inname, outname, ".dbg");
}
static int dbg_set_info(enum geninfo type, char **val)
@ -201,13 +193,9 @@ static int dbg_set_info(enum geninfo type, char **val)
char *types[] = {
"unknown", "label", "byte", "word", "dword", "float", "qword", "tbyte"
};
void dbgdbg_init(struct ofmt *of, void *id, FILE * fp, efunc error)
void dbgdbg_init(void)
{
(void)of;
(void)id;
(void)fp;
(void)error;
fprintf(fp, " With debug info\n");
fprintf(ofile, " With debug info\n");
}
static void dbgdbg_cleanup(void)
{
@ -215,13 +203,13 @@ static void dbgdbg_cleanup(void)
static void dbgdbg_linnum(const char *lnfname, int32_t lineno, int32_t segto)
{
fprintf(dbgf, "dbglinenum %s(%"PRId32") := %08"PRIx32"\n",
fprintf(ofile, "dbglinenum %s(%"PRId32") := %08"PRIx32"\n",
lnfname, lineno, segto);
}
static void dbgdbg_deflabel(char *name, int32_t segment,
int64_t offset, int is_global, char *special)
{
fprintf(dbgf, "dbglabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
fprintf(ofile, "dbglabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
name,
segment, offset,
is_global == 2 ? "common" : is_global ? "global" : "local",
@ -229,7 +217,7 @@ static void dbgdbg_deflabel(char *name, int32_t segment,
}
static void dbgdbg_define(const char *type, const char *params)
{
fprintf(dbgf, "dbgdirective [%s] value [%s]\n", type, params);
fprintf(ofile, "dbgdirective [%s] value [%s]\n", type, params);
}
static void dbgdbg_output(int output_type, void *param)
{
@ -238,7 +226,7 @@ static void dbgdbg_output(int output_type, void *param)
}
static void dbgdbg_typevalue(int32_t type)
{
fprintf(dbgf, "new type: %s(%"PRIX32")\n",
fprintf(ofile, "new type: %s(%"PRIX32")\n",
types[TYM_TYPE(type) >> 3], TYM_ELEMENTS(type));
}
static struct dfmt debug_debug_form = {

195
output/outelf32.c
View file

@ -49,6 +49,7 @@
#include "saa.h"
#include "raa.h"
#include "stdscan.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
#include "rbtree.h"
@ -113,10 +114,6 @@ static struct RAA *bsym;
static struct SAA *strs;
static uint32_t strslen;
static FILE *elffp;
static efunc error;
static evalfunc evaluate;
static struct Symbol *fwds;
static char elf_module[FILENAME_MAX];
@ -221,7 +218,7 @@ static void stabs32_generate(void);
static void stabs32_cleanup(void);
/* dwarf debugging routines */
static void dwarf32_init(struct ofmt *, void *, FILE *, efunc);
static void dwarf32_init(void);
static void dwarf32_linenum(const char *filename, int32_t linenumber, int32_t);
static void dwarf32_output(int, void *);
static void dwarf32_generate(void);
@ -238,12 +235,8 @@ static int32_t elf_gotpc_sect, elf_gotoff_sect;
static int32_t elf_got_sect, elf_plt_sect;
static int32_t elf_sym_sect, elf_tlsie_sect;
static void elf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void elf_init(void)
{
elffp = fp;
error = errfunc;
evaluate = eval;
(void)ldef; /* placate optimisers */
sects = NULL;
nsects = sectlen = 0;
syms = saa_init((int32_t)sizeof(struct Symbol));
@ -260,32 +253,31 @@ static void elf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
fwds = NULL;
elf_gotpc_sect = seg_alloc();
ldef("..gotpc", elf_gotpc_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..gotpc", elf_gotpc_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
elf_gotoff_sect = seg_alloc();
ldef("..gotoff", elf_gotoff_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..gotoff", elf_gotoff_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
elf_got_sect = seg_alloc();
ldef("..got", elf_got_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..got", elf_got_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
elf_plt_sect = seg_alloc();
ldef("..plt", elf_plt_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..plt", elf_plt_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
elf_sym_sect = seg_alloc();
ldef("..sym", elf_sym_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..sym", elf_sym_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
elf_tlsie_sect = seg_alloc();
ldef("..tlsie", elf_tlsie_sect + 1, 0L, NULL, false, false, &of_elf32,
error);
define_label("..tlsie", elf_tlsie_sect + 1, 0L, NULL, false, false, &of_elf32,
nasm_error);
def_seg = seg_alloc();
}
static void elf_init_hack(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void elf_init_hack(void)
{
of_elf32.current_dfmt = of_elf.current_dfmt; /* Sync debugging format */
elf_init(fp, errfunc, ldef, eval);
elf_init();
}
static void elf_cleanup(int debuginfo)
@ -396,7 +388,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if (align == 0)
align = 1;
if ((align - 1) & align) { /* means it's not a power of two */
error(ERR_NONFATAL, "section alignment %d is not"
nasm_error(ERR_NONFATAL, "section alignment %d is not"
" a power of two", align);
align = 1;
}
@ -426,7 +418,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
} else if (!nasm_stricmp(q, "nobits")) {
type = SHT_NOBITS;
} else if (pass == 1) {
error(ERR_WARNING, "Unknown section attribute '%s' ignored on"
nasm_error(ERR_WARNING, "Unknown section attribute '%s' ignored on"
" declaration of section `%s'", q, name);
}
}
@ -434,7 +426,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if (!strcmp(name, ".shstrtab") ||
!strcmp(name, ".symtab") ||
!strcmp(name, ".strtab")) {
error(ERR_NONFATAL, "attempt to redefine reserved section"
nasm_error(ERR_NONFATAL, "attempt to redefine reserved section"
"name `%s'", name);
return NO_SEG;
}
@ -460,7 +452,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if ((type && sects[i]->type != type)
|| (align && sects[i]->align != align)
|| (flags_and && ((sects[i]->flags & flags_and) != flags_or)))
error(ERR_WARNING, "section attributes ignored on"
nasm_error(ERR_WARNING, "section attributes ignored on"
" redeclaration of section `%s'", name);
}
@ -488,7 +480,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
strcmp(name, "..got") && strcmp(name, "..plt") &&
strcmp(name, "..sym") && strcmp(name, "..tlsie"))
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
return;
}
@ -511,10 +503,10 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = p;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
(*s)->size = reloc_value(e);
@ -549,7 +541,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
if (nsects == 0 && segment == def_seg) {
int tempint;
if (segment != elf_section_names(".text", 2, &tempint))
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"strange segment conditions in ELF driver");
sym->section = nsects;
} else {
@ -574,11 +566,11 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
bool err;
sym->symv.key = readnum(special, &err);
if (err)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" valid number", special);
else if ((sym->symv.key | (sym->symv.key - 1))
!= 2 * sym->symv.key - 1)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" power of two", special);
}
special_used = true;
@ -620,7 +612,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
else if (!nasm_strnicmp(special, "notype", n))
sym->type |= STT_NOTYPE;
else
error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
nasm_error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
n, special);
special += n;
@ -656,7 +648,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = special + n;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, error,
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, nasm_error,
NULL);
if (fwd) {
sym->nextfwd = fwds;
@ -664,7 +656,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
sym->name = nasm_strdup(name);
} else if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
sym->size = reloc_value(e);
@ -687,7 +679,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
nlocals++;
if (special && !special_used)
error(ERR_NONFATAL, "no special symbol features supported here");
nasm_error(ERR_NONFATAL, "no special symbol features supported here");
}
static void elf_add_reloc(struct Section *sect, int32_t segment, int type)
@ -762,7 +754,7 @@ static int32_t elf_add_gsym_reloc(struct Section *sect,
}
if (!s) {
if (exact && offset != 0)
error(ERR_NONFATAL, "unable to find a suitable global symbol"
nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
" for this reference");
else
elf_add_reloc(sect, segment, type);
@ -771,7 +763,7 @@ static int32_t elf_add_gsym_reloc(struct Section *sect,
srb = rb_search(s->gsyms, offset);
if (!srb || (exact && srb->key != offset)) {
error(ERR_NONFATAL, "unable to find a suitable global symbol"
nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
" for this reference");
return 0;
}
@ -805,7 +797,7 @@ static void elf_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -819,7 +811,7 @@ static void elf_out(int32_t segto, const void *data,
if (!s) {
int tempint; /* ignored */
if (segto != elf_section_names(".text", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in ELF driver");
nasm_error(ERR_PANIC, "strange segment conditions in ELF driver");
else {
s = sects[nsects - 1];
i = nsects - 1;
@ -836,7 +828,7 @@ static void elf_out(int32_t segto, const void *data,
/* end of debugging stuff */
if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in"
nasm_error(ERR_WARNING, "attempt to initialize memory in"
" BSS section `%s': ignored", s->name);
s->len += realsize(type, size);
return;
@ -844,21 +836,21 @@ static void elf_out(int32_t segto, const void *data,
if (type == OUT_RESERVE) {
if (s->type == SHT_PROGBITS) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" non-BSS section `%s': zeroing", s->name);
elf_sect_write(s, NULL, size);
} else
s->len += size;
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
elf_sect_write(s, data, size);
} else if (type == OUT_ADDRESS) {
bool gnu16 = false;
addr = *(int64_t *)data;
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
nasm_error(ERR_NONFATAL, "ELF format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
@ -894,10 +886,10 @@ static void elf_out(int32_t segto, const void *data,
R_386_32, false);
}
} else if (wrt == elf_plt_sect + 1) {
error(ERR_NONFATAL, "ELF format cannot produce non-PC-"
nasm_error(ERR_NONFATAL, "ELF format cannot produce non-PC-"
"relative PLT references");
} else {
error(ERR_NONFATAL, "ELF format does not support this"
nasm_error(ERR_NONFATAL, "ELF format does not support this"
" use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
}
@ -905,12 +897,12 @@ static void elf_out(int32_t segto, const void *data,
}
p = mydata;
if (gnu16) {
error(ERR_WARNING | ERR_WARN_GNUELF,
nasm_error(ERR_WARNING | ERR_WARN_GNUELF,
"16-bit relocations in ELF is a GNU extension");
WRITESHORT(p, addr);
} else {
if (size != 4 && segment != NO_SEG) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Unsupported non-32-bit ELF relocation");
}
WRITELONG(p, addr);
@ -918,17 +910,17 @@ static void elf_out(int32_t segto, const void *data,
elf_sect_write(s, mydata, size);
} else if (type == OUT_REL2ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL2ADR");
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
nasm_error(ERR_NONFATAL, "ELF format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
error(ERR_WARNING | ERR_WARN_GNUELF,
nasm_error(ERR_WARNING | ERR_WARN_GNUELF,
"16-bit relocations in ELF is a GNU extension");
elf_add_reloc(s, segment, R_386_PC16);
} else {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Unsupported non-32-bit ELF relocation");
}
}
@ -937,9 +929,9 @@ static void elf_out(int32_t segto, const void *data,
elf_sect_write(s, mydata, 2L);
} else if (type == OUT_REL4ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
nasm_error(ERR_NONFATAL, "ELF format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
@ -949,10 +941,10 @@ static void elf_out(int32_t segto, const void *data,
} else if (wrt == elf_gotpc_sect + 1 ||
wrt == elf_gotoff_sect + 1 ||
wrt == elf_got_sect + 1) {
error(ERR_NONFATAL, "ELF format cannot produce PC-"
nasm_error(ERR_NONFATAL, "ELF format cannot produce PC-"
"relative GOT references");
} else {
error(ERR_NONFATAL, "ELF format does not support this"
nasm_error(ERR_NONFATAL, "ELF format does not support this"
" use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
}
@ -1019,28 +1011,28 @@ static void elf_write(void)
/*
* Output the ELF header.
*/
fwrite("\177ELF\1\1\1", 7, 1, elffp);
fputc(elf_osabi, elffp);
fputc(elf_abiver, elffp);
fwritezero(7, elffp);
fwriteint16_t(1, elffp); /* ET_REL relocatable file */
fwriteint16_t(3, elffp); /* EM_386 processor ID */
fwriteint32_t(1L, elffp); /* EV_CURRENT file format version */
fwriteint32_t(0L, elffp); /* no entry point */
fwriteint32_t(0L, elffp); /* no program header table */
fwriteint32_t(0x40L, elffp); /* section headers straight after
fwrite("\177ELF\1\1\1", 7, 1, ofile);
fputc(elf_osabi, ofile);
fputc(elf_abiver, ofile);
fwritezero(7, ofile);
fwriteint16_t(1, ofile); /* ET_REL relocatable file */
fwriteint16_t(3, ofile); /* EM_386 processor ID */
fwriteint32_t(1L, ofile); /* EV_CURRENT file format version */
fwriteint32_t(0L, ofile); /* no entry point */
fwriteint32_t(0L, ofile); /* no program header table */
fwriteint32_t(0x40L, ofile); /* section headers straight after
* ELF header plus alignment */
fwriteint32_t(0L, elffp); /* 386 defines no special flags */
fwriteint16_t(0x34, elffp); /* size of ELF header */
fwriteint16_t(0, elffp); /* no program header table, again */
fwriteint16_t(0, elffp); /* still no program header table */
fwriteint16_t(0x28, elffp); /* size of section header */
fwriteint16_t(nsections, elffp); /* number of sections */
fwriteint16_t(sec_shstrtab, elffp); /* string table section index for
fwriteint32_t(0L, ofile); /* 386 defines no special flags */
fwriteint16_t(0x34, ofile); /* size of ELF header */
fwriteint16_t(0, ofile); /* no program header table, again */
fwriteint16_t(0, ofile); /* still no program header table */
fwriteint16_t(0x28, ofile); /* size of section header */
fwriteint16_t(nsections, ofile); /* number of sections */
fwriteint16_t(sec_shstrtab, ofile); /* string table section index for
* section header table */
fwriteint32_t(0L, elffp); /* align to 0x40 bytes */
fwriteint32_t(0L, elffp);
fwriteint32_t(0L, elffp);
fwriteint32_t(0L, ofile); /* align to 0x40 bytes */
fwriteint32_t(0L, ofile);
fwriteint32_t(0L, ofile);
/*
* Build the symbol table and relocation tables.
@ -1167,7 +1159,7 @@ static void elf_write(void)
loclen, 0, 0, 1, 0);
p += strlen(p) + 1;
}
fwritezero(align, elffp);
fwritezero(align, ofile);
/*
* Now output the sections.
@ -1350,18 +1342,18 @@ static void elf_section_header(int name, int type, int flags,
elf_sects[elf_nsect].is_saa = is_saa;
elf_nsect++;
fwriteint32_t((int32_t)name, elffp);
fwriteint32_t((int32_t)type, elffp);
fwriteint32_t((int32_t)flags, elffp);
fwriteint32_t(0L, elffp); /* no address, ever, in object files */
fwriteint32_t(type == 0 ? 0L : elf_foffs, elffp);
fwriteint32_t(datalen, elffp);
fwriteint32_t((int32_t)name, ofile);
fwriteint32_t((int32_t)type, ofile);
fwriteint32_t((int32_t)flags, ofile);
fwriteint32_t(0L, ofile); /* no address, ever, in object files */
fwriteint32_t(type == 0 ? 0L : elf_foffs, ofile);
fwriteint32_t(datalen, ofile);
if (data)
elf_foffs += (datalen + SEG_ALIGN_1) & ~SEG_ALIGN_1;
fwriteint32_t((int32_t)link, elffp);
fwriteint32_t((int32_t)info, elffp);
fwriteint32_t((int32_t)align, elffp);
fwriteint32_t((int32_t)eltsize, elffp);
fwriteint32_t((int32_t)link, ofile);
fwriteint32_t((int32_t)info, ofile);
fwriteint32_t((int32_t)align, ofile);
fwriteint32_t((int32_t)eltsize, ofile);
}
static void elf_write_sections(void)
@ -1373,10 +1365,10 @@ static void elf_write_sections(void)
int32_t reallen = (len + SEG_ALIGN_1) & ~SEG_ALIGN_1;
int32_t align = reallen - len;
if (elf_sects[i].is_saa)
saa_fpwrite(elf_sects[i].data, elffp);
saa_fpwrite(elf_sects[i].data, ofile);
else
fwrite(elf_sects[i].data, len, 1, elffp);
fwritezero(align, elffp);
fwrite(elf_sects[i].data, len, 1, ofile);
fwritezero(align, ofile);
}
}
@ -1405,11 +1397,11 @@ static int elf_directive(enum directives directive, char *value, int pass)
n = readnum(value, &err);
if (err) {
error(ERR_NONFATAL, "`osabi' directive requires a parameter");
nasm_error(ERR_NONFATAL, "`osabi' directive requires a parameter");
return 1;
}
if (n < 0 || n > 255) {
error(ERR_NONFATAL, "valid osabi numbers are 0 to 255");
nasm_error(ERR_NONFATAL, "valid osabi numbers are 0 to 255");
return 1;
}
elf_osabi = n;
@ -1420,7 +1412,7 @@ static int elf_directive(enum directives directive, char *value, int pass)
n = readnum(p+1, &err);
if (err || n < 0 || n > 255) {
error(ERR_NONFATAL, "invalid ABI version number (valid: 0 to 255)");
nasm_error(ERR_NONFATAL, "invalid ABI version number (valid: 0 to 255)");
return 1;
}
@ -1432,10 +1424,10 @@ static int elf_directive(enum directives directive, char *value, int pass)
}
}
static void elf_filename(char *inname, char *outname, efunc error)
static void elf_filename(char *inname, char *outname)
{
strcpy(elf_module, inname);
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t elf_stdmac[];
@ -1807,13 +1799,8 @@ static void stabs32_cleanup(void)
/* dwarf routines */
static void dwarf32_init(struct ofmt *of, void *id, FILE * fp, efunc error)
static void dwarf32_init(void)
{
(void)of;
(void)id;
(void)fp;
(void)error;
ndebugs = 3; /* 3 debug symbols */
}

196
output/outelf64.c
View file

@ -49,6 +49,7 @@
#include "saa.h"
#include "raa.h"
#include "stdscan.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
#include "rbtree.h"
@ -114,10 +115,6 @@ static struct RAA *bsym;
static struct SAA *strs;
static uint32_t strslen;
static FILE *elffp;
static efunc error;
static evalfunc evaluate;
static struct Symbol *fwds;
static char elf_module[FILENAME_MAX];
@ -229,7 +226,7 @@ static void stabs64_generate(void);
static void stabs64_cleanup(void);
/* dwarf debugging routines */
static void dwarf64_init(struct ofmt *, void *, FILE *, efunc);
static void dwarf64_init(void);
static void dwarf64_linenum(const char *filename, int32_t linenumber, int32_t);
static void dwarf64_output(int, void *);
static void dwarf64_generate(void);
@ -247,13 +244,9 @@ static int32_t elf_got_sect, elf_plt_sect;
static int32_t elf_sym_sect;
static int32_t elf_gottpoff_sect;
static void elf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void elf_init(void)
{
maxbits = 64;
elffp = fp;
error = errfunc;
evaluate = eval;
(void)ldef; /* placate optimisers */
sects = NULL;
nsects = sectlen = 0;
syms = saa_init((int32_t)sizeof(struct Symbol));
@ -270,23 +263,23 @@ static void elf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
fwds = NULL;
elf_gotpc_sect = seg_alloc();
ldef("..gotpc", elf_gotpc_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..gotpc", elf_gotpc_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
elf_gotoff_sect = seg_alloc();
ldef("..gotoff", elf_gotoff_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..gotoff", elf_gotoff_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
elf_got_sect = seg_alloc();
ldef("..got", elf_got_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..got", elf_got_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
elf_plt_sect = seg_alloc();
ldef("..plt", elf_plt_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..plt", elf_plt_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
elf_sym_sect = seg_alloc();
ldef("..sym", elf_sym_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..sym", elf_sym_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
elf_gottpoff_sect = seg_alloc();
ldef("..gottpoff", elf_gottpoff_sect + 1, 0L, NULL, false, false, &of_elf64,
error);
define_label("..gottpoff", elf_gottpoff_sect + 1, 0L, NULL, false, false, &of_elf64,
nasm_error);
def_seg = seg_alloc();
@ -399,7 +392,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if (align == 0)
align = 1;
if ((align - 1) & align) { /* means it's not a power of two */
error(ERR_NONFATAL, "section alignment %d is not"
nasm_error(ERR_NONFATAL, "section alignment %d is not"
" a power of two", align);
align = 1;
}
@ -429,7 +422,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
} else if (!nasm_stricmp(q, "nobits")) {
type = SHT_NOBITS;
} else if (pass == 1) {
error(ERR_WARNING, "Unknown section attribute '%s' ignored on"
nasm_error(ERR_WARNING, "Unknown section attribute '%s' ignored on"
" declaration of section `%s'", q, name);
}
}
@ -437,7 +430,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if (!strcmp(name, ".shstrtab") ||
!strcmp(name, ".symtab") ||
!strcmp(name, ".strtab")) {
error(ERR_NONFATAL, "attempt to redefine reserved section"
nasm_error(ERR_NONFATAL, "attempt to redefine reserved section"
"name `%s'", name);
return NO_SEG;
}
@ -463,7 +456,7 @@ static int32_t elf_section_names(char *name, int pass, int *bits)
if ((type && sects[i]->type != type)
|| (align && sects[i]->align != align)
|| (flags_and && ((sects[i]->flags & flags_and) != flags_or)))
error(ERR_WARNING, "incompatible section attributes ignored on"
nasm_error(ERR_WARNING, "incompatible section attributes ignored on"
" redeclaration of section `%s'", name);
}
@ -491,7 +484,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
if (strcmp(name, "..gotpc") && strcmp(name, "..gotoff") &&
strcmp(name, "..got") && strcmp(name, "..plt") &&
strcmp(name, "..sym") && strcmp(name, "..gottpoff"))
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
return;
}
@ -514,10 +507,10 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = p;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
(*s)->size = reloc_value(e);
@ -552,7 +545,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
if (nsects == 0 && segment == def_seg) {
int tempint;
if (segment != elf_section_names(".text", 2, &tempint))
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"strange segment conditions in ELF driver");
sym->section = nsects;
} else {
@ -577,11 +570,11 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
bool err;
sym->symv.key = readnum(special, &err);
if (err)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" valid number", special);
else if ((sym->symv.key | (sym->symv.key - 1))
!= 2 * sym->symv.key - 1)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" power of two", special);
}
special_used = true;
@ -623,7 +616,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
else if (!nasm_strnicmp(special, "notype", n))
sym->type |= STT_NOTYPE;
else
error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
nasm_error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
n, special);
special += n;
@ -659,7 +652,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
stdscan_reset();
stdscan_bufptr = special + n;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, error,
e = evaluate(stdscan, NULL, &tokval, &fwd, 0, nasm_error,
NULL);
if (fwd) {
sym->nextfwd = fwds;
@ -667,7 +660,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
sym->name = nasm_strdup(name);
} else if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as symbol size");
else
sym->size = reloc_value(e);
@ -690,7 +683,7 @@ static void elf_deflabel(char *name, int32_t segment, int64_t offset,
nlocals++;
if (special && !special_used)
error(ERR_NONFATAL, "no special symbol features supported here");
nasm_error(ERR_NONFATAL, "no special symbol features supported here");
}
static void elf_add_reloc(struct Section *sect, int32_t segment,
@ -767,7 +760,7 @@ static void elf_add_gsym_reloc(struct Section *sect,
if (!s) {
if (exact && offset)
error(ERR_NONFATAL, "invalid access to an external symbol");
nasm_error(ERR_NONFATAL, "invalid access to an external symbol");
else
elf_add_reloc(sect, segment, offset - pcrel, type);
return;
@ -775,7 +768,7 @@ static void elf_add_gsym_reloc(struct Section *sect,
srb = rb_search(s->gsyms, offset);
if (!srb || (exact && srb->key != offset)) {
error(ERR_NONFATAL, "unable to find a suitable global symbol"
nasm_error(ERR_NONFATAL, "unable to find a suitable global symbol"
" for this reference");
return;
}
@ -818,7 +811,7 @@ static void elf_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -832,7 +825,7 @@ static void elf_out(int32_t segto, const void *data,
if (!s) {
int tempint; /* ignored */
if (segto != elf_section_names(".text", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in ELF driver");
nasm_error(ERR_PANIC, "strange segment conditions in ELF driver");
else {
s = sects[nsects - 1];
i = nsects - 1;
@ -849,7 +842,7 @@ static void elf_out(int32_t segto, const void *data,
/* end of debugging stuff */
if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in"
nasm_error(ERR_WARNING, "attempt to initialize memory in"
" BSS section `%s': ignored", s->name);
s->len += realsize(type, size);
return;
@ -857,21 +850,21 @@ static void elf_out(int32_t segto, const void *data,
if (type == OUT_RESERVE) {
if (s->type == SHT_PROGBITS) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" non-BSS section `%s': zeroing", s->name);
elf_sect_write(s, NULL, size);
} else
s->len += size;
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
elf_sect_write(s, data, size);
} else if (type == OUT_ADDRESS) {
addr = *(int64_t *)data;
if (segment == NO_SEG) {
/* Do nothing */
} else if (segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
nasm_error(ERR_NONFATAL, "ELF format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
@ -889,7 +882,7 @@ static void elf_out(int32_t segto, const void *data,
elf_add_reloc(s, segment, addr, R_X86_64_64);
break;
default:
error(ERR_PANIC, "internal error elf64-hpa-871");
nasm_error(ERR_PANIC, "internal error elf64-hpa-871");
break;
}
addr = 0;
@ -904,7 +897,7 @@ static void elf_out(int32_t segto, const void *data,
addr = 0;
} else if (wrt == elf_gotoff_sect + 1) {
if (size != 8) {
error(ERR_NONFATAL, "ELF64 requires ..gotoff "
nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff "
"references to be qword");
} else {
elf_add_reloc(s, segment, addr, R_X86_64_GOTOFF64);
@ -923,7 +916,7 @@ static void elf_out(int32_t segto, const void *data,
addr = 0;
break;
default:
error(ERR_NONFATAL, "invalid ..got reference");
nasm_error(ERR_NONFATAL, "invalid ..got reference");
break;
}
} else if (wrt == elf_sym_sect + 1) {
@ -949,14 +942,14 @@ static void elf_out(int32_t segto, const void *data,
addr = 0;
break;
default:
error(ERR_PANIC, "internal error elf64-hpa-903");
nasm_error(ERR_PANIC, "internal error elf64-hpa-903");
break;
}
} else if (wrt == elf_plt_sect + 1) {
error(ERR_NONFATAL, "ELF format cannot produce non-PC-"
nasm_error(ERR_NONFATAL, "ELF format cannot produce non-PC-"
"relative PLT references");
} else {
error(ERR_NONFATAL, "ELF format does not support this"
nasm_error(ERR_NONFATAL, "ELF format does not support this"
" use of WRT");
}
}
@ -964,18 +957,18 @@ static void elf_out(int32_t segto, const void *data,
} else if (type == OUT_REL2ADR) {
addr = *(int64_t *)data - size;
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL2ADR");
if (segment == NO_SEG) {
/* Do nothing */
} else if (segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
nasm_error(ERR_NONFATAL, "ELF format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
elf_add_reloc(s, segment, addr, R_X86_64_PC16);
addr = 0;
} else {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Unsupported non-32-bit ELF relocation [2]");
}
}
@ -983,11 +976,11 @@ static void elf_out(int32_t segto, const void *data,
} else if (type == OUT_REL4ADR) {
addr = *(int64_t *)data - size;
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
if (segment == NO_SEG) {
/* Do nothing */
} else if (segment % 2) {
error(ERR_NONFATAL, "ELF64 format does not support"
nasm_error(ERR_NONFATAL, "ELF64 format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
@ -1004,14 +997,14 @@ static void elf_out(int32_t segto, const void *data,
addr = 0;
} else if (wrt == elf_gotoff_sect + 1 ||
wrt == elf_got_sect + 1) {
error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
"qword absolute");
} else if (wrt == elf_gottpoff_sect + 1) {
elf_add_gsym_reloc(s, segment, addr+size, size,
R_X86_64_GOTTPOFF, true);
addr = 0;
} else {
error(ERR_NONFATAL, "ELF64 format does not support this"
nasm_error(ERR_NONFATAL, "ELF64 format does not support this"
" use of WRT");
}
}
@ -1019,11 +1012,11 @@ static void elf_out(int32_t segto, const void *data,
} else if (type == OUT_REL8ADR) {
addr = *(int64_t *)data - size;
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL8ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL8ADR");
if (segment == NO_SEG) {
/* Do nothing */
} else if (segment % 2) {
error(ERR_NONFATAL, "ELF64 format does not support"
nasm_error(ERR_NONFATAL, "ELF64 format does not support"
" segment base references");
} else {
if (wrt == NO_SEG) {
@ -1036,13 +1029,13 @@ static void elf_out(int32_t segto, const void *data,
addr = 0;
} else if (wrt == elf_gotoff_sect + 1 ||
wrt == elf_got_sect + 1) {
error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
nasm_error(ERR_NONFATAL, "ELF64 requires ..gotoff references to be "
"absolute");
} else if (wrt == elf_gottpoff_sect + 1) {
error(ERR_NONFATAL, "ELF64 requires ..gottpoff references to be "
nasm_error(ERR_NONFATAL, "ELF64 requires ..gottpoff references to be "
"dword");
} else {
error(ERR_NONFATAL, "ELF64 format does not support this"
nasm_error(ERR_NONFATAL, "ELF64 format does not support this"
" use of WRT");
}
}
@ -1112,24 +1105,24 @@ static void elf_write(void)
/*
* Output the ELF header.
*/
fwrite("\177ELF\2\1\1", 7, 1, elffp);
fputc(elf_osabi, elffp);
fputc(elf_abiver, elffp);
fwritezero(7, elffp);
fwriteint16_t(ET_REL, elffp); /* relocatable file */
fwriteint16_t(EM_X86_64, elffp); /* processor ID */
fwriteint32_t(1L, elffp); /* EV_CURRENT file format version */
fwriteint64_t(0L, elffp); /* no entry point */
fwriteint64_t(0L, elffp); /* no program header table */
fwriteint64_t(0x40L, elffp); /* section headers straight after
fwrite("\177ELF\2\1\1", 7, 1, ofile);
fputc(elf_osabi, ofile);
fputc(elf_abiver, ofile);
fwritezero(7, ofile);
fwriteint16_t(ET_REL, ofile); /* relocatable file */
fwriteint16_t(EM_X86_64, ofile); /* processor ID */
fwriteint32_t(1L, ofile); /* EV_CURRENT file format version */
fwriteint64_t(0L, ofile); /* no entry point */
fwriteint64_t(0L, ofile); /* no program header table */
fwriteint64_t(0x40L, ofile); /* section headers straight after
* ELF header plus alignment */
fwriteint32_t(0L, elffp); /* 386 defines no special flags */
fwriteint16_t(0x40, elffp); /* size of ELF header */
fwriteint16_t(0, elffp); /* no program header table, again */
fwriteint16_t(0, elffp); /* still no program header table */
fwriteint16_t(sizeof(Elf64_Shdr), elffp); /* size of section header */
fwriteint16_t(nsections, elffp); /* number of sections */
fwriteint16_t(sec_shstrtab, elffp); /* string table section index for
fwriteint32_t(0L, ofile); /* 386 defines no special flags */
fwriteint16_t(0x40, ofile); /* size of ELF header */
fwriteint16_t(0, ofile); /* no program header table, again */
fwriteint16_t(0, ofile); /* still no program header table */
fwriteint16_t(sizeof(Elf64_Shdr), ofile); /* size of section header */
fwriteint16_t(nsections, ofile); /* number of sections */
fwriteint16_t(sec_shstrtab, ofile); /* string table section index for
* section header table */
/*
@ -1256,7 +1249,7 @@ static void elf_write(void)
loclen, 0, 0, 1, 0);
p += strlen(p) + 1;
}
fwritezero(align, elffp);
fwritezero(align, ofile);
/*
* Now output the sections.
@ -1437,18 +1430,18 @@ static void elf_section_header(int name, int type, uint64_t flags,
elf_sects[elf_nsect].is_saa = is_saa;
elf_nsect++;
fwriteint32_t((int32_t)name, elffp);
fwriteint32_t((int32_t)type, elffp);
fwriteint64_t((int64_t)flags, elffp);
fwriteint64_t(0L, elffp); /* no address, ever, in object files */
fwriteint64_t(type == 0 ? 0L : elf_foffs, elffp);
fwriteint64_t(datalen, elffp);
fwriteint32_t((int32_t)name, ofile);
fwriteint32_t((int32_t)type, ofile);
fwriteint64_t((int64_t)flags, ofile);
fwriteint64_t(0L, ofile); /* no address, ever, in object files */
fwriteint64_t(type == 0 ? 0L : elf_foffs, ofile);
fwriteint64_t(datalen, ofile);
if (data)
elf_foffs += (datalen + SEG_ALIGN_1) & ~SEG_ALIGN_1;
fwriteint32_t((int32_t)link, elffp);
fwriteint32_t((int32_t)info, elffp);
fwriteint64_t((int64_t)align, elffp);
fwriteint64_t((int64_t)eltsize, elffp);
fwriteint32_t((int32_t)link, ofile);
fwriteint32_t((int32_t)info, ofile);
fwriteint64_t((int64_t)align, ofile);
fwriteint64_t((int64_t)eltsize, ofile);
}
static void elf_write_sections(void)
@ -1460,10 +1453,10 @@ static void elf_write_sections(void)
int32_t reallen = (len + SEG_ALIGN_1) & ~SEG_ALIGN_1;
int32_t align = reallen - len;
if (elf_sects[i].is_saa)
saa_fpwrite(elf_sects[i].data, elffp);
saa_fpwrite(elf_sects[i].data, ofile);
else
fwrite(elf_sects[i].data, len, 1, elffp);
fwritezero(align, elffp);
fwrite(elf_sects[i].data, len, 1, ofile);
fwritezero(align, ofile);
}
}
@ -1496,11 +1489,11 @@ static int elf_directive(enum directives directive, char *value, int pass)
n = readnum(value, &err);
if (err) {
error(ERR_NONFATAL, "`osabi' directive requires a parameter");
nasm_error(ERR_NONFATAL, "`osabi' directive requires a parameter");
return 1;
}
if (n < 0 || n > 255) {
error(ERR_NONFATAL, "valid osabi numbers are 0 to 255");
nasm_error(ERR_NONFATAL, "valid osabi numbers are 0 to 255");
return 1;
}
elf_osabi = n;
@ -1511,7 +1504,7 @@ static int elf_directive(enum directives directive, char *value, int pass)
n = readnum(p+1, &err);
if (err || n < 0 || n > 255) {
error(ERR_NONFATAL, "invalid ABI version number (valid: 0 to 255)");
nasm_error(ERR_NONFATAL, "invalid ABI version number (valid: 0 to 255)");
return 1;
}
@ -1523,10 +1516,10 @@ static int elf_directive(enum directives directive, char *value, int pass)
}
}
static void elf_filename(char *inname, char *outname, efunc error)
static void elf_filename(char *inname, char *outname)
{
strcpy(elf_module, inname);
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t elf_stdmac[];
@ -1883,13 +1876,8 @@ static void stabs64_cleanup(void)
nasm_free(stabstrbuf);
}
/* dwarf routines */
static void dwarf64_init(struct ofmt *of, void *id, FILE * fp, efunc error)
static void dwarf64_init(void)
{
(void)of;
(void)id;
(void)fp;
(void)error;
ndebugs = 3; /* 3 debug symbols */
}

55
output/outform.c
View file

@ -47,55 +47,46 @@
#define BUILD_DRIVERS_ARRAY
#include "output/outform.h"
static int ndrivers = 0;
struct ofmt *ofmt_find(char *name)
{ /* find driver */
int i;
for (i = 0; i < ndrivers; i++)
if (!strcmp(name, drivers[i]->shortname))
return drivers[i];
struct ofmt **ofp, *of;
for (ofp = drivers; (of = *ofp); ofp++) {
if (!nasm_stricmp(name, of->shortname))
return of;
}
return NULL;
}
struct dfmt *dfmt_find(struct ofmt *ofmt, char *name)
{ /* find driver */
struct dfmt **dfmt = ofmt->debug_formats;
while (*dfmt) {
if (!strcmp(name, (*dfmt)->shortname))
return (*dfmt);
dfmt++;
struct dfmt **dfp, *df;
for (dfp = ofmt->debug_formats; (df = *dfp); dfp++) {
if (!nasm_stricmp(name, df->shortname))
return df;
}
return NULL;
}
void ofmt_list(struct ofmt *deffmt, FILE * fp)
{
int i;
for (i = 0; i < ndrivers; i++)
struct ofmt **ofp, *of;
for (ofp = drivers; (of = *ofp); ofp++) {
fprintf(fp, " %c %-10s%s\n",
drivers[i] == deffmt ? '*' : ' ',
drivers[i]->shortname, drivers[i]->fullname);
}
void dfmt_list(struct ofmt *ofmt, FILE * fp)
{
struct dfmt **drivers = ofmt->debug_formats;
while (*drivers) {
fprintf(fp, " %c %-10s%s\n",
drivers[0] == ofmt->current_dfmt ? '*' : ' ',
drivers[0]->shortname, drivers[0]->fullname);
drivers++;
of == deffmt ? '*' : ' ',
of->shortname, of->fullname);
}
}
struct ofmt *ofmt_register(efunc error)
void dfmt_list(struct ofmt *ofmt, FILE *fp)
{
for (ndrivers = 0; drivers[ndrivers] != NULL; ndrivers++) ;
struct dfmt **dfp, *df;
if (ndrivers == 0) {
error(ERR_PANIC | ERR_NOFILE,
"No output drivers given at compile time");
for (dfp = ofmt->debug_formats; (df = *dfp); dfp++) {
fprintf(fp, " %c %-10s%s\n",
df == ofmt->current_dfmt ? '*' : ' ',
df->shortname, df->fullname);
}
return (&OF_DEFAULT);
}

12
output/outform.h
View file

@ -253,11 +253,6 @@
#define OF_DEFAULT of_bin
#endif
#ifdef BUILD_DRIVERS_ARRAY /* only if included from outform.c */
/* pull in the externs for the different formats, then make the *drivers
* array based on the above defines */
extern struct ofmt of_bin;
extern struct ofmt of_ith;
extern struct ofmt of_srec;
@ -278,7 +273,12 @@ extern struct ofmt of_macho;
extern struct ofmt of_macho64;
extern struct ofmt of_dbg;
struct ofmt *drivers[] = {
#ifdef BUILD_DRIVERS_ARRAY /* only if included from outform.c */
/* pull in the externs for the different formats, then make the *drivers
* array based on the above defines */
static struct ofmt *drivers[] = {
#ifdef OF_BIN
&of_bin,
&of_ith,

67
output/outieee.c
View file

@ -87,9 +87,6 @@
static char ieee_infile[FILENAME_MAX];
static int ieee_uppercase;
static efunc error;
static ldfunc deflabel;
static FILE *ofp;
static bool any_segs;
static int arrindex;
@ -207,12 +204,8 @@ static void ieee_unqualified_name(char *, char *);
/*
* pup init
*/
static void ieee_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void ieee_init(void)
{
(void)eval;
ofp = fp;
error = errfunc;
deflabel = ldef;
any_segs = false;
fpubhead = NULL;
fpubtail = &fpubhead;
@ -306,7 +299,7 @@ static void ieee_deflabel(char *name, int32_t segment,
int i;
if (special) {
error(ERR_NONFATAL, "unrecognised symbol type `%s'", special);
nasm_error(ERR_NONFATAL, "unrecognised symbol type `%s'", special);
}
/*
* First check for the double-period, signifying something
@ -414,7 +407,7 @@ static void ieee_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -426,7 +419,7 @@ static void ieee_out(int32_t segto, const void *data,
if (!any_segs) {
int tempint; /* ignored */
if (segto != ieee_segment("__NASMDEFSEG", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in IEEE driver");
nasm_error(ERR_PANIC, "strange segment conditions in IEEE driver");
}
/*
@ -436,7 +429,7 @@ static void ieee_out(int32_t segto, const void *data,
if (seg->index == segto)
break;
if (!seg)
error(ERR_PANIC, "code directed to nonexistent segment?");
nasm_error(ERR_PANIC, "code directed to nonexistent segment?");
if (type == OUT_RAWDATA) {
ucdata = data;
@ -445,7 +438,7 @@ static void ieee_out(int32_t segto, const void *data,
} else if (type == OUT_ADDRESS || type == OUT_REL2ADR ||
type == OUT_REL4ADR) {
if (segment == NO_SEG && type != OUT_ADDRESS)
error(ERR_NONFATAL, "relative call to absolute address not"
nasm_error(ERR_NONFATAL, "relative call to absolute address not"
" supported by IEEE format");
ldata = *(int64_t *)data;
if (type == OUT_REL2ADR)
@ -535,15 +528,15 @@ static void ieee_write_fixup(int32_t segment, int32_t wrt,
s.addend = 0;
s.id2 = eb->index[i];
} else
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"Source of WRT must be an offset");
}
} else
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unrecognised WRT value in ieee_write_fixup");
} else
error(ERR_NONFATAL, "target of WRT must be a section ");
nasm_error(ERR_NONFATAL, "target of WRT must be a section ");
}
s.size = size;
ieee_install_fixup(segto, &s);
@ -582,7 +575,7 @@ static void ieee_write_fixup(int32_t segment, int32_t wrt,
*/
if (eb) {
if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"Segment of a rel not supported in ieee_write_fixup");
} else {
/* If we want the segment */
@ -593,7 +586,7 @@ static void ieee_write_fixup(int32_t segment, int32_t wrt,
} else
/* If we get here the seg value doesn't make sense */
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unrecognised segment value in ieee_write_fixup");
}
@ -648,12 +641,12 @@ static void ieee_write_fixup(int32_t segment, int32_t wrt,
} else
/* If we get here the seg value doesn't make sense */
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unrecognised segment value in ieee_write_fixup");
}
}
if (size != 2 && s.ftype == FT_SEG)
error(ERR_NONFATAL, "IEEE format can only handle 2-byte"
nasm_error(ERR_NONFATAL, "IEEE format can only handle 2-byte"
" segment base references");
s.size = size;
ieee_install_fixup(segto, &s);
@ -731,7 +724,7 @@ static int32_t ieee_segment(char *name, int pass, int *bits)
ieee_idx++;
if (!strcmp(seg->name, name)) {
if (attrs > 0 && pass == 1)
error(ERR_WARNING, "segment attributes specified on"
nasm_error(ERR_WARNING, "segment attributes specified on"
" redeclaration of segment: ignoring");
if (seg->use32)
*bits = 32;
@ -787,7 +780,7 @@ static int32_t ieee_segment(char *name, int pass, int *bits)
seg->align = 1;
if (rn_error) {
seg->align = 1;
error(ERR_NONFATAL, "segment alignment should be"
nasm_error(ERR_NONFATAL, "segment alignment should be"
" numeric");
}
switch ((int)seg->align) {
@ -802,7 +795,7 @@ static int32_t ieee_segment(char *name, int pass, int *bits)
case 128:
break;
default:
error(ERR_NONFATAL, "invalid alignment value %d",
nasm_error(ERR_NONFATAL, "invalid alignment value %d",
seg->align);
seg->align = 1;
break;
@ -810,18 +803,18 @@ static int32_t ieee_segment(char *name, int pass, int *bits)
} else if (!nasm_strnicmp(p, "absolute=", 9)) {
seg->align = SEG_ABS + readnum(p + 9, &rn_error);
if (rn_error)
error(ERR_NONFATAL, "argument to `absolute' segment"
nasm_error(ERR_NONFATAL, "argument to `absolute' segment"
" attribute should be numeric");
}
}
ieee_seg_needs_update = seg;
if (seg->align >= SEG_ABS)
deflabel(name, NO_SEG, seg->align - SEG_ABS,
NULL, false, false, &of_ieee, error);
define_label(name, NO_SEG, seg->align - SEG_ABS,
NULL, false, false, &of_ieee, nasm_error);
else
deflabel(name, seg->index + 1, 0L,
NULL, false, false, &of_ieee, error);
define_label(name, seg->index + 1, 0L,
NULL, false, false, &of_ieee, nasm_error);
ieee_seg_needs_update = NULL;
if (seg->use32)
@ -877,10 +870,10 @@ static int32_t ieee_segbase(int32_t segment)
/*
* filename
*/
static void ieee_filename(char *inname, char *outname, efunc error)
static void ieee_filename(char *inname, char *outname)
{
strcpy(ieee_infile, inname);
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
static void ieee_write_file(int debuginfo)
@ -978,7 +971,7 @@ static void ieee_write_file(int debuginfo)
if (seg->index == ieee_entry_seg)
break;
if (!seg)
error(ERR_PANIC, "Start address records are incorrect");
nasm_error(ERR_PANIC, "Start address records are incorrect");
else
ieee_putascii("ASG,R%X,%lX,+.\n", seg->ieee_index,
ieee_entry_ofs);
@ -1160,7 +1153,7 @@ static void ieee_putascii(char *format, ...)
if ((uint8_t)buffer[i] > 31)
checksum += buffer[i];
va_end(ap);
fprintf(ofp, buffer);
fprintf(ofile, buffer);
}
/*
@ -1283,13 +1276,9 @@ static void ieee_unqualified_name(char *dest, char *source)
} else
strcpy(dest, source);
}
void dbgls_init(struct ofmt *of, void *id, FILE * fp, efunc error)
void dbgls_init(void)
{
int tempint;
(void)of;
(void)id;
(void)fp;
(void)error;
fnhead = NULL;
fntail = &fnhead;
@ -1345,7 +1334,7 @@ static void dbgls_linnum(const char *lnfname, int32_t lineno, int32_t segto)
if (!any_segs) {
int tempint; /* ignored */
if (segto != ieee_segment("__NASMDEFSEG", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in OBJ driver");
nasm_error(ERR_PANIC, "strange segment conditions in OBJ driver");
}
/*
@ -1355,7 +1344,7 @@ static void dbgls_linnum(const char *lnfname, int32_t lineno, int32_t segto)
if (seg->index == segto)
break;
if (!seg)
error(ERR_PANIC, "lineno directed to nonexistent segment?");
nasm_error(ERR_PANIC, "lineno directed to nonexistent segment?");
for (fn = fnhead; fn; fn = fn->next) {
if (!nasm_stricmp(lnfname, fn->name))

2
output/outlib.h
View file

@ -44,7 +44,7 @@ int null_directive(enum directives directive, char *value, int pass);
/* Do-nothing versions of all the debug routines */
struct ofmt;
void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error);
void null_debug_init(void);
void null_debug_linenum(const char *filename, int32_t linenumber,
int32_t segto);
void null_debug_deflabel(char *name, int32_t segment, int64_t offset,

134
output/outmacho32.c
View file

@ -51,6 +51,7 @@
#include "nasmlib.h"
#include "saa.h"
#include "raa.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
@ -207,9 +208,7 @@ static struct RAA *extsyms;
static struct SAA *strs;
static uint32_t strslen;
static FILE *machofp;
static efunc error;
static evalfunc evaluate;
extern struct ofmt of_macho;
@ -328,17 +327,10 @@ static uint8_t get_section_fileindex_by_index(const int32_t index)
return NO_SECT;
}
static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void macho_init(void)
{
char zero = 0;
machofp = fp;
error = errfunc;
evaluate = eval;
(void)ldef; /* placate optimisers */
sects = NULL;
sectstail = &sects;
@ -713,9 +705,9 @@ static int32_t macho_segbase(int32_t section)
return section;
}
static void macho_filename(char *inname, char *outname, efunc error)
static void macho_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t macho_stdmac[];
@ -869,13 +861,13 @@ static void macho_calculate_sizes (void)
static void macho_write_header (void)
{
fwriteint32_t(MH_MAGIC, machofp); /* magic */
fwriteint32_t(CPU_TYPE_I386, machofp); /* CPU type */
fwriteint32_t(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
fwriteint32_t(MH_OBJECT, machofp); /* Mach-O file type */
fwriteint32_t(head_ncmds, machofp); /* number of load commands */
fwriteint32_t(head_sizeofcmds, machofp); /* size of load commands */
fwriteint32_t(0, machofp); /* no flags */
fwriteint32_t(MH_MAGIC, ofile); /* magic */
fwriteint32_t(CPU_TYPE_I386, ofile); /* CPU type */
fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile); /* CPU subtype */
fwriteint32_t(MH_OBJECT, ofile); /* Mach-O file type */
fwriteint32_t(head_ncmds, ofile); /* number of load commands */
fwriteint32_t(head_sizeofcmds, ofile); /* size of load commands */
fwriteint32_t(0, ofile); /* no flags */
}
/* Write out the segment load command at offset. */
@ -886,56 +878,56 @@ static uint32_t macho_write_segment (uint32_t offset)
uint32_t s_reloff = 0;
struct section *s;
fwriteint32_t(LC_SEGMENT, machofp); /* cmd == LC_SEGMENT */
fwriteint32_t(LC_SEGMENT, ofile); /* cmd == LC_SEGMENT */
/* size of load command including section load commands */
fwriteint32_t(MACHO_SEGCMD_SIZE + seg_nsects *
MACHO_SECTCMD_SIZE, machofp);
MACHO_SECTCMD_SIZE, ofile);
/* in an MH_OBJECT file all sections are in one unnamed (name
** all zeros) segment */
fwritezero(16, machofp);
fwriteint32_t(0, machofp); /* in-memory offset */
fwriteint32_t(seg_vmsize, machofp); /* in-memory size */
fwriteint32_t(offset, machofp); /* in-file offset to data */
fwriteint32_t(seg_filesize, machofp); /* in-file size */
fwriteint32_t(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
fwriteint32_t(VM_PROT_DEFAULT, machofp); /* initial vm protection */
fwriteint32_t(seg_nsects, machofp); /* number of sections */
fwriteint32_t(0, machofp); /* no flags */
fwritezero(16, ofile);
fwriteint32_t(0, ofile); /* in-memory offset */
fwriteint32_t(seg_vmsize, ofile); /* in-memory size */
fwriteint32_t(offset, ofile); /* in-file offset to data */
fwriteint32_t(seg_filesize, ofile); /* in-file size */
fwriteint32_t(VM_PROT_DEFAULT, ofile); /* maximum vm protection */
fwriteint32_t(VM_PROT_DEFAULT, ofile); /* initial vm protection */
fwriteint32_t(seg_nsects, ofile); /* number of sections */
fwriteint32_t(0, ofile); /* no flags */
/* emit section headers */
for (s = sects; s != NULL; s = s->next) {
fwrite(s->sectname, sizeof(s->sectname), 1, machofp);
fwrite(s->segname, sizeof(s->segname), 1, machofp);
fwriteint32_t(s->addr, machofp);
fwriteint32_t(s->size, machofp);
fwrite(s->sectname, sizeof(s->sectname), 1, ofile);
fwrite(s->segname, sizeof(s->segname), 1, ofile);
fwriteint32_t(s->addr, ofile);
fwriteint32_t(s->size, ofile);
/* dummy data for zerofill sections or proper values */
if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
fwriteint32_t(offset, machofp);
fwriteint32_t(offset, ofile);
/* Write out section alignment, as a power of two.
e.g. 32-bit word alignment would be 2 (2^^2 = 4). */
if (s->align == -1)
s->align = DEFAULT_SECTION_ALIGNMENT;
fwriteint32_t(s->align, machofp);
fwriteint32_t(s->align, ofile);
/* To be compatible with cctools as we emit
a zero reloff if we have no relocations. */
fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
fwriteint32_t(s->nreloc, machofp);
fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
fwriteint32_t(s->nreloc, ofile);
offset += s->size;
s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
} else {
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
}
fwriteint32_t(s->flags, machofp); /* flags */
fwriteint32_t(0, machofp); /* reserved */
fwriteint32_t(0, machofp); /* reserved */
fwriteint32_t(s->flags, ofile); /* flags */
fwriteint32_t(0, ofile); /* reserved */
fwriteint32_t(0, ofile); /* reserved */
}
rel_padcnt = rel_base - offset;
@ -952,14 +944,14 @@ static void macho_write_relocs (struct reloc *r)
while (r) {
uint32_t word2;
fwriteint32_t(r->addr, machofp); /* reloc offset */
fwriteint32_t(r->addr, ofile); /* reloc offset */
word2 = r->snum;
word2 |= r->pcrel << 24;
word2 |= r->length << 25;
word2 |= r->ext << 27;
word2 |= r->type << 28;
fwriteint32_t(word2, machofp); /* reloc data */
fwriteint32_t(word2, ofile); /* reloc data */
r = r->next;
}
@ -1026,11 +1018,11 @@ static void macho_write_section (void)
}
/* dump the section data to file */
saa_fpwrite(s->data, machofp);
saa_fpwrite(s->data, ofile);
}
/* pad last section up to reloc entries on int32_t boundary */
fwritezero(rel_padcnt, machofp);
fwritezero(rel_padcnt, ofile);
/* emit relocation entries */
for (s = sects; s != NULL; s = s->next)
@ -1050,10 +1042,10 @@ static void macho_write_symtab (void)
for (sym = syms; sym != NULL; sym = sym->next) {
if ((sym->type & N_EXT) == 0) {
fwriteint32_t(sym->strx, machofp); /* string table entry number */
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile); /* string table entry number */
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
@ -1063,16 +1055,16 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
}
}
for (i = 0; i < nextdefsym; i++) {
sym = extdefsyms[i];
fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile);
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
@ -1082,15 +1074,15 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
}
for (i = 0; i < nundefsym; i++) {
sym = undefsyms[i];
fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile);
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
@ -1100,7 +1092,7 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
}
}
@ -1217,15 +1209,15 @@ static void macho_write (void)
if (nsyms > 0) {
/* write out symbol command */
fwriteint32_t(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
fwriteint32_t(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
fwriteint32_t(offset, machofp); /* symbol table offset */
fwriteint32_t(nsyms, machofp); /* number of symbol
fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
fwriteint32_t(offset, ofile); /* symbol table offset */
fwriteint32_t(nsyms, ofile); /* number of symbol
** table entries */
offset += nsyms * MACHO_NLIST_SIZE;
fwriteint32_t(offset, machofp); /* string table offset */
fwriteint32_t(strslen, machofp); /* string table size */
fwriteint32_t(offset, ofile); /* string table offset */
fwriteint32_t(strslen, ofile); /* string table size */
}
/* emit section data */
@ -1239,7 +1231,7 @@ static void macho_write (void)
/* we don't need to pad here since MACHO_NLIST_SIZE == 12 */
/* emit string table */
saa_fpwrite(strs, machofp);
saa_fpwrite(strs, ofile);
}
/* We do quite a bit here, starting with finalizing all of the data
for the object file, writing, and then freeing all of the data from

196
output/outmacho64.c
View file

@ -209,10 +209,6 @@ static struct RAA *extsyms;
static struct SAA *strs;
static uint32_t strslen;
static FILE *machofp;
static efunc error;
static evalfunc evaluate;
extern struct ofmt of_macho64;
/* Global file information. This should be cleaned up into either
@ -327,7 +323,7 @@ static uint8_t get_section_fileindex_by_index(const int32_t index)
return i;
if (i == MAX_SECT)
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"too many sections (>255) - clipped by fileindex");
return NO_SECT;
@ -355,17 +351,11 @@ static struct symbol *get_closest_section_symbol_by_offset(uint8_t fileindex, in
*/
static int32_t macho_gotpcrel_sect;
static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
static void macho_init(void)
{
char zero = 0;
maxbits = 64;
machofp = fp;
error = errfunc;
evaluate = eval;
(void)ldef; /* placate optimizers */
maxbits = 64;
sects = NULL;
sectstail = &sects;
@ -387,7 +377,7 @@ static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
/* add special symbol for ..gotpcrel */
macho_gotpcrel_sect = seg_alloc();
macho_gotpcrel_sect ++;
ldef("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false, &of_macho64, error);
define_label("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false, &of_macho64, nasm_error);
}
static void sect_write(struct section *sect,
@ -521,7 +511,7 @@ static void macho_output(int32_t secto, const void *data,
if (secto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in "
nasm_error(ERR_NONFATAL, "attempt to assemble code in "
"[ABSOLUTE] space");
return;
@ -530,19 +520,19 @@ static void macho_output(int32_t secto, const void *data,
s = get_section_by_index(secto);
if (s == NULL) {
error(ERR_WARNING, "attempt to assemble code in"
nasm_error(ERR_WARNING, "attempt to assemble code in"
" section %d: defaulting to `.text'", secto);
s = get_section_by_name("__TEXT", "__text");
/* should never happen */
if (s == NULL)
error(ERR_PANIC, "text section not found");
nasm_error(ERR_PANIC, "text section not found");
}
sbss = get_section_by_name("__DATA", "__bss");
if (s == sbss && type != OUT_RESERVE) {
error(ERR_WARNING, "attempt to initialize memory in the"
nasm_error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
s->size += realsize(type, size);
return;
@ -551,7 +541,7 @@ static void macho_output(int32_t secto, const void *data,
switch (type) {
case OUT_RESERVE:
if (s != sbss) {
error(ERR_WARNING, "uninitialized space declared in"
nasm_error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
get_section_name_by_index(secto));
@ -563,7 +553,7 @@ static void macho_output(int32_t secto, const void *data,
case OUT_RAWDATA:
if (section != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
sect_write(s, data, size);
break;
@ -572,12 +562,12 @@ static void macho_output(int32_t secto, const void *data,
addr = *(int64_t *)data;
if (section != NO_SEG) {
if (section % 2) {
error(ERR_NONFATAL, "Mach-O format does not support"
nasm_error(ERR_NONFATAL, "Mach-O format does not support"
" section base references");
} else {
if (wrt == NO_SEG) {
if (size < 8) {
error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
nasm_error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
" 32-bit absolute addresses");
/*
Seemingly, Mach-O's X86_64_RELOC_SUBTRACTOR would require
@ -588,7 +578,7 @@ static void macho_output(int32_t secto, const void *data,
addr -= add_reloc(s, section, 0, size, addr); // X86_64_RELOC_UNSIGNED
}
} else {
error(ERR_NONFATAL, "Mach-O format does not support"
nasm_error(ERR_NONFATAL, "Mach-O format does not support"
" this use of WRT");
}
}
@ -604,15 +594,15 @@ static void macho_output(int32_t secto, const void *data,
WRITESHORT(p, *(int64_t *)data);
if (section == secto)
error(ERR_PANIC, "intra-section OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-section OUT_REL2ADR");
if (section == NO_SEG) {
/* Do nothing */
} else if (section % 2) {
error(ERR_NONFATAL, "Mach-O format does not support"
nasm_error(ERR_NONFATAL, "Mach-O format does not support"
" section base references");
} else {
error(ERR_NONFATAL, "Unsupported non-32-bit"
nasm_error(ERR_NONFATAL, "Unsupported non-32-bit"
" Macho-O relocation [2]");
}
@ -624,10 +614,10 @@ static void macho_output(int32_t secto, const void *data,
WRITELONG(p, *(int64_t *)data);
if (section == secto)
error(ERR_PANIC, "intra-section OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-section OUT_REL4ADR");
if (section != NO_SEG && section % 2) {
error(ERR_NONFATAL, "Mach-O format does not support"
nasm_error(ERR_NONFATAL, "Mach-O format does not support"
" section base references");
} else {
if (wrt == NO_SEG) {
@ -644,7 +634,7 @@ static void macho_output(int32_t secto, const void *data,
*mydata -= add_reloc(s, section, 3, 4, (int64_t)*mydata); // X86_64_GOT
}
} else {
error(ERR_NONFATAL, "Mach-O format does not support"
nasm_error(ERR_NONFATAL, "Mach-O format does not support"
" this use of WRT");
wrt = NO_SEG; /* we can at least _try_ to continue */
}
@ -654,7 +644,7 @@ static void macho_output(int32_t secto, const void *data,
break;
default:
error(ERR_PANIC, "unknown output type?");
nasm_error(ERR_PANIC, "unknown output type?");
break;
}
}
@ -720,14 +710,14 @@ static int32_t macho_section(char *name, int pass, int *bits)
newAlignment = exact_log2(value);
if (0 != *end) {
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unknown or missing alignment value \"%s\" "
"specified for section \"%s\"",
currentAttribute + 6,
name);
return NO_SEG;
} else if (0 > newAlignment) {
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"alignment of %d (for section \"%s\") is not "
"a power of two",
value,
@ -738,7 +728,7 @@ static int32_t macho_section(char *name, int pass, int *bits)
if ((-1 != originalIndex)
&& (s->align != newAlignment)
&& (s->align != -1)) {
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"section \"%s\" has already been specified "
"with alignment %d, conflicts with new "
"alignment of %d",
@ -752,7 +742,7 @@ static int32_t macho_section(char *name, int pass, int *bits)
} else if (!nasm_stricmp("data", currentAttribute)) {
/* Do nothing; 'data' is implicit */
} else {
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unknown section attribute %s for section %s",
currentAttribute,
name);
@ -765,7 +755,7 @@ static int32_t macho_section(char *name, int pass, int *bits)
}
}
error(ERR_PANIC, "invalid section name %s", name);
nasm_error(ERR_PANIC, "invalid section name %s", name);
return NO_SEG;
}
@ -775,13 +765,13 @@ static void macho_symdef(char *name, int32_t section, int64_t offset,
struct symbol *sym;
if (special) {
error(ERR_NONFATAL, "The Mach-O output format does "
nasm_error(ERR_NONFATAL, "The Mach-O output format does "
"not support any special symbol types");
return;
}
if (is_global == 3) {
error(ERR_NONFATAL, "The Mach-O format does not "
nasm_error(ERR_NONFATAL, "The Mach-O format does not "
"(yet) support forward reference fixups.");
return;
}
@ -793,7 +783,7 @@ static void macho_symdef(char *name, int32_t section, int64_t offset,
* _isn't_ a valid one, we should barf immediately.
*/
if (strcmp(name, "..gotpcrel"))
error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
return;
}
@ -847,7 +837,7 @@ static void macho_symdef(char *name, int32_t section, int64_t offset,
/* give an error on unfound section if it's not an
** external or common symbol (assemble_file() does a
** seg_alloc() on every call for them) */
error(ERR_PANIC, "in-file index for section %d not found",
nasm_error(ERR_PANIC, "in-file index for section %d not found",
section);
}
}
@ -860,9 +850,9 @@ static int32_t macho_segbase(int32_t section)
return section;
}
static void macho_filename(char *inname, char *outname, efunc error)
static void macho_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".o", error);
standard_extension(inname, outname, ".o");
}
extern macros_t macho_stdmac[];
@ -1018,14 +1008,14 @@ static void macho_calculate_sizes (void)
static void macho_write_header (void)
{
fwriteint32_t(MH_MAGIC_64, machofp); /* magic */
fwriteint32_t(CPU_TYPE_X86_64, machofp); /* CPU type */
fwriteint32_t(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
fwriteint32_t(MH_OBJECT, machofp); /* Mach-O file type */
fwriteint32_t(head_ncmds64, machofp); /* number of load commands */
fwriteint32_t(head_sizeofcmds64, machofp); /* size of load commands */
fwriteint32_t(0, machofp); /* no flags */
fwriteint32_t(0, machofp); /* reserved for future use */
fwriteint32_t(MH_MAGIC_64, ofile); /* magic */
fwriteint32_t(CPU_TYPE_X86_64, ofile); /* CPU type */
fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile); /* CPU subtype */
fwriteint32_t(MH_OBJECT, ofile); /* Mach-O file type */
fwriteint32_t(head_ncmds64, ofile); /* number of load commands */
fwriteint32_t(head_sizeofcmds64, ofile); /* size of load commands */
fwriteint32_t(0, ofile); /* no flags */
fwriteint32_t(0, ofile); /* reserved for future use */
}
/* Write out the segment load command at offset. */
@ -1036,51 +1026,51 @@ static uint32_t macho_write_segment (uint64_t offset)
uint32_t s_reloff = 0;
struct section *s;
fwriteint32_t(LC_SEGMENT_64, machofp); /* cmd == LC_SEGMENT_64 */
fwriteint32_t(LC_SEGMENT_64, ofile); /* cmd == LC_SEGMENT_64 */
/* size of load command including section load commands */
fwriteint32_t(MACHO_SEGCMD64_SIZE + seg_nsects64 *
MACHO_SECTCMD64_SIZE, machofp);
MACHO_SECTCMD64_SIZE, ofile);
/* in an MH_OBJECT file all sections are in one unnamed (name
** all zeros) segment */
fwritezero(16, machofp);
fwriteint64_t(0, machofp); /* in-memory offset */
fwriteint64_t(seg_vmsize64, machofp); /* in-memory size */
fwriteint64_t(offset, machofp); /* in-file offset to data */
fwriteint64_t(seg_filesize64, machofp); /* in-file size */
fwriteint32_t(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
fwriteint32_t(VM_PROT_DEFAULT, machofp); /* initial vm protection */
fwriteint32_t(seg_nsects64, machofp); /* number of sections */
fwriteint32_t(0, machofp); /* no flags */
fwritezero(16, ofile);
fwriteint64_t(0, ofile); /* in-memory offset */
fwriteint64_t(seg_vmsize64, ofile); /* in-memory size */
fwriteint64_t(offset, ofile); /* in-file offset to data */
fwriteint64_t(seg_filesize64, ofile); /* in-file size */
fwriteint32_t(VM_PROT_DEFAULT, ofile); /* maximum vm protection */
fwriteint32_t(VM_PROT_DEFAULT, ofile); /* initial vm protection */
fwriteint32_t(seg_nsects64, ofile); /* number of sections */
fwriteint32_t(0, ofile); /* no flags */
/* emit section headers */
for (s = sects; s != NULL; s = s->next) {
fwrite(s->sectname, sizeof(s->sectname), 1, machofp);
fwrite(s->segname, sizeof(s->segname), 1, machofp);
fwriteint64_t(s->addr, machofp);
fwriteint64_t(s->size, machofp);
fwrite(s->sectname, sizeof(s->sectname), 1, ofile);
fwrite(s->segname, sizeof(s->segname), 1, ofile);
fwriteint64_t(s->addr, ofile);
fwriteint64_t(s->size, ofile);
/* dummy data for zerofill sections or proper values */
if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
fwriteint32_t(offset, machofp);
fwriteint32_t(offset, ofile);
/* Write out section alignment, as a power of two.
e.g. 32-bit word alignment would be 2 (2^2 = 4). */
if (s->align == -1)
s->align = DEFAULT_SECTION_ALIGNMENT;
fwriteint32_t(s->align, machofp);
fwriteint32_t(s->align, ofile);
/* To be compatible with cctools as we emit
a zero reloff if we have no relocations. */
fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
fwriteint32_t(s->nreloc, machofp);
fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
fwriteint32_t(s->nreloc, ofile);
offset += s->size;
s_reloff += s->nreloc * MACHO_RELINFO64_SIZE;
} else {
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, machofp);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
fwriteint32_t(0, ofile);
}
if (s->nreloc) {
@ -1089,11 +1079,11 @@ static uint32_t macho_write_segment (uint64_t offset)
s->flags |= S_ATTR_EXT_RELOC;
}
fwriteint32_t(s->flags, machofp); /* flags */
fwriteint32_t(0, machofp); /* reserved */
fwriteint32_t(0, machofp); /* reserved */
fwriteint32_t(s->flags, ofile); /* flags */
fwriteint32_t(0, ofile); /* reserved */
fwriteint32_t(0, ofile); /* reserved */
fwriteint32_t(0, machofp); /* align */
fwriteint32_t(0, ofile); /* align */
}
rel_padcnt64 = rel_base - offset;
@ -1110,14 +1100,14 @@ static void macho_write_relocs (struct reloc *r)
while (r) {
uint32_t word2;
fwriteint32_t(r->addr, machofp); /* reloc offset */
fwriteint32_t(r->addr, ofile); /* reloc offset */
word2 = r->snum;
word2 |= r->pcrel << 24;
word2 |= r->length << 25;
word2 |= r->ext << 27;
word2 |= r->type << 28;
fwriteint32_t(word2, machofp); /* reloc data */
fwriteint32_t(word2, ofile); /* reloc data */
r = r->next;
}
}
@ -1197,11 +1187,11 @@ static void macho_write_section (void)
}
/* dump the section data to file */
saa_fpwrite(s->data, machofp);
saa_fpwrite(s->data, ofile);
}
/* pad last section up to reloc entries on int64_t boundary */
fwritezero(rel_padcnt64, machofp);
fwritezero(rel_padcnt64, ofile);
/* emit relocation entries */
for (s = sects; s != NULL; s = s->next)
@ -1221,10 +1211,10 @@ static void macho_write_symtab (void)
for (sym = syms; sym != NULL; sym = sym->next) {
if ((sym->type & N_EXT) == 0) {
fwriteint32_t(sym->strx, machofp); /* string table entry number */
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile); /* string table entry number */
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
@ -1234,16 +1224,16 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
fwriteint64_t(sym->value, ofile); /* value (i.e. offset) */
}
}
for (i = 0; i < nextdefsym; i++) {
sym = extdefsyms[i];
fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile);
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
@ -1253,15 +1243,15 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
fwriteint64_t(sym->value, ofile); /* value (i.e. offset) */
}
for (i = 0; i < nundefsym; i++) {
sym = undefsyms[i];
fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
fwriteint16_t(sym->desc, machofp); /* description */
fwriteint32_t(sym->strx, ofile);
fwrite(&sym->type, 1, 1, ofile); /* symbol type */
fwrite(&sym->sect, 1, 1, ofile); /* section */
fwriteint16_t(sym->desc, ofile); /* description */
// Fix up the symbol value now that we know the final section sizes.
if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
@ -1270,7 +1260,7 @@ static void macho_write_symtab (void)
sym->value += s->size;
}
fwriteint64_t(sym->value, machofp); // value (i.e. offset)
fwriteint64_t(sym->value, ofile); // value (i.e. offset)
}
}
@ -1382,19 +1372,19 @@ static void macho_write (void)
if (seg_nsects64 > 0)
offset = macho_write_segment (offset);
else
error(ERR_WARNING, "no sections?");
nasm_error(ERR_WARNING, "no sections?");
if (nsyms > 0) {
/* write out symbol command */
fwriteint32_t(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
fwriteint32_t(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
fwriteint32_t(offset, machofp); /* symbol table offset */
fwriteint32_t(nsyms, machofp); /* number of symbol
fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
fwriteint32_t(offset, ofile); /* symbol table offset */
fwriteint32_t(nsyms, ofile); /* number of symbol
** table entries */
offset += nsyms * MACHO_NLIST64_SIZE;
fwriteint32_t(offset, machofp); /* string table offset */
fwriteint32_t(strslen, machofp); /* string table size */
fwriteint32_t(offset, ofile); /* string table offset */
fwriteint32_t(strslen, ofile); /* string table size */
}
/* emit section data */
@ -1408,7 +1398,7 @@ static void macho_write (void)
/* we don't need to pad here since MACHO_NLIST64_SIZE == 16 */
/* emit string table */
saa_fpwrite(strs, machofp);
saa_fpwrite(strs, ofile);
}
/* We do quite a bit here, starting with finalizing all of the data
for the object file, writing, and then freeing all of the data from

128
output/outobj.c
View file

@ -47,6 +47,7 @@
#include "nasm.h"
#include "nasmlib.h"
#include "stdscan.h"
#include "eval.h"
#include "output/outform.h"
#include "output/outlib.h"
@ -497,10 +498,6 @@ static void ori_null(ObjRecord * orp)
static char obj_infile[FILENAME_MAX];
static efunc error;
static evalfunc evaluate;
static ldfunc deflabel;
static FILE *ofp;
static int32_t first_seg;
static bool any_segs;
static int passtwo;
@ -635,12 +632,8 @@ static int32_t obj_segment(char *, int, int *);
static void obj_write_file(int debuginfo);
static int obj_directive(enum directives, char *, int);
static void obj_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void obj_init(void)
{
ofp = fp;
error = errfunc;
evaluate = eval;
deflabel = ldef;
first_seg = seg_alloc();
any_segs = false;
fpubhead = NULL;
@ -802,7 +795,7 @@ static void obj_deflabel(char *name, int32_t segment,
obj_entry_ofs = offset;
return;
}
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
}
/*
@ -833,7 +826,7 @@ static void obj_deflabel(char *name, int32_t segment,
pub->segment = (segment == NO_SEG ? 0 : segment & ~SEG_ABS);
}
if (special)
error(ERR_NONFATAL, "OBJ supports no special symbol features"
nasm_error(ERR_NONFATAL, "OBJ supports no special symbol features"
" for this symbol type");
return;
}
@ -846,7 +839,7 @@ static void obj_deflabel(char *name, int32_t segment,
if (!any_segs && segment == first_seg) {
int tempint; /* ignored */
if (segment != obj_segment("__NASMDEFSEG", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in OBJ driver");
nasm_error(ERR_PANIC, "strange segment conditions in OBJ driver");
}
for (seg = seghead; seg && is_global; seg = seg->next)
@ -862,7 +855,7 @@ static void obj_deflabel(char *name, int32_t segment,
loc->offset = offset;
if (special)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"OBJ supports no special symbol features"
" for this symbol type");
return;
@ -929,7 +922,7 @@ static void obj_deflabel(char *name, int32_t segment,
obj_ext_set_defwrt(ext, p);
special += len;
if (*special && *special != ':')
error(ERR_NONFATAL, "`:' expected in special symbol"
nasm_error(ERR_NONFATAL, "`:' expected in special symbol"
" text for `%s'", ext->name);
else if (*special == ':')
special++;
@ -943,7 +936,7 @@ static void obj_deflabel(char *name, int32_t segment,
if (ext->commonsize)
ext->commonelem = 1;
else
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`%s': `far' keyword may only be applied"
" to common variables\n", ext->name);
special += 3;
@ -952,7 +945,7 @@ static void obj_deflabel(char *name, int32_t segment,
if (ext->commonsize)
ext->commonelem = 0;
else
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`%s': `far' keyword may only be applied"
" to common variables\n", ext->name);
special += 4;
@ -975,17 +968,17 @@ static void obj_deflabel(char *name, int32_t segment,
stdscan_reset();
stdscan_bufptr = special;
tokval.t_type = TOKEN_INVALID;
e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
e = evaluate(stdscan, NULL, &tokval, NULL, 1, nasm_error, NULL);
if (e) {
if (!is_simple(e))
error(ERR_NONFATAL, "cannot use relocatable"
nasm_error(ERR_NONFATAL, "cannot use relocatable"
" expression as common-variable element size");
else
ext->commonelem = reloc_value(e);
}
special = stdscan_bufptr;
} else {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"`%s': element-size specifications only"
" apply to common variables", ext->name);
while (*special && *special != ':')
@ -1017,7 +1010,7 @@ static void obj_deflabel(char *name, int32_t segment,
ext->index = ++externals;
if (special && !used_special)
error(ERR_NONFATAL, "OBJ supports no special symbol features"
nasm_error(ERR_NONFATAL, "OBJ supports no special symbol features"
" for this symbol type");
}
@ -1040,7 +1033,7 @@ static void obj_out(int32_t segto, const void *data,
*/
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
nasm_error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
" space");
return;
}
@ -1052,7 +1045,7 @@ static void obj_out(int32_t segto, const void *data,
if (!any_segs) {
int tempint; /* ignored */
if (segto != obj_segment("__NASMDEFSEG", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in OBJ driver");
nasm_error(ERR_PANIC, "strange segment conditions in OBJ driver");
}
/*
@ -1062,7 +1055,7 @@ static void obj_out(int32_t segto, const void *data,
if (seg->index == segto)
break;
if (!seg)
error(ERR_PANIC, "code directed to nonexistent segment?");
nasm_error(ERR_PANIC, "code directed to nonexistent segment?");
orp = seg->orp;
orp->parm[0] = seg->currentpos;
@ -1086,10 +1079,10 @@ static void obj_out(int32_t segto, const void *data,
int rsize;
if (segment == NO_SEG && type != OUT_ADDRESS)
error(ERR_NONFATAL, "relative call to absolute address not"
nasm_error(ERR_NONFATAL, "relative call to absolute address not"
" supported by OBJ format");
if (segment >= SEG_ABS)
error(ERR_NONFATAL, "far-absolute relocations not supported"
nasm_error(ERR_NONFATAL, "far-absolute relocations not supported"
" by OBJ format");
ldata = *(int64_t *)data;
if (type == OUT_REL2ADR) {
@ -1115,7 +1108,7 @@ static void obj_out(int32_t segto, const void *data,
*/
rsize = 2;
if (ldata & 0xFFFF)
error(ERR_NONFATAL, "OBJ format cannot handle complex"
nasm_error(ERR_NONFATAL, "OBJ format cannot handle complex"
" dword-size segment base references");
}
if (segment != NO_SEG)
@ -1145,7 +1138,7 @@ static void obj_write_fixup(ObjRecord * orp, int bytes,
ObjRecord *forp;
if (bytes == 1) {
error(ERR_NONFATAL, "`obj' output driver does not support"
nasm_error(ERR_NONFATAL, "`obj' output driver does not support"
" one-byte relocations");
return;
}
@ -1167,7 +1160,7 @@ static void obj_write_fixup(ObjRecord * orp, int bytes,
locat = FIX_16_SELECTOR;
seg--;
if (bytes != 2)
error(ERR_PANIC, "OBJ: 4-byte segment base fixup got"
nasm_error(ERR_PANIC, "OBJ: 4-byte segment base fixup got"
" through sanity check");
} else {
base = false;
@ -1213,7 +1206,7 @@ static void obj_write_fixup(ObjRecord * orp, int bytes,
if (eb)
method = 6, e = eb->exts[i], tidx = e->index;
else
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unrecognised segment value in obj_write_fixup");
}
}
@ -1237,7 +1230,7 @@ static void obj_write_fixup(ObjRecord * orp, int bytes,
else if (e->defwrt_type == DEFWRT_GROUP)
method |= 0x10, fidx = e->defwrt_ptr.grp->obj_index;
else {
error(ERR_NONFATAL, "default WRT specification for"
nasm_error(ERR_NONFATAL, "default WRT specification for"
" external `%s' unresolved", e->name);
method |= 0x50, fidx = -1; /* got to do _something_ */
}
@ -1272,7 +1265,7 @@ static void obj_write_fixup(ObjRecord * orp, int bytes,
if (eb)
method |= 0x20, fidx = eb->exts[i]->index;
else
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"unrecognised WRT value in obj_write_fixup");
}
}
@ -1341,7 +1334,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
obj_idx++;
if (!strcmp(seg->name, name)) {
if (attrs > 0 && pass == 1)
error(ERR_WARNING, "segment attributes specified on"
nasm_error(ERR_WARNING, "segment attributes specified on"
" redeclaration of segment: ignoring");
if (seg->use32)
*bits = 32;
@ -1421,7 +1414,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
if (!strcmp(grp->name, "FLAT"))
break;
if (!grp)
error(ERR_PANIC, "failure to define FLAT?!");
nasm_error(ERR_PANIC, "failure to define FLAT?!");
}
seg->grp = grp;
} else if (!nasm_strnicmp(p, "class=", 6))
@ -1432,7 +1425,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
seg->align = readnum(p + 6, &rn_error);
if (rn_error) {
seg->align = 1;
error(ERR_NONFATAL, "segment alignment should be"
nasm_error(ERR_NONFATAL, "segment alignment should be"
" numeric");
}
switch ((int)seg->align) {
@ -1444,7 +1437,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
case 4096: /* PharLap extension */
break;
case 8:
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"OBJ format does not support alignment"
" of 8: rounding up to 16");
seg->align = 16;
@ -1452,7 +1445,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
case 32:
case 64:
case 128:
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"OBJ format does not support alignment"
" of %d: rounding up to 256", seg->align);
seg->align = 256;
@ -1460,13 +1453,13 @@ static int32_t obj_segment(char *name, int pass, int *bits)
case 512:
case 1024:
case 2048:
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"OBJ format does not support alignment"
" of %d: rounding up to 4096", seg->align);
seg->align = 4096;
break;
default:
error(ERR_NONFATAL, "invalid alignment value %d",
nasm_error(ERR_NONFATAL, "invalid alignment value %d",
seg->align);
seg->align = 1;
break;
@ -1474,7 +1467,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
} else if (!nasm_strnicmp(p, "absolute=", 9)) {
seg->align = SEG_ABS + readnum(p + 9, &rn_error);
if (rn_error)
error(ERR_NONFATAL, "argument to `absolute' segment"
nasm_error(ERR_NONFATAL, "argument to `absolute' segment"
" attribute should be numeric");
}
}
@ -1484,11 +1477,11 @@ static int32_t obj_segment(char *name, int pass, int *bits)
obj_seg_needs_update = seg;
if (seg->align >= SEG_ABS)
deflabel(name, NO_SEG, seg->align - SEG_ABS,
NULL, false, false, &of_obj, error);
define_label(name, NO_SEG, seg->align - SEG_ABS,
NULL, false, false, &of_obj, nasm_error);
else
deflabel(name, seg->index + 1, 0L,
NULL, false, false, &of_obj, error);
define_label(name, seg->index + 1, 0L,
NULL, false, false, &of_obj, nasm_error);
obj_seg_needs_update = NULL;
/*
@ -1501,7 +1494,7 @@ static int32_t obj_segment(char *name, int pass, int *bits)
grp->segs[i] = grp->segs[grp->nindices];
grp->segs[grp->nindices++].index = seg->obj_index;
if (seg->grp)
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"segment `%s' is already part of"
" a group: first one takes precedence",
seg->name);
@ -1567,7 +1560,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
* practice, so the sanity check has been removed.
*
* if (!*q) {
* error(ERR_NONFATAL,"GROUP directive contains no segments");
* nasm_error(ERR_NONFATAL,"GROUP directive contains no segments");
* return 1;
* }
*/
@ -1576,7 +1569,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
for (grp = grphead; grp; grp = grp->next) {
obj_idx++;
if (!strcmp(grp->name, v)) {
error(ERR_NONFATAL, "group `%s' defined twice", v);
nasm_error(ERR_NONFATAL, "group `%s' defined twice", v);
return 1;
}
}
@ -1590,8 +1583,8 @@ static int obj_directive(enum directives directive, char *value, int pass)
grp->name = NULL;
obj_grp_needs_update = grp;
deflabel(v, grp->index + 1, 0L,
NULL, false, false, &of_obj, error);
define_label(v, grp->index + 1, 0L,
NULL, false, false, &of_obj, nasm_error);
obj_grp_needs_update = NULL;
while (*q) {
@ -1617,7 +1610,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
grp->segs[grp->nentries++] = grp->segs[grp->nindices];
grp->segs[grp->nindices++].index = seg->obj_index;
if (seg->grp)
error(ERR_WARNING,
nasm_error(ERR_WARNING,
"segment `%s' is already part of"
" a group: first one takes precedence",
seg->name);
@ -1682,7 +1675,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
impname = q;
if (!*extname || !*libname)
error(ERR_NONFATAL, "`import' directive requires symbol name"
nasm_error(ERR_NONFATAL, "`import' directive requires symbol name"
" and library name");
else {
struct ImpDef *imp;
@ -1730,7 +1723,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
}
if (!*intname) {
error(ERR_NONFATAL, "`export' directive requires export name");
nasm_error(ERR_NONFATAL, "`export' directive requires export name");
return 1;
}
if (!*extname) {
@ -1754,7 +1747,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
bool err = false;
flags |= EXPDEF_MASK_PARMCNT & readnum(v + 5, &err);
if (err) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"value `%s' for `parm' is non-numeric", v + 5);
return 1;
}
@ -1762,7 +1755,7 @@ static int obj_directive(enum directives directive, char *value, int pass)
bool err = false;
ordinal = readnum(v, &err);
if (err) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"unrecognised export qualifier `%s'", v);
return 1;
}
@ -1842,10 +1835,10 @@ static int32_t obj_segbase(int32_t segment)
return segment; /* no special treatment */
}
static void obj_filename(char *inname, char *outname, efunc lerror)
static void obj_filename(char *inname, char *outname)
{
strcpy(obj_infile, inname);
standard_extension(inname, outname, ".obj", lerror);
standard_extension(inname, outname, ".obj");
}
static void obj_write_file(int debuginfo)
@ -1968,7 +1961,7 @@ static void obj_write_file(int debuginfo)
/* acbp |= 0x00 */ ;
else if (seg->align >= 4096) {
if (seg->align > 4096)
error(ERR_NONFATAL, "segment `%s' requires more alignment"
nasm_error(ERR_NONFATAL, "segment `%s' requires more alignment"
" than OBJ format supports", seg->name);
acbp |= 0xC0; /* PharLap extension */
} else if (seg->align >= 256) {
@ -2003,7 +1996,7 @@ static void obj_write_file(int debuginfo)
if (grp->nindices != grp->nentries) {
for (i = grp->nindices; i < grp->nentries; i++) {
error(ERR_NONFATAL, "group `%s' contains undefined segment"
nasm_error(ERR_NONFATAL, "group `%s' contains undefined segment"
" `%s'", grp->name, grp->segs[i].name);
nasm_free(grp->segs[i].name);
grp->segs[i].name = NULL;
@ -2237,7 +2230,7 @@ static void obj_write_file(int debuginfo)
}
}
if (!seg)
error(ERR_NONFATAL, "entry point is not in this module");
nasm_error(ERR_NONFATAL, "entry point is not in this module");
}
/*
@ -2324,25 +2317,20 @@ static void obj_fwrite(ObjRecord * orp)
cksum = orp->type;
if (orp->x_size == 32)
cksum |= 1;
fputc(cksum, ofp);
fputc(cksum, ofile);
len = orp->committed + 1;
cksum += (len & 0xFF) + ((len >> 8) & 0xFF);
fwriteint16_t(len, ofp);
fwrite(orp->buf, 1, len - 1, ofp);
fwriteint16_t(len, ofile);
fwrite(orp->buf, 1, len - 1, ofile);
for (ptr = orp->buf; --len; ptr++)
cksum += *ptr;
fputc((-cksum) & 0xFF, ofp);
fputc((-cksum) & 0xFF, ofile);
}
extern macros_t obj_stdmac[];
void dbgbi_init(struct ofmt *of, void *id, FILE * fp, efunc error)
void dbgbi_init(void)
{
(void)of;
(void)id;
(void)fp;
(void)error;
fnhead = NULL;
fntail = &fnhead;
arrindex = ARRAYBOT;
@ -2394,7 +2382,7 @@ static void dbgbi_linnum(const char *lnfname, int32_t lineno, int32_t segto)
if (!any_segs) {
int tempint; /* ignored */
if (segto != obj_segment("__NASMDEFSEG", 2, &tempint))
error(ERR_PANIC, "strange segment conditions in OBJ driver");
nasm_error(ERR_PANIC, "strange segment conditions in OBJ driver");
}
/*
@ -2404,7 +2392,7 @@ static void dbgbi_linnum(const char *lnfname, int32_t lineno, int32_t segto)
if (seg->index == segto)
break;
if (!seg)
error(ERR_PANIC, "lineno directed to nonexistent segment?");
nasm_error(ERR_PANIC, "lineno directed to nonexistent segment?");
/* for (fn = fnhead; fn; fn = fnhead->next) */
for (fn = fnhead; fn; fn = fn->next) /* fbk - Austin Lunnen - John Fine */

70
output/outrdf2.c
View file

@ -97,10 +97,6 @@ static int segmenttypenumbers[COUNT_SEGTYPES] = {
static struct SAA *seg[RDF_MAXSEGS]; /* seg 0 = code, seg 1 = data */
static struct SAA *header; /* relocation/import/export records */
static FILE *ofile;
static efunc error;
static struct seginfo {
char *segname;
int segnumber;
@ -114,13 +110,10 @@ static int nsegments;
static int32_t bsslength;
static int32_t headerlength;
static void rdf2_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
static void rdf2_init(void)
{
int segtext, segdata, segbss;
(void)ldef;
(void)eval;
maxbits = 64;
/* set up the initial segments */
@ -144,9 +137,6 @@ static void rdf2_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
nsegments = 3;
ofile = fp;
error = errfunc;
seg[0] = saa_init(1L);
seg[1] = saa_init(1L);
seg[2] = NULL; /* special case! */
@ -157,7 +147,7 @@ static void rdf2_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
segdata = seg_alloc();
segbss = seg_alloc();
if (segtext != 0 || segdata != 2 || segbss != 4)
error(ERR_PANIC,
nasm_error(ERR_PANIC,
"rdf segment numbers not allocated as expected (%d,%d,%d)",
segtext, segdata, segbss);
bsslength = 0;
@ -200,7 +190,7 @@ static int32_t rdf2_section_names(char *name, int pass, int *bits)
reserved = readnum(q, &err);
if (err) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"value following comma must be numeric");
reserved = 0;
}
@ -217,7 +207,7 @@ static int32_t rdf2_section_names(char *name, int pass, int *bits)
if (code == -1) { /* didn't find anything */
code = readnum(p, &err);
if (err) {
error(ERR_NONFATAL, "unrecognised RDF segment type (%s)",
nasm_error(ERR_NONFATAL, "unrecognised RDF segment type (%s)",
p);
code = 3;
}
@ -226,7 +216,7 @@ static int32_t rdf2_section_names(char *name, int pass, int *bits)
for (i = 0; i < nsegments; i++) {
if (!strcmp(name, segments[i].segname)) {
if (code != -1 || reserved != 0)
error(ERR_NONFATAL, "segment attributes specified on"
nasm_error(ERR_NONFATAL, "segment attributes specified on"
" redeclaration of segment");
return segments[i].segnumber * 2;
}
@ -235,11 +225,11 @@ static int32_t rdf2_section_names(char *name, int pass, int *bits)
/* declaring a new segment! */
if (code == -1) {
error(ERR_NONFATAL, "new segment declared without type code");
nasm_error(ERR_NONFATAL, "new segment declared without type code");
code = 3;
}
if (nsegments == RDF_MAXSEGS) {
error(ERR_FATAL, "reached compiled-in maximum segment limit (%d)",
nasm_error(ERR_FATAL, "reached compiled-in maximum segment limit (%d)",
RDF_MAXSEGS);
return NO_SEG;
}
@ -247,7 +237,7 @@ static int32_t rdf2_section_names(char *name, int pass, int *bits)
segments[nsegments].segname = nasm_strdup(name);
i = seg_alloc();
if (i % 2 != 0)
error(ERR_PANIC, "seg_alloc() returned odd number");
nasm_error(ERR_PANIC, "seg_alloc() returned odd number");
segments[nsegments].segnumber = i >> 1;
segments[nsegments].segtype = code;
segments[nsegments].segreserved = reserved;
@ -396,11 +386,11 @@ static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
/* Check if the label length is OK */
if ((len = strlen(name)) >= EXIM_LABEL_MAX) {
error(ERR_NONFATAL, "label size exceeds %d bytes", EXIM_LABEL_MAX);
nasm_error(ERR_NONFATAL, "label size exceeds %d bytes", EXIM_LABEL_MAX);
return;
}
if (!len) {
error(ERR_NONFATAL, "zero-length label");
nasm_error(ERR_NONFATAL, "zero-length label");
return;
}
@ -421,10 +411,10 @@ static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
bool err;
ci.align = readnum(special, &err);
if (err)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" valid number", special);
else if ((ci.align | (ci.align - 1)) != 2 * ci.align - 1)
error(ERR_NONFATAL, "alignment constraint `%s' is not a"
nasm_error(ERR_NONFATAL, "alignment constraint `%s' is not a"
" power of two", special);
}
write_common_rec(&ci);
@ -460,13 +450,13 @@ static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
!nasm_stricmp(special, "object")) {
symflags |= SYM_DATA;
} else
error(ERR_NONFATAL, "unrecognised symbol type `%s'",
nasm_error(ERR_NONFATAL, "unrecognised symbol type `%s'",
special);
}
}
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
nasm_error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
return;
}
@ -478,7 +468,7 @@ static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
if (i >= nsegments) { /* EXTERN declaration */
ri.type = farsym ? RDFREC_FARIMPORT : RDFREC_IMPORT;
if (symflags & SYM_GLOBAL)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"symbol type conflict - EXTERN cannot be EXPORT");
ri.flags = symflags;
ri.segment = segment;
@ -488,7 +478,7 @@ static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
} else if (is_global) {
r.type = RDFREC_GLOBAL; /* GLOBAL declaration */
if (symflags & SYM_IMPORT)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"symbol type conflict - GLOBAL cannot be IMPORT");
r.flags = symflags;
r.segment = segment;
@ -509,7 +499,7 @@ static void membufwrite(int segment, const void *data, int bytes)
break;
}
if (i == nsegments)
error(ERR_PANIC, "can't find segment %d", segment);
nasm_error(ERR_PANIC, "can't find segment %d", segment);
if (bytes < 0) {
b = buf;
@ -532,7 +522,7 @@ static int getsegmentlength(int segment)
break;
}
if (i == nsegments)
error(ERR_PANIC, "can't find segment %d", segment);
nasm_error(ERR_PANIC, "can't find segment %d", segment);
return segments[i].seglength;
}
@ -547,7 +537,7 @@ static void rdf2_out(int32_t segto, const void *data,
if (segto == NO_SEG) {
if (type != OUT_RESERVE)
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"attempt to assemble code in ABSOLUTE space");
return;
}
@ -559,18 +549,18 @@ static void rdf2_out(int32_t segto, const void *data,
break;
}
if (seg >= nsegments) {
error(ERR_NONFATAL,
nasm_error(ERR_NONFATAL,
"specified segment not supported by rdf output format");
return;
}
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
error(ERR_NONFATAL, "WRT not supported by rdf output format");
nasm_error(ERR_NONFATAL, "WRT not supported by rdf output format");
}
if (segto == 2 && type != OUT_RESERVE) {
error(ERR_NONFATAL, "BSS segments may not be initialized");
nasm_error(ERR_NONFATAL, "BSS segments may not be initialized");
/* just reserve the space for now... */
@ -589,7 +579,7 @@ static void rdf2_out(int32_t segto, const void *data,
membufwrite(segto, databuf, 1);
} else if (type == OUT_RAWDATA) {
if (segment != NO_SEG)
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
membufwrite(segto, data, size);
} else if (type == OUT_ADDRESS) {
@ -617,7 +607,7 @@ static void rdf2_out(int32_t segto, const void *data,
membufwrite(segto, databuf, size);
} else if (type == OUT_REL2ADR) {
if (segment == segto)
error(ERR_PANIC, "intra-segment OUT_REL2ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL2ADR");
rr.reclen = 8;
rr.offset = getsegmentlength(segto); /* current offset */
@ -649,9 +639,9 @@ static void rdf2_out(int32_t segto, const void *data,
membufwrite(segto, &rr.offset, -2);
} else if (type == OUT_REL4ADR) {
if ((segment == segto) && (globalbits != 64))
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
nasm_error(ERR_PANIC, "intra-segment OUT_REL4ADR");
if (segment != NO_SEG && segment % 2) {
error(ERR_PANIC, "erm... 4 byte segment base ref?");
nasm_error(ERR_PANIC, "erm... 4 byte segment base ref?");
}
rr.type = RDFREC_RELOC; /* type signature */
@ -741,7 +731,7 @@ static int rdf2_directive(enum directives directive, char *value, int pass)
case D_LIBRARY:
n = strlen(value);
if (n >= MODLIB_NAME_MAX) {
error(ERR_NONFATAL, "name size exceeds %d bytes", MODLIB_NAME_MAX);
nasm_error(ERR_NONFATAL, "name size exceeds %d bytes", MODLIB_NAME_MAX);
return 1;
}
if (pass == 1) {
@ -755,7 +745,7 @@ static int rdf2_directive(enum directives directive, char *value, int pass)
case D_MODULE:
if ((n = strlen(value)) >= MODLIB_NAME_MAX) {
error(ERR_NONFATAL, "name size exceeds %d bytes", MODLIB_NAME_MAX);
nasm_error(ERR_NONFATAL, "name size exceeds %d bytes", MODLIB_NAME_MAX);
return 1;
}
if (pass == 1) {
@ -772,9 +762,9 @@ static int rdf2_directive(enum directives directive, char *value, int pass)
}
}
static void rdf2_filename(char *inname, char *outname, efunc error)
static void rdf2_filename(char *inname, char *outname)
{
standard_extension(inname, outname, ".rdf", error);
standard_extension(inname, outname, ".rdf");
}
extern macros_t rdf2_stdmac[];

3
raa.c
View file

@ -92,8 +92,7 @@ struct RAA *raa_write(struct RAA *r, int32_t posn, int64_t value)
{
struct RAA *result;
if (posn < 0)
nasm_malloc_error(ERR_PANIC, "negative position in raa_write");
nasm_assert(posn >= 0);
while ((UINT32_C(1) << (r->shift + LAYERSHIFT(r))) <= (uint32_t) posn) {
/*

31
saa.c
View file

@ -99,15 +99,10 @@ void *saa_wstruct(struct SAA *s)
{
void *p;
if (s->wpos % s->elem_len)
nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
"misaligned wpos in saa_wstruct");
nasm_assert((s->wpos % s->elem_len) == 0);
if (s->wpos + s->elem_len > s->blk_len) {
if (s->wpos != s->blk_len)
nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
"unfilled block in saa_wstruct");
nasm_assert(s->wpos == s->blk_len);
if (s->wptr + s->elem_len > s->length)
saa_extend(s);
s->wblk++;
@ -167,9 +162,7 @@ void *saa_rstruct(struct SAA *s)
if (s->rptr + s->elem_len > s->datalen)
return NULL;
if (s->rpos % s->elem_len)
nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
"misaligned rpos in saa_rstruct");
nasm_assert((s->rpos % s->elem_len) == 0);
if (s->rpos + s->elem_len > s->blk_len) {
s->rblk++;
@ -217,11 +210,7 @@ void saa_rnbytes(struct SAA *s, void *data, size_t len)
{
char *d = data;
if (s->rptr + len > s->datalen) {
nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
"overrun in saa_rnbytes");
return;
}
nasm_assert(s->rptr + len <= s->datalen);
while (len) {
size_t l;
@ -241,10 +230,7 @@ void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
{
size_t ix;
if (posn + len > s->datalen) {
nasm_malloc_error(ERR_PANIC | ERR_NOFILE, "overrun in saa_fread");
return;
}
nasm_assert(posn + len <= s->datalen);
if (likely(s->blk_len == SAA_BLKLEN)) {
ix = posn >> SAA_BLKSHIFT;
@ -264,11 +250,8 @@ void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
{
size_t ix;
if (posn > s->datalen) {
/* Seek beyond the end of the existing array not supported */
nasm_malloc_error(ERR_PANIC | ERR_NOFILE, "overrun in saa_fwrite");
return;
}
/* Seek beyond the end of the existing array not supported */
nasm_assert(posn <= s->datalen);
if (likely(s->blk_len == SAA_BLKLEN)) {
ix = posn >> SAA_BLKSHIFT;