laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/include/disp8.h

@@ -0,0 +1,45 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * disp8.h   header file for disp8.c
+ */
+
+#ifndef NASM_DISP8_H
+#define NASM_DISP8_H
+
+#include "nasm.h"
+
+uint8_t get_disp8N(insn *ins);
+bool is_disp8n(operand *input, insn *ins, int8_t *compdisp);
+#endif  /* NASM_DISP8_H */

data/vendor/repo.or.cz/nasm/include/error.h

@@ -0,0 +1,135 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Error reporting functions for the assembler
+ */
+
+#ifndef NASM_ERROR_H
+#define NASM_ERROR_H 1
+
+#include "compiler.h"
+
+/*
+ * An error reporting function should look like this.
+ */
+void printf_func(2, 3) nasm_error(int severity, const char *fmt, ...);
+no_return printf_func(2, 3) nasm_fatal(int flags, const char *fmt, ...);
+no_return printf_func(2, 3) nasm_panic(int flags, const char *fmt, ...);
+no_return nasm_panic_from_macro(const char *file, int line);
+#define panic() nasm_panic_from_macro(__FILE__, __LINE__);
+
+typedef void (*vefunc) (int severity, const char *fmt, va_list ap);
+extern vefunc nasm_verror;
+static inline vefunc nasm_set_verror(vefunc ve)
+{
+    vefunc old_verror = nasm_verror;
+    nasm_verror = ve;
+    return old_verror;
+}
+
+/*
+ * These are the error severity codes which get passed as the first
+ * argument to an efunc.
+ */
+
+#define ERR_DEBUG       0x00000000      /* put out debugging message */
+#define ERR_WARNING     0x00000001      /* warn only: no further action */
+#define ERR_NONFATAL    0x00000002      /* terminate assembly after phase */
+#define ERR_FATAL       0x00000006      /* instantly fatal: exit with error */
+#define ERR_PANIC       0x00000007      /* internal error: panic instantly
+                                         * and dump core for reference */
+#define ERR_MASK        0x00000007      /* mask off the above codes */
+#define ERR_NOFILE      0x00000010      /* don't give source file name/line */
+#define ERR_USAGE       0x00000020      /* print a usage message */
+#define ERR_PASS1       0x00000040      /* only print this error on pass one */
+#define ERR_PASS2       0x00000080
+
+#define ERR_NO_SEVERITY 0x00000100      /* suppress printing severity */
+#define ERR_PP_PRECOND	0x00000200	/* for preprocessor use */
+#define ERR_PP_LISTMACRO 0x00000400	/* from preproc->error_list_macros() */
+
+/*
+ * These codes define specific types of suppressible warning.
+ */
+
+#define ERR_WARN_MASK   0xFFFFF000      /* the mask for this feature */
+#define ERR_WARN_SHR    12              /* how far to shift right */
+
+#define WARN(x)         ((x) << ERR_WARN_SHR)
+#define WARN_IDX(x)     (((x) & ERR_WARN_MASK) >> ERR_WARN_SHR)
+
+#define ERR_WARN_OTHER          WARN( 0) /* any noncategorized warning */
+#define ERR_WARN_MNP            WARN( 1) /* macro-num-parameters warning */
+#define ERR_WARN_MSR            WARN( 2) /* macro self-reference */
+#define ERR_WARN_MDP            WARN( 3) /* macro default parameters check */
+#define ERR_WARN_OL             WARN( 4) /* orphan label (no colon, and
+                                          * alone on line) */
+#define ERR_WARN_NOV            WARN( 5) /* numeric overflow */
+#define ERR_WARN_GNUELF         WARN( 6) /* using GNU ELF extensions */
+#define ERR_WARN_FL_OVERFLOW    WARN( 7) /* FP overflow */
+#define ERR_WARN_FL_DENORM      WARN( 8) /* FP denormal */
+#define ERR_WARN_FL_UNDERFLOW   WARN( 9) /* FP underflow */
+#define ERR_WARN_FL_TOOLONG     WARN(10) /* FP too many digits */
+#define ERR_WARN_USER           WARN(11) /* %warning directives */
+#define ERR_WARN_LOCK		WARN(12) /* bad LOCK prefixes */
+#define ERR_WARN_HLE		WARN(13) /* bad HLE prefixes */
+#define ERR_WARN_BND		WARN(14) /* bad BND prefixes */
+#define ERR_WARN_ZEXTRELOC	WARN(15) /* relocation zero-extended */
+#define ERR_WARN_PTR		WARN(16) /* not a NASM keyword */
+#define ERR_WARN_BAD_PRAGMA	WARN(17) /* malformed pragma */
+#define ERR_WARN_UNKNOWN_PRAGMA	WARN(18) /* unknown pragma */
+#define ERR_WARN_NOTMY_PRAGMA	WARN(19) /* pragma inapplicable */
+#define ERR_WARN_UNK_WARNING	WARN(20) /* unknown warning */
+
+/* The "all" warning acts as a global switch, it must come last */
+#define ERR_WARN_ALL            21 /* Do not use WARN() here */
+
+struct warning {
+    const char *name;
+    const char *help;
+    bool enabled;
+};
+extern const struct warning warnings[ERR_WARN_ALL+1];
+
+/* This is a bitmask */
+#define WARN_ST_ENABLED      1   /* Warning is currently enabled */
+#define WARN_ST_ERROR        2   /* Treat this warning as an error */
+
+extern uint8_t warning_state[ERR_WARN_ALL];
+extern uint8_t warning_state_init[ERR_WARN_ALL];
+
+/* Process a warning option or directive */
+bool set_warning_status(const char *);
+
+#endif /* NASM_ERROR_H */

