Add ragel machine generators to SCONS

src/trusted/validator_ragel/unreviewed/validator-x86_64.rl

 /*
  * 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 <assert.h>
-#include <elf.h>
-#include <inttypes.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "validator.h"
+
+#include "native_client/src/trusted/validator_ragel/unreviewed/validator.h"
+
+#if defined(_MSC_VER)
+#define inline __inline
+#endif
 
 #undef TRUE
 #define TRUE    1
 
 #undef FALSE
 #define FALSE   0
 
-#include "validator-x86_64-instruction-consts.c"
+#include "native_client/src/trusted/validator_ragel/generated/validator-x86_64-instruction-consts.c"
 
 #define check_jump_dest \
     if ((jump_dest & bundle_mask) != bundle_mask) { \
       if (jump_dest >= size) { \
-        printf("direct jump out of range: %zx\n", jump_dest); \
+        printf("direct jump out of range: %"NACL_PRIxS"\n", jump_dest); \
         result = 1; \
         goto error_detected; \
       } else { \
         BitmapSetBit(jump_dests, jump_dest + 1); \
       } \
     } \
     operand0 = JMP_TO; \
     base = REG_RIP; \
-    index = REG_NONE;
+    index = NO_REG;
 
 static void PrintError(const char* msg, uintptr_t ptr) {
-  printf("offset 0x%zx: %s", ptr, msg);
+  printf("offset 0x%"NACL_PRIxS": %s", ptr, msg);
 }
 
 %%{
   machine x86_64_decoder;
   alphtype unsigned char;
 
   action check_access {
     if ((base == REG_RIP) || (base == REG_R15) ||
         ((base == REG_RSP) && (restricted_register != REG_RSP)) ||
         ((base == REG_RBP) && (restricted_register != REG_RBP))) {
       if ((index == restricted_register) ||
           ((index == REG_RDI) &&
            (restricted_register == kSandboxedRsiRestrictedRdi))) {
         BitmapClearBit(valid_targets, begin - data);
-      } else if ((index != REG_NONE) && (index != REG_RIZ)) {
+      } else if ((index != NO_REG) && (index != REG_RIZ)) {
         PrintError("Improper sandboxing in instruction\n", begin - data);
         result = 1;
         goto error_detected;
       }
     } else if ((index == REG_RIP) || (index == REG_R15) ||
                ((index == REG_RSP) && (restricted_register != REG_RSP)) ||
                ((index == REG_RBP) && (restricted_register != REG_RBP))) {
       if ((base == restricted_register) ||
           ((base == REG_RDI) &&
            (restricted_register == kSandboxedRsiRestrictedRdi))) {
         BitmapClearBit(valid_targets, begin - data);
-      } else if ((base != REG_NONE) && (base != REG_RIZ)) {
+      } else if ((base != NO_REG) && (base != REG_RIZ)) {
         PrintError("Improper sandboxing in instruction\n", begin - data);
         result = 1;
         goto error_detected;
       }
     } else {
       PrintError("Improper sandboxing in instruction\n", begin - data);
       result = 1;
       goto error_detected;
     }
   }
@@ skipping 330 matching lines @@
   IMMNONE,
   IMM2,
   IMM8,
   IMM16,
   IMM32,
   IMM64
 };
 
 static const int kBitsPerByte = 8;
 
-static inline uint8_t *BitmapAllocate(uint32_t indexes) {
-  uint32_t byte_count = (indexes + kBitsPerByte - 1) / kBitsPerByte;
+static inline uint8_t *BitmapAllocate(size_t indexes) {
+  size_t byte_count = (indexes + kBitsPerByte - 1) / kBitsPerByte;
   uint8_t *bitmap = malloc(byte_count);
   if (bitmap != NULL) {
     memset(bitmap, 0, byte_count);
   }
   return bitmap;
 }
 
-static inline int BitmapIsBitSet(uint8_t *bitmap, uint32_t index) {
+static inline int BitmapIsBitSet(uint8_t *bitmap, size_t index) {
   return (bitmap[index / kBitsPerByte] & (1 << (index % kBitsPerByte))) != 0;
 }
 
-static inline void BitmapSetBit(uint8_t *bitmap, uint32_t index) {
+static inline void BitmapSetBit(uint8_t *bitmap, size_t index) {
   bitmap[index / kBitsPerByte] |= 1 << (index % kBitsPerByte);
 }
 
-static inline void BitmapClearBit(uint8_t *bitmap, uint32_t index) {
+static inline void BitmapClearBit(uint8_t *bitmap, size_t index) {
   bitmap[index / kBitsPerByte] &= ~(1 << (index % kBitsPerByte));
 }
 
 static int CheckJumpTargets(uint8_t *valid_targets, uint8_t *jump_dests,
                             size_t size) {
   size_t i;
   for (i = 0; i < size / 32; i++) {
     uint32_t jump_dest_mask = ((uint32_t *) jump_dests)[i];
     uint32_t valid_target_mask = ((uint32_t *) valid_targets)[i];
     if ((jump_dest_mask & ~valid_target_mask) != 0) {
       printf("bad jump to around %x\n", (unsigned)(i * 32));
       return 1;
     }
   }
   return 0;
 }
 
 int ValidateChunkAMD64(const uint8_t *data, size_t size,
                        process_error_func process_error, void *userdata) {
   const size_t bundle_size = 32;
   const size_t bundle_mask = bundle_size - 1;
 
   uint8_t *valid_targets = BitmapAllocate(size);
   uint8_t *jump_dests = BitmapAllocate(size);
 
   const uint8_t *p = data;
   const uint8_t *begin = p;  /* Start of the instruction being processed.  */
 
-  uint8_t rex_prefix, vex_prefix2, vex_prefix3;
+  uint8_t rex_prefix = FALSE;
+  uint8_t vex_prefix2 = 0xe0;
+  uint8_t vex_prefix3 = 0x00;
   struct Operand {
     unsigned int name   :5;
     unsigned int type   :2;
-    bool         write  :1;
+    _Bool        write  :1;
   } operands[5];
-  enum register_name base, index;
-  uint8_t operands_count, i;
+  enum register_name base = NO_REG;
+  enum register_name index = NO_REG;
+  uint8_t operands_count = 0;
+  uint8_t i;
   int result = 0;
   /*
    * These are borders of the appropriate instructions.  Initialize them to make
    * compiler happy: they are never used uninitialized even without explicit
    * initialization but GCC is not sophysicated enough to prove that.
    */
   const uint8_t *sandboxed_rsi = 0;
   const uint8_t *sandboxed_rsi_restricted_rdi = 0;
   const uint8_t *sandboxed_rdi = 0;
 
@@ skipping 25 matching lines @@
     }
   }
 
   if (CheckJumpTargets(valid_targets, jump_dests, size)) {
     return 1;
   }
 
 error_detected:
   return result;
 }