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>
 
+#ifndef NACL_TRUSTED_BUT_NOT_TCB
+#error("This file is not meant for use in the TCB")
+#endif
+
+#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 102 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_delimiter();
         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) &&
+            auto symbolic_len = strlen(symbolic);
+            if (static_cast<size_t>(third_byte.end() - it) >= symbolic_len &&
                 !strncmp(&*it, symbolic, strlen(symbolic))) {
               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());
+            third_byte.length());
         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) {
             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;
 }