laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/nasmlib/file.h

@@ -0,0 +1,128 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   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.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef NASMLIB_FILE_H
+#define NASMLIB_FILE_H
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+
+#include <errno.h>
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef HAVE_IO_H
+# include <io.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+
+#if !defined(HAVE_ACCESS) && defined(HAVE__ACCESS)
+# define HAVE_ACCESS 1
+# define access _access
+#endif
+#ifndef R_OK
+# define R_OK 4                 /* Classic Unix constant, same on Windows */
+#endif
+
+/* Can we adjust the file size without actually writing all the bytes? */
+#ifdef HAVE__CHSIZE_S
+# define nasm_ftruncate(fd,size) _chsize_s(fd,size)
+#elif defined(HAVE__CHSIZE)
+# define nasm_ftruncate(fd,size) _chsize(fd,size)
+#elif defined(HAVE_FTRUNCATE)
+# define nasm_ftruncate(fd,size) ftruncate(fd,size)
+#endif
+
+/*
+ * On Win32/64, stat has a 32-bit file size but _stati64 has a 64-bit file
+ * size.  Things get complicated because some of these may be macros,
+ * which autoconf won't pick up on as the standard autoconf tests do
+ * #undef.
+ */
+#ifdef _stati64
+# define HAVE_STRUCT__STATI64 1
+# define HAVE__STATI64 1
+#endif
+#ifdef _fstati64
+# define HAVE__FSTATI64 1
+#endif
+
+#ifdef HAVE_STRUCT__STATI64
+typedef struct _stati64 nasm_struct_stat;
+# ifdef HAVE__STATI64
+#  define nasm_stat _stati64
+# endif
+# ifdef HAVE__FSTATI64
+#  define nasm_fstat _fstati64
+# endif
+#elif defined(HAVE_STRUCT_STAT)
+typedef struct stat nasm_struct_stat;
+# ifdef HAVE_STAT
+#  define nasm_stat stat
+# endif
+# ifdef HAVE_FSTAT
+#  define nasm_fstat fstat
+# endif
+#endif
+
+#ifndef HAVE_FILENO
+# ifdef fileno                  /* autoconf doesn't always pick up macros */
+#  define HAVE_FILENO 1
+# elif defined(HAVE__FILENO)
+#  define HAVE_FILENO 1
+#  define fileno _fileno
+# endif
+#endif
+
+/* These functions are utterly useless without fileno() */
+#ifndef HAVE_FILENO
+# undef nasm_fstat
+# undef nasm_ftruncate
+# undef HAVE_MMAP
+# undef HAVE__FILELENGTHI64
+#endif
+
+#endif /* NASMLIB_FILE_H */

data/vendor/repo.or.cz/nasm/nasmlib/filename.c

@@ -0,0 +1,69 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2016 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.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * nasmlib.c	library routines for the Netwide Assembler
+ */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include "error.h"
+
+void standard_extension(char *inname, char *outname, char *extension)
+{
+    char *p, *q;
+
+    if (*outname)               /* file name already exists, */
+        return;                 /* so do nothing */
+    q = inname;
+    p = outname;
+    while (*q)
+        *p++ = *q++;            /* copy, and find end of string */
+    *p = '\0';                  /* terminate it */
+    while (p > outname && *--p != '.') ;        /* find final period (or whatever) */
+    if (*p != '.')
+        while (*p)
+            p++;                /* go back to end if none found */
+    if (!strcmp(p, extension)) {        /* is the extension already there? */
+        if (*extension)
+            nasm_error(ERR_WARNING | ERR_NOFILE,
+		       "file name already ends in `%s': "
+		       "output will be in `nasm.out'", extension);
+        else
+            nasm_error(ERR_WARNING | ERR_NOFILE,
+		       "file name already has no extension: "
+		       "output will be in `nasm.out'");
+        strcpy(outname, "nasm.out");
+    } else
+        strcpy(p, extension);
+}

data/vendor/repo.or.cz/nasm/nasmlib/hashtbl.c

