add_asp(instruction, bits);
size_prob = false;
-
- for (temp = nasm_instructions[instruction->opcode]; temp->opcode != -1; temp++){
+
+ for (temp = nasm_instructions[instruction->opcode]; temp->opcode != -1; temp++){
int m = matches(temp, instruction, bits);
-
+
if (m == 99)
m += jmp_match(segment, offset, bits, instruction, temp->code);
NO_SEG, NO_SEG);
offset++;
}
- }
+ }
insn_end = offset + insn_size;
gencode(segment, offset, bits, instruction, codes,
insn_end);
break;
case 0300:
case 0301:
- case 0302:
- case 0303:
+ case 0302:
+ case 0303:
break;
case 0310:
if (bits == 64)
length += (bits != 32) && !has_prefix(ins,P_A32);
break;
case 0312:
- break;
+ break;
case 0313:
if (bits != 64 || has_prefix(ins,P_A16) || has_prefix(ins,P_A32))
return -1;
int rfield;
int32_t rflags;
ea_data.rex = 0; /* Ensure ea.REX is initially 0 */
-
+
if (c <= 0177) {
/* pick rfield from operand b */
rflags = regflag(&ins->oprs[c & 7]);
}
ins->rex &= rex_mask;
-
+
if (ins->rex & REX_D) {
if (ins->rex & REX_H) {
errfunc(ERR_NONFATAL, "cannot use high register in drex instruction");
uint8_t bytes[4];
int32_t size;
int64_t data;
-
+
while (*codes)
switch (c = *codes++) {
case 01:
out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
offset += 1;
break;
-
+
case 054:
case 055:
case 056:
break;
case 0322:
- case 0323:
- break;
-
+ case 0323:
+ break;
+
case 0324:
ins->rex |= REX_W;
break;
-
+
case 0330:
*bytes = *codes++ ^ condval[ins->condition];
out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
int32_t rflags;
uint8_t *p;
int32_t s;
-
+
if (c <= 0177) {
/* pick rfield from operand b */
rflags = regflag(&ins->oprs[c & 7]);
rfield, rflags, ins->forw_ref)) {
errfunc(ERR_NONFATAL, "invalid effective address");
}
-
+
p = bytes;
*p++ = ea_data.modrm;
if (ea_data.sib_present)
}
s++;
break;
- case 8:
+ case 8:
case 2:
case 4:
data = ins->oprs[(c >> 3) & 7].offset;
for (i = 0; i < itemp->operands; i++)
if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO))
return 0;
-
+
/*
* Check that the operand flags all match up
*/
for (i = 0; i < MAX_OPERANDS; i++)
size[i] = asize;
}
-
+
if (itemp->flags & (IF_SM | IF_SM2)) {
oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands);
asize = 0;
*/
if (((itemp->flags & IF_PLEVEL) > cpu))
return 3;
-
+
/*
* Check if instruction is available in long mode
*/
if (REG_EA & ~f)
return NULL; /* Invalid EA register */
-
+
output->rex |= op_rexflags(input, REX_B|REX_P|REX_W|REX_H);
output->sib_present = false; /* no SIB necessary */
if (s == 0)
i = -1; /* make this easy, at least */
-
+
if (i >= EXPR_REG_START && i < REG_ENUM_LIMIT) {
it = regvals[i];
ix = reg_flags[i];
it = -1;
ix = 0;
}
-
+
if (b != -1 && b >= EXPR_REG_START && b < REG_ENUM_LIMIT) {
bt = regvals[b];
bx = reg_flags[b];
bt = -1;
bx = 0;
}
-
+
/* check for a 32/64-bit memory reference... */
if ((ix|bx) & (BITS32|BITS64)) {
/* it must be a 32/64-bit memory reference. Firstly we have
return NULL; /* Invalid size */
sok &= ~bx;
}
-
+
/* While we're here, ensure the user didn't specify WORD. */
if (input->addr_size == 16 ||
(input->addr_size == 32 && !(sok & BITS32)) ||
if (it == -1 && (bt & 7) != REG_NUM_ESP) {
/* no SIB needed */
int mod, rm;
-
+
if (bt == -1) {
rm = 5;
mod = 0;
} else {
/* we need a SIB */
int mod, scale, index, base;
-
+
if (it == -1)
index = 4, s = 1;
else
index = (it & 7);
-
+
switch (s) {
case 1:
scale = 0;
default: /* then what the smeg is it? */
return NULL; /* panic */
}
-
+
if (bt == -1) {
base = 5;
mod = 0;
}
} else { /* it's 16-bit */
int mod, rm;
-
+
/* check for 64-bit long mode */
if (addrbits == 64)
return NULL;
}
}
}
-
+
output->size = 1 + output->sib_present + output->bytes;
return output;
}
for (j = 0; j < instruction->operands; j++) {
if (!(MEMORY & ~instruction->oprs[j].type)) {
int32_t i, b;
-
+
/* Verify as Register */
if (instruction->oprs[j].indexreg < EXPR_REG_START
|| instruction->oprs[j].indexreg >= REG_ENUM_LIMIT)
i = 0;
else
i = reg_flags[instruction->oprs[j].indexreg];
-
+
/* Verify as Register */
if (instruction->oprs[j].basereg < EXPR_REG_START
|| instruction->oprs[j].basereg >= REG_ENUM_LIMIT)
b = 0;
else
b = reg_flags[instruction->oprs[j].basereg];
-
+
if (instruction->oprs[j].scale == 0)
i = 0;
valid &= 32;
if (!(REG64 & ~b))
valid &= 64;
-
+
if (!(REG16 & ~i))
valid &= 16;
if (!(REG32 & ~i))
if ((drex & 8) != ((ins->rex & REX_OC) ? 8 : 0))
return NULL; /* OC0 mismatch */
ins->rex = (ins->rex & ~7) | (drex & 7);
-
+
dst->segment = SEG_RMREG;
dst->basereg = drex >> 4;
return data;
data += 4;
ins->oprs[c - 064].segment &= ~SEG_64BIT;
ins->oprs[c - 064].segment |= SEG_32BIT;
- }
+ }
if (segsize != osize) {
ins->oprs[c - 064].type =
(ins->oprs[c - 064].type & ~SIZE_MASK)
slen = 0;
/* TODO: snprintf returns the value that the string would have if
- * the buffer were long enough, and not the actual length of
+ * the buffer were long enough, and not the actual length of
* the returned string, so each instance of using the return
* value of snprintf should actually be checked to assure that
* the return value is "sane." Maybe a macro wrapper could
push(@tocptypes, 'toc0'.' :'.$sech.':'.$chap.' '.$secn.':');
unshift(@{$paras[$i]},
- [-5, $xref], [0,$chap.' '.$secn.':'], [0, ' ']);
+ [-5, $xref], [0,$chap.' '.$secn.':'], [0, ' ']);
} elsif ( $ptype eq 'head' || $ptype eq 'subh' ) {
unless ( $xtype =~ /^\S+ (\S+) :(.*)$/ ) {
die "Bad para";
# Source-form features:
# ---------------------
-#
+#
# Bullet \b
# Bullets the paragraph. Rest of paragraph is indented to cope. In
# HTML, consecutive groups of bulleted paragraphs become unordered
# lists.
-#
+#
# Emphasis \e{foobar}
# produces `_foobar_' in text and italics in HTML, PS, RTF
-#
+#
# Inline code \c{foobar}
# produces ``foobar'' in text, and fixed-pitch font in HTML, PS, RTF
-#
+#
# Display code
# \c line one
# \c line two
# produces fixed-pitch font where appropriate, and doesn't break
# pages except sufficiently far into the middle of a display.
-#
+#
# Chapter, header and subheader
# \C{intro} Introduction
# \H{whatsnasm} What is NASM?
# Expands to `Chapter 1', `Section 1.1', `Section 1.1.1'. \K has an
# initial capital whereas \k doesn't. In HTML, will produce
# hyperlinks.
-#
+#
# Web link \W{http://foobar/}{text} or \W{mailto:me@here}\c{me@here}
# the \W prefix is ignored except in HTML; in HTML the last part
# becomes a hyperlink to the first part.
-#
+#
# Literals \{ \} \\
# In case it's necessary, they expand to the real versions.
-#
+#
# Nonbreaking hyphen \-
# Need more be said?
-#
+#
# Source comment \#
# Causes everything after it on the line to be ignored by the
# source-form processor.
if ($$pname[$i] =~ /^k/) {
$k = $$pname[$i];
$caps = ($k =~ /^kK/);
- $k = substr($k,2);
+ $k = substr($k,2);
$repl = $refs{$k};
die "undefined keyword `$k'\n" unless $repl;
substr($repl,0,1) =~ tr/a-z/A-Z/ if $caps;
}
close(PARAS);
}
-
int sign = 1;
int64_t val;
int j;
-
+
i = scan(scpriv, tokval);
if (i != '(') {
error(ERR_NONFATAL, "expecting `('");
} else
return NO_SEG;
}
-
uint32_t temp[MANT_WORDS * 2];
int32_t i, j;
- /*
+ /*
* guaranteed that top bit of 'from' is set -- so we only have
* to worry about _one_ bit shift to the left
*/
{
int32_t i = 0;
bool neg = false;
-
+
if (*string == '+') {
string++;
} else if (*string == '-') {
while (*string) {
if (*string >= '0' && *string <= '9') {
i = (i * 10) + (*string - '0');
-
+
/*
* To ensure that underflows and overflows are
* handled properly we must avoid wraparounds of
}
string++;
}
-
+
if (*string) {
int32_t e;
goto overflow;
}
}
-
+
if (!fmt->explicit)
mant[one_pos] &= ~one_mask; /* remove explicit one */
mant[0] |= exponent << (15 - fmt->exponent);
return -1; /* Unknown option */
}
}
-
/* float.h header file for the floating-point constant module of
- * the Netwide Assembler
+ * the Netwide Assembler
*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
if (op->key) {
size_t pos = op->hash & mask;
size_t inc = ((op->hash >> 32) & mask) | 1;
-
+
while ((xp = &newtbl[pos])->key)
pos = (pos+inc) & mask;
#!/usr/bin/perl
-#
+#
# insns.pl produce insnsa.c, insnsd.c, insnsi.h, insnsn.c from insns.dat
#
# The Netwide Assembler is copyright (C) 1996 Simon Tatham and
if ( !defined($output) || $output eq 'a' ) {
print STDERR "Writing insnsa.c...\n";
-
+
open A, ">insnsa.c";
-
+
print A "/* This file auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
print A "#include \"nasm.h\"\n";
print A "#include \"insns.h\"\n";
print A "\n";
-
+
foreach $i (@opcodes, @opcodes_cc) {
print A "static const struct itemplate instrux_${i}[] = {\n";
$aname = "aa_$i";
print A " instrux_${i},\n";
}
print A "};\n";
-
+
close A;
}
if ( !defined($output) || $output eq 'd' ) {
print STDERR "Writing insnsd.c...\n";
-
+
open D, ">insnsd.c";
-
+
print D "/* This file auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
print D "#include \"nasm.h\"\n";
print D "#include \"insns.h\"\n";
print D "\n";
-
+
print D "static const struct itemplate instrux[] = {\n";
$n = 0;
foreach $j (@big) {
printf D " { itable_%s, -1 },\n", $nn;
} elsif (defined($dinstables{$nn})) {
printf D " { itable_%s, %u },\n",
- $nn, scalar(@{$dinstables{$nn}});
+ $nn, scalar(@{$dinstables{$nn}});
} else {
printf D " { NULL, 0 },\n";
}
}
print D "};\n";
}
-
+
close D;
}
if ( !defined($output) || $output eq 'i' ) {
print STDERR "Writing insnsi.h...\n";
-
+
open I, ">insnsi.h";
-
+
print I "/* This file is auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
print I "/* This file in included by nasm.h */\n\n";
-
+
print I "/* Instruction names */\n\n";
print I "#ifndef NASM_INSNSI_H\n";
print I "#define NASM_INSNSI_H 1\n\n";
print I "\n};\n\n";
print I "#define MAX_INSLEN ", $maxlen, "\n\n";
print I "#endif /* NASM_INSNSI_H */\n";
-
+
close I;
}
if ( !defined($output) || $output eq 'n' ) {
print STDERR "Writing insnsn.c...\n";
-
+
open N, ">insnsn.c";
-
+
print N "/* This file is auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
print N "/* This file in included by names.c */\n\n";
-
+
print N "static const char * const insn_names[] = {";
$first = 1;
foreach $i (@opcodes) {
$ilower =~ tr/A-Z/a-z/; # Change to lower case (Perl 4 compatible)
print N "\n\t\"${ilower}\"";
}
-
+
print N "\n};\n\n";
print N "/* and the corresponding opcodes */\n";
print N "static const enum opcode ico[] = {";
$first = 0;
print N "\n\tI_$i";
}
-
+
print N "\n};\n";
-
+
close N;
}
my $num, $nd = 0;
return (undef, undef) if $operands eq "ignore";
-
+
# format the operands
$operands =~ s/:/|colon,/g;
$operands =~ s/mem(\d+)/mem|bits$1/g;
}
$operands = join(',', @ops);
$operands =~ tr/a-z/A-Z/;
-
+
# format the flags
$flags =~ s/,/|IF_/g;
$flags =~ s/(\|IF_ND|IF_ND\|)//, $nd = 1 if $flags =~ /IF_ND/;
$flags = "IF_" . $flags;
-
+
("{I_$opcode, $num, {$operands}, \"$codes\", $flags},", $nd);
}
lfree = lfree->admin.next;
init_block(lfree);
}
-
+
lfree->admin.movingon = BOGUS_VALUE;
lfree->defn.label = perm_copy(label);
lfree->defn.special = NULL;
lfree->defn.is_global = NOT_DEFINED_YET;
-
+
hash_add(&ip, lfree->defn.label, lfree);
return lfree++;
}
HEX(q + 11, p[5]);
HEX(q + 13, p[6]);
HEX(q + 15, p[7]);
- list_out(offset, q);
+ list_out(offset, q);
} else {
q[0] = '[';
q[5] = ']';
#!/usr/bin/perl -w
-#
+#
# macros.pl produce macros.c from standard.mac
#
# The Netwide Assembler is copyright (C) 1996 Simon Tatham and
undef $tasm_count;
open(OUTPUT,">macros.c") or die "unable to open macros.c\n";
-
+
print OUTPUT "/* This file auto-generated from standard.mac by macros.pl" .
" - don't edit it */\n\n#include \"compiler.h\"\n\nstatic const char *stdmac[] = {\n";
-
+
foreach $fname ( @ARGV ) {
open(INPUT,$fname) or die "unable to open $fname\n";
while (<INPUT>) {
if (length > 0) {
print OUTPUT " \"$_\",\n";
$index++;
- }
+ }
} else {
die "$fname:$line: error unterminated quote";
}
}
print $line, "\n";
}
-
-
my($file) = @_;
$nexttemp++; # Unique serial number for each temp file
my($tmp) = File::Spec->catfile(dirname($file), 'tmp.'.$nexttemp);
-
+
sysopen(IN, $file, O_RDONLY)
or die "$0: Cannot open input: $file\n";
sysopen(OUT, $tmp, O_WRONLY|O_CREAT|O_TRUNC, 0666)
}
}
close(OUT);
-
- (unlink($file) && rename($tmp, $file))
+
+ (unlink($file) && rename($tmp, $file))
or die "$0: Failed to change $tmp -> $file\n";
}
#
# Main program
#
-
+
%deps = ();
@files = ();
@mkfiles = ();
ofmt->current_dfmt = ofmt->debug_formats[0];
} else if (p[1] == 'O') { /* Optimization level */
int opt;
-
+
if (!*param) {
/* Naked -O == -Ox */
optimizing = INT_MAX >> 1; /* Almost unlimited */
else
optimizing = opt; /* More than 5 passes */
break;
-
+
case 'v':
case '+':
param++;
opt_verbose_info = true;
break;
-
+
case 'x':
param++;
optimizing = INT_MAX >> 1; /* Almost unlimited */
break;
-
+
default:
report_error(ERR_FATAL,
"unknown optimization option -O%c\n",
"file `%s' is both input and output file",
inname);
- if (*errname) {
+ if (*errname) {
error_file = fopen(errname, "w");
if (!error_file) {
error_file = stderr; /* Revert to default! */
* This function prints an error message to error_file in the
* style used by GNU. An example would be:
* file.asm:50: error: blah blah blah
- * where file.asm is the name of the file, 50 is the line number on
+ * where file.asm is the name of the file, 50 is the line number on
* which the error occurs (or is detected) and "error:" is one of
* the possible optional diagnostics -- it can be "error" or "warning"
- * or something else. Finally the line terminates with the actual
+ * or something else. Finally the line terminates with the actual
* error message.
- *
- * @param severity the severity of the warning or error
+ *
+ * @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, ...)
/**
* MS style error reporting
* This function prints an error message to error_file in the
- * style used by Visual C and some other Microsoft tools. An example
+ * style used by Visual C and some other Microsoft tools. An example
* would be:
* file.asm(50) : error: blah blah blah
- * where file.asm is the name of the file, 50 is the line number on
+ * where file.asm is the name of the file, 50 is the line number on
* which the error occurs (or is detected) and "error:" is one of
* the possible optional diagnostics -- it can be "error" or "warning"
- * or something else. Finally the line terminates with the actual
+ * or something else. Finally the line terminates with the actual
* error message.
- *
- * @param severity the severity of the warning or error
+ *
+ * @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, ...)
/**
* check for supressed warning
- * checks for suppressed warning or pass one only warning and we're
+ * checks for suppressed warning or pass one only warning and we're
* not in pass 1
*
* @param severity the severity of the warning or error
/**
* common error reporting
* This is the common back end of the error reporting schemes currently
- * implemented. It prints the nature of the warning and then the
+ * implemented. It prints the nature of the warning and then the
* specific error message to error_file and may or may not return. It
* doesn't return if the error severity is a "panic" or "debug" type.
- *
- * @param severity the severity of the warning or error
+ *
+ * @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,
* matches any character that may appear at places other than the start of an
* identifier. E.g. a period may only appear at the start of an identifier
* (for local labels), whereas a number may appear anywhere *but* at the
- * start.
+ * start.
*/
#define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
typedef uint32_t opflags_t;
/* Size, and other attributes, of the operand */
-#define BITS8 0x00000001L
-#define BITS16 0x00000002L
-#define BITS32 0x00000004L
-#define BITS64 0x00000008L /* x64 and FPU only */
-#define BITS80 0x00000010L /* FPU only */
+#define BITS8 0x00000001L
+#define BITS16 0x00000002L
+#define BITS32 0x00000004L
+#define BITS64 0x00000008L /* x64 and FPU only */
+#define BITS80 0x00000010L /* FPU only */
#define BITS128 0x20000000L
-#define FAR 0x00000020L /* grotty: this means 16:16 or */
+#define FAR 0x00000020L /* grotty: this means 16:16 or */
/* 16:32, like in CALL/JMP */
-#define NEAR 0x00000040L
-#define SHORT 0x00000080L /* and this means what it says :) */
+#define NEAR 0x00000040L
+#define SHORT 0x00000080L /* and this means what it says :) */
-#define SIZE_MASK 0x200000FFL /* all the size attributes */
+#define SIZE_MASK 0x200000FFL /* all the size attributes */
/* Modifiers */
#define MODIFIER_MASK 0x00000f00L
-#define TO 0x00000100L /* reverse effect in FADD, FSUB &c */
-#define COLON 0x00000200L /* operand is followed by a colon */
-#define STRICT 0x00000400L /* do not optimize this operand */
+#define TO 0x00000100L /* reverse effect in FADD, FSUB &c */
+#define COLON 0x00000200L /* operand is followed by a colon */
+#define STRICT 0x00000400L /* do not optimize this operand */
/* Type of operand: memory reference, register, etc. */
#define OPTYPE_MASK 0x0000f000L
#define REGISTER 0x00001000L /* register number in 'basereg' */
#define IMMEDIATE 0x00002000L
#define MEMORY 0x0000c000L
-#define REGMEM 0x00008000L /* for r/m, ie EA, operands */
+#define REGMEM 0x00008000L /* for r/m, ie EA, operands */
/* Register classes */
-#define REG_EA 0x00009000L /* 'normal' reg, qualifies as EA */
+#define REG_EA 0x00009000L /* 'normal' reg, qualifies as EA */
#define RM_GPR 0x00208000L /* integer operand */
#define REG_GPR 0x00209000L /* integer register */
-#define REG8 0x00209001L /* 8-bit GPR */
-#define REG16 0x00209002L /* 16-bit GPR */
-#define REG32 0x00209004L /* 32-bit GPR */
-#define REG64 0x00209008L /* 64-bit GPR */
-#define IP_REG 0x00801000L /* RIP or EIP register */
-#define RIPREG 0x00801008L /* RIP */
-#define EIPREG 0x00801004L /* EIP */
-#define FPUREG 0x01001000L /* floating point stack registers */
-#define FPU0 0x01011000L /* FPU stack register zero */
+#define REG8 0x00209001L /* 8-bit GPR */
+#define REG16 0x00209002L /* 16-bit GPR */
+#define REG32 0x00209004L /* 32-bit GPR */
+#define REG64 0x00209008L /* 64-bit GPR */
+#define IP_REG 0x00801000L /* RIP or EIP register */
+#define RIPREG 0x00801008L /* RIP */
+#define EIPREG 0x00801004L /* EIP */
+#define FPUREG 0x01001000L /* floating point stack registers */
+#define FPU0 0x01011000L /* FPU stack register zero */
#define RM_MMX 0x02008000L /* MMX operand */
-#define MMXREG 0x02009000L /* MMX register */
+#define MMXREG 0x02009000L /* MMX register */
#define RM_XMM 0x04008000L /* XMM (SSE) operand */
-#define XMMREG 0x04009000L /* XMM (SSE) register */
+#define XMMREG 0x04009000L /* XMM (SSE) register */
#define XMM0 0x04019000L /* XMM register zero */
-#define REG_CDT 0x00101004L /* CRn, DRn and TRn */
+#define REG_CDT 0x00101004L /* CRn, DRn and TRn */
#define REG_CREG 0x00111004L /* CRn */
#define REG_DREG 0x00121004L /* DRn */
#define REG_TREG 0x00141004L /* TRn */
#define REG_EIP 0x00801004L /* EIP relative addressing */
/* Special GPRs */
-#define REG_SMASK 0x000f0000L /* a mask for the following */
+#define REG_SMASK 0x000f0000L /* a mask for the following */
#define REG_ACCUM 0x00219000L /* accumulator: AL, AX, EAX, RAX */
#define REG_AL 0x00219001L
#define REG_AX 0x00219002L
int nprefix; /* number of entries in above */
enum opcode opcode; /* the opcode - not just the string */
enum ccode condition; /* the condition code, if Jcc/SETcc */
- int operands; /* how many operands? 0-3
+ int operands; /* how many operands? 0-3
* (more if db et al) */
operand oprs[MAX_OPERANDS]; /* the operands, defined as above */
extop *eops; /* extended operands */
* This is a single keyword used to select the driver.
*/
const char *shortname;
-
+
/*
* this is reserved for out module specific help.
const char *shortname;
/*
- * init - called initially to set up local pointer to object format,
+ * 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.
*/
* is encountered. 'directive' contains the first parameter to the
* DEBUG directive, and params contains the rest. For example,
* 'DEBUG VAR _somevar:int' would translate to a call to this
- * function with 'directive' equal to "VAR" and 'params' equal to
+ * function with 'directive' equal to "VAR" and 'params' equal to
* "_somevar:int".
*/
void (*debug_directive) (const char *directive, const char *params);
*error = true;
return 0;
}
-
+
/*
* `checklimit' must be 2**(32|64) / radix. We can't do that in
* 32/64-bit arithmetic, which we're (probably) using, so we
(result == checklimit && digit >= last)) {
warn = true;
}
-
+
result = radix * result + digit;
}
r++;
static void saa_extend(struct SAA *s)
{
size_t blkn = s->nblks++;
-
+
if (blkn >= s->nblkptrs) {
size_t rindex = s->rblk - s->blk_ptrs;
size_t windex = s->wblk - s->blk_ptrs;
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;
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");
{
(void)filename;
(void)linenumber;
- (void)segto;
+ (void)segto;
}
void null_debug_deflabel(char *name, int32_t segment, int32_t offset,
int is_global, char *special)
* argument to an efunc.
*/
-#define ERR_DEBUG 0x00000008 /* put out debugging message */
+#define ERR_DEBUG 0x00000008 /* put out debugging message */
#define ERR_WARNING 0x00000000 /* warn only: no further action */
#define ERR_NONFATAL 0x00000001 /* terminate assembly after phase */
#define ERR_FATAL 0x00000002 /* instantly fatal: exit with error */
*/
#define ERR_WARN_MASK 0x0000FF00 /* the mask for this feature */
-#define ERR_WARN_SHR 8 /* how far to shift right */
+#define ERR_WARN_SHR 8 /* how far to shift right */
#define WARN(x) ((x) << ERR_WARN_SHR)
WRITECHAR(p,(v) >> 16); \
WRITECHAR(p,(v) >> 24); \
} while (0)
-
+
#define WRITEDLONG(p,v) \
do { \
WRITECHAR(p,v); \
/* outform.c manages a list of output formats, and associates
- * them with their relevant drivers. Also has a
- * routine to find the correct driver given a name
- * for it
+ * them with their relevant drivers. Also has a
+ * routine to find the correct driver given a name
+ * for it
*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
static int32_t aout_section_names(char *name, int pass, int *bits)
{
-
+
(void)pass;
/*
static int32_t as86_section_names(char *name, int pass, int *bits)
{
-
+
(void)pass;
/*
else
l -= s->vstart;
}
-
+
if (r->bytes >= 4)
WRITEDLONG(q, l);
else if (r->bytes == 2)
uint8_t *p, mydata[8];
struct Section *s;
int32_t realbytes;
-
-
+
+
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
error(ERR_NONFATAL, "WRT not supported by binary output format");
s = find_section_by_index(segto);
if (!s)
error(ERR_PANIC, "code directed to nonexistent segment?");
-
+
/* "Smart" section-type adaptation code. */
if (!(s->flags & TYPE_DEFINED)) {
if ((type & OUT_TYPMASK) == OUT_RESERVE)
#define EXPORT_SECTION_NAME ".drectve"
#define EXPORT_SECTION_FLAGS INFO_FLAGS
-/*
+/*
#define EXPORT_SECTION_NAME ".text"
#define EXPORT_SECTION_FLAGS TEXT_FLAGS
*/
static int32_t ieee_putlr(struct ieeeFixupp *);
static void ieee_unqualified_name(char *, char *);
-/*
- * pup init
+/*
+ * pup init
*/
static void ieee_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
*
* (ii) `segment' is one of our segments, or a SEG_ABS segment.
* Save the label position for later output of a PUBDEF record.
- *
+ *
*
* (iii) `segment' is not one of our segments. Save the label
* position for later output of an EXTDEF.
*/
ieee_putascii("CO0,%02X%s.\r\n", strlen(boast), boast);
- /*
+ /*
* write processor-specific information
*/
ieee_putascii("AD8,4,L.\r\n");
1900 + thetime->tm_year, thetime->tm_mon + 1,
thetime->tm_mday, thetime->tm_hour, thetime->tm_min,
thetime->tm_sec);
- /*
+ /*
* if debugging, dump file names
*/
for (fn = fnhead; fn && debuginfo; fn = fn->next) {
*/
ieee_putcs(false);
- /*
+ /*
* Write the section headers
*/
seg = seghead;
/* nasm internal data */
struct symbol *next; /* next symbol in the list */
char *name; /* name of this symbol */
- int32_t initial_snum; /* symbol number used above in
+ int32_t initial_snum; /* symbol number used above in
reloc */
int32_t snum; /* true snum for reloc */
* that its default group is group FLAT, even if
* the group FLAT does not explicitly _contain_ the
* segment.
- *
+ *
* When we see this, we must create the group
* `FLAT', containing no segments, if it does not
* already exist; then we must set the default
WRITEDLONG(pd, *(int64_t *)data);
else
WRITESHORT(pd, *(int32_t *)data);
-
+
membufwrite(seg[segto], databuf, bytes);
}
}
/*
- * check it against the text strings in segmenttypes
+ * check it against the text strings in segmenttypes
*/
for (i = 0; i < COUNT_SEGTYPES; i++)
$line =~ s/^\s+//; # Remove leading whitespace
$line =~ s/\s*\#.*$//; # Remove comments and trailing whitespace
next if ($line eq '');
-
+
if ($line =~ /^\%(.*)\*$/) {
push(@cctok, $1);
} elsif ($line =~ /^\%(.*)$/) {
$n += 2;
}
print OUT "};\n\n";
-
+
printf OUT "#define PP_COND(x) ((enum pp_conditional)((x) & 0x%x))\n",
- (scalar(@cond)-1) << 1;
+ (scalar(@cond)-1) << 1;
print OUT "#define PP_IS_COND(x) ((unsigned int)(x) < PP_\U$first_uncond\E)\n";
print OUT "#define PP_NEGATIVE(x) ((x) & 1)\n";
print OUT "\n";
# Paranoia...
verify_hash_table(\%tokens, \@hashinfo);
-
+
($n, $sv, $g) = @hashinfo;
$sv2 = $sv+2;
-
+
die if ($n & ($n-1));
-
+
print OUT "#include \"compiler.h\"\n";
print OUT "#include <inttypes.h>\n";
print OUT "#include <ctype.h>\n";
}
}
print OUT "};\n";
-
+
print OUT "enum preproc_token pp_token_hash(const char *token)\n";
print OUT "{\n";
print OUT " ", defined($h) ? $h : 'UNUSED', ",\n";
}
print OUT " };\n";
-
+
print OUT " static const int16_t hash2[$n] = {\n";
for ($i = 0; $i < $n; $i++) {
my $h = ${$g}[$i*2+1];
print OUT " ", defined($h) ? $h : 'UNUSED', ",\n";
}
print OUT " };\n";
-
+
print OUT " uint32_t k1, k2;\n";
print OUT " uint64_t crc;\n";
# For correct overflow behavior, "ix" should be unsigned of the same
print OUT "\n";
printf OUT " crc = crc64i(UINT64_C(0x%08x%08x), token);\n",
- $$sv[0], $$sv[1];
+ $$sv[0], $$sv[1];
print OUT " k1 = (uint32_t)crc;\n";
print OUT " k2 = (uint32_t)(crc >> 32);\n";
print OUT "\n";
* the substituted parameter. So in the definition
*
* %define a(x,y) ( (x) & ~(y) )
- *
+ *
* the token representing `x' will have its type changed to
* TOK_SMAC_PARAM, but the one representing `y' will be
* TOK_SMAC_PARAM+1.
* Multi-line macro definitions are stored as a linked list of
* these, which is essentially a container to allow several linked
* lists of Tokens.
- *
+ *
* Note that in this module, linked lists are treated as stacks
* wherever possible. For this reason, Lines are _pushed_ on to the
* `expansion' field in MMacro structures, so that the linked list,
};
#define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
-/*
+/*
* These defines are used as the possible return values for do_directive
*/
#define NO_DIRECTIVE_FOUND 0
/*
* this function allocates a new managed block of memory and
- * returns a pointer to the block. The managed blocks are
+ * returns a pointer to the block. The managed blocks are
* deleted only all at once by the delete_Blocks function.
*/
static void *new_Block(size_t size)
{
Blocks *a, *b = &blocks;
- /*
+ /*
* keep in mind that the first block, pointed to by blocks
- * is a static and not dynamically allocated, so we don't
+ * is a static and not dynamically allocated, so we don't
* free it.
*/
while (b) {
}
/*
- * this function creates a new Token and passes a pointer to it
+ * this function creates a new Token and passes a pointer to it
* back to the caller. It sets the type and text elements, and
* also the mac and next elements to NULL.
*/
free_tlist(origline);
return j ^ PP_NEGATIVE(ct);
-
+
fail:
free_tlist(origline);
return -1;
int nparam, Token *expansion)
{
SMacro *smac, **smhead;
-
+
if (smacro_defined(ctx, mname, nparam, &smac, casesense)) {
if (!smac) {
error(ERR_WARNING,
smhead = (SMacro **) hash_findi_add(smacros, mname);
else
smhead = &ctx->localmac;
-
+
smac = nasm_malloc(sizeof(SMacro));
smac->next = *smhead;
*smhead = smac;
smhead = (SMacro **) hash_findi(smacros, mname, NULL);
else
smhead = &ctx->localmac;
-
+
if (smhead) {
/*
* We now have a macro name... go hunt for it.
* find and process preprocessor directive in passed line
* Find out if a line contains a preprocessor directive, and deal
* with it if so.
- *
+ *
* If a directive _is_ found, it is the responsibility of this routine
* (and not the caller) to free_tlist() the line.
*
* @param tline a pointer to the current tokeninzed line linked list
* @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
- *
+ *
*/
static int do_directive(Token * tline)
{
rotate %= (int)mmac->nparam;
if (rotate < 0)
rotate += mmac->nparam;
-
+
mmac->rotate = rotate;
}
return DIRECTIVE_FOUND;
case PP_STRLEN:
casesense = true;
-
+
tline = tline->next;
skip_white_(tline);
tline = expand_id(tline);
if (m && m->in_progress)
m = NULL;
if (!m) { /* in progess or didn't find '(' or wrong nparam */
- /*
+ /*
* Design question: should we handle !tline, which
* indicates missing ')' here, or expand those
* macros anyway, which requires the (t) test a few
- * lines down?
+ * lines down?
*/
nasm_free(params);
nasm_free(paramsize);
void pp_runtime(char *definition)
{
Token *def;
-
+
def = tokenize(definition);
if(do_directive(def) == NO_DIRECTIVE_FOUND)
free_tlist(def);
-
+
}
void pp_extra_stdmac(const char **macros)
*/
struct segment_infonode {
- int dest_seg; /* output segment to be placed into, -1 to
+ int dest_seg; /* output segment to be placed into, -1 to
skip linking this segment */
int32_t reloc; /* segment's relocation factor */
};
/* The current state of segment allocation, including information about
* which output segment numbers have been allocated, and their types and
- * amount of data which has already been allocated inside them.
+ * amount of data which has already been allocated inside them.
*/
struct SegmentHeaderRec outputseg[RDF_MAXSEGS];
int nsegs = 0;
exit(1);
}
- /*
+ /*
* store information about the module, and determine what segments
* it contains, and what we should do with them (determine relocation
* factor if we decide to keep them)
break;
}
- /*
+ /*
* okay, now the relocation is in the segment pointed to by
* cur->seginfo[localseg], and we know everything else is
* okay to go ahead and do the relocation
case RDFREC_FARIMPORT:
/*
* scan the global symbol table for the symbol
- * and associate its location with the segment number
+ * and associate its location with the segment number
* for this module
*/
se = symtabFind(symtab, hr->i.label);
{0xFFFF, 0xFFFF, "invalid segment", 0, 0}
};
-#define getsegconfig(target,number) \
+#define getsegconfig(target,number) \
{ \
int _i; \
int _t = number; \
* The format of the directory will be 'RDLDD' followed by a version
* number, followed by the length of the directory, and then the
* directory, the format of which has not yet been designed.
- * The module name of the directory must be '.dir'.
+ * The module name of the directory must be '.dir'.
*
* All module names beginning with '.' are reserved for possible future
* extensions. The linker ignores all such modules, assuming they have
rewind(lib->fp);
while (!feof(lib->fp)) {
- /*
- * read the module name from the file, and prepend
+ /*
+ * read the module name from the file, and prepend
* the library name and '.' to it.
*/
strcpy(buf, lib->name);
-/* rdoff.c library of routines for manipulating rdoff files
+/* rdoff.c library of routines for manipulating rdoff files
*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
General purpose routines and variables used by the library functions
========================================================================= */
-/*
+/*
* translateint32_t() and translateint16_t()
*
- * translate from little endian to local representation
+ * translate from little endian to local representation
*/
int32_t translateint32_t(int32_t in)
{
#define RDFREC_MODNAME 8
#define RDFREC_COMMON 10
-/*
+/*
* Generic record - contains the type and length field, plus a 128 byte
* array 'data'
*/
char data[128];
};
-/*
+/*
* Relocation record
*/
struct RelocRec {
struct segtabnode *left;
struct segtabnode *right;
- /*
+ /*
* counts of how many are left or right, for use in reorganising
* the tree
*/
if ( !defined($disclass{$dclass}) ) {
$disclass{$dclass} = [];
}
-
+
$disclass{$dclass}->[$x86regno] = $reg;
}
chomp $line;
$line =~ s/\s*(\#.*|)$//;
-
+
next if ( $line eq '' );
process_line($line);
} else /* just an ordinary char */
return tv->t_type = (uint8_t)(*stdscan_bufptr++);
}
-
if ($line =~ /^([A-Z0-9_]+)(|cc)\s/) {
$insn = $1.$2;
($token = $1) =~ tr/A-Z/a-z/;
-
+
if ($2 eq '') {
# Single instruction token
if (!defined($tokens{$token})) {
$reg = $1.$2.$4;
$reg_nr = $2;
$reg_prefix = $1;
- $reg_suffix = $4;
+ $reg_suffix = $4;
} else {
$nregs = 1;
undef $reg_prefix, $reg_suffix;
}
$tokens{$reg} = scalar @tokendata;
push(@tokendata, "\"${reg}\", TOKEN_REG, 0, R_\U${reg}\E");
-
+
if (defined($reg_prefix)) {
$reg_nr++;
$reg = sprintf("%s%u%s", $reg_prefix, $reg_nr, $reg_suffix);
die "Duplicate definition: $token\n";
}
$tokens{$token} = scalar @tokendata;
-
+
$data = $pattern;
if ($data =~ /^(.*)\{(.*)\}(.*)$/) {
my $head = $1, $tail = $3;
my $px = $2;
-
+
$px =~ s/\*/(.*)/g;
if ($token =~ /$px/i) {
$data = $head."\U$1".$tail;
# Paranoia...
verify_hash_table(\%tokens, \@hashinfo);
-
+
($n, $sv, $g) = @hashinfo;
$sv2 = $sv+2;
-
+
die if ($n & ($n-1));
-
+
print "/*\n";
print " * This file is generated from insns.dat, regs.dat and token.dat\n";
print " * by tokhash.pl; do not edit.\n";
print " */\n";
print "\n";
-
+
print "#include \"compiler.h\"\n";
print "#include <string.h>\n";
print "#include \"nasm.h\"\n";
print "#include \"hashtbl.h\"\n";
print "#include \"insns.h\"\n";
print "\n";
-
+
# These somewhat odd sizes and ordering thereof are due to the
# relative ranges of the types; this makes it fit in 16 bytes on
# 64-bit machines and 12 bytes on 32-bit machines.
print " int32_t num;\n";
print "};\n";
print "\n";
-
+
print "int nasm_token_hash(const char *token, struct tokenval *tv)\n";
print "{\n";
-
+
# Put a large value in unused slots. This makes it extremely unlikely
# that any combination that involves unused slot will pass the range test.
# This speeds up rejection of unrecognized tokens, i.e. identifiers.
print "#define UNUSED 16383\n";
-
+
print " static const int16_t hash1[$n] = {\n";
for ($i = 0; $i < $n; $i++) {
my $h = ${$g}[$i*2+0];
print " ", defined($h) ? $h : 'UNUSED', ",\n";
}
print " };\n";
-
+
print " static const int16_t hash2[$n] = {\n";
for ($i = 0; $i < $n; $i++) {
my $h = ${$g}[$i*2+1];
print " ", defined($h) ? $h : 'UNUSED', ",\n";
}
print " };\n";
-
+
printf " static const struct tokendata tokendata[%d] = {\n", scalar(@tokendata);
foreach $d (@tokendata) {
print " { ", $d, " },\n";
}
print " };\n";
-
+
print " uint32_t k1, k2;\n";
print " uint64_t crc;\n";
# For correct overflow behavior, "ix" should be unsigned of the same
print " const struct tokendata *data;\n";
print "\n";
printf " crc = crc64(UINT64_C(0x%08x%08x), token);\n",
- $$sv[0], $$sv[1];
+ $$sv[0], $$sv[1];
print " k1 = (uint32_t)crc;\n";
print " k2 = (uint32_t)(crc >> 32);\n";
print "\n";
print " return tv->t_type = TOKEN_ID;\n";
print "\n";
print " data = &tokendata[ix];\n";
-
+
print " if (strcmp(data->string, token))\n";
print " return tv->t_type = TOKEN_ID;\n";
print "\n";
projects / platform / upstream / nasm.git / commitdiff