data/vendor/repo.or.cz/nasm/include/hashtbl.h

@@ -0,0 +1,85 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * hashtbl.h
+ *
+ * Efficient dictionary hash table class.
+ */
+
+#ifndef NASM_HASHTBL_H
+#define NASM_HASHTBL_H
+
+#include <stddef.h>
+#include "nasmlib.h"
+
+struct hash_tbl_node {
+    uint64_t hash;
+    const char *key;
+    void *data;
+};
+
+struct hash_table {
+    struct hash_tbl_node *table;
+    size_t load;
+    size_t size;
+    size_t max_load;
+};
+
+struct hash_insert {
+    uint64_t hash;
+    struct hash_table *head;
+    struct hash_tbl_node *where;
+};
+
+uint64_t crc64(uint64_t crc, const char *string);
+uint64_t crc64i(uint64_t crc, const char *string);
+#define CRC64_INIT UINT64_C(0xffffffffffffffff)
+
+/* Some reasonable initial sizes... */
+#define HASH_SMALL	4
+#define HASH_MEDIUM	16
+#define HASH_LARGE	256
+
+void hash_init(struct hash_table *head, size_t size);
+void **hash_find(struct hash_table *head, const char *string,
+		struct hash_insert *insert);
+void **hash_findi(struct hash_table *head, const char *string,
+		struct hash_insert *insert);
+void **hash_add(struct hash_insert *insert, const char *string, void *data);
+void *hash_iterate(const struct hash_table *head,
+		   struct hash_tbl_node **iterator,
+		   const char **key);
+void hash_free(struct hash_table *head);
+
+#endif /* NASM_HASHTBL_H */

data/vendor/repo.or.cz/nasm/include/iflag.h

