validator_ragel: Use different actions for different types of commands

src/trusted/validator_ragel/unreviewed/gen-dfa.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <fcntl.h>
 #include <getopt.h>
 #include <libgen.h>
 #include <stdio.h>
@@ skipping 1234 matching lines @@
                                  c_identifier(pair.first).c_str(), pair.second);
     }
   }
 
   class MarkedInstruction : Instruction {
    public:
     /* Additional marks are created in the process of parsing. */
     explicit MarkedInstruction(Instruction instruction_) :
         Instruction(instruction_),
         instruction_class(get_instruction_class(instruction_)),
-        rex { }, opcode_in_modrm(false), opcode_in_imm(false) {
+        rex { }, opcode_in_modrm(false), opcode_in_imm(false),
+        rm_half_enabled(false) {
       if (has_flag("branch_hint")) {
         optional_prefixes.insert("branch_hint");
       }
       if (has_flag("condrep")) {
         optional_prefixes.insert("condrep");
       }
       if (has_flag("rep")) {
         optional_prefixes.insert("rep");
       }
       for (auto opcode_it = opcodes.begin();
@@ skipping 113 matching lines @@
     std::multiset<std::string> required_prefixes;
     std::multiset<std::string> optional_prefixes;
     struct {
       bool b : 1;
       bool x : 1;
       bool r : 1;
       bool w : 1;
     } rex;
     bool opcode_in_modrm : 1;
     bool opcode_in_imm : 1;
+    bool rm_half_enabled : 1;
 
     static InstructionClass get_instruction_class(
                                                const Instruction &instruction) {
       InstructionClass instruction_class = InstructionClass::kUnknown;
       for (auto operand_it = instruction.operands.begin();
            operand_it != instruction.operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         static const std::map<std::string, InstructionClass> classes_map {
           /* 'size8' is special 'prefix' not included in AMD manual:  w bit in
              opcode switches between 8bit and 16/32/64 bit versions.  M is just
@@ skipping 285 matching lines @@
       print_legacy_prefixes();
       print_rex_prefix();
       print_opcode_nomodrm();
       if (opcode_in_imm) {
         print_immediate_opcode();
         print_opcode_recognition(false);
       } else {
         print_opcode_recognition(false);
         print_immediate_arguments();
       }
+      print_instruction_processing();
     }
 
     void print_one_size_definition_modrm_register(void) {
       print_operator_delimiter();
       if (mod_reg_is_used()) {
         rex.r = true;
       }
       if (mod_rm_is_used()) {
         rex.b = true;
       }
@@ skipping 38 matching lines @@
       }
       if (opcode_in_modrm) {
         fprintf(out_file, ")");
       }
       if (opcode_in_imm) {
         print_immediate_opcode();
         print_opcode_recognition(false);
       } else {
         print_immediate_arguments();
       }
+      print_instruction_processing();
     }
 
     void print_one_size_definition_modrm_memory(void) {
       typedef std::tuple<const char *, bool, bool> T;
       static const T modes[] = {
         T { " operand_disp",            false,  true    },
         T { " operand_rip",             false,  false   },
         T { " single_register_memory",  false,  true    },
         T { " operand_sib_pure_index",  true,   false   },
         T { " operand_sib_base_index",  true,   true    }
@@ skipping 34 matching lines @@
               { 'P', "from_modrm_reg"         },
               { 'Q', "rm"                     },
               { 'R', "rm"                     },
               { 'S', "from_modrm_reg_norex"   },
               { 'U', "rm"                     },
               { 'V', "from_modrm_reg"         },
               { 'W', "rm"                     }
             };
             if (operand.enabled) {
               auto it = operand_type.find(operand.source);
-              if (it != operand_type.end() &&
-                  (strcmp(it->second, "rm") ||
-                   enabled(Actions::kParseOperandPositions))) {
-                fprintf(out_file, " @operand%zd_%s", operand_index, it->second);
+              if (it != operand_type.end()) {
+                if (enabled(Actions::kParseOperandPositions) ||
+                    strcmp(it->second, "rm")) {
+                  fprintf(out_file, " @operand%zd_%s", operand_index, it->second);

[pasko-google - do not use, 2012/05/12 13:54:31]

80

[pasko-google - do not use, 2012/05/12 13:54:31]

80

+                } else {
+                  rm_half_enabled = true;

[pasko-google - do not use, 2012/05/12 13:54:31]

if (enabled(Actions::kParseOperandPositions) || operand_allows_mem(operand)) {
  fprintf(out_file, " @operand ...

bool has_mem_operand() {
  for (auto operand_it = operands.begin(); operand_it != operands.end();
++operand_it) {
    if (allows_mem(*operand_it)) {
      return TRUE;
    }
  }
  return false;
}

[khim, 2012/05/12 14:32:16]

Done.

+                }
               }
             }
             if (operand.enabled || enabled(Actions::kParseOperandPositions)) {
               ++operand_index;
             }
           }
         }
         fprintf(out_file, " . any* &%s", std::get<0>(mode));
         if (enabled(Actions::kCheckAccess) && !has_flag("no_memory_access")) {
           fprintf(out_file, " @check_access");
         }
         fprintf(out_file, ")");
         if (opcode_in_imm) {
           print_immediate_opcode();
           print_opcode_recognition(true);
         } else {
           print_immediate_arguments();
         }
+        print_instruction_processing();
       }
     }
 
     static bool first_delimiter;
     void print_operator_delimiter(void) {
       if (first_delimiter) {
         fprintf(out_file, "\n    (");
       } else {
         fprintf(out_file, ") |\n    (");
       }
       first_delimiter = false;
     }
 
+    void print_instruction_processing() {

[pasko-google - do not use, 2012/05/12 13:54:31]

print_inst_end_actions

[khim, 2012/05/12 14:32:16]

Done.

+      if (enabled(Actions::kParseOperands)) {
+        if (!enabled(Actions::kParseOperandPositions)) {
+          int operands_count = rm_half_enabled ? -1 : 0;
+          for (auto operand_it = operands.begin();
+               operand_it != operands.end(); ++operand_it) {
+            auto &operand = *operand_it;
+            if (operand.enabled) {
+              ++operands_count;
+            }
+          }
+          fprintf(out_file, " @process_%d_operands", operands_count);
+        }
+      }
+    }
+
     bool mod_reg_is_used() {
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         if (operand.source == 'C' &&
             required_prefixes.find("0xf0") == required_prefixes.end()) {
           return true;
         }
         static const char cc[] = { 'G', 'P', 'V' };
         for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
@@ skipping 809 matching lines @@
 
   fprintf(out_file, "\n  one_instruction =");
 
   print_one_instruction_definition();
 
   fprintf(out_file, ");\n"
 "}%%%%\n"
 "");
   return 0;
 }