Update our yasm copy to yasm 1.1.0 (Part 1: yasm side)...

third_party/yasm/patched-yasm/modules/parsers/nasm/nasm-parse.c

 /*
  * NASM-compatible parser
  *
  *  Copyright (C) 2001-2007  Peter Johnson, Michael Urman
  *
  * 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>
-RCSID("$Id: nasm-parse.c 2191 2009-03-25 03:42:05Z peter $");
+RCSID("$Id: nasm-parse.c 2323 2010-05-16 03:37:00Z peter $");
 
 #include <libyasm.h>
 
 #include <math.h>
 
 #include "modules/parsers/nasm/nasm-parser.h"
 #include "modules/preprocs/nasm/nasm.h"
 
 typedef enum {
     NORM_EXPR,
@@ skipping 132 matching lines @@
         case INCBIN:            str = "INCBIN"; break;
         case EQU:               str = "EQU"; break;
         case TIMES:             str = "TIMES"; break;
         case SEG:               str = "SEG"; break;
         case WRT:               str = "WRT"; break;
         case NOSPLIT:           str = "NOSPLIT"; break;
         case STRICT:            str = "STRICT"; break;
         case INSN:              str = "instruction"; break;
         case PREFIX:            str = "instruction prefix"; break;
         case REG:               str = "register"; break;
+        case REGGROUP:          str = "register group"; break;
         case SEGREG:            str = "segment register"; break;
         case TARGETMOD:         str = "target modifier"; break;
         case LEFT_OP:           str = "<<"; break;
         case RIGHT_OP:          str = ">>"; break;
         case SIGNDIV:           str = "//"; break;
         case SIGNMOD:           str = "%%"; break;
         case START_SECTION_ID:  str = "$$"; break;
         case ID:                str = "identifier"; break;
         case LOCAL_ID:          str = ".identifier"; break;
         case SPECIAL_ID:        str = "..identifier"; break;
@@ skipping 118 matching lines @@
             incr = INTNUM_val;
             get_next_token();
 
             if (!expect(FILENAME)) return NULL;
             filename = FILENAME_val;
             get_next_token();
 
             /* %line indicates the line number of the *next* line, so subtract
              * out the increment when setting the line number.
              */