@@ -0,0 +1,173 @@
+#ifndef NASM_IFLAG_H
+#define NASM_IFLAG_H
+
+#include "compiler.h"
+
+#include <string.h>
+
+#include "iflaggen.h"
+#include "nasmlib.h"            /* For ilog2_32() */
+
+#define IF_GENBIT(bit)          (UINT32_C(1) << (bit))
+
+static inline bool iflag_test(const iflag_t *f, unsigned int bit)
+{
+    return !!(f->field[bit >> 5] & IF_GENBIT(bit & 31));
+}
+
+static inline void iflag_set(iflag_t *f, unsigned int bit)
+{
+    f->field[bit >> 5] |= IF_GENBIT(bit & 31);
+}
+
+static inline void iflag_clear(iflag_t *f, unsigned int bit)
+{
+    f->field[bit >> 5] &= ~IF_GENBIT(bit & 31);
+}
+
+static inline void iflag_clear_all(iflag_t *f)
+{
+     memset(f, 0, sizeof(*f));
+}
+
+static inline void iflag_set_all(iflag_t *f)
+{
+     memset(f, ~0, sizeof(*f));
+}
+
+#define iflag_for_each_field(v) for ((v) = 0; (v) < IF_FIELD_COUNT; (v)++)
+
+static inline int iflag_cmp(const iflag_t *a, const iflag_t *b)
+{
+    int i;
+
+    /* This is intentionally a reverse loop! */
+    for (i = IF_FIELD_COUNT-1; i >= 0; i--) {
+        if (a->field[i] == b->field[i])
+            continue;
+
+        return (int)(a->field[i] - b->field[i]);
+    }
+
+    return 0;
+}
+
+#define IF_GEN_HELPER(name, op)                                         \
+    static inline iflag_t iflag_##name(const iflag_t *a, const iflag_t *b) \
+    {                                                                   \
+        unsigned int i;                                                 \
+        iflag_t res;                                                    \
+                                                                        \
+        iflag_for_each_field(i)                                         \
+            res.field[i] = a->field[i] op b->field[i];                  \
+                                                                        \
+        return res;                                                     \
+    }
+
+IF_GEN_HELPER(xor, ^)
+
+/* Some helpers which are to work with predefined masks */
+#define IF_SMASK        \
+    (IF_GENBIT(IF_SB)  |\
+     IF_GENBIT(IF_SW)  |\
+     IF_GENBIT(IF_SD)  |\
+     IF_GENBIT(IF_SQ)  |\
+     IF_GENBIT(IF_SO)  |\
+     IF_GENBIT(IF_SY)  |\
+     IF_GENBIT(IF_SZ)  |\
+     IF_GENBIT(IF_SIZE))
+#define IF_ARMASK       \
+    (IF_GENBIT(IF_AR0) |\
+     IF_GENBIT(IF_AR1) |\
+     IF_GENBIT(IF_AR2) |\
+     IF_GENBIT(IF_AR3) |\
+     IF_GENBIT(IF_AR4))
+
+#define _itemp_smask(idx)      (insns_flags[(idx)].field[0] & IF_SMASK)
+#define _itemp_armask(idx)     (insns_flags[(idx)].field[0] & IF_ARMASK)
+#define _itemp_arg(idx)        ((_itemp_armask(idx) >> IF_AR0) - 1)
+
+#define itemp_smask(itemp)      _itemp_smask((itemp)->iflag_idx)
+#define itemp_arg(itemp)        _itemp_arg((itemp)->iflag_idx)
+#define itemp_armask(itemp)     _itemp_armask((itemp)->iflag_idx)
+
+/*
+ * IF_8086 is the first CPU level flag and IF_PLEVEL the last
+ */
+#if IF_8086 & 31
+#error "IF_8086 must be on a uint32_t boundary"
+#endif
+#define IF_PLEVEL               IF_IA64
+#define IF_CPU_FIELD	       (IF_8086 >> 5)
+#define IF_CPU_LEVEL_MASK      ((IF_GENBIT(IF_PLEVEL & 31) << 1) - 1)
+
+/*
+ * IF_PRIV is the firstr instruction filtering flag
+ */
+#if IF_PRIV & 31
+#error "IF_PRIV must be on a uint32_t boundary"
+#endif
+#define IF_FEATURE_FIELD	(IF_PRIV >> 5)
+
+static inline int iflag_cmp_cpu(const iflag_t *a, const iflag_t *b)
+{
+    return (int)(a->field[IF_CPU_FIELD] - b->field[IF_CPU_FIELD]);
+}
+
+static inline uint32_t _iflag_cpu_level(const iflag_t *a)
+{
+    return a->field[IF_CPU_FIELD] & IF_CPU_LEVEL_MASK;
+}
+
+static inline int iflag_cmp_cpu_level(const iflag_t *a, const iflag_t *b)
+{
+    uint32_t aa = _iflag_cpu_level(a);
+    uint32_t bb = _iflag_cpu_level(b);
+
+    return (int)(aa - bb);
+}
+
+/* Returns true if the CPU level is at least a certain value */
+static inline bool iflag_cpu_level_ok(const iflag_t *a, unsigned int bit)
+{
+    return _iflag_cpu_level(a) >= IF_GENBIT(bit & 31);
+}
+
+static inline void iflag_set_all_features(iflag_t *a)
+{
+    size_t i;
+
+    for (i = IF_FEATURE_FIELD; i < IF_CPU_FIELD; i++)
+        a->field[i] = ~UINT32_C(0);
+}
+
+static inline void iflag_set_cpu(iflag_t *a, unsigned int cpu)
+{
+    a->field[0] = 0;     /* Not applicable to the CPU type */
+    iflag_set_all_features(a);    /* All feature masking bits set for now */
+    a->field[IF_CPU_FIELD] &= ~IF_CPU_LEVEL_MASK;
+    iflag_set(a, cpu);
+}
+
+static inline void iflag_set_default_cpu(iflag_t *a)
+{
+    iflag_set_cpu(a, IF_PLEVEL);
+}
+
+static inline iflag_t _iflag_pfmask(const iflag_t *a)
+{
+    iflag_t r;
+
+    iflag_clear_all(&r);
+
+    if (iflag_test(a, IF_CYRIX))
+        iflag_set(&r, IF_CYRIX);
+    if (iflag_test(a, IF_AMD))
+        iflag_set(&r, IF_AMD);
+
+    return r;
+}
+
+#define iflag_pfmask(itemp)     _iflag_pfmask(&insns_flags[(itemp)->iflag_idx])
+
+#endif /* NASM_IFLAG_H */

