Restoring authorship annotation for <somov@yandex-team.ru>. Commit 1 of 2.

1 files changed, 295 insertions, 295 deletions

diff --git a/contrib/tools/yasm/libyasm/insn.c b/contrib/tools/yasm/libyasm/insn.c
index 8f7a4c1978..a1ebbfc568 100644
--- a/contrib/tools/yasm/libyasm/insn.c
+++ b/contrib/tools/yasm/libyasm/insn.c
@@ -1,295 +1,295 @@
-/*
- * Mnemonic instruction bytecode
- *
- *  Copyright (C) 2005-2007  Peter Johnson
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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 AUTHOR AND OTHER 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 AUTHOR OR OTHER 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 "util.h"
-
-#include "libyasm-stdint.h"
-#include "coretype.h"
-
-#include "errwarn.h"
-#include "expr.h"
-#include "value.h"
-
-#include "bytecode.h"
-#include "insn.h"
-#include "arch.h"
-
-
-void
-yasm_ea_set_segreg(yasm_effaddr *ea, uintptr_t segreg)
-{
-    if (!ea)
-        return;
-
-    if (segreg != 0 && ea->segreg != 0)
-        yasm_warn_set(YASM_WARN_GENERAL,
-                      N_("multiple segment overrides, using leftmost"));
-
-    ea->segreg = segreg;
-}
-
-yasm_insn_operand *
-yasm_operand_create_reg(uintptr_t reg)
-{
-    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
-
-    retval->type = YASM_INSN__OPERAND_REG;
-    retval->data.reg = reg;
-    retval->seg = 0;
-    retval->targetmod = 0;
-    retval->size = 0;
-    retval->deref = 0;
-    retval->strict = 0;
-
-    return retval;
-}
-
-yasm_insn_operand *
-yasm_operand_create_segreg(uintptr_t segreg)
-{
-    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
-
-    retval->type = YASM_INSN__OPERAND_SEGREG;
-    retval->data.reg = segreg;
-    retval->seg = 0;
-    retval->targetmod = 0;
-    retval->size = 0;
-    retval->deref = 0;
-    retval->strict = 0;
-
-    return retval;
-}
-
-yasm_insn_operand *
-yasm_operand_create_mem(/*@only@*/ yasm_effaddr *ea)
-{
-    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
-
-    retval->type = YASM_INSN__OPERAND_MEMORY;
-    retval->data.ea = ea;
-    retval->seg = 0;
-    retval->targetmod = 0;
-    retval->size = 0;
-    retval->deref = 0;
-    retval->strict = 0;
-    retval->size = ea->data_len * 8;
-
-    return retval;
-}
-
-yasm_insn_operand *
-yasm_operand_create_imm(/*@only@*/ yasm_expr *val)
-{
-    yasm_insn_operand *retval;
-    const uintptr_t *reg;
-
-    reg = yasm_expr_get_reg(&val, 0);
-    if (reg) {
-        retval = yasm_operand_create_reg(*reg);
-        yasm_expr_destroy(val);
-    } else {
-        retval = yasm_xmalloc(sizeof(yasm_insn_operand));
-        retval->type = YASM_INSN__OPERAND_IMM;
-        retval->data.val = val;
-        retval->seg = 0;
-        retval->targetmod = 0;
-        retval->size = 0;
-        retval->deref = 0;
-        retval->strict = 0;
-    }
-
-    return retval;
-}
-
-yasm_insn_operand *
-yasm_insn_ops_append(yasm_insn *insn, yasm_insn_operand *op)
-{
-    if (op) {
-        insn->num_operands++;
-        STAILQ_INSERT_TAIL(&insn->operands, op, link);
-        return op;
-    }
-    return (yasm_insn_operand *)NULL;
-}
-
-void
-yasm_insn_add_prefix(yasm_insn *insn, uintptr_t prefix)
-{
-    insn->prefixes =
-        yasm_xrealloc(insn->prefixes,
-                      (insn->num_prefixes+1)*sizeof(uintptr_t));
-    insn->prefixes[insn->num_prefixes] = prefix;
-    insn->num_prefixes++;
-}
-
-void
-yasm_insn_add_seg_prefix(yasm_insn *insn, uintptr_t segreg)
-{
-    insn->segregs =
-        yasm_xrealloc(insn->segregs, (insn->num_segregs+1)*sizeof(uintptr_t));
-    insn->segregs[insn->num_segregs] = segreg;
-    insn->num_segregs++;
-}
-
-void
-yasm_insn_initialize(yasm_insn *insn)
-{
-    STAILQ_INIT(&insn->operands);
-
-    insn->prefixes = NULL;
-    insn->segregs = NULL;
-
-    insn->num_operands = 0;
-    insn->num_prefixes = 0;
-    insn->num_segregs = 0;
-}
-
-void
-yasm_insn_delete(yasm_insn *insn,
-                 void (*ea_destroy) (/*@only@*/ yasm_effaddr *))
-{
-    if (insn->num_operands > 0) {
-        yasm_insn_operand *cur, *next;
-
-        cur = STAILQ_FIRST(&insn->operands);
-        while (cur) {
-            next = STAILQ_NEXT(cur, link);
-            switch (cur->type) {
-                case YASM_INSN__OPERAND_MEMORY:
-                    ea_destroy(cur->data.ea);
-                    break;
-                case YASM_INSN__OPERAND_IMM:
-                    yasm_expr_destroy(cur->data.val);
-                    break;
-                default:
-                    break;
-            }
-            yasm_xfree(cur);
-            cur = next;
-        }
-    }
-    if (insn->num_prefixes > 0)
-        yasm_xfree(insn->prefixes);
-    if (insn->num_segregs > 0)
-        yasm_xfree(insn->segregs);
-}
-
-void
-yasm_insn_print(const yasm_insn *insn, FILE *f, int indent_level)
-{
-    const yasm_insn_operand *op;
-
-    STAILQ_FOREACH (op, &insn->operands, link) {
-        switch (op->type) {
-            case YASM_INSN__OPERAND_REG:
-                fprintf(f, "%*sReg=", indent_level, "");
-                /*yasm_arch_reg_print(arch, op->data.reg, f);*/
-                fprintf(f, "\n");
-                break;
-            case YASM_INSN__OPERAND_SEGREG:
-                fprintf(f, "%*sSegReg=", indent_level, "");
-                /*yasm_arch_segreg_print(arch, op->data.reg, f);*/
-                fprintf(f, "\n");
-                break;
-            case YASM_INSN__OPERAND_MEMORY:
-                fprintf(f, "%*sMemory=\n", indent_level, "");
-                /*yasm_arch_ea_print(arch, op->data.ea, f, indent_level);*/
-                break;
-            case YASM_INSN__OPERAND_IMM:
-                fprintf(f, "%*sImm=", indent_level, "");
-                yasm_expr_print(op->data.val, f);
-                fprintf(f, "\n");
-                break;
-        }
-        fprintf(f, "%*sTargetMod=%lx\n", indent_level+1, "",
-                (unsigned long)op->targetmod);
-        fprintf(f, "%*sSize=%u\n", indent_level+1, "", op->size);
-        fprintf(f, "%*sDeref=%d, Strict=%d\n", indent_level+1, "",
-                (int)op->deref, (int)op->strict);
-    }
-}
-
-void
-yasm_insn_finalize(yasm_insn *insn)
-{
-    unsigned int i;
-    yasm_insn_operand *op;
-    yasm_error_class eclass;
-    char *str, *xrefstr;
-    unsigned long xrefline;
-
-    /* Simplify the operands' expressions first. */
-    for (i = 0, op = yasm_insn_ops_first(insn);
-         op && i<insn->num_operands; op = yasm_insn_op_next(op), i++) {
-        /* Check operand type */
-        switch (op->type) {
-            case YASM_INSN__OPERAND_MEMORY:
-                /* Don't get over-ambitious here; some archs' memory expr
-                 * parser are sensitive to the presence of *1, etc, so don't
-                 * simplify reg*1 identities.
-                 */
-                if (op->data.ea)
-                    op->data.ea->disp.abs =
-                        yasm_expr__level_tree(op->data.ea->disp.abs, 1, 1, 0,
-                                              0, NULL, NULL);
-                if (yasm_error_occurred()) {
-                    /* Add a pointer to where it was used to the error */
-                    yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr);
-                    if (xrefstr) {
-                        yasm_error_set_xref(xrefline, "%s", xrefstr);
-                        yasm_xfree(xrefstr);
-                    }
-                    if (str) {
-                        yasm_error_set(eclass, "%s in memory expression", str);
-                        yasm_xfree(str);
-                    }
-                    return;
-                }
-                break;
-            case YASM_INSN__OPERAND_IMM:
-                op->data.val =
-                    yasm_expr__level_tree(op->data.val, 1, 1, 1, 0, NULL,
-                                          NULL);
-                if (yasm_error_occurred()) {
-                    /* Add a pointer to where it was used to the error */
-                    yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr);
-                    if (xrefstr) {
-                        yasm_error_set_xref(xrefline, "%s", xrefstr);
-                        yasm_xfree(xrefstr);
-                    }
-                    if (str) {
-                        yasm_error_set(eclass, "%s in immediate expression",
-                                       str);
-                        yasm_xfree(str);
-                    }
-                    return;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-}
+/* 
+ * Mnemonic instruction bytecode 
+ * 
+ *  Copyright (C) 2005-2007  Peter Johnson 
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. 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 AUTHOR AND OTHER 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 AUTHOR OR OTHER 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 "util.h" 
+ 
+#include "libyasm-stdint.h" 
+#include "coretype.h" 
+ 
+#include "errwarn.h" 
+#include "expr.h" 
+#include "value.h" 
+ 
+#include "bytecode.h" 
+#include "insn.h" 
+#include "arch.h" 
+ 
+ 
+void 
+yasm_ea_set_segreg(yasm_effaddr *ea, uintptr_t segreg) 
+{ 
+    if (!ea) 
+        return; 
+ 
+    if (segreg != 0 && ea->segreg != 0) 
+        yasm_warn_set(YASM_WARN_GENERAL, 
+                      N_("multiple segment overrides, using leftmost")); 
+ 
+    ea->segreg = segreg; 
+} 
+ 
+yasm_insn_operand * 
+yasm_operand_create_reg(uintptr_t reg) 
+{ 
+    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand)); 
+ 
+    retval->type = YASM_INSN__OPERAND_REG; 
+    retval->data.reg = reg; 
+    retval->seg = 0; 
+    retval->targetmod = 0; 
+    retval->size = 0; 
+    retval->deref = 0; 
+    retval->strict = 0; 
+ 
+    return retval; 
+} 
+ 
+yasm_insn_operand * 
+yasm_operand_create_segreg(uintptr_t segreg) 
+{ 
+    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand)); 
+ 
+    retval->type = YASM_INSN__OPERAND_SEGREG; 
+    retval->data.reg = segreg; 
+    retval->seg = 0; 
+    retval->targetmod = 0; 
+    retval->size = 0; 
+    retval->deref = 0; 
+    retval->strict = 0; 
+ 
+    return retval; 
+} 
+ 
+yasm_insn_operand * 
+yasm_operand_create_mem(/*@only@*/ yasm_effaddr *ea) 
+{ 
+    yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand)); 
+ 
+    retval->type = YASM_INSN__OPERAND_MEMORY; 
+    retval->data.ea = ea; 
+    retval->seg = 0; 
+    retval->targetmod = 0; 
+    retval->size = 0; 
+    retval->deref = 0; 
+    retval->strict = 0; 
+    retval->size = ea->data_len * 8; 
+ 
+    return retval; 
+} 
+ 
+yasm_insn_operand * 
+yasm_operand_create_imm(/*@only@*/ yasm_expr *val) 
+{ 
+    yasm_insn_operand *retval; 
+    const uintptr_t *reg; 
+ 
+    reg = yasm_expr_get_reg(&val, 0); 
+    if (reg) { 
+        retval = yasm_operand_create_reg(*reg); 
+        yasm_expr_destroy(val); 
+    } else { 
+        retval = yasm_xmalloc(sizeof(yasm_insn_operand)); 
+        retval->type = YASM_INSN__OPERAND_IMM; 
+        retval->data.val = val; 
+        retval->seg = 0; 
+        retval->targetmod = 0; 
+        retval->size = 0; 
+        retval->deref = 0; 
+        retval->strict = 0; 
+    } 
+ 
+    return retval; 
+} 
+ 
+yasm_insn_operand * 
+yasm_insn_ops_append(yasm_insn *insn, yasm_insn_operand *op) 
+{ 
+    if (op) { 
+        insn->num_operands++; 
+        STAILQ_INSERT_TAIL(&insn->operands, op, link); 
+        return op; 
+    } 
+    return (yasm_insn_operand *)NULL; 
+} 
+ 
+void 
+yasm_insn_add_prefix(yasm_insn *insn, uintptr_t prefix) 
+{ 
+    insn->prefixes = 
+        yasm_xrealloc(insn->prefixes, 
+                      (insn->num_prefixes+1)*sizeof(uintptr_t)); 
+    insn->prefixes[insn->num_prefixes] = prefix; 
+    insn->num_prefixes++; 
+} 
+ 
+void 
+yasm_insn_add_seg_prefix(yasm_insn *insn, uintptr_t segreg) 
+{ 
+    insn->segregs = 
+        yasm_xrealloc(insn->segregs, (insn->num_segregs+1)*sizeof(uintptr_t)); 
+    insn->segregs[insn->num_segregs] = segreg; 
+    insn->num_segregs++; 
+} 
+ 
+void 
+yasm_insn_initialize(yasm_insn *insn) 
+{ 
+    STAILQ_INIT(&insn->operands); 
+ 
+    insn->prefixes = NULL; 
+    insn->segregs = NULL; 
+ 
+    insn->num_operands = 0; 
+    insn->num_prefixes = 0; 
+    insn->num_segregs = 0; 
+} 
+ 
+void 
+yasm_insn_delete(yasm_insn *insn, 
+                 void (*ea_destroy) (/*@only@*/ yasm_effaddr *)) 
+{ 
+    if (insn->num_operands > 0) { 
+        yasm_insn_operand *cur, *next; 
+ 
+        cur = STAILQ_FIRST(&insn->operands); 
+        while (cur) { 
+            next = STAILQ_NEXT(cur, link); 
+            switch (cur->type) { 
+                case YASM_INSN__OPERAND_MEMORY: 
+                    ea_destroy(cur->data.ea); 
+                    break; 
+                case YASM_INSN__OPERAND_IMM: 
+                    yasm_expr_destroy(cur->data.val); 
+                    break; 
+                default: 
+                    break; 
+            } 
+            yasm_xfree(cur); 
+            cur = next; 
+        } 
+    } 
+    if (insn->num_prefixes > 0) 
+        yasm_xfree(insn->prefixes); 
+    if (insn->num_segregs > 0) 
+        yasm_xfree(insn->segregs); 
+} 
+ 
+void 
+yasm_insn_print(const yasm_insn *insn, FILE *f, int indent_level) 
+{ 
+    const yasm_insn_operand *op; 
+ 
+    STAILQ_FOREACH (op, &insn->operands, link) { 
+        switch (op->type) { 
+            case YASM_INSN__OPERAND_REG: 
+                fprintf(f, "%*sReg=", indent_level, ""); 
+                /*yasm_arch_reg_print(arch, op->data.reg, f);*/ 
+                fprintf(f, "\n"); 
+                break; 
+            case YASM_INSN__OPERAND_SEGREG: 
+                fprintf(f, "%*sSegReg=", indent_level, ""); 
+                /*yasm_arch_segreg_print(arch, op->data.reg, f);*/ 
+                fprintf(f, "\n"); 
+                break; 
+            case YASM_INSN__OPERAND_MEMORY: 
+                fprintf(f, "%*sMemory=\n", indent_level, ""); 
+                /*yasm_arch_ea_print(arch, op->data.ea, f, indent_level);*/ 
+                break; 
+            case YASM_INSN__OPERAND_IMM: 
+                fprintf(f, "%*sImm=", indent_level, ""); 
+                yasm_expr_print(op->data.val, f); 
+                fprintf(f, "\n"); 
+                break; 
+        } 
+        fprintf(f, "%*sTargetMod=%lx\n", indent_level+1, "", 
+                (unsigned long)op->targetmod); 
+        fprintf(f, "%*sSize=%u\n", indent_level+1, "", op->size); 
+        fprintf(f, "%*sDeref=%d, Strict=%d\n", indent_level+1, "", 
+                (int)op->deref, (int)op->strict); 
+    } 
+} 
+ 
+void 
+yasm_insn_finalize(yasm_insn *insn) 
+{ 
+    unsigned int i; 
+    yasm_insn_operand *op; 
+    yasm_error_class eclass; 
+    char *str, *xrefstr; 
+    unsigned long xrefline; 
+ 
+    /* Simplify the operands' expressions first. */ 
+    for (i = 0, op = yasm_insn_ops_first(insn); 
+         op && i<insn->num_operands; op = yasm_insn_op_next(op), i++) { 
+        /* Check operand type */ 
+        switch (op->type) { 
+            case YASM_INSN__OPERAND_MEMORY: 
+                /* Don't get over-ambitious here; some archs' memory expr 
+                 * parser are sensitive to the presence of *1, etc, so don't 
+                 * simplify reg*1 identities. 
+                 */ 
+                if (op->data.ea) 
+                    op->data.ea->disp.abs = 
+                        yasm_expr__level_tree(op->data.ea->disp.abs, 1, 1, 0, 
+                                              0, NULL, NULL); 
+                if (yasm_error_occurred()) { 
+                    /* Add a pointer to where it was used to the error */ 
+                    yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr); 
+                    if (xrefstr) { 
+                        yasm_error_set_xref(xrefline, "%s", xrefstr); 
+                        yasm_xfree(xrefstr); 
+                    } 
+                    if (str) { 
+                        yasm_error_set(eclass, "%s in memory expression", str); 
+                        yasm_xfree(str); 
+                    } 
+                    return; 
+                } 
+                break; 
+            case YASM_INSN__OPERAND_IMM: 
+                op->data.val = 
+                    yasm_expr__level_tree(op->data.val, 1, 1, 1, 0, NULL, 
+                                          NULL); 
+                if (yasm_error_occurred()) { 
+                    /* Add a pointer to where it was used to the error */ 
+                    yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr); 
+                    if (xrefstr) { 
+                        yasm_error_set_xref(xrefline, "%s", xrefstr); 
+                        yasm_xfree(xrefstr); 
+                    } 
+                    if (str) { 
+                        yasm_error_set(eclass, "%s in immediate expression", 
+                                       str); 
+                        yasm_xfree(str); 
+                    } 
+                    return; 
+                } 
+                break; 
+            default: 
+                break; 
+        } 
+    } 
+}