-            yasm_linemap_set(parser_nasm->linemap, filename,
+            yasm_linemap_set(parser_nasm->linemap, filename, 0,
                 yasm_intnum_get_uint(line) - yasm_intnum_get_uint(incr),
                 yasm_intnum_get_uint(incr));
             yasm_intnum_destroy(line);
             yasm_intnum_destroy(incr);
             yasm_xfree(filename);
             return NULL;
         }
         case '[': /* [ directive ] */
         {
             char *dirname;
             yasm_valparamhead dir_vps;
             int have_vps = 1;
 
             parser_nasm->state = DIRECTIVE;
             get_next_token();
 
             if (!expect(DIRECTIVE_NAME))
                 return NULL;
             dirname = DIRECTIVE_NAME_val;
             get_next_token();
 
+            /* ignore [warning].  TODO: actually implement */
+            if (yasm__strcasecmp(dirname, "warning") == 0) {
+                yasm_warn_set(YASM_WARN_GENERAL,
+                    N_("[warning] directive not supported; ignored"));
+
+                /* throw away the rest of the directive tokens */
+                while (!is_eol() && curtok != ']')
+                {
+                    destroy_curtok();
+                    get_next_token();
+                }
+                expect(']');
+                get_next_token();
+                return NULL;
+            }
+
             if (curtok == ']' || curtok == ':')
                 have_vps = 0;
             else if (!parse_directive_valparams(parser_nasm, &dir_vps)) {
                 yasm_error_set(YASM_ERROR_SYNTAX,
                                N_("invalid arguments to [%s]"), dirname);
                 yasm_xfree(dirname);
                 return NULL;
             }
             if (curtok == ':') {
                 yasm_valparamhead ext_vps;
@@ skipping 485 matching lines @@
                 ea = yasm_arch_ea_create(p_object->arch, e);
                 yasm_ea_set_implicit_size_segment(parser_nasm, ea, e);
                 op = yasm_operand_create_mem(ea);
             }
             return op;
         }
         case OFFSET:
         {
             yasm_insn_operand *op2;
             get_next_token();
+            if (parser_nasm->masm && curtok == ID && !yasm__strcasecmp(ID_val, "flat")) {
+                get_next_token();
+                if (curtok == ':') {
+                    get_next_token();
+                }
+            }
             op = parse_operand(parser_nasm);
             if (!op) {
                 yasm_error_set(YASM_ERROR_SYNTAX,
                                N_("memory address expected"));
                 return NULL;
             }
             if (op->type == YASM_INSN__OPERAND_IMM)
                 return op;
             if (op->type != YASM_INSN__OPERAND_MEMORY) {
                 yasm_error_set(YASM_ERROR_SYNTAX,
@@ skipping 41 matching lines @@
                 yasm_ea_set_segreg(op->data.ea, segreg);
                 return op;
             }
             op = yasm_operand_create_segreg(segreg);
             return op;
         }
         case REG:
             op = yasm_operand_create_reg(REG_val);
             get_next_token();
             return op;
+        case REGGROUP:
+        {
+            unsigned long regindex;
+            uintptr_t reg = REGGROUP_val;
+            get_next_token(); /* REGGROUP */
+            if (curtok != '(')
+                return yasm_operand_create_reg(reg);
+            get_next_token(); /* '(' */
+            if (!expect(INTNUM)) {
+                yasm_error_set(YASM_ERROR_SYNTAX,
+                               N_("integer register index expected"));
+                return NULL;
+            }
+            regindex = yasm_intnum_get_uint(INTNUM_val);
+            get_next_token(); /* INTNUM */
+            if (!expect(')')) {
+                yasm_error_set(YASM_ERROR_SYNTAX,
+                    N_("missing closing parenthesis for register index"));
+                return NULL;
+            }
+            get_next_token(); /* ')' */
+            reg = yasm_arch_reggroup_get_reg(p_object->arch, reg, regindex);
+            if (reg == 0) {
+                yasm_error_set(YASM_ERROR_SYNTAX, N_("bad register index `%u'"),
+                               regindex);
+                return NULL;
+            }
+            return yasm_operand_create_reg(reg);
+        }
         case STRICT:
             get_next_token();
             op = parse_operand(parser_nasm);
             if (op)
                 op->strict = 1;
             return op;
         case SIZE_OVERRIDE:
         {
             unsigned int size = SIZE_OVERRIDE_val;
             get_next_token();
+            if (parser_nasm->masm && curtok == ID && !yasm__strcasecmp(ID_val, "ptr")) {
+                get_next_token();
+            }
             op = parse_operand(parser_nasm);
             if (!op)
                 return NULL;
             if (op->type == YASM_INSN__OPERAND_REG &&
                 yasm_arch_get_reg_size(p_object->arch, op->data.reg) != size)
                 yasm_error_set(YASM_ERROR_TYPE,
                                N_("cannot override register size"));
             else {
                 /* Silently override others unless a warning is turned on.
                  * This is to allow overrides such as:
@@ skipping 54 matching lines @@
                     op = yasm_operand_create_mem(ea);
                     return op;
                 }
             }
             /* Fallthrough */
         default:
         {
             yasm_expr *e = parse_bexpr(parser_nasm, NORM_EXPR);
             if (!e)
                 return NULL;
-            if (curtok != ':')
+            if (curtok != ':') {
                 if (parser_nasm->tasm && yasm_expr_size(e)) {
                     yasm_effaddr *ea = yasm_arch_ea_create(p_object->arch, e);
                     yasm_ea_set_implicit_size_segment(parser_nasm, ea, e);
                     op = yasm_operand_create_mem(ea);
                     return op;
-                } else
+                } else if (curtok == '[') {
+                    yasm_expr *f;
+                    yasm_effaddr *ea;
+                    yasm_insn_operand *op2;
+
+                    op = parse_operand(parser_nasm);
+                    if (!op)
+                        return NULL;
+    
+                    f = op->data.ea->disp.abs;
+                    e = p_expr_new_tree(e, YASM_EXPR_ADD, f);
+                    ea = yasm_arch_ea_create(p_object->arch, e);
+                    yasm_ea_set_implicit_size_segment(parser_nasm, ea, e);
+                    op2 = yasm_operand_create_mem(ea);
+
+                    yasm_xfree(op);
+
+                    return op2;
+                } else {
                     return yasm_operand_create_imm(e);
-            else {
+                }
+            } else {
                 yasm_expr *off;
                 get_next_token();
                 off = parse_bexpr(parser_nasm, NORM_EXPR);
                 if (!off) {
                     yasm_expr_destroy(e);
                     return NULL;
                 }
                 op = yasm_operand_create_imm(off);
                 op->seg = e;
                 return op;
@@ skipping 246 matching lines @@
     }
     return e;
 }
 
 static yasm_expr *
 parse_expr6(yasm_parser_nasm *parser_nasm, expr_type type)
 {
     yasm_expr *e;
     yasm_symrec *sym;
 
-    /* directives allow very little and handle IDs specially */
-    if (type == DIR_EXPR) {
-        switch (curtok) {
-        case '~':
-            get_next_token();
-            e = parse_expr6(parser_nasm, type);
-            if (!e) {
-                yasm_error_set(YASM_ERROR_SYNTAX,
-                               N_("expected expression after %s"), "`~'");
-                return NULL;
-            }
-            return p_expr_new_branch(YASM_EXPR_NOT, e);
-        case '(':
-            get_next_token();
-            e = parse_expr(parser_nasm, type);
-            if (!e) {
-                yasm_error_set(YASM_ERROR_SYNTAX,
-                               N_("expected expression after %s"), "`('");
-                return NULL;
-            }
-            if (!expect(')')) {
-                yasm_error_set(YASM_ERROR_SYNTAX, N_("missing parenthesis"));
-                return NULL;
-            }
-            get_next_token();
-            return e;
-        case INTNUM:
-            e = p_expr_new_ident(yasm_expr_int(INTNUM_val));
-            break;
-        case REG:
-            e = p_expr_new_ident(yasm_expr_reg(REG_val));
-            break;
-        case ID:
-            sym = yasm_symtab_use(p_symtab, ID_val, cur_line);
-            e = p_expr_new_ident(yasm_expr_sym(sym));
-            yasm_xfree(ID_val);
-            break;
-        default:
-            return NULL;
-        }
-    } else switch (curtok) {
+    switch (curtok) {
         case '+':
             get_next_token();
             e = parse_expr6(parser_nasm, type);
             if (!e) {
                 yasm_error_set(YASM_ERROR_SYNTAX,
                                N_("expected expression after %s"), "`+'");
             }
             return e;
         case '-':
             get_next_token();
@@ skipping 55 matching lines @@
                 return NULL;
             }
             if (!expect(')')) {
                 yasm_error_set(YASM_ERROR_SYNTAX, N_("missing parenthesis"));
                 return NULL;
             }
             get_next_token();
             return e;
         case INTNUM:
             e = p_expr_new_ident(yasm_expr_int(INTNUM_val));
-            break;
-        case FLTNUM:
-            e = p_expr_new_ident(yasm_expr_float(FLTNUM_val));
-            break;
+            get_next_token();
+            return e;
         case REG:
             if (type == DV_EXPR) {
                 yasm_error_set(YASM_ERROR_SYNTAX,
                                N_("data values can't have registers"));
                 return NULL;
             }
             e = p_expr_new_ident(yasm_expr_reg(REG_val));
+            get_next_token();
+            return e;
+    }
+
+    /* directives allow very little and handle IDs specially */
+    if (type == DIR_EXPR) {
+        switch (curtok) {
+        case ID:
+            sym = yasm_symtab_use(p_symtab, ID_val, cur_line);
+            e = p_expr_new_ident(yasm_expr_sym(sym));
+            yasm_xfree(ID_val);
+            break;
+        default:
+            return NULL;
+        }
+    } else switch (curtok) {
+        case FLTNUM:
+            e = p_expr_new_ident(yasm_expr_float(FLTNUM_val));
             break;
         case STRING:
         {
             yasm_intnum *intn;
             if (parser_nasm->tasm)
                 intn = yasm_intnum_create_charconst_tasm(STRING_val.contents);
             else
                 intn = yasm_intnum_create_charconst_nasm(STRING_val.contents);
             e = p_expr_new_ident(yasm_expr_int(intn));
             yasm_xfree(STRING_val.contents);
@@ skipping 30 matching lines @@
                 e = yasm_expr_copy(parser_nasm->absstart);
             else {
                 sym = yasm_symtab_define_label(p_symtab, "$$",
                     yasm_section_bcs_first(cursect), 0, cur_line);
                 e = p_expr_new_ident(yasm_expr_sym(sym));
             }
             break;
         default:
             return NULL;
     }
+
     get_next_token();
     return e;
 }
 
 static void
 set_nonlocal_label(yasm_parser_nasm *parser_nasm, const char *name)
 {
     if (!parser_nasm->tasm || tasm_locals) {
         if (parser_nasm->locallabel_base)
             yasm_xfree(parser_nasm->locallabel_base);
@@ skipping 146 matching lines @@
     if (cursect) {
         /* In case cursect changed or a bytecode was added, update prev_bc. */
         parser_nasm->prev_bc = yasm_section_bcs_last(cursect);
     }
 
     if (valparams)
         yasm_vps_delete(valparams);
     if (objext_valparams)
         yasm_vps_delete(objext_valparams);
 }
+
+yasm_bytecode *
+gas_intel_syntax_parse_instr(yasm_parser_nasm *parser_nasm, unsigned char *instr)
+{
+    yasm_bytecode *bc = NULL;
+    char *sinstr = (char *) instr;
+
+    parser_nasm->s.bot = instr;
+    parser_nasm->s.tok = instr;
+    parser_nasm->s.ptr = instr;
+    parser_nasm->s.cur = instr;
+    parser_nasm->s.lim = instr + strlen(sinstr) + 1;
+    parser_nasm->s.top = parser_nasm->s.lim;
+    parser_nasm->peek_token = NONE;
+
+    get_next_token();
+    if (!is_eol()) {
+        bc = parse_instr(parser_nasm);
+    }
+
+    return bc;
+}