data/vendor/repo.or.cz/nasm/include/insns.h

@@ -0,0 +1,76 @@
+/* insns.h   header file for insns.c
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the license given in the file "LICENSE"
+ * distributed in the NASM archive.
+ */
+
+#ifndef NASM_INSNS_H
+#define NASM_INSNS_H
+
+#include "nasm.h"
+#include "tokens.h"
+#include "iflag.h"
+
+/* if changed, ITEMPLATE_END should be also changed accordingly */
+struct itemplate {
+    enum opcode     opcode;             /* the token, passed from "parser.c" */
+    int             operands;           /* number of operands */
+    opflags_t       opd[MAX_OPERANDS];  /* bit flags for operand types */
+    decoflags_t     deco[MAX_OPERANDS]; /* bit flags for operand decorators */
+    const uint8_t   *code;              /* the code it assembles to */
+    uint32_t        iflag_idx;          /* some flags referenced by index */
+};
+
+/* Use this helper to test instruction template flags */
+static inline bool itemp_has(const struct itemplate *itemp, unsigned int bit)
+{
+    return iflag_test(&insns_flags[itemp->iflag_idx], bit);
+}
+
+/* Disassembler table structure */
+
+/*
+ * If n == -1, then p points to another table of 256
+ * struct disasm_index, otherwise p points to a list of n
+ * struct itemplates to consider.
+ */
+struct disasm_index {
+    const void *p;
+    int n;
+};
+
+/* Tables for the assembler and disassembler, respectively */
+extern const struct itemplate * const nasm_instructions[];
+extern const struct disasm_index itable[256];
+extern const struct disasm_index * const itable_vex[NASM_VEX_CLASSES][32][4];
+
+/* Common table for the byte codes */
+extern const uint8_t nasm_bytecodes[];
+
+/*
+ * this define is used to signify the end of an itemplate
+ */
+#define ITEMPLATE_END {I_none,0,{0,},{0,},NULL,0}
+
+/* Width of Dx and RESx instructions */
+int const_func idata_bytes(enum opcode opcode);
+int const_func resv_bytes(enum opcode opcode);
+
+/*
+ * Pseudo-op tests
+ */
+/* DB-type instruction (DB, DW, ...) */
+static inline bool opcode_is_db(enum opcode opcode)
+{
+    return idata_bytes(opcode) > 0;
+}
+
+/* RESB-type instruction (RESB, RESW, ...) */
+static inline bool opcode_is_resb(enum opcode opcode)
+{
+    return resv_bytes(opcode) > 0;
+}
+
+#endif /* NASM_INSNS_H */