@@ -0,0 +1,232 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 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.c
+ *
+ * Efficient dictionary hash table class.
+ */
+
+#include "compiler.h"
+
+#include <string.h>
+#include "nasm.h"
+#include "hashtbl.h"
+
+#define HASH_MAX_LOAD   2 /* Higher = more memory-efficient, slower */
+
+#define hash_calc(key)          crc64(CRC64_INIT, (key))
+#define hash_calci(key)         crc64i(CRC64_INIT, (key))
+#define hash_max_load(size)     ((size) * (HASH_MAX_LOAD - 1) / HASH_MAX_LOAD)
+#define hash_expand(size)       ((size) << 1)
+#define hash_mask(size)         ((size) - 1)
+#define hash_pos(hash, mask)    ((hash) & (mask))
+#define hash_inc(hash, mask)    ((((hash) >> 32) & (mask)) | 1) /* always odd */
+#define hash_pos_next(pos, inc, mask) (((pos) + (inc)) & (mask))
+
+static struct hash_tbl_node *alloc_table(size_t newsize)
+{
+    size_t bytes = newsize * sizeof(struct hash_tbl_node);
+    return nasm_zalloc(bytes);
+}
+
+void hash_init(struct hash_table *head, size_t size)
+{
+    nasm_assert(is_power2(size));
+    head->table    = alloc_table(size);
+    head->load     = 0;
+    head->size     = size;
+    head->max_load = hash_max_load(size);
+}
+
+/*
+ * Find an entry in a hash table.
+ *
+ * On failure, if "insert" is non-NULL, store data in that structure
+ * which can be used to insert that node using hash_add().
+ *
+ * WARNING: this data is only valid until the very next call of
+ * hash_add(); it cannot be "saved" to a later date.
+ *
+ * On success, return a pointer to the "data" element of the hash
+ * structure.
+ */
+void **hash_find(struct hash_table *head, const char *key,
+                 struct hash_insert *insert)
+{
+    struct hash_tbl_node *np;
+    struct hash_tbl_node *tbl = head->table;
+    uint64_t hash = hash_calc(key);
+    size_t mask = hash_mask(head->size);
+    size_t pos = hash_pos(hash, mask);
+    size_t inc = hash_inc(hash, mask);
+
+    while ((np = &tbl[pos])->key) {
+        if (hash == np->hash && !strcmp(key, np->key))
+            return &np->data;
+        pos = hash_pos_next(pos, inc, mask);
+    }
+
+    /* Not found.  Store info for insert if requested. */
+    if (insert) {
+        insert->head  = head;
+        insert->hash  = hash;
+        insert->where = np;
+    }
+    return NULL;
+}
+
+/*
+ * Same as hash_find, but for case-insensitive hashing.
+ */
+void **hash_findi(struct hash_table *head, const char *key,
+                  struct hash_insert *insert)
+{
+    struct hash_tbl_node *np;
+    struct hash_tbl_node *tbl = head->table;
+    uint64_t hash = hash_calci(key);
+    size_t mask = hash_mask(head->size);
+    size_t pos = hash_pos(hash, mask);
+    size_t inc = hash_inc(hash, mask);
+
+    while ((np = &tbl[pos])->key) {
+        if (hash == np->hash && !nasm_stricmp(key, np->key))
+            return &np->data;
+        pos = hash_pos_next(pos, inc, mask);
+    }
+
+    /* Not found.  Store info for insert if requested. */
+    if (insert) {
+        insert->head  = head;
+        insert->hash  = hash;
+        insert->where = np;
+    }
+    return NULL;
+}
+
+/*
+ * Insert node.  Return a pointer to the "data" element of the newly
+ * created hash node.
+ */
+void **hash_add(struct hash_insert *insert, const char *key, void *data)
+{
+    struct hash_table *head  = insert->head;
+    struct hash_tbl_node *np = insert->where;
+
+    /*
+     * Insert node.  We can always do this, even if we need to
+     * rebalance immediately after.
+     */
+    np->hash = insert->hash;
+    np->key  = key;
+    np->data = data;
+
+    if (++head->load > head->max_load) {
+        /* Need to expand the table */
+        size_t newsize                  = hash_expand(head->size);
+        struct hash_tbl_node *newtbl    = alloc_table(newsize);
+        size_t mask                     = hash_mask(newsize);
+
+        if (head->table) {
+            struct hash_tbl_node *op, *xp;
+            size_t i;
+
+            /* Rebalance all the entries */
+            for (i = 0, op = head->table; i < head->size; i++, op++) {
+                if (op->key) {
+                    size_t pos = hash_pos(op->hash, mask);
+                    size_t inc = hash_inc(op->hash, mask);
+
+                    while ((xp = &newtbl[pos])->key)
+                        pos = hash_pos_next(pos, inc, mask);
+
+                    *xp = *op;
+                    if (op == np)
+                        np = xp;
+                }
+            }
+            nasm_free(head->table);
+        }
+
+        head->table    = newtbl;
+        head->size     = newsize;
+        head->max_load = hash_max_load(newsize);
+    }
+
+    return &np->data;
+}
+
+/*
+ * Iterate over all members of a hash set.  For the first call,
+ * iterator should be initialized to NULL.  Returns the data pointer,
+ * or NULL on failure.
+ */
+void *hash_iterate(const struct hash_table *head,
+                   struct hash_tbl_node **iterator,
+                   const char **key)
+{
+    struct hash_tbl_node *np = *iterator;
+    struct hash_tbl_node *ep = head->table + head->size;
+
+    if (!np) {
+        np = head->table;
+        if (!np)
+            return NULL;        /* Uninitialized table */
+    }
+
+    while (np < ep) {
+        if (np->key) {
+            *iterator = np + 1;
+            if (key)
+                *key = np->key;
+            return np->data;
+        }
+        np++;
+    }
+
+    *iterator = NULL;
+    if (key)
+        *key = NULL;
+    return NULL;
+}
+
+/*
+ * Free the hash itself.  Doesn't free the data elements; use
+ * hash_iterate() to do that first, if needed.
+ */
+void hash_free(struct hash_table *head)
+{
+    void *p = head->table;
+    head->table = NULL;
+    nasm_free(p);
+}

