This is the AUTHORS file for the NASM project located at:
-http://nasm.2y.net/
+http://nasm.sourceforge.net/
Names should be inserted as follows:
E: alexfru@users.sourceforge.net
D: "-I" paths searched for "incbined" files
D: bugswatting
+
+N: Keith Kanios, aka SpooK
+E: keith@kanios.net
+D: c99 Compliance
+D: General x64 Support
+D: win64 (x86-64 COFF) output format
+D: __BITS__ Standard Macro
+D: Website Maintenance @ http://nasm.sourceforge.net/
-0.98.40
-* fix (?) bug in outobj.c - every 256th "extern" caused Nasm crash
+0.99.00
+-------
+* Added c99 data-type compliance.
+* Added general x86-64 support.
+* Added win64 (x86-64 COFF) output format.
+* Added __BITS__ standard macro which returns current [BITS XX] mode.
+* fix (???) bug in outobj.c - every 256th "extern" caused Nasm crash.
+ (is this during definition or use, I made over 260 externs with obj
+ and could not duplicate the gripe -Keith Kanios)
0.98.39
-------
+2007-04-10 Keith Kanios <keith@kanios.net>
+ * (insns.dat): updated x86-64 general+system instruction set.
+
+2007-04-09 Keith Kanios <keith@kanios.net>
+ * (outrdf.c): added support for 64-bit addressing.
+ * (outrdf2.c): added support for 64-bit addressing.
+
+2007-04-08 Keith Kanios <keith@kanios.net>
+ * (standard.mac): added entry for __BITS__ standard macro.
+ * (preproc.c): added __BITS__ to the standard macro processing.
+
+2007-04-05 Keith Kanios <keith@kanios.net>
+ * (nasm.c): added [BITS 64] for the x86-64 architecture extension.
+ * (nasm.h): added general flags to support the x86-64 architecture.
+ * (nasmlib.h): updated to support the x86-64 architecture.
+ * (nasmlib.c): revamped readnum/readlinenum to support 64-bit.
+ * (assemble.c): modified for the x86-64 architecture extension.
+ * (regs.dat): added x86-64 register extensions; revamped flags.
+ * (insns.dat): added AMD64 instruction set support.
+ * (outbin.c): added support for 64-bit addressing.
+ * (outcoff.c): added win64 (x86-64 COFF) support.
+ * (outform.h): added entry for win64.
+
+2007-03-15 Keith Kanios <keith@kanios.net>
+ * (*.c): added c99 data-type compliance and <inttypes.h> inclusion.
+ * (*.pl): added c99 data-type compliance and <inttypes.h> inclusion.
+ * (*.h): added c99 data-type compliance.
+ * (assemble.h): fixed procedure defintions to sync with respective
+ procedure declarations.
+
2002-05-16 Ed Beroset <beroset@mindspring.com>
* (preproc.c): fixed unterminated macro bug error reporting
* (nasmlib.h): changed strdup's arg to const char *
Makefile.b32 Win32 Borland C++ OK as of NASM 0.98.37
Makefile.bc3 16-bit DOS Borland C++ OK as of NASM 0.98.34
Makefile.bor 16-bit DOS Turbo C (**)
+ Makefile.dcp Win32 Dev-Cpp/MinGW OK as of NASM 0.99.00
Makefile.dj 32-bit DOS DJGPP OK as of NASM 0.98.37
Makefile.djo 32-bit DOS DJGPP "Opus Make" version(**)
Makefile.dl 32-bit DOS cc386 cc386 by David Lindauer
programmers wishing to improve their lovely assembler.
The NASM project is now situated at SourceForge.net, the most
-famous Open Source development center on The Net.
+popular Open Source development site on the Internet.
-Visit our development page at http://nasm.2y.net/ and our
-SF project at http://sf.net/projects/nasm/
+Visit our website at http://nasm.sourceforge.net/ and our
+SourceForge project at http://sourceforge.net/projects/nasm/
See the file CHANGES for the description of changes between revisions.
=============
+F: Extended x64 Support
+D: Full FPU/MMX/SSE* instruction support for x64
+
+F: ELF64 output format
+D: Support for assembling code to the ELF64 output format
+
+F: NDISASM x64 Support
+D: Ability to disassemble respective x64 code
+
+F: General x64 Support
+V: 0.99.00
+R: Keith Kanios
+C: 99%
+D: Support for assembling 64-bit code to various output formats
+
+F: win64 (x86-64 COFF) output format
+V: 0.99.00
+R: Keith Kanios
+C: 99%
+D: Support for assembling code to the win64 output format
+
+F: c99 data-type compliance
+V: 0.99.00
+R: Keith Kanios
+C: 99%
+D: Revamped entire source-code base data-types for compliance
+D: with c99 (inttypes.h)
+
+F: __BITS__ Standard Macro
+V: 0.99.00
+R: Keith Kanios
+C: 100%
+D: __BITS__ standard macro that returns current [BITS XX] mode
+
F: i18n via gettext
+D: kkanios: be careful about that, stick to UTF-8 if anything
F: Convert shallow code model to deep code model
D: Tired of messing between lots of unrelated files (especially .c/.h stuff)
F: Move output modules out*.c to output/ subdir
R: madfire
-C: 10%
+C: 100%
== THESE ARE FROM old NASM's Wishlist
== THEY NEED SEVERE REVISING (seems they weren't updated for a couple of years or so)
V: 0.98
D: hpa: Does it really make sense to have a whole instruction set
D: reference packaged with the assembler?
+D: kkanios: Yes, for me it was a great help... and still is.
F: prototypes of lrotate don't match in test/*. Fix.
V: 0.98
* \44, \45, \46 - select between \3[012] and \4[012] depending on 16/32 bit
* assembly mode or the address-size override on the operand
* \50, \51, \52 - a byte relative operand, from operand 0, 1 or 2
+ * \54, \55, \56 - a qword immediate operand, from operand 0, 1 or 2
* \60, \61, \62 - a word relative operand, from operand 0, 1 or 2
* \64, \65, \66 - select between \6[012] and \7[012] depending on 16/32 bit
* assembly mode or the operand-size override on the operand
* \140,\141,\142 - an immediate dword or signed byte for operand 0, 1, or 2
* \143,\144,\145 - or 2 (s-field) into next opcode byte if operand 0, 1, or 2
* is a signed byte rather than a dword.
+ * \150,\151,\152 - an immediate qword or signed byte for operand 0, 1, or 2
+ * \153,\154,\155 - or 2 (s-field) into next opcode byte if operand 0, 1, or 2
+ * is a signed byte rather than a qword.
* \2ab - a ModRM, calculated on EA in operand a, with the spare
* field equal to digit b.
* \30x - might be an 0x67 byte, depending on the address size of
* \310 - indicates fixed 16-bit address size, i.e. optional 0x67.
* \311 - indicates fixed 32-bit address size, i.e. optional 0x67.
* \312 - (disassembler only) marker on LOOP, LOOPxx instructions.
+ * \313 - indicates fixed 64-bit address size, no REX required.
* \320 - indicates fixed 16-bit operand size, i.e. optional 0x66.
* \321 - indicates fixed 32-bit operand size, i.e. optional 0x66.
* \322 - indicates that this instruction is only valid when the
* operand size is the default (instruction to disassembler,
* generates no code in the assembler)
+ * \323 - indicates fixed 64-bit operand size, REX on extensions, only.
+ * \324 - indicates 64-bit operand size requiring REX prefix.
* \330 - a literal byte follows in the code stream, to be added
* to the condition code value of the instruction.
* \331 - instruction not valid with REP prefix. Hint for
* \332 - disassemble a rep (0xF3 byte) prefix as repe not rep.
* \333 - REP prefix (0xF3 byte); for SSE instructions. Not encoded
* as a literal byte in order to aid the disassembler.
- * \340 - reserve <operand 0> bytes of uninitialised storage.
+ * \340 - reserve <operand 0> bytes of uninitialized storage.
* Operand 0 had better be a segmentless constant.
* \370,\371,\372 - match only if operand 0 meets byte jump criteria.
* 370 is used for Jcc, 371 is used for JMP.
#include <stdio.h>
#include <string.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
#include "assemble.h"
#include "insns.h"
#include "preproc.h"
+#include "regvals.c"
extern struct itemplate *nasm_instructions[];
typedef struct {
- int sib_present; /* is a SIB byte necessary? */
- int bytes; /* # of bytes of offset needed */
- int size; /* lazy - this is sib+bytes+1 */
- unsigned char modrm, sib; /* the bytes themselves */
+ int sib_present; /* is a SIB byte necessary? */
+ int bytes; /* # of bytes of offset needed */
+ int size; /* lazy - this is sib+bytes+1 */
+ uint8_t modrm, sib, rex, rip; /* the bytes themselves */
} ea;
-static unsigned long cpu; /* cpu level received from nasm.c */
+static uint32_t cpu; /* cpu level received from nasm.c */
static efunc errfunc;
static struct ofmt *outfmt;
static ListGen *list;
-static long calcsize(long, long, int, insn *, const char *);
-static void gencode(long, long, int, insn *, const char *, long);
+static int32_t calcsize(int32_t, int32_t, int, insn *, const int8_t *);
+static void gencode(int32_t, int32_t, int, insn *, const int8_t *, int32_t);
static int regval(operand * o);
-static int matches(struct itemplate *, insn *);
+static int regflag(operand * o);
+static int matches(struct itemplate *, insn *, int bits);
static ea *process_ea(operand *, ea *, int, int, int);
static int chsize(operand *, int);
* in order to pass a copy of the data off to the listing file
* generator at the same time.
*/
-static void out(long offset, long segto, const void *data,
- unsigned long type, long segment, long wrt)
+static void out(int32_t offset, int32_t segto, const void *data,
+ uint32_t type, int32_t segment, int32_t wrt)
{
- static long lineno = 0; /* static!!! */
- static char *lnfname = NULL;
+ static int32_t lineno = 0; /* static!!! */
+ static int8_t *lnfname = NULL;
if ((type & OUT_TYPMASK) == OUT_ADDRESS) {
if (segment != NO_SEG || wrt != NO_SEG) {
*/
list->output(offset, data, type);
} else {
- unsigned char p[4], *q = p;
+ uint8_t p[8], *q = p;
/*
* This is a non-relocated address, and we're going to
* convert it into RAWDATA format.
*/
if ((type & OUT_SIZMASK) == 4) {
- WRITELONG(q, *(long *)data);
+ WRITELONG(q, *(int32_t *)data);
list->output(offset, p, OUT_RAWDATA + 4);
+ } else if ((type & OUT_SIZMASK) == 8) {
+ WRITEDLONG(q, *(int64_t *)data);
+ list->output(offset, p, OUT_RAWDATA + 8);
} else {
- WRITESHORT(q, *(long *)data);
+ WRITESHORT(q, *(int32_t *)data);
list->output(offset, p, OUT_RAWDATA + 2);
}
}
outfmt->output(segto, data, type, segment, wrt);
}
-static int jmp_match(long segment, long offset, int bits,
- insn * ins, const char *code)
+static int jmp_match(int32_t segment, int32_t offset, int bits,
+ insn * ins, const int8_t *code)
{
- long isize;
- unsigned char c = code[0];
+ int32_t isize;
+ uint8_t c = code[0];
if (c != 0370 && c != 0371)
return 0;
return 0;
}
-long assemble(long segment, long offset, int bits, unsigned long cp,
+int32_t assemble(int32_t segment, int32_t offset, int bits, uint32_t cp,
insn * instruction, struct ofmt *output, efunc error,
ListGen * listgen)
{
struct itemplate *temp;
int j;
int size_prob;
- long insn_end;
- long itimes;
- long start = offset;
- long wsize = 0; /* size for DB etc. */
+ int32_t insn_end;
+ int32_t itimes;
+ int32_t start = offset;
+ int32_t wsize = 0; /* size for DB etc. */
errfunc = error; /* to pass to other functions */
cpu = cp;
if (wsize) {
extop *e;
- long t = instruction->times;
+ int32_t t = instruction->times;
if (t < 0)
errfunc(ERR_PANIC,
"instruction->times < 0 (%ld) in assemble()", t);
errfunc(ERR_NONFATAL,
"one-byte relocation attempted");
else {
- unsigned char out_byte = e->offset;
+ uint8_t out_byte = e->offset;
out(offset, segment, &out_byte,
OUT_RAWDATA + 1, NO_SEG, NO_SEG);
}
}
if (instruction->opcode == I_INCBIN) {
- static char fname[FILENAME_MAX];
+ static int8_t fname[FILENAME_MAX];
FILE *fp;
- long len;
- char *prefix = "", *combine;
- char **pPrevPath = NULL;
+ int32_t len;
+ int8_t *prefix = "", *combine;
+ int8_t **pPrevPath = NULL;
len = FILENAME_MAX - 1;
if (len > instruction->eops->stringlen)
strncpy(fname, instruction->eops->stringval, len);
fname[len] = '\0';
- while (1) { /* added by alexfru: 'incbin' uses include paths */
+ while (1) { /* added by alexfru: 'incbin' uses include paths */
combine = nasm_malloc(strlen(prefix) + len + 1);
strcpy(combine, prefix);
strcat(combine, fname);
error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
fname);
else {
- static char buf[2048];
- long t = instruction->times;
- long base = 0;
+ static int8_t buf[2048];
+ int32_t t = instruction->times;
+ int32_t base = 0;
len = ftell(fp);
if (instruction->eops->next) {
list->output(offset, NULL, OUT_RAWDATA);
list->uplevel(LIST_INCBIN);
while (t--) {
- long l;
+ int32_t l;
fseek(fp, base, SEEK_SET);
l = len;
while (l > 0) {
- long m =
+ int32_t m =
fread(buf, 1, (l > sizeof(buf) ? sizeof(buf) : l),
fp);
if (!m) {
}
size_prob = FALSE;
- temp = nasm_instructions[instruction->opcode];
- while (temp->opcode != -1) {
- int m = matches(temp, instruction);
+
+ 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);
if (m == 100) { /* matches! */
- const char *codes = temp->code;
- long insn_size = calcsize(segment, offset, bits,
+ const int8_t *codes = temp->code;
+ int32_t insn_size = calcsize(segment, offset, bits,
instruction, codes);
itimes = instruction->times;
if (insn_size < 0) /* shouldn't be, on pass two */
else
while (itimes--) {
for (j = 0; j < instruction->nprefix; j++) {
- unsigned char c = 0;
+ uint8_t c = 0;
switch (instruction->prefixes[j]) {
case P_LOCK:
c = 0xF0;
"segr6 and segr7 cannot be used as prefixes");
break;
case P_A16:
+ if (bits == 64) {
+ error(ERR_PANIC, "16-bit addressing is depreciated in long mode");
+ break;
+ }
if (bits != 16)
c = 0x67;
break;
c = 0x66;
break;
case P_O32:
- if (bits != 32)
+ if (bits == 16)
c = 0x66;
break;
default:
NO_SEG, NO_SEG);
offset++;
}
- }
+ }
insn_end = offset + insn_size;
gencode(segment, offset, bits, instruction, codes,
insn_end);
} else if (m > 0 && m > size_prob) {
size_prob = m;
}
- temp++;
+// temp++;
}
if (temp->opcode == -1) { /* didn't match any instruction */
error(ERR_NONFATAL, "mismatch in operand sizes");
else if (size_prob == 3)
error(ERR_NONFATAL, "no instruction for this cpu level");
+ else if (size_prob == 4)
+ error(ERR_NONFATAL, "instruction depreciated in long mode");
else
error(ERR_NONFATAL,
"invalid combination of opcode and operands");
return 0;
}
-long insn_size(long segment, long offset, int bits, unsigned long cp,
+int32_t insn_size(int32_t segment, int32_t offset, int bits, uint32_t cp,
insn * instruction, efunc error)
{
struct itemplate *temp;
instruction->opcode == I_DD ||
instruction->opcode == I_DQ || instruction->opcode == I_DT) {
extop *e;
- long isize, osize, wsize = 0; /* placate gcc */
+ int32_t isize, osize, wsize = 0; /* placate gcc */
isize = 0;
switch (instruction->opcode) {
}
for (e = instruction->eops; e; e = e->next) {
- long align;
+ int32_t align;
osize = 0;
if (e->type == EOT_DB_NUMBER)
}
if (instruction->opcode == I_INCBIN) {
- char fname[FILENAME_MAX];
+ int8_t fname[FILENAME_MAX];
FILE *fp;
- long len;
- char *prefix = "", *combine;
- char **pPrevPath = NULL;
+ int32_t len;
+ int8_t *prefix = "", *combine;
+ int8_t **pPrevPath = NULL;
len = FILENAME_MAX - 1;
if (len > instruction->eops->stringlen)
return 0; /* if we're here, there's an error */
}
- temp = nasm_instructions[instruction->opcode];
- while (temp->opcode != -1) {
- int m = matches(temp, instruction);
+ 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);
if (m == 100) {
/* we've matched an instruction. */
- long isize;
- const char *codes = temp->code;
+ int32_t isize;
+ const int8_t *codes = temp->code;
int j;
isize = calcsize(segment, offset, bits, instruction, codes);
if ((instruction->prefixes[j] != P_A16 &&
instruction->prefixes[j] != P_O16 && bits == 16) ||
(instruction->prefixes[j] != P_A32 &&
- instruction->prefixes[j] != P_O32 && bits == 32)) {
+ instruction->prefixes[j] != P_O32 && bits == 32) ||
+ (instruction->prefixes[j] == P_A32 &&
+ instruction->prefixes[j] != P_O32 && bits == 64)) {
isize++;
}
}
return isize * instruction->times;
}
- temp++;
}
return -1; /* didn't match any instruction */
}
and return the signed value*/
static int is_sbyte(insn * ins, int op, int size)
{
- signed long v;
+ int32_t v;
int ret;
ret = !(ins->forw_ref && ins->oprs[op].opflags) && /* dead in the water on forward reference or External */
v = ins->oprs[op].offset;
if (size == 16)
- v = (signed short)v; /* sign extend if 16 bits */
+ v = (int16_t)v; /* sign extend if 16 bits */
return ret && v >= -128L && v <= 127L;
}
-static long calcsize(long segment, long offset, int bits,
- insn * ins, const char *codes)
+static int32_t calcsize(int32_t segment, int32_t offset, int bits,
+ insn * ins, const int8_t *codes)
{
- long length = 0;
- unsigned char c;
+ int32_t length = 0;
+ uint8_t c;
+ int t;
+ ins->rex = 0; /* Ensure REX is reset */
+ int rex_mask = 0xFF;
(void)segment; /* Don't warn that this parameter is unused */
(void)offset; /* Don't warn that this parameter is unused */
case 010:
case 011:
case 012:
+ if (bits == 64) {
+ t = regval(&ins->oprs[c - 010]);
+ if (t >= 0400 && t < 0500) { /* Calculate REX.B */
+ if (t < 0410 || (t >= 0440 && t < 0450))
+ ins->rex |= 0xF0; /* Set REX.0 */
+ else
+ ins->rex |= 0xF1; /* Set REX.B */
+ if (t >= 0440)
+ ins->rex |= 0xF8; /* Set REX.W */
+ }
+ }
codes++, length++;
break;
case 017:
case 034:
case 035:
case 036:
- if (ins->oprs[c - 034].type & (BITS16 | BITS32))
+ if (ins->oprs[c - 034].type & (BITS16 | BITS32 | BITS64))
length += (ins->oprs[c - 034].type & BITS16) ? 2 : 4;
else
length += (bits == 16) ? 2 : 4;
case 045:
case 046:
length += ((ins->oprs[c - 044].addr_size ?
- ins->oprs[c - 044].addr_size : bits) ==
- 16 ? 2 : 4);
+ ins->oprs[c - 044].addr_size : bits) >> 3);
break;
case 050:
case 051:
case 052:
length++;
break;
+ case 054:
+ case 055:
+ case 056:
+ length += 8; /* MOV reg64/imm */
+ break;
case 060:
case 061:
case 062:
case 064:
case 065:
case 066:
- if (ins->oprs[c - 064].type & (BITS16 | BITS32))
+ if (ins->oprs[c - 064].type & (BITS16 | BITS32 | BITS64))
length += (ins->oprs[c - 064].type & BITS16) ? 2 : 4;
else
length += (bits == 16) ? 2 : 4;
break;
case 0300:
case 0301:
- case 0302:
+ case 0302:
+ if (bits == 64) { /* Calculate REX */
+ t = ins->oprs[c - 0300].basereg;
+ if (t >= EXPR_REG_START && t < REG_ENUM_LIMIT) {
+ t = regvals[t];
+ if ((t >= 0410 && t < 0440) || (t >= 0450 && t < 0500)) {
+ ins->rex |= 0xF1; /* Set REX.B */
+ }
+ }
+ }
length += chsize(&ins->oprs[c - 0300], bits);
break;
case 0310:
- length += (bits == 32);
+ length += (bits != 16);
break;
case 0311:
- length += (bits == 16);
+ length += (bits != 32);
break;
case 0312:
+ break;
+ case 0313:
+ length -= 1;
break;
case 0320:
- length += (bits == 32);
+ length += (bits != 16);
break;
case 0321:
length += (bits == 16);
break;
case 0322:
break;
+ case 0323:
+ rex_mask = 0x07;
+ break;
+ case 0324:
+ length++;
+ break;
case 0330:
codes++, length++;
break;
default: /* can't do it by 'case' statements */
if (c >= 0100 && c <= 0277) { /* it's an EA */
ea ea_data;
+ int rfield;
+ ea_data.rex = 0; /* Ensure ea.REX is initially 0 */
+
+ if (bits == 64) {
+ if (c <= 0177) /* pick rfield from operand b */
+ rfield = regval(&ins->oprs[c & 7]);
+ else
+ rfield = c & 7;
+ } else
+ rfield = 0;
+
if (!process_ea
- (&ins->oprs[(c >> 3) & 7], &ea_data, bits, 0,
- ins->forw_ref)) {
+ (&ins->oprs[(c >> 3) & 7], &ea_data, bits,
+ rfield, ins->forw_ref)) {
errfunc(ERR_NONFATAL, "invalid effective address");
return -1;
- } else
+ } else {
+ if (bits == 64)
+ ins->rex |= ea_data.rex;
length += ea_data.size;
+ }
} else
errfunc(ERR_PANIC, "internal instruction table corrupt"
": instruction code 0x%02X given", c);
}
- return length;
-}
-static void gencode(long segment, long offset, int bits,
- insn * ins, const char *codes, long insn_end)
+ if (bits == 64) {
+ ins->rex &= rex_mask;
+ if (ins->rex)
+ length += 1;
+ }
+
+return length; }
+
+static void gencode(int32_t segment, int32_t offset, int bits,
+ insn * ins, const int8_t *codes, int32_t insn_end)
{
- static char condval[] = { /* conditional opcodes */
+ static int8_t condval[] = { /* conditional opcodes */
0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2,
0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5,
0x0, 0xA, 0xA, 0xB, 0x8, 0x4
};
- unsigned char c;
- unsigned char bytes[4];
- long data, size;
-
+ uint8_t c;
+ uint8_t bytes[4];
+ int32_t size;
+ int64_t data;
+
while (*codes)
switch (c = *codes++) {
case 01:
case 02:
case 03:
+ if(ins->rex && (bits == 64)) { /* REX Supercedes all other Prefixes */
+ ins->rex = (ins->rex&0x0F)+0x40;
+ out(offset, segment, &ins->rex, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
+ ins->rex = 0;
+ offset += 1;
+ }
out(offset, segment, codes, OUT_RAWDATA + c, NO_SEG, NO_SEG);
codes += c;
offset += c;
case 010:
case 011:
case 012:
- bytes[0] = *codes++ + regval(&ins->oprs[c - 010]);
+ if(ins->rex && (bits == 64)) { /* REX Supercedes all other Prefixes */
+ ins->rex = (ins->rex&0x0F)+0x40;
+ out(offset, segment, &ins->rex, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
+ ins->rex = 0;
+ offset += 1;
+ }
+ bytes[0] = *codes++ + ((regval(&ins->oprs[c - 010])) & 7);
out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
offset += 1;
break;
case 046:
data = ins->oprs[c - 044].offset;
size = ((ins->oprs[c - 044].addr_size ?
- ins->oprs[c - 044].addr_size : bits) == 16 ? 2 : 4);
+ ins->oprs[c - 044].addr_size : bits) >> 3);
if (size == 2 && (data < -65536L || data > 65535L))
errfunc(ERR_WARNING, "word value exceeds bounds");
out(offset, segment, &data, OUT_ADDRESS + size,
out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
offset += 1;
break;
+
+ case 054:
+ case 055:
+ case 056:
+ data = (int64_t)ins->oprs[c - 054].offset;
+ out(offset, segment, &data, OUT_ADDRESS + 8,
+ ins->oprs[c - 054].segment, ins->oprs[c - 054].wrt);
+ offset += 8;
+ break;
case 060:
case 061:
case 064:
case 065:
case 066:
- if (ins->oprs[c - 064].type & (BITS16 | BITS32))
+ if (ins->oprs[c - 064].type & (BITS16 | BITS32 | BITS64))
size = (ins->oprs[c - 064].type & BITS16) ? 2 : 4;
else
size = (bits == 16) ? 2 : 4;
if (ins->oprs[c - 064].segment != segment) {
- long reltype = (size == 2 ? OUT_REL2ADR : OUT_REL4ADR);
+ int32_t reltype = (size == 2 ? OUT_REL2ADR : OUT_REL4ADR);
data = ins->oprs[c - 064].offset;
out(offset, segment, &data, reltype + insn_end - offset,
ins->oprs[c - 064].segment, ins->oprs[c - 064].wrt);
case 0133:
case 0134:
case 0135:
+ if(ins->rex && (bits == 64)) { /* REX Supercedes all other Prefixes */
+ ins->rex = (ins->rex&0x0F)+0x40;
+ out(offset, segment, &ins->rex, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
+ ins->rex = 0;
+ offset += 1;
+ }
codes++;
bytes[0] = *codes++;
if (is_sbyte(ins, c - 0133, 16))
case 0143:
case 0144:
case 0145:
+ if(ins->rex && (bits == 64)) { /* REX Supercedes all other Prefixes */
+ ins->rex = (ins->rex&0x0F)+0x40;
+ out(offset, segment, &ins->rex, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
+ ins->rex = 0;
+ offset += 1;
+ }
codes++;
bytes[0] = *codes++;
if (is_sbyte(ins, c - 0143, 32))
break;
case 0310:
- if (bits == 32) {
+ if (bits != 16) {
*bytes = 0x67;
out(offset, segment, bytes,
OUT_RAWDATA + 1, NO_SEG, NO_SEG);
break;
case 0311:
- if (bits == 16) {
+ if (bits != 32) {
*bytes = 0x67;
out(offset, segment, bytes,
OUT_RAWDATA + 1, NO_SEG, NO_SEG);
case 0312:
break;
+ case 0313:
+ ins->rex = 0;
+ break;
+
case 0320:
- if (bits == 32) {
+ if (bits != 16) {
*bytes = 0x66;
out(offset, segment, bytes,
OUT_RAWDATA + 1, NO_SEG, NO_SEG);
break;
case 0322:
+ case 0323:
+ break;
+
+ case 0324:
+ ins->rex |= 0xF8;
break;
-
+
case 0330:
*bytes = *codes++ ^ condval[ins->condition];
out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
if (ins->oprs[0].segment != NO_SEG)
errfunc(ERR_PANIC, "non-constant BSS size in pass two");
else {
- long size = ins->oprs[0].offset << (c - 0340);
+ int32_t size = ins->oprs[0].offset << (c - 0340);
if (size > 0)
out(offset, segment, NULL,
OUT_RESERVE + size, NO_SEG, NO_SEG);
break;
default: /* can't do it by 'case' statements */
- if (c >= 0100 && c <= 0277) { /* it's an EA */
+ if ( c >= 0100 && c <= 0277) { /* it's an EA */
ea ea_data;
int rfield;
- unsigned char *p;
- long s;
-
+ uint8_t *p;
+ int32_t s;
+
if (c <= 0177) /* pick rfield from operand b */
rfield = regval(&ins->oprs[c & 7]);
else /* rfield is constant */
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 2:
case 4:
data = ins->oprs[(c >> 3) & 7].offset;
- out(offset, segment, &data,
- OUT_ADDRESS + ea_data.bytes,
+ out(offset, segment, &data, /* RIP = Relative, not Absolute */
+ (ea_data.rip ? OUT_REL4ADR : OUT_ADDRESS) + ea_data.bytes,
ins->oprs[(c >> 3) & 7].segment,
ins->oprs[(c >> 3) & 7].wrt);
s += ea_data.bytes;
}
}
-#include "regvals.c"
-
static int regval(operand * o)
{
if (o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT) {
return regvals[o->basereg];
}
-static int matches(struct itemplate *itemp, insn * instruction)
+static int matches(struct itemplate *itemp, insn * instruction, int bits)
{
- int i, size[3], asize, oprs, ret;
+ int i, b, x, size[3], asize, oprs, ret;
ret = 100;
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
*/
(instruction->oprs[i].type & SIZE_MASK))
return 0;
else
-/* ret = 1; */
return 1;
}
size[i] = BITS16;
} else if (itemp->flags & IF_SD) {
size[i] = BITS32;
+ } else if (itemp->flags & IF_SQ) {
+ if (bits != 64)
+ return 2;
+ size[i] = BITS64;
}
} else {
asize = 0;
} else if (itemp->flags & IF_SD) {
asize = BITS32;
oprs = itemp->operands;
+ } else if (itemp->flags & IF_SQ) {
+ if (bits != 64)
+ return 2;
+ asize = BITS64;
+ oprs = itemp->operands;
}
size[0] = size[1] = size[2] = asize;
}
-
+
if (itemp->flags & (IF_SM | IF_SM2)) {
oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands);
asize = 0;
oprs = itemp->operands;
}
- for (i = 0; i < itemp->operands; i++)
+ for (i = 0; i < itemp->operands; i++) {
if (!(itemp->opd[i] & SIZE_MASK) &&
(instruction->oprs[i].type & SIZE_MASK & ~size[i]))
-/* ret = 2; */
return 2;
+ if ( (((itemp->opd[i] & SIZE_MASK) == BITS64) ||
+ ((instruction->oprs[i].type & SIZE_MASK) == BITS64))
+ && bits != 64)
+ return 2;
+
+ x = instruction->oprs[i].indexreg;
+ b = instruction->oprs[i].basereg;
+
+ if (x != -1 && x >= EXPR_REG_START && x < REG_ENUM_LIMIT)
+ x = regvals[x];
+ if (b != -1 && b >= EXPR_REG_START && b < REG_ENUM_LIMIT)
+ b = regvals[b];
+
+ if (((b >= 0400 && b <= 0500) || (x >= 0400 && x < 0500)) && bits != 64)
+ return 2;
+ }
+
/*
* Check template is okay at the set cpu level
*/
- if ((itemp->flags & IF_PLEVEL) > cpu)
+ if (((itemp->flags & IF_PLEVEL) > cpu))
return 3;
+
+ /*
+ * Check if instruction is available in long mode
+ */
+ if ((itemp->flags & IF_NOLONG) && (bits == 64))
+ return 4;
/*
* Check if special handling needed for Jumps
*/
- if ((unsigned char)(itemp->code[0]) >= 0370)
+ if ((uint8_t)(itemp->code[0]) >= 0370)
return 99;
return ret;
static ea *process_ea(operand * input, ea * output, int addrbits,
int rfield, int forw_ref)
{
- if (!(REGISTER & ~input->type)) { /* it's a single register */
- static int regs[] = {
- R_AL, R_CL, R_DL, R_BL, R_AH, R_CH, R_DH, R_BH,
- R_AX, R_CX, R_DX, R_BX, R_SP, R_BP, R_SI, R_DI,
- R_EAX, R_ECX, R_EDX, R_EBX, R_ESP, R_EBP, R_ESI, R_EDI,
- R_MM0, R_MM1, R_MM2, R_MM3, R_MM4, R_MM5, R_MM6, R_MM7,
- R_XMM0, R_XMM1, R_XMM2, R_XMM3, R_XMM4, R_XMM5, R_XMM6, R_XMM7
- };
+
+ int rip = FALSE; /* Used for RIP-relative addressing */
+
+
+ if (!(REGISTER & ~input->type)) { /* register direct */
int i;
-
- for (i = 0; i < elements(regs); i++)
- if (input->basereg == regs[i])
- break;
- if (i < elements(regs)) {
- output->sib_present = FALSE; /* no SIB necessary */
- output->bytes = 0; /* no offset necessary either */
- output->modrm = 0xC0 | (rfield << 3) | (i & 7);
- } else
+ if ( input->basereg < EXPR_REG_START /* Verify as Register */
+ || input->basereg >= REG_ENUM_LIMIT)
return NULL;
+ i = regvals[input->basereg];
+ if ( i >= 0100 && i < 0210) /* GPR's, MMX & XMM only */
+ return NULL;
+
+ if (i >= 0400 && i < 0500) { /* Calculate REX.B */
+ if (i < 0410 || (i >= 0440 && i < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF1; /* Set REX.B */
+ if (i >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
+ if ((rfield >= 0400 && rfield < 0500) || /* Calculate REX.R */
+ (rfield >= 0120 && rfield < 0200 && /* Include CR/DR/TR... */
+ !(rfield & 0010))) { /* ... extensions, only */
+ if ((rfield >= 0400 && rfield < 0410) || (rfield >= 0440 && rfield < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF4; /* Set REX.R */
+ if (rfield >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
+ output->sib_present = FALSE; /* no SIB necessary */
+ output->bytes = 0; /* no offset necessary either */
+ output->modrm = 0xC0 | ((rfield & 7) << 3) | (i & 7);
} else { /* it's a memory reference */
+
if (input->basereg == -1
&& (input->indexreg == -1 || input->scale == 0)) {
/* it's a pure offset */
if (input->addr_size)
addrbits = input->addr_size;
+
+ if (rfield >= 0400 && rfield < 0500) { /* Calculate REX.R */
+ if (rfield < 0410 || (rfield >= 0440 && rfield < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF4; /* Set REX.R */
+ if (rfield >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
output->sib_present = FALSE;
- output->bytes = (addrbits == 32 ? 4 : 2);
- output->modrm = (addrbits == 32 ? 5 : 6) | (rfield << 3);
+ output->bytes = (addrbits != 16 ? 4 : 2);
+ output->modrm = (addrbits != 16 ? 5 : 6) | ((rfield & 7) << 3);
} else { /* it's an indirection */
int i = input->indexreg, b = input->basereg, s = input->scale;
- long o = input->offset, seg = input->segment;
+ int32_t o = input->offset, seg = input->segment;
int hb = input->hintbase, ht = input->hinttype;
int t;
+ int it, bt;
if (s == 0)
i = -1; /* make this easy, at least */
+
+ if (i != -1 && i >= EXPR_REG_START
+ && i < REG_ENUM_LIMIT)
+ it = regvals[i];
+ else
+ it = -1;
+
+ if (b != -1 && b >= EXPR_REG_START
+ && b < REG_ENUM_LIMIT)
+ bt = regvals[b];
+ else
+ bt = -1;
+
+ /* check for a 32/64-bit memory reference... */
+ if ((it >= 0020 && it < 0030) || (it >= 0430 && it < 0460) ||
+ (bt >= 0020 && bt < 0030) || (bt >= 0430 && bt < 0460) ||
+ bt == 0500) {
+ /* it must be a 32/64-bit memory reference. Firstly we have
+ * to check that all registers involved are type E/Rxx. */
+ t = 1;
+ if (it != -1) {
+ if (it < 0020 || (it >= 0030 && it < 0430) || it >= 0460)
+ return NULL;
+ if (it >= 0440)
+ t = 2;
+ else
+ t = 0;
+ }
- if (i == R_EAX || i == R_EBX || i == R_ECX || i == R_EDX
- || i == R_EBP || i == R_ESP || i == R_ESI || i == R_EDI
- || b == R_EAX || b == R_EBX || b == R_ECX || b == R_EDX
- || b == R_EBP || b == R_ESP || b == R_ESI || b == R_EDI) {
- /* it must be a 32-bit memory reference. Firstly we have
- * to check that all registers involved are type Exx. */
- if (i != -1 && i != R_EAX && i != R_EBX && i != R_ECX
- && i != R_EDX && i != R_EBP && i != R_ESP && i != R_ESI
- && i != R_EDI)
- return NULL;
- if (b != -1 && b != R_EAX && b != R_EBX && b != R_ECX
- && b != R_EDX && b != R_EBP && b != R_ESP && b != R_ESI
- && b != R_EDI)
- return NULL;
-
+ if (bt != -1) {
+ if (bt < 0020 || (bt >= 0030 && bt < 0430) || (bt >= 0460 && bt < 0500))
+ return NULL;
+ if (bt == 0500) {
+ bt = b = -1;
+ rip = TRUE;
+ } else if (bt >= 0440) {
+ if (t < 1)
+ return NULL;
+ } else {
+ if (t > 1)
+ return NULL;
+ }
+ }
+
/* While we're here, ensure the user didn't specify WORD. */
if (input->addr_size == 16)
return NULL;
- /* now reorganise base/index */
- if (s == 1 && b != i && b != -1 && i != -1 &&
- ((hb == b && ht == EAH_NOTBASE)
- || (hb == i && ht == EAH_MAKEBASE)))
- t = b, b = i, i = t; /* swap if hints say so */
- if (b == i) /* convert EAX+2*EAX to 3*EAX */
- b = -1, s++;
- if (b == -1 && s == 1 && !(hb == i && ht == EAH_NOTBASE))
- b = i, i = -1; /* make single reg base, unless hint */
- if (((s == 2 && i != R_ESP
+ /* now reorganize base/index */
+ if (s == 1 && bt != it && bt != -1 && it != -1 &&
+ ((hb == bt && ht == EAH_NOTBASE)
+ || (hb == it && ht == EAH_MAKEBASE)))
+ t = bt, bt = it, it = t; /* swap if hints say so */
+ if (bt == it) /* convert EAX+2*EAX to 3*EAX */
+ bt = -1, s++;
+ if (bt == -1 && s == 1 && !(hb == it && ht == EAH_NOTBASE))
+ bt = i, it = -1; /* make single reg base, unless hint */
+ if (((s == 2 && (it & 7) != (REG_NUM_ESP & 7)
&& !(input->eaflags & EAF_TIMESTWO)) || s == 3
- || s == 5 || s == 9) && b == -1)
- b = i, s--; /* convert 3*EAX to EAX+2*EAX */
- if (i == -1 && b != R_ESP
+ || s == 5 || s == 9) && bt == -1)
+ bt = it, s--; /* convert 3*EAX to EAX+2*EAX */
+ if (it == -1 && (bt & 7) != (REG_NUM_ESP & 7)
&& (input->eaflags & EAF_TIMESTWO))
- i = b, b = -1, s = 1;
+ it = bt, bt = -1, s = 1;
/* convert [NOSPLIT EAX] to sib format with 0x0 displacement */
- if (s == 1 && i == R_ESP) /* swap ESP into base if scale is 1 */
- i = b, b = R_ESP;
- if (i == R_ESP
- || (s != 1 && s != 2 && s != 4 && s != 8 && i != -1))
+ if (s == 1 && (it & 7) == (REG_NUM_ESP & 7)) /* swap ESP into base if scale is 1 */
+ t = it, it = bt, bt = t;
+ if ((it & 7) == (REG_NUM_ESP & 7)
+ || (s != 1 && s != 2 && s != 4 && s != 8 && it != -1))
return NULL; /* wrong, for various reasons */
- if (i == -1 && b != R_ESP) { /* no SIB needed */
+ if (i >= 0400 && i < 0500) { /* Calculate REX.I */
+ if (i < 0410 || (i >= 0440 && i < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF2; /* Set REX.I */
+ if (i >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
+ if (b >= 0400 && b < 0500) { /* Calculate REX.B */
+ if (b < 0410 || (b >= 0440 && b < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF1; /* Set REX.B */
+ if (b >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
+ if (rfield >= 0400 && rfield < 0500) { /* Calculate REX.R */
+ if (rfield < 0410 || (rfield >= 0440 && rfield < 0450))
+ output->rex |= 0xF0; /* Set REX.0 */
+ else
+ output->rex |= 0xF4; /* Set REX.R */
+ if (rfield >= 0440)
+ output->rex |= 0xF8; /* Set REX.W */
+ }
+
+ if (it == -1 && (bt & 7) != (REG_NUM_ESP & 7)) { /* no SIB needed */
int mod, rm;
- switch (b) {
- case R_EAX:
- rm = 0;
- break;
- case R_ECX:
- rm = 1;
- break;
- case R_EDX:
- rm = 2;
- break;
- case R_EBX:
- rm = 3;
- break;
- case R_EBP:
+
+ if (bt == -1) {
rm = 5;
- break;
- case R_ESI:
- rm = 6;
- break;
- case R_EDI:
- rm = 7;
- break;
- case -1:
- rm = 5;
- break;
- default: /* should never happen */
- return NULL;
- }
- if (b == -1 || (b != R_EBP && o == 0 &&
- seg == NO_SEG && !forw_ref &&
- !(input->eaflags &
- (EAF_BYTEOFFS | EAF_WORDOFFS))))
mod = 0;
- else if (input->eaflags & EAF_BYTEOFFS ||
- (o >= -128 && o <= 127 && seg == NO_SEG
- && !forw_ref
- && !(input->eaflags & EAF_WORDOFFS))) {
- mod = 1;
- } else
- mod = 2;
+ } else {
+ rm = (bt & 7);
+ if (rm != (REG_NUM_EBP & 7) && o == 0 &&
+ seg == NO_SEG && !forw_ref &&
+ !(input->eaflags &
+ (EAF_BYTEOFFS | EAF_WORDOFFS)))
+ mod = 0;
+ else if (input->eaflags & EAF_BYTEOFFS ||
+ (o >= -128 && o <= 127 && seg == NO_SEG
+ && !forw_ref
+ && !(input->eaflags & EAF_WORDOFFS)))
+ mod = 1;
+ else
+ mod = 2;
+ }
output->sib_present = FALSE;
- output->bytes = (b == -1 || mod == 2 ? 4 : mod);
- output->modrm = (mod << 6) | (rfield << 3) | rm;
+ output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
+ output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
} else { /* we need a SIB */
int mod, scale, index, base;
-
- switch (b) {
- case R_EAX:
- base = 0;
- break;
- case R_ECX:
- base = 1;
- break;
- case R_EDX:
- base = 2;
- break;
- case R_EBX:
- base = 3;
- break;
- case R_ESP:
- base = 4;
- break;
- case R_EBP:
- case -1:
- base = 5;
- break;
- case R_ESI:
- base = 6;
- break;
- case R_EDI:
- base = 7;
- break;
- default: /* then what the smeg is it? */
- return NULL; /* panic */
- }
-
- switch (i) {
- case R_EAX:
- index = 0;
- break;
- case R_ECX:
- index = 1;
- break;
- case R_EDX:
- index = 2;
- break;
- case R_EBX:
- index = 3;
- break;
- case -1:
- index = 4;
- break;
- case R_EBP:
- index = 5;
- break;
- case R_ESI:
- index = 6;
- break;
- case R_EDI:
- index = 7;
- break;
- default: /* then what the smeg is it? */
- return NULL; /* panic */
- }
-
- if (i == -1)
- s = 1;
+
+ 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 (b == -1 || (b != R_EBP && o == 0 &&
+
+ if (bt == -1) {
+ base = 5;
+ mod = 0;
+ } else {
+ base = (bt & 7);
+ if (base != (REG_NUM_EBP & 7) && o == 0 &&
seg == NO_SEG && !forw_ref &&
!(input->eaflags &
- (EAF_BYTEOFFS | EAF_WORDOFFS))))
- mod = 0;
- else if (input->eaflags & EAF_BYTEOFFS ||
- (o >= -128 && o <= 127 && seg == NO_SEG
- && !forw_ref
- && !(input->eaflags & EAF_WORDOFFS)))
- mod = 1;
- else
- mod = 2;
+ (EAF_BYTEOFFS | EAF_WORDOFFS)))
+ mod = 0;
+ else if (input->eaflags & EAF_BYTEOFFS ||
+ (o >= -128 && o <= 127 && seg == NO_SEG
+ && !forw_ref
+ && !(input->eaflags & EAF_WORDOFFS)))
+ mod = 1;
+ else
+ mod = 2;
+ }
output->sib_present = TRUE;
- output->bytes = (b == -1 || mod == 2 ? 4 : mod);
- output->modrm = (mod << 6) | (rfield << 3) | 4;
+ output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
+ output->modrm = (mod << 6) | ((rfield & 7) << 3) | 4;
output->sib = (scale << 6) | (index << 3) | base;
}
} else { /* it's 16-bit */
int mod, rm;
+
+ /* check for 64-bit long mode */
+ if (addrbits == 64)
+ return NULL;
/* check all registers are BX, BP, SI or DI */
if ((b != -1 && b != R_BP && b != R_BX && b != R_SI
&& i != R_SI && i != R_DI))
return NULL;
- /* ensure the user didn't specify DWORD */
- if (input->addr_size == 32)
+ /* ensure the user didn't specify DWORD/QWORD */
+ if (input->addr_size == 32 || input->addr_size == 64)
return NULL;
if (s != 1 && i != -1)
output->sib_present = FALSE; /* no SIB - it's 16-bit */
output->bytes = mod; /* bytes of offset needed */
- output->modrm = (mod << 6) | (rfield << 3) | rm;
+ output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
}
}
}
+
+ /* Process RIP-relative Addressing */
+ if (rip) {
+ if ((output->modrm & 0xC7) != 0x05)
+ return NULL;
+ output->rip = TRUE;
+ } else {
+ output->rip = FALSE;
+ if (globalbits == 64 && /* Actual Disp32 needs blank SIB on x64 */
+ !(output->sib_present) && ((output->modrm & 0xC7) == 0x05)) {
+ output->sib_present = TRUE;
+ output->modrm --; /* RM Field = 4 (forward to Base of SIB) */
+ output->sib = (4 << 3) | 5; /* Index = 4 (none), Base = 5 */
+ }
+ }
output->size = 1 + output->sib_present + output->bytes;
return output;
}
static int chsize(operand * input, int addrbits)
{
if (!(MEMORY & ~input->type)) {
- int i = input->indexreg, b = input->basereg;
+ int i, b;
+
+ if ( input->indexreg < EXPR_REG_START /* Verify as Register */
+ || input->indexreg >= REG_ENUM_LIMIT)
+ i = -1;
+ else
+ i = regvals[input->indexreg];
+
+ if ( input->basereg < EXPR_REG_START /* Verify as Register */
+ || input->basereg >= REG_ENUM_LIMIT)
+ b = -1;
+ else
+ b = regvals[input->basereg];
if (input->scale == 0)
i = -1;
if (i == -1 && b == -1) /* pure offset */
return (input->addr_size != 0 && input->addr_size != addrbits);
-
- if (i == R_EAX || i == R_EBX || i == R_ECX || i == R_EDX
- || i == R_EBP || i == R_ESP || i == R_ESI || i == R_EDI
- || b == R_EAX || b == R_EBX || b == R_ECX || b == R_EDX
- || b == R_EBP || b == R_ESP || b == R_ESI || b == R_EDI)
- return (addrbits == 16);
+
+ if ((i >= 0020 && i < 0030) || (i >= 0430 && i < 0440) ||
+ (b >= 0020 && b < 0030) || (b >= 0430 && b < 0440))
+ return (addrbits != 32);
else
return (addrbits == 32);
} else
#ifndef NASM_ASSEMBLE_H
#define NASM_ASSEMBLE_H
-long insn_size(long segment, long offset, int bits, unsigned long cpu,
+int32_t insn_size(int32_t segment, int32_t offset, int bits, uint32_t cp,
insn * instruction, efunc error);
-long assemble(long segment, long offset, int bits, unsigned long cpu,
+int32_t assemble(int32_t segment, int32_t offset, int bits, uint32_t cp,
insn * instruction, struct ofmt *output, efunc error,
ListGen * listgen);
#include <stdio.h>
#include <string.h>
+#include <inttypes.h>
#include "nasm.h"
#include "disasm.h"
#define SEG_NODISP 64
#define SEG_SIGNED 128
-static int whichreg(long regflags, int regval)
+static int whichreg(int32_t regflags, int regval)
{
#include "regdis.c"
return 0;
}
-static const char *whichcond(int condval)
+static const int8_t *whichcond(int condval)
{
static int conds[] = {
C_O, C_NO, C_C, C_NC, C_Z, C_NZ, C_NA, C_A,
/*
* Process an effective address (ModRM) specification.
*/
-static unsigned char *do_ea(unsigned char *data, int modrm, int asize,
+static uint8_t *do_ea(uint8_t *data, int modrm, int asize,
int segsize, operand * op)
{
int mod, rm, scale, index, base;
break;
case 1:
op->segment |= SEG_DISP8;
- op->offset = (signed char)*data++;
+ op->offset = (int8_t)*data++;
break;
case 2:
op->segment |= SEG_DISP16;
break;
case 1:
op->segment |= SEG_DISP8;
- op->offset = (signed char)*data++;
+ op->offset = (int8_t)*data++;
break;
case 2:
op->segment |= SEG_DISP32;
op->offset = *data++;
op->offset |= ((unsigned)*data++) << 8;
- op->offset |= ((long)*data++) << 16;
- op->offset |= ((long)*data++) << 24;
+ op->offset |= ((int32_t)*data++) << 16;
+ op->offset |= ((int32_t)*data++) << 24;
break;
}
return data;
* Determine whether the instruction template in t corresponds to the data
* stream in data. Return the number of bytes matched if so.
*/
-static int matches(struct itemplate *t, unsigned char *data, int asize,
+static int matches(struct itemplate *t, uint8_t *data, int asize,
int osize, int segsize, int rep, insn * ins)
{
- unsigned char *r = (unsigned char *)(t->code);
- unsigned char *origdata = data;
+ uint8_t *r = (uint8_t *)(t->code);
+ uint8_t *origdata = data;
int a_used = FALSE, o_used = FALSE;
int drep = 0;
if (*data++)
return FALSE;
if (c >= 014 && c <= 016) {
- ins->oprs[c - 014].offset = (signed char)*data++;
+ ins->oprs[c - 014].offset = (int8_t)*data++;
ins->oprs[c - 014].segment |= SEG_SIGNED;
}
if (c >= 020 && c <= 022)
ins->oprs[c - 034].offset = *data++;
ins->oprs[c - 034].offset |= (((unsigned)*data++) << 8);
if (osize == 32) {
- ins->oprs[c - 034].offset |= (((long)*data++) << 16);
- ins->oprs[c - 034].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 034].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 034].offset |= (((int32_t)*data++) << 24);
}
if (segsize != asize)
ins->oprs[c - 034].addr_size = asize;
if (c >= 040 && c <= 042) {
ins->oprs[c - 040].offset = *data++;
ins->oprs[c - 040].offset |= (((unsigned)*data++) << 8);
- ins->oprs[c - 040].offset |= (((long)*data++) << 16);
- ins->oprs[c - 040].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 040].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 040].offset |= (((int32_t)*data++) << 24);
}
if (c >= 044 && c <= 046) {
ins->oprs[c - 044].offset = *data++;
ins->oprs[c - 044].offset |= (((unsigned)*data++) << 8);
if (asize == 32) {
- ins->oprs[c - 044].offset |= (((long)*data++) << 16);
- ins->oprs[c - 044].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 044].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 044].offset |= (((int32_t)*data++) << 24);
}
if (segsize != asize)
ins->oprs[c - 044].addr_size = asize;
}
if (c >= 050 && c <= 052) {
- ins->oprs[c - 050].offset = (signed char)*data++;
+ ins->oprs[c - 050].offset = (int8_t)*data++;
ins->oprs[c - 050].segment |= SEG_RELATIVE;
}
if (c >= 060 && c <= 062) {
ins->oprs[c - 064].offset = *data++;
ins->oprs[c - 064].offset |= (((unsigned)*data++) << 8);
if (osize == 32) {
- ins->oprs[c - 064].offset |= (((long)*data++) << 16);
- ins->oprs[c - 064].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 064].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 064].offset |= (((int32_t)*data++) << 24);
ins->oprs[c - 064].segment |= SEG_32BIT;
} else
ins->oprs[c - 064].segment &= ~SEG_32BIT;
if (c >= 070 && c <= 072) {
ins->oprs[c - 070].offset = *data++;
ins->oprs[c - 070].offset |= (((unsigned)*data++) << 8);
- ins->oprs[c - 070].offset |= (((long)*data++) << 16);
- ins->oprs[c - 070].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 070].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 070].offset |= (((int32_t)*data++) << 24);
ins->oprs[c - 070].segment |= SEG_32BIT | SEG_RELATIVE;
}
if (c >= 0100 && c < 0130) {
if (c >= 0140 && c <= 0142) {
ins->oprs[c - 0140].offset = *data++;
ins->oprs[c - 0140].offset |= (((unsigned)*data++) << 8);
- ins->oprs[c - 0140].offset |= (((long)*data++) << 16);
- ins->oprs[c - 0140].offset |= (((long)*data++) << 24);
+ ins->oprs[c - 0140].offset |= (((int32_t)*data++) << 16);
+ ins->oprs[c - 0140].offset |= (((int32_t)*data++) << 24);
}
if (c >= 0200 && c <= 0277) {
int modrm = *data++;
return data - origdata;
}
-long disasm(unsigned char *data, char *output, int outbufsize, int segsize,
- long offset, int autosync, unsigned long prefer)
+int32_t disasm(uint8_t *data, int8_t *output, int outbufsize, int segsize,
+ int32_t offset, int autosync, uint32_t prefer)
{
struct itemplate **p, **best_p;
int length, best_length = 0;
- char *segover;
+ int8_t *segover;
int rep, lock, asize, osize, i, slen, colon;
- unsigned char *origdata;
+ uint8_t *origdata;
int works;
insn tmp_ins, ins;
- unsigned long goodness, best;
+ uint32_t goodness, best;
/*
* Scan for prefixes.
} else if (!(MEM_OFFS & ~(*p)->opd[i])) {
slen +=
snprintf(output + slen, outbufsize - slen, "[%s%s%s0x%lx]",
- (segover ? segover : ""), (segover ? ":" : ""),
+ ((const char*)segover ? (const char*)segover : ""), /* placate type mistmatch warning */
+ ((const char*)segover ? ":" : ""), /* by using (const char*) instead of uint8_t* */
(ins.oprs[i].addr_size ==
32 ? "dword " : ins.oprs[i].addr_size ==
16 ? "word " : ""), ins.oprs[i].offset);
if (ins.oprs[i].segment & SEG_DISP8) {
int sign = '+';
if (ins.oprs[i].offset & 0x80) {
- ins.oprs[i].offset = -(signed char)ins.oprs[i].offset;
+ ins.oprs[i].offset = -(int8_t)ins.oprs[i].offset;
sign = '-';
}
slen +=
}
output[slen] = '\0';
if (segover) { /* unused segment override */
- char *p = output;
+ int8_t *p = output;
int count = slen + 1;
while (count--)
p[count + 3] = p[count];
return length;
}
-long eatbyte(unsigned char *data, char *output, int outbufsize)
+int32_t eatbyte(uint8_t *data, int8_t *output, int outbufsize)
{
snprintf(output, outbufsize, "db 0x%02X", *data);
return 1;
#define INSN_MAX 32 /* one instruction can't be longer than this */
-long disasm(unsigned char *data, char *output, int outbufsize, int segsize,
- long offset, int autosync, unsigned long prefer);
-long eatbyte(unsigned char *data, char *output, int outbufsize);
+int32_t disasm(uint8_t *data, int8_t *output, int outbufsize, int segsize,
+ int32_t offset, int autosync, uint32_t prefer);
+int32_t eatbyte(uint8_t *data, int8_t *output, int outbufsize);
#endif
\M{title}{NASM - The Netwide Assembler}
\M{year}{2003}
\M{author}{The NASM Development Team}
-\M{license}{All rights reserved. This document is redistributable under the licence given in the file "COPYING" distributed in the NASM archive.}
+\M{license}{All rights reserved. This document is redistributable under the license given in the file "COPYING" distributed in the NASM archive.}
\M{summary}{This file documents NASM, the Netwide Assembler: an assembler targetting the Intel x86 series of processors, with portable source.}
\M{infoname}{NASM}
\M{infofile}{nasm}
\IA{sib}{sib byte}
\IR{sib byte} SIB byte
\IR{solaris x86} Solaris x86
-\IA{standard section names}{standardised section names}
+\IA{standard section names}{standardized section names}
\IR{symbols, exporting from dlls} symbols, exporting from DLLs
\IR{symbols, importing from dlls} symbols, importing from DLLs
\IR{test subdirectory} \c{test} subdirectory
\IR{visual c++} Visual C++
\IR{www page} WWW page
\IR{win32} Win32
+\IR{win32} Win64
\IR{windows} Windows
\IR{windows 95} Windows 95
\IR{windows nt} Windows NT
\H{whatsnasm} What Is NASM?
-The Netwide Assembler, NASM, is an 80x86 assembler designed for
+The Netwide Assembler, NASM, is an 80x86 and x86-64 assembler designed for
portability and modularity. It supports a range of object file
-formats, including Linux and \c{NetBSD/FreeBSD} \c{a.out}, \c{ELF},
-\c{COFF}, \c{Mach-O}, Microsoft 16-bit \c{OBJ} and \c{Win32}. It will also output
-plain binary files. Its syntax is designed to be simple and easy to
-understand, similar to Intel's but less complex. It supports \c{Pentium},
-\c{P6}, \c{MMX}, \c{3DNow!}, \c{SSE} and \c{SSE2} opcodes, and has
-macro capability.
+formats, including Linux and \c{*BSD} \c{a.out}, \c{ELF}, \c{COFF}, \c{Mach-O},
+Microsoft 16-bit \c{OBJ}, \c{Win32} and \c{Win64}. It will also output plain
+binary files. Its syntax is designed to be simple and easy to understand, similar
+to Intel's but less complex. It supports from the upto and including \c{Pentium},
+\c{P6}, \c{MMX}, \c{3DNow!}, \c{SSE}, \c{SSE2}, \c{SSE3} and \c{x64} opcodes. NASM has
+a strong support for macro conventions.
\S{yaasm} Why Yet Another Assembler?
\b \i\c{a86} is good, but not free, and in particular you don't get any
32-bit capability until you pay. It's DOS only, too.
-\b \i\c{gas} is free, and ports over DOS and Unix, but it's not
+\b \i\c{gas} is free, and ports over to DOS and Unix, but it's not
very good, since it's designed to be a back end to \i\c{gcc}, which
always feeds it correct code. So its error checking is minimal. Also,
its syntax is horrible, from the point of view of anyone trying to
actually \e{write} anything in it. Plus you can't write 16-bit code in
-it (properly).
+it (properly.)
-\b \i\c{as86} is Minix- and Linux-specific, and (my version at least)
+\b \i\c{as86} is specific to Minix and Linux, and (my version at least)
doesn't seem to have much (or any) documentation.
\b \i\c{MASM} isn't very good, and it's (was) expensive, and it runs only under
\b \i\c{TASM} is better, but still strives for MASM compatibility,
which means millions of directives and tons of red tape. And its syntax
is essentially MASM's, with the contradictions and quirks that
-entails (although it sorts out some of those by means of Ideal mode).
+entails (although it sorts out some of those by means of Ideal mode.)
It's expensive too. And it's DOS-only.
So here, for your coding pleasure, is NASM. At present it's
Again.
-\S{legal} Licence Conditions
+\S{legal} License Conditions
Please see the file \c{COPYING}, supplied as part of any NASM
-distribution archive, for the \i{licence} conditions under which you
+distribution archive, for the \i{license} conditions under which you
may use NASM. NASM is now under the so-called GNU Lesser General
Public License, LGPL.
\H{contact} Contact Information
-The current version of NASM (since about 0.98.08) are maintained by a
+The current version of NASM (since about 0.98.08) is maintained by a
team of developers, accessible through the \c{nasm-devel} mailing list
(see below for the link).
If you want to report a bug, please read \k{bugs} first.
-O0, but will produce successful assembly more often if
branch offset sizes are not specified.
Additionally, immediate operands which will fit in a signed byte
- are optimised, unless the long form is specified.
+ are optimized, unless the long form is specified.
\b \c{-On} multi-pass optimization, minimize branch offsets; also will
minimize signed immediate bytes, overriding size specification
For historical reasons, NASM uses the keyword \i\c{TWORD} where MASM
and compatible assemblers use \i\c{TBYTE}.
-NASM does not declare \i{uninitialised storage} in the same way as
+NASM does not declare \i{uninitialized storage} in the same way as
MASM: where a MASM programmer might use \c{stack db 64 dup (?)},
NASM requires \c{stack resb 64}, intended to be read as `reserve 64
bytes'. For a limited amount of compatibility, since NASM treats
instructions, are used in the instruction field anyway because
that's the most convenient place to put them. The current
pseudo-instructions are \i\c{DB}, \i\c{DW}, \i\c{DD}, \i\c{DQ} and
-\i\c{DT}, their \i{uninitialised} counterparts \i\c{RESB},
+\i\c{DT}, their \i{uninitialized} counterparts \i\c{RESB},
\i\c{RESW}, \i\c{RESD}, \i\c{RESQ} and \i\c{REST}, the \i\c{INCBIN}
command, the \i\c{EQU} command, and the \i\c{TIMES} prefix.
-\S{db} \c{DB} and friends: Declaring Initialised Data
+\S{db} \c{DB} and friends: Declaring initialized Data
\i\c{DB}, \i\c{DW}, \i\c{DD}, \i\c{DQ} and \i\c{DT} are used, much
-as in MASM, to declare initialised data in the output file. They can
+as in MASM, to declare initialized data in the output file. They can
be invoked in a wide range of ways:
\I{floating-point}\I{character constant}\I{string constant}
constants as operands.
-\S{resb} \c{RESB} and friends: Declaring \i{Uninitialised} Data
+\S{resb} \c{RESB} and friends: Declaring \i{Uninitialized} Data
\i\c{RESB}, \i\c{RESW}, \i\c{RESD}, \i\c{RESQ} and \i\c{REST} are
designed to be used in the BSS section of a module: they declare
-\e{uninitialised} storage space. Each takes a single operand, which
+\e{uninitialized} storage space. Each takes a single operand, which
is the number of bytes, words, doublewords or whatever to reserve.
As stated in \k{qsother}, NASM does not support the MASM/TASM syntax
-of reserving uninitialised space by writing \I\c{?}\c{DW ?} or
+of reserving uninitialized space by writing \I\c{?}\c{DW ?} or
similar things: this is what it does instead. The operand to a
\c{RESB}-type pseudo-instruction is a \i\e{critical expression}: see
\k{crit}.
NASM provides this level of power by means of a \e{context stack}.
The preprocessor maintains a stack of \e{contexts}, each of which is
-characterised by a name. You add a new context to the stack using
+characterized by a name. You add a new context to the stack using
the \i\c{%push} directive, and remove one using \i\c{%pop}. You can
define labels that are local to a particular context on the stack.
and then pepper your code with calls to \c{notdeadyet} until you
find the crash point.
+\S{bitsm} \i\c{__BITS__}: Current BITS Mode
+
+The \c{__BITS__} standard macro is updated every time that the BITS mode is
+set using the \c{BITS XX} or \c{[BITS XX]} directive, where XX is a valid mode
+number of 16, 32 or 64. \c{__BITS__} receives the specified mode number and
+makes it globally available. This can be very useful for those who utilize
+mode-dependent macros.
+
\S{struc} \i\c{STRUC} and \i\c{ENDSTRUC}: \i{Declaring Structure} Data Types
The \c{BITS} directive specifies whether NASM should generate code
\I{16-bit mode, versus 32-bit mode}designed to run on a processor
-operating in 16-bit mode, or code designed to run on a processor
-operating in 32-bit mode. The syntax is \c{BITS 16} or \c{BITS 32}.
+operating in 16-bit mode, 32-bit mode or 64-bit mode. The syntax is
+\c{BITS XX}, where XX is 16, 32 or 64.
In most cases, you should not need to use \c{BITS} explicitly. The
-\c{aout}, \c{coff}, \c{elf}, \c{macho} and \c{win32} object formats, which are
-designed for use in 32-bit operating systems, all cause NASM to
-select 32-bit mode by default. The \c{obj} object format allows you
+\c{aout}, \c{coff}, \c{elf}, \c{macho}, \c{win32} and \c{win64}
+object formats, which are designed for use in 32-bit or 64-bit
+operating systems, all cause NASM to select 32-bit or 64-bit mode,
+respectively, by default. The \c{obj} object format allows you
to specify each segment you define as either \c{USE16} or \c{USE32},
and NASM will set its operating mode accordingly, so the use of the
\c{BITS} directive is once again unnecessary.
The most likely reason for using the \c{BITS} directive is to write
-32-bit code in a flat binary file; this is because the \c{bin}
+32-bit or 64-bit code in a flat binary file; this is because the \c{bin}
output format defaults to 16-bit mode in anticipation of it being
used most frequently to write DOS \c{.COM} programs, DOS \c{.SYS}
device drivers and boot loader software.
assembler will generate incorrect code because it will be writing
code targeted at a 32-bit platform, to be run on a 16-bit one.
-When NASM is in \c{BITS 16} state, instructions which use 32-bit
+When NASM is in \c{BITS 16} mode, instructions which use 32-bit
data are prefixed with an 0x66 byte, and those referring to 32-bit
-addresses have an 0x67 prefix. In \c{BITS 32} state, the reverse is
+addresses have an 0x67 prefix. In \c{BITS 32} mode, the reverse is
true: 32-bit instructions require no prefixes, whereas instructions
using 16-bit data need an 0x66 and those working on 16-bit addresses
need an 0x67.
+When NASM is in \c{BITS 64} mode, most instructions operate the same
+as they do for \c{BITS 32} mode. However, 16-bit addresses are depreciated
+in the x86-64 architecture extension and the 0x67 prefix is used for 32-bit
+addressing. This is due to the default of 64-bit addressing. When the \c{REX}
+prefix is used, the processor does not know how to address the AH, BH, CH or
+DH (high 8-bit legacy) registers. This because the x86-64 has added a new
+set of registers and the capability to address the low 8-bits of the SP, BP
+SI and DI registers as SPL, BPL, SIL and DIL, respectively; but only when
+the REX prefix is used. In summary, the \c{REX} prefix causes the addressing
+of AH, BH, CH and DH to be replaced by SPL, BPL, SIL and DIL.
+
The \c{BITS} directive has an exactly equivalent primitive form,
-\c{[BITS 16]} and \c{[BITS 32]}. The user-level form is a macro
-which has no function other than to call the primitive form.
+\c{[BITS 16]}, \c{[BITS 32]} and \c{BITS 64]}. The user-level form is
+a macro which has no function other than to call the primitive form.
-Note that the space is neccessary, \c{BITS32} will \e{not} work!
+Note that the space is neccessary, e.g. \c{BITS32} will \e{not} work!
\S{USE16 & USE32} \i\c{USE16} & \i\c{USE32}: Aliases for BITS
The Unix object formats, and the \c{bin} object format (but see
\k{multisec}, all support
-the \i{standardised section names} \c{.text}, \c{.data} and \c{.bss}
-for the code, data and uninitialised-data sections. The \c{obj}
-format, by contrast, does not recognise these section names as being
+the \i{standardized section names} \c{.text}, \c{.data} and \c{.bss}
+for the code, data and uninitialized-data sections. The \c{obj}
+format, by contrast, does not recognize these section names as being
special, and indeed will strip off the leading period of any section
name that has one.
The \c{COMMON} directive is used to declare \i\e{common variables}.
A common variable is much like a global variable declared in the
-uninitialised data section, so that
+uninitialized data section, so that
\c common intvar 4
\b\c{CPU PRESCOTT} Prescott instruction set
+\b\c{CPU X64} x86-64 (x64/AMD64/EM64T) instruction set
+
\b\c{CPU IA64} IA64 CPU (in x86 mode) instruction set
All options are case insensitive. All instructions will be selected
how nasm handles sections in the \c{bin} format, see \k{multisec}.
Using the \c{bin} format puts NASM by default into 16-bit mode (see
-\k{bits}). In order to use \c{bin} to write 32-bit code such as an
-OS kernel, you need to explicitly issue the \I\c{BITS}\c{BITS 32}
-directive.
+\k{bits}). In order to use \c{bin} to write 32-bit or 64-bit code,
+such as an OS kernel, you need to explicitly issue the \I\c{BITS}\c{BITS 32}
+or \I\c{BITS}\c{BITS 64} directive.
\c{bin} has no default output file name extension: instead, it
leaves your file name as it is once the original extension has been
\c
\c segment bss
\c
-\c ; some uninitialised data
+\c ; some uninitialized data
\c
\c group dgroup data bss
frequently used symbols imported by name.
\b \c{nodata} indicates that the exported symbol is a function which
-does not make use of any initialised data.
+does not make use of any initialized data.
\b \c{parm=NNN}, where \c{NNN} is an integer, sets the number of
parameter words for the case in which the symbol is a call gate
\b \c{data} and \c{bss} define the section to be a data section,
analogously to \c{code}. Data sections are marked as readable and
-writable, but not executable. \c{data} declares an initialised data
-section, whereas \c{bss} declares an uninitialised data section.
+writable, but not executable. \c{data} declares an initialized data
+section, whereas \c{bss} declares an uninitialized data section.
-\b \c{rdata} declares an initialised data section that is readable
+\b \c{rdata} declares an initialized data section that is readable
but not writable. Microsoft compilers use this section to place
constants in it.
Any other section name is treated by default like \c{.text}.
+\H{win64fmt} \i\c{win64}: Microsoft Win64 Object Files
+
+The \c{win64} output format generates Microsoft Win64 object files,
+which is nearly 100% indentical to the \c{win32} object format (\k{win32fmt})
+with the exception that it is meant to target 64-bit code and the x86-64
+platform altogether. This object file is used exactly the same as the \c{win32}
+object format (\k{win32fmt}), in NASM, with regard to this exception.
+
+
\H{cofffmt} \i\c{coff}: \i{Common Object File Format}
The \c{coff} output type produces \c{COFF} object files suitable for
\c{elf} defines five special symbols which you can use as the
right-hand side of the \c{WRT} operator to obtain PIC relocation
types. They are \i\c{..gotpc}, \i\c{..gotoff}, \i\c{..got},
-\i\c{..plt} and \i\c{..sym}. Their functions are summarised here:
+\i\c{..plt} and \i\c{..sym}. Their functions are summarized here:
\b Referring to the symbol marking the global offset table base
using \c{wrt ..gotpc} will end up giving the distance from the
\c mov sp,stacktop
This initial piece of code sets up \c{DS} to point to the data
-segment, and initialises \c{SS} and \c{SP} to point to the top of
+segment, and initializes \c{SS} and \c{SP} to point to the top of
the provided stack. Notice that interrupts are implicitly disabled
for one instruction after a move into \c{SS}, precisely for this
situation, so that there's no chance of an interrupt occurring
\c stacktop:
The above code declares a stack segment containing 64 bytes of
-uninitialised stack space, and points \c{stacktop} at the top of it.
+uninitialized stack space, and points \c{stacktop} at the top of it.
The directive \c{segment stack stack} defines a segment \e{called}
\c{stack}, and also of \e{type} \c{STACK}. The latter is not
necessary to the correct running of the program, but linkers are
\c
\c section .bss
\c
-\c ; put uninitialised data here
+\c ; put uninitialized data here
The \c{bin} format puts the \c{.text} section first in the file, so
you can declare data or BSS items before beginning to write code if
you want to and the code will still end up at the front of the file
where it belongs.
-The BSS (uninitialised data) section does not take up space in the
+The BSS (uninitialized data) section does not take up space in the
\c{.COM} file itself: instead, addresses of BSS items are resolved
to point at space beyond the end of the file, on the grounds that
this will be free memory when the program is run. Therefore you
-should not rely on your BSS being initialised to all zeros when you
+should not rely on your BSS being initialized to all zeros when you
run.
To assemble the above program, you should use a command line like
In large model, the function-call code might look more like this. In
this example, it is assumed that \c{DS} already holds the segment
-base of the segment \c{_DATA}. If not, you would have to initialise
+base of the segment \c{_DATA}. If not, you would have to initialize
it first.
\c push word [myint]
one offset and using just that.
To do either of these, you should read your C compiler's manual to
-find out how it organises data structures. NASM gives no special
+find out how it organizes data structures. NASM gives no special
alignment to structure members in its own \c{STRUC} macro, so you
have to specify alignment yourself if the C compiler generates it.
Typically, you might find that a structure like
\b Procedures and functions must be in a segment whose name is
either \c{CODE}, \c{CSEG}, or something ending in \c{_TEXT}.
-\b Initialised data must be in a segment whose name is either
+\b initialized data must be in a segment whose name is either
\c{CONST} or something ending in \c{_DATA}.
-\b Uninitialised data must be in a segment whose name is either
+\b Uninitialized data must be in a segment whose name is either
\c{DATA}, \c{DSEG}, or something ending in \c{_BSS}.
\b Any other segments in the object file are completely ignored.
one offset and using just that.
To do either of these, you should read your C compiler's manual to
-find out how it organises data structures. NASM gives no special
+find out how it organizes data structures. NASM gives no special
alignment to structure members in its own \i\c{STRUC} macro, so you
have to specify alignment yourself if the C compiler generates it.
Typically, you might find that a structure like
Sync points are specified using the \i\c{-s} option: they are measured
in terms of the program origin, not the file position. So if you
-want to synchronise after 32 bytes of a \c{.COM} file, you would have to
+want to synchronize after 32 bytes of a \c{.COM} file, you would have to
do
\c ndisasm -o100h -s120h file.com
which NASM will assemble, and a short description of the function of
each one.
-It is not intended to be exhaustive documentation on the fine
+It is not intended to be an exhaustive documentation on the fine
details of the instructions' function, such as which exceptions they
can trigger: for such documentation, you should go to Intel's Web
site, \W{http://developer.intel.com/design/Pentium4/manuals/}\c{http://developer.intel.com/design/Pentium4/manuals/}.
using the following notation:
\b Registers: \c{reg8} denotes an 8-bit \i{general purpose
-register}, \c{reg16} denotes a 16-bit general purpose register, and
-\c{reg32} a 32-bit one. \c{fpureg} denotes one of the eight FPU
-stack registers, \c{mmxreg} denotes one of the eight 64-bit MMX
-registers, and \c{segreg} denotes a segment register. In addition,
-some registers (such as \c{AL}, \c{DX} or
-\c{ECX}) may be specified explicitly.
+register}, \c{reg16} denotes a 16-bit general purpose register,
+\c{reg32} a 32-bit one and \c{reg64} a 64-bit one. \c{fpureg} denotes
+one of the eight FPU stack registers, \c{mmxreg} denotes one of the
+eight 64-bit MMX registers, and \c{segreg} denotes a segment register.
+\c{xmmreg} denotes one of the 8, or 16 in x64 long mode, SSE XMM registers.
+In addition, some registers (such as \c{AL}, \c{DX}, \c{ECX} or \c{RAX})
+may be specified explicitly.
\b Immediate operands: \c{imm} denotes a generic \i{immediate operand}.
\c{imm8}, \c{imm16} and \c{imm32} are used when the operand is
needs an explicit specifier: for example, \c{ADD ESP,16} could be
interpreted as either \c{ADD r/m32,imm32} or \c{ADD r/m32,imm8}.
NASM chooses the former by default, and so you must specify \c{ADD
-ESP,BYTE 16} for the latter.
+ESP,BYTE 16} for the latter. There is a special case of the allowance
+of an \c{imm64} for particular x64 versions of the MOV instruction.
\b Memory references: \c{mem} denotes a generic \i{memory reference};
\c{mem8}, \c{mem16}, \c{mem32}, \c{mem64} and \c{mem80} are used
\b \i{Restricted memory references}: one form of the \c{MOV}
instruction allows a memory address to be specified \e{without}
allowing the normal range of register combinations and effective
-address processing. This is denoted by \c{memoffs8}, \c{memoffs16}
-and \c{memoffs32}.
+address processing. This is denoted by \c{memoffs8}, \c{memoffs16},
+\c{memoffs32} or \c{memoffs64}.
\b Register or memory choices: many instructions can accept either a
-register \e{or} a memory reference as an operand. \c{r/m8} is a
+register \e{or} a memory reference as an operand. \c{r/m8} is
shorthand for \c{reg8/mem8}; similarly \c{r/m16} and \c{r/m32}.
-\c{r/m64} is MMX-related, and is a shorthand for \c{mmxreg/mem64}.
+On legacy x86 modes, \c{r/m64} is MMX-related, and is shorthand for
+\c{mmxreg/mem64}. When utilizing the x86-64 architecture extension,
+\c{r/m64} denotes use of a 64-bit GPR as well, and is shorthand for
+\c{reg64/mem64}.
\H{iref-opc} Key to Opcode Descriptions
\b The codes \c{a16} and \c{a32}, similarly to \c{o16} and \c{o32},
indicate the address size of the given form of the instruction.
Where this does not match the \c{BITS} setting, a \c{67} prefix is
-required.
+required. Please note that \c{a16} is useless in long mode as
+16-bit addressing is depreciated on the x86-64 architecture extension.
\S{iref-rv} Register Values
there is no problem with registers of different types sharing an
encoding value.
+Please note that for the register classes listed below, the register
+extensions (REX) classes require the use of the REX prefix, in which
+is only available when in long mode on the x86-64 processor. This
+pretty much goes for any register that has a number higher than 7.
+
The encodings for the various classes of register are:
\b 8-bit general registers: \c{AL} is 0, \c{CL} is 1, \c{DL} is 2,
-\c{BL} is 3, \c{AH} is 4, \c{CH} is 5, \c{DH} is 6, and \c{BH} is
-7.
+\c{BL} is 3, \c{AH} is 4, \c{CH} is 5, \c{DH} is 6 and \c{BH} is
+7. Please note that \c{AH}, \c{BH}, \c{CH} and \c{DH} are not
+addressable when using the REX prefix in long mode.
+
+\b 8-bit general register extensions (REX): \c{SPL} is 4, \c{BPL} is 5,
+\c{SIL} is 6, \c{DIL} is 7, \c{R8B} is 8, \c{R9B} is 9, \c{R10B} is 10,
+\c{R11B} is 11, \c{R12B} is 12, \c{R13B} is 13, \c{R14B} is 14 and
+\c{R15B} is 15.
\b 16-bit general registers: \c{AX} is 0, \c{CX} is 1, \c{DX} is 2,
\c{BX} is 3, \c{SP} is 4, \c{BP} is 5, \c{SI} is 6, and \c{DI} is 7.
+\b 16-bit general register extensions (REX): \c{R8W} is 8, \c{R9W} is 9,
+\c{R10w} is 10, \c{R11W} is 11, \c{R12W} is 12, \c{R13W} is 13, \c{R14W}
+is 14 and \c{R15W} is 15.
+
\b 32-bit general registers: \c{EAX} is 0, \c{ECX} is 1, \c{EDX} is
2, \c{EBX} is 3, \c{ESP} is 4, \c{EBP} is 5, \c{ESI} is 6, and
\c{EDI} is 7.
+\b 32-bit general register extensions (REX): \c{R8D} is 8, \c{R9D} is 9,
+\c{R10D} is 10, \c{R11D} is 11, \c{R12D} is 12, \c{R13D} is 13, \c{R14D}
+is 14 and \c{R15D} is 15.
+
+\b 64-bit general register extensions (REX): \c{RAX} is 0, \c{RCX} is 1,
+\c{RDX} is 2, \c{RBX} is 3, \c{RSP} is 4, \c{RBP} is 5, \c{RSI} is 6,
+\c{RDI} is 7, \c{R8} is 8, \c{R9} is 9, \c{R10} is 10, \c{R11} is 11,
+\c{R12} is 12, \c{R13} is 13, \c{R14} is 14 and \c{R15} is 15.
+
\b \i{Segment registers}: \c{ES} is 0, \c{CS} is 1, \c{SS} is 2, \c{DS}
is 3, \c{FS} is 4, and \c{GS} is 5.
\c{MM3} is 3, \c{MM4} is 4, \c{MM5} is 5, \c{MM6} is 6, and \c{MM7}
is 7.
+\b 128-bit \i{XMM (SSE) registers}: \c{XMM0} is 0, \c{XMM1} is 1,
+\c{XMM2} is 2, \c{XMM3} is 3, \c{XMM4} is 4, \c{XMM5} is 5, \c{XMM6} is
+6 and \c{XMM7} is 7.
+
+\b 128-bit \i{XMM (SSE) register} extensions (REX): \c{XMM8} is 8,
+\c{XMM9} is 9, \c{XMM10} is 10, \c{XMM11} is 11, \c{XMM12} is 12,
+\c{XMM13} is 13, \c{XMM14} is 14 and \c{XMM15} is 15.
+
\b \i{Control registers}: \c{CR0} is 0, \c{CR2} is 2, \c{CR3} is 3,
and \c{CR4} is 4.
+\b \i{Control register} extensions: \c{CR8} is 8.
+
\b \i{Debug registers}: \c{DR0} is 0, \c{DR1} is 1, \c{DR2} is 2,
\c{DR3} is 3, \c{DR6} is 6, and \c{DR7} is 7.
long, and no registers are added to the displacement.
\b If \c{mod} is 0, \c{r/m} is 4 (meaning the SIB byte is present)
-and \c{base} is 4, the effective address encoded is not
+and \c{base} is 5, the effective address encoded is not
\c{[EBP+index]} as the above rules would suggest, but instead
\c{[disp32+index]}: the displacement field is present and is four
bytes long, and there is no base register (but the index register is
still processed in the normal way).
+\S{iref-rex} Register Extensions: The \i{REX} Prefix
+
+The Register Extensions, or \i{REX} for short, prefix is the means
+of accessing extended registers on the x86-64 architecture. \i{REX}
+is considered an instruction prefix, but is required to be after
+all other prefixes and thus immediately before the first instruction
+opcode itself. So overall, \i{REX} can be thought of as an "Opcode
+Prefix" instead. The \i{REX} prefix itself is indicated by a value
+of 0x4X, where X is one of 16 different combinations of the actual
+\i{REX} flags.
+
+The \i{REX} prefix flags consist of four 1-bit extensions fields.
+These flags are found in the lower nibble of the actual \i{REX}
+prefix opcode. Below is the list of \i{REX} prefix flags, from
+high bit to low bit.
+
+\c{REX.W}: When set, this flag indicates the use of a 64-bit operand,
+as opposed to the default of using 32-bit operands as found in 32-bit
+Protected Mode.
+
+\c{REX.R}: When set, this flag extends the \c{reg (spare)} field of
+the \c{ModRM} byte. Overall, this raises the amount of addressable
+registers in this field from 8 to 16.
+
+\c{REX.X}: When set, this flag extends the \c{index} field of the
+\c{SIB} byte. Overall, this raises the amount of addressable
+registers in this field from 8 to 16.
+
+\c{REX.B}: When set, this flag extends the \c{r/m} field of the
+\c{ModRM} byte. This flag can also represent an extension to the
+opcode register \c{(/r)} field. The determination of which is used
+varies depending on which instruction is used. Overall, this raises
+the amount of addressable registers in these fields from 8 to 16.
+
+Interal use of the \i{REX} prefix by the processor is consistent,
+yet non-trivial. Most instructions use the \i{REX} prefix as
+indicated by the above flags. Some instructions require the \i{REX}
+prefix to be present even if the flags are empty. Some instructions
+default to a 64-bit operand and require the \i{REX} prefix only for
+actual register extensions, and thus ignores the \c{REX.W} field
+completely.
+
+At any rate, NASM is designed to handle, and fully supports, the
+\i{REX} prefix internally. Please read the appropriate processor
+documentation for further information on the \i{REX} prefix.
+
+You may have noticed that opcodes 0x40 through 0x4F are actually
+opcodes for the INC/DEC instructions for each General Purpose
+Register. This is, of course, correct... for legacy x86. While
+in long mode, opcodes 0x40 through 0x4F are reserved for use as
+the REX prefix. The other opcode forms of the INC/DEC instructions
+are used instead.
+
+
\H{iref-flg} Key to Instruction Flags
Given along with each instruction in this appendix is a set of
part of the new instruction set in the Pentium 4 and Intel Xeon
processors. These instructions are also known as SSE2 instructions.
+\b \c{X64} indicates that the instruction was introduced as part of
+the new instruction set in the x86-64 architecture extension,
+commonly referred to as x64, AMD64 or EM64T.
+
\H{iref-inst} x86 Instruction Set
\c{ECX} and \c{EDX} with information, which varies depending on the
input contents of \c{EAX}.
-\c{CPUID} also acts as a barrier to serialise instruction execution:
+\c{CPUID} also acts as a barrier to serialize instruction execution:
executing the \c{CPUID} instruction guarantees that all the effects
(memory modification, flag modification, register modification) of
previous instructions have been completed before the next
\c{FDECSTP} (\k{insFDECSTP}).
-\S{insFINIT} \i\c{FINIT}, \i\c{FNINIT}: Initialise Floating-Point Unit
+\S{insFINIT} \i\c{FINIT}, \i\c{FNINIT}: initialize Floating-Point Unit
\c FINIT ; 9B DB E3 [8086,FPU]
\c FNINIT ; DB E3 [8086,FPU]
-\c{FINIT} initialises the FPU to its default state. It flags all
+\c{FINIT} initializes the FPU to its default state. It flags all
registers as empty, without actually change their values, clears
the top of stack pointer. \c{FNINIT} does the same, without first
waiting for pending exceptions to clear.
\c FSETPM ; DB E4 [286,FPU]
-This instruction initialises protected mode on the 287 floating-point
+This instruction initializes protected mode on the 287 floating-point
coprocessor. It is only meaningful on that processor: the 387 and
above treat the instruction as a no-operation.
Unlike the \c{FSAVE/FNSAVE} instructions, the processor retains the
contents of the \c{FPU}, \c{MMX} and \c{SSE} state in the processor
-after the state has been saved. This instruction has been optimised
+after the state has been saved. This instruction has been optimized
to maximize floating-point save performance.
by coding the cumbersome \c{JMP SEG routine:routine}, but instead
allows the easier synonym \c{JMP FAR routine}.
-The \c{CALL r/m} forms given above are near calls; NASM will accept
-the \c{NEAR} keyword (e.g. \c{CALL NEAR [address]}), even though it
+The \c{JMP r/m} forms given above are near calls; NASM will accept
+the \c{NEAR} keyword (e.g. \c{JMP NEAR [address]}), even though it
is not strictly necessary.
\c LLDT r/m16 ; 0F 00 /2 [286,PRIV]
\c{LGDT} and \c{LIDT} both take a 6-byte memory area as an operand:
-they load a 32-bit linear address and a 16-bit size limit from that
+they load a 16-bit size limit and a 32-bit linear address from that
area (in the opposite order) into the \c{GDTR} (global descriptor table
register) or \c{IDTR} (interrupt descriptor table register). These are
the only instructions which directly use \e{linear} addresses, rather
#include <stddef.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
static struct eval_hints *hint;
extern int in_abs_seg; /* ABSOLUTE segment flag */
-extern long abs_seg; /* ABSOLUTE segment */
-extern long abs_offset; /* ABSOLUTE segment offset */
+extern int32_t abs_seg; /* ABSOLUTE segment */
+extern int32_t abs_offset; /* ABSOLUTE segment offset */
/*
* Unimportant cleanup is done to avoid confusing people who are trying
tempexpr_size = ntempexpr = 0;
}
-static void addtotemp(long type, long value)
+static void addtotemp(int32_t type, int64_t value)
{
while (ntempexpr >= tempexpr_size) {
tempexpr_size += TEMPEXPR_DELTA;
addtotemp(p->type, p->value);
lasttype = p++->type;
} else { /* *p and *q have same type */
- long sum = p->value + q->value;
+ int32_t sum = p->value + q->value;
if (sum)
addtotemp(p->type, sum);
lasttype = p->type;
* multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
* as the base register.
*/
-static expr *scalar_mult(expr * vect, long scalar, int affect_hints)
+static expr *scalar_mult(expr * vect, int32_t scalar, int affect_hints)
{
expr *p = vect;
return vect;
}
-static expr *scalarvect(long scalar)
+static expr *scalarvect(int32_t scalar)
{
begintemp();
addtotemp(EXPR_SIMPLE, scalar);
*/
static expr *segment_part(expr * e)
{
- long seg;
+ int32_t seg;
if (is_unknown(e))
return unknown_expr();
" is already a segment base");
return NULL;
} else {
- long base = outfmt->segbase(seg + 1);
+ int32_t base = outfmt->segbase(seg + 1);
begintemp();
addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect((long)(reloc_value(e) || reloc_value(f)));
+ e = scalarvect((int32_t)(reloc_value(e) || reloc_value(f)));
}
return e;
}
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect((long)(!reloc_value(e) ^ !reloc_value(f)));
+ e = scalarvect((int32_t)(!reloc_value(e) ^ !reloc_value(f)));
}
return e;
}
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect((long)(reloc_value(e) && reloc_value(f)));
+ e = scalarvect((int32_t)(reloc_value(e) && reloc_value(f)));
}
return e;
}
static expr *rexp3(int critical)
{
expr *e, *f;
- long v;
+ int32_t v;
e = expr0(critical);
if (!e)
e = scalarvect(reloc_value(e) << reloc_value(f));
break;
case TOKEN_SHR:
- e = scalarvect(((unsigned long)reloc_value(e)) >>
+ e = scalarvect(((uint32_t)reloc_value(e)) >>
reloc_value(f));
break;
}
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect(((unsigned long)reloc_value(e)) /
- ((unsigned long)reloc_value(f)));
+ e = scalarvect(((uint32_t)reloc_value(e)) /
+ ((uint32_t)reloc_value(f)));
break;
case '%':
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect(((unsigned long)reloc_value(e)) %
- ((unsigned long)reloc_value(f)));
+ e = scalarvect(((uint32_t)reloc_value(e)) %
+ ((uint32_t)reloc_value(f)));
break;
case TOKEN_SDIV:
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect(((signed long)reloc_value(e)) /
- ((signed long)reloc_value(f)));
+ e = scalarvect(((int32_t)reloc_value(e)) /
+ ((int32_t)reloc_value(f)));
break;
case TOKEN_SMOD:
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
- e = scalarvect(((signed long)reloc_value(e)) %
- ((signed long)reloc_value(f)));
+ e = scalarvect(((int32_t)reloc_value(e)) %
+ ((int32_t)reloc_value(f)));
break;
}
}
static expr *expr6(int critical)
{
- long type;
+ int32_t type;
expr *e;
- long label_seg, label_ofs;
+ int32_t label_seg, label_ofs;
if (i == '-') {
i = scan(scpriv, tokval);
else
i = tokval->t_type;
- while (ntempexprs) /* initialise temporary storage */
+ while (ntempexprs) /* initialize temporary storage */
nasm_free(tempexprs[--ntempexprs]);
e = bexpr(critical);
if (is_just_unknown(f))
g = unknown_expr();
else {
- long value;
+ int64_t value;
begintemp();
if (!is_reloc(f)) {
error(ERR_NONFATAL, "invalid right-hand operand to WRT");
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <inttypes.h>
#include "nasm.h"
* => we only have to worry about _one_ bit shift to the left
*/
-static int ieee_multiply(unsigned short *to, unsigned short *from)
+static int ieee_multiply(uint16_t *to, uint16_t *from)
{
- unsigned long temp[MANT_WORDS * 2];
+ uint32_t temp[MANT_WORDS * 2];
int i, j;
for (i = 0; i < MANT_WORDS * 2; i++)
for (i = 0; i < MANT_WORDS; i++)
for (j = 0; j < MANT_WORDS; j++) {
- unsigned long n;
- n = (unsigned long)to[i] * (unsigned long)from[j];
+ uint32_t n;
+ n = (uint32_t)to[i] * (uint32_t)from[j];
temp[i + j] += n >> 16;
temp[i + j + 1] += n & 0xFFFF;
}
}
}
-static void ieee_flconvert(char *string, unsigned short *mant,
- long *exponent, efunc error)
+static void ieee_flconvert(int8_t *string, uint16_t *mant,
+ int32_t *exponent, efunc error)
{
- char digits[MANT_DIGITS];
- char *p, *q, *r;
- unsigned short mult[MANT_WORDS], bit;
- unsigned short *m;
- long tenpwr, twopwr;
+ int8_t digits[MANT_DIGITS];
+ int8_t *p, *q, *r;
+ uint16_t mult[MANT_WORDS], bit;
+ uint16_t *m;
+ int32_t tenpwr, twopwr;
int extratwos, started, seendot;
p = digits;
started = FALSE;
twopwr = 0;
while (m < mant + MANT_WORDS) {
- unsigned short carry = 0;
+ uint16_t carry = 0;
while (p > q && !p[-1])
p--;
if (p <= q)
/*
* Shift a mantissa to the right by i (i < 16) bits.
*/
-static void ieee_shr(unsigned short *mant, int i)
+static void ieee_shr(uint16_t *mant, int i)
{
- unsigned short n = 0, m;
+ uint16_t n = 0, m;
int j;
for (j = 0; j < MANT_WORDS; j++) {
/*
* Round a mantissa off after i words.
*/
-static int ieee_round(unsigned short *mant, int i)
+static int ieee_round(uint16_t *mant, int i)
{
if (mant[i] & 0x8000) {
do {
#define put(a,b) ( (*(a)=(b)), ((a)[1]=(b)>>8) )
-static int to_double(char *str, long sign, unsigned char *result,
+static int to_double(int8_t *str, int32_t sign, uint8_t *result,
efunc error)
{
- unsigned short mant[MANT_WORDS];
- long exponent;
+ uint16_t mant[MANT_WORDS];
+ int32_t exponent;
sign = (sign < 0 ? 0x8000L : 0L);
return 1; /* success */
}
-static int to_float(char *str, long sign, unsigned char *result,
+static int to_float(int8_t *str, int32_t sign, uint8_t *result,
efunc error)
{
- unsigned short mant[MANT_WORDS];
- long exponent;
+ uint16_t mant[MANT_WORDS];
+ int32_t exponent;
sign = (sign < 0 ? 0x8000L : 0L);
return 1;
}
-static int to_ldoub(char *str, long sign, unsigned char *result,
+static int to_ldoub(int8_t *str, int32_t sign, uint8_t *result,
efunc error)
{
- unsigned short mant[MANT_WORDS];
- long exponent;
+ uint16_t mant[MANT_WORDS];
+ int32_t exponent;
sign = (sign < 0 ? 0x8000L : 0L);
return 1;
}
-int float_const(char *number, long sign, unsigned char *result, int bytes,
+int float_const(int8_t *number, int32_t sign, uint8_t *result, int bytes,
efunc error)
{
if (bytes == 4)
#ifndef NASM_FLOAT_H
#define NASM_FLOAT_H
-int float_const(char *number, long sign, unsigned char *result, int bytes,
+int float_const(int8_t *number, int32_t sign, uint8_t *result, int bytes,
efunc error);
#endif
; see the comment at the top of assemble.c. For a detailed description
; of the flags (fourth field), please see insns.h.
;
-AAA void \1\x37 8086
-AAD void \2\xD5\x0A 8086
-AAD imm \1\xD5\24 8086,SB
-AAM void \2\xD4\x0A 8086
-AAM imm \1\xD4\24 8086,SB
-AAS void \1\x3F 8086
+AAA void \1\x37 8086,NOLONG
+AAD void \2\xD5\x0A 8086,NOLONG
+AAD imm \1\xD5\24 8086,SB,NOLONG
+AAM void \2\xD4\x0A 8086,NOLONG
+AAM imm \1\xD4\24 8086,SB,NOLONG
+AAS void \1\x3F 8086,NOLONG
ADC mem,reg8 \300\1\x10\101 8086,SM
ADC reg8,reg8 \1\x10\101 8086
ADC mem,reg16 \320\300\1\x11\101 8086,SM
ADC reg16,reg16 \320\1\x11\101 8086
ADC mem,reg32 \321\300\1\x11\101 386,SM
ADC reg32,reg32 \321\1\x11\101 386
+ADC mem,reg64 \321\300\1\x11\101 X64,SM
+ADC reg64,reg64 \321\1\x11\101 X64
ADC reg8,mem \301\1\x12\110 8086,SM
ADC reg8,reg8 \1\x12\110 8086
ADC reg16,mem \320\301\1\x13\110 8086,SM
ADC reg16,reg16 \320\1\x13\110 8086
ADC reg32,mem \321\301\1\x13\110 386,SM
ADC reg32,reg32 \321\1\x13\110 386
+ADC reg64,mem \321\301\1\x13\110 X64,SM
+ADC reg64,reg64 \321\1\x13\110 X64
ADC rm16,imm8 \320\300\1\x83\202\15 8086
ADC rm32,imm8 \321\300\1\x83\202\15 386
+ADC rm64,imm8 \321\300\1\x83\202\15 X64
ADC reg_al,imm \1\x14\21 8086,SM
ADC reg_ax,sbyte \320\1\x83\202\15 8086,SM,ND
ADC reg_ax,imm \320\1\x15\31 8086,SM
ADC reg_eax,sbyte \321\1\x83\202\15 386,SM,ND
ADC reg_eax,imm \321\1\x15\41 386,SM
+ADC reg_rax,sbyte \321\1\x83\202\15 X64,SM,ND
+ADC reg_rax,imm \321\1\x15\41 X64,SM
ADC rm8,imm \300\1\x80\202\21 8086,SM
ADC rm16,imm \320\300\134\1\x81\202\131 8086,SM
ADC rm32,imm \321\300\144\1\x81\202\141 386,SM
+ADC rm64,imm \321\300\144\1\x81\202\141 X64,SM
ADC mem,imm8 \300\1\x80\202\21 8086,SM
ADC mem,imm16 \320\300\134\1\x81\202\131 8086,SM
ADC mem,imm32 \321\300\144\1\x81\202\141 386,SM
ADD reg16,reg16 \320\1\x01\101 8086
ADD mem,reg32 \321\300\1\x01\101 386,SM
ADD reg32,reg32 \321\1\x01\101 386
+ADD mem,reg64 \321\300\1\x01\101 X64,SM
+ADD reg64,reg64 \321\1\x01\101 X64
ADD reg8,mem \301\1\x02\110 8086,SM
ADD reg8,reg8 \1\x02\110 8086
ADD reg16,mem \320\301\1\x03\110 8086,SM
ADD reg16,reg16 \320\1\x03\110 8086
ADD reg32,mem \321\301\1\x03\110 386,SM
ADD reg32,reg32 \321\1\x03\110 386
+ADD reg64,mem \321\301\1\x03\110 X64,SM
+ADD reg64,reg64 \321\1\x03\110 X64
ADD rm16,imm8 \320\300\1\x83\200\15 8086
ADD rm32,imm8 \321\300\1\x83\200\15 386
+ADD rm64,imm8 \321\300\1\x83\200\15 X64
ADD reg_al,imm \1\x04\21 8086,SM
ADD reg_ax,sbyte \320\1\x83\200\15 8086,SM,ND
ADD reg_ax,imm \320\1\x05\31 8086,SM
ADD reg_eax,sbyte \321\1\x83\200\15 386,SM,ND
ADD reg_eax,imm \321\1\x05\41 386,SM
+ADD reg_rax,sbyte \321\1\x83\200\15 X64,SM,ND
+ADD reg_rax,imm \323\1\x05\41 X64,SM
ADD rm8,imm \300\1\x80\200\21 8086,SM
ADD rm16,imm \320\300\134\1\x81\200\131 8086,SM
ADD rm32,imm \321\300\144\1\x81\200\141 386,SM
+ADD rm64,imm \321\300\144\1\x81\200\141 X64,SM
ADD mem,imm8 \300\1\x80\200\21 8086,SM
ADD mem,imm16 \320\300\134\1\x81\200\131 8086,SM
ADD mem,imm32 \321\300\144\1\x81\200\141 386,SM
AND reg16,reg16 \320\1\x21\101 8086
AND mem,reg32 \321\300\1\x21\101 386,SM
AND reg32,reg32 \321\1\x21\101 386
+AND mem,reg64 \321\300\1\x21\101 X64,SM
+AND reg64,reg64 \321\1\x21\101 X64
AND reg8,mem \301\1\x22\110 8086,SM
AND reg8,reg8 \1\x22\110 8086
AND reg16,mem \320\301\1\x23\110 8086,SM
AND reg16,reg16 \320\1\x23\110 8086
AND reg32,mem \321\301\1\x23\110 386,SM
AND reg32,reg32 \321\1\x23\110 386
+AND reg64,mem \321\301\1\x23\110 X64,SM
+AND reg64,reg64 \321\1\x23\110 X64
AND rm16,imm8 \320\300\1\x83\204\15 8086
AND rm32,imm8 \321\300\1\x83\204\15 386
+AND rm64,imm8 \321\300\1\x83\204\15 X64
AND reg_al,imm \1\x24\21 8086,SM
AND reg_ax,sbyte \320\1\x83\204\15 8086,SM,ND
AND reg_ax,imm \320\1\x25\31 8086,SM
AND reg_eax,sbyte \321\1\x83\204\15 386,SM,ND
AND reg_eax,imm \321\1\x25\41 386,SM
+AND reg_rax,sbyte \321\1\x83\204\15 X64,SM,ND
+AND reg_rax,imm \324\1\x25\41 X64,SM
AND rm8,imm \300\1\x80\204\21 8086,SM
AND rm16,imm \320\300\134\1\x81\204\131 8086,SM
AND rm32,imm \321\300\144\1\x81\204\141 386,SM
+AND rm64,imm \321\300\144\1\x81\204\141 X64,SM
AND mem,imm8 \300\1\x80\204\21 8086,SM
AND mem,imm16 \320\300\134\1\x81\204\131 8086,SM
AND mem,imm32 \321\300\144\1\x81\204\141 386,SM
-ARPL mem,reg16 \300\1\x63\101 286,PROT,SM
-ARPL reg16,reg16 \1\x63\101 286,PROT
-BOUND reg16,mem \320\301\1\x62\110 186
-BOUND reg32,mem \321\301\1\x62\110 386
+ARPL mem,reg16 \300\1\x63\101 286,PROT,SM,NOLONG
+ARPL reg16,reg16 \1\x63\101 286,PROT,NOLONG
+BOUND reg16,mem \320\301\1\x62\110 186,NOLONG
+BOUND reg32,mem \321\301\1\x62\110 386,NOLONG
BSF reg16,mem \320\301\2\x0F\xBC\110 386,SM
BSF reg16,reg16 \320\2\x0F\xBC\110 386
BSF reg32,mem \321\301\2\x0F\xBC\110 386,SM
BSF reg32,reg32 \321\2\x0F\xBC\110 386
+BSF reg64,mem \321\301\2\x0F\xBC\110 X64,SM
+BSF reg64,reg64 \321\2\x0F\xBC\110 X64
BSR reg16,mem \320\301\2\x0F\xBD\110 386,SM
BSR reg16,reg16 \320\2\x0F\xBD\110 386
BSR reg32,mem \321\301\2\x0F\xBD\110 386,SM
BSR reg32,reg32 \321\2\x0F\xBD\110 386
+BSR reg64,mem \321\301\2\x0F\xBD\110 X64,SM
+BSR reg64,reg64 \321\2\x0F\xBD\110 X64
BSWAP reg32 \321\1\x0F\10\xC8 486
+BSWAP reg64 \321\1\x0F\10\xC8 X64
BT mem,reg16 \320\300\2\x0F\xA3\101 386,SM
BT reg16,reg16 \320\2\x0F\xA3\101 386
BT mem,reg32 \321\300\2\x0F\xA3\101 386,SM
BT reg32,reg32 \321\2\x0F\xA3\101 386
+BT mem,reg64 \321\300\2\x0F\xA3\101 X64,SM
+BT reg64,reg64 \321\2\x0F\xA3\101 X64
BT rm16,imm \320\300\2\x0F\xBA\204\25 386,SB
BT rm32,imm \321\300\2\x0F\xBA\204\25 386,SB
+BT rm64,imm \321\300\2\x0F\xBA\204\25 X64,SB
BTC mem,reg16 \320\300\2\x0F\xBB\101 386,SM
BTC reg16,reg16 \320\2\x0F\xBB\101 386
BTC mem,reg32 \321\300\2\x0F\xBB\101 386,SM
BTC reg32,reg32 \321\2\x0F\xBB\101 386
+BTC mem,reg64 \321\300\2\x0F\xBB\101 X64,SM
+BTC reg64,reg64 \321\2\x0F\xBB\101 X64
BTC rm16,imm \320\300\2\x0F\xBA\207\25 386,SB
BTC rm32,imm \321\300\2\x0F\xBA\207\25 386,SB
+BTC rm64,imm \321\300\2\x0F\xBA\207\25 X64,SB
BTR mem,reg16 \320\300\2\x0F\xB3\101 386,SM
BTR reg16,reg16 \320\2\x0F\xB3\101 386
BTR mem,reg32 \321\300\2\x0F\xB3\101 386,SM
BTR reg32,reg32 \321\2\x0F\xB3\101 386
+BTR mem,reg64 \321\300\2\x0F\xB3\101 X64,SM
+BTR reg64,reg64 \321\2\x0F\xB3\101 X64
BTR rm16,imm \320\300\2\x0F\xBA\206\25 386,SB
BTR rm32,imm \321\300\2\x0F\xBA\206\25 386,SB
+BTR rm64,imm \321\300\2\x0F\xBA\206\25 X64,SB
BTS mem,reg16 \320\300\2\x0F\xAB\101 386,SM
BTS reg16,reg16 \320\2\x0F\xAB\101 386
BTS mem,reg32 \321\300\2\x0F\xAB\101 386,SM
BTS reg32,reg32 \321\2\x0F\xAB\101 386
+BTS mem,reg64 \321\300\2\x0F\xAB\101 X64,SM
+BTS reg64,reg64 \321\2\x0F\xAB\101 X64
BTS rm16,imm \320\300\2\x0F\xBA\205\25 386,SB
BTS rm32,imm \321\300\2\x0F\xBA\205\25 386,SB
+BTS rm64,imm \321\300\2\x0F\xBA\205\25 X64,SB
CALL imm \322\1\xE8\64 8086
CALL imm|near \322\1\xE8\64 8086
-CALL imm|far \322\1\x9A\34\37 8086,ND
+CALL imm|far \322\1\x9A\34\37 8086,ND,NOLONG
CALL imm16 \320\1\xE8\64 8086
CALL imm16|near \320\1\xE8\64 8086
-CALL imm16|far \320\1\x9A\34\37 8086,ND
+CALL imm16|far \320\1\x9A\34\37 8086,ND,NOLONG
CALL imm32 \321\1\xE8\64 386
CALL imm32|near \321\1\xE8\64 386
-CALL imm32|far \321\1\x9A\34\37 386,ND
-CALL imm:imm \322\1\x9A\35\30 8086
-CALL imm16:imm \320\1\x9A\31\30 8086
-CALL imm:imm16 \320\1\x9A\31\30 8086
-CALL imm32:imm \321\1\x9A\41\30 386
-CALL imm:imm32 \321\1\x9A\41\30 386
+CALL imm32|far \321\1\x9A\34\37 386,ND,NOLONG
+CALL imm:imm \322\1\x9A\35\30 8086,NOLONG
+CALL imm16:imm \320\1\x9A\31\30 8086,NOLONG
+CALL imm:imm16 \320\1\x9A\31\30 8086,NOLONG
+CALL imm32:imm \321\1\x9A\41\30 386,NOLONG
+CALL imm:imm32 \321\1\x9A\41\30 386,NOLONG
CALL mem|far \322\300\1\xFF\203 8086
CALL mem16|far \320\300\1\xFF\203 8086
CALL mem32|far \321\300\1\xFF\203 386
CALL mem|near \322\300\1\xFF\202 8086
CALL mem16|near \320\300\1\xFF\202 8086
-CALL mem32|near \321\300\1\xFF\202 386
+CALL mem32|near \321\300\1\xFF\202 386,NOLONG
+CALL mem64|near \321\300\1\xFF\202 X64
CALL reg16 \320\300\1\xFF\202 8086
-CALL reg32 \321\300\1\xFF\202 386
+CALL reg32 \321\300\1\xFF\202 386,NOLONG
+CALL reg64 \321\300\1\xFF\202 X64
CALL mem \322\300\1\xFF\202 8086
CALL mem16 \320\300\1\xFF\202 8086
-CALL mem32 \321\300\1\xFF\202 386
+CALL mem32 \321\300\1\xFF\202 386,NOLONG
+CALL mem64 \321\300\1\xFF\202 X64
CBW void \320\1\x98 8086
CDQ void \321\1\x99 386
+CDQE void \324\1\x98 X64
CLC void \1\xF8 8086
CLD void \1\xFC 8086
+CLFLUSH mem8 \300\2\x0F\x80\207 X64,AMD,SM
+CLGI void \3\x0F\x01\xDD X64,AMD
CLI void \1\xFA 8086
CLTS void \2\x0F\x06 286,PRIV
CMC void \1\xF5 8086
CMP reg16,reg16 \320\1\x39\101 8086
CMP mem,reg32 \321\300\1\x39\101 386,SM
CMP reg32,reg32 \321\1\x39\101 386
+CMP mem,reg64 \321\300\1\x39\101 X64,SM
+CMP reg64,reg64 \321\1\x39\101 X64
CMP reg8,mem \301\1\x3A\110 8086,SM
CMP reg8,reg8 \1\x3A\110 8086
CMP reg16,mem \320\301\1\x3B\110 8086,SM
CMP reg16,reg16 \320\1\x3B\110 8086
CMP reg32,mem \321\301\1\x3B\110 386,SM
CMP reg32,reg32 \321\1\x3B\110 386
+CMP reg64,mem \321\301\1\x3B\110 X64,SM
+CMP reg64,reg64 \321\1\x3B\110 X64
CMP rm16,imm8 \320\300\1\x83\207\15 8086
CMP rm32,imm8 \321\300\1\x83\207\15 386
+CMP rm64,imm8 \321\300\1\x83\207\15 X64
CMP reg_al,imm \1\x3C\21 8086,SM
CMP reg_ax,sbyte \320\1\x83\207\15 8086,SM,ND
CMP reg_ax,imm \320\1\x3D\31 8086,SM
CMP reg_eax,sbyte \321\1\x83\207\15 386,SM,ND
CMP reg_eax,imm \321\1\x3D\41 386,SM
+CMP reg_rax,sbyte \321\1\x83\207\15 X64,SM,ND
+CMP reg_rax,imm \321\1\x3D\41 X64,SM
CMP rm8,imm \300\1\x80\207\21 8086,SM
CMP rm16,imm \320\300\134\1\x81\207\131 8086,SM
CMP rm32,imm \321\300\144\1\x81\207\141 386,SM
+CMP rm64,imm \321\300\144\1\x81\207\141 X64,SM
CMP mem,imm8 \300\1\x80\207\21 8086,SM
CMP mem,imm16 \320\300\134\1\x81\207\131 8086,SM
CMP mem,imm32 \321\300\144\1\x81\207\141 386,SM
CMPSB void \332\1\xA6 8086
CMPSD void \332\321\1\xA7 386
+CMPSQ void \332\324\1\xA7 X64
CMPSW void \332\320\1\xA7 8086
CMPXCHG mem,reg8 \300\2\x0F\xB0\101 PENT,SM
CMPXCHG reg8,reg8 \2\x0F\xB0\101 PENT
CMPXCHG reg16,reg16 \320\2\x0F\xB1\101 PENT
CMPXCHG mem,reg32 \321\300\2\x0F\xB1\101 PENT,SM
CMPXCHG reg32,reg32 \321\2\x0F\xB1\101 PENT
+CMPXCHG mem,reg64 \321\300\2\x0F\xB1\101 X64,SM
+CMPXCHG reg64,reg64 \321\2\x0F\xB1\101 X64
CMPXCHG486 mem,reg8 \300\2\x0F\xA6\101 486,SM,UNDOC
CMPXCHG486 reg8,reg8 \2\x0F\xA6\101 486,UNDOC
CMPXCHG486 mem,reg16 \320\300\2\x0F\xA7\101 486,SM,UNDOC
CMPXCHG486 mem,reg32 \321\300\2\x0F\xA7\101 486,SM,UNDOC
CMPXCHG486 reg32,reg32 \321\2\x0F\xA7\101 486,UNDOC
CMPXCHG8B mem \300\2\x0F\xC7\201 PENT
+CMPXCHG16B mem \324\300\2\x0F\xC7\201 X64
CPUID void \2\x0F\xA2 PENT
+CQO void \324\1\x99 X64
CWD void \320\1\x99 8086
CWDE void \321\1\x98 386
-DAA void \1\x27 8086
-DAS void \1\x2F 8086
+DAA void \1\x27 8086,NOLONG
+DAS void \1\x2F 8086,NOLONG
DB ignore ignore ignore
DD ignore ignore ignore
-DEC reg16 \320\10\x48 8086
-DEC reg32 \321\10\x48 386
+DEC reg16 \320\10\x48 8086,NOLONG
+DEC reg32 \321\10\x48 386,NOLONG
DEC rm8 \300\1\xFE\201 8086
DEC rm16 \320\300\1\xFF\201 8086
DEC rm32 \321\300\1\xFF\201 386
+DEC rm64 \321\300\1\xFF\201 X64
DIV rm8 \300\1\xF6\206 8086
DIV rm16 \320\300\1\xF7\206 8086
DIV rm32 \321\300\1\xF7\206 386
+DIV rm64 \321\300\1\xF7\206 X64
DQ ignore ignore ignore
DT ignore ignore ignore
DW ignore ignore ignore
IDIV rm8 \300\1\xF6\207 8086
IDIV rm16 \320\300\1\xF7\207 8086
IDIV rm32 \321\300\1\xF7\207 386
+IDIV rm64 \321\300\1\xF7\207 X64
IMUL rm8 \300\1\xF6\205 8086
IMUL rm16 \320\300\1\xF7\205 8086
IMUL rm32 \321\300\1\xF7\205 386
+IMUL rm64 \321\300\1\xF7\205 X64
IMUL reg16,mem \320\301\2\x0F\xAF\110 386,SM
IMUL reg16,reg16 \320\2\x0F\xAF\110 386
IMUL reg32,mem \321\301\2\x0F\xAF\110 386,SM
IMUL reg32,reg32 \321\2\x0F\xAF\110 386
+IMUL reg64,mem \321\301\2\x0F\xAF\110 X64,SM
+IMUL reg64,reg64 \321\2\x0F\xAF\110 X64
IMUL reg16,mem,imm8 \320\301\1\x6B\110\16 186,SM
IMUL reg16,mem,sbyte \320\301\1\x6B\110\16 186,SM,ND
IMUL reg16,mem,imm16 \320\301\1\x69\110\32 186,SM
IMUL reg32,reg32,sbyte \321\1\x6B\110\16 386,SM,ND
IMUL reg32,reg32,imm32 \321\1\x69\110\42 386
IMUL reg32,reg32,imm \321\145\1\x69\110\142 386,SM,ND
+IMUL reg64,mem,imm8 \321\301\1\x6B\110\16 X64,SM
+IMUL reg64,mem,sbyte \321\301\1\x6B\110\16 X64,SM,ND
+IMUL reg64,mem,imm32 \321\301\1\x69\110\42 X64,SM
+IMUL reg64,mem,imm \321\301\145\1\x69\110\142 X64,SM,ND
+IMUL reg64,reg64,imm8 \321\1\x6B\110\16 X64
+IMUL reg64,reg64,sbyte \321\1\x6B\110\16 X64,SM,ND
+IMUL reg64,reg64,imm32 \321\1\x69\110\42 X64
+IMUL reg64,reg64,imm \321\145\1\x69\110\142 X64,SM,ND
IMUL reg16,imm8 \320\1\x6B\100\15 186
IMUL reg16,sbyte \320\1\x6B\100\15 186,SM,ND
IMUL reg16,imm16 \320\1\x69\100\31 186
IMUL reg32,sbyte \321\1\x6B\100\15 386,SM,ND
IMUL reg32,imm32 \321\1\x69\100\41 386
IMUL reg32,imm \321\144\1\x69\100\141 386,SM,ND
+IMUL reg64,sbyte \321\1\x6B\100\15 X64,SM,ND
+IMUL reg64,imm32 \321\1\x69\100\41 X64
+IMUL reg64,imm \321\144\1\x69\100\141 X64,SM,ND
IN reg_al,imm \1\xE4\25 8086,SB
IN reg_ax,imm \320\1\xE5\25 8086,SB
IN reg_eax,imm \321\1\xE5\25 386,SB
IN reg_al,reg_dx \1\xEC 8086
IN reg_ax,reg_dx \320\1\xED 8086
IN reg_eax,reg_dx \321\1\xED 386
-INC reg16 \320\10\x40 8086
-INC reg32 \321\10\x40 386
+INC reg16 \320\10\x40 8086,NOLONG
+INC reg32 \321\10\x40 386,NOLONG
INC rm8 \300\1\xFE\200 8086
INC rm16 \320\300\1\xFF\200 8086
INC rm32 \321\300\1\xFF\200 386
+INC rm64 \321\300\1\xFF\200 X64
INCBIN ignore ignore ignore
INSB void \1\x6C 186
INSD void \321\1\x6D 386
INT1 void \1\xF1 386
INT03 void \1\xCC 8086,ND
INT3 void \1\xCC 8086
-INTO void \1\xCE 8086
+INTO void \1\xCE 8086,NOLONG
INVD void \2\x0F\x08 486,PRIV
INVLPG mem \300\2\x0F\x01\207 486,PRIV
+INVLPGA void \3\x0F\x01\xDF X64,AMD
IRET void \322\1\xCF 8086
IRETD void \321\1\xCF 386
+IRETQ void \324\1\xCF X64
IRETW void \320\1\xCF 8086
-JCXZ imm \310\1\xE3\50 8086
+JCXZ imm \310\1\xE3\50 8086,NOLONG
JECXZ imm \311\1\xE3\50 386
JMP imm|short \1\xEB\50 8086
JMP imm \371\1\xEB\50 8086,ND
JMP imm \322\1\xE9\64 8086
JMP imm|near \322\1\xE9\64 8086,ND
-JMP imm|far \322\1\xEA\34\37 8086,ND
+JMP imm|far \322\1\xEA\34\37 8086,ND,NOLONG
JMP imm16 \320\1\xE9\64 8086
JMP imm16|near \320\1\xE9\64 8086,ND
-JMP imm16|far \320\1\xEA\34\37 8086,ND
+JMP imm16|far \320\1\xEA\34\37 8086,ND,NOLONG
JMP imm32 \321\1\xE9\64 386
JMP imm32|near \321\1\xE9\64 386,ND
-JMP imm32|far \321\1\xEA\34\37 386,ND
-JMP imm:imm \322\1\xEA\35\30 8086
-JMP imm16:imm \320\1\xEA\31\30 8086
-JMP imm:imm16 \320\1\xEA\31\30 8086
-JMP imm32:imm \321\1\xEA\41\30 386
-JMP imm:imm32 \321\1\xEA\41\30 386
+JMP imm32|far \321\1\xEA\34\37 386,ND,NOLONG
+JMP imm:imm \322\1\xEA\35\30 8086,NOLONG
+JMP imm16:imm \320\1\xEA\31\30 8086,NOLONG
+JMP imm:imm16 \320\1\xEA\31\30 8086,NOLONG
+JMP imm32:imm \321\1\xEA\41\30 386,NOLONG
+JMP imm:imm32 \321\1\xEA\41\30 386,NOLONG
JMP mem|far \322\300\1\xFF\205 8086
JMP mem16|far \320\300\1\xFF\205 8086
JMP mem32|far \321\300\1\xFF\205 386
JMP mem|near \322\300\1\xFF\204 8086
JMP mem16|near \320\300\1\xFF\204 8086
-JMP mem32|near \321\300\1\xFF\204 386
+JMP mem32|near \321\300\1\xFF\204 386,NOLONG
+JMP mem64|near \321\300\1\xFF\204 X64
JMP reg16 \320\300\1\xFF\204 8086
-JMP reg32 \321\300\1\xFF\204 386
+JMP reg32 \321\300\1\xFF\204 386,NOLONG
+JMP reg64 \321\300\1\xFF\204 X64
JMP mem \322\300\1\xFF\204 8086
JMP mem16 \320\300\1\xFF\204 8086
-JMP mem32 \321\300\1\xFF\204 386
+JMP mem32 \321\300\1\xFF\204 386,NOLONG
+JMP mem64 \321\300\1\xFF\204 X64
JMPE imm \322\2\x0F\xB8\64 IA64
JMPE imm16 \320\2\x0F\xB8\64 IA64
JMPE imm32 \321\2\x0F\xB8\64 IA64
JMPE rm16 \320\2\x0F\x00\206 IA64
JMPE rm32 \321\2\x0F\x00\206 IA64
+JRCXZ imm \300\1\xE3\50 X64
LAHF void \1\x9F 8086
LAR reg16,mem \320\301\2\x0F\x02\110 286,PROT,SM
LAR reg16,reg16 \320\2\x0F\x02\110 286,PROT
LAR reg32,mem \321\301\2\x0F\x02\110 386,PROT,SM
LAR reg32,reg32 \321\2\x0F\x02\110 386,PROT
-LDS reg16,mem \320\301\1\xC5\110 8086
-LDS reg32,mem \321\301\1\xC5\110 386
+LAR reg64,mem \321\301\2\x0F\x02\110 X64,SM
+LAR reg64,reg64 \321\2\x0F\x02\110 X64,PROT
+LDS reg16,mem \320\301\1\xC5\110 8086,NOLONG
+LDS reg32,mem \321\301\1\xC5\110 386,NOLONG
LEA reg16,mem \320\301\1\x8D\110 8086
LEA reg32,mem \321\301\1\x8D\110 386
+LEA reg64,mem \321\301\1\x8D\110 X64
LEAVE void \1\xC9 186
-LES reg16,mem \320\301\1\xC4\110 8086
-LES reg32,mem \321\301\1\xC4\110 386
+LES reg16,mem \320\301\1\xC4\110 8086,NOLONG
+LES reg32,mem \321\301\1\xC4\110 386,NOLONG
+LFENCE void \3\x0F\xAE\xE8 X64,AMD
LFS reg16,mem \320\301\2\x0F\xB4\110 386
LFS reg32,mem \321\301\2\x0F\xB4\110 386
LGDT mem \300\2\x0F\x01\202 286,PRIV
LOADALL286 void \2\x0F\x05 286,UNDOC
LODSB void \1\xAC 8086
LODSD void \321\1\xAD 386
+LODSQ void \324\1\xAD X64
LODSW void \320\1\xAD 8086
LOOP imm \312\1\xE2\50 8086
-LOOP imm,reg_cx \310\1\xE2\50 8086
+LOOP imm,reg_cx \310\1\xE2\50 8086,NOLONG
LOOP imm,reg_ecx \311\1\xE2\50 386
+LOOP imm,reg_rcx \313\1\xE2\50 X64
LOOPE imm \312\1\xE1\50 8086
-LOOPE imm,reg_cx \310\1\xE1\50 8086
+LOOPE imm,reg_cx \310\1\xE1\50 8086,NOLONG
LOOPE imm,reg_ecx \311\1\xE1\50 386
+LOOPE imm,reg_rcx \313\1\xE1\50 X64
LOOPNE imm \312\1\xE0\50 8086
-LOOPNE imm,reg_cx \310\1\xE0\50 8086
+LOOPNE imm,reg_cx \310\1\xE0\50 8086,NOLONG
LOOPNE imm,reg_ecx \311\1\xE0\50 386
+LOOPNE imm,reg_rcx \313\1\xE0\50 X64
LOOPNZ imm \312\1\xE0\50 8086
-LOOPNZ imm,reg_cx \310\1\xE0\50 8086
+LOOPNZ imm,reg_cx \310\1\xE0\50 8086,NOLONG
LOOPNZ imm,reg_ecx \311\1\xE0\50 386
+LOOPNZ imm,reg_rcx \313\1\xE0\50 X64
LOOPZ imm \312\1\xE1\50 8086
-LOOPZ imm,reg_cx \310\1\xE1\50 8086
+LOOPZ imm,reg_cx \310\1\xE1\50 8086,NOLONG
LOOPZ imm,reg_ecx \311\1\xE1\50 386
+LOOPZ imm,reg_rcx \313\1\xE1\50 X64
LSL reg16,mem \320\301\2\x0F\x03\110 286,PROT,SM
LSL reg16,reg16 \320\2\x0F\x03\110 286,PROT
LSL reg32,mem \321\301\2\x0F\x03\110 386,PROT,SM
LSL reg32,reg32 \321\2\x0F\x03\110 386,PROT
+LSL reg64,mem \321\301\2\x0F\x03\110 X64,SM
+LSL reg64,reg64 \321\2\x0F\x03\110 X64,PROT
LSS reg16,mem \320\301\2\x0F\xB2\110 386
LSS reg32,mem \321\301\2\x0F\xB2\110 386
LTR mem \300\1\x0F\17\203 286,PROT,PRIV
-LTR mem16 \300\1\x0F\17\203 286,PROT,PRIV
-LTR reg16 \1\x0F\17\203 286,PROT,PRIV
+LTR mem16 \300\1\x0F\17\203 286,PROT,PRIV,NOLONG
+LTR reg16 \1\x0F\17\203 286,PROT,PRIV,NOLONG
+MFENCE void \3\x0F\xAE\xF0 X64,AMD
MONITOR void \3\x0F\x01\xC8 PRESCOTT
MONITOR reg_eax,reg_ecx,reg_edx \3\x0F\x01\xC8 PRESCOTT,ND
MOV mem,reg_sreg \300\1\x8C\101 8086,SM
MOV reg_al,mem_offs \301\1\xA0\45 8086,SM
MOV reg_ax,mem_offs \301\320\1\xA1\45 8086,SM
MOV reg_eax,mem_offs \301\321\1\xA1\45 386,SM
+MOV reg_rax,mem_offs \301\321\1\xA1\45 X64,SM
MOV mem_offs,reg_al \300\1\xA2\44 8086,SM
MOV mem_offs,reg_ax \300\320\1\xA3\44 8086,SM
MOV mem_offs,reg_eax \300\321\1\xA3\44 386,SM
+MOV mem_offs,reg_rax \300\321\1\xA3\44 X64,SM
+MOV reg32,reg_c8reg \3\xF0\x0F\x20\101 NOLONG
+MOV reg_c8reg,reg32 \3\xF0\x0F\x22\110 NOLONG
+MOV reg32,reg_c8reg \321\2\x0F\x20\101 X64
+MOV reg64,reg_c8reg \323\2\x0F\x20\101 X64
+MOV reg_c8reg,reg32 \321\2\x0F\x22\110 X64
+MOV reg_c8reg,reg64 \323\2\x0F\x22\110 X64
MOV reg32,reg_creg \2\x0F\x20\101 386,PRIV
-MOV reg32,reg_dreg \2\x0F\x21\101 386,PRIV
-MOV reg32,reg_treg \2\x0F\x24\101 386,PRIV
+MOV reg64,reg_creg \323\2\x0F\x20\101 X64
MOV reg_creg,reg32 \2\x0F\x22\110 386,PRIV
+MOV reg_creg,reg64 \323\2\x0F\x22\110 X64
+MOV reg32,reg_dreg \2\x0F\x21\101 386,PRIV
+MOV reg64,reg_dreg \323\2\x0F\x21\101 X64
MOV reg_dreg,reg32 \2\x0F\x23\110 386,PRIV
+MOV reg_dreg,reg64 \323\2\x0F\x23\110 X64
+MOV reg32,reg_treg \2\x0F\x24\101 386,PRIV
+MOV reg64,reg_treg \323\2\x0F\x24\101 X64
MOV reg_treg,reg32 \2\x0F\x26\110 386,PRIV
+MOV reg_treg,reg64 \323\2\x0F\x26\110 X64
MOV mem,reg8 \300\1\x88\101 8086,SM
MOV reg8,reg8 \1\x88\101 8086
MOV mem,reg16 \320\300\1\x89\101 8086,SM
MOV reg16,reg16 \320\1\x89\101 8086
MOV mem,reg32 \321\300\1\x89\101 386,SM
MOV reg32,reg32 \321\1\x89\101 386
+MOV mem,reg64 \321\300\1\x89\101 X64,SM
+MOV reg64,reg64 \321\1\x89\101 X64
MOV reg8,mem \301\1\x8A\110 8086,SM
MOV reg8,reg8 \1\x8A\110 8086
MOV reg16,mem \320\301\1\x8B\110 8086,SM
MOV reg16,reg16 \320\1\x8B\110 8086
MOV reg32,mem \321\301\1\x8B\110 386,SM
MOV reg32,reg32 \321\1\x8B\110 386
+MOV reg64,mem \321\301\1\x8B\110 X64,SM
+MOV reg64,reg64 \321\1\x8B\110 X64
MOV reg8,imm \10\xB0\21 8086,SM
MOV reg16,imm \320\10\xB8\31 8086,SM
MOV reg32,imm \321\10\xB8\41 386,SM
+MOV reg64,imm \321\10\xB8\55 X64,SM
MOV rm8,imm \300\1\xC6\200\21 8086,SM
MOV rm16,imm \320\300\1\xC7\200\31 8086,SM
MOV rm32,imm \321\300\1\xC7\200\41 386,SM
+MOV rm64,imm \321\300\1\xC7\200\41 X64,SM
MOV mem,imm8 \300\1\xC6\200\21 8086,SM
MOV mem,imm16 \320\300\1\xC7\200\31 8086,SM
MOV mem,imm32 \321\300\1\xC7\200\41 386,SM
MOVD mmxreg,mem \301\2\x0F\x6E\110 PENT,MMX,SD
MOVD mmxreg,reg32 \2\x0F\x6E\110 PENT,MMX
+MOVD mmxreg,reg64 \2\x0F\x6E\110 X64,MMX
MOVD mem,mmxreg \300\2\x0F\x7E\101 PENT,MMX,SD
MOVD reg32,mmxreg \2\x0F\x7E\101 PENT,MMX
+MOVD reg64,mmxreg \2\x0F\x7E\101 X64,MMX
+MOVD xmmreg,mem \320\301\2\x0F\x6E\110 X64,SD
+MOVD xmmreg,reg32 \320\2\x0F\x6E\110 X64
+MOVD xmmreg,reg64 \320\2\x0F\x6E\110 X64
+MOVD mem,xmmreg \320\300\2\x0F\x7E\101 X64,SD
+MOVD reg32,xmmreg \320\2\x0F\x7E\101 X64,SSE
+MOVD reg64,xmmreg \320\2\x0F\x7E\101 X64,SSE
+MOVMSKPD reg32,xmmreg \320\2\x0F\x50\101 X64,SSE
+MOVMSKPS reg32,xmmreg \2\x0F\x50\101 X64,SSE
MOVQ mmxreg,mem \301\2\x0F\x6F\110 PENT,MMX,SM
MOVQ mmxreg,mmxreg \2\x0F\x6F\110 PENT,MMX
MOVQ mem,mmxreg \300\2\x0F\x7F\101 PENT,MMX,SM
MOVQ mmxreg,mmxreg \2\x0F\x7F\101 PENT,MMX
MOVSB void \1\xA4 8086
MOVSD void \321\1\xA5 386
+MOVSQ void \324\1\xA5 X64
MOVSW void \320\1\xA5 8086
MOVSX reg16,mem \320\301\2\x0F\xBE\110 386,SB
MOVSX reg16,reg8 \320\2\x0F\xBE\110 386
MOVSX reg32,rm8 \321\301\2\x0F\xBE\110 386
MOVSX reg32,rm16 \321\301\2\x0F\xBF\110 386
+MOVSX reg64,rm8 \321\301\2\x0F\xBE\110 X64
+MOVSX reg64,rm16 \321\301\2\x0F\xBF\110 X64
+MOVSX reg64,rm32 \321\301\1\x63\110 X64
MOVZX reg16,mem \320\301\2\x0F\xB6\110 386,SB
MOVZX reg16,reg8 \320\2\x0F\xB6\110 386
MOVZX reg32,rm8 \321\301\2\x0F\xB6\110 386
MOVZX reg32,rm16 \321\301\2\x0F\xB7\110 386
+MOVZX reg64,rm8 \321\301\2\x0F\xB6\110 X64
+MOVZX reg64,rm16 \321\301\2\x0F\xB7\110 X64
MUL rm8 \300\1\xF6\204 8086
MUL rm16 \320\300\1\xF7\204 8086
MUL rm32 \321\300\1\xF7\204 386
+MUL rm64 \321\300\1\xF7\204 X64
MWAIT void \3\x0F\x01\xC9 PRESCOTT
MWAIT reg_eax,reg_ecx \3\x0F\x01\xC9 PRESCOTT,ND
NEG rm8 \300\1\xF6\203 8086
NEG rm16 \320\300\1\xF7\203 8086
NEG rm32 \321\300\1\xF7\203 386
+NEG rm64 \321\300\1\xF7\203 X64
NOP void \1\x90 8086
NOT rm8 \300\1\xF6\202 8086
NOT rm16 \320\300\1\xF7\202 8086
NOT rm32 \321\300\1\xF7\202 386
+NOT rm64 \321\300\1\xF7\202 X64
OR mem,reg8 \300\1\x08\101 8086,SM
OR reg8,reg8 \1\x08\101 8086
OR mem,reg16 \320\300\1\x09\101 8086,SM
OR reg16,reg16 \320\1\x09\101 8086
OR mem,reg32 \321\300\1\x09\101 386,SM
OR reg32,reg32 \321\1\x09\101 386
+OR mem,reg64 \321\300\1\x09\101 X64,SM
+OR reg64,reg64 \321\1\x09\101 X64
OR reg8,mem \301\1\x0A\110 8086,SM
OR reg8,reg8 \1\x0A\110 8086
OR reg16,mem \320\301\1\x0B\110 8086,SM
OR reg16,reg16 \320\1\x0B\110 8086
OR reg32,mem \321\301\1\x0B\110 386,SM
OR reg32,reg32 \321\1\x0B\110 386
+OR reg64,mem \321\301\1\x0B\110 X64,SM
+OR reg64,reg64 \321\1\x0B\110 X64
OR rm16,imm8 \320\300\1\x83\201\15 8086
OR rm32,imm8 \321\300\1\x83\201\15 386
+OR rm64,imm8 \321\300\1\x83\201\15 X64
OR reg_al,imm \1\x0C\21 8086,SM
OR reg_ax,sbyte \320\1\x83\201\15 8086,SM,ND
OR reg_ax,imm \320\1\x0D\31 8086,SM
OR reg_eax,sbyte \321\1\x83\201\15 386,SM,ND
OR reg_eax,imm \321\1\x0D\41 386,SM
+OR reg_rax,sbyte \321\1\x83\201\15 X64,SM,ND
+OR reg_rax,imm \321\1\x0D\41 X64,SM
OR rm8,imm \300\1\x80\201\21 8086,SM
OR rm16,imm \320\300\134\1\x81\201\131 8086,SM
OR rm32,imm \321\300\144\1\x81\201\141 386,SM
+OR rm64,imm \321\300\144\1\x81\201\141 X64,SM
OR mem,imm8 \300\1\x80\201\21 8086,SM
OR mem,imm16 \320\300\134\1\x81\201\131 8086,SM
OR mem,imm32 \321\300\144\1\x81\201\141 386,SM
PAND mmxreg,mmxreg \2\x0F\xDB\110 PENT,MMX
PANDN mmxreg,mem \301\2\x0F\xDF\110 PENT,MMX,SM
PANDN mmxreg,mmxreg \2\x0F\xDF\110 PENT,MMX
+PAUSE void \2\xF3\x90 X64,AMD
PAVEB mmxreg,mem \301\2\x0F\x50\110 PENT,MMX,SM,CYRIX
PAVEB mmxreg,mmxreg \2\x0F\x50\110 PENT,MMX,CYRIX
PAVGUSB mmxreg,mem \301\2\x0F\x0F\110\01\xBF PENT,3DNOW,SM
PMVNZB mmxreg,mem \301\2\x0F\x5A\110 PENT,MMX,SM,CYRIX
PMVZB mmxreg,mem \301\2\x0F\x58\110 PENT,MMX,SM,CYRIX
POP reg16 \320\10\x58 8086
-POP reg32 \321\10\x58 386
+POP reg32 \321\10\x58 386,NOLONG
+POP reg64 \323\10\x58 X64
POP rm16 \320\300\1\x8F\200 8086
-POP rm32 \321\300\1\x8F\200 386
+POP rm32 \321\300\1\x8F\200 386,NOLONG
+POP rm64 \323\300\1\x8F\200 X64
POP reg_cs \1\x0F 8086,UNDOC,ND
-POP reg_dess \4 8086
+POP reg_dess \4 8086,NOLONG
POP reg_fsgs \1\x0F\5 386
-POPA void \322\1\x61 186
-POPAD void \321\1\x61 386
-POPAW void \320\1\x61 186
+POPA void \322\1\x61 186,NOLONG
+POPAD void \321\1\x61 386,NOLONG
+POPAW void \320\1\x61 186,NOLONG
POPF void \322\1\x9D 8086
-POPFD void \321\1\x9D 386
+POPFD void \321\1\x9D 386,NOLONG
+POPFQ void \321\1\x9D X64
POPFW void \320\1\x9D 8086
POR mmxreg,mem \301\2\x0F\xEB\110 PENT,MMX,SM
POR mmxreg,mmxreg \2\x0F\xEB\110 PENT,MMX
PREFETCH mem \2\x0F\x0D\200 PENT,3DNOW,SM
PREFETCHW mem \2\x0F\x0D\201 PENT,3DNOW,SM
+PREFETCHNTA mem \2\x0F\x18\200 X64,AMD,SM
+PREFETCHT0 mem \2\x0F\x18\200 X64,AMD,SM
+PREFETCHT1 mem \2\x0F\x18\201 X64,AMD,SM
+PREFETCHT2 mem \2\x0F\x18\202 X64,AMD,SM
PSLLD mmxreg,mem \301\2\x0F\xF2\110 PENT,MMX,SM
PSLLD mmxreg,mmxreg \2\x0F\xF2\110 PENT,MMX
PSLLD mmxreg,imm \2\x0F\x72\206\25 PENT,MMX
PUNPCKLWD mmxreg,mem \301\2\x0F\x61\110 PENT,MMX,SM
PUNPCKLWD mmxreg,mmxreg \2\x0F\x61\110 PENT,MMX
PUSH reg16 \320\10\x50 8086
-PUSH reg32 \321\10\x50 386
+PUSH reg32 \321\10\x50 386,NOLONG
+PUSH reg64 \323\10\x50 X64
PUSH rm16 \320\300\1\xFF\206 8086
-PUSH rm32 \321\300\1\xFF\206 386
-PUSH reg_cs \6 8086
-PUSH reg_dess \6 8086
+PUSH rm32 \321\300\1\xFF\206 386,NOLONG
+PUSH rm64 \323\300\1\xFF\206 X64
+PUSH reg_cs \6 8086,NOLONG
+PUSH reg_dess \6 8086,NOLONG
PUSH reg_fsgs \1\x0F\7 386
PUSH imm8 \1\x6A\14 186
PUSH sbyte \1\x6A\14 186,ND
PUSH imm16 \320\133\1\x68\130 186
-PUSH imm32 \321\143\1\x68\140 386
+PUSH imm32 \321\143\1\x68\140 386,NOLONG
+PUSH imm64 \321\143\1\x68\140 X64
PUSH imm \1\x68\34 186
-PUSHA void \322\1\x60 186
-PUSHAD void \321\1\x60 386
-PUSHAW void \320\1\x60 186
+PUSHA void \322\1\x60 186,NOLONG
+PUSHAD void \321\1\x60 386,NOLONG
+PUSHAW void \320\1\x60 186,NOLONG
PUSHF void \322\1\x9C 8086
-PUSHFD void \321\1\x9C 386
+PUSHFD void \321\1\x9C 386,NOLONG
+PUSHFQ void \321\1\x9C X64
PUSHFW void \320\1\x9C 8086
PXOR mmxreg,mem \301\2\x0F\xEF\110 PENT,MMX,SM
PXOR mmxreg,mmxreg \2\x0F\xEF\110 PENT,MMX
RCL rm32,unity \321\300\1\xD1\202 386
RCL rm32,reg_cl \321\300\1\xD3\202 386
RCL rm32,imm \321\300\1\xC1\202\25 386,SB
+RCL rm64,unity \321\300\1\xD1\202 X64
+RCL rm64,reg_cl \321\300\1\xD3\202 X64
+RCL rm64,imm \321\300\1\xC1\202\25 X64,SB
RCR rm8,unity \300\1\xD0\203 8086
RCR rm8,reg_cl \300\1\xD2\203 8086
RCR rm8,imm \300\1\xC0\203\25 186,SB
RCR rm32,unity \321\300\1\xD1\203 386
RCR rm32,reg_cl \321\300\1\xD3\203 386
RCR rm32,imm \321\300\1\xC1\203\25 386,SB
+RCR rm64,unity \321\300\1\xD1\203 X64
+RCR rm64,reg_cl \321\300\1\xD3\203 X64
+RCR rm64,imm \321\300\1\xC1\203\25 X64,SB
RDSHR rm32 \321\300\2\x0F\x36\200 P6,CYRIX,SMM
RDMSR void \2\x0F\x32 PENT,PRIV
RDPMC void \2\x0F\x33 P6
RDTSC void \2\x0F\x31 PENT
+RDTSCP void \3\x0F\x01\xF9 X64
RESB imm \340 8086
RESD ignore ignore ignore
RESQ ignore ignore ignore
ROL rm32,unity \321\300\1\xD1\200 386
ROL rm32,reg_cl \321\300\1\xD3\200 386
ROL rm32,imm \321\300\1\xC1\200\25 386,SB
+ROL rm64,unity \321\300\1\xD1\200 X64
+ROL rm64,reg_cl \321\300\1\xD3\200 X64
+ROL rm64,imm \321\300\1\xC1\200\25 X64,SB
ROR rm8,unity \300\1\xD0\201 8086
ROR rm8,reg_cl \300\1\xD2\201 8086
ROR rm8,imm \300\1\xC0\201\25 186,SB
ROR rm32,unity \321\300\1\xD1\201 386
ROR rm32,reg_cl \321\300\1\xD3\201 386
ROR rm32,imm \321\300\1\xC1\201\25 386,SB
+ROR rm64,unity \321\300\1\xD1\201 X64
+ROR rm64,reg_cl \321\300\1\xD3\201 X64
+ROR rm64,imm \321\300\1\xC1\201\25 X64,SB
RSDC reg_sreg,mem80 \301\2\x0F\x79\110 486,CYRIX,SMM
RSLDT mem80 \300\2\x0F\x7B\200 486,CYRIX,SMM
RSM void \2\x0F\xAA PENT,SMM
SAL rm32,unity \321\300\1\xD1\204 386,ND
SAL rm32,reg_cl \321\300\1\xD3\204 386,ND
SAL rm32,imm \321\300\1\xC1\204\25 386,ND,SB
+SAL rm64,unity \321\300\1\xD1\204 X64,ND
+SAL rm64,reg_cl \321\300\1\xD3\204 X64,ND
+SAL rm64,imm \321\300\1\xC1\204\25 X64,ND,SB
SALC void \1\xD6 8086,UNDOC
SAR rm8,unity \300\1\xD0\207 8086
SAR rm8,reg_cl \300\1\xD2\207 8086
SAR rm32,unity \321\300\1\xD1\207 386
SAR rm32,reg_cl \321\300\1\xD3\207 386
SAR rm32,imm \321\300\1\xC1\207\25 386,SB
+SAR rm64,unity \321\300\1\xD1\207 X64
+SAR rm64,reg_cl \321\300\1\xD3\207 X64
+SAR rm64,imm \321\300\1\xC1\207\25 X64,SB
SBB mem,reg8 \300\1\x18\101 8086,SM
SBB reg8,reg8 \1\x18\101 8086
SBB mem,reg16 \320\300\1\x19\101 8086,SM
SBB reg16,reg16 \320\1\x19\101 8086
SBB mem,reg32 \321\300\1\x19\101 386,SM
SBB reg32,reg32 \321\1\x19\101 386
+SBB mem,reg64 \321\300\1\x19\101 X64,SM
+SBB reg64,reg64 \321\1\x19\101 X64
SBB reg8,mem \301\1\x1A\110 8086,SM
SBB reg8,reg8 \1\x1A\110 8086
SBB reg16,mem \320\301\1\x1B\110 8086,SM
SBB reg16,reg16 \320\1\x1B\110 8086
SBB reg32,mem \321\301\1\x1B\110 386,SM
SBB reg32,reg32 \321\1\x1B\110 386
+SBB reg64,mem \321\301\1\x1B\110 X64,SM
+SBB reg64,reg64 \321\1\x1B\110 X64
SBB rm16,imm8 \320\300\1\x83\203\15 8086
SBB rm32,imm8 \321\300\1\x83\203\15 386
+SBB rm64,imm8 \321\300\1\x83\203\15 X64
SBB reg_al,imm \1\x1C\21 8086,SM
SBB reg_ax,sbyte \320\1\x83\203\15 8086,SM,ND
SBB reg_ax,imm \320\1\x1D\31 8086,SM
SBB reg_eax,sbyte \321\1\x83\203\15 386,SM,ND
SBB reg_eax,imm \321\1\x1D\41 386,SM
+SBB reg_rax,sbyte \321\1\x83\203\15 X64,SM,ND
+SBB reg_rax,imm \321\1\x1D\41 X64,SM
SBB rm8,imm \300\1\x80\203\21 8086,SM
SBB rm16,imm \320\300\134\1\x81\203\131 8086,SM
SBB rm32,imm \321\300\144\1\x81\203\141 386,SM
+SBB rm64,imm \321\300\144\1\x81\203\141 X64,SM
SBB mem,imm8 \300\1\x80\203\21 8086,SM
SBB mem,imm16 \320\300\134\1\x81\203\131 8086,SM
SBB mem,imm32 \321\300\144\1\x81\203\141 386,SM
SCASB void \332\1\xAE 8086
SCASD void \332\321\1\xAF 386
+SCASQ void \332\324\1\xAF X64
SCASW void \332\320\1\xAF 8086
+SFENCE void \3\x0F\xAE\xF8 X64,AMD
SGDT mem \300\2\x0F\x01\200 286
SHL rm8,unity \300\1\xD0\204 8086
SHL rm8,reg_cl \300\1\xD2\204 8086
SHL rm32,unity \321\300\1\xD1\204 386
SHL rm32,reg_cl \321\300\1\xD3\204 386
SHL rm32,imm \321\300\1\xC1\204\25 386,SB
+SHL rm64,unity \321\300\1\xD1\204 X64
+SHL rm64,reg_cl \321\300\1\xD3\204 X64
+SHL rm64,imm \321\300\1\xC1\204\25 X64,SB
SHLD mem,reg16,imm \300\320\2\x0F\xA4\101\26 386,SM2,SB,AR2
SHLD reg16,reg16,imm \320\2\x0F\xA4\101\26 386,SM2,SB,AR2
SHLD mem,reg32,imm \300\321\2\x0F\xA4\101\26 386,SM2,SB,AR2
SHLD reg32,reg32,imm \321\2\x0F\xA4\101\26 386,SM2,SB,AR2
+SHLD mem,reg64,imm \300\321\2\x0F\xA4\101\26 X64,SM2,SB,AR2
+SHLD reg64,reg64,imm \321\2\x0F\xA4\101\26 X64,SM2,SB,AR2
SHLD mem,reg16,reg_cl \300\320\2\x0F\xA5\101 386,SM
SHLD reg16,reg16,reg_cl \320\2\x0F\xA5\101 386
SHLD mem,reg32,reg_cl \300\321\2\x0F\xA5\101 386,SM
SHLD reg32,reg32,reg_cl \321\2\x0F\xA5\101 386
+SHLD mem,reg64,reg_cl \300\321\2\x0F\xA5\101 X64,SM
+SHLD reg64,reg64,reg_cl \321\2\x0F\xA5\101 X64
SHR rm8,unity \300\1\xD0\205 8086
SHR rm8,reg_cl \300\1\xD2\205 8086
SHR rm8,imm \300\1\xC0\205\25 186,SB
SHR rm32,unity \321\300\1\xD1\205 386
SHR rm32,reg_cl \321\300\1\xD3\205 386
SHR rm32,imm \321\300\1\xC1\205\25 386,SB
+SHR rm64,unity \321\300\1\xD1\205 X64
+SHR rm64,reg_cl \321\300\1\xD3\205 X64
+SHR rm64,imm \321\300\1\xC1\205\25 X64,SB
SHRD mem,reg16,imm \300\320\2\x0F\xAC\101\26 386,SM2,SB,AR2
SHRD reg16,reg16,imm \320\2\x0F\xAC\101\26 386,SM2,SB,AR2
SHRD mem,reg32,imm \300\321\2\x0F\xAC\101\26 386,SM2,SB,AR2
SHRD reg32,reg32,imm \321\2\x0F\xAC\101\26 386,SM2,SB,AR2
+SHRD mem,reg64,imm \300\321\2\x0F\xAC\101\26 X64,SM2,SB,AR2
+SHRD reg64,reg64,imm \321\2\x0F\xAC\101\26 X64,SM2,SB,AR2
SHRD mem,reg16,reg_cl \300\320\2\x0F\xAD\101 386,SM
SHRD reg16,reg16,reg_cl \320\2\x0F\xAD\101 386
SHRD mem,reg32,reg_cl \300\321\2\x0F\xAD\101 386,SM
SHRD reg32,reg32,reg_cl \321\2\x0F\xAD\101 386
+SHRD mem,reg64,reg_cl \300\321\2\x0F\xAD\101 X64,SM
+SHRD reg64,reg64,reg_cl \321\2\x0F\xAD\101 X64
SIDT mem \300\2\x0F\x01\201 286
SLDT mem \300\1\x0F\17\200 286
SLDT mem16 \300\1\x0F\17\200 286
SLDT reg16 \320\1\x0F\17\200 286
SLDT reg32 \321\1\x0F\17\200 386
+SKINIT void \3\x0F\x01\xDE X64
SMI void \1\xF1 386,UNDOC
SMINT void \2\x0F\x38 P6,CYRIX
; Older Cyrix chips had this; they had to move due to conflict with MMX
SMSW reg32 \321\2\x0F\x01\204 386
STC void \1\xF9 8086
STD void \1\xFD 8086
+STGI void \3\x0F\x01\xDC X64
STI void \1\xFB 8086
STOSB void \1\xAA 8086
STOSD void \321\1\xAB 386
+STOSQ void \324\1\xAB X64
STOSW void \320\1\xAB 8086
STR mem \300\1\x0F\17\201 286,PROT
STR mem16 \300\1\x0F\17\201 286,PROT
STR reg16 \320\1\x0F\17\201 286,PROT
STR reg32 \321\1\x0F\17\201 386,PROT
+STR reg64 \321\1\x0F\17\201 X64
SUB mem,reg8 \300\1\x28\101 8086,SM
SUB reg8,reg8 \1\x28\101 8086
SUB mem,reg16 \320\300\1\x29\101 8086,SM
SUB reg16,reg16 \320\1\x29\101 8086
SUB mem,reg32 \321\300\1\x29\101 386,SM
SUB reg32,reg32 \321\1\x29\101 386
+SUB mem,reg64 \321\300\1\x29\101 X64,SM
+SUB reg64,reg64 \321\1\x29\101 X64
SUB reg8,mem \301\1\x2A\110 8086,SM
SUB reg8,reg8 \1\x2A\110 8086
SUB reg16,mem \320\301\1\x2B\110 8086,SM
SUB reg16,reg16 \320\1\x2B\110 8086
SUB reg32,mem \321\301\1\x2B\110 386,SM
SUB reg32,reg32 \321\1\x2B\110 386
+SUB reg64,mem \321\301\1\x2B\110 X64,SM
+SUB reg64,reg64 \321\1\x2B\110 X64
SUB rm16,imm8 \320\300\1\x83\205\15 8086
SUB rm32,imm8 \321\300\1\x83\205\15 386
+SUB rm64,imm8 \321\300\1\x83\205\15 X64
SUB reg_al,imm \1\x2C\21 8086,SM
SUB reg_ax,sbyte \320\1\x83\205\15 8086,SM,ND
SUB reg_ax,imm \320\1\x2D\31 8086,SM
SUB reg_eax,sbyte \321\1\x83\205\15 386,SM,ND
SUB reg_eax,imm \321\1\x2D\41 386,SM
+SUB reg_rax,sbyte \321\1\x83\205\15 X64,SM,ND
+SUB reg_rax,imm \321\1\x2D\41 X64,SM
SUB rm8,imm \300\1\x80\205\21 8086,SM
SUB rm16,imm \320\300\134\1\x81\205\131 8086,SM
SUB rm32,imm \321\300\144\1\x81\205\141 386,SM
+SUB rm64,imm \321\300\144\1\x81\205\141 X64,SM
SUB mem,imm8 \300\1\x80\205\21 8086,SM
SUB mem,imm16 \320\300\134\1\x81\205\131 8086,SM
SUB mem,imm32 \321\300\144\1\x81\205\141 386,SM
SVDC mem80,reg_sreg \300\2\x0F\x78\101 486,CYRIX,SMM
SVLDT mem80 \300\2\x0F\x7A\200 486,CYRIX,SMM
SVTS mem80 \300\2\x0F\x7C\200 486,CYRIX,SMM
+SWAPGS void \3\x0F\x01\xF8 X64
SYSCALL void \2\x0F\x05 P6,AMD
SYSENTER void \2\x0F\x34 P6
SYSEXIT void \2\x0F\x35 P6,PRIV
TEST reg16,reg16 \320\1\x85\101 8086
TEST mem,reg32 \321\300\1\x85\101 386,SM
TEST reg32,reg32 \321\1\x85\101 386
+TEST mem,reg64 \321\300\1\x85\101 X64,SM
+TEST reg64,reg64 \321\1\x85\101 X64
TEST reg8,mem \301\1\x84\110 8086,SM
TEST reg16,mem \320\301\1\x85\110 8086,SM
TEST reg32,mem \321\301\1\x85\110 386,SM
+TEST reg64,mem \321\301\1\x85\110 X64,SM
TEST reg_al,imm \1\xA8\21 8086,SM
TEST reg_ax,imm \320\1\xA9\31 8086,SM
TEST reg_eax,imm \321\1\xA9\41 386,SM
+TEST reg_rax,imm \321\1\xA9\41 X64,SM
TEST rm8,imm \300\1\xF6\200\21 8086,SM
TEST rm16,imm \320\300\1\xF7\200\31 8086,SM
TEST rm32,imm \321\300\1\xF7\200\41 386,SM
+TEST rm64,imm \321\300\1\xF7\200\41 X64,SM
TEST mem,imm8 \300\1\xF6\200\21 8086,SM
TEST mem,imm16 \320\300\1\xF7\200\31 8086,SM
TEST mem,imm32 \321\300\1\xF7\200\41 386,SM
XADD reg16,reg16 \320\2\x0F\xC1\101 486
XADD mem,reg32 \321\300\2\x0F\xC1\101 486,SM
XADD reg32,reg32 \321\2\x0F\xC1\101 486
+XADD mem,reg64 \321\300\2\x0F\xC1\101 X64,SM
+XADD reg64,reg64 \321\2\x0F\xC1\101 X64
XBTS reg16,mem \320\301\2\x0F\xA6\110 386,SW,UNDOC,ND
XBTS reg16,reg16 \320\2\x0F\xA6\110 386,UNDOC,ND
XBTS reg32,mem \321\301\2\x0F\xA6\110 386,SD,UNDOC,ND
XBTS reg32,reg32 \321\2\x0F\xA6\110 386,UNDOC,ND
-XCHG reg_ax,reg16 \320\11\x90 8086
-XCHG reg_eax,reg32 \321\11\x90 386
-XCHG reg16,reg_ax \320\10\x90 8086
-XCHG reg32,reg_eax \321\10\x90 386
+XCHG reg_ax,reg16 \320\11\x90 8086,NOLONG
+XCHG reg_eax,reg32 \321\11\x90 386,NOLONG
+XCHG reg16,reg_ax \320\10\x90 8086,NOLONG
+XCHG reg32,reg_eax \321\10\x90 386,NOLONG
+XCHG reg_rax,reg_rax \321\11\x90 X64
XCHG reg8,mem \301\1\x86\110 8086,SM
XCHG reg8,reg8 \1\x86\110 8086
XCHG reg16,mem \320\301\1\x87\110 8086,SM
XCHG reg16,reg16 \320\1\x87\110 8086
XCHG reg32,mem \321\301\1\x87\110 386,SM
XCHG reg32,reg32 \321\1\x87\110 386
+XCHG reg64,mem \321\301\1\x87\110 X64,SM
+XCHG reg64,reg64 \321\1\x87\110 X64
XCHG mem,reg8 \300\1\x86\101 8086,SM
XCHG reg8,reg8 \1\x86\101 8086
XCHG mem,reg16 \320\300\1\x87\101 8086,SM
XCHG reg16,reg16 \320\1\x87\101 8086
XCHG mem,reg32 \321\300\1\x87\101 386,SM
XCHG reg32,reg32 \321\1\x87\101 386
+XCHG mem,reg64 \321\300\1\x87\101 X64,SM
+XCHG reg64,reg64 \321\1\x87\101 X64
XLATB void \1\xD7 8086
XLAT void \1\xD7 8086
XOR mem,reg8 \300\1\x30\101 8086,SM
XOR reg16,reg16 \320\1\x31\101 8086
XOR mem,reg32 \321\300\1\x31\101 386,SM
XOR reg32,reg32 \321\1\x31\101 386
+XOR mem,reg64 \321\300\1\x31\101 X64,SM
+XOR reg64,reg64 \321\1\x31\101 X64
XOR reg8,mem \301\1\x32\110 8086,SM
XOR reg8,reg8 \1\x32\110 8086
XOR reg16,mem \320\301\1\x33\110 8086,SM
XOR reg16,reg16 \320\1\x33\110 8086
XOR reg32,mem \321\301\1\x33\110 386,SM
XOR reg32,reg32 \321\1\x33\110 386
+XOR reg64,mem \321\301\1\x33\110 X64,SM
+XOR reg64,reg64 \321\1\x33\110 X64
XOR rm16,imm8 \320\300\1\x83\206\15 8086
XOR rm32,imm8 \321\300\1\x83\206\15 386
+XOR rm64,imm8 \321\300\1\x83\206\15 X64
XOR reg_al,imm \1\x34\21 8086,SM
XOR reg_ax,sbyte \320\1\x83\206\15 8086,SM,ND
XOR reg_ax,imm \320\1\x35\31 8086,SM
XOR reg_eax,sbyte \321\1\x83\206\15 386,SM,ND
XOR reg_eax,imm \321\1\x35\41 386,SM
+XOR reg_rax,sbyte \321\1\x83\206\15 X64,SM,ND
+XOR reg_rax,imm \321\1\x35\41 X64,SM
XOR rm8,imm \300\1\x80\206\21 8086,SM
XOR rm16,imm \320\300\134\1\x81\206\131 8086,SM
XOR rm32,imm \321\300\144\1\x81\206\141 386,SM
+XOR rm64,imm \321\300\144\1\x81\206\141 X64,SM
XOR mem,imm8 \300\1\x80\206\21 8086,SM
XOR mem,imm16 \320\300\134\1\x81\206\131 8086,SM
XOR mem,imm32 \321\300\144\1\x81\206\141 386,SM
CMOVcc reg16,reg16 \320\1\x0F\330\x40\110 P6
CMOVcc reg32,mem \321\301\1\x0F\330\x40\110 P6,SM
CMOVcc reg32,reg32 \321\1\x0F\330\x40\110 P6
+CMOVcc reg64,mem \321\301\1\x0F\330\x40\110 X64,SM
+CMOVcc reg64,reg64 \321\1\x0F\330\x40\110 X64
Jcc imm|near \322\1\x0F\330\x80\64 386
Jcc imm16|near \320\1\x0F\330\x80\64 386
Jcc imm32|near \321\1\x0F\330\x80\64 386
VMCALL void \3\x0F\x01\xC1 VMX
VMCLEAR mem \3\x66\x0F\xC7\206 VMX
VMLAUNCH void \3\x0F\x01\xC2 VMX
+VMLOAD void \3\x0F\x01\xDA X64,VMX
+VMMCALL void \3\x0F\x01\xD9 X64,VMX
VMPTRLD mem \2\x0F\xC7\206 VMX
VMPTRST mem \2\x0F\xC7\207 VMX
VMREAD mem,reg32 \2\x0F\x78\101 VMX
VMREAD reg32,reg32 \2\x0F\x78\101 VMX
VMRESUME void \3\x0F\x01\xC3 VMX
+VMRUN void \3\x0F\x01\xD8 X64,VMX
+VMSAVE void \3\x0F\x01\xDB X64,VMX
VMWRITE reg32,mem \2\x0F\x79\110 VMX
VMWRITE reg32,reg32 \2\x0F\x79\110 VMX
VMXOFF void \3\x0F\x01\xC4 VMX
VMXON mem \3\xF3\x0F\xC7\206 VMX
+
struct itemplate {
int opcode; /* the token, passed from "parser.c" */
int operands; /* number of operands */
- long opd[3]; /* bit flags for operand types */
- const char *code; /* the code it assembles to */
- unsigned long flags; /* some flags */
+ int32_t opd[3]; /* bit flags for operand types */
+ const int8_t *code; /* the code it assembles to */
+ uint32_t flags; /* some flags */
};
/*
#define IF_SM2 0x00000002UL /* size match first two operands */
#define IF_SB 0x00000004UL /* unsized operands can't be non-byte */
#define IF_SW 0x00000008UL /* unsized operands can't be non-word */
-#define IF_SD 0x00000010UL /* unsized operands can't be nondword */
-#define IF_AR0 0x00000020UL /* SB, SW, SD applies to argument 0 */
-#define IF_AR1 0x00000040UL /* SB, SW, SD applies to argument 1 */
-#define IF_AR2 0x00000060UL /* SB, SW, SD applies to argument 2 */
-#define IF_ARMASK 0x00000060UL /* mask for unsized argument spec */
+#define IF_SD 0x00000010UL /* unsized operands can't be non-dword */
+#define IF_SQ 0x00000020UL /* unsized operands can't be non-qword */
+#define IF_AR0 0x00000040UL /* SB, SW, SD applies to argument 0 */
+#define IF_AR1 0x00000080UL /* SB, SW, SD applies to argument 1 */
+#define IF_AR2 0x000000C0UL /* SB, SW, SD applies to argument 2 */
+#define IF_ARMASK 0x000000C0UL /* mask for unsized argument spec */
#define IF_PRIV 0x00000100UL /* it's a privileged instruction */
#define IF_SMM 0x00000200UL /* it's only valid in SMM */
#define IF_PROT 0x00000400UL /* it's protected mode only */
+#define IF_NOLONG 0x00000800UL /* it's not available in long mode */
#define IF_UNDOC 0x00001000UL /* it's an undocumented instruction */
#define IF_FPU 0x00002000UL /* it's an FPU instruction */
#define IF_MMX 0x00004000UL /* it's an MMX instruction */
#define IF_KATMAI 0x07000000UL /* Katmai instructions */
#define IF_WILLAMETTE 0x08000000UL /* Willamette instructions */
#define IF_PRESCOTT 0x09000000UL /* Prescott instructions */
+#define IF_X64 0x0A000000UL /* x86-64 instructions */
#define IF_IA64 0x0F000000UL /* IA64 instructions */
#define IF_CYRIX 0x10000000UL /* Cyrix-specific instruction */
#define IF_AMD 0x20000000UL /* AMD-specific instruction */
print A "/* This file auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
+ print A "#include \<inttypes.h\>\n\n";
print A "#include \"nasm.h\"\n";
print A "#include \"insns.h\"\n";
print A "\n";
print D "/* This file auto-generated from insns.dat by insns.pl" .
" - don't edit it */\n\n";
+ print D "#include \<inttypes.h\>\n\n";
print D "#include \"nasm.h\"\n";
print D "#include \"insns.h\"\n";
print D "\n";
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 "#include \<inttypes.h\>\n\n";
- print N "static const char *insn_names[] = {";
+ print N "static const int8_t *insn_names[] = {";
$first = 1;
foreach $i (@opcodes) {
print N "," if ( !$first );
}
print N "\n};\n\n";
print N "/* Conditional instructions */\n";
- print N "static const char *icn[] = {";
+ print N "static const int8_t *icn[] = {";
$first = 1;
foreach $i (@opcodes_cc) {
print N "," if ( !$first );
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
+#include <inttypes.h>
+
#include "nasm.h"
#include "nasmlib.h"
union label { /* actual label structures */
struct {
- long segment, offset;
- char *label, *special;
+ int32_t segment, offset;
+ int8_t *label, *special;
int is_global, is_norm;
} defn;
struct {
- long movingon, dummy;
+ int32_t movingon, dummy;
union label *next;
} admin;
};
struct permts { /* permanent text storage */
struct permts *next; /* for the linked list */
int size, usage; /* size and used space in ... */
- char data[PERMTS_SIZE]; /* ... the data block itself */
+ int8_t data[PERMTS_SIZE]; /* ... the data block itself */
};
extern int global_offset_changed; /* defined in nasm.c */
static struct permts *perm_tail; /* end of perm. text storage */
static void init_block(union label *blk);
-static char *perm_copy(char *string1, char *string2);
+static int8_t *perm_copy(int8_t *string1, int8_t *string2);
-static char *prevlabel;
+static int8_t *prevlabel;
-static int initialised = FALSE;
+static int initialized = FALSE;
-char lprefix[PREFIX_MAX] = { 0 };
-char lpostfix[PREFIX_MAX] = { 0 };
+int8_t lprefix[PREFIX_MAX] = { 0 };
+int8_t lpostfix[PREFIX_MAX] = { 0 };
/*
* Internal routine: finds the `union label' corresponding to the
* given label name. Creates a new one, if it isn't found, and if
* `create' is TRUE.
*/
-static union label *find_label(char *label, int create)
+static union label *find_label(int8_t *label, int create)
{
int hash = 0;
- char *p, *prev;
+ int8_t *p, *prev;
int prevlen;
union label *lptr;
return NULL;
}
-int lookup_label(char *label, long *segment, long *offset)
+int lookup_label(int8_t *label, int32_t *segment, int32_t *offset)
{
union label *lptr;
- if (!initialised)
+ if (!initialized)
return 0;
lptr = find_label(label, 0);
return 0;
}
-int is_extern(char *label)
+int is_extern(int8_t *label)
{
union label *lptr;
- if (!initialised)
+ if (!initialized)
return 0;
lptr = find_label(label, 0);
return 0;
}
-void redefine_label(char *label, long segment, long offset, char *special,
+void redefine_label(int8_t *label, int32_t segment, int32_t offset, int8_t *special,
int is_norm, int isextrn, struct ofmt *ofmt,
efunc error)
{
if (pass0 == 1) {
exi = !!(lptr->defn.is_global & GLOBAL_BIT);
if (exi) {
- char *xsymbol;
+ int8_t *xsymbol;
int slen;
slen = strlen(lprefix);
slen += strlen(lptr->defn.label);
slen += strlen(lpostfix);
- slen++; /* room for that null char */
+ slen++; /* room for that null int8_t */
xsymbol = nasm_malloc(slen);
snprintf(xsymbol, slen, "%s%s%s", lprefix, lptr->defn.label,
lpostfix);
/* if (pass0 == 1) */
}
-void define_label(char *label, long segment, long offset, char *special,
+void define_label(int8_t *label, int32_t segment, int32_t offset, int8_t *special,
int is_norm, int isextrn, struct ofmt *ofmt, efunc error)
{
union label *lptr;
if (pass0 == 1 || (!is_norm && !isextrn && (segment & 1))) {
exi = !!(lptr->defn.is_global & GLOBAL_BIT);
if (exi) {
- char *xsymbol;
+ int8_t *xsymbol;
int slen;
slen = strlen(lprefix);
slen += strlen(lptr->defn.label);
} /* if (pass0 == 1) */
}
-void define_common(char *label, long segment, long size, char *special,
+void define_common(int8_t *label, int32_t segment, int32_t size, int8_t *special,
struct ofmt *ofmt, efunc error)
{
union label *lptr;
special);
}
-void declare_as_global(char *label, char *special, efunc error)
+void declare_as_global(int8_t *label, int8_t *special, efunc error)
{
union label *lptr;
prevlabel = "";
- initialised = TRUE;
+ initialized = TRUE;
return 0;
}
{
int i;
- initialised = FALSE;
+ initialized = FALSE;
for (i = 0; i < LABEL_HASHES; i++) {
union label *lptr, *lhold;
blk[LABEL_BLOCK - 1].admin.next = NULL;
}
-static char *perm_copy(char *string1, char *string2)
+static int8_t *perm_copy(int8_t *string1, int8_t *string2)
{
- char *p, *q;
+ int8_t *p, *q;
int len = strlen(string1) + strlen(string2) + 1;
if (perm_tail->size - perm_tail->usage < len) {
* distributed in the NASM archive.
*/
-extern char lprefix[PREFIX_MAX];
-extern char lpostfix[PREFIX_MAX];
+extern int8_t lprefix[PREFIX_MAX];
+extern int8_t lpostfix[PREFIX_MAX];
-int lookup_label(char *label, long *segment, long *offset);
-int is_extern(char *label);
-void define_label(char *label, long segment, long offset, char *special,
+int lookup_label(int8_t *label, int32_t *segment, int32_t *offset);
+int is_extern(int8_t *label);
+void define_label(int8_t *label, int32_t segment, int32_t offset, int8_t *special,
int is_norm, int isextrn, struct ofmt *ofmt,
efunc error);
-void redefine_label(char *label, long segment, long offset, char *special,
+void redefine_label(int8_t *label, int32_t segment, int32_t offset, int8_t *special,
int is_norm, int isextrn, struct ofmt *ofmt,
efunc error);
-void define_common(char *label, long segment, long size, char *special,
+void define_common(int8_t *label, int32_t segment, int32_t size, int8_t *special,
struct ofmt *ofmt, efunc error);
-void declare_as_global(char *label, char *special, efunc error);
+void declare_as_global(int8_t *label, int8_t *special, efunc error);
int init_labels(void);
void cleanup_labels(void);
#define NASMPATH "/usr/local/bin/nasm"
-char *cpp[] = { LCCDIR "cpp", "-D__STDC__=1",
+int8_t *cpp[] = { LCCDIR "cpp", "-D__STDC__=1",
"-Di386", "-D__i386", "-D__i386__",
"-Dlinux", "-D__linux", "-D__linux__",
"-Dunix", "-D__unix", "-D__unix__",
"$1", "$2", "$3", 0
};
-char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include",
+int8_t *include[] = { "-I" LCCDIR "include", "-I/usr/local/include",
"-I/usr/include", 0
};
-char *com[] = { LCCDIR "rcc", "-target=x86/nasm",
+int8_t *com[] = { LCCDIR "rcc", "-target=x86/nasm",
"$1", "$2", "$3", 0
};
-char *as[] = { NASMPATH, "-a", "-faout", "-o", "$3", "$1", "$2", 0 };
-char *ld[] = { "/usr/bin/ld", "-m", "i386linux",
+int8_t *as[] = { NASMPATH, "-a", "-faout", "-o", "$3", "$1", "$2", 0 };
+int8_t *ld[] = { "/usr/bin/ld", "-m", "i386linux",
"-L/usr/i486-linuxaout/lib",
"-o", "$3", "$1",
"/usr/i486-linuxaout/lib/crt0.o",
"$2", "", "-lc", 0
};
-static char *bbexit = LCCDIR "bbexit.o";
+static int8_t *bbexit = LCCDIR "bbexit.o";
-extern char *concat(char *, char *);
-extern int access(const char *, int);
+extern int8_t *concat(int8_t *, int8_t *);
+extern int access(const int8_t *, int);
-int option(char *arg)
+int option(int8_t *arg)
{
if (strncmp(arg, "-lccdir=", 8) == 0) {
cpp[0] = concat(&arg[8], "/cpp");
#define NASMPATH "/usr/local/bin/nasm"
-char *cpp[] = { LCCDIR "cpp", "-D__STDC__=1",
+int8_t *cpp[] = { LCCDIR "cpp", "-D__STDC__=1",
"-D__ELF__", "-Di386", "-D__i386", "-D__i386__",
"-Dlinux", "-D__linux", "-D__linux__",
"$1", "$2", "$3", 0
};
-char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include",
+int8_t *include[] = { "-I" LCCDIR "include", "-I/usr/local/include",
"-I/usr/include", 0
};
-char *com[] = { LCCDIR "rcc", "-target=x86/nasm",
+int8_t *com[] = { LCCDIR "rcc", "-target=x86/nasm",
"$1", "$2", "$3", 0
};
-char *as[] = { NASMPATH, "-a", "-felf", "-o", "$3", "$1", "$2", 0 };
-char *ld[] = { "/usr/bin/ld", "-m", "elf_i386",
+int8_t *as[] = { NASMPATH, "-a", "-felf", "-o", "$3", "$1", "$2", 0 };
+int8_t *ld[] = { "/usr/bin/ld", "-m", "elf_i386",
"-dynamic-linker", "/lib/ld-linux.so.1",
"-L/usr/i486-linux/lib",
"-o", "$3", "$1",
"$2", "",
"-lc", "", "/usr/lib/crtend.o", "/usr/lib/crtn.o", 0
};
-static char *bbexit = LCCDIR "bbexit.o";
+static int8_t *bbexit = LCCDIR "bbexit.o";
-extern char *concat(char *, char *);
-extern int access(const char *, int);
+extern int8_t *concat(int8_t *, int8_t *);
+extern int access(const int8_t *, int);
-int option(char *arg)
+int option(int8_t *arg)
{
if (strncmp(arg, "-lccdir=", 8) == 0) {
cpp[0] = concat(&arg[8], "/cpp");
#include <stddef.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
int inhibiting;
} *mistack;
-static char xdigit[] = "0123456789ABCDEF";
+static int8_t xdigit[] = "0123456789ABCDEF";
#define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
-static char listline[LIST_MAX_LEN];
+static int8_t listline[LIST_MAX_LEN];
static int listlinep;
-static char listdata[2 * LIST_INDENT]; /* we need less than that actually */
-static long listoffset;
+static int8_t listdata[2 * LIST_INDENT]; /* we need less than that actually */
+static int32_t listoffset;
-static long listlineno;
+static int32_t listlineno;
-static long listp;
+static int32_t listp;
static int suppress; /* for INCBIN & TIMES special cases */
listdata[0] = '\0';
}
-static void list_init(char *fname, efunc error)
+static void list_init(int8_t *fname, efunc error)
{
listfp = fopen(fname, "w");
if (!listfp) {
fclose(listfp);
}
-static void list_out(long offset, char *str)
+static void list_out(int32_t offset, int8_t *str)
{
if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
strcat(listdata, "-");
strcat(listdata, str);
}
-static void list_output(long offset, const void *data, unsigned long type)
+static void list_output(int32_t offset, const void *data, uint32_t type)
{
- unsigned long typ, size;
+ uint32_t typ, size;
if (!listp || suppress || user_nolist) /* fbk - 9/2/00 */
return;
typ = type & OUT_TYPMASK;
size = type & OUT_SIZMASK;
+
if (typ == OUT_RAWDATA) {
- unsigned char const *p = data;
- char q[3];
+ uint8_t const *p = data;
+ int8_t q[3];
while (size--) {
HEX(q, *p);
q[2] = '\0';
p++;
}
} else if (typ == OUT_ADDRESS) {
- unsigned long d = *(long *)data;
- char q[11];
- unsigned char p[4], *r = p;
+ uint64_t d = *(int64_t *)data;
+ int8_t q[20];
+ uint8_t p[8], *r = p;
if (size == 4) {
q[0] = '[';
q[9] = ']';
HEX(q + 5, p[2]);
HEX(q + 7, p[3]);
list_out(offset, q);
+ } else if (size == 8) {
+ q[0] = '[';
+ q[17] = ']';
+ q[18] = '\0';
+ WRITEDLONG(r, d);
+ HEX(q + 1, p[0]);
+ HEX(q + 3, p[1]);
+ HEX(q + 5, p[2]);
+ HEX(q + 7, p[3]);
+ HEX(q + 9, p[4]);
+ HEX(q + 11, p[5]);
+ HEX(q + 13, p[6]);
+ HEX(q + 15, p[7]);
+ list_out(offset, q);
} else {
q[0] = '[';
q[5] = ']';
list_out(offset, q);
}
} else if (typ == OUT_REL2ADR) {
- unsigned long d = *(long *)data;
- char q[11];
- unsigned char p[4], *r = p;
+ uint32_t d = *(int32_t *)data;
+ int8_t q[11];
+ uint8_t p[4], *r = p;
q[0] = '(';
q[5] = ')';
q[6] = '\0';
HEX(q + 3, p[1]);
list_out(offset, q);
} else if (typ == OUT_REL4ADR) {
- unsigned long d = *(long *)data;
- char q[11];
- unsigned char p[4], *r = p;
+ uint32_t d = *(int32_t *)data;
+ int8_t q[11];
+ uint8_t p[4], *r = p;
q[0] = '(';
q[9] = ')';
q[10] = '\0';
HEX(q + 7, p[3]);
list_out(offset, q);
} else if (typ == OUT_RESERVE) {
- char q[20];
+ int8_t q[20];
snprintf(q, sizeof(q), "<res %08lX>", size);
list_out(offset, q);
}
}
-static void list_line(int type, char *line)
+static void list_line(int type, int8_t *line)
{
if (!listp)
return;
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 <stddef.h>\n\nstatic const char *stdmac[] = {\n";
+" - don't edit it */\n\n#include <stddef.h>\n#include <inttypes.h>\n\nstatic const int8_t *stdmac[] = {\n";
foreach $fname ( @ARGV ) {
open(INPUT,$fname) or die "unable to open $fname\n";
* distributed in the NASM archive.
*/
-static const char *conditions[] = { /* condition code names */
+static const int8_t *conditions[] = { /* condition code names */
"a", "ae", "b", "be", "c", "e", "g", "ge", "l", "le", "na", "nae",
"nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no", "np",
"ns", "nz", "o", "p", "pe", "po", "s", "z"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
int operand;
};
-static int get_bits(char *value);
-static unsigned long get_cpu(char *cpu_str);
-static void parse_cmdline(int, char **);
-static void assemble_file(char *);
-static int getkw(char **directive, char **value);
+static int get_bits(int8_t *value);
+static uint32_t get_cpu(int8_t *cpu_str);
+static void parse_cmdline(int, int8_t **);
+static void assemble_file(int8_t *);
+static int getkw(int8_t **directive, int8_t **value);
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,
+static void report_error_gnu(int severity, const int8_t *fmt, ...);
+static void report_error_vc(int severity, const int8_t *fmt, ...);
+static void report_error_common(int severity, const int8_t *fmt,
va_list args);
static int is_suppressed_warning(int severity);
static void usage(void);
static int using_debug_info, opt_verbose_info;
int tasm_compatible_mode = FALSE;
int pass0;
+int maxbits = 0;
-static char inname[FILENAME_MAX];
-static char outname[FILENAME_MAX];
-static char listname[FILENAME_MAX];
+static int8_t inname[FILENAME_MAX];
+static int8_t outname[FILENAME_MAX];
+static int8_t listname[FILENAME_MAX];
static int globallineno; /* for forward-reference tracking */
/* static int pass = 0; */
static struct ofmt *ofmt = NULL;
static FILE *ofile = NULL;
int optimizing = -1; /* number of optimization passes to take */
static int sb, cmd_sb = 16; /* by default */
-static unsigned long cmd_cpu = IF_PLEVEL; /* highest level by default */
-static unsigned long cpu = IF_PLEVEL; /* passed to insn_size & assemble.c */
+static uint32_t cmd_cpu = IF_PLEVEL; /* highest level by default */
+static uint32_t cpu = IF_PLEVEL; /* passed to insn_size & assemble.c */
int global_offset_changed; /* referenced in labels.c */
static loc_t location;
int in_abs_seg; /* Flag we are in ABSOLUTE seg */
-long abs_seg; /* ABSOLUTE segment basis */
-long abs_offset; /* ABSOLUTE offset */
+int32_t abs_seg; /* ABSOLUTE segment basis */
+int32_t abs_offset; /* ABSOLUTE offset */
static struct RAA *offsets;
* Which of the suppressible warnings are suppressed. Entry zero
* doesn't do anything. Initial defaults are given here.
*/
-static char suppressed[1 + ERR_WARN_MAX] = {
+static int8_t suppressed[1 + ERR_WARN_MAX] = {
0, TRUE, TRUE, TRUE, FALSE, TRUE
};
* The option names for the suppressible warnings. As before, entry
* zero does nothing.
*/
-static const char *suppressed_names[1 + ERR_WARN_MAX] = {
+static const int8_t *suppressed_names[1 + ERR_WARN_MAX] = {
NULL, "macro-params", "macro-selfref", "orphan-labels",
"number-overflow",
"gnu-elf-extensions"
* The explanations for the suppressible warnings. As before, entry
* zero does nothing.
*/
-static const char *suppressed_what[1 + ERR_WARN_MAX] = {
+static const int8_t *suppressed_what[1 + ERR_WARN_MAX] = {
NULL,
"macro calls with wrong no. of params",
"cyclic macro self-references",
* not preprocess their source file.
*/
-static void no_pp_reset(char *, int, efunc, evalfunc, ListGen *);
-static char *no_pp_getline(void);
+static void no_pp_reset(int8_t *, int, efunc, evalfunc, ListGen *);
+static int8_t *no_pp_getline(void);
static void no_pp_cleanup(int);
static Preproc no_pp = {
no_pp_reset,
static int terminate_after_phase;
int user_nolist = 0; /* fbk 9/2/00 */
-static void nasm_fputs(const char *line, FILE * outfile)
+static void nasm_fputs(const int8_t *line, FILE * outfile)
{
if (outfile) {
fputs(line, outfile);
puts(line);
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
pass0 = 1;
want_usage = terminate_after_phase = FALSE;
nasm_set_malloc_error(report_error);
offsets = raa_init();
- forwrefs = saa_init((long)sizeof(struct forwrefinfo));
+ forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo));
preproc = &nasmpp;
operating_mode = op_normal;
/* define some macros dependent of command-line */
{
- char temp[64];
+ int8_t temp[64];
snprintf(temp, sizeof(temp), "__OUTPUT_FORMAT__=%s\n",
ofmt->shortname);
pp_pre_define(temp);
switch (operating_mode) {
case op_depend:
{
- char *line;
+ int8_t *line;
preproc->reset(inname, 0, report_error, evaluate, &nasmlist);
if (outname[0] == '\0')
ofmt->filename(inname, outname, report_error);
case op_preprocess:
{
- char *line;
- char *file_name = NULL;
- long prior_linnum = 0;
+ int8_t *line;
+ int8_t *file_name = NULL;
+ int32_t prior_linnum = 0;
int lineinc = 0;
if (*outname) {
/*
* We generate %line directives if needed for later programs
*/
- long linnum = prior_linnum += lineinc;
+ int32_t linnum = prior_linnum += lineinc;
int altline = src_get(&linnum, &file_name);
if (altline) {
if (altline == 1 && lineinc == 1)
* Get a parameter for a command line option.
* First arg must be in the form of e.g. -f...
*/
-static char *get_param(char *p, char *q, int *advance)
+static int8_t *get_param(int8_t *p, int8_t *q, int *advance)
{
*advance = 0;
if (p[2]) { /* the parameter's in the option */
}
struct textargs {
- const char *label;
+ const int8_t *label;
int value;
};
};
int stopoptions = 0;
-static int process_arg(char *p, char *q)
+static int process_arg(int8_t *p, int8_t *q)
{
- char *param;
+ int8_t *param;
int i, advance = 0;
if (!p || !p[0])
case 'r':
case 'v':
{
- const char *nasm_version_string =
+ const int8_t *nasm_version_string =
"NASM version " NASM_VER " compiled on " __DATE__
#ifdef DEBUG
" with -DDEBUG"
static void process_respfile(FILE * rfile)
{
- char *buffer, *p, *q, *prevarg;
+ int8_t *buffer, *p, *q, *prevarg;
int bufsize, prevargsize;
bufsize = prevargsize = ARG_BUF_DELTA;
* argv array. Used by the environment variable and response file
* processing.
*/
-static void process_args(char *args)
+static void process_args(int8_t *args)
{
- char *p, *q, *arg, *prevarg;
- char separator = ' ';
+ int8_t *p, *q, *arg, *prevarg;
+ int8_t separator = ' ';
p = args;
if (*p && *p != '-')
process_arg(arg, NULL);
}
-static void parse_cmdline(int argc, char **argv)
+static void parse_cmdline(int argc, int8_t **argv)
{
FILE *rfile;
- char *envreal, *envcopy = NULL, *p, *arg;
+ int8_t *envreal, *envcopy = NULL, *p, *arg;
*inname = *outname = *listname = '\0';
* different to the -@resp file processing below for regular
* NASM.
*/
- char *str = malloc(2048);
+ int8_t *str = malloc(2048);
FILE *f = fopen(&argv[0][1], "r");
if (!str) {
printf("out of memory");
"no input file specified");
}
-static void assemble_file(char *fname)
+static void assemble_file(int8_t *fname)
{
- char *directive, *value, *p, *q, *special, *line, debugid[80];
+ int8_t *directive, *value, *p, *q, *special, *line, debugid[80];
insn output_ins;
int i, rn_error, validid;
- long seg, offs;
+ int32_t seg, offs;
struct tokenval tokval;
expr *e;
int pass, pass_max;
def_label = pass > 1 ? redefine_label : define_label;
- sb = cmd_sb; /* set 'bits' to command line default */
+ globalbits = sb = cmd_sb; /* set 'bits' to command line default */
cpu = cmd_cpu;
if (pass0 == 2) {
if (*listname)
in_abs_seg = FALSE;
global_offset_changed = FALSE; /* set by redefine_label */
location.segment = ofmt->section(NULL, pass2, &sb);
+ globalbits = sb;
if (pass > 1) {
saa_rewind(forwrefs);
forwref = saa_rstruct(forwrefs);
seg = ofmt->section(value, pass2, &sb);
if (seg == NO_SEG) {
report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
- "segment name `%s' not recognised",
+ "segment name `%s' not recognized",
value);
} else {
in_abs_seg = FALSE;
} /* else pass0 == 1 */
break;
case 3: /* [BITS bits] */
- sb = get_bits(value);
+ globalbits = sb = get_bits(value);
break;
case 4: /* [GLOBAL symbol:special] */
if (*value == '$')
break;
}
if (*p) {
- long size;
+ int64_t size;
while (*p && isspace(*p))
*p++ = '\0';
if (pass1 == 1) {
- long l = insn_size(location.segment, offs, sb, cpu,
+ int32_t l = insn_size(location.segment, offs, sb, cpu,
&output_ins, report_error);
/* if (using_debug_info) && output_ins.opcode != -1) */
if (using_debug_info)
{ /* fbk 03/25/01 */
/* this is done here so we can do debug type info */
- long typeinfo =
+ int32_t typeinfo =
TYS_ELEMENTS(output_ins.operands);
switch (output_ins.opcode) {
case I_RESB:
#endif
} /* exit from assemble_file (...) */
-static int getkw(char **directive, char **value)
+static int getkw(int8_t **directive, int8_t **value)
{
- char *p, *q, *buf;
+ int8_t *p, *q, *buf;
buf = *directive;
* @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 report_error_gnu(int severity, const int8_t *fmt, ...)
{
va_list ap;
if (severity & ERR_NOFILE)
fputs("nasm: ", error_file);
else {
- char *currentfile = NULL;
- long lineno = 0;
+ int8_t *currentfile = NULL;
+ int32_t lineno = 0;
src_get(&lineno, ¤tfile);
fprintf(error_file, "%s:%ld: ", currentfile, lineno);
nasm_free(currentfile);
* @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 report_error_vc(int severity, const int8_t *fmt, ...)
{
va_list ap;
if (severity & ERR_NOFILE)
fputs("nasm: ", error_file);
else {
- char *currentfile = NULL;
- long lineno = 0;
+ int8_t *currentfile = NULL;
+ int32_t lineno = 0;
src_get(&lineno, ¤tfile);
fprintf(error_file, "%s(%ld) : ", currentfile, lineno);
nasm_free(currentfile);
* @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,
+static void report_error_common(int severity, const int8_t *fmt,
va_list args)
{
switch (severity & ERR_MASK) {
static FILE *no_pp_fp;
static efunc no_pp_err;
static ListGen *no_pp_list;
-static long no_pp_lineinc;
+static int32_t no_pp_lineinc;
-static void no_pp_reset(char *file, int pass, efunc error, evalfunc eval,
+static void no_pp_reset(int8_t *file, int pass, efunc error, evalfunc eval,
ListGen * listgen)
{
src_set_fname(nasm_strdup(file));
(void)eval; /* placate compilers */
}
-static char *no_pp_getline(void)
+static int8_t *no_pp_getline(void)
{
- char *buffer, *p, *q;
+ int8_t *buffer, *p, *q;
int bufsize;
bufsize = BUF_DELTA;
buffer[strcspn(buffer, "\r\n\032")] = '\0';
if (!strncmp(buffer, "%line", 5)) {
- long ln;
+ int32_t ln;
int li;
- char *nm = nasm_malloc(strlen(buffer));
+ int8_t *nm = nasm_malloc(strlen(buffer));
if (sscanf(buffer + 5, "%ld+%d %s", &ln, &li, nm) == 3) {
nasm_free(src_set_fname(nm));
src_set_linnum(ln);
fclose(no_pp_fp);
}
-static unsigned long get_cpu(char *value)
+static uint32_t get_cpu(int8_t *value)
{
if (!strcmp(value, "8086"))
return IF_WILLAMETTE;
if (!nasm_stricmp(value, "prescott"))
return IF_PRESCOTT;
+ if (!nasm_stricmp(value, "x64") ||
+ !nasm_stricmp(value, "x86-64"))
+ return IF_X64;
if (!nasm_stricmp(value, "ia64") ||
!nasm_stricmp(value, "ia-64") ||
!nasm_stricmp(value, "itanium") ||
return IF_PLEVEL; /* the maximum level */
}
-static int get_bits(char *value)
+static int get_bits(int8_t *value)
{
int i;
"cannot specify 32-bit segment on processor below a 386");
i = 16;
}
+ } else if (i == 64) {
+ if (cpu < IF_X64) {
+ report_error(ERR_NONFATAL,
+ "cannot specify 64-bit segment on processor below an x86-64");
+ i = 16;
+ }
+ if (i != maxbits) {
+ report_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,
- "`%s' is not a valid segment size; must be 16 or 32",
+ "`%s' is not a valid segment size; must be 16, 32 or 64",
value);
i = 16;
}
/*
* An error reporting function should look like this.
*/
-typedef void (*efunc) (int severity, const char *fmt, ...);
+typedef void (*efunc) (int severity, const int8_t *fmt, ...);
/*
* These are the error severity codes which get passed as the first
/*
* A label-lookup function should look like this.
*/
-typedef int (*lfunc) (char *label, long *segment, long *offset);
+typedef int (*lfunc) (int8_t *label, int32_t *segment, int32_t *offset);
/*
* And a label-definition function like this. The boolean parameter
* 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, long segment, long offset,
- char *special, int is_norm, int isextrn,
+typedef void (*ldfunc) (int8_t *label, int32_t segment, int32_t offset,
+ int8_t *special, int is_norm, int isextrn,
struct ofmt * ofmt, efunc error);
/*
*/
typedef struct {
/*
- * Called to initialise the listing file generator. Before this
+ * Called to initialize the listing file generator. Before this
* is called, the other routines will silently do nothing when
- * called. The `char *' parameter is the file name to write the
+ * called. The `int8_t *' parameter is the file name to write the
* listing to.
*/
- void (*init) (char *, efunc);
+ void (*init) (int8_t *, efunc);
/*
* Called to clear stuff up and close the listing file.
* work with when doing things like uplevel(LIST_TIMES) or
* uplevel(LIST_INCBIN).
*/
- void (*output) (long, const void *, unsigned long);
+ void (*output) (int32_t, const void *, uint32_t);
/*
* Called to send a text line to the listing generator. The
* whether the line came directly from an input file or is the
* result of a multi-line macro expansion.
*/
- void (*line) (int, char *);
+ void (*line) (int, int8_t *);
/*
* Called to change one of the various levelled mechanisms in
*/
struct tokenval {
int t_type;
- long t_integer, t_inttwo;
- char *t_charptr;
+ int64_t t_integer, t_inttwo;
+ int8_t *t_charptr;
};
typedef int (*scanner) (void *private_data, struct tokenval * tv);
TOKEN_ID = 256, TOKEN_NUM, TOKEN_REG, TOKEN_INSN, /* major token types */
TOKEN_ERRNUM, /* numeric constant with error in */
TOKEN_HERE, TOKEN_BASE, /* $ and $$ */
- TOKEN_SPECIAL, /* BYTE, WORD, DWORD, FAR, NEAR, etc */
+ TOKEN_SPECIAL, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
TOKEN_PREFIX, /* A32, O16, LOCK, REPNZ, TIMES, etc */
TOKEN_SHL, TOKEN_SHR, /* << and >> */
TOKEN_SDIV, TOKEN_SMOD, /* // and %% */
};
typedef struct {
- long segment;
- long offset;
+ int32_t segment;
+ int32_t offset;
int known;
} loc_t;
* `value' field of zero is insignificant.
*/
typedef struct {
- long type; /* a register, or EXPR_xxx */
- long value; /* must be >= 32 bits */
+ int32_t type; /* a register, or EXPR_xxx */
+ int64_t value; /* must be >= 32 bits */
} expr;
/*
* `operand' structure.
*/
struct eval_hints {
- int base;
+ int64_t base;
int type;
};
* of the pass, an error reporting function, an evaluator
* function, and a listing generator to talk to.
*/
- void (*reset) (char *, int, efunc, evalfunc, ListGen *);
+ void (*reset) (int8_t *, int, efunc, evalfunc, ListGen *);
/*
* Called to fetch a line of preprocessed source. The line
* returned has been malloc'ed, and so should be freed after
* use.
*/
- char *(*getline) (void);
+ int8_t *(*getline) (void);
/*
* Called at the end of a pass.
#define BITS8 0x00000001L
#define BITS16 0x00000002L
#define BITS32 0x00000004L
-#define BITS64 0x00000008L /* FPU only */
+#define BITS64 0x00000008L /* x64 and FPU only */
#define BITS80 0x00000010L /* FPU only */
#define FAR 0x00000020L /* grotty: this means 16:16 or */
/* 16:32, like in CALL/JMP */
#define REG8 0x00201001L
#define REG16 0x00201002L
#define REG32 0x00201004L
-#define MMXREG 0x00201008L /* MMX registers */
-#define XMMREG 0x00201010L /* XMM Katmai reg */
+#define REG64 0x00201008L /* x64 registers */
+#define REGRIP 0x0020100CL /* RIP register */
+#define MMXREG 0x00201010L /* MMX registers */
+#define XMMREG 0x00201011L /* XMM Katmai reg */
#define FPUREG 0x01000000L /* floating point stack registers */
#define FPU0 0x01000800L /* FPU stack register zero */
#define REG_AL 0x00211001L /* REG_ACCUM | BITSxx */
#define REG_AX 0x00211002L /* ditto */
#define REG_EAX 0x00211004L /* and again */
-#define REG_COUNT 0x00221000L /* counter: CL, CX or ECX */
+#define REG_RAX 0x00211008L /* and again */
+#define REG_COUNT 0x00221000L /* counter: CL, CX, ECX or RCX */
#define REG_CL 0x00221001L /* REG_COUNT | BITSxx */
#define REG_CX 0x00221002L /* ditto */
#define REG_ECX 0x00221004L /* another one */
+#define REG_RCX 0x00221008L /* another one */
#define REG_DL 0x00241001L
#define REG_DX 0x00241002L
#define REG_EDX 0x00241004L
+#define REG_RDX 0x00241008L
+#define REG_RIP 0x0027100CL /* RIP relative addressing */
#define REG_SREG 0x00081002L /* any segment register */
#define REG_CS 0x01081002L /* CS */
#define REG_DESS 0x02081002L /* DS, ES, SS (non-CS 86 registers) */
#define REG_CREG 0x08101004L /* CRn */
#define REG_DREG 0x10101004L /* DRn */
#define REG_TREG 0x20101004L /* TRn */
+#define REG_C8REG 0x40101004L /* CR8 */
/* special type of EA */
#define MEM_OFFS 0x00604000L /* simple [address] offset */
*/
enum { /* instruction prefixes */
PREFIX_ENUM_START = REG_ENUM_LIMIT,
- P_A16 = PREFIX_ENUM_START, P_A32, P_LOCK, P_O16, P_O32, P_REP, P_REPE,
- P_REPNE, P_REPNZ, P_REPZ, P_TIMES
+ P_A16 = PREFIX_ENUM_START, P_A32, P_LOCK, P_O16, P_O32,
+ P_REP, P_REPE, P_REPNE, P_REPNZ, P_REPZ, P_TIMES
};
enum { /* extended operand types */
};
enum { /* values for `hinttype' */
- EAH_NOHINT = 0, /* no hint at all - our discretion */
+ EAH_NOHINT = 0, /* no hint at all - our discretion */
EAH_MAKEBASE = 1, /* try to make given reg the base */
- EAH_NOTBASE = 2 /* try _not_ to make reg the base */
+ EAH_NOTBASE = 2 /* try _not_ to make reg the base */
};
typedef struct { /* operand to an instruction */
- long type; /* type of operand */
- int addr_size; /* 0 means default; 16; 32 */
+ int32_t type; /* type of operand */
+ int addr_size; /* 0 means default; 16; 32; 64 */
int basereg, indexreg, scale; /* registers and scale involved */
int hintbase, hinttype; /* hint as to real base register */
- long segment; /* immediate segment, if needed */
- long offset; /* any immediate number */
- long wrt; /* segment base it's relative to */
+ int32_t segment; /* immediate segment, if needed */
+ int64_t offset; /* any immediate number */
+ int32_t wrt; /* segment base it's relative to */
int eaflags; /* special EA flags */
int opflags; /* see OPFLAG_* defines below */
} operand;
typedef struct extop { /* extended operand */
struct extop *next; /* linked list */
- long type; /* defined above */
- char *stringval; /* if it's a string, then here it is */
+ int32_t type; /* defined above */
+ int8_t *stringval; /* if it's a string, then here it is */
int stringlen; /* ... and here's how long it is */
- long segment; /* if it's a number/address, then... */
- long offset; /* ... it's given here ... */
- long wrt; /* ... and here */
+ int32_t segment; /* if it's a number/address, then... */
+ int64_t offset; /* ... it's given here ... */
+ int32_t wrt; /* ... and here */
} extop;
#define MAXPREFIX 4
typedef struct { /* an instruction itself */
- char *label; /* the label defined, or NULL */
+ int8_t *label; /* the label defined, or NULL */
int prefixes[MAXPREFIX]; /* instruction prefixes, if any */
int nprefix; /* number of entries in above */
int opcode; /* the opcode - not just the string */
operand oprs[3]; /* the operands, defined as above */
extop *eops; /* extended operands */
int eops_float; /* true if DD and floating */
- long times; /* repeat count (TIMES prefix) */
+ int32_t times; /* repeat count (TIMES prefix) */
int forw_ref; /* is there a forward reference? */
+ uint8_t rex; /* Special REX Prefix */
} insn;
enum geninfo { GI_SWITCH };
* This is a short (one-liner) description of the type of
* output generated by the driver.
*/
- const char *fullname;
+ const int8_t *fullname;
/*
* This is a single keyword used to select the driver.
*/
- const char *shortname;
+ const int8_t *shortname;
+
/*
* this is reserved for out module specific help.
- * It is set to NULL in all the out modules but is not implemented
+ * It is set to NULL in all the out modules and is not implemented
* in the main program
*/
- const char *helpstring;
+ const int8_t *helpstring;
/*
* this is a pointer to the first element of the debug information
struct dfmt *current_dfmt;
/*
- * This, if non-NULL, is a NULL-terminated list of `char *'s
+ * This, if non-NULL, is a NULL-terminated list of `int8_t *'s
* pointing to extra standard macros supplied by the object
* format (e.g. a sensible initial default value of __SECT__,
* and user-level equivalents for any format-specific
* directives).
*/
- const char **stdmac;
+ const int8_t **stdmac;
/*
* This procedure is called at the start of an output session.
* and the second parameter gives the value. This function returns
* 1 if recognized, 0 if unrecognized
*/
- int (*setinfo) (enum geninfo type, char **string);
+ int (*setinfo) (enum geninfo type, int8_t **string);
/*
* This procedure is called by assemble() to write actual
* The `type' argument specifies the type of output data, and
* usually the size as well: its contents are described below.
*/
- void (*output) (long segto, const void *data, unsigned long type,
- long segment, long wrt);
+ void (*output) (int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt);
/*
* This procedure is called once for every symbol defined in
* been an EXTERN, a COMMON or a GLOBAL. The distinction should
* be obvious to the output format from the other parameters.
*/
- void (*symdef) (char *name, long segment, long offset, int is_global,
- char *special);
+ void (*symdef) (int8_t *name, int32_t segment, int32_t offset, int is_global,
+ int8_t *special);
/*
* This procedure is called when the source code requests a
* the segment, by setting `*bits' to 16 or 32. Or, if it
* doesn't wish to define a default, it can leave `bits' alone.
*/
- long (*section) (char *name, int pass, int *bits);
+ int32_t (*section) (int8_t *name, int pass, int *bits);
/*
* This procedure is called to modify the segment base values
* responsible for throwing an error condition if that occurs
* in pass two or in a critical expression.
*/
- long (*segbase) (long segment);
+ int32_t (*segbase) (int32_t segment);
/*
* This procedure is called to allow the output driver to
* should also return non-zero if it correctly processes the
* directive.
*/
- int (*directive) (char *directive, char *value, int pass);
+ int (*directive) (int8_t *directive, int8_t *value, int pass);
/*
* This procedure is called before anything else - even before
* should return its preferred name for the output file in
* `outname', if outname[0] is not '\0', and do nothing to
* `outname' otherwise. Since it is called before the driver is
- * properly initialised, it has to be passed its error handler
+ * properly initialized, it has to be passed its error handler
* separately.
*
* This procedure may also take its own copy of the input file
* 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) (int8_t *inname, int8_t *outname, efunc error);
/*
* This procedure is called after assembly finishes, to allow
* Also OUT_RESERVE denotes reservation of N bytes of BSS space,
* and the contents of the "data" parameter is irrelevant.
*
- * The "data" parameter for the output function points to a "long",
+ * The "data" parameter for the output function points to a "int32_t",
* containing the address in question, unless the type is
- * OUT_RAWDATA, in which case it points to an "unsigned char"
+ * OUT_RAWDATA, in which case it points to an "uint8_t"
* array.
*/
#define OUT_RAWDATA 0x00000000UL
* This is a short (one-liner) description of the type of
* output generated by the driver.
*/
- const char *fullname;
+ const int8_t *fullname;
/*
* This is a single keyword used to select the driver.
*/
- const char *shortname;
+ const int8_t *shortname;
/*
* init - called initially to set up local pointer to object format,
* linenum - called any time there is output with a change of
* line number or file.
*/
- void (*linenum) (const char *filename, long linenumber, long segto);
+ void (*linenum) (const int8_t *filename, int32_t linenumber, int32_t segto);
/*
* debug_deflabel - called whenever a label is defined. Parameters
* would be called before the output format version.
*/
- void (*debug_deflabel) (char *name, long segment, long offset,
- int is_global, char *special);
+ void (*debug_deflabel) (int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special);
/*
* debug_directive - called whenever a DEBUG directive other than 'LINE'
* is encountered. 'directive' contains the first parameter to the
* 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 int8_t *directive, const int8_t *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) (long type);
+ void (*debug_typevalue) (int32_t type);
/*
* debug_output - called whenever output is required
extern int pass0; /* this is globally known */
extern int optimizing;
+extern int globalbits; /* this is globally known */
+extern int maxbits; /* this is globally known */
#endif
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
#include "insns.h" /* For MAX_KEYWORD */
+int globalbits = 0; /* defined in nasm.h, works better here for ASM+DISASM */
+
static efunc nasm_malloc_error;
#ifdef LOGALLOC
}
#ifdef LOGALLOC
-void *nasm_malloc_log(char *file, int line, size_t size)
+void *nasm_malloc_log(int8_t *file, int line, size_t size)
#else
void *nasm_malloc(size_t size)
#endif
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
- file, line, (long)size, p);
+ file, line, (int32_t)size, p);
#endif
return p;
}
#ifdef LOGALLOC
-void *nasm_realloc_log(char *file, int line, void *q, size_t size)
+void *nasm_realloc_log(int8_t *file, int line, void *q, size_t size)
#else
void *nasm_realloc(void *q, size_t size)
#endif
#ifdef LOGALLOC
else if (q)
fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
- file, line, q, (long)size, p);
+ file, line, q, (int32_t)size, p);
else
fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
- file, line, (long)size, p);
+ file, line, (int32_t)size, p);
#endif
return p;
}
#ifdef LOGALLOC
-void nasm_free_log(char *file, int line, void *q)
+void nasm_free_log(int8_t *file, int line, void *q)
#else
void nasm_free(void *q)
#endif
}
#ifdef LOGALLOC
-char *nasm_strdup_log(char *file, int line, const char *s)
+int8_t *nasm_strdup_log(int8_t *file, int line, const int8_t *s)
#else
-char *nasm_strdup(const char *s)
+int8_t *nasm_strdup(const int8_t *s)
#endif
{
- char *p;
+ int8_t *p;
int size = strlen(s) + 1;
p = malloc(size);
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
- file, line, (long)size, p);
+ file, line, (int32_t)size, p);
#endif
strcpy(p, s);
return p;
}
#ifdef LOGALLOC
-char *nasm_strndup_log(char *file, int line, char *s, size_t len)
+int8_t *nasm_strndup_log(int8_t *file, int line, int8_t *s, size_t len)
#else
-char *nasm_strndup(char *s, size_t len)
+int8_t *nasm_strndup(int8_t *s, size_t len)
#endif
{
- char *p;
+ int8_t *p;
int size = len + 1;
p = malloc(size);
#ifdef LOGALLOC
else
fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
- file, line, (long)size, p);
+ file, line, (int32_t)size, p);
#endif
strncpy(p, s, len);
p[len] = '\0';
}
#if !defined(stricmp) && !defined(strcasecmp)
-int nasm_stricmp(const char *s1, const char *s2)
+int nasm_stricmp(const int8_t *s1, const int8_t *s2)
{
while (*s1 && tolower(*s1) == tolower(*s2))
s1++, s2++;
#endif
#if !defined(strnicmp) && !defined(strncasecmp)
-int nasm_strnicmp(const char *s1, const char *s2, int n)
+int nasm_strnicmp(const int8_t *s1, const int8_t *s2, int n)
{
while (n > 0 && *s1 && tolower(*s1) == tolower(*s2))
s1++, s2++, n--;
#define lib_isnumchar(c) ( isalnum(c) || (c) == '$')
#define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
-long readnum(char *str, int *error)
+int64_t readnum(int8_t *str, int *error)
{
- char *r = str, *q;
- long radix;
- unsigned long result, checklimit;
+ int8_t *r = str, *q;
+ int32_t radix;
+ uint64_t result, checklimit;
int digit, last;
int warn = FALSE;
int sign = 1;
*error = TRUE;
return 0;
}
-
+
/*
- * `checklimit' must be 2**32 / radix. We can't do that in
- * 32-bit arithmetic, which we're (probably) using, so we
+ * `checklimit' must be 2**(32|64) / radix. We can't do that in
+ * 32/64-bit arithmetic, which we're (probably) using, so we
* cheat: since we know that all radices we use are even, we
- * can divide 2**31 by radix/2 instead.
+ * can divide 2**(31|63) by radix/2 instead.
*/
- checklimit = 0x80000000UL / (radix >> 1);
+ if (globalbits == 64)
+ checklimit = 0x8000000000000000ULL / (radix >> 1);
+ else
+ checklimit = 0x80000000UL / (radix >> 1);
/*
- * Calculate the highest allowable value for the last digit
- * of a 32 bit constant... in radix 10, it is 6, otherwise it is 0
+ * Calculate the highest allowable value for the last digit of a
+ * 32-bit constant... in radix 10, it is 6, otherwise it is 0
*/
last = (radix == 10 ? 6 : 0);
return result * sign;
}
-long readstrnum(char *str, int length, int *warn)
+int64_t readstrnum(int8_t *str, int length, int *warn)
{
- long charconst = 0;
+ int64_t charconst = 0;
int i;
*warn = FALSE;
str += length;
- for (i = 0; i < length; i++) {
- if (charconst & 0xff000000UL) {
- *warn = TRUE;
+ if (globalbits == 64) {
+ for (i = 0; i < length; i++) {
+ if (charconst & 0xFF00000000000000ULL)
+ *warn = TRUE;
+ charconst = (charconst << 8) + (uint8_t)*--str;
+ }
+ } else {
+ for (i = 0; i < length; i++) {
+ if (charconst & 0xFF000000UL)
+ *warn = TRUE;
+ charconst = (charconst << 8) + (uint8_t)*--str;
}
- charconst = (charconst << 8) + (unsigned char)*--str;
}
return charconst;
}
-static long next_seg;
+static int32_t next_seg;
void seg_init(void)
{
next_seg = 0;
}
-long seg_alloc(void)
+int32_t seg_alloc(void)
{
return (next_seg += 2) - 2;
}
-void fwriteshort(int data, FILE * fp)
+void fwriteint16_t(int data, FILE * fp)
{
fputc((int)(data & 255), fp);
fputc((int)((data >> 8) & 255), fp);
}
-void fwritelong(long data, FILE * fp)
+void fwriteint32_t(int32_t data, FILE * fp)
{
fputc((int)(data & 255), fp);
fputc((int)((data >> 8) & 255), fp);
fputc((int)((data >> 24) & 255), fp);
}
-void standard_extension(char *inname, char *outname, char *extension,
+void standard_extension(int8_t *inname, int8_t *outname, int8_t *extension,
efunc error)
{
- char *p, *q;
+ int8_t *p, *q;
if (*outname) /* file name already exists, */
return; /* so do nothing */
}
}
-long raa_read(struct RAA *r, long posn)
+int32_t raa_read(struct RAA *r, int32_t posn)
{
if (posn >= r->stepsize * LAYERSIZ(r))
return 0; /* Return 0 for undefined entries */
return r->u.l.data[posn];
}
-struct RAA *raa_write(struct RAA *r, long posn, long value)
+struct RAA *raa_write(struct RAA *r, int32_t posn, int32_t value)
{
struct RAA *result;
#define SAA_MAXLEN 8192
-struct SAA *saa_init(long elem_len)
+struct SAA *saa_init(int32_t elem_len)
{
struct SAA *s;
return p;
}
-void saa_wbytes(struct SAA *s, const void *data, long len)
+void saa_wbytes(struct SAA *s, const void *data, int32_t len)
{
- const char *d = data;
+ const int8_t *d = data;
while (len > 0) {
- long l = s->end->length - s->end->posn;
+ int32_t l = s->end->length - s->end->posn;
if (l > len)
l = len;
if (l > 0) {
return p;
}
-void *saa_rbytes(struct SAA *s, long *len)
+void *saa_rbytes(struct SAA *s, int32_t *len)
{
void *p;
return p;
}
-void saa_rnbytes(struct SAA *s, void *data, long len)
+void saa_rnbytes(struct SAA *s, void *data, int32_t len)
{
- char *d = data;
+ int8_t *d = data;
while (len > 0) {
- long l;
+ int32_t l;
if (!s->rptr)
return;
}
}
-void saa_fread(struct SAA *s, long posn, void *data, long len)
+void saa_fread(struct SAA *s, int32_t posn, void *data, int32_t len)
{
struct SAA *p;
- long pos;
- char *cdata = data;
+ int64_t pos;
+ int8_t *cdata = data;
if (!s->rptr || posn < s->rptr->start)
saa_rewind(s);
pos = posn - p->start;
while (len) {
- long l = p->posn - pos;
+ int64_t l = p->posn - pos;
if (l > len)
l = len;
memcpy(cdata, p->data + pos, l);
p = p->next;
if (!p)
return;
- pos = 0L;
+ pos = 0LL;
}
s->rptr = p;
}
-void saa_fwrite(struct SAA *s, long posn, void *data, long len)
+void saa_fwrite(struct SAA *s, int32_t posn, void *data, int32_t len)
{
struct SAA *p;
- long pos;
- char *cdata = data;
+ int64_t pos;
+ int8_t *cdata = data;
if (!s->rptr || posn < s->rptr->start)
saa_rewind(s);
pos = posn - p->start;
while (len) {
- long l = p->posn - pos;
+ int64_t l = p->posn - pos;
if (l > len)
l = len;
memcpy(p->data + pos, cdata, l);
p = p->next;
if (!p)
return;
- pos = 0L;
+ pos = 0LL;
}
s->rptr = p;
}
void saa_fpwrite(struct SAA *s, FILE * fp)
{
- char *data;
- long len;
+ int8_t *data;
+ int32_t len;
saa_rewind(s);
while ((data = saa_rbytes(s, &len)))
* by the scanner.
*/
#include "names.c"
-static const char *special_names[] = {
+static const int8_t *special_names[] = {
"byte", "dword", "far", "long", "near", "nosplit", "qword",
"short", "strict", "to", "tword", "word"
};
-static const char *prefix_names[] = {
+static const int8_t *prefix_names[] = {
"a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
"repnz", "repz", "times"
};
* formats. It keeps a succession of temporary-storage strings in
* stdscan_tempstorage, which can be cleared using stdscan_reset.
*/
-static char **stdscan_tempstorage = NULL;
+static int8_t **stdscan_tempstorage = NULL;
static int stdscan_tempsize = 0, stdscan_templen = 0;
#define STDSCAN_TEMP_DELTA 256
nasm_free(stdscan_tempstorage);
}
-static char *stdscan_copy(char *p, int len)
+static int8_t *stdscan_copy(int8_t *p, int len)
{
- char *text;
+ int8_t *text;
text = nasm_malloc(len + 1);
strncpy(text, p, len);
stdscan_tempsize += STDSCAN_TEMP_DELTA;
stdscan_tempstorage = nasm_realloc(stdscan_tempstorage,
stdscan_tempsize *
- sizeof(char *));
+ sizeof(int8_t *));
}
stdscan_tempstorage[stdscan_templen++] = text;
return text;
}
-char *stdscan_bufptr = NULL;
+int8_t *stdscan_bufptr = NULL;
int stdscan(void *private_data, struct tokenval *tv)
{
- char ourcopy[MAX_KEYWORD + 1], *r, *s;
+ int8_t ourcopy[MAX_KEYWORD + 1], *r, *s;
(void)private_data; /* Don't warn that this parameter is unused */
}
for (i = 0; i < elements(icn); i++)
if (!strncmp(ourcopy, icn[i], strlen(icn[i]))) {
- char *p = ourcopy + strlen(icn[i]);
+ int8_t *p = ourcopy + strlen(icn[i]);
tv->t_integer = ico[i];
if ((tv->t_inttwo = bsi(p, conditions,
elements(conditions))) >= 0)
tv->t_charptr = NULL;
return tv->t_type = TOKEN_NUM;
} else if (*stdscan_bufptr == '\'' || *stdscan_bufptr == '"') { /* a char constant */
- char quote = *stdscan_bufptr++, *r;
+ int8_t quote = *stdscan_bufptr++, *r;
int rn_warn;
r = tv->t_charptr = stdscan_bufptr;
while (*stdscan_bufptr && *stdscan_bufptr != quote)
stdscan_bufptr += 2;
return tv->t_type = TOKEN_DBL_OR;
} else /* just an ordinary char */
- return tv->t_type = (unsigned char)(*stdscan_bufptr++);
+ return tv->t_type = (uint8_t)(*stdscan_bufptr++);
}
/*
* Return the scalar part of a relocatable vector. (Including
* simple scalar vectors - those qualify as relocatable.)
*/
-long reloc_value(expr * vect)
+int64_t reloc_value(expr * vect)
{
while (vect->type && !vect->value)
vect++;
* Return the segment number of a relocatable vector, or NO_SEG for
* simple scalars.
*/
-long reloc_seg(expr * vect)
+int32_t reloc_seg(expr * vect)
{
while (vect->type && (vect->type == EXPR_WRT || !vect->value))
vect++;
* Return the WRT segment number of a relocatable vector, or NO_SEG
* if no WRT part is present.
*/
-long reloc_wrt(expr * vect)
+int32_t reloc_wrt(expr * vect)
{
while (vect->type && vect->type < EXPR_WRT)
vect++;
/*
* Binary search.
*/
-int bsi(char *string, const char **array, int size)
+int bsi(int8_t *string, const int8_t **array, int size)
{
int i = -1, j = size; /* always, i < index < j */
while (j - i >= 2) {
return -1; /* we haven't got it :( */
}
-static char *file_name = NULL;
-static long line_number = 0;
+static int8_t *file_name = NULL;
+static int32_t line_number = 0;
-char *src_set_fname(char *newname)
+int8_t *src_set_fname(int8_t *newname)
{
- char *oldname = file_name;
+ int8_t *oldname = file_name;
file_name = newname;
return oldname;
}
-long src_set_linnum(long newline)
+int32_t src_set_linnum(int32_t newline)
{
- long oldline = line_number;
+ int32_t oldline = line_number;
line_number = newline;
return oldline;
}
-long src_get_linnum(void)
+int32_t src_get_linnum(void)
{
return line_number;
}
-int src_get(long *xline, char **xname)
+int src_get(int32_t *xline, int8_t **xname)
{
if (!file_name || !*xname || strcmp(*xname, file_name)) {
nasm_free(*xname);
return -2;
}
if (*xline != line_number) {
- long tmp = line_number - *xline;
+ int32_t tmp = line_number - *xline;
*xline = line_number;
return tmp;
}
return 0;
}
-void nasm_quote(char **str)
+void nasm_quote(int8_t **str)
{
int ln = strlen(*str);
- char q = (*str)[0];
- char *p;
+ int8_t q = (*str)[0];
+ int8_t *p;
if (ln > 1 && (*str)[ln - 1] == q && (q == '"' || q == '\''))
return;
q = '"';
*str = p;
}
-char *nasm_strcat(char *one, char *two)
+int8_t *nasm_strcat(int8_t *one, int8_t *two)
{
- char *rslt;
+ int8_t *rslt;
int l1 = strlen(one);
rslt = nasm_malloc(l1 + strlen(two) + 1);
strcpy(rslt, one);
void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error)
{
}
-void null_debug_linenum(const char *filename, long linenumber, long segto)
+void null_debug_linenum(const int8_t *filename, int32_t linenumber, int32_t segto)
{
}
-void null_debug_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+void null_debug_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
}
-void null_debug_routine(const char *directive, const char *params)
+void null_debug_routine(const int8_t *directive, const int8_t *params)
{
}
-void null_debug_typevalue(long type)
+void null_debug_typevalue(int32_t type)
{
}
void null_debug_output(int type, void *param)
void *nasm_malloc(size_t);
void *nasm_realloc(void *, size_t);
void nasm_free(void *);
-char *nasm_strdup(const char *);
-char *nasm_strndup(char *, size_t);
+int8_t *nasm_strdup(const int8_t *);
+int8_t *nasm_strndup(int8_t *, size_t);
#else
-void *nasm_malloc_log(char *, int, size_t);
-void *nasm_realloc_log(char *, int, void *, size_t);
-void nasm_free_log(char *, int, void *);
-char *nasm_strdup_log(char *, int, const char *);
-char *nasm_strndup_log(char *, int, char *, size_t);
+void *nasm_malloc_log(int8_t *, int, size_t);
+void *nasm_realloc_log(int8_t *, int, void *, size_t);
+void nasm_free_log(int8_t *, int, void *);
+int8_t *nasm_strdup_log(int8_t *, int, const int8_t *);
+int8_t *nasm_strndup_log(int8_t *, int, int8_t *, size_t);
#define nasm_malloc(x) nasm_malloc_log(__FILE__,__LINE__,x)
#define nasm_realloc(x,y) nasm_realloc_log(__FILE__,__LINE__,x,y)
#define nasm_free(x) nasm_free_log(__FILE__,__LINE__,x)
#define nasm_stricmp strcasecmp
#endif
#else
-int nasm_stricmp(const char *, const char *);
+int nasm_stricmp(const int8_t *, const int8_t *);
#endif
#if defined(strnicmp) || defined(strncasecmp)
#define nasm_strnicmp strncasecmp
#endif
#else
-int nasm_strnicmp(const char *, const char *, int);
+int nasm_strnicmp(const int8_t *, const int8_t *, int);
#endif
/*
* Convert a string into a number, using NASM number rules. Sets
* `*error' to TRUE if an error occurs, and FALSE otherwise.
*/
-long readnum(char *str, int *error);
+int64_t readnum(int8_t *str, int *error);
/*
* Convert a character constant into a number. Sets
* str points to and length covers the middle of the string,
* without the quotes.
*/
-long readstrnum(char *str, int length, int *warn);
+int64_t readstrnum(int8_t *str, int length, int *warn);
/*
* seg_init: Initialise the segment-number allocator.
* seg_alloc: allocate a hitherto unused segment number.
*/
void seg_init(void);
-long seg_alloc(void);
+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,
+void standard_extension(int8_t *inname, int8_t *outname, int8_t *extension,
efunc error);
#endif
WRITECHAR(p,(v) >> 16); \
WRITECHAR(p,(v) >> 24); \
} while (0)
+
+#define WRITEDLONG(p,v) \
+ do { \
+ WRITECHAR(p,v); \
+ WRITECHAR(p,(v) >> 8); \
+ WRITECHAR(p,(v) >> 16); \
+ WRITECHAR(p,(v) >> 24); \
+ WRITECHAR(p,(v) >> 32); \
+ WRITECHAR(p,(v) >> 40); \
+ WRITECHAR(p,(v) >> 48); \
+ WRITECHAR(p,(v) >> 56); \
+ } while (0)
/*
* and routines to do the same thing to a file
*/
-void fwriteshort(int data, FILE * fp);
-void fwritelong(long data, FILE * fp);
+void fwriteint16_t(int data, FILE * fp);
+void fwriteint32_t(int32_t data, FILE * fp);
/*
- * Routines to manage a dynamic random access array of longs which
+ * Routines to manage a dynamic random access array of int32_ts which
* may grow in size to be more than the largest single malloc'able
* chunk.
*/
* RAA_BLKSIZE, and for a level 2 branch it's
* RAA_LAYERSIZE*RAA_BLKSIZE.
*/
- long stepsize;
+ int32_t stepsize;
union RAA_UNION {
struct RAA_LEAF {
- long data[RAA_BLKSIZE];
+ int32_t data[RAA_BLKSIZE];
} l;
struct RAA_BRANCH {
struct RAA *data[RAA_LAYERSIZE];
struct RAA *raa_init(void);
void raa_free(struct RAA *);
-long raa_read(struct RAA *, long);
-struct RAA *raa_write(struct RAA *r, long posn, long value);
+int32_t raa_read(struct RAA *, int32_t);
+struct RAA *raa_write(struct RAA *r, int32_t posn, int32_t value);
/*
* Routines to manage a dynamic sequential-access array, under the
* same restriction on maximum mallocable block. This array may be
* written to in two ways: a contiguous chunk can be reserved of a
- * given size, and a pointer returned, or single-byte data may be
+ * given size with a pointer returned OR single-byte data may be
* written. The array can also be read back in the same two ways:
* as a series of big byte-data blocks or as a list of structures
* of a given size.
* list; `rptr' and `rpos' are used for reading
*/
struct SAA *next, *end, *rptr;
- long elem_len, length, posn, start, rpos;
- char *data;
+ int32_t elem_len, length, posn, start, rpos;
+ int8_t *data;
};
-struct SAA *saa_init(long elem_len); /* 1 == byte */
+struct SAA *saa_init(int32_t elem_len); /* 1 == byte */
void saa_free(struct SAA *);
void *saa_wstruct(struct SAA *); /* return a structure of elem_len */
-void saa_wbytes(struct SAA *, const void *, long); /* write arbitrary bytes */
+void saa_wbytes(struct SAA *, const void *, int32_t); /* write arbitrary bytes */
void saa_rewind(struct SAA *); /* for reading from beginning */
void *saa_rstruct(struct SAA *); /* return NULL on EOA */
-void *saa_rbytes(struct SAA *, long *); /* return 0 on EOA */
-void saa_rnbytes(struct SAA *, void *, long); /* read a given no. of bytes */
-void saa_fread(struct SAA *s, long posn, void *p, long len); /* fixup */
-void saa_fwrite(struct SAA *s, long posn, void *p, long len); /* fixup */
+void *saa_rbytes(struct SAA *, int32_t *); /* return 0 on EOA */
+void saa_rnbytes(struct SAA *, void *, int32_t); /* read a given no. of bytes */
+void saa_fread(struct SAA *s, int32_t posn, void *p, int32_t len); /* fixup */
+void saa_fwrite(struct SAA *s, int32_t posn, void *p, int32_t len); /* fixup */
void saa_fpwrite(struct SAA *, FILE *);
#ifdef NASM_NASM_H
/*
* Standard scanner.
*/
-extern char *stdscan_bufptr;
+extern int8_t *stdscan_bufptr;
void stdscan_reset(void);
int stdscan(void *private_data, struct tokenval *tv);
#endif
int is_really_simple(expr *);
int is_unknown(expr *);
int is_just_unknown(expr *);
-long reloc_value(expr *);
-long reloc_seg(expr *);
-long reloc_wrt(expr *);
+int64_t reloc_value(expr *);
+int32_t reloc_seg(expr *);
+int32_t reloc_wrt(expr *);
#endif
/*
* matching `string', or <0 if no match. `array' is taken to
* contain `size' elements.
*/
-int bsi(char *string, const char **array, int size);
+int bsi(int8_t *string, const int8_t **array, int size);
-char *src_set_fname(char *newname);
-long src_set_linnum(long newline);
-long src_get_linnum(void);
+int8_t *src_set_fname(int8_t *newname);
+int32_t src_set_linnum(int32_t newline);
+int32_t src_get_linnum(void);
/*
* src_get may be used if you simply want to know the source file and line.
* It is also used if you maintain private status about the source location
* It return 0 if the information was the same as the last time you
* checked, -1 if the name changed and (new-old) if just the line changed.
*/
-int src_get(long *xline, char **xname);
+int src_get(int32_t *xline, int8_t **xname);
-void nasm_quote(char **str);
-char *nasm_strcat(char *one, char *two);
+void nasm_quote(int8_t **str);
+int8_t *nasm_strcat(int8_t *one, int8_t *two);
void nasmlib_cleanup(void);
-void null_debug_routine(const char *directive, const char *params);
+void null_debug_routine(const int8_t *directive, const int8_t *params);
extern struct dfmt null_debug_form;
extern struct dfmt *null_debug_arr[2];
+
#endif
#include <string.h>
#include <ctype.h>
#include <errno.h>
+#include <inttypes.h>
#include "insns.h"
#include "nasm.h"
#define BPL 8 /* bytes per line of hex dump */
-static const char *help =
+static const int8_t *help =
"usage: ndisasm [-a] [-i] [-h] [-r] [-u] [-b bits] [-o origin] [-s sync...]\n"
" [-e bytes] [-k start,bytes] [-p vendor] file\n"
" -a or -i activates auto (intelligent) sync\n"
" -k avoids disassembling <bytes> bytes from position <start>\n"
" -p selects the preferred vendor instruction set (intel, amd, cyrix, idt)\n";
-static void output_ins(unsigned long, unsigned char *, int, char *);
-static void skip(unsigned long dist, FILE * fp);
+static void output_ins(uint32_t, uint8_t *, int, int8_t *);
+static void skip(uint32_t dist, FILE * fp);
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
- unsigned char buffer[INSN_MAX * 2], *p, *q;
- char outbuf[256];
- char *pname = *argv;
- char *filename = NULL;
- unsigned long nextsync, synclen, initskip = 0L;
+ uint8_t buffer[INSN_MAX * 2], *p, *q;
+ int8_t outbuf[256];
+ int8_t *pname = *argv;
+ int8_t *filename = NULL;
+ uint32_t nextsync, synclen, initskip = 0L;
int lenread;
- long lendis;
+ int32_t lendis;
int autosync = FALSE;
int bits = 16;
int eof = FALSE;
- unsigned long prefer = 0;
+ uint32_t prefer = 0;
int rn_error;
- long offset;
+ int32_t offset;
FILE *fp;
offset = 0;
init_sync();
while (--argc) {
- char *v, *vv, *p = *++argv;
+ int8_t *v, *vv, *p = *++argv;
if (*p == '-' && p[1]) {
p++;
while (*p)
p = q = buffer;
nextsync = next_sync(offset, &synclen);
do {
- unsigned long to_read = buffer + sizeof(buffer) - p;
+ uint32_t to_read = buffer + sizeof(buffer) - p;
if (to_read > nextsync - offset - (p - q))
to_read = nextsync - offset - (p - q);
if (to_read) {
} else
lenread = 0;
p += lenread;
- if ((unsigned long)offset == nextsync) {
+ if ((uint32_t)offset == nextsync) {
if (synclen) {
fprintf(stdout, "%08lX skipping 0x%lX bytes\n", offset,
synclen);
disasm(q, outbuf, sizeof(outbuf), bits, offset, autosync,
prefer);
if (!lendis || lendis > (p - q)
- || (unsigned long)lendis > nextsync - offset)
+ || (uint32_t)lendis > nextsync - offset)
lendis = eatbyte(q, outbuf, sizeof(outbuf));
output_ins(offset, q, lendis, outbuf);
q += lendis;
offset += lendis;
}
if (q >= buffer + INSN_MAX) {
- unsigned char *r = buffer, *s = q;
+ uint8_t *r = buffer, *s = q;
int count = p - q;
while (count--)
*r++ = *s++;
return 0;
}
-static void output_ins(unsigned long offset, unsigned char *data,
- int datalen, char *insn)
+static void output_ins(uint32_t offset, uint8_t *data,
+ int datalen, int8_t *insn)
{
int bytes;
fprintf(stdout, "%08lX ", offset);
* Skip a certain amount of data in a file, either by seeking if
* possible, or if that fails then by reading and discarding.
*/
-static void skip(unsigned long dist, FILE * fp)
+static void skip(uint32_t dist, FILE * fp)
{
- char buffer[256]; /* should fit on most stacks :-) */
+ int8_t buffer[256]; /* should fit on most stacks :-) */
/*
* Got to be careful with fseek: at least one fseek I've tried
*/
if (fseek(fp, dist + ftell(fp), SEEK_SET)) {
while (dist > 0) {
- unsigned long len = (dist < sizeof(buffer) ?
+ uint32_t len = (dist < sizeof(buffer) ?
dist : sizeof(buffer));
if (fread(buffer, 1, len, fp) < len) {
perror("fread");
#include <stdio.h>
#include <string.h>
+#include <inttypes.h>
#define BUILD_DRIVERS_ARRAY
#include "outform.h"
static int ndrivers = 0;
-struct ofmt *ofmt_find(char *name)
+struct ofmt *ofmt_find(int8_t *name)
{ /* find driver */
int i;
return NULL;
}
-struct dfmt *dfmt_find(struct ofmt *ofmt, char *name)
+struct dfmt *dfmt_find(struct ofmt *ofmt, int8_t *name)
{ /* find driver */
struct dfmt **dfmt = ofmt->debug_formats;
while (*dfmt) {
#ifndef OF_WIN32
#define OF_WIN32
#endif
+#ifndef OF_WIN64
+#define OF_WIN64
+#endif
#ifndef OF_AS86
#define OF_AS86
#endif
#ifndef OF_WIN32
#define OF_WIN32
#endif
+#ifndef OF_WIN64
+#define OF_WIN64
+#endif
#endif
#ifdef OF_UNIX
#ifdef OF_NO_WIN32
#undef OF_WIN32
#endif
+#ifdef OF_NO_WIN64
+#undef OF_WIN64
+#endif
#ifdef OF_NO_AS86
#undef OF_AS86
#endif
extern struct ofmt of_as86;
extern struct ofmt of_obj;
extern struct ofmt of_win32;
+extern struct ofmt of_win64;
extern struct ofmt of_rdf2;
extern struct ofmt of_ieee;
extern struct ofmt of_macho;
#ifdef OF_WIN32
&of_win32,
#endif
+#ifdef OF_WIN64
+ &of_win64,
+#endif
#ifdef OF_RDF2
&of_rdf2,
#endif
#endif /* BUILD_DRIVERS_ARRAY */
-struct ofmt *ofmt_find(char *);
-struct dfmt *dfmt_find(struct ofmt *, char *);
+struct ofmt *ofmt_find(int8_t *);
+struct dfmt *dfmt_find(struct ofmt *, int8_t *);
void ofmt_list(struct ofmt *, FILE *);
void dfmt_list(struct ofmt *ofmt, FILE * fp);
struct ofmt *ofmt_register(efunc error);
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
struct Reloc {
struct Reloc *next;
- long address; /* relative to _start_ of section */
- long symbol; /* symbol number or -ve section id */
+ int32_t address; /* relative to _start_ of section */
+ int32_t symbol; /* symbol number or -ve section id */
int bytes; /* 2 or 4 */
int reltype; /* see above */
};
struct Symbol {
- long strpos; /* string table position of name */
+ int32_t strpos; /* string table position of name */
int type; /* symbol type - see flags below */
- long value; /* address, or COMMON variable size */
- long size; /* size for data or function exports */
- long segment; /* back-reference used by gsym_reloc */
+ int32_t value; /* address, or COMMON variable size */
+ int32_t size; /* size for data or function exports */
+ int32_t segment; /* back-reference used by gsym_reloc */
struct Symbol *next; /* list of globals in each section */
struct Symbol *nextfwd; /* list of unresolved-size symbols */
- char *name; /* for unresolved-size symbols */
- long symnum; /* index into symbol table */
+ int8_t *name; /* for unresolved-size symbols */
+ int32_t symnum; /* index into symbol table */
};
/*
struct Section {
struct SAA *data;
- unsigned long len, size, nrelocs;
- long index;
+ uint32_t len, size, nrelocs;
+ int32_t index;
struct Reloc *head, **tail;
struct Symbol *gsyms, *asym;
};
static struct Section stext, sdata, sbss;
static struct SAA *syms;
-static unsigned long nsyms;
+static uint32_t nsyms;
static struct RAA *bsym;
static struct SAA *strs;
-static unsigned long strslen;
+static uint32_t strslen;
static struct Symbol *fwds;
static void aout_write(void);
static void aout_write_relocs(struct Reloc *);
static void aout_write_syms(void);
-static void aout_sect_write(struct Section *, const unsigned char *,
- unsigned long);
+static void aout_sect_write(struct Section *, const uint8_t *,
+ uint32_t);
static void aout_pad_sections(void);
static void aout_fixup_relocs(struct Section *);
* symbols, which can be used with WRT to provide PIC relocation
* types.
*/
-static long aout_gotpc_sect, aout_gotoff_sect;
-static long aout_got_sect, aout_plt_sect;
-static long aout_sym_sect;
+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)
sdata.index = seg_alloc();
sbss.index = seg_alloc();
stext.asym = sdata.asym = sbss.asym = NULL;
- syms = saa_init((long)sizeof(struct Symbol));
+ syms = saa_init((int32_t)sizeof(struct Symbol));
nsyms = 0;
bsym = raa_init();
strs = saa_init(1L);
saa_free(strs);
}
-static long aout_section_names(char *name, int pass, int *bits)
+static int32_t aout_section_names(int8_t *name, int pass, int *bits)
{
/*
* Default to 32 bits.
return NO_SEG;
}
-static void aout_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void aout_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
int pos = strslen + 4;
struct Symbol *sym;
if (!strcmp((*s)->name, name)) {
struct tokenval tokval;
expr *e;
- char *p = special;
+ int8_t *p = special;
while (*p && !isspace(*p))
p++;
return; /* it wasn't an important one */
}
- saa_wbytes(strs, name, (long)(1 + strlen(name)));
+ saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
strslen += 1 + strlen(name);
sym = saa_wstruct(syms);
struct tokenval tokval;
expr *e;
int fwd = FALSE;
- char *saveme = stdscan_bufptr; /* bugfix? fbk 8/10/00 */
+ int8_t *saveme = stdscan_bufptr; /* bugfix? fbk 8/10/00 */
if (!bsd) {
error(ERR_NONFATAL, "Linux a.out does not support"
error(ERR_NONFATAL, "no special symbol features supported here");
}
-static void aout_add_reloc(struct Section *sect, long segment,
+static void aout_add_reloc(struct Section *sect, int32_t segment,
int reltype, int bytes)
{
struct Reloc *r;
* Inefficiency: we search, currently, using a linked list which
* isn't even necessarily sorted.
*/
-static long aout_add_gsym_reloc(struct Section *sect,
- long segment, long offset,
+static int32_t aout_add_gsym_reloc(struct Section *sect,
+ int32_t segment, int32_t offset,
int type, int bytes, int exact)
{
struct Symbol *sym, *sm, *shead;
* Return value is the adjusted value of `addr', having become an
* offset from the `asym' symbol rather than the section.
*/
-static long aout_add_gotoff_reloc(struct Section *sect, long segment,
- long offset, int bytes)
+static int32_t aout_add_gotoff_reloc(struct Section *sect, int32_t segment,
+ int32_t offset, int bytes)
{
struct Reloc *r;
struct Symbol *asym;
return offset - asym->value;
}
-static void aout_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void aout_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
struct Section *s;
- long realbytes = type & OUT_SIZMASK;
- long addr;
- unsigned char mydata[4], *p;
+ int32_t realbytes = type & OUT_SIZMASK;
+ int32_t addr;
+ uint8_t mydata[4], *p;
type &= OUT_TYPMASK;
}
if (!s && type != OUT_RESERVE) {
- error(ERR_WARNING, "attempt to initialise memory in the"
+ error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
if (type == OUT_REL2ADR)
realbytes = 2;
if (type == OUT_RESERVE) {
if (s) {
- error(ERR_WARNING, "uninitialised space declared in"
+ error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
(segto == stext.index ? "code" : "data"));
aout_sect_write(s, NULL, realbytes);
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
aout_sect_write(s, data, realbytes);
} else if (type == OUT_ADDRESS) {
- addr = *(long *)data;
+ addr = *(int32_t *)data;
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "a.out format does not support"
}
}
p = mydata;
- WRITESHORT(p, *(long *)data - (realbytes + s->len));
+ WRITESHORT(p, *(int32_t *)data - (realbytes + s->len));
aout_sect_write(s, mydata, 2L);
} else if (type == OUT_REL4ADR) {
if (segment == segto)
}
}
p = mydata;
- WRITELONG(p, *(long *)data - (realbytes + s->len));
+ WRITELONG(p, *(int32_t *)data - (realbytes + s->len));
aout_sect_write(s, mydata, 4L);
}
}
static void aout_pad_sections(void)
{
- static unsigned char pad[] = { 0x90, 0x90, 0x90, 0x90 };
+ static uint8_t pad[] = { 0x90, 0x90, 0x90, 0x90 };
/*
* Pad each of the text and data sections with NOPs until their
* length is a multiple of four. (NOP == 0x90.) Also increase
* the length of the BSS section similarly.
*/
- aout_sect_write(&stext, pad, (-(long)stext.len) & 3);
- aout_sect_write(&sdata, pad, (-(long)sdata.len) & 3);
+ aout_sect_write(&stext, pad, (-(int32_t)stext.len) & 3);
+ aout_sect_write(&sdata, pad, (-(int32_t)sdata.len) & 3);
sbss.len = (sbss.len + 3) & ~3;
}
saa_rewind(sect->data);
for (r = sect->head; r; r = r->next) {
- unsigned char *p, *q, blk[4];
- long l;
+ uint8_t *p, *q, blk[4];
+ int32_t l;
- saa_fread(sect->data, r->address, blk, (long)r->bytes);
+ saa_fread(sect->data, r->address, blk, (int32_t)r->bytes);
p = q = blk;
l = *p++;
if (r->bytes > 1) {
- l += ((long)*p++) << 8;
+ l += ((int32_t)*p++) << 8;
if (r->bytes == 4) {
- l += ((long)*p++) << 16;
- l += ((long)*p++) << 24;
+ l += ((int32_t)*p++) << 16;
+ l += ((int32_t)*p++) << 24;
}
}
if (r->symbol == -SECT_DATA)
WRITESHORT(q, l);
else
*q++ = l & 0xFF;
- saa_fwrite(sect->data, r->address, blk, (long)r->bytes);
+ saa_fwrite(sect->data, r->address, blk, (int32_t)r->bytes);
}
}
* Emit the a.out header.
*/
/* OMAGIC, M_386 or MID_I386, no flags */
- fwritelong(bsd ? 0x07018600 | is_pic : 0x640107L, aoutfp);
- fwritelong(stext.len, aoutfp);
- fwritelong(sdata.len, aoutfp);
- fwritelong(sbss.len, aoutfp);
- fwritelong(nsyms * 12, aoutfp); /* length of symbol table */
- fwritelong(0L, aoutfp); /* object files have no entry point */
- fwritelong(stext.nrelocs * 8, aoutfp); /* size of text relocs */
- fwritelong(sdata.nrelocs * 8, aoutfp); /* size of data relocs */
+ 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 */
/*
* Write out the code section and the data section.
/*
* And the string table.
*/
- fwritelong(strslen + 4, aoutfp); /* length includes length count */
+ fwriteint32_t(strslen + 4, aoutfp); /* length includes length count */
saa_fpwrite(strs, aoutfp);
}
static void aout_write_relocs(struct Reloc *r)
{
while (r) {
- unsigned long word2;
+ uint32_t word2;
- fwritelong(r->address, aoutfp);
+ fwriteint32_t(r->address, aoutfp);
if (r->symbol >= 0)
word2 = r->symbol;
word2 |= r->reltype << 24;
word2 |= (r->bytes == 1 ? 0 :
r->bytes == 2 ? 0x2000000L : 0x4000000L);
- fwritelong(word2, aoutfp);
+ fwriteint32_t(word2, aoutfp);
r = r->next;
}
static void aout_write_syms(void)
{
- unsigned long i;
+ uint32_t i;
saa_rewind(syms);
for (i = 0; i < nsyms; i++) {
struct Symbol *sym = saa_rstruct(syms);
- fwritelong(sym->strpos, aoutfp);
- fwritelong((long)sym->type & ~SYM_WITH_SIZE, aoutfp);
+ fwriteint32_t(sym->strpos, aoutfp);
+ fwriteint32_t((int32_t)sym->type & ~SYM_WITH_SIZE, aoutfp);
/*
* Fix up the symbol value now we know the final section
* sizes.
sym->value += stext.len;
if ((sym->type & SECT_MASK) == SECT_BSS)
sym->value += stext.len + sdata.len;
- fwritelong(sym->value, aoutfp);
+ fwriteint32_t(sym->value, aoutfp);
/*
* Output a size record if necessary.
*/
if (sym->type & SYM_WITH_SIZE) {
- fwritelong(sym->strpos, aoutfp);
- fwritelong(0x0DL, aoutfp); /* special value: means size */
- fwritelong(sym->size, aoutfp);
+ fwriteint32_t(sym->strpos, aoutfp);
+ fwriteint32_t(0x0DL, aoutfp); /* special value: means size */
+ fwriteint32_t(sym->size, aoutfp);
i++; /* use up another of `nsyms' */
}
}
}
static void aout_sect_write(struct Section *sect,
- const unsigned char *data, unsigned long len)
+ const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->len += len;
}
-static long aout_segbase(long segment)
+static int32_t aout_segbase(int32_t segment)
{
return segment;
}
-static int aout_directive(char *directive, char *value, int pass)
+static int aout_directive(int8_t *directive, int8_t *value, int pass)
{
return 0;
}
-static void aout_filename(char *inname, char *outname, efunc error)
+static void aout_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, ".o", error);
}
-static const char *aout_stdmac[] = {
+static const int8_t *aout_stdmac[] = {
"%define __SECT__ [section .text]",
"%macro __NASM_CDecl__ 1",
"%endmacro",
NULL
};
-static int aout_set_info(enum geninfo type, char **val)
+static int aout_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
struct Piece {
struct Piece *next;
int type; /* 0 = absolute, 1 = seg, 2 = sym */
- long offset; /* relative offset */
+ int32_t offset; /* relative offset */
int number; /* symbol/segment number (4=bss) */
- long bytes; /* size of reloc or of absolute data */
+ int32_t bytes; /* size of reloc or of absolute data */
int relative; /* TRUE or FALSE */
};
struct Symbol {
- long strpos; /* string table position of name */
+ int32_t strpos; /* string table position of name */
int flags; /* symbol flags */
int segment; /* 4=bss at this point */
- long value; /* address, or COMMON variable size */
+ int32_t value; /* address, or COMMON variable size */
};
/*
struct Section {
struct SAA *data;
- unsigned long datalen, size, len;
- long index;
+ uint32_t datalen, size, len;
+ int32_t index;
struct Piece *head, *last, **tail;
};
-static char as86_module[FILENAME_MAX];
+static int8_t as86_module[FILENAME_MAX];
static struct Section stext, sdata;
-static unsigned long bsslen;
-static long bssindex;
+static uint32_t bsslen;
+static int32_t bssindex;
static struct SAA *syms;
-static unsigned long nsyms;
+static uint32_t nsyms;
static struct RAA *bsym;
static struct SAA *strs;
-static unsigned long strslen;
+static uint32_t strslen;
static int as86_reloc_size;
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 unsigned char *,
- unsigned long);
+static int as86_add_string(int8_t *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)
{
stext.index = seg_alloc();
sdata.index = seg_alloc();
bssindex = seg_alloc();
- syms = saa_init((long)sizeof(struct Symbol));
+ syms = saa_init((int32_t)sizeof(struct Symbol));
nsyms = 0;
bsym = raa_init();
strs = saa_init(1L);
saa_free(strs);
}
-static long as86_section_names(char *name, int pass, int *bits)
+static int32_t as86_section_names(int8_t *name, int pass, int *bits)
{
/*
* Default is 16 bits.
return NO_SEG;
}
-static int as86_add_string(char *name)
+static int as86_add_string(int8_t *name)
{
int pos = strslen;
int length = strlen(name);
- saa_wbytes(strs, name, (long)(length + 1));
+ saa_wbytes(strs, name, (int32_t)(length + 1));
strslen += 1 + length;
return pos;
}
-static void as86_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void as86_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
struct Symbol *sym;
nsyms++;
}
-static void as86_add_piece(struct Section *sect, int type, long offset,
- long segment, long bytes, int relative)
+static void as86_add_piece(struct Section *sect, int type, int32_t offset,
+ int32_t segment, int32_t bytes, int relative)
{
struct Piece *p;
p->number = raa_read(bsym, segment), p->type = 2;
}
-static void as86_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void as86_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
struct Section *s;
- long realbytes = type & OUT_SIZMASK;
- long offset;
- unsigned char mydata[4], *p;
+ int32_t realbytes = type & OUT_SIZMASK;
+ int32_t offset;
+ uint8_t mydata[4], *p;
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
}
if (!s && type != OUT_RESERVE) {
- error(ERR_WARNING, "attempt to initialise memory in the"
+ error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
if (type == OUT_REL2ADR)
realbytes = 2;
if (type == OUT_RESERVE) {
if (s) {
- error(ERR_WARNING, "uninitialised space declared in"
+ error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
(segto == stext.index ? "code" : "data"));
as86_sect_write(s, NULL, realbytes);
error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
- offset = *(long *)data;
+ offset = *(int32_t *)data;
as86_add_piece(s, 1, offset, segment, realbytes, 0);
}
} else {
p = mydata;
- WRITELONG(p, *(long *)data);
+ WRITELONG(p, *(int32_t *)data);
as86_sect_write(s, data, realbytes);
as86_add_piece(s, 0, 0L, 0L, realbytes, 0);
}
error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
- offset = *(long *)data;
+ offset = *(int32_t *)data;
as86_add_piece(s, 1, offset - realbytes + 2, segment, 2L,
1);
}
error(ERR_NONFATAL, "as86 format does not support"
" segment base references");
} else {
- offset = *(long *)data;
+ offset = *(int32_t *)data;
as86_add_piece(s, 1, offset - realbytes + 4, segment, 4L,
1);
}
static void as86_write(void)
{
- unsigned long i;
- long symlen, seglen, segsize;
+ uint32_t i;
+ int32_t symlen, seglen, segsize;
/*
* First, go through the symbol records working out how big
* descriptor word at the same time.
*/
seglen = segsize = 0;
- if ((unsigned long)stext.len > 65535L)
+ if ((uint32_t)stext.len > 65535L)
segsize |= 0x03000000L, seglen += 4;
else
segsize |= 0x02000000L, seglen += 2;
- if ((unsigned long)sdata.len > 65535L)
+ if ((uint32_t)sdata.len > 65535L)
segsize |= 0xC0000000L, seglen += 4;
else
segsize |= 0x80000000L, seglen += 2;
/*
* Emit the as86 header.
*/
- fwritelong(0x000186A3L, as86fp);
+ fwriteint32_t(0x000186A3L, as86fp);
fputc(0x2A, as86fp);
- fwritelong(27 + symlen + seglen + strslen, as86fp); /* header length */
- fwritelong(stext.len + sdata.len + bsslen, as86fp);
- fwriteshort(strslen, as86fp);
- fwriteshort(0, as86fp); /* class = revision = 0 */
- fwritelong(0x55555555L, as86fp); /* segment max sizes: always this */
- fwritelong(segsize, as86fp); /* segment size descriptors */
+ 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 */
if (segsize & 0x01000000L)
- fwritelong(stext.len, as86fp);
+ fwriteint32_t(stext.len, as86fp);
else
- fwriteshort(stext.len, as86fp);
+ fwriteint16_t(stext.len, as86fp);
if (segsize & 0x40000000L)
- fwritelong(sdata.len + bsslen, as86fp);
+ fwriteint32_t(sdata.len + bsslen, as86fp);
else
- fwriteshort(sdata.len + bsslen, as86fp);
- fwriteshort(nsyms, as86fp);
+ fwriteint16_t(sdata.len + bsslen, as86fp);
+ fwriteint16_t(nsyms, as86fp);
/*
* Write the symbol table.
saa_rewind(syms);
for (i = 0; i < nsyms; i++) {
struct Symbol *sym = saa_rstruct(syms);
- fwriteshort(sym->strpos, as86fp);
- fwriteshort(sym->flags, as86fp);
+ fwriteint16_t(sym->strpos, as86fp);
+ fwriteint16_t(sym->flags, as86fp);
switch (sym->flags & (3 << 14)) {
case 0 << 14:
break;
fputc(sym->value, as86fp);
break;
case 2 << 14:
- fwriteshort(sym->value, as86fp);
+ fwriteint16_t(sym->value, as86fp);
break;
case 3 << 14:
- fwritelong(sym->value, as86fp);
+ fwriteint32_t(sym->value, as86fp);
break;
}
}
*/
if (bsslen > 65535L) {
fputc(0x13, as86fp);
- fwritelong(bsslen, as86fp);
+ fwriteint32_t(bsslen, as86fp);
} else if (bsslen > 255) {
fputc(0x12, as86fp);
- fwriteshort(bsslen, as86fp);
+ fwriteint16_t(bsslen, as86fp);
} else if (bsslen) {
fputc(0x11, as86fp);
fputc(bsslen, as86fp);
static void as86_write_section(struct Section *sect, int index)
{
struct Piece *p;
- unsigned long s;
- long length;
+ uint32_t s;
+ int32_t length;
fputc(0x20 + index, as86fp); /* select the right section */
*/
length = p->bytes;
do {
- char buf[64];
- long tmplen = (length > 64 ? 64 : length);
+ int8_t buf[64];
+ int32_t tmplen = (length > 64 ? 64 : length);
fputc(0x40 | (tmplen & 0x3F), as86fp);
saa_rnbytes(sect->data, buf, tmplen);
fwrite(buf, 1, tmplen, as86fp);
as86_set_rsize(p->bytes);
fputc(0x80 | (p->relative ? 0x20 : 0) | p->number, as86fp);
if (as86_reloc_size == 2)
- fwriteshort(p->offset, as86fp);
+ fwriteint16_t(p->offset, as86fp);
else
- fwritelong(p->offset, as86fp);
+ fwriteint32_t(p->offset, as86fp);
break;
case 2:
/*
(p->relative ? 0x20 : 0) |
(p->number > 255 ? 0x04 : 0) | s, as86fp);
if (p->number > 255)
- fwriteshort(p->number, as86fp);
+ fwriteint16_t(p->number, as86fp);
else
fputc(p->number, as86fp);
switch ((int)s) {
fputc(p->offset, as86fp);
break;
case 2:
- fwriteshort(p->offset, as86fp);
+ fwriteint16_t(p->offset, as86fp);
break;
case 3:
- fwritelong(p->offset, as86fp);
+ fwriteint32_t(p->offset, as86fp);
break;
}
break;
}
static void as86_sect_write(struct Section *sect,
- const unsigned char *data, unsigned long len)
+ const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->datalen += len;
}
-static long as86_segbase(long segment)
+static int32_t as86_segbase(int32_t segment)
{
return segment;
}
-static int as86_directive(char *directive, char *value, int pass)
+static int as86_directive(int8_t *directive, int8_t *value, int pass)
{
return 0;
}
-static void as86_filename(char *inname, char *outname, efunc error)
+static void as86_filename(int8_t *inname, int8_t *outname, efunc error)
{
- char *p;
+ int8_t *p;
if ((p = strrchr(inname, '.')) != NULL) {
strncpy(as86_module, inname, p - inname);
standard_extension(inname, outname, ".o", error);
}
-static const char *as86_stdmac[] = {
+static const int8_t *as86_stdmac[] = {
"%define __SECT__ [section .text]",
"%macro __NASM_CDecl__ 1",
"%endmacro",
NULL
};
-static int as86_set_info(enum geninfo type, char **val)
+static int as86_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
-void as86_linenumber(char *name, long segment, long offset, int is_main,
+void as86_linenumber(int8_t *name, int32_t segment, int32_t offset, int is_main,
int lineno)
{
}
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
/* This struct is used to keep track of symbols for map-file generation. */
static struct bin_label {
- char *name;
+ int8_t *name;
struct bin_label *next;
} *no_seg_labels, **nsl_tail;
static struct Section {
- char *name;
+ int8_t *name;
struct SAA *contents;
- long length; /* section length in bytes */
+ int32_t length; /* section length in bytes */
/* Section attributes */
int flags; /* see flag definitions above */
- unsigned long align; /* section alignment */
- unsigned long valign; /* notional section alignment */
- unsigned long start; /* section start address */
- unsigned long vstart; /* section virtual start address */
- char *follows; /* the section that this one will follow */
- char *vfollows; /* the section that this one will notionally follow */
- long start_index; /* NASM section id for non-relocated version */
- long vstart_index; /* the NASM section id */
+ uint32_t align; /* section alignment */
+ uint32_t valign; /* notional section alignment */
+ uint32_t start; /* section start address */
+ uint32_t vstart; /* section virtual start address */
+ int8_t *follows; /* the section that this one will follow */
+ int8_t *vfollows; /* the section that this one will notionally follow */
+ int32_t start_index; /* NASM section id for non-relocated version */
+ int32_t vstart_index; /* the NASM section id */
struct bin_label *labels; /* linked-list of label handles for map output. */
struct bin_label **labels_end; /* Holds address of end of labels list. */
static struct Reloc {
struct Reloc *next;
- long posn;
- long bytes;
- long secref;
- long secrel;
+ int32_t posn;
+ int32_t bytes;
+ int32_t secref;
+ int32_t secrel;
struct Section *target;
} *relocs, **reloctail;
-extern char *stdscan_bufptr;
-extern int lookup_label(char *label, long *segment, long *offset);
+extern int8_t *stdscan_bufptr;
+extern int lookup_label(int8_t *label, int32_t *segment, int32_t *offset);
-static unsigned char format_mode; /* 0 = original bin, 1 = extended bin */
-static long current_section; /* only really needed if format_mode = 0 */
-static unsigned long origin;
+static uint8_t format_mode; /* 0 = original bin, 1 = extended bin */
+static int32_t current_section; /* only really needed if format_mode = 0 */
+static uint32_t origin;
static int origin_defined;
/* Stuff we need for map-file generation. */
#define MAP_SECTIONS 4
#define MAP_SYMBOLS 8
static int map_control = 0;
-static char *infile, *outfile;
+static int8_t *infile, *outfile;
-static const char *bin_stdmac[] = {
+static const int8_t *bin_stdmac[] = {
"%define __SECT__ [section .text]",
"%imacro org 1+.nolist",
"[org %1]",
NULL
};
-static void add_reloc(struct Section *s, long bytes, long secref,
- long secrel)
+static void add_reloc(struct Section *s, int32_t bytes, int32_t secref,
+ int32_t secrel)
{
struct Reloc *r;
r->target = s;
}
-static struct Section *find_section_by_name(const char *name)
+static struct Section *find_section_by_name(const int8_t *name)
{
struct Section *s;
return s;
}
-static struct Section *find_section_by_index(long index)
+static struct Section *find_section_by_index(int32_t index)
{
struct Section *s;
return s;
}
-static struct Section *create_section(char *name)
+static struct Section *create_section(int8_t *name)
{ /* Create a new section. */
last_section->next = nasm_malloc(sizeof(struct Section));
last_section->next->ifollows = last_section;
struct Section *last_progbits;
struct bin_label *l;
struct Reloc *r;
- unsigned long pend;
+ uint32_t pend;
int h;
#ifdef DEBUG
saa_rewind(s->contents);
/* Apply relocations. */
for (r = relocs; r; r = r->next) {
- unsigned char *p, *q, mydata[4];
- long l;
+ uint8_t *p, *q, mydata[8];
+ int64_t l;
saa_fread(r->target->contents, r->posn, mydata, r->bytes);
p = q = mydata;
l = *p++;
if (r->bytes > 1) {
- l += ((long)*p++) << 8;
- if (r->bytes == 4) {
- l += ((long)*p++) << 16;
- l += ((long)*p++) << 24;
+ l += ((int64_t)*p++) << 8;
+ if (r->bytes >= 4) {
+ l += ((int64_t)*p++) << 16;
+ l += ((int64_t)*p++) << 24;
+ }
+ if (r->bytes == 8) {
+ l += ((int64_t)*p++) << 32;
+ l += ((int64_t)*p++) << 40;
+ l += ((int64_t)*p++) << 48;
+ l += ((int64_t)*p++) << 56;
}
}
else
l -= s->vstart;
}
-
- if (r->bytes == 4)
- WRITELONG(q, l);
+
+ if (r->bytes >= 4)
+ WRITEDLONG(q, l);
else if (r->bytes == 2)
WRITESHORT(q, l);
else
- *q++ = (unsigned char)(l & 0xFF);
+ *q++ = (uint8_t)(l & 0xFF);
saa_fwrite(r->target->contents, r->posn, mydata, r->bytes);
}
/* Step 7: Generate the map file. */
if (map_control) {
- const char *not_defined = { "not defined" };
+ const int8_t *not_defined = { "not defined" };
/* Display input and output file names. */
fprintf(rf, "\n- NASM Map file ");
}
/* Display symbols information. */
if (map_control & MAP_SYMBOLS) {
- long segment, offset;
+ int32_t segment, offset;
fprintf(rf, "-- Symbols ");
for (h = 68; h; h--)
}
}
-static void bin_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void bin_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- unsigned char *p, mydata[4];
+ uint8_t *p, mydata[8];
struct Section *s;
- long realbytes;
-
+ 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)
}
if ((s->flags & TYPE_NOBITS) && ((type & OUT_TYPMASK) != OUT_RESERVE))
- error(ERR_WARNING, "attempt to initialise memory in a"
+ error(ERR_WARNING, "attempt to initialize memory in a"
" nobits section: ignored");
if ((type & OUT_TYPMASK) == OUT_ADDRESS) {
add_reloc(s, type & OUT_SIZMASK, segment, -1L);
p = mydata;
if ((type & OUT_SIZMASK) == 4)
- WRITELONG(p, *(long *)data);
+ WRITELONG(p, *(int32_t *)data);
+ else if ((type & OUT_SIZMASK) == 8)
+ WRITEDLONG(p, *(int64_t *)data);
else
- WRITESHORT(p, *(long *)data);
+ WRITESHORT(p, *(int32_t *)data);
saa_wbytes(s->contents, mydata, type & OUT_SIZMASK);
}
s->length += type & OUT_SIZMASK;
} else if ((type & OUT_TYPMASK) == OUT_RESERVE) {
type &= OUT_SIZMASK;
if (s->flags & TYPE_PROGBITS) {
- error(ERR_WARNING, "uninitialised space declared in"
+ error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing", s->name);
saa_wbytes(s->contents, NULL, type);
}
s->length += type;
} else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
(type & OUT_TYPMASK) == OUT_REL4ADR) {
- realbytes = ((type & OUT_TYPMASK) == OUT_REL4ADR ? 4 : 2);
+ realbytes = (type & OUT_TYPMASK);
+ if (realbytes == OUT_REL2ADR)
+ realbytes = 2;
+ else
+ realbytes = 4;
if (segment != NO_SEG && !find_section_by_index(segment)) {
if (segment % 2)
error(ERR_NONFATAL, "binary output format does not support"
add_reloc(s, realbytes, segment, segto);
p = mydata;
if (realbytes == 4)
- WRITELONG(p, *(long *)data - realbytes - s->length);
+ WRITELONG(p, *(int32_t *)data - realbytes - s->length);
else
- WRITESHORT(p, *(long *)data - realbytes - s->length);
+ WRITESHORT(p, *(int32_t *)data - realbytes - s->length);
saa_wbytes(s->contents, mydata, realbytes);
}
s->length += realbytes;
}
}
-static void bin_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void bin_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
(void)segment; /* Don't warn that this parameter is unused */
(void)offset; /* Don't warn that this parameter is unused */
ATTRIB_NOBITS, ATTRIB_PROGBITS
};
-static int bin_read_attribute(char **line, int *attribute,
- unsigned long *value)
+static int bin_read_attribute(int8_t **line, int *attribute,
+ uint32_t *value)
{
expr *e;
int attrib_name_size;
struct tokenval tokval;
- char *exp;
+ int8_t *exp;
/* Skip whitespace. */
while (**line && isspace(**line))
(*line)++;
}
} else {
- char c;
+ int8_t c;
int pcount = 1;
/* Full expression (delimited by parenthesis) */
" specified in `section' directive.");
return -1;
}
- *value = (unsigned long)reloc_value(e);
+ *value = (uint32_t)reloc_value(e);
return 1;
}
-static void bin_assign_attributes(struct Section *sec, char *astring)
+static void bin_assign_attributes(struct Section *sec, int8_t *astring)
{
int attribute, check;
- unsigned long value;
- char *p;
+ uint32_t value;
+ int8_t *p;
while (1) { /* Get the next attribute. */
check = bin_read_attribute(&astring, &attribute, &value);
{
static int labels_defined = 0;
struct Section *sec;
- char *label_name;
+ int8_t *label_name;
size_t base_len;
if (labels_defined)
labels_defined = 1;
}
-static long bin_secname(char *name, int pass, int *bits)
+static int32_t bin_secname(int8_t *name, int pass, int *bits)
{
- char *p;
+ int8_t *p;
struct Section *sec;
/* bin_secname is called with *name = NULL at the start of each
return current_section;
}
-static int bin_directive(char *directive, char *args, int pass)
+static int bin_directive(int8_t *directive, int8_t *args, int pass)
{
/* Handle ORG directive */
if (!nasm_stricmp(directive, "org")) {
struct tokenval tokval;
- unsigned long value;
+ uint32_t value;
expr *e;
stdscan_reset();
/* The 'map' directive allows the user to generate section
* and symbol information to stdout, stderr, or to a file. */
else if (format_mode && !nasm_stricmp(directive, "map")) {
- char *p;
+ int8_t *p;
if (pass != 1)
return 1;
return 0;
}
-static void bin_filename(char *inname, char *outname, efunc error)
+static void bin_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, "", error);
infile = inname;
outfile = outname;
}
-static long bin_segbase(long segment)
+static int32_t bin_segbase(int32_t segment)
{
return segment;
}
-static int bin_set_info(enum geninfo type, char **val)
+static int bin_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
(void)eval; /* Don't warn that this parameter is unused. */
(void)ldef; /* Placate optimizers. */
+ maxbits = 64; /* Support 64-bit Segments */
relocs = NULL;
reloctail = &relocs;
origin_defined = 0;
#include <string.h>
#include <ctype.h>
#include <time.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
#include "outform.h"
-#if defined(OF_COFF) || defined(OF_WIN32)
+#if defined(OF_COFF) || defined(OF_WIN32) || defined(OF_WIN64)
/*
* Notes on COFF:
*/
/* Flag which version of COFF we are currently outputting. */
-static int win32;
+static int win32, win64;
struct Reloc {
struct Reloc *next;
- long address; /* relative to _start_ of section */
- long symbol; /* symbol number */
+ int32_t address; /* relative to _start_ of section */
+ int32_t symbol; /* symbol number */
enum {
SECT_SYMBOLS,
ABS_SYMBOL,
REAL_SYMBOLS
} symbase; /* relocation for symbol number :) */
int relative; /* TRUE or FALSE */
+ int size64; /* TRUE or FALSE */
};
struct Symbol {
- char name[9];
- long strpos; /* string table position of name */
+ int8_t name[9];
+ int32_t strpos; /* string table position of name */
int section; /* section number where it's defined
* - in COFF codes, not NASM codes */
int is_global; /* is it a global symbol or not? */
- long value; /* address, or COMMON variable size */
+ int32_t value; /* address, or COMMON variable size */
};
static FILE *coffp;
static efunc error;
-static char coff_infile[FILENAME_MAX];
+static int8_t coff_infile[FILENAME_MAX];
struct Section {
struct SAA *data;
- unsigned long len;
+ uint32_t len;
int nrelocs;
- long index;
+ int32_t index;
struct Reloc *head, **tail;
- unsigned long flags; /* section flags */
- char name[9];
- long pos, relpos;
+ uint32_t flags; /* section flags */
+ int8_t name[9];
+ int32_t pos, relpos;
};
-#define TEXT_FLAGS (win32 ? 0x60500020L : 0x20L)
-#define DATA_FLAGS (win32 ? 0xC0300040L : 0x40L)
-#define BSS_FLAGS (win32 ? 0xC0300080L : 0x80L)
+#define TEXT_FLAGS ((win32 | win64) ? 0x60500020L : 0x20L)
+#define DATA_FLAGS ((win32 | win64) ? 0xC0300040L : 0x40L)
+#define BSS_FLAGS ((win32 | win64) ? 0xC0300080L : 0x80L)
#define INFO_FLAGS 0x00100A00L
-#define RDATA_FLAGS (win32 ? 0x40400040L : 0x40L)
+#define RDATA_FLAGS ((win32 | win64) ? 0x40400040L : 0x40L)
#define SECT_DELTA 32
static struct Section **sects;
static int nsects, sectlen;
static struct SAA *syms;
-static unsigned long nsyms;
+static uint32_t nsyms;
-static long def_seg;
+static int32_t def_seg;
static int initsym;
static struct RAA *bsym, *symval;
static struct SAA *strs;
-static unsigned long strslen;
+static uint32_t strslen;
static void coff_gen_init(FILE *, efunc);
-static void coff_sect_write(struct Section *, const unsigned char *,
- unsigned long);
+static void coff_sect_write(struct Section *, const uint8_t *,
+ uint32_t);
static void coff_write(void);
-static void coff_section_header(char *, long, long, long, long, int, long);
+static void coff_section_header(int8_t *, int32_t, int32_t, int32_t, int32_t, int, int32_t);
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)
{
- win32 = TRUE;
- (void)ldef; /* placate optimisers */
+ win32 = TRUE; win64 = FALSE;
+ (void)ldef; /* placate optimizers */
+ coff_gen_init(fp, errfunc);
+}
+
+static void coff_win64_init(FILE * fp, efunc errfunc,
+ ldfunc ldef, evalfunc eval)
+{
+ maxbits = 64;
+ win32 = FALSE; win64 = TRUE;
+ (void)ldef; /* placate optimizers */
coff_gen_init(fp, errfunc);
}
static void coff_std_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
{
- win32 = FALSE;
- (void)ldef; /* placate optimisers */
+ win32 = win64 = FALSE;
+ (void)ldef; /* placate optimizers */
coff_gen_init(fp, errfunc);
}
error = errfunc;
sects = NULL;
nsects = sectlen = 0;
- syms = saa_init((long)sizeof(struct Symbol));
+ syms = saa_init((int32_t)sizeof(struct Symbol));
nsyms = 0;
bsym = raa_init();
symval = raa_init();
saa_free(strs);
}
-static int coff_make_section(char *name, unsigned long flags)
+static int coff_make_section(int8_t *name, uint32_t flags)
{
struct Section *s;
return nsects - 1;
}
-static long coff_section_names(char *name, int pass, int *bits)
+static int32_t coff_section_names(int8_t *name, int pass, int *bits)
{
- char *p;
- unsigned long flags, align_and = ~0L, align_or = 0L;
+ int8_t *p;
+ uint32_t flags, align_and = ~0L, align_or = 0L;
int i;
/*
- * Default is 32 bits.
+ * Set default bits.
*/
- if (!name)
- *bits = 32;
+ if (!name) {
+ if(win64)
+ *bits = 64;
+ else
+ *bits = 32;
+ }
if (!name)
return def_seg;
while (*p && isspace(*p))
p++;
while (*p) {
- char *q = p;
+ int8_t *q = p;
while (*p && !isspace(*p))
p++;
if (*p)
} else if (!nasm_stricmp(q, "data")) {
flags = DATA_FLAGS;
} else if (!nasm_stricmp(q, "rdata")) {
- if (win32)
+ if (win32 | win64)
flags = RDATA_FLAGS;
else {
flags = DATA_FLAGS; /* gotta do something */
} else if (!nasm_stricmp(q, "bss")) {
flags = BSS_FLAGS;
} else if (!nasm_stricmp(q, "info")) {
- if (win32)
+ if (win32 | win64)
flags = INFO_FLAGS;
else {
flags = DATA_FLAGS; /* gotta do something */
" informational sections");
}
} else if (!nasm_strnicmp(q, "align=", 6)) {
- if (!win32)
+ if (!(win32 | win64))
error(ERR_NONFATAL, "standard COFF does not support"
" section alignment specification");
else {
return sects[i]->index;
}
-static void coff_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void coff_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
int pos = strslen + 4;
struct Symbol *sym;
" special symbol types");
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
- error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
+ error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
return;
}
if (strlen(name) > 8) {
- saa_wbytes(strs, name, (long)(1 + strlen(name)));
+ saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
strslen += 1 + strlen(name);
} else
pos = -1;
* define the references from external-symbol segment numbers
* to these symbol records.
*/
- if (sym->section == 0)
+ if (sym->section == 0) {
bsym = raa_write(bsym, segment, nsyms);
+ }
if (segment != NO_SEG)
symval = raa_write(symval, segment, sym->section ? 0 : sym->value);
nsyms++;
}
-static long coff_add_reloc(struct Section *sect, long segment,
- int relative)
+static int32_t coff_add_reloc(struct Section *sect, int32_t segment,
+ int relative, int size64)
{
struct Reloc *r;
/*
* Return the fixup for standard COFF common variables.
*/
- if (r->symbase == REAL_SYMBOLS && !win32)
+ if (r->symbase == REAL_SYMBOLS && !(win32 | win64))
return raa_read(symval, segment);
else
return 0;
}
-static void coff_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void coff_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
struct Section *s;
- long realbytes = type & OUT_SIZMASK;
- unsigned char mydata[4], *p;
+ int32_t realbytes = type & OUT_SIZMASK;
+ uint8_t mydata[8], *p;
int i;
if (wrt != NO_SEG) {
}
if (!s->data && type != OUT_RESERVE) {
- error(ERR_WARNING, "attempt to initialise memory in"
+ error(ERR_WARNING, "attempt to initialize memory in"
" BSS section `%s': ignored", s->name);
if (type == OUT_REL2ADR)
realbytes = 2;
error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
coff_sect_write(s, data, realbytes);
} else if (type == OUT_ADDRESS) {
- if (realbytes != 4 && (segment != NO_SEG || wrt != NO_SEG))
- error(ERR_NONFATAL, "COFF format does not support non-32-bit"
- " relocations");
- else {
- long fix = 0;
- if (segment != NO_SEG || wrt != NO_SEG) {
+ if (!(win64)) {
+ if (realbytes != 4 && (segment != NO_SEG || wrt != NO_SEG))
+ 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"
+ " WRT types");
+ } else if (segment % 2) {
+ error(ERR_NONFATAL, "COFF format does not support"
+ " segment base references");
+ } else
+ fix = coff_add_reloc(s, segment, FALSE, FALSE);
+ }
+ p = mydata;
+ WRITELONG(p, *(int32_t *)data + fix);
+ coff_sect_write(s, mydata, realbytes);
+ }
+ } else {
+ int32_t fix = 0;
+ p = mydata;
+ if (realbytes == 8) {
+/* if (segment != NO_SEG || wrt != NO_SEG) {
if (wrt != NO_SEG) {
error(ERR_NONFATAL, "COFF format does not support"
" WRT types");
" segment base references");
} else
fix = coff_add_reloc(s, segment, FALSE);
+ } */
+ fix = coff_add_reloc(s, segment, FALSE, TRUE);
+ WRITEDLONG(p, *(int64_t *)data + fix);
+ coff_sect_write(s, mydata, realbytes);
+ } else {
+ fix = coff_add_reloc(s, segment, FALSE, FALSE);
+ WRITELONG(p, *(int32_t *)data + fix);
+ coff_sect_write(s, mydata, realbytes);
}
- p = mydata;
- WRITELONG(p, *(long *)data + fix);
- coff_sect_write(s, mydata, realbytes);
}
} else if (type == OUT_REL2ADR) {
error(ERR_NONFATAL, "COFF format does not support 16-bit"
" relocations");
} else if (type == OUT_REL4ADR) {
- if (segment == segto)
+ if (segment == segto && !(win64)) /* Acceptable for RIP-relative */
error(ERR_PANIC, "intra-segment OUT_REL4ADR");
else if (segment == NO_SEG && win32)
error(ERR_NONFATAL, "Win32 COFF does not correctly support"
" relative references to absolute addresses");
else {
- long fix = 0;
+ int32_t fix = 0;
if (segment != NO_SEG && segment % 2) {
error(ERR_NONFATAL, "COFF format does not support"
" segment base references");
} else
- fix = coff_add_reloc(s, segment, TRUE);
+ fix = coff_add_reloc(s, segment, TRUE, FALSE);
p = mydata;
- if (win32) {
- WRITELONG(p, *(long *)data + 4 - realbytes + fix);
+ if (win32 | win64) {
+ WRITELONG(p, *(int32_t *)data + 4 - realbytes + fix);
} else {
- WRITELONG(p, *(long *)data - (realbytes + s->len) + fix);
+ WRITELONG(p, *(int32_t *)data - (realbytes + s->len) + fix);
}
coff_sect_write(s, mydata, 4L);
}
+
}
}
static void coff_sect_write(struct Section *sect,
- const unsigned char *data, unsigned long len)
+ const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->len += len;
typedef struct tagString {
struct tagString *Next;
int len;
- char *String;
+ int8_t *String;
} STRING;
#define EXPORT_SECTION_NAME ".drectve"
static STRING *Exports = NULL;
static struct Section *directive_sec;
-void AddExport(char *name)
+void AddExport(int8_t *name)
{
STRING *rvp = Exports, *newS;
newS = (STRING *) nasm_malloc(sizeof(STRING));
newS->len = strlen(name);
newS->Next = NULL;
- newS->String = (char *)nasm_malloc(newS->len + 1);
+ newS->String = (int8_t *)nasm_malloc(newS->len + 1);
strcpy(newS->String, name);
if (rvp == NULL) {
int i;
void BuildExportTable(void)
{
STRING *rvp = Exports, *next;
- unsigned char buf[256];
+ uint8_t buf[256];
int len;
if (rvp == NULL)
return;
while (rvp) {
- len = sprintf((char *)buf, "-export:%s ", rvp->String);
+ len = sprintf((int8_t *)buf, "-export:%s ", rvp->String);
coff_sect_write(directive_sec, buf, len);
rvp = rvp->Next;
}
Exports = NULL;
}
-static int coff_directives(char *directive, char *value, int pass)
+static int coff_directives(int8_t *directive, int8_t *value, int pass)
{
if (!strcmp(directive, "export")) {
- char *q, *name;
+ int8_t *q, *name;
if (pass == 2)
return 1; /* ignore in pass two */
return 1;
}
if (*q) {
- error(ERR_NONFATAL, "unrecognised export qualifier `%s'", q);
+ error(ERR_NONFATAL, "unrecognized export qualifier `%s'", q);
return 1;
}
AddExport(name);
static void coff_write(void)
{
- long pos, sympos, vsize;
+ int32_t pos, sympos, vsize;
int i;
BuildExportTable(); /* fill in the .drectve section with -export's */
/*
* Output the COFF header.
*/
- fwriteshort(0x14C, coffp); /* MACHINE_i386 */
- fwriteshort(nsects, coffp); /* number of sections */
- fwritelong(time(NULL), coffp); /* time stamp */
- fwritelong(sympos, coffp);
- fwritelong(nsyms + initsym, coffp);
- fwriteshort(0, coffp); /* no optional header */
+ if (win64)
+ fwriteint16_t(0x8664, coffp); /* 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 */
/* Flags: 32-bit, no line numbers. Win32 doesn't even bother with them. */
- fwriteshort(win32 ? 0 : 0x104, coffp);
+ fwriteint16_t((win32 | win64) ? 0 : 0x104, coffp);
/*
* Output the section headers.
* Output the symbol and string tables.
*/
coff_write_symbols();
- fwritelong(strslen + 4, coffp); /* length includes length count */
+ fwriteint32_t(strslen + 4, coffp); /* length includes length count */
saa_fpwrite(strs, coffp);
}
-static void coff_section_header(char *name, long vsize,
- long datalen, long datapos,
- long relpos, int nrelocs, long flags)
+static void coff_section_header(int8_t *name, int32_t vsize,
+ int32_t datalen, int32_t datapos,
+ int32_t relpos, int nrelocs, int32_t flags)
{
- char padname[8];
+ int8_t padname[8];
memset(padname, 0, 8);
strncpy(padname, name, 8);
fwrite(padname, 8, 1, coffp);
- fwritelong(vsize, coffp);
- fwritelong(0L, coffp); /* RVA/offset - we ignore */
- fwritelong(datalen, coffp);
- fwritelong(datapos, coffp);
- fwritelong(relpos, coffp);
- fwritelong(0L, coffp); /* no line numbers - we don't do 'em */
- fwriteshort(nrelocs, coffp);
- fwriteshort(0, coffp); /* again, no line numbers */
- fwritelong(flags, coffp);
+ fwriteint32_t(vsize, coffp);
+ 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);
}
static void coff_write_relocs(struct Section *s)
struct Reloc *r;
for (r = s->head; r; r = r->next) {
- fwritelong(r->address, coffp);
- fwritelong(r->symbol + (r->symbase == REAL_SYMBOLS ? initsym :
+ fwriteint32_t(r->address, coffp);
+ fwriteint32_t(r->symbol + (r->symbase == REAL_SYMBOLS ? initsym :
r->symbase == ABS_SYMBOL ? initsym - 1 :
r->symbase == SECT_SYMBOLS ? 2 : 0),
coffp);
* Strange: Microsoft's COFF documentation says 0x03 for an
* absolute relocation, but both Visual C++ and DJGPP agree
* that in fact it's 0x06. I'll use 0x06 until someone
- * argues.
+ * argues. ***** UPDATE: PE/COFF Ver.8 docs confirm this -kkanios *****
*/
- fwriteshort(r->relative ? 0x14 : 0x06, coffp);
+ if (win64)
+ fwriteint16_t(r->relative ? 0x04 : r->size64 ? 0x01 : 0x02, coffp);
+ else
+ fwriteint16_t(r->relative ? 0x14 : 0x06, coffp);
}
}
-static void coff_symbol(char *name, long strpos, long value,
+static void coff_symbol(int8_t *name, int32_t strpos, int32_t value,
int section, int type, int aux)
{
- char padname[8];
+ int8_t padname[8];
if (name) {
memset(padname, 0, 8);
strncpy(padname, name, 8);
fwrite(padname, 8, 1, coffp);
} else {
- fwritelong(0L, coffp);
- fwritelong(strpos, coffp);
+ fwriteint32_t(0L, coffp);
+ fwriteint32_t(strpos, coffp);
}
- fwritelong(value, coffp);
- fwriteshort(section, coffp);
- fwriteshort(0, coffp);
+ fwriteint32_t(value, coffp);
+ fwriteint16_t(section, coffp);
+ fwriteint16_t(0, coffp);
fputc(type, coffp);
fputc(aux, coffp);
}
static void coff_write_symbols(void)
{
- char filename[18];
- unsigned long i;
+ int8_t filename[18];
+ uint32_t i;
/*
* The `.file' record, and the file name auxiliary record.
for (i = 0; i < nsects; i++) {
coff_symbol(sects[i]->name, 0L, 0L, i + 1, 3, 1);
- fwritelong(sects[i]->len, coffp);
- fwriteshort(sects[i]->nrelocs, coffp);
+ fwriteint32_t(sects[i]->len, coffp);
+ fwriteint16_t(sects[i]->nrelocs, coffp);
fwrite(filename, 12, 1, coffp);
}
}
}
-static long coff_segbase(long segment)
+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(int8_t *inname, int8_t *outname, efunc error)
{
strcpy(coff_infile, inname);
standard_extension(inname, outname, ".o", error);
}
-static void coff_win32_filename(char *inname, char *outname, efunc error)
+static void coff_win32_filename(int8_t *inname, int8_t *outname, efunc error)
{
strcpy(coff_infile, inname);
standard_extension(inname, outname, ".obj", error);
}
-static const char *coff_stdmac[] = {
+static const int8_t *coff_stdmac[] = {
"%define __SECT__ [section .text]",
"%macro __NASM_CDecl__ 1",
"%endmacro",
NULL
};
-static int coff_set_info(enum geninfo type, char **val)
+static int coff_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
};
#endif
+
+#ifdef OF_WIN64
+
+struct ofmt of_win64 = {
+ "Microsoft Win64 (x86-64) object files",
+ "win64",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
+ coff_stdmac,
+ coff_win64_init,
+ coff_set_info,
+ coff_out,
+ coff_deflabel,
+ coff_section_names,
+ coff_segbase,
+ coff_directives,
+ coff_win32_filename,
+ coff_cleanup
+};
+
+#endif
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
struct Section {
struct Section *next;
- long number;
- char *name;
+ int32_t number;
+ int8_t *name;
} *dbgsect;
FILE *dbgf;
fclose(dbgf);
}
-static long dbg_section_names(char *name, int pass, int *bits)
+static int32_t dbg_section_names(int8_t *name, int pass, int *bits)
{
int seg;
seg = seg_alloc());
else {
int n = strcspn(name, " \t");
- char *sname = nasm_strndup(name, n);
+ int8_t *sname = nasm_strndup(name, n);
struct Section *s;
seg = NO_SEG;
return seg;
}
-static void dbg_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void dbg_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
fprintf(dbgf, "deflabel %s := %08lx:%08lx %s (%d)%s%s\n",
name, segment, offset,
is_global, special ? ": " : "", special);
}
-static void dbg_out(long segto, void *data, unsigned long type,
- long segment, long wrt)
+static void dbg_out(int32_t segto, void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- long realbytes = type & OUT_SIZMASK;
- long ldata;
+ int32_t realbytes = type & OUT_SIZMASK;
+ int32_t ldata;
int id;
type &= OUT_TYPMASK;
case OUT_RAWDATA:
fprintf(dbgf, "raw data = ");
while (realbytes--) {
- id = *(unsigned char *)data;
- data = (char *)data + 1;
+ id = *(uint8_t *)data;
+ data = (int8_t *)data + 1;
fprintf(dbgf, "%02x ", id);
}
fprintf(dbgf, "\n");
case OUT_ADDRESS:
ldata = 0; /* placate gcc */
if (realbytes == 1)
- ldata = *((char *)data);
+ ldata = *((int8_t *)data);
else if (realbytes == 2)
- ldata = *((short *)data);
+ ldata = *((int16_t *)data);
else if (realbytes == 4)
- ldata = *((long *)data);
+ ldata = *((int32_t *)data);
fprintf(dbgf, "addr %08lx (seg %08lx, wrt %08lx)\n", ldata,
segment, wrt);
break;
case OUT_REL2ADR:
- fprintf(dbgf, "rel2adr %04x (seg %08lx)\n", (int)*(short *)data,
+ fprintf(dbgf, "rel2adr %04x (seg %08lx)\n", (int)*(int16_t *)data,
segment);
break;
case OUT_REL4ADR:
- fprintf(dbgf, "rel4adr %08lx (seg %08lx)\n", *(long *)data,
+ fprintf(dbgf, "rel4adr %08lx (seg %08lx)\n", *(int32_t *)data,
segment);
break;
default:
}
}
-static long dbg_segbase(long segment)
+static int32_t dbg_segbase(int32_t segment)
{
return segment;
}
-static int dbg_directive(char *directive, char *value, int pass)
+static int dbg_directive(int8_t *directive, int8_t *value, int pass)
{
fprintf(dbgf, "directive [%s] value [%s] (pass %d)\n",
directive, value, pass);
return 1;
}
-static void dbg_filename(char *inname, char *outname, efunc error)
+static void dbg_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, ".dbg", error);
}
-static int dbg_set_info(enum geninfo type, char **val)
+static int dbg_set_info(enum geninfo type, int8_t **val)
{
(void)type;
(void)val;
return 0;
}
-char *types[] = {
+int8_t *types[] = {
"unknown", "label", "byte", "word", "dword", "float", "qword", "tbyte"
};
void dbgdbg_init(struct ofmt *of, void *id, FILE * fp, efunc error)
{
}
-static void dbgdbg_linnum(const char *lnfname, long lineno, long segto)
+static void dbgdbg_linnum(const int8_t *lnfname, int32_t lineno, int32_t segto)
{
fprintf(dbgf, "dbglinenum %s(%ld) := %08lx\n", lnfname, lineno, segto);
}
-static void dbgdbg_deflabel(char *name, long segment,
- long offset, int is_global, char *special)
+static void dbgdbg_deflabel(int8_t *name, int32_t segment,
+ int32_t offset, int is_global, int8_t *special)
{
fprintf(dbgf, "dbglabel %s := %08lx:%08lx %s (%d)%s%s\n",
name,
is_global == 2 ? "common" : is_global ? "global" : "local",
is_global, special ? ": " : "", special);
}
-static void dbgdbg_define(const char *type, const char *params)
+static void dbgdbg_define(const int8_t *type, const int8_t *params)
{
fprintf(dbgf, "dbgdirective [%s] value [%s]\n", type, params);
}
(void)output_type;
(void)param;
}
-static void dbgdbg_typevalue(long type)
+static void dbgdbg_typevalue(int32_t type)
{
fprintf(dbgf, "new type: %s(%lX)\n",
types[TYM_TYPE(type) >> 3], TYM_ELEMENTS(type));
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
struct Reloc {
struct Reloc *next;
- long address; /* relative to _start_ of section */
- long symbol; /* ELF symbol info thingy */
+ int32_t address; /* relative to _start_ of section */
+ int32_t symbol; /* ELF symbol info thingy */
int type; /* type of relocation */
};
struct Symbol {
- long strpos; /* string table position of name */
- long section; /* section ID of the symbol */
+ int32_t strpos; /* string table position of name */
+ int32_t section; /* section ID of the symbol */
int type; /* symbol type */
- long value; /* address, or COMMON variable align */
- long size; /* size of symbol */
- long globnum; /* symbol table offset if global */
+ int32_t value; /* address, or COMMON variable align */
+ int32_t size; /* size of symbol */
+ int32_t globnum; /* symbol table offset if global */
struct Symbol *next; /* list of globals in each section */
struct Symbol *nextfwd; /* list of unresolved-size symbols */
- char *name; /* used temporarily if in above list */
+ int8_t *name; /* used temporarily if in above list */
};
#define SHT_PROGBITS 1
struct Section {
struct SAA *data;
- unsigned long len, size, nrelocs;
- long index;
+ uint32_t len, size, nrelocs;
+ int32_t index;
int type; /* SHT_PROGBITS or SHT_NOBITS */
int align; /* alignment: power of two */
- unsigned long flags; /* section flags */
- char *name;
+ uint32_t flags; /* section flags */
+ int8_t *name;
struct SAA *rel;
- long rellen;
+ int32_t rellen;
struct Reloc *head, **tail;
struct Symbol *gsyms; /* global symbols in section */
};
static int nsects, sectlen;
#define SHSTR_DELTA 256
-static char *shstrtab;
+static int8_t *shstrtab;
static int shstrtablen, shstrtabsize;
static struct SAA *syms;
-static unsigned long nlocals, nglobs;
+static uint32_t nlocals, nglobs;
-static long def_seg;
+static int32_t def_seg;
static struct RAA *bsym;
static struct SAA *strs;
-static unsigned long strslen;
+static uint32_t strslen;
static FILE *elffp;
static efunc error;
static struct Symbol *fwds;
-static char elf_module[FILENAME_MAX];
+static int8_t elf_module[FILENAME_MAX];
extern struct ofmt of_elf;
#define SEG_ALIGN 16 /* alignment of sections in file */
#define SEG_ALIGN_1 (SEG_ALIGN-1)
-static const char align_str[SEG_ALIGN] = ""; /* ANSI will pad this with 0s */
+static const int8_t align_str[SEG_ALIGN] = ""; /* ANSI will pad this with 0s */
#define ELF_MAX_SECTIONS 16 /* really 10, but let's play safe */
static struct ELF_SECTDATA {
void *data;
- long len;
+ int32_t len;
int is_saa;
} *elf_sects;
static int elf_nsect;
-static long elf_foffs;
+static int32_t elf_foffs;
static void elf_write(void);
-static void elf_sect_write(struct Section *, const unsigned char *,
- unsigned long);
-static void elf_section_header(int, int, int, void *, int, long, int, int,
+static void elf_sect_write(struct Section *, const uint8_t *,
+ uint32_t);
+static void elf_section_header(int, int, int, void *, int, int32_t, int, int,
int, int);
static void elf_write_sections(void);
-static struct SAA *elf_build_symtab(long *, long *);
-static struct SAA *elf_build_reltab(long *, struct Reloc *);
-static void add_sectname(char *, char *);
+static struct SAA *elf_build_symtab(int32_t *, int32_t *);
+static struct SAA *elf_build_reltab(int32_t *, struct Reloc *);
+static void add_sectname(int8_t *, int8_t *);
/* this stuff is needed for the stabs debugging format */
#define N_SO 0x64 /* ID for main source file */
#define TY_STABSSYMLIN 0x40 /* ouch */
struct stabentry {
- unsigned long n_strx;
- unsigned char n_type;
- unsigned char n_other;
- unsigned short n_desc;
- unsigned long n_value;
+ uint32_t n_strx;
+ uint8_t n_type;
+ uint8_t n_other;
+ uint16_t n_desc;
+ uint32_t n_value;
};
struct erel {
struct symlininfo {
int offset;
int section; /* section index */
- char *name; /* shallow-copied pointer of section name */
+ int8_t *name; /* shallow-copied pointer of section name */
};
struct linelist {
struct symlininfo info;
int line;
- char *filename;
+ int8_t *filename;
struct linelist *next;
struct linelist *last;
};
static int stabs_immcall = 0;
static int currentline = 0;
static int numlinestabs = 0;
-static char *stabs_filename = 0;
+static int8_t *stabs_filename = 0;
static int symtabsection;
-static unsigned char *stabbuf = 0, *stabstrbuf = 0, *stabrelbuf = 0;
+static uint8_t *stabbuf = 0, *stabstrbuf = 0, *stabrelbuf = 0;
static int stablen, stabstrlen, stabrellen;
static struct dfmt df_stabs;
void stabs_init(struct ofmt *, void *, FILE *, efunc);
-void stabs_linenum(const char *filename, long linenumber, long);
-void stabs_deflabel(char *, long, long, int, char *);
-void stabs_directive(const char *, const char *);
-void stabs_typevalue(long);
+void stabs_linenum(const int8_t *filename, int32_t linenumber, int32_t);
+void stabs_deflabel(int8_t *, int32_t, int32_t, int, int8_t *);
+void stabs_directive(const int8_t *, const int8_t *);
+void stabs_typevalue(int32_t);
void stabs_output(int, void *);
void stabs_generate();
void stabs_cleanup();
* symbols, which can be used with WRT to provide PIC relocation
* types.
*/
-static long elf_gotpc_sect, elf_gotoff_sect;
-static long elf_got_sect, elf_plt_sect;
-static long elf_sym_sect;
+static int32_t elf_gotpc_sect, elf_gotoff_sect;
+static int32_t elf_got_sect, elf_plt_sect;
+static int32_t elf_sym_sect;
static void elf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
(void)ldef; /* placate optimisers */
sects = NULL;
nsects = sectlen = 0;
- syms = saa_init((long)sizeof(struct Symbol));
+ syms = saa_init((int32_t)sizeof(struct Symbol));
nlocals = nglobs = 0;
bsym = raa_init();
strs = saa_init(1L);
saa_wbytes(strs, "\0", 1L);
- saa_wbytes(strs, elf_module, (long)(strlen(elf_module) + 1));
+ saa_wbytes(strs, elf_module, (int32_t)(strlen(elf_module) + 1));
strslen = 2 + strlen(elf_module);
shstrtab = NULL;
shstrtablen = shstrtabsize = 0;;
}
}
-static void add_sectname(char *firsthalf, char *secondhalf)
+static void add_sectname(int8_t *firsthalf, int8_t *secondhalf)
{
int len = strlen(firsthalf) + strlen(secondhalf);
while (shstrtablen + len + 1 > shstrtabsize)
shstrtablen += len + 1;
}
-static int elf_make_section(char *name, int type, int flags, int align)
+static int elf_make_section(int8_t *name, int type, int flags, int align)
{
struct Section *s;
return nsects - 1;
}
-static long elf_section_names(char *name, int pass, int *bits)
+static int32_t elf_section_names(int8_t *name, int pass, int *bits)
{
- char *p;
+ int8_t *p;
int flags_and, flags_or, type, align, i;
/*
while (*p && isspace(*p))
p++;
while (*p) {
- char *q = p;
+ int8_t *q = p;
while (*p && !isspace(*p))
p++;
if (*p)
return sects[i]->index;
}
-static void elf_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void elf_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
int pos = strslen;
struct Symbol *sym;
if (!strcmp((*s)->name, name)) {
struct tokenval tokval;
expr *e;
- char *p = special;
+ int8_t *p = special;
while (*p && !isspace(*p))
p++;
return; /* it wasn't an important one */
}
- saa_wbytes(strs, name, (long)(1 + strlen(name)));
+ saa_wbytes(strs, name, (int32_t)(1 + strlen(name)));
strslen += 1 + strlen(name);
sym = saa_wstruct(syms);
struct tokenval tokval;
expr *e;
int fwd = FALSE;
- char *saveme = stdscan_bufptr; /* bugfix? fbk 8/10/00 */
+ int8_t *saveme = stdscan_bufptr; /* bugfix? fbk 8/10/00 */
while (special[n] && isspace(special[n]))
n++;
error(ERR_NONFATAL, "no special symbol features supported here");
}
-static void elf_add_reloc(struct Section *sect, long segment, int type)
+static void elf_add_reloc(struct Section *sect, int32_t segment, int type)
{
struct Reloc *r;
* Inefficiency: we search, currently, using a linked list which
* isn't even necessarily sorted.
*/
-static long elf_add_gsym_reloc(struct Section *sect,
- long segment, long offset,
+static int32_t elf_add_gsym_reloc(struct Section *sect,
+ int32_t segment, int32_t offset,
int type, int exact)
{
struct Reloc *r;
return offset - sym->value;
}
-static void elf_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void elf_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
struct Section *s;
- long realbytes = type & OUT_SIZMASK;
- long addr;
- unsigned char mydata[4], *p;
+ int32_t realbytes = type & OUT_SIZMASK;
+ int32_t addr;
+ uint8_t mydata[4], *p;
int i;
static struct symlininfo sinfo;
/* end of debugging stuff */
if (s->type == SHT_NOBITS && type != OUT_RESERVE) {
- error(ERR_WARNING, "attempt to initialise memory in"
+ error(ERR_WARNING, "attempt to initialize memory in"
" BSS section `%s': ignored", s->name);
if (type == OUT_REL2ADR)
realbytes = 2;
if (type == OUT_RESERVE) {
if (s->type == SHT_PROGBITS) {
- error(ERR_WARNING, "uninitialised space declared in"
+ error(ERR_WARNING, "uninitialized space declared in"
" non-BSS section `%s': zeroing", s->name);
elf_sect_write(s, NULL, realbytes);
} else
elf_sect_write(s, data, realbytes);
} else if (type == OUT_ADDRESS) {
int gnu16 = 0;
- addr = *(long *)data;
+ addr = *(int32_t *)data;
if (segment != NO_SEG) {
if (segment % 2) {
error(ERR_NONFATAL, "ELF format does not support"
}
}
p = mydata;
- WRITESHORT(p, *(long *)data - realbytes);
+ WRITESHORT(p, *(int32_t *)data - realbytes);
elf_sect_write(s, mydata, 2L);
} else if (type == OUT_REL4ADR) {
if (segment == segto)
}
}
p = mydata;
- WRITELONG(p, *(long *)data - realbytes);
+ WRITELONG(p, *(int32_t *)data - realbytes);
elf_sect_write(s, mydata, 4L);
}
}
{
int nsections, align;
int scount;
- char *p;
+ int8_t *p;
int commlen;
- char comment[64];
+ int8_t comment[64];
int i;
struct SAA *symtab;
- long symtablen, symtablocal;
+ int32_t symtablen, symtablocal;
/*
* Work out how many sections we will have. We have SHN_UNDEF,
* Output the ELF header.
*/
fwrite("\177ELF\1\1\1\0\0\0\0\0\0\0\0\0", 16, 1, elffp);
- fwriteshort(1, elffp); /* ET_REL relocatable file */
- fwriteshort(3, elffp); /* EM_386 processor ID */
- fwritelong(1L, elffp); /* EV_CURRENT file format version */
- fwritelong(0L, elffp); /* no entry point */
- fwritelong(0L, elffp); /* no program header table */
- fwritelong(0x40L, elffp); /* section headers straight after
+ 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
* ELF header plus alignment */
- fwritelong(0L, elffp); /* 386 defines no special flags */
- fwriteshort(0x34, elffp); /* size of ELF header */
- fwriteshort(0, elffp); /* no program header table, again */
- fwriteshort(0, elffp); /* still no program header table */
- fwriteshort(0x28, elffp); /* size of section header */
- fwriteshort(nsections, elffp); /* number of sections */
- fwriteshort(nsects + 2, elffp); /* string table section index for
+ 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(nsects + 2, elffp); /* string table section index for
* section header table */
- fwritelong(0L, elffp); /* align to 0x40 bytes */
- fwritelong(0L, elffp);
- fwritelong(0L, elffp);
+ fwriteint32_t(0L, elffp); /* align to 0x40 bytes */
+ fwriteint32_t(0L, elffp);
+ fwriteint32_t(0L, elffp);
/*
* Build the symbol table and relocation tables.
p += strlen(p) + 1;
scount++; /* dito */
}
- elf_section_header(p - shstrtab, 1, 0, comment, FALSE, (long)commlen, 0, 0, 1, 0); /* .comment */
+ elf_section_header(p - shstrtab, 1, 0, comment, FALSE, (int32_t)commlen, 0, 0, 1, 0); /* .comment */
scount++; /* dito */
p += strlen(p) + 1;
- elf_section_header(p - shstrtab, 3, 0, shstrtab, FALSE, (long)shstrtablen, 0, 0, 1, 0); /* .shstrtab */
+ elf_section_header(p - shstrtab, 3, 0, shstrtab, FALSE, (int32_t)shstrtablen, 0, 0, 1, 0); /* .shstrtab */
scount++; /* dito */
p += strlen(p) + 1;
elf_section_header(p - shstrtab, 2, 0, symtab, TRUE, symtablen, nsects + 4, symtablocal, 4, 16); /* .symtab */
saa_free(symtab);
}
-static struct SAA *elf_build_symtab(long *len, long *local)
+static struct SAA *elf_build_symtab(int32_t *len, int32_t *local)
{
struct SAA *s = saa_init(1L);
struct Symbol *sym;
- unsigned char entry[16], *p;
+ uint8_t entry[16], *p;
int i;
*len = *local = 0;
return s;
}
-static struct SAA *elf_build_reltab(long *len, struct Reloc *r)
+static struct SAA *elf_build_reltab(int32_t *len, struct Reloc *r)
{
struct SAA *s;
- unsigned char *p, entry[8];
+ uint8_t *p, entry[8];
if (!r)
return NULL;
*len = 0;
while (r) {
- long sym = r->symbol;
+ int32_t sym = r->symbol;
if (sym >= GLOBAL_TEMP_BASE)
sym += -GLOBAL_TEMP_BASE + (nsects + 3) + nlocals;
}
static void elf_section_header(int name, int type, int flags,
- void *data, int is_saa, long datalen,
+ void *data, int is_saa, int32_t datalen,
int link, int info, int align, int eltsize)
{
elf_sects[elf_nsect].data = data;
elf_sects[elf_nsect].is_saa = is_saa;
elf_nsect++;
- fwritelong((long)name, elffp);
- fwritelong((long)type, elffp);
- fwritelong((long)flags, elffp);
- fwritelong(0L, elffp); /* no address, ever, in object files */
- fwritelong(type == 0 ? 0L : elf_foffs, elffp);
- fwritelong(datalen, elffp);
+ 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);
if (data)
elf_foffs += (datalen + SEG_ALIGN_1) & ~SEG_ALIGN_1;
- fwritelong((long)link, elffp);
- fwritelong((long)info, elffp);
- fwritelong((long)align, elffp);
- fwritelong((long)eltsize, elffp);
+ fwriteint32_t((int32_t)link, elffp);
+ fwriteint32_t((int32_t)info, elffp);
+ fwriteint32_t((int32_t)align, elffp);
+ fwriteint32_t((int32_t)eltsize, elffp);
}
static void elf_write_sections(void)
int i;
for (i = 0; i < elf_nsect; i++)
if (elf_sects[i].data) {
- long len = elf_sects[i].len;
- long reallen = (len + SEG_ALIGN_1) & ~SEG_ALIGN_1;
- long align = reallen - len;
+ int32_t len = elf_sects[i].len;
+ 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);
else
}
static void elf_sect_write(struct Section *sect,
- const unsigned char *data, unsigned long len)
+ const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->len += len;
}
-static long elf_segbase(long segment)
+static int32_t elf_segbase(int32_t segment)
{
return segment;
}
-static int elf_directive(char *directive, char *value, int pass)
+static int elf_directive(int8_t *directive, int8_t *value, int pass)
{
return 0;
}
-static void elf_filename(char *inname, char *outname, efunc error)
+static void elf_filename(int8_t *inname, int8_t *outname, efunc error)
{
strcpy(elf_module, inname);
standard_extension(inname, outname, ".o", error);
}
-static const char *elf_stdmac[] = {
+static const int8_t *elf_stdmac[] = {
"%define __SECT__ [section .text]",
"%macro __NASM_CDecl__ 1",
"%define $_%1 $%1",
"%endmacro",
NULL
};
-static int elf_set_info(enum geninfo type, char **val)
+static int elf_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
{
}
-void stabs_linenum(const char *filename, long linenumber, long segto)
+void stabs_linenum(const int8_t *filename, int32_t linenumber, int32_t segto)
{
if (!stabs_filename) {
- stabs_filename = (char *)nasm_malloc(strlen(filename) + 1);
+ stabs_filename = (int8_t *)nasm_malloc(strlen(filename) + 1);
strcpy(stabs_filename, filename);
} else {
if (strcmp(stabs_filename, filename)) {
/* why not nasm_free(stabs_filename); we're done with the old one */
- stabs_filename = (char *)nasm_malloc(strlen(filename) + 1);
+ stabs_filename = (int8_t *)nasm_malloc(strlen(filename) + 1);
strcpy(stabs_filename, filename);
}
}
currentline = linenumber;
}
-void stabs_deflabel(char *name, long segment, long offset, int is_global,
- char *special)
+void stabs_deflabel(int8_t *name, int32_t segment, int32_t offset, int is_global,
+ int8_t *special)
{
}
-void stabs_directive(const char *directive, const char *params)
+void stabs_directive(const int8_t *directive, const int8_t *params)
{
}
-void stabs_typevalue(long type)
+void stabs_typevalue(int32_t type)
{
}
void stabs_generate(void)
{
int i, numfiles, strsize, numstabs = 0, currfile, mainfileindex;
- unsigned char *sbuf, *ssbuf, *rbuf, *sptr, *rptr;
- char **allfiles;
+ uint8_t *sbuf, *ssbuf, *rbuf, *sptr, *rptr;
+ int8_t **allfiles;
int *fileidx;
struct linelist *ptr;
ptr = stabslines;
- allfiles = (char **)nasm_malloc(numlinestabs * sizeof(char *));
+ allfiles = (int8_t **)nasm_malloc(numlinestabs * sizeof(int8_t *));
for (i = 0; i < numlinestabs; i++)
allfiles[i] = 0;
numfiles = 0;
the sourcefiles changes each line, which would mean 1 SOL, 1 SYMLIN per line
*/
sbuf =
- (unsigned char *)nasm_malloc((numlinestabs * 2 + 3) *
+ (uint8_t *)nasm_malloc((numlinestabs * 2 + 3) *
sizeof(struct stabentry));
- ssbuf = (unsigned char *)nasm_malloc(strsize);
+ ssbuf = (uint8_t *)nasm_malloc(strsize);
- rbuf = (unsigned char *)nasm_malloc(numlinestabs * 8 * (2 + 3));
+ rbuf = (uint8_t *)nasm_malloc(numlinestabs * 8 * (2 + 3));
rptr = rbuf;
for (i = 0; i < numfiles; i++) {
- strcpy((char *)ssbuf + fileidx[i], allfiles[i]);
+ strcpy((int8_t *)ssbuf + fileidx[i], allfiles[i]);
}
ssbuf[0] = 0;
#include <time.h>
#include <stdarg.h> /* Note: we need the ANSI version of stdarg.h */
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
#define ARRAY_BOT 0x1
-static char ieee_infile[FILENAME_MAX];
+static int8_t ieee_infile[FILENAME_MAX];
static int ieee_uppercase;
static efunc error;
struct LineNumber {
struct LineNumber *next;
struct ieeeSection *segment;
- long offset;
- long lineno;
+ int32_t offset;
+ int32_t lineno;
};
static struct FileName {
struct FileName *next;
- char *name;
- long index;
+ int8_t *name;
+ int32_t index;
} *fnhead, **fntail;
static struct Array {
static struct ieeePublic {
struct ieeePublic *next;
- char *name;
- long offset;
- long segment; /* only if it's far-absolute */
- long index;
+ int8_t *name;
+ int32_t offset;
+ int32_t segment; /* only if it's far-absolute */
+ int32_t index;
int type; /* for debug purposes */
} *fpubhead, **fpubtail, *last_defined;
static struct ieeeExternal {
struct ieeeExternal *next;
- char *name;
- long commonsize;
+ int8_t *name;
+ int32_t commonsize;
} *exthead, **exttail;
static int externals;
struct ieeeObjData *data, *datacurr;
struct ieeeSection *next;
struct ieeeFixupp *fptr, *flptr;
- long index; /* the NASM segment id */
- long ieee_index; /* the OBJ-file segment index */
- long currentpos;
- long align; /* can be SEG_ABS + absolute addr */
- long startpos;
+ int32_t index; /* the NASM segment id */
+ int32_t ieee_index; /* the OBJ-file segment index */
+ int32_t currentpos;
+ int32_t align; /* can be SEG_ABS + absolute addr */
+ int32_t startpos;
enum {
CMB_PRIVATE = 0,
CMB_PUBLIC = 2,
CMB_COMMON = 6
} combine;
- long use32; /* is this segment 32-bit? */
+ int32_t use32; /* is this segment 32-bit? */
struct ieeePublic *pubhead, **pubtail, *lochead, **loctail;
- char *name;
+ int8_t *name;
} *seghead, **segtail, *ieee_seg_needs_update;
struct ieeeObjData {
struct ieeeObjData *next;
- unsigned char data[HUNKSIZE];
+ uint8_t data[HUNKSIZE];
};
struct ieeeFixupp {
FT_EXTWRT = 6,
FT_EXTSEG = 7
} ftype;
- short size;
- long id1;
- long id2;
- long offset;
- long addend;
+ int16_t size;
+ int32_t id1;
+ int32_t id2;
+ int32_t offset;
+ int32_t addend;
};
-static long ieee_entry_seg, ieee_entry_ofs;
+static int32_t ieee_entry_seg, ieee_entry_ofs;
static int checksum;
extern struct ofmt of_ieee;
static void ieee_data_new(struct ieeeSection *);
-static void ieee_write_fixup(long, long, struct ieeeSection *,
- int, unsigned long, long);
+static void ieee_write_fixup(int32_t, int32_t, struct ieeeSection *,
+ int, uint32_t, int32_t);
static void ieee_install_fixup(struct ieeeSection *, struct ieeeFixupp *);
-static long ieee_segment(char *, int, int *);
+static int32_t ieee_segment(int8_t *, int, int *);
static void ieee_write_file(int debuginfo);
static void ieee_write_byte(struct ieeeSection *, int);
static void ieee_write_word(struct ieeeSection *, int);
-static void ieee_write_dword(struct ieeeSection *, long);
-static void ieee_putascii(char *, ...);
+static void ieee_write_dword(struct ieeeSection *, int32_t);
+static void ieee_putascii(int8_t *, ...);
static void ieee_putcs(int);
-static long ieee_putld(long, long, unsigned char *);
-static long ieee_putlr(struct ieeeFixupp *);
-static void ieee_unqualified_name(char *, char *);
+static int32_t ieee_putld(int32_t, int32_t, uint8_t *);
+static int32_t ieee_putlr(struct ieeeFixupp *);
+static void ieee_unqualified_name(int8_t *, int8_t *);
/*
* pup init
checksum = 0;
of_ieee.current_dfmt->init(&of_ieee, NULL, fp, errfunc);
}
-static int ieee_set_info(enum geninfo type, char **val)
+static int ieee_set_info(enum geninfo type, int8_t **val)
{
(void)type;
(void)val;
/*
* callback for labels
*/
-static void ieee_deflabel(char *name, long segment,
- long offset, int is_global, char *special)
+static void ieee_deflabel(int8_t *name, int32_t segment,
+ int32_t offset, int is_global, int8_t *special)
{
/*
* We have three cases:
/*
* Put data out
*/
-static void ieee_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void ieee_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- unsigned long size, realtype;
- const unsigned char *ucdata;
- long ldata;
+ uint32_t size, realtype;
+ const uint8_t *ucdata;
+ int32_t ldata;
struct ieeeSection *seg;
/*
if (segment == NO_SEG && realtype != OUT_ADDRESS)
error(ERR_NONFATAL, "relative call to absolute address not"
" supported by IEEE format");
- ldata = *(long *)data;
+ ldata = *(int32_t *)data;
if (realtype == OUT_REL2ADR)
ldata += (size - 2);
if (realtype == OUT_REL4ADR)
* but I might as well see what it is like on a harmless program.
* If anyone wants to optimize this is a good canditate!
*/
-static void ieee_write_fixup(long segment, long wrt,
+static void ieee_write_fixup(int32_t segment, int32_t wrt,
struct ieeeSection *segto, int size,
- unsigned long realtype, long offset)
+ uint32_t realtype, int32_t offset)
{
struct ieeeSection *target;
struct ieeeFixupp s;
* Now we assume the segment field is being used
* to hold an extern index
*/
- long i = segment / 2;
+ int32_t i = segment / 2;
struct ExtBack *eb = ebhead;
while (i > EXT_BLKSIZ) {
if (eb)
* Now we assume the segment field is being used
* to hold an extern index
*/
- long i = segment / 2;
+ int32_t i = segment / 2;
struct ExtBack *eb = ebhead;
while (i > EXT_BLKSIZ) {
if (eb)
* Now we assume the segment field is being used
* to hold an extern index
*/
- long i = segment / 2;
+ int32_t i = segment / 2;
struct ExtBack *eb = ebhead;
while (i > EXT_BLKSIZ) {
if (eb)
/*
* segment registry
*/
-static long ieee_segment(char *name, int pass, int *bits)
+static int32_t ieee_segment(int8_t *name, int pass, int *bits)
{
/*
* We call the label manager here to define a name for the new
} else {
struct ieeeSection *seg;
int ieee_idx, attrs, rn_error;
- char *p;
+ int8_t *p;
/*
* Look for segment attributes.
/*
* directives supported
*/
-static int ieee_directive(char *directive, char *value, int pass)
+static int ieee_directive(int8_t *directive, int8_t *value, int pass)
{
(void)value;
/*
* Return segment data
*/
-static long ieee_segbase(long segment)
+static int32_t ieee_segbase(int32_t segment)
{
struct ieeeSection *seg;
/*
* filename
*/
-static void ieee_filename(char *inname, char *outname, efunc error)
+static void ieee_filename(int8_t *inname, int8_t *outname, efunc error)
{
strcpy(ieee_infile, inname);
standard_extension(inname, outname, ".o", error);
struct ieeeObjData *data;
struct ieeeFixupp *fix;
struct Array *arr;
- static char boast[] = "The Netwide Assembler " NASM_VER;
+ static int8_t boast[] = "The Netwide Assembler " NASM_VER;
int i;
/*
if (!debuginfo && !strcmp(seg->name, "??LINE"))
seg = seg->next;
while (seg) {
- char buf[256];
- char attrib;
+ int8_t buf[256];
+ int8_t attrib;
switch (seg->combine) {
case CMB_PUBLIC:
default:
i = 1;
for (seg = seghead; seg; seg = seg->next) {
for (pub = seg->pubhead; pub; pub = pub->next) {
- char buf[256];
+ int8_t buf[256];
ieee_unqualified_name(buf, pub->name);
ieee_putascii("NI%X,%02X%s.\r\n", i, strlen(buf), buf);
if (pub->segment == -1)
pub = fpubhead;
i = 1;
while (pub) {
- char buf[256];
+ int8_t buf[256];
ieee_unqualified_name(buf, pub->name);
ieee_putascii("NI%X,%02X%s.\r\n", i, strlen(buf), buf);
if (pub->segment == -1)
ext = exthead;
i = 1;
while (ext) {
- char buf[256];
+ int8_t buf[256];
ieee_unqualified_name(buf, ext->name);
ieee_putascii("NX%X,%02X%s.\r\n", i++, strlen(buf), buf);
ext = ext->next;
i = 1;
for (seg = seghead; seg && debuginfo; seg = seg->next) {
for (loc = seg->lochead; loc; loc = loc->next) {
- char buf[256];
+ int8_t buf[256];
ieee_unqualified_name(buf, loc->name);
ieee_putascii("NN%X,%02X%s.\r\n", i, strlen(buf), buf);
if (loc->segment == -1)
seg = seg->next;
while (seg) {
if (seg->currentpos) {
- long size, org = 0;
+ int32_t size, org = 0;
data = seg->data;
ieee_putascii("SB%X.\r\n", seg->ieee_index);
fix = seg->fptr;
ieee_write_byte(seg, (data >> 8) & 0xFF);
}
-static void ieee_write_dword(struct ieeeSection *seg, long data)
+static void ieee_write_dword(struct ieeeSection *seg, int32_t data)
{
ieee_write_byte(seg, data & 0xFF);
ieee_write_byte(seg, (data >> 8) & 0xFF);
ieee_write_byte(seg, (data >> 16) & 0xFF);
ieee_write_byte(seg, (data >> 24) & 0xFF);
}
-static void ieee_putascii(char *format, ...)
+static void ieee_putascii(int8_t *format, ...)
{
- char buffer[256];
+ int8_t buffer[256];
int i, l;
va_list ap;
checksum = 0;
}
-static long ieee_putld(long start, long end, unsigned char *buf)
+static int32_t ieee_putld(int32_t start, int32_t end, uint8_t *buf)
{
- long val;
+ int32_t val;
if (start == end)
return (start);
val = start % HUNKSIZE;
ieee_putascii(".\r\n");
return (start);
}
-static long ieee_putlr(struct ieeeFixupp *p)
+static int32_t ieee_putlr(struct ieeeFixupp *p)
{
/*
* To deal with the vagaries of segmentation the LADsoft linker
* becomes an issue if real mode code is used. A pure 32-bit linker could
* get away without defining the virtual mode...
*/
- char buf[40];
- long size = p->size;
+ int8_t buf[40];
+ int32_t size = p->size;
switch (p->ftype) {
case FT_SEG:
if (p->id1 < 0)
/* Dump all segment data (text and fixups )*/
-static void ieee_unqualified_name(char *dest, char *source)
+static void ieee_unqualified_name(int8_t *dest, int8_t *source)
{
if (ieee_uppercase) {
while (*source)
* so, we have to make sure the ??LINE segment is avaialbe
* as the first segment when this debug format is selected
*/
-static void dbgls_linnum(const char *lnfname, long lineno, long segto)
+static void dbgls_linnum(const int8_t *lnfname, int32_t lineno, int32_t segto)
{
struct FileName *fn;
struct ieeeSection *seg;
seg->currentpos);
}
-static void dbgls_deflabel(char *name, long segment,
- long offset, int is_global, char *special)
+static void dbgls_deflabel(int8_t *name, int32_t segment,
+ int32_t offset, int is_global, int8_t *special)
{
struct ieeeSection *seg;
int used_special; /* have we used the special text? */
}
}
}
-static void dbgls_typevalue(long type)
+static void dbgls_typevalue(int32_t type)
{
int elem = TYM_ELEMENTS(type);
type = TYM_TYPE(type);
switch (type) {
case TY_BYTE:
- last_defined->type = 1; /* unsigned char */
+ last_defined->type = 1; /* uint8_t */
break;
case TY_WORD:
last_defined->type = 3; /* unsigned word */
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
/* nasm internal data */
struct section *next;
struct SAA *data;
- long index;
+ int32_t index;
struct reloc *relocs;
int align;
/* data that goes into the file */
- char sectname[16]; /* what this section is called */
- char segname[16]; /* segment this section will be in */
- unsigned long size; /* in-memory and -file size */
- unsigned long nreloc; /* relocation entry count */
- unsigned long flags; /* type and attributes (masked) */
+ int8_t sectname[16]; /* what this section is called */
+ int8_t segname[16]; /* segment this section will be in */
+ uint32_t size; /* in-memory and -file size */
+ uint32_t nreloc; /* relocation entry count */
+ uint32_t flags; /* type and attributes (masked) */
};
#define SECTION_TYPE 0x000000ff /* section type mask */
static struct sectmap {
- const char *nasmsect;
- const char *segname;
- const char *sectname;
- const long flags;
+ const int8_t *nasmsect;
+ const int8_t *segname;
+ const int8_t *sectname;
+ const int32_t flags;
} sectmap[] = { {
".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS}, {
".data", "__DATA", "__data", S_REGULAR}, {
struct reloc *next;
/* data that goes into the file */
- long addr; /* op's offset in section */
+ int32_t addr; /* op's offset in section */
unsigned int snum:24, /* contains symbol index if
** ext otherwise in-file
** section number */
pcrel:1, /* relative relocation */
- length:2, /* 0=byte, 1=word, 2=long */
+ length:2, /* 0=byte, 1=word, 2=int32_t */
ext:1, /* external symbol referenced */
type:4; /* reloc type, 0 for us */
};
struct symbol {
/* nasm internal data */
struct symbol *next; /* next symbol in the list */
- char *name; /* name of this symbol */
- long initial_snum; /* symbol number used above in
+ int8_t *name; /* name of this symbol */
+ int32_t initial_snum; /* symbol number used above in
reloc */
- long snum; /* true snum for reloc */
+ int32_t snum; /* true snum for reloc */
/* data that goes into the file */
- long strx; /* string table index */
- unsigned char type; /* symbol type */
- unsigned char sect; /* NO_SECT or section number */
- short desc; /* for stab debugging, 0 for us */
- unsigned long value; /* offset of symbol in section */
+ int32_t strx; /* string table index */
+ uint8_t type; /* symbol type */
+ uint8_t sect; /* NO_SECT or section number */
+ int16_t desc; /* for stab debugging, 0 for us */
+ uint32_t value; /* offset of symbol in section */
};
/* symbol type bits */
static struct section *sects, **sectstail;
static struct symbol *syms, **symstail;
-static unsigned long nsyms;
+static uint32_t nsyms;
/* These variables are set by macho_layout_symbols() to organize
the symbol table and string table in order the dynamic linker
strings for external symbols
strings for local symbols
*/
-static unsigned long ilocalsym = 0;
-static unsigned long iextdefsym = 0;
-static unsigned long iundefsym = 0;
-static unsigned long nlocalsym;
-static unsigned long nextdefsym;
-static unsigned long nundefsym;
+static uint32_t ilocalsym = 0;
+static uint32_t iextdefsym = 0;
+static uint32_t iundefsym = 0;
+static uint32_t nlocalsym;
+static uint32_t nextdefsym;
+static uint32_t nundefsym;
static struct symbol **extdefsyms = NULL;
static struct symbol **undefsyms = NULL;
static struct RAA *extsyms;
static struct SAA *strs;
-static unsigned long strslen;
+static uint32_t strslen;
static FILE *machofp;
static efunc error;
/* Global file information. This should be cleaned up into either
a structure or as function arguments. */
-unsigned long head_ncmds = 0;
-unsigned long head_sizeofcmds = 0;
-unsigned long seg_filesize = 0;
-unsigned long seg_vmsize = 0;
-unsigned long seg_nsects = 0;
-unsigned long rel_padcnt = 0;
+uint32_t head_ncmds = 0;
+uint32_t head_sizeofcmds = 0;
+uint32_t seg_filesize = 0;
+uint32_t seg_vmsize = 0;
+uint32_t seg_nsects = 0;
+uint32_t rel_padcnt = 0;
#define xstrncpy(xdst, xsrc) \
#define align(x, y) \
(((x) + (y) - 1) & ~((y) - 1)) /* align x to multiple of y */
-#define alignlong(x) \
- align(x, sizeof(long)) /* align x to long boundary */
+#define alignint32_t(x) \
+ align(x, sizeof(int32_t)) /* align x to int32_t boundary */
static void debug_reloc (struct reloc *);
static void debug_section_relocs (struct section *) __attribute__ ((unused));
-static int exact_log2 (unsigned long align) {
+static int exact_log2 (uint32_t align) {
if (align != (align & -align)) {
return -1;
} else {
#ifdef __GNUC__
return (align ? __builtin_ctzl (align) : 0);
#else
- unsigned long result = 0;
+ uint32_t result = 0;
while (align >>= 1) {
++result;
}
}
-static struct section *get_section_by_name(const char *segname,
- const char *sectname)
+static struct section *get_section_by_name(const int8_t *segname,
+ const int8_t *sectname)
{
struct section *s;
return s;
}
-static struct section *get_section_by_index(const long index)
+static struct section *get_section_by_index(const int32_t index)
{
struct section *s;
return s;
}
-static long get_section_index_by_name(const char *segname,
- const char *sectname)
+static int32_t get_section_index_by_name(const int8_t *segname,
+ const int8_t *sectname)
{
struct section *s;
return -1;
}
-static char *get_section_name_by_index(const long index)
+static int8_t *get_section_name_by_index(const int32_t index)
{
struct section *s;
return NULL;
}
-static unsigned char get_section_fileindex_by_index(const long index)
+static uint8_t get_section_fileindex_by_index(const int32_t index)
{
struct section *s;
- unsigned char i = 1;
+ uint8_t i = 1;
for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
if (index == s->index)
static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
evalfunc eval)
{
- char zero = 0;
+ int8_t zero = 0;
machofp = fp;
error = errfunc;
strs = saa_init(1L);
/* string table starts with a zero byte - don't ask why */
- saa_wbytes(strs, &zero, sizeof(char));
+ saa_wbytes(strs, &zero, sizeof(int8_t));
strslen = 1;
}
-static int macho_setinfo(enum geninfo type, char **val)
+static int macho_setinfo(enum geninfo type, int8_t **val)
{
return 0;
}
static void sect_write(struct section *sect,
- const unsigned char *data, unsigned long len)
+ const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->size += len;
}
-static void add_reloc(struct section *sect, long section,
+static void add_reloc(struct section *sect, int32_t section,
int pcrel, int bytes)
{
struct reloc *r;
- long fi;
+ int32_t fi;
/* NeXT as puts relocs in reversed order (address-wise) into the
** files, so we do the same, doesn't seem to make much of a
++sect->nreloc;
}
-static void macho_output(long secto, const void *data, unsigned long type,
- long section, long wrt)
+static void macho_output(int32_t secto, const void *data, uint32_t type,
+ int32_t section, int32_t wrt)
{
struct section *s, *sbss;
- long realbytes = type & OUT_SIZMASK;
- long addr;
- unsigned char mydata[4], *p;
+ int32_t realbytes = type & OUT_SIZMASK;
+ int32_t addr;
+ uint8_t mydata[4], *p;
type &= OUT_TYPMASK;
sbss = get_section_by_name("__DATA", "__bss");
if (s == sbss && type != OUT_RESERVE) {
- error(ERR_WARNING, "attempt to initialise memory in the"
+ error(ERR_WARNING, "attempt to initialize memory in the"
" BSS section: ignored");
switch (type) {
switch (type) {
case OUT_RESERVE:
if (s != sbss) {
- error(ERR_WARNING, "uninitialised space declared in"
+ error(ERR_WARNING, "uninitialized space declared in"
" %s section: zeroing",
get_section_name_by_index(secto));
break;
case OUT_ADDRESS:
- addr = *(long *)data;
+ addr = *(int32_t *)data;
if (section != NO_SEG) {
if (section % 2) {
add_reloc(s, section, 1, 2);
p = mydata;
- WRITESHORT(p, *(long *)data - (realbytes + s->size));
+ WRITESHORT(p, *(int32_t *)data - (realbytes + s->size));
sect_write(s, mydata, 2L);
break;
add_reloc(s, section, 1, 4);
p = mydata;
- WRITELONG(p, *(long *)data - (realbytes + s->size));
+ WRITELONG(p, *(int32_t *)data - (realbytes + s->size));
sect_write(s, mydata, 4L);
break;
}
}
-static long macho_section(char *name, int pass, int *bits)
+static int32_t macho_section(int8_t *name, int pass, int *bits)
{
- long index, originalIndex;
- char *sectionAttributes;
+ int32_t index, originalIndex;
+ int8_t *sectionAttributes;
struct sectmap *sm;
struct section *s;
sectionAttributes = NULL;
} else {
sectionAttributes = name;
- name = strsep(§ionAttributes, " \t");
+ name = strtok((char*)§ionAttributes, " \t");
}
for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
/* make lookup into section name translation table */
if (!strcmp(name, sm->nasmsect)) {
- char *currentAttribute;
+ int8_t *currentAttribute;
/* try to find section with that name */
originalIndex = index = get_section_index_by_name(sm->segname,
}
while ((NULL != sectionAttributes)
- && (currentAttribute = strsep(§ionAttributes, " \t"))) {
+ && (currentAttribute = strtok((char*)§ionAttributes, " \t"))) {
if (0 != *currentAttribute) {
if (0 == strncasecmp("align=", currentAttribute, 6)) {
- char *end;
+ int8_t *end;
int newAlignment, value;
- value = strtoul(currentAttribute + 6, &end, 0);
+ value = strtoul(currentAttribute + 6, (char**)&end, 0);
newAlignment = exact_log2(value);
if (0 != *end) {
return NO_SEG;
}
-static void macho_symdef(char *name, long section, long offset,
- int is_global, char *special)
+static void macho_symdef(int8_t *name, int32_t section, int32_t offset,
+ int is_global, int8_t *special)
{
struct symbol *sym;
++nsyms;
}
-static long macho_segbase(long section)
+static int32_t macho_segbase(int32_t section)
{
return section;
}
-static int macho_directive(char *directive, char *value, int pass)
+static int macho_directive(int8_t *directive, int8_t *value, int pass)
{
return 0;
}
-static void macho_filename(char *inname, char *outname, efunc error)
+static void macho_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, ".o", error);
}
-static const char *macho_stdmac[] = {
+static const int8_t *macho_stdmac[] = {
"%define __SECT__ [section .text]",
"%macro __NASM_CDecl__ 1",
"%endmacro",
numsyms is the total number of symbols we have. strtabsize is the
number entries in the string table. */
-static void macho_layout_symbols (unsigned long *numsyms,
- unsigned long *strtabsize)
+static void macho_layout_symbols (uint32_t *numsyms,
+ uint32_t *strtabsize)
{
struct symbol *sym, **symp;
- unsigned long i,j;
+ uint32_t i,j;
*numsyms = 0;
- *strtabsize = sizeof (char);
+ *strtabsize = sizeof (int8_t);
symp = &syms;
to check for it here instead of just
adding the symbol to the string table. */
sym->strx = *strtabsize;
- saa_wbytes (strs, sym->name, (long)(strlen(sym->name) + 1));
+ saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
*strtabsize += strlen(sym->name) + 1;
}
symp = &(sym->next);
if((sym->type & N_EXT) == 0) {
sym->strx = *strtabsize;
- saa_wbytes (strs, sym->name, (long)(strlen (sym->name) + 1));
+ saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
*strtabsize += strlen(sym->name) + 1;
}
else {
static void macho_write_header (void)
{
- fwritelong(MH_MAGIC, machofp); /* magic */
- fwritelong(CPU_TYPE_I386, machofp); /* CPU type */
- fwritelong(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
- fwritelong(MH_OBJECT, machofp); /* Mach-O file type */
- fwritelong(head_ncmds, machofp); /* number of load commands */
- fwritelong(head_sizeofcmds, machofp); /* size of load commands */
- fwritelong(0, machofp); /* no flags */
+ 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 */
}
/* Write out the segment load command at offset. */
-static unsigned long macho_write_segment (unsigned long offset)
+static uint32_t macho_write_segment (uint32_t offset)
{
- unsigned long s_addr = 0;
- unsigned long rel_base = alignlong (offset + seg_filesize);
- unsigned long s_reloff = 0;
+ uint32_t s_addr = 0;
+ uint32_t rel_base = alignint32_t (offset + seg_filesize);
+ uint32_t s_reloff = 0;
struct section *s;
- fwritelong(LC_SEGMENT, machofp); /* cmd == LC_SEGMENT */
+ fwriteint32_t(LC_SEGMENT, machofp); /* cmd == LC_SEGMENT */
/* size of load command including section load commands */
- fwritelong(MACHO_SEGCMD_SIZE + seg_nsects *
+ fwriteint32_t(MACHO_SEGCMD_SIZE + seg_nsects *
MACHO_SECTCMD_SIZE, machofp);
/* in an MH_OBJECT file all sections are in one unnamed (name
** all zeros) segment */
fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16, 1, machofp);
- fwritelong(0, machofp); /* in-memory offset */
- fwritelong(seg_vmsize, machofp); /* in-memory size */
- fwritelong(offset, machofp); /* in-file offset to data */
- fwritelong(seg_filesize, machofp); /* in-file size */
- fwritelong(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
- fwritelong(VM_PROT_DEFAULT, machofp); /* initial vm protection */
- fwritelong(seg_nsects, machofp); /* number of sections */
- fwritelong(0, machofp); /* no flags */
+ 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 */
/* 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);
- fwritelong(s_addr, machofp);
- fwritelong(s->size, machofp);
+ fwriteint32_t(s_addr, machofp);
+ fwriteint32_t(s->size, machofp);
/* dummy data for zerofill sections or proper values */
if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
- fwritelong(offset, machofp);
+ fwriteint32_t(offset, machofp);
/* Write out section alignment, as a power of two.
e.g. 32-bit word alignment would be 2 (2^^2 = 4). */
- fwritelong(s->align, machofp);
+ fwriteint32_t(s->align, machofp);
/* To be compatible with cctools as we emit
a zero reloff if we have no relocations. */
- fwritelong(s->nreloc ? rel_base + s_reloff : 0, machofp);
- fwritelong(s->nreloc, machofp);
+ fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
+ fwriteint32_t(s->nreloc, machofp);
offset += s->size;
s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
} else {
- fwritelong(0, machofp);
- fwritelong(0, machofp);
- fwritelong(0, machofp);
- fwritelong(0, machofp);
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
}
- fwritelong(s->flags, machofp); /* flags */
- fwritelong(0, machofp); /* reserved */
- fwritelong(0, machofp); /* reserved */
+ fwriteint32_t(s->flags, machofp); /* flags */
+ fwriteint32_t(0, machofp); /* reserved */
+ fwriteint32_t(0, machofp); /* reserved */
s_addr += s->size;
}
static void macho_write_relocs (struct reloc *r)
{
while (r) {
- unsigned long word2;
+ uint32_t word2;
- fwritelong(r->addr, machofp); /* reloc offset */
+ fwriteint32_t(r->addr, machofp); /* reloc offset */
word2 = r->snum;
word2 |= r->pcrel << 24;
word2 |= r->length << 25;
word2 |= r->ext << 27;
word2 |= r->type << 28;
- fwritelong(word2, machofp); /* reloc data */
+ fwriteint32_t(word2, machofp); /* reloc data */
r = r->next;
}
{
struct section *s, *s2;
struct reloc *r;
- char *rel_paddata = "\0\0\0";
- unsigned char fi, *p, *q, blk[4];
- long l;
+ int8_t *rel_paddata = "\0\0\0";
+ uint8_t fi, *p, *q, blk[4];
+ int32_t l;
for (s = sects; s != NULL; s = s->next) {
if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
* for more information. */
saa_rewind(s->data);
for (r = s->relocs; r != NULL; r = r->next) {
- saa_fread(s->data, r->addr, blk, (long)r->length << 1);
+ saa_fread(s->data, r->addr, blk, (int32_t)r->length << 1);
p = q = blk;
l = *p++;
/* get offset based on relocation type */
if (r->length > 0) {
- l += ((long)*p++) << 8;
+ l += ((int32_t)*p++) << 8;
if (r->length == 2) {
- l += ((long)*p++) << 16;
- l += ((long)*p++) << 24;
+ l += ((int32_t)*p++) << 16;
+ l += ((int32_t)*p++) << 24;
}
}
else
*q++ = l & 0xFF;
- saa_fwrite(s->data, r->addr, blk, (long)r->length << 1);
+ saa_fwrite(s->data, r->addr, blk, (int32_t)r->length << 1);
}
/* dump the section data to file */
saa_fpwrite(s->data, machofp);
}
- /* pad last section up to reloc entries on long boundary */
+ /* pad last section up to reloc entries on int32_t boundary */
fwrite(rel_paddata, rel_padcnt, 1, machofp);
/* emit relocation entries */
{
struct symbol *sym;
struct section *s;
- long fi;
- long i;
+ int32_t fi;
+ int32_t i;
/* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
for (sym = syms; sym != NULL; sym = sym->next) {
if ((sym->type & N_EXT) == 0) {
- fwritelong(sym->strx, machofp); /* string table entry number */
+ fwriteint32_t(sym->strx, machofp); /* string table entry number */
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
- fwriteshort(sym->desc, machofp); /* description */
+ fwriteint16_t(sym->desc, machofp); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
sym->value += s->size;
}
- fwritelong(sym->value, machofp); /* value (i.e. offset) */
+ fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
}
}
for (i = 0; i < nextdefsym; i++) {
sym = extdefsyms[i];
- fwritelong(sym->strx, machofp);
+ fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
- fwriteshort(sym->desc, machofp); /* description */
+ fwriteint16_t(sym->desc, machofp); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
sym->value += s->size;
}
- fwritelong(sym->value, machofp); /* value (i.e. offset) */
+ fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
}
for (i = 0; i < nundefsym; i++) {
sym = undefsyms[i];
- fwritelong(sym->strx, machofp);
+ fwriteint32_t(sym->strx, machofp);
fwrite(&sym->type, 1, 1, machofp); /* symbol type */
fwrite(&sym->sect, 1, 1, machofp); /* section */
- fwriteshort(sym->desc, machofp); /* description */
+ fwriteint16_t(sym->desc, machofp); /* description */
/* Fix up the symbol value now that we know the final section
sizes. */
sym->value += s->size;
}
- fwritelong(sym->value, machofp); /* value (i.e. offset) */
+ fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
}
}
static void macho_write (void)
{
- unsigned long offset = 0;
+ uint32_t offset = 0;
/* mach-o object file structure:
**
** mach header
- ** ulong magic
+ ** uint32_t magic
** int cpu type
** int cpu subtype
- ** ulong mach file type
- ** ulong number of load commands
- ** ulong size of all load commands
+ ** uint32_t mach file type
+ ** uint32_t number of load commands
+ ** uint32_t size of all load commands
** (includes section struct size of segment command)
- ** ulong flags
+ ** uint32_t flags
**
** segment command
- ** ulong command type == LC_SEGMENT
- ** ulong size of load command
+ ** uint32_t command type == LC_SEGMENT
+ ** uint32_t size of load command
** (including section load commands)
- ** char[16] segment name
- ** ulong in-memory offset
- ** ulong in-memory size
- ** ulong in-file offset to data area
- ** ulong in-file size
+ ** int8_t[16] segment name
+ ** uint32_t in-memory offset
+ ** uint32_t in-memory size
+ ** uint32_t in-file offset to data area
+ ** uint32_t in-file size
** (in-memory size excluding zerofill sections)
** int maximum vm protection
** int initial vm protection
- ** ulong number of sections
- ** ulong flags
+ ** uint32_t number of sections
+ ** uint32_t flags
**
** section commands
- ** char[16] section name
- ** char[16] segment name
- ** ulong in-memory offset
- ** ulong in-memory size
- ** ulong in-file offset
- ** ulong alignment
+ ** int8_t[16] section name
+ ** int8_t[16] segment name
+ ** uint32_t in-memory offset
+ ** uint32_t in-memory size
+ ** uint32_t in-file offset
+ ** uint32_t alignment
** (irrelevant in MH_OBJECT)
- ** ulong in-file offset of relocation entires
- ** ulong number of relocations
- ** ulong flags
- ** ulong reserved
- ** ulong reserved
+ ** uint32_t in-file offset of relocation entires
+ ** uint32_t number of relocations
+ ** uint32_t flags
+ ** uint32_t reserved
+ ** uint32_t reserved
**
** symbol table command
- ** ulong command type == LC_SYMTAB
- ** ulong size of load command
- ** ulong symbol table offset
- ** ulong number of symbol table entries
- ** ulong string table offset
- ** ulong string table size
+ ** uint32_t command type == LC_SYMTAB
+ ** uint32_t size of load command
+ ** uint32_t symbol table offset
+ ** uint32_t number of symbol table entries
+ ** uint32_t string table offset
+ ** uint32_t string table size
**
** raw section data
**
- ** padding to long boundary
+ ** padding to int32_t boundary
**
** relocation data (struct reloc)
- ** long offset
+ ** int32_t offset
** uint data (symbolnum, pcrel, length, extern, type)
**
** symbol table data (struct nlist)
- ** long string table entry number
- ** uchar type
+ ** int32_t string table entry number
+ ** uint8_t type
** (extern, absolute, defined in section)
- ** uchar section
+ ** uint8_t section
** (0 for global symbols, section number of definition (>= 1, <=
** 254) for local symbols, size of variable for common symbols
** [type == extern])
- ** short description
+ ** int16_t description
** (for stab debugging format)
- ** ulong value (i.e. file offset) of symbol or stab offset
+ ** uint32_t value (i.e. file offset) of symbol or stab offset
**
** string table data
** list of null-terminated strings
if (nsyms > 0) {
/* write out symbol command */
- fwritelong(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
- fwritelong(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
- fwritelong(offset, machofp); /* symbol table offset */
- fwritelong(nsyms, machofp); /* number of symbol
+ 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
** table entries */
offset += nsyms * MACHO_NLIST_SIZE;
- fwritelong(offset, machofp); /* string table offset */
- fwritelong(strslen, machofp); /* string table size */
+ fwriteint32_t(offset, machofp); /* string table offset */
+ fwriteint32_t(strslen, machofp); /* string table size */
}
/* emit section data */
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
ObjRecord *child; /* Associated record below this one */
ObjRecord **up; /* Master pointer to this ObjRecord */
ObjRecord *back; /* Previous part of this record */
- unsigned long parm[OBJ_PARMS]; /* Parameters for ori routine */
- unsigned char buf[RECORD_MAX + 3];
+ uint32_t parm[OBJ_PARMS]; /* Parameters for ori routine */
+ uint8_t buf[RECORD_MAX + 3];
};
static void obj_fwrite(ObjRecord * orp);
/*
* Write a byte
*/
-static ObjRecord *obj_byte(ObjRecord * orp, unsigned char val)
+static ObjRecord *obj_byte(ObjRecord * orp, uint8_t val)
{
orp = obj_check(orp, 1);
orp->buf[orp->used] = val;
/*
* Write a dword
*/
-static ObjRecord *obj_dword(ObjRecord * orp, unsigned long val)
+static ObjRecord *obj_dword(ObjRecord * orp, uint32_t val)
{
orp = obj_check(orp, 4);
orp->buf[orp->used] = val;
* This routine writes a field of size x. The caller does not need to worry at
* all about whether 16-bits or 32-bits are required.
*/
-static ObjRecord *obj_x(ObjRecord * orp, unsigned long val)
+static ObjRecord *obj_x(ObjRecord * orp, uint32_t val)
{
if (orp->type & 1)
orp->x_size = 32;
/*
* Writes a variable length value
*/
-static ObjRecord *obj_value(ObjRecord * orp, unsigned long val)
+static ObjRecord *obj_value(ObjRecord * orp, uint32_t val)
{
if (val <= 128)
return (obj_byte(orp, val));
/*
* Writes a counted string
*/
-static ObjRecord *obj_name(ObjRecord * orp, char *name)
+static ObjRecord *obj_name(ObjRecord * orp, int8_t *name)
{
int len = strlen(name);
- unsigned char *ptr;
+ uint8_t *ptr;
orp = obj_check(orp, len + 1);
ptr = orp->buf + orp->used;
* This concludes the low level section of outobj.c
*/
-static char obj_infile[FILENAME_MAX];
+static int8_t obj_infile[FILENAME_MAX];
static efunc error;
static evalfunc evaluate;
static ldfunc deflabel;
static FILE *ofp;
-static long first_seg;
+static int32_t first_seg;
static int any_segs;
static int passtwo;
static int arrindex;
struct LineNumber {
struct LineNumber *next;
struct Segment *segment;
- long offset;
- long lineno;
+ int32_t offset;
+ int32_t lineno;
};
static struct FileName {
struct FileName *next;
- char *name;
+ int8_t *name;
struct LineNumber *lnhead, **lntail;
int index;
} *fnhead, **fntail;
static struct Public {
struct Public *next;
- char *name;
- long offset;
- long segment; /* only if it's far-absolute */
+ int8_t *name;
+ int32_t offset;
+ int32_t segment; /* only if it's far-absolute */
int type; /* only for local debug syms */
} *fpubhead, **fpubtail, *last_defined;
static struct External {
struct External *next;
- char *name;
- long commonsize;
- long commonelem; /* element size if FAR, else zero */
+ int8_t *name;
+ int32_t commonsize;
+ int32_t commonelem; /* element size if FAR, else zero */
int index; /* OBJ-file external index */
enum {
DEFWRT_NONE, /* no unusual default-WRT */
DEFWRT_GROUP /* a group */
} defwrt_type;
union {
- char *string;
+ int8_t *string;
struct Segment *seg;
struct Group *grp;
} defwrt_ptr;
static struct Segment {
struct Segment *next;
- long index; /* the NASM segment id */
- long obj_index; /* the OBJ-file segment index */
- struct Group *grp; /* the group it belongs to */
- unsigned long currentpos;
- long align; /* can be SEG_ABS + absolute addr */
+ int32_t index; /* the NASM segment id */
+ int32_t obj_index; /* the OBJ-file segment index */
+ struct Group *grp; /* the group it beint32_ts to */
+ uint32_t currentpos;
+ int32_t align; /* can be SEG_ABS + absolute addr */
enum {
CMB_PRIVATE = 0,
CMB_PUBLIC = 2,
CMB_STACK = 5,
CMB_COMMON = 6
} combine;
- long use32; /* is this segment 32-bit? */
+ int32_t use32; /* is this segment 32-bit? */
struct Public *pubhead, **pubtail, *lochead, **loctail;
- char *name;
- char *segclass, *overlay; /* `class' is a C++ keyword :-) */
+ int8_t *name;
+ int8_t *segclass, *overlay; /* `class' is a C++ keyword :-) */
ObjRecord *orp;
} *seghead, **segtail, *obj_seg_needs_update;
static struct Group {
struct Group *next;
- char *name;
- long index; /* NASM segment id */
- long obj_index; /* OBJ-file group index */
- long nentries; /* number of elements... */
- long nindices; /* ...and number of index elts... */
+ int8_t *name;
+ int32_t index; /* NASM segment id */
+ int32_t obj_index; /* OBJ-file group index */
+ int32_t nentries; /* number of elements... */
+ int32_t nindices; /* ...and number of index elts... */
union {
- long index;
- char *name;
+ int32_t index;
+ int8_t *name;
} segs[GROUP_MAX]; /* ...in this */
} *grphead, **grptail, *obj_grp_needs_update;
static struct ImpDef {
struct ImpDef *next;
- char *extname;
- char *libname;
+ int8_t *extname;
+ int8_t *libname;
unsigned int impindex;
- char *impname;
+ int8_t *impname;
} *imphead, **imptail;
static struct ExpDef {
struct ExpDef *next;
- char *intname;
- char *extname;
+ int8_t *intname;
+ int8_t *extname;
unsigned int ordinal;
int flags;
} *exphead, **exptail;
#define EXPDEF_FLAG_NODATA 0x20
#define EXPDEF_MASK_PARMCNT 0x1F
-static long obj_entry_seg, obj_entry_ofs;
+static int32_t obj_entry_seg, obj_entry_ofs;
struct ofmt of_obj;
/* The current segment */
static struct Segment *current_seg;
-static long obj_segment(char *, int, int *);
+static int32_t obj_segment(int8_t *, int, int *);
static void obj_write_file(int debuginfo);
-static int obj_directive(char *, char *, int);
+static int obj_directive(int8_t *, int8_t *, int);
static void obj_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
of_obj.current_dfmt->init(&of_obj, NULL, fp, errfunc);
}
-static int obj_set_info(enum geninfo type, char **val)
+static int obj_set_info(enum geninfo type, int8_t **val)
{
(void)type;
(void)val;
}
}
-static void obj_ext_set_defwrt(struct External *ext, char *id)
+static void obj_ext_set_defwrt(struct External *ext, int8_t *id)
{
struct Segment *seg;
struct Group *grp;
dws = ext;
}
-static void obj_deflabel(char *name, long segment,
- long offset, int is_global, char *special)
+static void obj_deflabel(int8_t *name, int32_t segment,
+ int32_t offset, int is_global, int8_t *special)
{
/*
* We have three cases:
* We might have a default-WRT specification.
*/
if (!nasm_strnicmp(special, "wrt", 3)) {
- char *p;
+ int8_t *p;
int len;
special += 3;
special += strspn(special, " \t");
/* forward declaration */
static void obj_write_fixup(ObjRecord * orp, int bytes,
- int segrel, long seg, long wrt,
+ int segrel, int32_t seg, int32_t wrt,
struct Segment *segto);
-static void obj_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void obj_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- unsigned long size, realtype;
- const unsigned char *ucdata;
- long ldata;
+ uint32_t size, realtype;
+ const uint8_t *ucdata;
+ int32_t ldata;
struct Segment *seg;
ObjRecord *orp;
if (segment >= SEG_ABS)
error(ERR_NONFATAL, "far-absolute relocations not supported"
" by OBJ format");
- ldata = *(long *)data;
+ ldata = *(int32_t *)data;
if (realtype == OUT_REL2ADR) {
ldata += (size - 2);
size = 2;
}
static void obj_write_fixup(ObjRecord * orp, int bytes,
- int segrel, long seg, long wrt,
+ int segrel, int32_t seg, int32_t wrt,
struct Segment *segto)
{
unsigned locat;
int method;
int base;
- long tidx, fidx;
+ int32_t tidx, fidx;
struct Segment *s = NULL;
struct Group *g = NULL;
struct External *e = NULL;
if (g)
method = 5, tidx = g->obj_index;
else {
- long i = seg / 2;
+ int32_t i = seg / 2;
struct ExtBack *eb = ebhead;
while (i >= EXT_BLKSIZ) {
if (eb)
if (g)
method |= 0x10, fidx = g->obj_index;
else {
- long i = wrt / 2;
+ int32_t i = wrt / 2;
struct ExtBack *eb = ebhead;
while (i >= EXT_BLKSIZ) {
if (eb)
obj_commit(forp);
}
-static long obj_segment(char *name, int pass, int *bits)
+static int32_t obj_segment(int8_t *name, int pass, int *bits)
{
/*
* We call the label manager here to define a name for the new
struct Group *grp;
struct External **extp;
int obj_idx, i, attrs, rn_error;
- char *p;
+ int8_t *p;
/*
* Look for segment attributes.
}
}
-static int obj_directive(char *directive, char *value, int pass)
+static int obj_directive(int8_t *directive, int8_t *value, int pass)
{
if (!strcmp(directive, "group")) {
- char *p, *q, *v;
+ int8_t *p, *q, *v;
if (pass == 1) {
struct Group *grp;
struct Segment *seg;
return 1;
}
if (!strcmp(directive, "import")) {
- char *q, *extname, *libname, *impname;
+ int8_t *q, *extname, *libname, *impname;
if (pass == 2)
return 1; /* ignore in pass two */
return 1;
}
if (!strcmp(directive, "export")) {
- char *q, *extname, *intname, *v;
+ int8_t *q, *extname, *intname, *v;
struct ExpDef *export;
int flags = 0;
unsigned int ordinal = 0;
return 0;
}
-static long obj_segbase(long segment)
+static int32_t obj_segbase(int32_t segment)
{
struct Segment *seg;
/*
* Might be an external with a default WRT.
*/
- long i = segment / 2;
+ int32_t i = segment / 2;
struct ExtBack *eb = ebhead;
struct External *e;
return segment; /* no special treatment */
}
-static void obj_filename(char *inname, char *outname, efunc lerror)
+static void obj_filename(int8_t *inname, int8_t *outname, efunc lerror)
{
strcpy(obj_infile, inname);
standard_extension(inname, outname, ".obj", lerror);
struct External *ext;
struct ImpDef *imp;
struct ExpDef *export;
- static char boast[] = "The Netwide Assembler " NASM_VER;
+ static int8_t boast[] = "The Netwide Assembler " NASM_VER;
int lname_idx;
ObjRecord *orp;
/*
* Write the first LNAMES record, containing LNAME one, which
- * is null. Also initialise the LNAME counter.
+ * is null. Also initialize the LNAME counter.
*/
orp->type = LNAMES;
obj_byte(orp, 0);
orp->type = SEGDEF;
for (seg = seghead; seg; seg = seg->next) {
int acbp;
- unsigned long seglen = seg->currentpos;
+ uint32_t seglen = seg->currentpos;
acbp = (seg->combine << 2); /* C field */
void obj_fwrite(ObjRecord * orp)
{
unsigned int cksum, len;
- unsigned char *ptr;
+ uint8_t *ptr;
cksum = orp->type;
if (orp->x_size == 32)
fputc(cksum, ofp);
len = orp->committed + 1;
cksum += (len & 0xFF) + ((len >> 8) & 0xFF);
- fwriteshort(len, ofp);
+ fwriteint16_t(len, ofp);
fwrite(orp->buf, 1, len - 1, ofp);
for (ptr = orp->buf; --len; ptr++)
cksum += *ptr;
fputc((-cksum) & 0xFF, ofp);
}
-static const char *obj_stdmac[] = {
+static const int8_t *obj_stdmac[] = {
"%define __SECT__ [section .text]",
"%imacro group 1+.nolist",
"[group %1]",
}
}
-static void dbgbi_linnum(const char *lnfname, long lineno, long segto)
+static void dbgbi_linnum(const int8_t *lnfname, int32_t lineno, int32_t segto)
{
struct FileName *fn;
struct LineNumber *ln;
fn->lntail = &ln->next;
}
-static void dbgbi_deflabel(char *name, long segment,
- long offset, int is_global, char *special)
+static void dbgbi_deflabel(int8_t *name, int32_t segment,
+ int32_t offset, int is_global, int8_t *special)
{
struct Segment *seg;
loc->offset = offset;
}
}
-static void dbgbi_typevalue(long type)
+static void dbgbi_typevalue(int32_t type)
{
int vsize;
int elem = TYM_ELEMENTS(type);
switch (type) {
case TY_BYTE:
- last_defined->type = 8; /* unsigned char */
+ last_defined->type = 8; /* uint8_t */
vsize = 1;
break;
case TY_WORD:
#ifdef OF_RDF
-typedef short int16; /* not sure if this will be required to be altered
+typedef int16_t int16; /* not sure if this will be required to be altered
at all... best to typedef it just in case */
-static const char *RDOFFId = "RDOFF1"; /* written to start of RDOFF files */
+static const int8_t *RDOFFId = "RDOFF1"; /* written to start of RDOFF files */
/* the records that can be found in the RDOFF header */
* 32764. */
struct RelocRec {
- char type; /* must be 1 */
- char segment; /* only 0 for code, or 1 for data supported,
+ int8_t type; /* must be 1 */
+ int8_t segment; /* only 0 for code, or 1 for data supported,
* but add 64 for relative refs (ie do not require
* reloc @ loadtime, only linkage) */
- long offset; /* from start of segment in which reference is loc'd */
- char length; /* 1 2 or 4 bytes */
+ int32_t offset; /* from start of segment in which reference is loc'd */
+ int8_t length; /* 1 2 or 4 bytes */
int16 refseg; /* segment to which reference refers to */
};
struct ImportRec {
- char type; /* must be 2 */
+ int8_t type; /* must be 2 */
int16 segment; /* segment number allocated to the label for reloc
* records - label is assumed to be at offset zero
* in this segment, so linker must fix up with offset
* of segment and of offset within segment */
- char label[33]; /* zero terminated... should be written to file until
+ int8_t label[33]; /* zero terminated... should be written to file until
* the zero, but not after it - max len = 32 chars */
};
struct ExportRec {
- char type; /* must be 3 */
- char segment; /* segment referred to (0/1) */
- long offset; /* offset within segment */
- char label[33]; /* zero terminated as above. max len = 32 chars */
+ int8_t type; /* must be 3 */
+ int8_t segment; /* segment referred to (0/1) */
+ int32_t offset; /* offset within segment */
+ int8_t label[33]; /* zero terminated as above. max len = 32 chars */
};
struct DLLRec {
- char type; /* must be 4 */
- char libname[128]; /* name of library to link with at load time */
+ int8_t type; /* must be 4 */
+ int8_t libname[128]; /* name of library to link with at load time */
};
struct BSSRec {
- char type; /* must be 5 */
- long amount; /* number of bytes BSS to reserve */
+ int8_t type; /* must be 5 */
+ int32_t amount; /* number of bytes BSS to reserve */
};
/* code for managing buffers needed to seperate code and data into individual
typedef struct memorybuffer {
int length;
- char buffer[BUF_BLOCK_LEN];
+ int8_t buffer[BUF_BLOCK_LEN];
struct memorybuffer *next;
} memorybuffer;
static void membufwrite(memorybuffer * b, void *data, int bytes)
{
int16 w;
- long l;
+ int32_t l;
if (b->next) { /* memory buffer full - use next buffer */
membufwrite(b->next, data, bytes);
if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN)
|| (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN)) {
- /* buffer full and no next allocated... allocate and initialise next
+ /* buffer full and no next allocated... allocate and initialize next
* buffer */
b->next = newmembuf();
switch (bytes) {
case -4: /* convert to little-endian */
- l = *(long *)data;
+ l = *(int32_t *)data;
b->buffer[b->length++] = l & 0xFF;
l >>= 8;
b->buffer[b->length++] = l & 0xFF;
default:
while (bytes--) {
- b->buffer[b->length++] = *(*(unsigned char **)&data);
+ b->buffer[b->length++] = *(*(uint8_t **)&data);
- (*(unsigned char **)&data)++;
+ (*(uint8_t **)&data)++;
}
break;
}
static efunc error;
static int segtext, segdata, segbss;
-static long bsslength;
+static int32_t bsslength;
static void rdf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
bsslength = 0;
}
-static long rdf_section_names(char *name, int pass, int *bits)
+static int32_t rdf_section_names(int8_t *name, int pass, int *bits)
{
/*
* Default is 32 bits.
membufwrite(header, r->libname, strlen(r->libname) + 1);
}
-static void rdf_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void rdf_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
struct ExportRec r;
struct ImportRec ri;
}
}
-static void rdf_out(long segto, void *data, unsigned long type,
- long segment, long wrt)
+static void rdf_out(int32_t segto, void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- long bytes = type & OUT_SIZMASK;
+ int32_t bytes = type & OUT_SIZMASK;
struct RelocRec rr;
- unsigned char databuf[4], *pd;
+ uint8_t databuf[8], *pd;
if (segto == NO_SEG) {
if ((type & OUT_TYPMASK) != OUT_RESERVE)
type &= OUT_TYPMASK;
if (segto == 2 && type != OUT_RESERVE) {
- error(ERR_NONFATAL, "BSS segments may not be initialised");
+ error(ERR_NONFATAL, "BSS segments may not be initialized");
/* just reserve the space for now... */
}
pd = databuf; /* convert address to little-endian */
- if (bytes == 2)
- WRITESHORT(pd, *(long *)data);
+ if (bytes == 4)
+ WRITELONG(pd, *(int32_t *)data);
+ else if (bytes == 8)
+ WRITEDLONG(pd, *(int64_t *)data);
else
- WRITELONG(pd, *(long *)data);
+ WRITESHORT(pd, *(int32_t *)data);
+
membufwrite(seg[segto], databuf, bytes);
* address of imported symbol onto it to get address relative to end of
* instruction: import_address + data(offset) - end_of_instrn */
- rr.offset = *(long *)data - (rr.offset + bytes);
+ rr.offset = *(int32_t *)data - (rr.offset + bytes);
membufwrite(seg[segto], &rr.offset, -2);
} else if (type == OUT_REL4ADR) {
rr.refseg = segment; /* segment referred to */
write_reloc_rec(&rr);
- rr.offset = *(long *)data - (rr.offset + bytes);
+ rr.offset = *(int32_t *)data - (rr.offset + bytes);
membufwrite(seg[segto], &rr.offset, -4);
}
}
static void rdf_cleanup(int debuginfo)
{
- long l;
- unsigned char b[4], *d;
+ int32_t l;
+ uint8_t b[4], *d;
struct BSSRec bs;
(void)debuginfo;
fclose(ofile);
}
-static long rdf_segbase(long segment)
+static int32_t rdf_segbase(int32_t segment)
{
return segment;
}
-static int rdf_directive(char *directive, char *value, int pass)
+static int rdf_directive(int8_t *directive, int8_t *value, int pass)
{
struct DLLRec r;
return 0;
}
-static void rdf_filename(char *inname, char *outname, efunc error)
+static void rdf_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, ".rdf", error);
}
-static char *rdf_stdmac[] = {
+static int8_t *rdf_stdmac[] = {
"%define __SECT__ [section .text]",
"%imacro library 1+.nolist",
"[library %1]",
NULL
};
-static int rdf_set_info(enum geninfo type, char **val)
+static int rdf_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
/*
* outrdf2.c output routines for the Netwide Assembler to produce
- * RDOFF version 2 format object files, which is used as a
- * main binary format in the RadiOS (http://radios.sf.net).
- * Originally Julian planned to use it in his MOSCOW
- * operating system.
+ * RDOFF version 2 format object files, which Julian originally
+ * planned to use it in his MOSCOW operating system.
*
* The Netwide Assembler is copyright (C) 1996-1998 Simon Tatham and
* Julian Hall. All rights reserved. The software is
#include <string.h>
#include <ctype.h>
#include <assert.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
#include "rdoff/rdoff.h"
/* This signature is written to start of RDOFF files */
-static const char *RDOFF2Id = RDOFF2_SIGNATURE;
+static const int8_t *RDOFF2Id = RDOFF2_SIGNATURE;
/* Note that whenever a segment is referred to in the RDOFF file, its number
* is always half of the segment number that NASM uses to refer to it; this
#define COUNT_SEGTYPES 9
-static char *segmenttypes[COUNT_SEGTYPES] = {
+static int8_t *segmenttypes[COUNT_SEGTYPES] = {
"null", "text", "code", "data",
"comment", "lcomment", "pcomment",
"symdebug", "linedebug"
static efunc error;
static struct seginfo {
- char *segname;
+ int8_t *segname;
int segnumber;
uint16 segtype;
uint16 segreserved;
- long seglength;
+ int32_t seglength;
} segments[RDF_MAXSEGS];
static int nsegments;
-static long bsslength;
-static long headerlength;
+static int32_t bsslength;
+static int32_t headerlength;
static void rdf2_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
headerlength = 0;
}
-static long rdf2_section_names(char *name, int pass, int *bits)
+static int32_t rdf2_section_names(int8_t *name, int pass, int *bits)
{
int i;
- char *p, *q;
+ int8_t *p, *q;
int code = -1;
int reserved = 0;
*/
static void write_reloc_rec(struct RelocRec *r)
{
- char buf[4], *b;
+ int8_t buf[4], *b;
if (r->refseg != (uint16) NO_SEG && (r->refseg & 1)) /* segment base ref */
r->type = RDFREC_SEGRELOC;
*/
static void write_export_rec(struct ExportRec *r)
{
- char buf[4], *b;
+ int8_t buf[4], *b;
r->segment >>= 1;
static void write_import_rec(struct ImportRec *r)
{
- char buf[4], *b;
+ int8_t buf[4], *b;
r->segment >>= 1;
*/
static void write_bss_rec(struct BSSRec *r)
{
- char buf[4], *b;
+ int8_t buf[4], *b;
saa_wbytes(header, &r->type, 1);
saa_wbytes(header, &r->reclen, 1);
*/
static void write_common_rec(struct CommonRec *r)
{
- char buf[4], *b;
+ int8_t buf[4], *b;
r->segment >>= 1;
/*
* Handle export, import and common records.
*/
-static void rdf2_deflabel(char *name, long segment, long offset,
- int is_global, char *special)
+static void rdf2_deflabel(int8_t *name, int32_t segment, int32_t offset,
+ int is_global, int8_t *special)
{
struct ExportRec r;
struct ImportRec ri;
static void membufwrite(int segment, const void *data, int bytes)
{
int i;
- char buf[4], *b;
+ int8_t buf[4], *b;
for (i = 0; i < nsegments; i++) {
if (segments[i].segnumber == segment)
if (bytes < 0) {
b = buf;
if (bytes == -2)
- WRITESHORT(b, *(short *)data);
+ WRITESHORT(b, *(int16_t *)data);
else
- WRITELONG(b, *(long *)data);
+ WRITELONG(b, *(int32_t *)data);
data = buf;
bytes = -bytes;
}
return segments[i].seglength;
}
-static void rdf2_out(long segto, const void *data, unsigned long type,
- long segment, long wrt)
+static void rdf2_out(int32_t segto, const void *data, uint32_t type,
+ int32_t segment, int32_t wrt)
{
- long bytes = type & OUT_SIZMASK;
+ int32_t bytes = type & OUT_SIZMASK;
struct RelocRec rr;
- unsigned char databuf[4], *pd;
+ uint8_t databuf[8], *pd;
int seg;
if (segto == NO_SEG) {
type &= OUT_TYPMASK;
if (segto == 2 && type != OUT_RESERVE) {
- error(ERR_NONFATAL, "BSS segments may not be initialised");
+ error(ERR_NONFATAL, "BSS segments may not be initialized");
/* just reserve the space for now... */
}
pd = databuf; /* convert address to little-endian */
- if (bytes == 2)
- WRITESHORT(pd, *(long *)data);
+ if (bytes == 4)
+ WRITESHORT(pd, *(int32_t *)data);
+ else if (bytes == 8)
+ WRITEDLONG(pd, *(int64_t *)data);
else
- WRITELONG(pd, *(long *)data);
+ WRITESHORT(pd, *(int32_t *)data);
membufwrite(segto, databuf, bytes);
/* what do we put in the code? Simply the data. This should almost
* always be zero, unless someone's doing segment arithmetic...
*/
- rr.offset = *(long *)data;
+ rr.offset = *(int32_t *)data;
} else {
rr.type = RDFREC_RELOC; /* type signature */
rr.segment = segto + 64; /* segment we're currently in + rel flag */
* address of imported symbol onto it to get address relative to end of
* instruction: import_address + data(offset) - end_of_instrn */
- rr.offset = *(long *)data - (rr.offset + bytes);
+ rr.offset = *(int32_t *)data - (rr.offset + bytes);
}
membufwrite(segto, &rr.offset, -2);
rr.reclen = 8;
write_reloc_rec(&rr);
- rr.offset = *(long *)data - (rr.offset + bytes);
+ rr.offset = *(int32_t *)data - (rr.offset + bytes);
membufwrite(segto, &rr.offset, -4);
}
static void rdf2_cleanup(int debuginfo)
{
- long l;
+ int32_t l;
struct BSSRec bs;
int i;
}
l += 10; /* null segment */
- fwritelong(l, ofile);
+ fwriteint32_t(l, ofile);
- fwritelong(headerlength, ofile);
+ fwriteint32_t(headerlength, ofile);
saa_fpwrite(header, ofile); /* dump header */
saa_free(header);
if (i == 2)
continue;
- fwriteshort(segments[i].segtype, ofile);
- fwriteshort(segments[i].segnumber, ofile);
- fwriteshort(segments[i].segreserved, ofile);
- fwritelong(segments[i].seglength, ofile);
+ fwriteint16_t(segments[i].segtype, ofile);
+ fwriteint16_t(segments[i].segnumber, ofile);
+ fwriteint16_t(segments[i].segreserved, ofile);
+ fwriteint32_t(segments[i].seglength, ofile);
saa_fpwrite(seg[i], ofile);
saa_free(seg[i]);
}
/* null segment - write 10 bytes of zero */
- fwritelong(0, ofile);
- fwritelong(0, ofile);
- fwriteshort(0, ofile);
+ fwriteint32_t(0, ofile);
+ fwriteint32_t(0, ofile);
+ fwriteint16_t(0, ofile);
fclose(ofile);
}
-static long rdf2_segbase(long segment)
+static int32_t rdf2_segbase(int32_t segment)
{
return segment;
}
/*
* Handle RDOFF2 specific directives
*/
-static int rdf2_directive(char *directive, char *value, int pass)
+static int rdf2_directive(int8_t *directive, int8_t *value, int pass)
{
int n;
return 0;
}
-static void rdf2_filename(char *inname, char *outname, efunc error)
+static void rdf2_filename(int8_t *inname, int8_t *outname, efunc error)
{
standard_extension(inname, outname, ".rdf", error);
}
-static const char *rdf2_stdmac[] = {
+static const int8_t *rdf2_stdmac[] = {
"%define __SECT__ [section .text]",
"%imacro library 1+.nolist",
"[library %1]",
NULL
};
-static int rdf2_set_info(enum geninfo type, char **val)
+static int rdf2_set_info(enum geninfo type, int8_t **val)
{
return 0;
}
#include <stddef.h>
#include <string.h>
#include <ctype.h>
+#include <inttypes.h>
#include "nasm.h"
#include "insns.h"
#include "float.h"
extern int in_abs_seg; /* ABSOLUTE segment flag */
-extern long abs_seg; /* ABSOLUTE segment */
-extern long abs_offset; /* ABSOLUTE segment offset */
+extern int32_t abs_seg; /* ABSOLUTE segment */
+extern int32_t abs_offset; /* ABSOLUTE segment offset */
#include "regflags.c" /* List of register flags */
location = locp;
}
-insn *parse_line(int pass, char *buffer, insn * result,
+insn *parse_line(int pass, int8_t *buffer, insn * result,
efunc errfunc, evalfunc evaluate, ldfunc ldef)
{
int operand;
result->label = NULL; /* Assume no label */
result->eops = NULL; /* must do this, whatever happens */
- result->operands = 0; /* must initialise this */
+ result->operands = 0; /* must initialize this */
if (i == 0) { /* blank line - ignore */
result->opcode = -1; /* and no instruction either */
}
if ((i == TOKEN_FLOAT && is_comma_next()) || i == '-') {
- long sign = +1L;
+ int32_t sign = +1L;
if (i == '-') {
- char *save = stdscan_bufptr;
+ int8_t *save = stdscan_bufptr;
i = stdscan(NULL, &tokval);
sign = -1L;
if (i != TOKEN_FLOAT || !is_comma_next()) {
nasm_realloc(eop, sizeof(extop) + eop->stringlen);
tail = &eop->next;
*fixptr = eop;
- eop->stringval = (char *)eop + sizeof(extop);
+ eop->stringval = (int8_t *)eop + sizeof(extop);
if (eop->stringlen < 4 ||
!float_const(tokval.t_charptr, sign,
- (unsigned char *)eop->stringval,
+ (uint8_t *)eop->stringval,
eop->stringlen, error))
eop->type = EOT_NOTHING;
i = stdscan(NULL, &tokval); /* eat the comma */
if (mref) { /* it's a memory reference */
expr *e = value;
int b, i, s; /* basereg, indexreg, scale */
- long o; /* offset */
+ int32_t o; /* offset */
b = i = -1, o = s = 0;
result->oprs[operand].hintbase = hints.base;
static int is_comma_next(void)
{
- char *p;
+ int8_t *p;
int i;
struct tokenval tv;
#define NASM_PARSER_H
void parser_global_info(struct ofmt *output, loc_t * locp);
-insn *parse_line(int pass, char *buffer, insn * result,
+insn *parse_line(int pass, int8_t *buffer, insn * result,
efunc error, evalfunc evaluate, ldfunc ldef);
void cleanup_insn(insn * instruction);
/* Typical flow of text through preproc
*
- * pp_getline gets tokenised lines, either
+ * pp_getline gets tokenized lines, either
*
* from a macro expansion
*
* or
* {
* read_line gets raw text from stdmacpos, or predef, or current input file
- * tokenise converts to tokens
+ * tokenize converts to tokens
* }
*
* expand_mmac_params is used to expand %1 etc., unless a macro is being
#include <string.h>
#include <ctype.h>
#include <limits.h>
+#include <inttypes.h>
#include "nasm.h"
#include "nasmlib.h"
*/
struct SMacro {
SMacro *next;
- char *name;
+ int8_t *name;
int casesense;
int nparam;
int in_progress;
*/
struct MMacro {
MMacro *next;
- char *name;
+ int8_t *name;
int casesense;
- int nparam_min, nparam_max;
+ int64_t nparam_min, nparam_max;
int plus; /* is the last parameter greedy? */
int nolist; /* is this macro listing-inhibited? */
int in_progress;
Token **params; /* actual parameters */
Token *iline; /* invocation line */
int nparam, rotate, *paramlen;
- unsigned long unique;
+ uint32_t unique;
int lineno; /* Current line number on expansion */
};
struct Context {
Context *next;
SMacro *localmac;
- char *name;
- unsigned long number;
+ int8_t *name;
+ uint32_t number;
};
/*
*/
struct Token {
Token *next;
- char *text;
+ int8_t *text;
SMacro *mac; /* associated macro for TOK_SMAC_END */
int type;
};
FILE *fp;
Cond *conds;
Line *expansion;
- char *fname;
+ int8_t *fname;
int lineno, lineinc;
MMacro *mstk; /* stack of active macros/reps */
};
*/
struct IncPath {
IncPath *next;
- char *path;
+ int8_t *path;
};
/*
* we treat CXZ and ECXZ as condition codes, albeit non-invertible
* ones, so we need a different enum...
*/
-static const char *conditions[] = {
+static const int8_t *conditions[] = {
"a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
"na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
"np", "ns", "nz", "o", "p", "pe", "po", "s", "z"
/*
* Directive names.
*/
-static const char *directives[] = {
+static const int8_t *directives[] = {
"%arg",
"%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
"%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx",
TM_IFNDEF, TM_INCLUDE, TM_LOCAL
};
-static const char *tasm_directives[] = {
+static const int8_t *tasm_directives[] = {
"arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
"ifndef", "include", "local"
};
static int StackSize = 4;
-static char *StackPointer = "ebp";
+static int8_t *StackPointer = "ebp";
static int ArgOffset = 8;
static int LocalOffset = 4;
static int pass; /* HACK: pass 0 = generate dependencies only */
-static unsigned long unique; /* unique identifier numbers */
+static uint32_t unique; /* unique identifier numbers */
static Line *predef = NULL;
#define PARAM_DELTA 16
/*
- * The standard macro set: defined as `static char *stdmac[]'. Also
+ * The standard macro set: defined as `static int8_t *stdmac[]'. Also
* gives our position in the macro set, when we're processing it.
*/
#include "macros.c"
-static const char **stdmacpos;
+static const int8_t **stdmacpos;
/*
* The extra standard macros that come from the object format, if
* any.
*/
-static const char **extrastdmac = NULL;
+static const int8_t **extrastdmac = NULL;
int any_extrastdmac;
/*
static Token *expand_mmac_params(Token * tline);
static Token *expand_smacro(Token * tline);
static Token *expand_id(Token * tline);
-static Context *get_ctx(char *name, int all_contexts);
-static void make_tok_num(Token * tok, long val);
-static void error(int severity, const char *fmt, ...);
+static Context *get_ctx(int8_t *name, int all_contexts);
+static void make_tok_num(Token * tok, int32_t val);
+static void error(int severity, const int8_t *fmt, ...);
static void *new_Block(size_t size);
static void delete_Blocks(void);
-static Token *new_Token(Token * next, int type, char *text, int txtlen);
+static Token *new_Token(Token * next, int type, int8_t *text, int txtlen);
static Token *delete_Token(Token * t);
/*
* place to do it for the moment, and it is a hack (ideally it would
* be nice to be able to use the NASM pre-processor to do it).
*/
-static char *check_tasm_directive(char *line)
+static int8_t *check_tasm_directive(int8_t *line)
{
- int i, j, k, m, len;
- char *p = line, *oldline, oldchar;
+ int32_t i, j, k, m, len;
+ int8_t *p = line, *oldline, oldchar;
/* Skip whitespace */
while (isspace(*p) && *p != 0)
* flags') into NASM preprocessor line number indications (`%line
* lineno file').
*/
-static char *prepreproc(char *line)
+static int8_t *prepreproc(int8_t *line)
{
int lineno, fnlen;
- char *fname, *oldline;
+ int8_t *fname, *oldline;
if (line[0] == '#' && line[1] == ' ') {
oldline = line;
* invariant under case changes. We implement this by applying a
* perfectly normal hash function to the uppercase of the string.
*/
-static int hash(char *s)
+static int hash(int8_t *s)
{
unsigned int h = 0;
int i = 0;
};
while (*s) {
- h += multipliers[i] * (unsigned char)(toupper(*s));
+ h += multipliers[i] * (uint8_t)(toupper(*s));
s++;
if (++i >= elements(multipliers))
i = 0;
* return lines from the standard macro set if this has not already
* been done.
*/
-static char *read_line(void)
+static int8_t *read_line(void)
{
- char *buffer, *p, *q;
+ int8_t *buffer, *p, *q;
int bufsize, continued_count;
if (stdmacpos) {
if (*stdmacpos) {
- char *ret = nasm_strdup(*stdmacpos++);
+ int8_t *ret = nasm_strdup(*stdmacpos++);
if (!*stdmacpos && any_extrastdmac) {
stdmacpos = extrastdmac;
any_extrastdmac = FALSE;
}
}
if (p - buffer > bufsize - 10) {
- long offset = p - buffer;
+ int32_t offset = p - buffer;
bufsize += BUF_DELTA;
buffer = nasm_realloc(buffer, bufsize);
p = buffer + offset; /* prevent stale-pointer problems */
}
/*
- * Tokenise a line of text. This is a very simple process since we
+ * Tokenize a line of text. This is a very simple process since we
* don't need to parse the value out of e.g. numeric tokens: we
* simply split one string into many.
*/
-static Token *tokenise(char *line)
+static Token *tokenize(int8_t *line)
{
- char *p = line;
+ int8_t *p = line;
int type;
Token *list = NULL;
Token *t, **tail = &list;
/*
* A string token.
*/
- char c = *p;
+ int8_t c = *p;
p++;
type = TOK_STRING;
while (*p && *p != c)
* Anything else is an operator of some kind. We check
* for all the double-character operators (>>, <<, //,
* %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
- * else is a single-character operator.
+ * else is a single-int8_tacter operator.
*/
type = TOK_OTHER;
if ((p[0] == '>' && p[1] == '>') ||
* back to the caller. It sets the type and text elements, and
* also the mac and next elements to NULL.
*/
-static Token *new_Token(Token * next, int type, char *text, int txtlen)
+static Token *new_Token(Token * next, int type, int8_t *text, int txtlen)
{
Token *t;
int i;
* If expand_locals is not zero, identifiers of the form "%$*xxx"
* will be transformed into ..@ctxnum.xxx
*/
-static char *detoken(Token * tlist, int expand_locals)
+static int8_t *detoken(Token * tlist, int expand_locals)
{
Token *t;
int len;
- char *line, *p;
+ int8_t *line, *p;
len = 0;
for (t = tlist; t; t = t->next) {
if (t->type == TOK_PREPROC_ID && t->text[1] == '!') {
- char *p = getenv(t->text + 2);
+ int8_t *p = getenv(t->text + 2);
nasm_free(t->text);
if (p)
t->text = nasm_strdup(p);
t->text[0] == '%' && t->text[1] == '$') {
Context *ctx = get_ctx(t->text, FALSE);
if (ctx) {
- char buffer[40];
- char *p, *q = t->text + 2;
+ int8_t buffer[40];
+ int8_t *p, *q = t->text + 2;
q += strspn(q, "$");
snprintf(buffer, sizeof(buffer), "..@%lu.", ctx->number);
if (tline->type == TOK_STRING) {
int rn_warn;
- char q, *r;
+ int8_t q, *r;
int l;
r = tline->text;
* simple wrapper which calls either strcmp or nasm_stricmp
* depending on the value of the `casesense' parameter.
*/
-static int mstrcmp(char *p, char *q, int casesense)
+static int mstrcmp(int8_t *p, int8_t *q, int casesense)
{
return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
}
* only the context that directly results from the number of $'s
* in variable's name.
*/
-static Context *get_ctx(char *name, int all_contexts)
+static Context *get_ctx(int8_t *name, int all_contexts)
{
Context *ctx;
SMacro *m;
* the include path one by one until it finds the file or reaches
* the end of the path.
*/
-static FILE *inc_fopen(char *file)
+static FILE *inc_fopen(int8_t *file)
{
FILE *fp;
- char *prefix = "", *combine;
+ int8_t *prefix = "", *combine;
IncPath *ip = ipath;
static int namelen = 0;
int len = strlen(file);
* is true, macro will be searched in outer contexts as well.
*/
static int
-smacro_defined(Context * ctx, char *name, int nparam, SMacro ** defn,
+smacro_defined(Context * ctx, int8_t *name, int nparam, SMacro ** defn,
int nocase)
{
SMacro *m;
/*
* Expand macros in a string. Used in %error and %include directives.
- * First tokenise the string, apply "expand_smacro" and then de-tokenise back.
+ * First tokenize the string, apply "expand_smacro" and then de-tokenize back.
* The returned variable should ALWAYS be freed after usage.
*/
-void expand_macros_in_string(char **p)
+void expand_macros_in_string(int8_t **p)
{
- Token *line = tokenise(*p);
+ Token *line = tokenize(*p);
line = expand_smacro(line);
*p = detoken(line, FALSE);
}
*/
static int do_directive(Token * tline)
{
- int i, j, k, m, nparam, nolist;
+ int i, j, nparam, nolist;
+ int64_t k, m;
int offset;
- char *p, *mname;
+ int8_t *p, *mname;
Include *inc;
Context *ctx;
Cond *cond;
*/
offset = ArgOffset;
do {
- char *arg, directive[256];
+ int8_t *arg, directive[256];
int size = StackSize;
/* Find the argument name */
}
/* Allow macro expansion of type parameter */
- tt = tokenise(tline->text);
+ tt = tokenize(tline->text);
tt = expand_smacro(tt);
if (nasm_stricmp(tt->text, "byte") == 0) {
size = MAX(StackSize, 1);
/* Now define the macro for the argument */
snprintf(directive, sizeof(directive), "%%define %s (%s+%d)",
arg, StackPointer, offset);
- do_directive(tokenise(directive));
+ do_directive(tokenize(directive));
offset += size;
/* Move to the next argument in the list */
*/
offset = LocalOffset;
do {
- char *local, directive[256];
+ int8_t *local, directive[256];
int size = StackSize;
/* Find the argument name */
}
/* Allow macro expansion of type parameter */
- tt = tokenise(tline->text);
+ tt = tokenize(tline->text);
tt = expand_smacro(tt);
if (nasm_stricmp(tt->text, "byte") == 0) {
size = MAX(StackSize, 1);
/* Now define the macro for the argument */
snprintf(directive, sizeof(directive), "%%define %s (%s-%d)",
local, StackPointer, offset);
- do_directive(tokenise(directive));
+ do_directive(tokenize(directive));
offset += size;
/* Now define the assign to setup the enter_c macro correctly */
snprintf(directive, sizeof(directive),
"%%assign %%$localsize %%$localsize+%d", size);
- do_directive(tokenise(directive));
+ do_directive(tokenize(directive));
/* Move to the next argument in the list */
tline = tline->next;
(((tline->text[1] == '+' || tline->text[1] == '-')
&& tline->text[2]) || tline->text[1] == '%'
|| (tline->text[1] >= '0' && tline->text[1] <= '9'))) {
- char *text = NULL;
+ int8_t *text = NULL;
int type = 0, cc; /* type = 0 to placate optimisers */
- char tmpbuf[30];
+ int8_t tmpbuf[30];
int n, i;
MMacro *mac;
break;
case TOK_ID:
if (tt->type == TOK_ID || tt->type == TOK_NUMBER) {
- char *tmp = nasm_strcat(t->text, tt->text);
+ int8_t *tmp = nasm_strcat(t->text, tt->text);
nasm_free(t->text);
t->text = tmp;
t->next = delete_Token(tt);
break;
case TOK_NUMBER:
if (tt->type == TOK_NUMBER) {
- char *tmp = nasm_strcat(t->text, tt->text);
+ int8_t *tmp = nasm_strcat(t->text, tt->text);
nasm_free(t->text);
t->text = tmp;
t->next = delete_Token(tt);
int nparam, sparam, brackets, rescan;
Token *org_tline = tline;
Context *ctx;
- char *mname;
+ int8_t *mname;
/*
* Trick: we should avoid changing the start token pointer since it can
*/
if (!m->expansion) {
if (!strcmp("__FILE__", m->name)) {
- long num = 0;
+ int32_t num = 0;
src_get(&num, &(tline->text));
nasm_quote(&(tline->text));
tline->type = TOK_STRING;
make_tok_num(tline, src_get_linnum());
continue;
}
+ if (!strcmp("__BITS__", m->name)) {
+ nasm_free(tline->text);
+ make_tok_num(tline, globalbits);
+ continue;
+ }
tline = delete_Token(tline);
continue;
}
}
if (tline->type == TOK_OTHER
&& tline->text[1] == 0) {
- char ch = tline->text[0];
+ int8_t ch = tline->text[0];
if (ch == ',' && !paren && brackets <= 0) {
if (++nparam >= sparam) {
sparam += PARAM_DELTA;
/*
* Now scan the entire line and look for successive TOK_IDs that resulted
- * after expansion (they can't be produced by tokenise()). The successive
+ * after expansion (they can't be produced by tokenize()). The successive
* TOK_IDs should be concatenated.
* Also we look for %+ tokens and concatenate the tokens before and after
* them (without white spaces in between).
if (t->next->type == TOK_ID ||
t->next->type == TOK_PREPROC_ID ||
t->next->type == TOK_NUMBER) {
- char *p = nasm_strcat(t->text, t->next->text);
+ int8_t *p = nasm_strcat(t->text, t->next->text);
nasm_free(t->text);
t->next = delete_Token(t->next);
t->text = p;
* won't want to see same error twice (preprocessing is done once
* per pass) we will want to show errors only during pass one.
*/
-static void error(int severity, const char *fmt, ...)
+static void error(int severity, const int8_t *fmt, ...)
{
va_list arg;
- char buff[1024];
+ int8_t buff[1024];
/* If we're in a dead branch of IF or something like it, ignore the error */
if (istk && istk->conds && !emitting(istk->conds->state))
}
static void
-pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
+pp_reset(int8_t *file, int apass, efunc errfunc, evalfunc eval,
ListGen * listgen)
{
int h;
pass = apass;
}
-static char *pp_getline(void)
+static int8_t *pp_getline(void)
{
- char *line;
+ int8_t *line;
Token *tline;
while (1) {
/*
- * Fetch a tokenised line, either from the macro-expansion
+ * Fetch a tokenized line, either from the macro-expansion
* buffer or from the input file.
*/
tline = NULL;
while (1) { /* until we get a line we can use */
if (istk->expansion) { /* from a macro expansion */
- char *p;
+ int8_t *p;
Line *l = istk->expansion;
if (istk->mstk)
istk->mstk->lineno++;
line = read_line();
if (line) { /* from the current input file */
line = prepreproc(line);
- tline = tokenise(line);
+ tline = tokenize(line);
nasm_free(line);
break;
}
/*
* We're defining a multi-line macro. We emit nothing
* at all, and just
- * shove the tokenised line on to the macro definition.
+ * shove the tokenized line on to the macro definition.
*/
Line *l = nasm_malloc(sizeof(Line));
l->next = defining->expansion;
tline = expand_smacro(tline);
if (!expand_mmacro(tline)) {
/*
- * De-tokenise the line again, and emit it.
+ * De-tokenize the line again, and emit it.
*/
line = detoken(tline, TRUE);
free_tlist(tline);
}
}
-void pp_include_path(char *path)
+void pp_include_path(int8_t *path)
{
IncPath *i;
/* by alexfru: order of path inclusion fixed (was reverse order) */
* The function use is simple:
*
* The 1st call (with NULL argument) returns a pointer to the 1st path
- * (char** type) or NULL if none include paths available.
+ * (int8_t** type) or NULL if none include paths available.
*
* All subsequent calls take as argument the value returned by this
* function last. The return value is either the next path
- * (char** type) or NULL if the end of the paths list is reached.
+ * (int8_t** type) or NULL if the end of the paths list is reached.
*
* It is maybe not the best way to do things, but I didn't want
* to export too much, just one or two functions and no types or
* Can't say I like the current situation with e.g. this path list either,
* it seems to be never deallocated after creation...
*/
-char **pp_get_include_path_ptr(char **pPrevPath)
+int8_t **pp_get_include_path_ptr(int8_t **pPrevPath)
{
/* This macro returns offset of a member of a structure */
#define GetMemberOffset(StructType,MemberName)\
else
return NULL;
}
- i = (IncPath *) ((char *)pPrevPath - GetMemberOffset(IncPath, path));
+ i = (IncPath *) ((int8_t *)pPrevPath - GetMemberOffset(IncPath, path));
i = i->next;
if (i != NULL)
return &i->path;
#undef GetMemberOffset
}
-void pp_pre_include(char *fname)
+void pp_pre_include(int8_t *fname)
{
Token *inc, *space, *name;
Line *l;
predef = l;
}
-void pp_pre_define(char *definition)
+void pp_pre_define(int8_t *definition)
{
Token *def, *space;
Line *l;
- char *equals;
+ int8_t *equals;
equals = strchr(definition, '=');
space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
if (equals)
*equals = ' ';
- space->next = tokenise(definition);
+ space->next = tokenize(definition);
if (equals)
*equals = '=';
predef = l;
}
-void pp_pre_undefine(char *definition)
+void pp_pre_undefine(int8_t *definition)
{
Token *def, *space;
Line *l;
space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
- space->next = tokenise(definition);
+ space->next = tokenize(definition);
l = nasm_malloc(sizeof(Line));
l->next = predef;
predef = l;
}
-void pp_extra_stdmac(const char **macros)
+/*
+ * Added by Keith Kanios:
+ *
+ * This function is used to assist with "runtime" preprocessor
+ * directives. (e.g. pp_runtime("%define __BITS__ 64");)
+ *
+ * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
+ * PASS A VALID STRING TO THIS FUNCTION!!!!!
+ */
+
+void pp_runtime(int8_t *definition)
+{
+ Token *def;
+
+ def = tokenize(definition);
+ if(do_directive(def) == NO_DIRECTIVE_FOUND)
+ free_tlist(def);
+
+}
+
+void pp_extra_stdmac(const int8_t **macros)
{
extrastdmac = macros;
}
-static void make_tok_num(Token * tok, long val)
+static void make_tok_num(Token * tok, int32_t val)
{
- char numbuf[20];
+ int8_t numbuf[20];
snprintf(numbuf, sizeof(numbuf), "%ld", val);
tok->text = nasm_strdup(numbuf);
tok->type = TOK_NUMBER;
#ifndef NASM_PREPROC_H
#define NASM_PREPROC_H
-void pp_include_path(char *);
-char **pp_get_include_path_ptr(char **pPrevPath);
-void pp_pre_include(char *);
-void pp_pre_define(char *);
-void pp_pre_undefine(char *);
-void pp_extra_stdmac(const char **);
+void pp_include_path(int8_t *);
+int8_t **pp_get_include_path_ptr(int8_t **pPrevPath);
+void pp_pre_include(int8_t *);
+void pp_pre_define(int8_t *);
+void pp_pre_undefine(int8_t *);
+void pp_runtime(int8_t *);
+void pp_extra_stdmac(const int8_t **);
extern Preproc nasmpp;
* collectn.h - header file for 'collection' abstract data type.
*
* This file is public domain, and does not come under the NASM license.
- * It, along with 'collectn.c' implements what is basically a variable
+ * It, aint32_t with 'collectn.c' implements what is basically a variable
* length array (of pointers).
*/
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
-unsigned hash(const char *name)
+unsigned hash(const int8_t *name)
{
- register const char *n;
+ register const int8_t *n;
register crc32 hashval = 0xffffffff;
for (n = name; *n; n++)
* distributed in the NASM archive.
*/
-unsigned hash(const char *name);
+unsigned hash(const int8_t *name);
struct segment_infonode {
int dest_seg; /* output segment to be placed into, -1 to
skip linking this segment */
- long reloc; /* segment's relocation factor */
+ int32_t reloc; /* segment's relocation factor */
};
struct modulenode {
struct segment_infonode seginfo[RDF_MAXSEGS]; /* what are we doing
with each segment? */
void *header;
- char *name;
+ int8_t *name;
struct modulenode *next;
- long bss_reloc;
+ int32_t bss_reloc;
};
#include "ldsegs.h"
* Function prototypes of private utility functions
*/
-void processmodule(const char *filename, struct modulenode *mod);
+void processmodule(const int8_t *filename, struct modulenode *mod);
int allocnewseg(uint16 type, uint16 reserved);
int findsegment(uint16 type, uint16 reserved);
-void symtab_add(const char *symbol, int segment, long offset);
-int symtab_get(const char *symbol, int *segment, long *offset);
+void symtab_add(const int8_t *symbol, int segment, int32_t offset);
+int symtab_get(const int8_t *symbol, int *segment, int32_t *offset);
/* =========================================================================
* Global data structures.
void *symtab = NULL;
/* objects search path */
-char *objpath = NULL;
+int8_t *objpath = NULL;
/* libraries search path */
-char *libpath = NULL;
+int8_t *libpath = NULL;
/* file to embed as a generic record */
-char *generic_rec_file = NULL;
+int8_t *generic_rec_file = NULL;
/* error file */
static FILE *error_file;
*/
struct SegmentHeaderRec outputseg[RDF_MAXSEGS];
int nsegs = 0;
-long bss_length;
+int32_t bss_length;
/* global options which affect how the program behaves */
struct ldrdfoptions {
/*
* loadmodule
*
- * Determine the characteristics of a module, and decide what to do with
+ * Determine the int8_tacteristics of a module, and decide what to do with
* each segment it contains (including determining destination segments and
* relocation factors for segments that are kept).
*/
-void loadmodule(const char *filename)
+void loadmodule(const int8_t *filename)
{
if (options.verbose)
printf("loading `%s'\n", filename);
* (b) is fairly easy, because we're now keeping track of how big each
* segment in our output file is...
*/
-void processmodule(const char *filename, struct modulenode *mod)
+void processmodule(const int8_t *filename, struct modulenode *mod)
{
struct segconfig sconf;
int seg, outseg;
void *header;
rdfheaderrec *hr;
- long bssamount = 0;
+ int32_t bssamount = 0;
int bss_was_referenced = 0;
for (seg = 0; seg < mod->f.nsegs; seg++) {
case RDFREC_GLOBAL:{ /* exported symbol */
int destseg;
- long destreloc;
+ int32_t destreloc;
if (hr->e.segment == 2) {
bss_was_referenced = 1;
/*
* Return 1 if a given module is in the list, 0 otherwise.
*/
-int lookformodule(const char *name)
+int lookformodule(const int8_t *name)
{
struct modulenode *curr = modules;
* routine won't change a previously existing symbol. It will change
* to segment = -2 only if the segment was previously < 0.
*/
-void symtab_add(const char *symbol, int segment, long offset)
+void symtab_add(const int8_t *symbol, int segment, int32_t offset)
{
symtabEnt *ste;
* are assumed to have -1:0 associated. Returns 1 if the symbol was
* successfully located.
*/
-int symtab_get(const char *symbol, int *segment, long *offset)
+int symtab_get(const int8_t *symbol, int *segment, int32_t *offset)
{
symtabEnt *ste = symtabFind(symtab, symbol);
if (!ste) {
* checks that a library can be opened and is in the correct format,
* then adds it to the linked list of libraries.
*/
-void add_library(const char *name)
+void add_library(const int8_t *name)
{
if (rdl_verify(name)) {
rdl_perror("ldrdf", name);
int i;
void *header;
int segment;
- long offset;
+ int32_t offset;
int doneanything = 0, pass = 1, keepfile;
rdfheaderrec *hr;
* all the modules into a single output module, and then writes this to a
* file.
*/
-void write_output(const char *filename)
+void write_output(const int8_t *filename)
{
FILE *f;
rdf_headerbuf *rdfheader;
rdfheaderrec *hr, newrec;
symtabEnt *se;
segtab segs;
- long offset;
+ int32_t offset;
byte *data;
if ((f = fopen(filename, "wb")) == NULL) {
"warning: relocation out of range "
"at %s(%02x:%08lx)\n", cur->name,
(int)hr->r.segment, hr->r.offset);
- *data = (char)offset;
+ *data = (int8_t)offset;
break;
case 2:
- offset += *(short *)data;
+ offset += *(int16_t *)data;
if (offset < -32767 || offset > 32768)
fprintf(error_file,
"warning: relocation out of range "
"at %s(%02x:%08lx)\n", cur->name,
(int)hr->r.segment, hr->r.offset);
- *(short *)data = (short)offset;
+ *(int16_t *)data = (int16_t)offset;
break;
case 4:
- *(long *)data += offset;
+ *(int32_t *)data += offset;
/* we can't easily detect overflow on this one */
break;
}
*/
for (i = 0; i < nsegs; i++) {
uint16 s;
- long l;
+ int32_t l;
if (i == 2)
continue;
- s = translateshort(outputseg[i].type);
+ s = translateint16_t(outputseg[i].type);
fwrite(&s, 2, 1, f);
- s = translateshort(outputseg[i].number);
+ s = translateint16_t(outputseg[i].number);
fwrite(&s, 2, 1, f);
- s = translateshort(outputseg[i].reserved);
+ s = translateint16_t(outputseg[i].reserved);
fwrite(&s, 2, 1, f);
- l = translatelong(outputseg[i].length);
+ l = translateint32_t(outputseg[i].length);
fwrite(&l, 4, 1, f);
fwrite(outputseg[i].data, outputseg[i].length, 1, f);
exit(0);
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
- char *outname = "aout.rdf";
+ int8_t *outname = "aout.rdf";
int moduleloaded = 0;
- char *respstrings[128] = { 0, };
+ int8_t *respstrings[128] = { 0, };
options.verbose = 0;
options.align = 16;
}
case '@':{
int i = 0;
- char buf[256];
+ int8_t buf[256];
FILE *f;
options.respfile = 1;
argv++, argc--;
while (fgets(buf, sizeof(buf), f) != NULL) {
- char *p;
+ int8_t *p;
if (buf[0] == '\n')
continue;
if ((p = strchr(buf, '\n')) != NULL)
*/
#ifndef UI16
-#define UI16 unsigned short
+#define UI16 uint16_t
#endif
struct segconfig {
UI16 typelow, typehi; /* range of seg nos for which this is valid */
- char *typedesc; /* a description of the segment type */
+ int8_t *typedesc; /* a description of the segment type */
UI16 dowhat; /* one of the SEG_xxxx values below */
UI16 mergetype; /* if SEG_MERGE what type segment do we merge with?
0 -> same type of segment. This type is also
#include "rdfload.h"
#include "nasmlib.h"
-long origin = 0;
+int32_t origin = 0;
int align = 16;
-char *getfilename(char *pathname)
+int8_t *getfilename(int8_t *pathname)
{
- char *lastslash = pathname - 1;
- char *i = pathname;
+ int8_t *lastslash = pathname - 1;
+ int8_t *i = pathname;
while (*i) {
if (*i == '/')
return lastslash + 1;
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
rdfmodule *m;
int tmp;
FILE *of;
- char *padding;
+ int8_t *padding;
int codepad, datapad, bsspad = 0;
if (argc < 2) {
#include "nasmlib.h"
#include "symtab.h"
-long origin = 0;
+int32_t origin = 0;
int align = 16;
/* This function writes a single n-byte data record to of. Maximum value
for n is 255. */
static int write_data_record(FILE * of, int ofs, int nbytes,
- unsigned char *data)
+ uint8_t *data)
{
int i, iofs;
unsigned int checksum;
return (ofs);
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
rdfmodule *m;
int tmp;
FILE *of;
- char *padding;
- unsigned char *segbin[2];
+ int8_t *padding;
+ uint8_t *segbin[2];
int pad[2], segn, ofs, i;
- long segaddr;
+ int32_t segaddr;
unsigned int checksum;
symtabEnt *s;
FILE *infile;
-void print_header(long length, int rdf_version)
+void print_header(int32_t length, int rdf_version)
{
- char buf[129], t, l, s, flags;
- unsigned char reclen;
- long o, ll;
+ int8_t buf[129], t, l, s, flags;
+ uint8_t reclen;
+ int32_t o, ll;
uint16 rs;
while (length > 0) {
printf(" %s: location (%04x:%08lx), length %d, "
"referred seg %04x\n",
t == 1 ? "relocation" : "seg relocation", (int)s,
- translatelong(o), (int)l, translateshort(rs));
+ translateint32_t(o), (int)l, translateint16_t(rs));
if (rdf_version >= 2 && reclen != 8)
printf(" warning: reclen != 8\n");
if (rdf_version == 1)
printf(" proc");
if (flags & SYM_DATA)
printf(" data");
- printf(": segment %04x = %s\n", translateshort(rs), buf);
+ printf(": segment %04x = %s\n", translateint16_t(rs), buf);
if (rdf_version == 1)
length -= ll + 3;
if (rdf_version == 1 && t == 7)
printf(" proc");
if (flags & SYM_DATA)
printf(" data");
- printf(": (%04x:%08lx) = %s\n", (int)s, translatelong(o), buf);
+ printf(": (%04x:%08lx) = %s\n", (int)s, translateint32_t(o), buf);
if (rdf_version == 1)
length -= ll + 6;
break;
case RDFREC_BSS: /* BSS reservation */
fread(&ll, 4, 1, infile);
- printf(" bss reservation: %08lx bytes\n", translatelong(ll));
+ printf(" bss reservation: %08lx bytes\n", translateint32_t(ll));
if (rdf_version == 1)
length -= 5;
if (rdf_version > 1 && reclen != 4)
break;
case RDFREC_COMMON:{
- unsigned short seg, align;
- unsigned long size;
+ uint16_t seg, align;
+ uint32_t size;
fread(&seg, 2, 1, infile);
fread(&size, 4, 1, infile);
for (ll = 0; ll < reclen - 8; ll++)
fread(buf + ll, 1, 1, infile);
printf(" common: segment %04x = %s, %ld:%d\n",
- translateshort(seg), buf, translatelong(size),
- translateshort(align));
+ translateint16_t(seg), buf, translateint32_t(size),
+ translateint16_t(align));
break;
}
}
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
- char id[7];
- long l;
+ int8_t id[7];
+ int32_t l;
uint16 s;
int verbose = 0;
- long offset;
+ int32_t offset;
int foundnullsegment = 0;
int version;
- long segmentcontentlength = 0;
+ int32_t segmentcontentlength = 0;
int nsegments = 0;
- long headerlength = 0;
- long objectlength = 0;
+ int32_t headerlength = 0;
+ int32_t objectlength = 0;
printf("RDOFF dump utility, version %s\n", PROGRAM_VERSION);
printf("RDOFF2 revision %s\n", RDOFF2_REVISION);
if (version > 1) {
fread(&l, 4, 1, infile);
- objectlength = translatelong(l);
+ objectlength = translateint32_t(l);
printf("Object content size: %ld bytes\n", objectlength);
}
fread(&l, 4, 1, infile);
- headerlength = translatelong(l);
+ headerlength = translateint32_t(l);
printf("Header (%ld bytes):\n", headerlength);
print_header(headerlength, version);
if (version == 1) {
fread(&l, 4, 1, infile);
- l = translatelong(l);
+ l = translateint32_t(l);
printf("\nText segment length = %ld bytes\n", l);
offset = 0;
while (l--) {
if (verbose) {
if (offset % 16 == 0)
printf("\n%08lx ", offset);
- printf(" %02x", (int)(unsigned char)id[0]);
+ printf(" %02x", (int)(uint8_t)id[0]);
offset++;
}
}
printf("\n\n");
fread(&l, 4, 1, infile);
- l = translatelong(l);
+ l = translateint32_t(l);
printf("Data segment length = %ld bytes\n", l);
if (verbose) {
fread(id, 1, 1, infile);
if (offset % 16 == 0)
printf("\n%08lx ", offset);
- printf(" %02x", (int)(unsigned char)id[0]);
+ printf(" %02x", (int)(uint8_t)id[0]);
offset++;
}
printf("\n");
} else {
do {
fread(&s, 2, 1, infile);
- s = translateshort(s);
+ s = translateint16_t(s);
if (!s) {
printf("\nNULL segment\n");
foundnullsegment = 1;
nsegments++;
fread(&s, 2, 1, infile);
- printf(" Number = %04X\n", (int)translateshort(s));
+ printf(" Number = %04X\n", (int)translateint16_t(s));
fread(&s, 2, 1, infile);
- printf(" Resrvd = %04X\n", (int)translateshort(s));
+ printf(" Resrvd = %04X\n", (int)translateint16_t(s));
fread(&l, 4, 1, infile);
- l = translatelong(l);
+ l = translateint32_t(l);
printf(" Length = %ld bytes\n", l);
segmentcontentlength += l;
if (verbose) {
if (offset % 16 == 0)
printf("\n%08lx ", offset);
- printf(" %02x", (int)(unsigned char)id[0]);
+ printf(" %02x", (int)(uint8_t)id[0]);
offset++;
}
}
/*
* an rdoff library is simply a sequence of RDOFF object files, each
* preceded by the name of the module, an ASCII string of up to 255
- * characters, terminated by a zero.
+ * int8_tacters, terminated by a zero.
*
* When a library is being created, special signature block is placed
* in the beginning of the file. It is a string 'RDLIB' followed by a
- * version number, then long content size and a long time stamp.
+ * version number, then int32_t content size and a int32_t time stamp.
* The module name of the signature block is '.sig'.
*
*
*
* All module names beginning with '.' are reserved for possible future
* extensions. The linker ignores all such modules, assuming they have
- * the format of a six byte type & version identifier followed by long
+ * the format of a six byte type & version identifier followed by int32_t
* content size, followed by data.
*/
* list modules
*/
-const char *usage =
+const int8_t *usage =
"usage:\n"
" rdflib x libname [extra operands]\n\n"
" where x is one of:\n"
" d - delete (module-name)\n" " t - list\n";
/* Library signature */
-const char *rdl_signature = "RDLIB2", *sig_modname = ".sig";
+const int8_t *rdl_signature = "RDLIB2", *sig_modname = ".sig";
-char **_argv;
+int8_t **_argv;
#define _ENDIANNESS 0 /* 0 for little, 1 for big */
-static void longtolocal(long *l)
+static void int32_ttolocal(int32_t *l)
{
#if _ENDIANNESS
- unsigned char t;
- unsigned char *p = (unsigned char *)l;
+ uint8_t t;
+ uint8_t *p = (uint8_t *)l;
t = p[0];
p[0] = p[3];
#endif
}
-char copybytes(FILE * fp, FILE * fp2, int n)
+int8_t copybytes(FILE * fp, FILE * fp2, int n)
{
int i, t = 0;
exit(1);
}
}
- return (char)t; /* return last char read */
+ return (int8_t)t; /* return last int8_t read */
}
-long copylong(FILE * fp, FILE * fp2)
+int32_t copyint32_t(FILE * fp, FILE * fp2)
{
- long l;
+ int32_t l;
int i, t;
- unsigned char *p = (unsigned char *)&l;
+ uint8_t *p = (uint8_t *)&l;
for (i = 0; i < 4; i++) { /* skip magic no */
t = fgetc(fp);
}
*p++ = t;
}
- longtolocal(&l);
+ int32_ttolocal(&l);
return l;
}
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
FILE *fp, *fp2 = NULL, *fptmp;
- char *p, buf[256], c;
+ int8_t *p, buf[256], c;
int i;
- long l;
+ int32_t l;
time_t t;
- char rdbuf[10];
+ int8_t rdbuf[10];
_argv = argv;
while (!feof(fp)) {
/* read name */
p = buf;
- while ((*(p++) = (char)fgetc(fp)))
+ while ((*(p++) = (int8_t)fgetc(fp)))
if (feof(fp))
break;
else
copybytes(fp, fp2, 6);
- l = copylong(fp, fp2);
+ l = copyint32_t(fp, fp2);
if (argv[1][0] == 't')
printf(" %ld bytes content\n", l);
copybytes(fp, fp2, l);
} else if ((c = copybytes(fp, fp2, 6)) >= '2') { /* version 2 or above */
- l = copylong(fp, fp2);
+ l = copyint32_t(fp, fp2);
if (argv[1][0] == 't')
printf("RDOFF%c %ld bytes content\n", c, l);
* version 1 object, so we don't have an object content
* length field.
*/
- copybytes(fp, fp2, copylong(fp, fp2)); /* header */
- copybytes(fp, fp2, copylong(fp, fp2)); /* text */
- copybytes(fp, fp2, copylong(fp, fp2)); /* data */
+ copybytes(fp, fp2, copyint32_t(fp, fp2)); /* header */
+ copybytes(fp, fp2, copyint32_t(fp, fp2)); /* text */
+ copybytes(fp, fp2, copyint32_t(fp, fp2)); /* data */
}
if (fp2)
while (!feof(fptmp)) {
/* read name */
p = buf;
- while ((*(p++) = (char)fgetc(fptmp)))
+ while ((*(p++) = (int8_t)fgetc(fptmp)))
if (feof(fptmp))
break;
/* check against desired name */
if (!strcmp(buf, argv[3])) {
fread(p = rdbuf, 1, sizeof(rdbuf), fptmp);
- l = *(long *)(p + 6);
+ l = *(int32_t *)(p + 6);
fseek(fptmp, l, SEEK_CUR);
break;
} else {
fwrite(buf, 1, strlen(buf) + 1, fp); /* module name */
if ((c = copybytes(fptmp, fp, 6)) >= '2') {
- l = copylong(fptmp, fp); /* version 2 or above */
+ l = copyint32_t(fptmp, fp); /* version 2 or above */
copybytes(fptmp, fp, l); /* entire object */
}
}
* redistributable under the licence given in the file "Licence"
* distributed in the NASM archive.
*
- * Permission to use this file in your own projects is granted, as long
+ * Permission to use this file in your own projects is granted, as int32_t
* as acknowledgement is given in an appropriate manner to its authors,
* with instructions of how to obtain a copy via ftp.
*/
extern int rdf_errno;
-rdfmodule *rdfload(const char *filename)
+rdfmodule *rdfload(const int8_t *filename)
{
rdfmodule *f;
- long bsslength = 0;
- char *hdr;
+ int32_t bsslength = 0;
+ int8_t *hdr;
rdfheaderrec *r;
f = malloc(sizeof(rdfmodule));
rdfheaderrewind(&f->f);
- f->textrel = (long)f->t;
- f->datarel = (long)f->d;
- f->bssrel = (long)f->b;
+ f->textrel = (int32_t)f->t;
+ f->datarel = (int32_t)f->d;
+ f->bssrel = (int32_t)f->b;
return f;
}
rdfheaderrec *r;
Collection imports;
symtabEnt e;
- long rel;
- unsigned char *seg;
+ int32_t rel;
+ uint8_t *seg;
rdfheaderrewind(&m->f);
collection_init(&imports);
non-portable */
switch (r->r.length) {
case 1:
- seg[r->r.offset] += (char)rel;
+ seg[r->r.offset] += (int8_t)rel;
break;
case 2:
*(uint16 *) (seg + r->r.offset) += (uint16) rel;
break;
case 4:
- *(long *)(seg + r->r.offset) += rel;
+ *(int32_t *)(seg + r->r.offset) += rel;
break;
}
break;
typedef struct RDFModuleStruct {
rdffile f; /* file structure */
- unsigned char *t, *d, *b; /* text, data, and bss segments */
- long textrel;
- long datarel;
- long bssrel;
+ uint8_t *t, *d, *b; /* text, data, and bss segments */
+ int32_t textrel;
+ int32_t datarel;
+ int32_t bssrel;
void *symtab;
} rdfmodule;
-rdfmodule *rdfload(const char *filename);
+rdfmodule *rdfload(const int8_t *filename);
int rdf_relocate(rdfmodule * m);
#endif
typedef enum { FALSE, TRUE } bool;
/** Constants **/
-const char commands[] = "adnrtx";
-const char modifiers[] = "cflouvV";
+const int8_t commands[] = "adnrtx";
+const int8_t modifiers[] = "cflouvV";
/** Global variables **/
-char *progname = "rdlar";
-char **_argv = NULL;
+int8_t *progname = "rdlar";
+int8_t **_argv = NULL;
struct {
bool createok;
bool usefname;
#define _ENDIANNESS 0 /* 0 for little, 1 for big */
/*
- * Convert long to little endian (if we were compiled on big-endian machine)
+ * Convert int32_t to little endian (if we were compiled on big-endian machine)
*/
-static void longtolocal(long *l)
+static void int32_ttolocal(int32_t *l)
{
#if _ENDIANNESS
- unsigned char t;
- unsigned char *p = (unsigned char *)l;
+ uint8_t t;
+ uint8_t *p = (uint8_t *)l;
t = p[0];
p[0] = p[3];
/*
* Print an error message and exit
*/
-void error_exit(int errcode, bool useperror, const char *fmt, ...)
+void error_exit(int errcode, bool useperror, const int8_t *fmt, ...)
{
va_list ap;
/*
* Fill in and write a header
*/
-void put_header(struct rdlm_hdr *hdr, FILE * libfp, char *modname)
+void put_header(struct rdlm_hdr *hdr, FILE * libfp, int8_t *modname)
{
int n = 0;
}
/*
- * Copy n bytes from one file to another and return last character read.
+ * Copy n bytes from one file to another and return last int8_tacter read.
*/
-char copybytes(FILE * fp, FILE * fp2, int n)
+int8_t copybytes(FILE * fp, FILE * fp2, int n)
{
int i, t = 0;
if (fputc(t, fp2) == EOF)
error_exit(1, FALSE, "write error");
}
- return (char)t;
+ return (int8_t)t;
}
/*
- * Copy unsigned long from one file to another.
- * Return local presentation of long.
+ * Copy uint32_t from one file to another.
+ * Return local presentation of int32_t.
*/
-long copylong(FILE * fp, FILE * fp2)
+int32_t copyint32_t(FILE * fp, FILE * fp2)
{
- long l;
+ int32_t l;
int i, t;
- unsigned char *p = (unsigned char *)&l;
+ uint8_t *p = (uint8_t *)&l;
for (i = 0; i < 4; i++) {
t = fgetc(fp);
error_exit(1, FALSE, "write error");
*p++ = t;
}
- longtolocal(&l);
+ int32_ttolocal(&l);
return l;
}
/*
* Create a new library
*/
-int create_library(char *libname)
+int create_library(int8_t *libname)
{
FILE *libfp;
struct rdlm_hdr hdr;
/*
* Add a module to the library
*/
-int add_module(FILE * libfp, const char *fname, char *modname)
+int add_module(FILE * libfp, const int8_t *fname, int8_t *modname)
{
FILE *modfp;
struct rdlm_hdr hdr = { RDLMMAG, 0, 0, 0, 0, 0, 0 };
/*
* Main
*/
-int main(int argc, char *argv[])
+int main(int argc, int8_t *argv[])
{
FILE *libfp, *tmpfp, *modfp = NULL;
struct stat finfo;
struct rdlm_hdr hdr;
- char buf[MAXMODNAMELEN], *p = NULL;
- char c;
+ int8_t buf[MAXMODNAMELEN], *p = NULL;
+ int8_t c;
int i;
progname = argv[0];
if (options.verbose) {
printf("%ld bytes", hdr.size);
}
- putchar('\n');
+ putint8_t('\n');
}
copybytes(libfp, modfp, hdr.size);
#define MAXMODNAMELEN 256 /* Maximum length of module name */
struct rdlm_hdr {
- unsigned long magic; /* Must be RDLAMAG */
- unsigned long hdrsize; /* Header size + sizeof(module_name) */
- unsigned long date; /* Creation date */
- unsigned long owner; /* UID */
- unsigned long group; /* GID */
- unsigned long mode; /* File mode */
- unsigned long size; /* File size */
+ uint32_t magic; /* Must be RDLAMAG */
+ uint32_t hdrsize; /* Header size + sizeof(module_name) */
+ uint32_t date; /* Creation date */
+ uint32_t owner; /* UID */
+ uint32_t group; /* GID */
+ uint32_t mode; /* File mode */
+ uint32_t size; /* File size */
/* NULL-terminated module name immediately follows */
};
int rdl_error = 0;
-char *rdl_errors[5] = {
+int8_t *rdl_errors[5] = {
"no error", "could not open file", "invalid file structure",
"file contains modules of an unsupported RDOFF version",
"module not found"
};
-int rdl_verify(const char *filename)
+int rdl_verify(const int8_t *filename)
{
FILE *fp = fopen(filename, "rb");
- char buf[257];
+ int8_t buf[257];
int i;
- long length;
- static char lastverified[256];
+ int32_t length;
+ static int8_t lastverified[256];
static int lastresult = -1;
if (lastresult != -1 && !strcmp(filename, lastverified))
/*
* A special module, eg a signature block or a directory.
* Format of such a module is defined to be:
- * six char type identifier
- * long count bytes content
+ * six int8_t type identifier
+ * int32_t count bytes content
* content
* so we can handle it uniformaly with RDOFF2 modules.
*/
return lastresult = 0; /* library in correct format */
}
-int rdl_open(struct librarynode *lib, const char *name)
+int rdl_open(struct librarynode *lib, const int8_t *name)
{
int i = rdl_verify(name);
if (i)
free(lib->name);
}
-int rdl_searchlib(struct librarynode *lib, const char *label, rdffile * f)
+int rdl_searchlib(struct librarynode *lib, const int8_t *label, rdffile * f)
{
- char buf[512];
+ int8_t buf[512];
int i, t;
void *hdr;
rdfheaderrec *r;
- long l;
+ int32_t l;
rdl_error = 0;
lib->referenced++;
int rdl_openmodule(struct librarynode *lib, int moduleno, rdffile * f)
{
- char buf[512];
+ int8_t buf[512];
int i, cmod, t;
- long length;
+ int32_t length;
lib->referenced++;
return rdl_error = 4; /* module not found */
}
-void rdl_perror(const char *apname, const char *filename)
+void rdl_perror(const int8_t *apname, const int8_t *filename)
{
if (rdl_error >= 16)
rdfperror(apname, filename);
*/
struct librarynode {
- char *name;
+ int8_t *name;
FILE *fp; /* initialised to NULL - always check */
int referenced; /* & open if required. Close afterwards */
struct librarynode *next; /* if ! referenced. */
#define RDL_EVERSION 3
#define RDL_ENOTFOUND 4
-int rdl_verify(const char *filename);
-int rdl_open(struct librarynode *lib, const char *filename);
-int rdl_searchlib(struct librarynode *lib, const char *label, rdffile * f);
+int rdl_verify(const int8_t *filename);
+int rdl_open(struct librarynode *lib, const int8_t *filename);
+int rdl_searchlib(struct librarynode *lib, const int8_t *label, rdffile * f);
int rdl_openmodule(struct librarynode *lib, int module, rdffile * f);
-void rdl_perror(const char *apname, const char *filename);
+void rdl_perror(const int8_t *apname, const int8_t *filename);
* redistributable under the licence given in the file "Licence"
* distributed in the NASM archive.
*
- * Permission to use this file in your own projects is granted, as long
+ * Permission to use this file in your own projects is granted, as int32_t
* as acknowledgement is given in an appropriate manner to its authors,
* with instructions of how to obtain a copy via ftp.
*/
/* ========================================================================
* Code for memory buffers (for delayed writing of header until we know
- * how long it is).
+ * how int32_t it is).
* ======================================================================== */
memorybuffer *newmembuf()
void membufwrite(memorybuffer * const b, void *data, int bytes)
{
uint16 w;
- long l;
+ int32_t l;
if (b->next) { /* memory buffer full - use next buffer */
membufwrite(b->next, data, bytes);
switch (bytes) {
case -4: /* convert to little-endian */
- l = *(long *)data;
+ l = *(int32_t *)data;
b->buffer[b->length++] = l & 0xFF;
l >>= 8;
b->buffer[b->length++] = l & 0xFF;
default:
while (bytes--) {
- b->buffer[b->length++] = *(*(unsigned char **)&data);
+ b->buffer[b->length++] = *(*(uint8_t **)&data);
- (*(unsigned char **)&data)++;
+ (*(uint8_t **)&data)++;
}
break;
}
========================================================================= */
/*
- * translatelong() and translateshort()
+ * translateint32_t() and translateint16_t()
*
* translate from little endian to local representation
*/
-long translatelong(long in)
+int32_t translateint32_t(int32_t in)
{
- long r;
- unsigned char *i;
+ int32_t r;
+ uint8_t *i;
- i = (unsigned char *)∈
+ i = (uint8_t *)∈
r = i[3];
r = (r << 8) + i[2];
r = (r << 8) + i[1];
return r;
}
-uint16 translateshort(uint16 in)
+uint16 translateint16_t(uint16 in)
{
uint16 r;
- unsigned char *i;
+ uint8_t *i;
- i = (unsigned char *)∈
+ i = (uint8_t *)∈
r = (i[1] << 8) + i[0];
return r;
}
/* Segment types */
-static char *knownsegtypes[8] = {
+static int8_t *knownsegtypes[8] = {
"NULL", "text", "data", "object comment",
"linked comment", "loader comment",
"symbolic debug", "line number debug"
};
/* Get a textual string describing the segment type */
-char *translatesegmenttype(uint16 type)
+int8_t *translatesegmenttype(uint16 type)
{
if (type < 8)
return knownsegtypes[type];
}
/* This signature is written to the start of RDOFF files */
-const char *RDOFFId = RDOFF2_SIGNATURE;
+const int8_t *RDOFFId = RDOFF2_SIGNATURE;
/* Error messages. Must correspond to the codes defined in rdoff.h */
-const char *rdf_errors[11] = {
+const int8_t *rdf_errors[11] = {
/* 0 */ "no error occurred",
/* 1 */ "could not open file",
/* 2 */ "invalid file format",
The library functions
======================================================================== */
-int rdfopen(rdffile * f, const char *name)
+int rdfopen(rdffile * f, const int8_t *name)
{
FILE *fp;
return rdfopenhere(f, fp, NULL, name);
}
-int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const char *name)
+int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const int8_t *name)
{
- char buf[8];
- long initpos;
- long l;
+ int8_t buf[8];
+ int32_t initpos;
+ int32_t l;
uint16 s;
- if (translatelong(0x01020304) != 0x01020304) {
+ if (translateint32_t(0x01020304) != 0x01020304) {
/* fix this to be portable! */
fputs("*** this program requires a little endian machine\n",
stderr);
- fprintf(stderr, "01020304h = %08lxh\n", translatelong(0x01020304));
+ fprintf(stderr, "01020304h = %08lxh\n", translateint32_t(0x01020304));
exit(3);
}
}
f->header_ofs = ftell(f->fp);
- f->eof_offset = f->header_ofs + translatelong(l) - 4;
+ f->eof_offset = f->header_ofs + translateint32_t(l) - 4;
if (fseek(f->fp, f->header_len, SEEK_CUR)) {
fclose(f->fp);
/*
* Print the message for last error (from rdf_errno)
*/
-void rdfperror(const char *app, const char *name)
+void rdfperror(const int8_t *app, const int8_t *name)
{
fprintf(stderr, "%s:%s: %s\n", app, name, rdf_errors[rdf_errno]);
if (rdf_errno == RDF_ERR_OPEN || rdf_errno == RDF_ERR_READ) {
*/
int rdfloadseg(rdffile * f, int segment, void *buffer)
{
- long fpos, slen;
+ int32_t fpos, slen;
switch (segment) {
case RDOFF_HEADER:
return 0;
}
-int rdfaddsegment(rdf_headerbuf * h, long seglength)
+int rdfaddsegment(rdf_headerbuf * h, int32_t seglength)
{
h->nsegments++;
h->seglength += seglength;
int rdfwriteheader(FILE * fp, rdf_headerbuf * h)
{
- long l, l2;
+ int32_t l, l2;
fwrite(RDOFFId, 1, strlen(RDOFFId), fp);
l = membuflength(h->buf);
l2 = l + 14 + 10 * h->nsegments + h->seglength;
- l = translatelong(l);
- l2 = translatelong(l2);
+ l = translateint32_t(l);
+ l2 = translateint32_t(l2);
fwrite(&l2, 4, 1, fp); /* object length */
fwrite(&l, 4, 1, fp); /* header length */
* redistributable under the licence given in the file "Licence"
* distributed in the NASM archive.
*
- * Permission to use this file in your own projects is granted, as long
+ * Permission to use this file in your own projects is granted, as int32_t
* as acknowledgement is given in an appropriate manner to its authors,
* with instructions of how to obtain a copy via ftp.
*/
*/
/* Type definitions */
-typedef unsigned long uint32;
-typedef unsigned short uint16;
-typedef unsigned char byte;
+typedef uint32_t uint32;
+typedef uint16_t uint16;
+typedef uint8_t byte;
typedef unsigned int bool;
/* RDOFF format revision (currently used only when printing the version) */
/*
* Generic record - contains the type and length field, plus a 128 byte
- * char array 'data'
+ * int8_t array 'data'
*/
struct GenericRec {
byte type;
byte reclen;
- char data[128];
+ int8_t data[128];
};
/*
byte segment; /* only 0 for code, or 1 for data supported,
but add 64 for relative refs (ie do not require
reloc @ loadtime, only linkage) */
- long offset; /* from start of segment in which reference is loc'd */
+ int32_t offset; /* from start of segment in which reference is loc'd */
byte length; /* 1 2 or 4 bytes */
uint16 refseg; /* segment to which reference refers to */
};
records - label is assumed to be at offset zero
in this segment, so linker must fix up with offset
of segment and of offset within segment */
- char label[EXIM_LABEL_MAX]; /* zero terminated, should be written to file
+ int8_t label[EXIM_LABEL_MAX]; /* zero terminated, should be written to file
until the zero, but not after it */
};
byte reclen; /* content length */
byte flags; /* SYM_* flags (see below) */
byte segment; /* segment referred to (0/1/2) */
- long offset; /* offset within segment */
- char label[EXIM_LABEL_MAX]; /* zero terminated as in import */
+ int32_t offset; /* offset within segment */
+ int8_t label[EXIM_LABEL_MAX]; /* zero terminated as in import */
};
/*
struct DLLRec {
byte type; /* must be 4 */
byte reclen; /* content length */
- char libname[MODLIB_NAME_MAX]; /* name of library to link with at load time */
+ int8_t libname[MODLIB_NAME_MAX]; /* name of library to link with at load time */
};
/*
struct BSSRec {
byte type; /* must be 5 */
byte reclen; /* content length */
- long amount; /* number of bytes BSS to reserve */
+ int32_t amount; /* number of bytes BSS to reserve */
};
/*
struct ModRec {
byte type; /* must be 8 */
byte reclen; /* content length */
- char modname[MODLIB_NAME_MAX]; /* module name */
+ int8_t modname[MODLIB_NAME_MAX]; /* module name */
};
/*
byte type; /* must be 10 */
byte reclen; /* equals 7+label length */
uint16 segment; /* segment number */
- long size; /* size of common variable */
+ int32_t size; /* size of common variable */
uint16 align; /* alignment (power of two) */
- char label[EXIM_LABEL_MAX]; /* zero terminated as in import */
+ int8_t label[EXIM_LABEL_MAX]; /* zero terminated as in import */
};
/* Flags for ExportRec */
/* Some systems don't define this automatically */
#if !defined(strdup)
-extern char *strdup(const char *);
+extern int8_t *strdup(const int8_t *);
#endif
typedef union RDFHeaderRec {
- char type; /* invariant throughout all below */
+ int8_t type; /* invariant throughout all below */
struct GenericRec g; /* type 0 */
struct RelocRec r; /* type == 1 / 6 */
struct ImportRec i; /* type == 2 / 7 */
uint16 type;
uint16 number;
uint16 reserved;
- long length;
+ int32_t length;
/* information built up here */
- long offset;
+ int32_t offset;
byte *data; /* pointer to segment data if it exists in memory */
};
typedef struct RDFFileInfo {
FILE *fp; /* file descriptor; must be open to use this struct */
int rdoff_ver; /* should be 1; any higher => not guaranteed to work */
- long header_len;
- long header_ofs;
+ int32_t header_len;
+ int32_t header_ofs;
byte *header_loc; /* keep location of header */
- long header_fp; /* current location within header for reading */
+ int32_t header_fp; /* current location within header for reading */
struct SegmentHeaderRec seg[RDF_MAXSEGS];
int nsegs;
- long eof_offset; /* offset of the first byte beyond the end of this
+ int32_t eof_offset; /* offset of the first byte beyond the end of this
module */
- char *name; /* name of module in libraries */
+ int8_t *name; /* name of module in libraries */
int *refcount; /* pointer to reference count on file, or NULL */
} rdffile;
typedef struct {
memorybuffer *buf; /* buffer containing header records */
int nsegments; /* number of segments to be written */
- long seglength; /* total length of all the segments */
+ int32_t seglength; /* total length of all the segments */
} rdf_headerbuf;
/* segments used by RDOFF, understood by rdoffloadseg */
};
/* utility functions */
-long translatelong(long in);
-uint16 translateshort(uint16 in);
-char *translatesegmenttype(uint16 type);
+int32_t translateint32_t(int32_t in);
+uint16 translateint16_t(uint16 in);
+int8_t *translatesegmenttype(uint16 type);
/* RDOFF file manipulation functions */
-int rdfopen(rdffile * f, const char *name);
-int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const char *name);
+int rdfopen(rdffile * f, const int8_t *name);
+int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const int8_t *name);
int rdfclose(rdffile * f);
int rdffindsegment(rdffile * f, int segno);
int rdfloadseg(rdffile * f, int segment, void *buffer);
rdfheaderrec *rdfgetheaderrec(rdffile * f); /* returns static storage */
void rdfheaderrewind(rdffile * f); /* back to start of header */
-void rdfperror(const char *app, const char *name);
+void rdfperror(const int8_t *app, const int8_t *name);
/* functions to write a new RDOFF header to a file -
use rdfnewheader to allocate a header, rdfaddheader to add records to it,
rdfaddsegment to notify the header routines that a segment exists, and
- to tell it how long the segment will be.
+ to tell it how int32_t the segment will be.
rdfwriteheader to write the file id, object length, and header
to a file, and then rdfdoneheader to dispose of the header */
rdf_headerbuf *rdfnewheader(void);
int rdfaddheader(rdf_headerbuf * h, rdfheaderrec * r);
-int rdfaddsegment(rdf_headerbuf * h, long seglength);
+int rdfaddsegment(rdf_headerbuf * h, int32_t seglength);
int rdfwriteheader(FILE * fp, rdf_headerbuf * h);
void rdfdoneheader(rdf_headerbuf * h);
#include "rdfload.h"
#include "symtab.h"
-typedef int (*main_fn) (int, char **); /* Main function prototype */
+typedef int (*main_fn) (int, int8_t **); /* Main function prototype */
-int main(int argc, char **argv)
+int main(int argc, int8_t **argv)
{
rdfmodule *m;
main_fn code;
struct segtabnode {
int localseg;
int destseg;
- long offset;
+ int32_t offset;
struct segtabnode *left;
struct segtabnode *right;
}
void descend_tree_add(struct segtabnode **node,
- int localseg, int destseg, long offset)
+ int localseg, int destseg, int32_t offset)
{
struct segtabnode *n;
}
}
-void add_seglocation(segtab * root, int localseg, int destseg, long offset)
+void add_seglocation(segtab * root, int localseg, int destseg, int32_t offset)
{
descend_tree_add((struct segtabnode **)root, localseg, destseg,
offset);
}
int get_seglocation(segtab * root, int localseg, int *destseg,
- long *offset)
+ int32_t *offset)
{
struct segtabnode *n = (struct segtabnode *)*root;
typedef void *segtab;
void init_seglocations(segtab * r);
-void add_seglocation(segtab * r, int localseg, int destseg, long offset);
-int get_seglocation(segtab * r, int localseg, int *destseg, long *offset);
+void add_seglocation(segtab * r, int localseg, int destseg, int32_t offset);
+int get_seglocation(segtab * r, int localseg, int *destseg, int32_t *offset);
void done_seglocations(segtab * r);
}
/* ------------------------------------- */
-symtabEnt *symtabFind(void *stab, const char *name)
+symtabEnt *symtabFind(void *stab, const int8_t *name)
{
symtab mytab = (symtab) stab;
int slot = slotnum(name);
{
symtab mytab = (symtab) stab;
int i;
- char *SegNames[3] = { "code", "data", "bss" };
+ int8_t *SegNames[3] = { "code", "data", "bss" };
fprintf(of, "Symbol table is ...\n");
for (i = 0; i < SYMTABSIZE; ++i) {
*/
typedef struct {
- char *name;
+ int8_t *name;
int segment;
- long offset;
- long flags;
+ int32_t offset;
+ int32_t flags;
} symtabEnt;
void *symtabNew(void);
void symtabDone(void *symtab);
void symtabInsert(void *symtab, symtabEnt * ent);
-symtabEnt *symtabFind(void *symtab, const char *name);
+symtabEnt *symtabFind(void *symtab, const int8_t *name);
void symtabDump(void *symtab, FILE * of);
# A * means the line should be repeated for each value from 0 to 7
#
+# Legacy Registers
+# 000-007 = 8-bit Registers
+# 010-017 = 16-bit Registers
+# 020-027 = 32-bit Registers
+
+# System Registers
+# 100-107 = Segment Registers
+# 110-127 = Control Registers
+# 130-147 = Debug Registers
+# 150-167 = Test Registers
+
+# Legacy Extended Registers
+# 200-207 = FPU Registers
+# 210-217 = MMX Registers
+# 220-227 = XMM Registers (XMM0-XMM7)
+
+# x64 Extended Registers
+# 400-407 = 8-bit Extensions (SIL/DIL/BPL/SPL)
+# 410-417 = 8-bit Registers (R8B-R15B)
+# 420-427 = 16-bit Registers (R8W-R15W)
+# 430-437 = 32-bit Registers (R8D-R15D)
+# 440-457 = 64-bit Registers (RAX-RDI+R8-R15)
+# 460-467 = XMM Extended Registers (XMM8-XMM15)
+
+# Special Registers
+# 0500 = RIP (for RIP-relative Addressing)
+
+
# General-purpose registers
-al REG_AL reg8 0
-ah REG8 reg8 4
-ax REG_AX reg16 0
-eax REG_EAX reg32 0
-bl REG8 reg8 3
-bh REG8 reg8 7
-bx REG16 reg16 3
-ebx REG32 reg32 3
-cl REG_CL reg8 1
-ch REG8 reg8 5
-cx REG_CX reg16 1
-ecx REG_ECX reg32 1
-dl REG_DL reg8 2
-dh REG8 reg8 6
-dx REG_DX reg16 2
-edx REG_EDX reg32 2
-sp REG16 reg16 4
-esp REG32 reg32 4
-bp REG16 reg16 5
-ebp REG32 reg32 5
-si REG16 reg16 6
-esi REG32 reg32 6
-di REG16 reg16 7
-edi REG32 reg32 7
+al REG_AL reg8 0000
+ah REG8 reg8 0004
+ax REG_AX reg16 0010
+eax REG_EAX reg32 0020
+rax REG_RAX reg64 0440
+bl REG8 reg8 0003
+bh REG8 reg8 0007
+bx REG16 reg16 0013
+ebx REG32 reg32 0023
+rbx REG64 reg64 0443
+cl REG_CL reg8 0001
+ch REG8 reg8 0005
+cx REG_CX reg16 0011
+ecx REG_ECX reg32 0021
+rcx REG_RCX reg64 0441
+dl REG_DL reg8 0002
+dh REG8 reg8 0006
+dx REG_DX reg16 0012
+edx REG_EDX reg32 0022
+rdx REG_RDX reg64 0442
+spl REG8 reg8 0404
+sp REG16 reg16 0014
+esp REG32 reg32 0024
+rsp REG64 reg64 0444
+bpl REG8 reg8 0405
+bp REG16 reg16 0015
+ebp REG32 reg32 0025
+rbp REG64 reg64 0445
+sil REG8 reg8 0406
+si REG16 reg16 0016
+esi REG32 reg32 0026
+rsi REG64 reg64 0446
+dil REG8 reg8 0407
+di REG16 reg16 0017
+edi REG32 reg32 0027
+rdi REG64 reg64 0447
+r8b REG8 reg8 0410
+r8w REG16 reg16 0420
+r8d REG32 reg32 0430
+r8 REG64 reg64 0450
+r9b REG8 reg8 0411
+r9w REG16 reg16 0421
+r9d REG32 reg32 0431
+r9 REG64 reg64 0451
+r10b REG8 reg8 0412
+r10w REG16 reg16 0422
+r10d REG32 reg32 0432
+r10 REG64 reg64 0452
+r11b REG8 reg8 0413
+r11w REG16 reg16 0423
+r11d REG32 reg32 0433
+r11 REG64 reg64 0453
+r12b REG8 reg8 0414
+r12w REG16 reg16 0424
+r12d REG32 reg32 0434
+r12 REG64 reg64 0454
+r13b REG8 reg8 0415
+r13w REG16 reg16 0425
+r13d REG32 reg32 0435
+r13 REG64 reg64 0455
+r14b REG8 reg8 0416
+r14w REG16 reg16 0426
+r14d REG32 reg32 0436
+r14 REG64 reg64 0456
+r15b REG8 reg8 0417
+r15w REG16 reg16 0427
+r15d REG32 reg32 0437
+r15 REG64 reg64 0457
# Segment registers
-cs REG_CS sreg 1
-ds REG_DESS sreg 3
-es REG_DESS sreg 0
-ss REG_DESS sreg 2
-fs REG_FSGS sreg 4
-gs REG_FSGS sreg 5
-segr6 REG_SEG67 sreg 6
-segr7 REG_SEG67 sreg 7
+cs REG_CS sreg 0101
+ds REG_DESS sreg 0103
+es REG_DESS sreg 0100
+ss REG_DESS sreg 0102
+fs REG_FSGS sreg 0104
+gs REG_FSGS sreg 0105
+segr6 REG_SEG67 sreg 0106
+segr7 REG_SEG67 sreg 0107
# Control registers
-cr* REG_CREG creg *
+cr0 REG_CREG creg 0110
+cr1 REG_CREG creg 0111
+cr2 REG_CREG creg 0112
+cr3 REG_CREG creg 0113
+cr4 REG_CREG creg 0114
+cr5 REG_CREG creg 0115
+cr6 REG_CREG creg 0116
+cr7 REG_CREG creg 0127
+cr8 REG_C8REG creg 0120
+cr9 REG_CREG creg 0121
+cr10 REG_CREG creg 0122
+cr11 REG_CREG creg 0123
+cr12 REG_CREG creg 0124
+cr13 REG_CREG creg 0125
+cr14 REG_CREG creg 0126
+cr15 REG_CREG creg 0127
# Debug registers
-dr* REG_DREG dreg *
+dr0 REG_DREG dreg 0130
+dr1 REG_DREG dreg 0131
+dr2 REG_DREG dreg 0132
+dr3 REG_DREG dreg 0133
+dr4 REG_DREG dreg 0134
+dr5 REG_DREG dreg 0135
+dr6 REG_DREG dreg 0136
+dr7 REG_DREG dreg 0137
+dr8 REG_DREG dreg 0140
+dr9 REG_DREG dreg 0141
+dr10 REG_DREG dreg 0142
+dr11 REG_DREG dreg 0143
+dr12 REG_DREG dreg 0144
+dr13 REG_DREG dreg 0145
+dr14 REG_DREG dreg 0146
+dr15 REG_DREG dreg 0147
# Test registers
-tr* REG_TREG treg *
+tr0 REG_TREG treg 0150
+tr1 REG_TREG treg 0151
+tr2 REG_TREG treg 0152
+tr3 REG_TREG treg 0153
+tr4 REG_TREG treg 0154
+tr5 REG_TREG treg 0155
+tr6 REG_TREG treg 0156
+tr7 REG_TREG treg 0157
# Floating-point registers
-st0 FPU0 fpureg 0
-st1 FPUREG fpureg 1
-st2 FPUREG fpureg 2
-st3 FPUREG fpureg 3
-st4 FPUREG fpureg 4
-st5 FPUREG fpureg 5
-st6 FPUREG fpureg 6
-st7 FPUREG fpureg 7
+st0 FPU0 fpureg 0200
+st1 FPUREG fpureg 0201
+st2 FPUREG fpureg 0202
+st3 FPUREG fpureg 0203
+st4 FPUREG fpureg 0204
+st5 FPUREG fpureg 0205
+st6 FPUREG fpureg 0206
+st7 FPUREG fpureg 0207
# MMX registers
-mm* MMXREG mmxreg *
+mm0 MMXREG mmxreg 0220
+mm1 MMXREG mmxreg 0221
+mm2 MMXREG mmxreg 0222
+mm3 MMXREG mmxreg 0223
+mm4 MMXREG mmxreg 0224
+mm5 MMXREG mmxreg 0225
+mm6 MMXREG mmxreg 0226
+mm7 MMXREG mmxreg 0227
+
# SSE registers
-xmm* XMMREG xmmreg *
+xmm0 XMMREG xmmreg 0240
+xmm1 XMMREG xmmreg 0241
+xmm2 XMMREG xmmreg 0242
+xmm3 XMMREG xmmreg 0243
+xmm4 XMMREG xmmreg 0244
+xmm5 XMMREG xmmreg 0245
+xmm6 XMMREG xmmreg 0246
+xmm7 XMMREG xmmreg 0247
+xmm8 XMMREG xmmreg 0460
+xmm9 XMMREG xmmreg 0461
+xmm10 XMMREG xmmreg 0462
+xmm11 XMMREG xmmreg 0463
+xmm12 XMMREG xmmreg 0464
+xmm13 XMMREG xmmreg 0465
+xmm14 XMMREG xmmreg 0466
+xmm15 XMMREG xmmreg 0467
+
+# Special registers
+rip REG_RIP ripreg 0500
my($line) = @_;
my @v;
- if ( $line !~ /^\s*(\S+)\s*(\S+)\s*(\S+)\s*([0-7])\s*$/ ) {
+ if ( $line !~ /^\s*(\S+)\s*(\S+)\s*(\S+)\s*([0-9]+)\s*$/ ) {
die "regs.dat:$nline: invalid input\n";
}
$reg = $1;
$attach = ''; $ch = ',';
}
print " REG_ENUM_LIMIT\n";
- print "};\n";
+ print "};\n\n";
+ foreach $reg ( sort(keys(%regs)) ) {
+ print "#define REG_NUM_\U${reg} $regvals{$reg}\n";
+ }
+ print "\n";
} elsif ( $fmt eq 'c' ) {
# Output regs.c
print "/* automatically generated from $file - do not edit */\n";
- print "static const char *reg_names[] = "; $ch = '{';
+ print "static const int8_t *reg_names[] = "; $ch = '{';
# This one has no dummy entry for 0
foreach $reg ( sort(keys(%regs)) ) {
print "$ch\n \"${reg}\"";
} elsif ( $fmt eq 'fc' ) {
# Output regflags.c
print "/* automatically generated from $file - do not edit */\n";
- print "static const long reg_flags[] = {\n";
+ print "static const int32_t reg_flags[] = {\n";
print " 0"; # Dummy entry for 0
foreach $reg ( sort(keys(%regs)) ) {
print ",\n ", $regs{$reg}; # Print the class of the register
; here, not all of them are: the user-level form of a format-specific
; directive should be defined in the module for that directive.
-; These two need to be defined, though the actual definitions will
+; These three need to be defined, though the actual definitions will
; be constantly updated during preprocessing.
%define __FILE__
%define __LINE__
+%define __BITS__
%define __SECT__ ; it ought to be defined, even if as nothing
%imacro use32 0.nolist
[bits 32]
%endmacro
+%imacro use64 0.nolist
+[bits 64]
+%endmacro
%imacro global 1-*.nolist
%rep %0
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
+#include <inttypes.h>
#include "sync.h"
*/
static struct Sync {
- unsigned long pos;
- unsigned long length;
+ uint32_t pos;
+ uint32_t length;
} *synx;
static int nsynx;
nsynx = 0;
}
-void add_sync(unsigned long pos, unsigned long length)
+void add_sync(uint32_t pos, uint32_t length)
{
int i;
}
}
-unsigned long next_sync(unsigned long position, unsigned long *length)
+uint32_t next_sync(uint32_t position, uint32_t *length)
{
while (nsynx > 0 && synx[1].pos + synx[1].length <= position) {
int i, j;
#define NASM_SYNC_H
void init_sync(void);
-void add_sync(unsigned long position, unsigned long length);
-unsigned long next_sync(unsigned long position, unsigned long *length);
+void add_sync(uint32_t position, uint32_t length);
+uint32_t next_sync(uint32_t position, uint32_t *length);
#endif
*/
#include <stdio.h>
+#include <inttypes.h>
-extern int lrotate(long, int);
+extern int lrotate(int32_t, int);
extern void greet(void);
-extern char asmstr[];
+extern int8_t asmstr[];
extern void *selfptr;
extern void *textptr;
extern int integer, commvar;
#include <stdio.h>
-extern int lrotate(long, int);
+extern int lrotate(int32_t, int);
extern void greet(void);
-extern char asmstr[];
+extern int8_t asmstr[];
extern void *selfptr;
extern void *textptr;
extern int integer, commvar;
#include <stdio.h>
-extern int lrotate(long, int);
+extern int lrotate(int32_t, int);
extern void greet(void);
-extern char asmstr[];
+extern int8_t asmstr[];
extern void *selfptr;
extern void *textptr;
extern int integer, commvar;
#include <stdio.h>
-char text[] = "hello, world\n";
+int8_t text[] = "hello, world\n";
-extern void function(char *);
+extern void function(int8_t *);
extern int bsssym, commvar;
extern void *selfptr;
extern void *selfptr2;
int main(void)
{
printf("these should be identical: %p, %p\n",
- (long)selfptr, (long)&selfptr);
+ (int32_t)selfptr, (int32_t)&selfptr);
printf("these should be equivalent but different: %p, %p\n",
- (long)selfptr2, (long)&selfptr2);
+ (int32_t)selfptr2, (int32_t)&selfptr2);
printf("you should see \"hello, world\" twice:\n");
bsssym = 0xF00D;
commvar = 0xD00F;
projects / platform / upstream / nasm.git / commitdiff