laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/output/outcoff.mac

@@ -0,0 +1,43 @@
+;; --------------------------------------------------------------------------
+;;   
+;;   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.
+;;
+;; --------------------------------------------------------------------------
+
+OUT: coff win32 win64
+%define __SECT__ [section .text]
+%macro __NASM_CDecl__ 1
+%endmacro
+%imacro export 1+.nolist
+[export %1]
+%endmacro
+%imacro safeseh 1.nolist
+[safeseh %1]
+%endmacro

data/vendor/repo.or.cz/nasm/output/outdbg.c

@@ -0,0 +1,425 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   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.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outdbg.c	output routines for the Netwide Assembler to produce
+ *		a debugging trace
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outform.h"
+#include "outlib.h"
+#include "insns.h"
+
+#ifdef OF_DBG
+
+struct Section {
+    struct Section *next;
+    int32_t number;
+    char *name;
+} *dbgsect;
+
+static unsigned long dbg_max_data_dump = 128;
+
+const struct ofmt of_dbg;
+static void dbg_init(void)
+{
+    dbgsect = NULL;
+    fprintf(ofile, "NASM Output format debug dump\n");
+}
+
+static void dbg_cleanup(void)
+{
+    dfmt->cleanup();
+    while (dbgsect) {
+        struct Section *tmp = dbgsect;
+        dbgsect = dbgsect->next;
+        nasm_free(tmp->name);
+        nasm_free(tmp);
+    }
+}
+
+static int32_t dbg_section_names(char *name, int pass, int *bits)
+{
+    int seg;
+
+    /*
+     * We must have an initial default: let's make it 16.
+     */
+    if (!name)
+        *bits = 16;
+
+    if (!name)
+        fprintf(ofile, "section_name on init: returning %d\n",
+                seg = seg_alloc());
+    else {
+        int n = strcspn(name, " \t");
+        char *sname = nasm_strndup(name, n);
+        struct Section *s;
+
+        seg = NO_SEG;
+        for (s = dbgsect; s; s = s->next)
+            if (!strcmp(s->name, sname))
+                seg = s->number;
+
+        if (seg == NO_SEG) {
+            s = nasm_malloc(sizeof(*s));
+            s->name = sname;
+            s->number = seg = seg_alloc();
+            s->next = dbgsect;
+            dbgsect = s;
+            fprintf(ofile, "section_name %s (pass %d): returning %d\n",
+                    name, pass, seg);
+        }
+    }
+    return seg;
+}
+
+static void dbg_deflabel(char *name, int32_t segment, int64_t offset,
+                         int is_global, char *special)
+{
+    fprintf(ofile, "deflabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
+            name, segment, offset,
+            is_global == 2 ? "common" : is_global ? "global" : "local",
+            is_global, special ? ": " : "", special);
+}
+
+static const char *out_type(enum out_type type)
+{
+    static const char *out_types[] = {
+        "rawdata",
+        "reserve",
+        "address",
+        "reladdr",
+        "segment"
+    };
+    static char invalid_buf[64];
+
+    if (type >= sizeof(out_types)/sizeof(out_types[0])) {
+        sprintf(invalid_buf, "[invalid type %d]", type);
+        return invalid_buf;
+    }
+
+    return out_types[type];
+}
+
+static const char *out_sign(enum out_sign sign)
+{
+    static const char *out_signs[] = {
+        "wrap",
+        "signed",
+        "unsigned"
+    };
+    static char invalid_buf[64];
+
+    if (sign >= sizeof(out_signs)/sizeof(out_signs[0])) {
+        sprintf(invalid_buf, "[invalid sign %d]", sign);
+        return invalid_buf;
+    }
+
+    return out_signs[sign];
+}
+
+static void dbg_out(const struct out_data *data)
+{
+    fprintf(ofile,
+            "out to %"PRIx32":%"PRIx64" %s %s bits %d insoffs %d/%d "
+            "size %"PRIu64,
+            data->segment, data->offset,
+            out_type(data->type), out_sign(data->sign),
+            data->bits, data->insoffs, data->inslen, data->size);
+    if (data->itemp) {
+        fprintf(ofile, " ins %s(%d)",
+                nasm_insn_names[data->itemp->opcode], data->itemp->operands);
+    } else {
+        fprintf(ofile, " no ins (plain data)");
+    }
+
+    if (data->type == OUT_ADDRESS || data->type == OUT_RELADDR ||
+        data->type == OUT_SEGMENT) {
+        fprintf(ofile, " target %"PRIx32":%"PRIx64,
+                data->tsegment, data->toffset);
+        if (data->twrt != NO_SEG)
+            fprintf(ofile, " wrt %"PRIx32, data->twrt);
+    }
+    if (data->type == OUT_RELADDR)
+        fprintf(ofile, " relbase %"PRIx64, data->relbase);
+
+    putc('\n', ofile);
+
+    if (data->type == OUT_RAWDATA) {
+        if ((size_t)data->size != data->size) {
+            fprintf(ofile, "  data: <error: impossible size>\n");
+        } else if (!data->data) {
+            fprintf(ofile, "  data: <error: null pointer>\n");
+        } else if (dbg_max_data_dump != -1UL &&
+                   data->size > dbg_max_data_dump) {
+            fprintf(ofile, "  data: <%"PRIu64" bytes>\n", data->size);
+        } else {
+            size_t i, j;
+            const uint8_t *bytes = data->data;
+            for (i = 0; i < data->size; i += 16) {
+                fprintf(ofile, "  data:");
+                for (j = 0; j < 16; j++) {
+                    if (i+j >= data->size)
+                        fprintf(ofile, "   ");
+                    else
+                        fprintf(ofile, "%c%02x",
+                                (j == 8) ? '-' : ' ', bytes[i+j]);
+                }
+                fprintf(ofile,"    ");
+                for (j = 0; j < 16; j++) {
+                    if (i+j >= data->size) {
+                        putc(' ', ofile);
+                    } else {
+                        if (bytes[i+j] >= 32 && bytes[i+j] <= 126)
+                            putc(bytes[i+j], ofile);
+                        else
+                            putc('.', ofile);
+                    }
+                }
+                putc('\n', ofile);
+            }
+        }
+    }
+
+    /* This is probably the only place were we'll call this this way... */
+    nasm_do_legacy_output(data);
+}
+
+static void dbg_legacy_out(int32_t segto, const void *data,
+                           enum out_type type, uint64_t size,
+                           int32_t segment, int32_t wrt)
+{
+    int32_t ldata;
+
+    if (type == OUT_ADDRESS)
+        fprintf(ofile, "  legacy: out to %"PRIx32", len = %d: ",
+                segto, (int)abs((int)size));
+    else
+        fprintf(ofile, "  legacy: out to %"PRIx32", len = %"PRId64" (0x%"PRIx64"): ",
+                segto, (int64_t)size, size);
+
+    switch (type) {
+    case OUT_RESERVE:
+        fprintf(ofile, "reserved.\n");
+        break;
+    case OUT_RAWDATA:
+        fprintf(ofile, "rawdata\n"); /* Already have a data dump */
+        break;
+    case OUT_ADDRESS:
+	ldata = *(int64_t *)data;
+        fprintf(ofile, "addr %08"PRIx32" (seg %08"PRIx32", wrt %08"PRIx32")\n",
+                ldata, segment, wrt);
+        break;
+    case OUT_REL1ADR:
+        fprintf(ofile, "rel1adr %02"PRIx8" (seg %08"PRIx32")\n",
+		(uint8_t)*(int64_t *)data, segment);
+        break;
+    case OUT_REL2ADR:
+        fprintf(ofile, "rel2adr %04"PRIx16" (seg %08"PRIx32")\n",
+		(uint16_t)*(int64_t *)data, segment);
+        break;
+    case OUT_REL4ADR:
+        fprintf(ofile, "rel4adr %08"PRIx32" (seg %08"PRIx32")\n",
+		(uint32_t)*(int64_t *)data,
+                segment);
+        break;
+    case OUT_REL8ADR:
+        fprintf(ofile, "rel8adr %016"PRIx64" (seg %08"PRIx32")\n",
+		(uint64_t)*(int64_t *)data, segment);
+        break;
+    default:
+        fprintf(ofile, "unknown\n");
+        break;
+    }
+}
+
+static void dbg_sectalign(int32_t seg, unsigned int value)
+{
+    fprintf(ofile, "set alignment (%d) for segment (%u)\n",
+            seg, value);
+}
+
+static int32_t dbg_segbase(int32_t segment)
+{
+    return segment;
+}
+
+static enum directive_result
+dbg_directive(enum directive directive, char *value, int pass)
+{
+    fprintf(ofile, "directive [%s] value [%s] (pass %d)\n",
+            directive_dname(directive), value, pass);
+    return DIRR_OK;
+}
+
+static enum directive_result
+dbg_pragma(const struct pragma *pragma);
+
+static const struct pragma_facility dbg_pragma_list[] = {
+    { NULL, dbg_pragma }
+};
+
+static enum directive_result
+dbg_pragma(const struct pragma *pragma)
+{
+    fprintf(ofile, "pragma %s(%s) %s[%s] %s\n",
+            pragma->facility_name,
+            pragma->facility->name ? pragma->facility->name : "<default>",
+            pragma->opname, directive_dname(pragma->opcode),
+            pragma->tail);
+
+    if (pragma->facility == &dbg_pragma_list[0] &&
+        pragma->opcode == D_MAXDUMP) {
+        if (!nasm_stricmp(pragma->tail, "unlimited")) {
+            dbg_max_data_dump = -1UL;
+        } else {
+            char *ep;
+            unsigned long arg;
+
+            errno = 0;
+            arg = strtoul(pragma->tail, &ep, 0);
+            if (errno || *nasm_skip_spaces(ep)) {
+                nasm_error(ERR_WARNING | ERR_WARN_BAD_PRAGMA | ERR_PASS2,
+                           "invalid %%pragma dbg maxdump argument");
+                return DIRR_ERROR;
+            } else {
+                dbg_max_data_dump = arg;
+            }
+        }
+    }
+
+    return DIRR_OK;
+}
+
+static void dbg_filename(char *inname, char *outname)
+{
+    standard_extension(inname, outname, ".dbg");
+}
+
+static const char * const types[] = {
+    "unknown", "label", "byte", "word", "dword", "float", "qword", "tbyte"
+};
+static void dbgdbg_init(void)
+{
+    fprintf(ofile, "   With debug info\n");
+}
+static void dbgdbg_cleanup(void)
+{
+}
+
+static void dbgdbg_linnum(const char *lnfname, int32_t lineno, int32_t segto)
+{
+    fprintf(ofile, "dbglinenum %s(%"PRId32") segment %"PRIx32"\n",
+	    lnfname, lineno, segto);
+}
+static void dbgdbg_deflabel(char *name, int32_t segment,
+                            int64_t offset, int is_global, char *special)
+{
+    fprintf(ofile, "dbglabel %s := %08"PRIx32":%016"PRIx64" %s (%d)%s%s\n",
+            name,
+            segment, offset,
+            is_global == 2 ? "common" : is_global ? "global" : "local",
+            is_global, special ? ": " : "", special);
+}
+static void dbgdbg_define(const char *type, const char *params)
+{
+    fprintf(ofile, "dbgdirective [%s] value [%s]\n", type, params);
+}
+static void dbgdbg_output(int output_type, void *param)
+{
+    (void)output_type;
+    (void)param;
+}
+static void dbgdbg_typevalue(int32_t type)
+{
+    fprintf(ofile, "new type: %s(%"PRIX32")\n",
+            types[TYM_TYPE(type) >> 3], TYM_ELEMENTS(type));
+}
+
+static const struct pragma_facility dbgdbg_pragma_list[] = {
+    { "dbgdbg", dbg_pragma },
+    { NULL, dbg_pragma }        /* Won't trigger, "debug" is a reserved ns */
+};
+
+static const struct dfmt debug_debug_form = {
+    "Trace of all info passed to debug stage",
+    "debug",
+    dbgdbg_init,
+    dbgdbg_linnum,
+    dbgdbg_deflabel,
+    dbgdbg_define,
+    dbgdbg_typevalue,
+    dbgdbg_output,
+    dbgdbg_cleanup,
+    dbgdbg_pragma_list
+};
+
+static const struct dfmt * const debug_debug_arr[3] = {
+    &debug_debug_form,
+    &null_debug_form,
+    NULL
+};
+
+const struct ofmt of_dbg = {
+    "Trace of all info passed to output stage",
+    "dbg",
+    OFMT_TEXT,
+    64,
+    debug_debug_arr,
+    &debug_debug_form,
+    NULL,
+    dbg_init,
+    dbg_out,
+    dbg_legacy_out,
+    dbg_deflabel,
+    dbg_section_names,
+    dbg_sectalign,
+    dbg_segbase,
+    dbg_directive,
+    dbg_filename,
+    dbg_cleanup,
+    dbg_pragma_list
+};
+
+#endif                          /* OF_DBG */