data/vendor/repo.or.cz/nasm/nasmlib/ilog2.c

@@ -0,0 +1,168 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   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.
+ *
+ * ----------------------------------------------------------------------- */
+
+#include "compiler.h"
+#include "nasmlib.h"
+#include <limits.h>
+
+#define ROUND(v, a, w)                                  \
+    do {                                                \
+        if (v & (((UINT32_C(1) << w) - 1) << w)) {      \
+            a  += w;                                    \
+            v >>= w;                                    \
+        }                                               \
+    } while (0)
+
+
+#if defined(__GNUC__) && defined(__x86_64__)
+
+int ilog2_32(uint32_t v)
+{
+    int n;
+
+    __asm__("bsrl %1,%0"
+            : "=r" (n)
+            : "rm" (v), "0" (0));
+    return n;
+}
+
+#elif defined(__GNUC__) && defined(__i386__)
+
+int ilog2_32(uint32_t v)
+{
+    int n;
+
+#ifdef __i686__
+    __asm__("bsrl %1,%0 ; cmovz %2,%0\n"
+            : "=&r" (n)
+            : "rm" (v), "r" (0));
+#else
+    __asm__("bsrl %1,%0 ; jnz 1f ; xorl %0,%0\n"
+            "1:"
+            : "=&r" (n)
+            : "rm" (v));
+#endif
+     return n;
+}
+
+#elif defined(HAVE___BUILTIN_CLZ) && INT_MAX == 2147483647
+
+int ilog2_32(uint32_t v)
+{
+    if (!v)
+        return 0;
+
+    return __builtin_clz(v) ^ 31;
+}
+
+#else
+
+int ilog2_32(uint32_t v)
+{
+    int p = 0;
+
+    ROUND(v, p, 16);
+    ROUND(v, p,  8);
+    ROUND(v, p,  4);
+    ROUND(v, p,  2);
+    ROUND(v, p,  1);
+
+    return p;
+}
+
+#endif
+
+#if defined(__GNUC__) && defined(__x86_64__)
+
+int ilog2_64(uint64_t v)
+{
+    uint64_t n;
+
+    __asm__("bsrq %1,%0"
+            : "=r" (n)
+            : "rm" (v), "0" (UINT64_C(0)));
+    return n;
+}
+
+#elif defined(HAVE__BUILTIN_CLZLL) && LLONG_MAX == 9223372036854775807LL
+
+int ilog2_64(uint64_t v)
+{
+    if (!v)
+        return 0;
+
+    return __builtin_clzll(v) ^ 63;
+}
+
+#else
+
+int ilog2_64(uint64_t vv)
+{
+    int p = 0;
+    uint32_t v;
+
+    v = vv >> 32;
+    if (v)
+        p += 32;
+    else
+        v = vv;
+
+    ROUND(v, p, 16);
+    ROUND(v, p,  8);
+    ROUND(v, p,  4);
+    ROUND(v, p,  2);
+    ROUND(v, p,  1);
+
+    return p;
+}
+
+#endif
+
+/*
+ * v == 0 ? 0 : is_power2(x) ? ilog2_X(v) : -1
+ */
+int alignlog2_32(uint32_t v)
+{
+    if (unlikely(v & (v-1)))
+        return -1;              /* invalid alignment */
+
+    return ilog2_32(v);
+}
+
+int alignlog2_64(uint64_t v)
+{
+    if (unlikely(v & (v-1)))
+        return -1;              /* invalid alignment */
+
+    return ilog2_64(v);
+}