Add ragel machine generators to SCONS

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>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
+#include <iterator>
 #include <map>
 #include <set>
 #include <string>
 #include <tuple>
 #include <vector>
 
+#ifdef __GNUC__
+/* We use operand number formats here.  They are defined in SUSv2 and supported
+   on all POSIX systems (including all versions of Linux and MacOS), yet
+   -pedantic warns about them.  */
+#pragma GCC diagnostic ignored "-Wformat"
+/* GCC complains even when we explicitly use empty initializer list.  Can be
+   easily fixed with data member initializers, but this requires GCC 4.7+.  */
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+/* Default is perfectly valid way to handle missing cases.  Especially if we
+   only care about very few non-default ones as often here.  */
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#pragma GCC diagnostic error "-Wswitch"
+#endif
+
 template <typename T, size_t N>
 char (&ArraySizeHelper(T (&array)[N]))[N];
 #define arraysize(array) (sizeof(ArraySizeHelper(array)))
 
 namespace {
   const char* short_program_name;
 
   const struct option kProgramOptions[] = {
     {"mode",    required_argument,      NULL,   'm'},
     {"disable", required_argument,      NULL,   'd'},
@@ skipping 151 matching lines @@
      /* Flags for enabling/disabling based on architecture and validity.  */
      "ia32",
      "amd64",
      "nacl-ia32-forbidden",
      "nacl-amd64-forbidden",
      "nacl-forbidden"
   };
 
   class Instruction {
    public:
-    static bool check_flag_valid(const std::string &flag) {
+    static void check_flag_valid(const std::string &flag) {
       if (all_instruction_flags.find(flag) == all_instruction_flags.end()) {
         fprintf(stderr, "%s: unknown flag: '%s'\n",
                 short_program_name, flag.c_str());
         exit(1);
       }
     }
 
     void add_flag(const std::string &flag) {
       check_flag_valid(flag);
       flags.insert(flag);
@@ skipping 358 matching lines @@
       }
     }
     return name;
   }
 
   void print_common_decoding(void) {
     if (enabled(Actions::kRelOperandAction)) {
       fprintf(out_file, "  action rel8_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP8;\n"
 "    disp = p;\n"
 "  }\n"
 "  action rel16_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP16;\n"
 "    disp = p - 1;\n"
 "  }\n"
 "  action rel32_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP32;\n"
 "    disp = p - 3;\n"
 "  }\n"
 "");
     }
     fprintf(out_file,
 "  action branch_not_taken {\n"
 "    branch_not_taken = TRUE;\n"
 "  }\n"
@@ skipping 80 matching lines @@
 "  action imm64_second_operand {\n"
 "    imm2_operand = IMM64;\n"
 "    imm2 = p - 7;\n"
 "  }\n"
 "");
     }
     if (enabled(Actions::kParseOperands)) {
       if (ia32_mode) {
         fprintf(out_file, "  action modrm_only_base {\n"
 "    disp_type = DISPNONE;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = (*p) & 0x07;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_base_disp {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = (*p) & 0x07;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_disp {\n"
-"    base = REG_NONE;\n"
-"    index = REG_NONE;\n"
+"    base = NO_REG;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_index {\n"
 "    disp_type = DISPNONE;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = index_registers[((*p) & 0x38) >> 3];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n"
 "  action modrm_parse_sib {\n"
 "    disp_type = DISPNONE;\n"
 "    base = (*p) & 0x7;\n"
 "    index = index_registers[((*p) & 0x38) >> 3];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n");
       } else {
         fprintf(out_file, "  action modrm_only_base {\n"
 "    disp_type = DISPNONE;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = ((*p) & 0x07) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_base_disp {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = ((*p) & 0x07) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_rip {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = REG_RIP;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_index {\n"
 "    disp_type = DISPNONE;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = index_registers[(((*p) & 0x38) >> 3) |\n"
 "                           ((rex_prefix & 0x02) << 2) |\n"
 "                           (((~vex_prefix2) & 0x40) >> 3)];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n"
 "  action modrm_parse_sib {\n"
 "    disp_type = DISPNONE;\n"
 "    base = ((*p) & 0x7) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
@@ skipping 232 matching lines @@
     static const T vex_fields[] = {
       T { "NONE",       0xe0 },
       T { "R",          0x60 },
       T { "X",          0xa0 },
       T { "B",          0xc0 },
       T { "RX",         0x20 },
       T { "RB",         0x40 },
       T { "XB",         0x80 },
       T { "RXB",        0x00 }
     };
-    for (int vex_it = 0; vex_it < arraysize(vex_fields); ++vex_it) {
+    for (size_t vex_it = 0; vex_it < arraysize(vex_fields); ++vex_it) {
       auto vex = vex_fields[vex_it];
       fprintf(out_file, "  VEX_%2$s = %3$s%1$s;\n"
 "", enabled(Actions::kVexPrefix) && !ia32_mode ? " @vex_prefix2" : "",
        vex.first, chartest((c & vex.second) == vex.second));
     }
     static const T vex_map[] = {
       T { "01",         1       },
       T { "02",         2       },
       T { "03",         3       },
       T { "08",         8       },
       T { "09",         9       },
       T { "0A",         10      },
       T { "00001",      1       },
       T { "00010",      2       },
       T { "00011",      3       },
       T { "01000",      8       },
       T { "01001",      9       },
       T { "01010",      10      },
     };
-    for (int vex_it = 0; vex_it < arraysize(vex_map); ++vex_it) {
+    for (size_t vex_it = 0; vex_it < arraysize(vex_map); ++vex_it) {
       auto vex = vex_map[vex_it];
       fprintf(out_file, "  VEX_map%1$s = %2$s;\n"
 "", vex.first, chartest((c & 0x1f) == vex.second));
     }
     if (enabled(Actions::kOpcode)) {
       fprintf(out_file, "\n"
 "  action begin_opcode {\n"
 "    begin_opcode = p;\n"
 "  }\n"
 "  action end_opcode {\n"
@@ skipping 34 matching lines @@
           T { "x87",                    "ST"                            },
           T { "mmx",                    "MMX"                           },
           T { "xmm",                    "XMM"                           },
           T { "ymm",                    "YMM"                           },
           T { "farptr",                 "FarPtr"                        },
           T { "segreg",                 "SegmentRegister"               },
           T { "creg",                   "ControlRegister"               },
           T { "dreg",                   "DebugRegister"                 },
           T { "selector",               "Selector"                      }
         };
-        for (int size_it = 0; size_it < arraysize(sizes); ++size_it) {
+        for (size_t size_it = 0; size_it < arraysize(sizes); ++size_it) {
           auto size = sizes[size_it];
           fprintf(out_file, "  action operand%1$d_%2$s {\n"
 "    operand%1$d_type = Operand%3$s;\n"
 "  }\n"
 "", i, size.first, size.second);
         }
         if (ia32_mode) {
           fprintf(out_file, "  action operand%1$d_absolute_disp {\n"
 "    operand%1$d = REG_RM;\n"
-"    base = REG_NONE;\n"
-"    index = REG_NONE;\n"
+"    base = NO_REG;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action operand%1$d_from_opcode {\n"
 "    operand%1$d = (*p) & 0x7;\n"
 "  }\n"
 "  action operand%1$d_from_is4 {\n"
 "    operand%1$d = p[0] >> 4;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_rm {\n"
 "    operand%1$d = (*p) & 0x07;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_reg {\n"
 "    operand%1$d = ((*p) & 0x38) >> 3;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_reg_norex {\n"
 "    operand%1$d = ((*p) & 0x38) >> 3;\n"
 "  }\n"
 "  action operand%1$d_from_vex {\n"
 "    operand%1$d = ((~vex_prefix3) & 0x38) >> 3;\n"
 "  }\n"
 "", i);
         } else {
           fprintf(out_file, "  action operand%1$d_absolute_disp {\n"
 "    operand%1$d = REG_RM;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = REG_RIZ;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action operand%1$d_from_opcode {\n"
 "    operand%1$d = ((*p) & 0x7) |\n"
 "              ((rex_prefix & 0x01) << 3) |\n"
 "              (((~vex_prefix2) & 0x20) >> 2);\n"
 "  }\n"
 "  action operand%1$d_from_is4 {\n"
 "    operand%1$d = p[0] >> 4;\n"
@@ skipping 22 matching lines @@
           T { "es_rdi",                 "REG_ES_RDI"    },
           T { "immediate",              "REG_IMM"       },
           T { "second_immediate",       "REG_IMM2"      },
           T { "port_dx",                "REG_PORT_DX"   },
           T { "rax",                    "REG_RAX"       },
           T { "rcx",                    "REG_RCX"       },
           T { "rdx",                    "REG_RDX"       },
           T { "rm",                     "REG_RM"        },
           T { "st",                     "REG_ST"        }
         };
-        for (int type_it = 0; type_it < arraysize(types); ++type_it) {
+        for (size_t type_it = 0; type_it < arraysize(types); ++type_it) {
           auto type = types[type_it];
           fprintf(out_file, "  action operand%1$d_%2$s {\n"
 "    operand%1$d = %3$s;\n"
 "  }\n"
 "", i, type.first, type.second);
         }
       }
     }
     if (enabled(Actions::kParseOperandsStates)) {
       for (auto i = 0 ; i < 5; ++i) {
         fprintf(out_file, "  action operand%1$d_unused {\n"
-"    operand%1$d_read = false;\n"
-"    operand%1$d_write = false;\n"
+"    operand%1$d_read = FALSE;\n"
+"    operand%1$d_write = FALSE;\n"
 "  }\n"
 "  action operand%1$d_read {\n"
-"    operand%1$d_read = true;\n"
-"    operand%1$d_write = false;\n"
+"    operand%1$d_read = TRUE;\n"
+"    operand%1$d_write = FALSE;\n"
 "  }\n"
 "  action operand%1$d_write {\n"
-"    operand%1$d_read = false;\n"
-"    operand%1$d_write = true;\n"
+"    operand%1$d_read = FALSE;\n"
+"    operand%1$d_write = TRUE;\n"
 "  }\n"
 "  action operand%1$d_readwrite {\n"
-"    operand%1$d_read = true;\n"
-"    operand%1$d_write = true;\n"
+"    operand%1$d_read = TRUE;\n"
+"    operand%1$d_write = TRUE;\n"
 "  }\n"
 "", i);
       }
     }
   }
 
   void print_name_actions(void) {
     for (auto pair_it = instruction_names.begin();
          pair_it != instruction_names.end(); ++pair_it) {
       auto &pair = *pair_it;
       fprintf(out_file, "  action instruction_%s"
         " { instruction_name = instruction_names + %zd; }\n",
                                  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_)),
-        opcode_in_modrm(false), opcode_in_imm(false), rex { } {
+        rex { }, opcode_in_modrm(false), opcode_in_imm(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 27 matching lines @@
                   }
                   opcode->push_back(')');
                   if (saved_opcode == "0x97") {
                     opcode->erase(1, 5);
                   }
                   break;
                 case '8':
                   (*opcode) = "(";
                   opcode->append(saved_opcode);
                   static const char cc[] = {'9', 'a', 'b', 'c', 'd', 'e', 'f'};
-                  for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+                  for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
                     auto c = cc[c_it];
                     opcode->push_back('|');
                     (*(saved_opcode.rbegin())) = c;
                     opcode->append(saved_opcode);
                   }
                   opcode->push_back(')');
                   break;
                 default:
                   fprintf(stderr, "%s: error - can not use 'r' operand in "
                     "instruction '%s'", short_program_name, name.c_str());
@@ skipping 251 matching lines @@
               if (saved_class == InstructionClass::kLSetUnsetDefaultRexW) {
                 instruction_class = InstructionClass::kRexW;
                 print_one_size_definition_rexw();
               }
               opcode[Lbit] = '0';
               auto saved_operands = operands;
               for (auto operand_it = operands.begin();
                    operand_it != operands.end(); ++operand_it) {
                 auto &operand = *operand_it;
                 static const char cc[] = {'H', 'L', 'U', 'V', 'W'};
-                for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+                for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
                   auto c = cc[c_it];
                   if ((operand.source == c) &&
                       (*(operand.size.rbegin()) == 'x') &&
                       (((operand.size.length() > 1) &&
                         (operand.size[0] == 'p')) ||
                        (operand.size.length() == 1))) {
                     operand.size.resize(operand.size.length() - 1);
                   }
                 }
               }
@@ skipping 18 matching lines @@
       }
     }
 
     void print_one_size_definition(void) {
       /* 64bit commands are not supported in ia32 mode.  */
       if (ia32_mode && rex.w) {
         return;
       }
       bool modrm_memory = false;
       bool modrm_register = false;
-      char operand_source;
+      char operand_source = ' ';
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         static std::map<char, std::pair<bool, bool> > operand_map {
           { 'E', std::make_pair(true,  true) },
           { 'M', std::make_pair(true,  false) },
           { 'N', std::make_pair(false, true) },
           { 'Q', std::make_pair(true,  true) },
           { 'R', std::make_pair(false, true) },
           { 'U', std::make_pair(false, true) },
@@ skipping 103 matching lines @@
 
     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    }
       };
-      for (int mode_it = 0; mode_it < arraysize(modes); ++mode_it) {
+      for (size_t mode_it = 0; mode_it < arraysize(modes); ++mode_it) {
         auto mode = modes[mode_it];
         print_operator_delimeter();
         if (mod_reg_is_used()) {
           rex.r = true;
         }
         if (mod_rm_is_used()) {
           rex.x = std::get<1>(mode);
           rex.b = std::get<2>(mode);
         }
         print_legacy_prefixes();
@@ skipping 59 matching lines @@
 
     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 (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+        for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
           auto c = cc[c_it];
           if (operand.source == c) {
             return true;
           }
         }
       }
       return false;
     }
 
     bool mod_rm_is_used() {
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         static const char cc[] = { 'E', 'M', 'N', 'Q', 'R', 'U', 'W' };
-        for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+        for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
           auto c = cc[c_it];
           if (operand.source == c) {
             return true;
           }
         }
       }
       return false;
     }
 
     void print_legacy_prefixes(void) {
@@ skipping 130 matching lines @@
         if (ia32_mode || (!rex.r && !rex.x & !rex.b)) {
           fprintf(out_file, "NONE");
         } else {
           if (rex.r) fprintf(out_file, "R");
           if (rex.x) fprintf(out_file, "X");
           if (rex.b) fprintf(out_file, "B");
         }
         fprintf(out_file, " & VEX_map%s) ", opcodes[1].c_str() + 4);
         auto third_byte = opcodes[2];
         static const char* symbolic_names[] = { "cntl", "dest", "src1", "src" };
-        for (int symbolic_it = 0;
+        for (size_t symbolic_it = 0;
              symbolic_it < arraysize(symbolic_names); ++symbolic_it) {
           auto symbolic = symbolic_names[symbolic_it];
           for (auto it = third_byte.begin(); it != third_byte.end(); ++it) {
-            if ((third_byte.end() - it) >= strlen(symbolic) &&
-                !strncmp(&*it, symbolic, strlen(symbolic))) {
+            if (static_cast<size_t>(third_byte.end() - it) >=
+                                                          strlen(symbolic) &&
+                                   !strncmp(&*it, symbolic, strlen(symbolic))) {

[pasko-google - do not use, 2012/04/05 14:16:38]

I do not like how this is formatted. Should be shifted by 4, mot aligned to the
right border.

btw, this can look less ugly if you added in front of the loop:
size_t symbolic_len = strlen(symbolic);

[khim, 2012/04/05 16:38:43]

Whatever. I don't really care about this file (I have clean version anyway).

Done.

               third_byte.replace(it, it + strlen(symbolic), "XXXX");
               break;
             }
           }
         }
         static const std::set<char> third_byte_check[] {
           { '0', '1', 'x', 'X', 'W' },
           { '.' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '.' },
           { '0', '1', 'x', 'X' },
           { '.' },
           { '0', '1' },
           { '0', '1' }
         };
         auto third_byte_ok = (arraysize(third_byte_check) ==
                                                            third_byte.length());

[pasko-google - do not use, 2012/04/05 14:16:38]

spacing, better be:
bool third_byte_ok =
    (arraysize(third_byte_check) == third_byte.length());

[khim, 2012/04/05 16:38:43]

Done.

         if (third_byte_ok) {
-          for (int set_it = 0; set_it < arraysize(third_byte_check); ++set_it) {
+          for (size_t set_it = 0; set_it < arraysize(third_byte_check);
+                                                                     ++set_it) {

[pasko-google - do not use, 2012/04/05 14:16:38]

shiftwidth = 4

[khim, 2012/04/05 16:38:43]

Done.

             auto &set = third_byte_check[set_it];
             if (set.find(third_byte[&set - third_byte_check]) == set.end()) {
               third_byte_ok = false;
               break;
             }
           }
         }
         if (third_byte_ok) {
           if (ia32_mode && third_byte[2] == 'X') {
             third_byte[2] = '1';
@@ skipping 528 matching lines @@
 
   fprintf(out_file, "\n  one_instruction =");
 
   print_one_instruction_definition();
 
   fprintf(out_file, ");\n"
 "}%%%%\n"
 "");
   return 0;
 }