Add ragel validator to SCONS

src/trusted/validator_ragel/unreviewed/decoder-test.c

 /*
  * 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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "decoder.h"
 
-#undef TRUE
-#define TRUE    1
+#include "native_client/src/include/elf32.h"
+#include "native_client/src/include/elf64.h"
+#include "native_client/src/shared/platform/nacl_check.h"
+#include "native_client/src/shared/utils/types.h"
+#include "native_client/src/trusted/validator_ragel/unreviewed/decoder.h"
 
-#undef FALSE
-#define FALSE   0
+/* This is a copy of NaClLog_Function from shared/platform/nacl_log.c to avoid
+ * linking in code in NaCl shared code in the unreviewed/Makefile and be able to
+ *  use CHECK().
+
+ * TODO(khim): remove the copy of NaClLog_Function implementation as soon as
+ * unreviewed/Makefile is eliminated.
+ */
+void NaClLog_Function(int detail_level, char const  *fmt, ...) {
+  va_list ap;
+
+  UNREFERENCED_PARAMETER(detail_level);
+  va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  exit(1);
+}
 
 static void CheckBounds(unsigned char *data, size_t data_size,
                         void *ptr, size_t inside_size) {
-  assert(data <= (unsigned char *) ptr);
-  assert((unsigned char *) ptr + inside_size <= data + data_size);
+  CHECK(data <= (unsigned char *) ptr);
+  CHECK((unsigned char *) ptr + inside_size <= data + data_size);
 }
 
-void ReadFile(const char *filename, uint8_t **result, size_t *result_size) {
+void ReadImage(const char *filename, uint8_t **result, size_t *result_size) {
   FILE *fp;
   uint8_t *data;
   size_t file_size;
   size_t got;
 
   fp = fopen(filename, "rb");
   if (fp == NULL) {
     fprintf(stderr, "Failed to open input file: %s\n", filename);
     exit(1);
   }
@@ skipping 31 matching lines @@
   const char *instruction_name;
   unsigned char operands_count;
   const uint8_t *p;
   char delimeter = ' ';
   int print_rip = FALSE;
   int rex_bits = 0;
   int maybe_rex_bits = 0;
   int show_name_suffix = FALSE;
   int empty_rex_prefix_ok = FALSE;
 #define print_name(x) (printf((x)), shown_name += strlen((x)))
-  int shown_name = 0;
+  size_t shown_name = 0;
   int i, operand_type;
 
   /* "fwait" is nasty: any number of them will be included in other X87
      instructions ("fclex", "finit", "fstcw", "fstsw", "fsave" have two
      names, other instructions are unchanged) - but if after them we see
      regular instruction then we must print all them.  This convoluted
      logic is not needed when we  don't print anything so decoder does
      not include it.  */
   if ((end == begin + 1) && (begin[0] == 0x9b)) {
     if (!(((struct DecodeState *)userdata)->fwait)) {
       ((struct DecodeState *)userdata)->fwait = begin;
     }
     return;
   } else if (((struct DecodeState *)userdata)->fwait) {
     if ((begin[0] < 0xd8) || (begin[0] > 0xdf)) {
       while ((((struct DecodeState *)userdata)->fwait) < begin) {
-        printf("%*zx:\t                   \tfwait\n",
+        printf("%*lx:\t                   \tfwait\n",
           ((struct DecodeState *)userdata)->width,
-          ((((struct DecodeState *)userdata)->fwait++) -
-            (((struct DecodeState *)userdata)->offset)));
+          (long)((((struct DecodeState *)userdata)->fwait++) -
+                                   (((struct DecodeState *)userdata)->offset)));
       }
     } else {
       begin = ((struct DecodeState *)userdata)->fwait;
     }
     ((struct DecodeState *)userdata)->fwait = FALSE;
   }
-  printf("%*zx:\t", ((struct DecodeState *)userdata)->width,
-                          (begin - (((struct DecodeState *)userdata)->offset)));
+  printf("%*lx:\t", ((struct DecodeState *)userdata)->width,
+                    (long)(begin - (((struct DecodeState *)userdata)->offset)));
   for (p = begin; p < begin + 7; ++p) {
     if (p >= end) {
       printf("   ");
     } else {
       printf("%02x ", *p);
     }
   }
   printf("\t");
   instruction_name = instruction->name;
   operands_count = instruction->operands_count;
@@ skipping 405 matching lines @@
                 instruction->operands[i].name -= 8;
                 --rex_bits;
               }
             }
           }
         }
       } else if (instruction->operands[i].name == REG_RM) {
         if ((instruction->rm.base >= REG_R8) &&
             (instruction->rm.base <= REG_R15)) {
           ++rex_bits;
-        } else if ((instruction->rm.base == REG_NONE) ||
+        } else if ((instruction->rm.base == NO_REG) ||
                    (instruction->rm.base == REG_RIP)) {
           ++maybe_rex_bits;
         }
         if ((instruction->rm.index >= REG_R8) &&
             (instruction->rm.index <= REG_R15)) {
           ++rex_bits;
         }
       }
     }
   }
@@ skipping 225 matching lines @@
       ++shown_name;
     }
   }
   if (!strcmp(instruction_name, "mov")) {
     if ((instruction->operands[1].name == REG_IMM) &&
        (instruction->operands[1].type == OperandSize64bit)) {
       print_name("abs");
     }
   }
   {
+    size_t i;
     /* Print branch hint suffixes for conditional jump instructions (Jcc).  */
     const char* jcc_jumps[] = {
       "ja", "jae", "jbe", "jb", "je", "jg", "jge", "jle",
       "jl", "jne", "jno", "jnp", "jns", "jo", "jp", "js", NULL};
-    for (int i = 0; jcc_jumps[i] != NULL; ++i) {
+    for (i = 0; jcc_jumps[i] != NULL; ++i) {
       if (!strcmp(instruction_name, jcc_jumps[i])) {
         if (instruction->prefix.branch_not_taken) {
           print_name(",pn");
         } else if (instruction->prefix.branch_taken) {
           print_name(",pt");
         }
         break;
       }
     }
   }
@@ skipping 348 matching lines @@
         case OperandDebugRegister: printf("%%db15"); break;
         default: assert(FALSE);
       }
       break;
       case REG_ST:
         assert(operand_type == OperandST);
         printf("%%st");
         break;
       case REG_RM: {
         if (instruction->rm.offset) {
-          printf("0x%"PRIx64, instruction->rm.offset);
+          printf("0x%"NACL_PRIx64, instruction->rm.offset);
         }
         if (((struct DecodeState *)userdata)->ia32_mode) {
-          if ((instruction->rm.base != REG_NONE) ||
-              (instruction->rm.index != REG_NONE) ||
+          if ((instruction->rm.base != NO_REG) ||
+              (instruction->rm.index != NO_REG) ||
               (instruction->rm.scale != 0)) {
             printf("(");
           }
           switch (instruction->rm.base) {
             case REG_RAX: printf("%%eax"); break;
             case REG_RCX: printf("%%ecx"); break;
             case REG_RDX: printf("%%edx"); break;
             case REG_RBX: printf("%%ebx"); break;
             case REG_RSP: printf("%%esp"); break;
             case REG_RBP: printf("%%ebp"); break;
             case REG_RSI: printf("%%esi"); break;
             case REG_RDI: printf("%%edi"); break;
-            case REG_NONE: break;
+            case NO_REG: break;
             case REG_R8:
             case REG_R9:
             case REG_R10:
             case REG_R11:
             case REG_R12:
             case REG_R13:
             case REG_R14:
             case REG_R15:
             case REG_RIP:
             case REG_RM:
@@ skipping 14 matching lines @@
             case REG_RDX: printf(",%%edx,%d",1<<instruction->rm.scale); break;
             case REG_RBX: printf(",%%ebx,%d",1<<instruction->rm.scale); break;
             case REG_RSP: printf(",%%esp,%d",1<<instruction->rm.scale); break;
             case REG_RBP: printf(",%%ebp,%d",1<<instruction->rm.scale); break;
             case REG_RSI: printf(",%%esi,%d",1<<instruction->rm.scale); break;
             case REG_RDI: printf(",%%edi,%d",1<<instruction->rm.scale); break;
             case REG_RIZ: if ((instruction->rm.base != REG_RSP) ||
                               (instruction->rm.scale != 0))
                 printf(",%%eiz,%d",1<<instruction->rm.scale);
               break;
-            case REG_NONE: break;
+            case NO_REG: break;
             case REG_R8:
             case REG_R9:
             case REG_R10:
             case REG_R11:
             case REG_R12:
             case REG_R13:
             case REG_R14:
             case REG_R15:
             case REG_RM:
             case REG_RIP:
             case REG_IMM:
             case REG_IMM2:
             case REG_DS_RBX:
             case REG_ES_RDI:
             case REG_DS_RSI:
             case REG_PORT_DX:
             case REG_ST:
             case JMP_TO:
               assert(FALSE);
           }
-          if ((instruction->rm.base != REG_NONE) ||
-              (instruction->rm.index != REG_NONE) ||
+          if ((instruction->rm.base != NO_REG) ||
+              (instruction->rm.index != NO_REG) ||
               (instruction->rm.scale != 0)) {
             printf(")");
           }
         } else {
-          if ((instruction->rm.base != REG_NONE) ||
+          if ((instruction->rm.base != NO_REG) ||
               (instruction->rm.index != REG_RIZ) ||
               (instruction->rm.scale != 0)) {
             printf("(");
           }
           switch (instruction->rm.base) {
             case REG_RAX: printf("%%rax"); break;
             case REG_RCX: printf("%%rcx"); break;
             case REG_RDX: printf("%%rdx"); break;
             case REG_RBX: printf("%%rbx"); break;
             case REG_RSP: printf("%%rsp"); break;
             case REG_RBP: printf("%%rbp"); break;
             case REG_RSI: printf("%%rsi"); break;
             case REG_RDI: printf("%%rdi"); break;
             case REG_R8: printf("%%r8"); break;
             case REG_R9: printf("%%r9"); break;
             case REG_R10: printf("%%r10"); break;
             case REG_R11: printf("%%r11"); break;
             case REG_R12: printf("%%r12"); break;
             case REG_R13: printf("%%r13"); break;
             case REG_R14: printf("%%r14"); break;
             case REG_R15: printf("%%r15"); break;
             case REG_RIP: printf("%%rip"); print_rip = TRUE; break;
-            case REG_NONE: break;
+            case NO_REG: break;
             case REG_RM:
             case REG_RIZ:
             case REG_IMM:
             case REG_IMM2:
             case REG_DS_RBX:
             case REG_ES_RDI:
             case REG_DS_RSI:
             case REG_PORT_DX:
             case REG_ST:
             case JMP_TO:
               assert(FALSE);
           }
           switch (instruction->rm.index) {
             case REG_RAX: printf(",%%rax,%d",1<<instruction->rm.scale); break;
             case REG_RCX: printf(",%%rcx,%d",1<<instruction->rm.scale); break;
             case REG_RDX: printf(",%%rdx,%d",1<<instruction->rm.scale); break;
             case REG_RBX: printf(",%%rbx,%d",1<<instruction->rm.scale); break;
             case REG_RSP: printf(",%%rsp,%d",1<<instruction->rm.scale); break;
             case REG_RBP: printf(",%%rbp,%d",1<<instruction->rm.scale); break;
             case REG_RSI: printf(",%%rsi,%d",1<<instruction->rm.scale); break;
             case REG_RDI: printf(",%%rdi,%d",1<<instruction->rm.scale); break;
             case REG_R8: printf(",%%r8,%d",1<<instruction->rm.scale); break;
             case REG_R9: printf(",%%r9,%d",1<<instruction->rm.scale); break;
             case REG_R10: printf(",%%r10,%d",1<<instruction->rm.scale); break;
             case REG_R11: printf(",%%r11,%d",1<<instruction->rm.scale); break;
             case REG_R12: printf(",%%r12,%d",1<<instruction->rm.scale); break;
             case REG_R13: printf(",%%r13,%d",1<<instruction->rm.scale); break;
             case REG_R14: printf(",%%r14,%d",1<<instruction->rm.scale); break;
             case REG_R15: printf(",%%r15,%d",1<<instruction->rm.scale); break;
-            case REG_RIZ: if (((instruction->rm.base != REG_NONE) &&
+            case REG_RIZ: if (((instruction->rm.base != NO_REG) &&
                                (instruction->rm.base != REG_RSP) &&
                                (instruction->rm.base != REG_R12)) ||
                                (instruction->rm.scale != 0))
                 printf(",%%riz,%d",1<<instruction->rm.scale);
               break;
-            case REG_NONE: break;
+            case NO_REG: break;
             case REG_RM:
             case REG_RIP:
             case REG_IMM:
             case REG_IMM2:
             case REG_DS_RBX:
             case REG_ES_RDI:
             case REG_DS_RSI:
             case REG_PORT_DX:
             case REG_ST:
             case JMP_TO:
               assert(FALSE);
           }
-          if ((instruction->rm.base != REG_NONE) ||
+          if ((instruction->rm.base != NO_REG) ||
               (instruction->rm.index != REG_RIZ) ||
               (instruction->rm.scale != 0)) {
             printf(")");
           }
         }
       }
       break;
       case REG_IMM: {
-        printf("$0x%"PRIx64,instruction->imm[0]);
+        printf("$0x%"NACL_PRIx64,instruction->imm[0]);
         break;
       }
       case REG_IMM2: {
-        printf("$0x%"PRIx64,instruction->imm[1]);
+        printf("$0x%"NACL_PRIx64,instruction->imm[1]);
         break;
       }
       case REG_PORT_DX: printf("(%%dx)"); break;
       case REG_DS_RBX: if (((struct DecodeState *)userdata)->ia32_mode) {
           printf("%%ds:(%%ebx)");
         } else {
           printf("%%ds:(%%rbx)");
         }
         break;
       case REG_ES_RDI: if (((struct DecodeState *)userdata)->ia32_mode) {
           printf("%%es:(%%edi)");
         } else {
           printf("%%es:(%%rdi)");
         }
         break;
       case REG_DS_RSI: if (((struct DecodeState *)userdata)->ia32_mode) {
           printf("%%ds:(%%esi)");
         } else {
           printf("%%ds:(%%rsi)");
         }
         break;
       case JMP_TO: if (instruction->operands[0].type == OperandSize16bit)
-          printf("0x%zx", ((end + instruction->rm.offset -
+          printf("0x%lx", (long)((end + instruction->rm.offset -
                          (((struct DecodeState *)userdata)->offset)) & 0xffff));
         else
-          printf("0x%zx", (end + instruction->rm.offset -
+          printf("0x%lx", (long)(end + instruction->rm.offset -
                                    (((struct DecodeState *)userdata)->offset)));
         break;
       case REG_RIP:
       case REG_RIZ:
-      case REG_NONE:
+      case NO_REG:
         assert(FALSE);
     }
     delimeter = ',';
   }
   if (print_rip) {
-    printf("        # 0x%8"PRIx64,
+    printf("        # 0x%8"NACL_PRIx64,
            (uint64_t) (end + instruction->rm.offset -
                (((struct DecodeState *)userdata)->offset)));
   }
   printf("\n");
   begin += 7;
   while (begin < end) {
-    printf("%*"PRIx64":\t", ((struct DecodeState *)userdata)->width,
+    printf("%*"NACL_PRIx64":\t", ((struct DecodeState *)userdata)->width,
            (uint64_t) (begin - (((struct DecodeState *)userdata)->offset)));
     for (p = begin; p < begin + 7; ++p) {
       if (p >= end) {
         printf("\n");
         return;
       } else {
         printf("%02x ", *p);
       }
     }
     if (p >= end) {
       printf("\n");
       return;
     }
     begin += 7;
   }
 }
 
 void ProcessError (const uint8_t *ptr, void *userdata) {
-  printf("rejected at %"PRIx64" (byte 0x%02"PRIx32")\n",
+  printf("rejected at %"NACL_PRIx64" (byte 0x%02"NACL_PRIx32")\n",
          (uint64_t) (ptr - (((struct DecodeState *)userdata)->offset)),
          *ptr);
 }
 
 int DecodeFile(const char *filename, int repeat_count) {
   size_t data_size;
   uint8_t *data;
   int count;
 
-  ReadFile(filename, &data, &data_size);
+  ReadImage(filename, &data, &data_size);
   if (data[4] == 1) {
     for (count = 0; count < repeat_count; ++count) {
       Elf32_Ehdr *header;
       int index;
 
       header = (Elf32_Ehdr *) data;
       CheckBounds(data, data_size, header, sizeof(*header));
       assert(memcmp(header->e_ident, ELFMAG, strlen(ELFMAG)) == 0);
 
       for (index = 0; index < header->e_shnum; ++index) {
@@ skipping 16 matching lines @@
             state.width = 12;
           }
           CheckBounds(data, data_size,
                       data + section->sh_offset, section->sh_size);
           res = DecodeChunkIA32(data + section->sh_offset, section->sh_size,
                                       ProcessInstruction, ProcessError, &state);
           if (res != 0) {
             return res;
           } else if (state.fwait) {
             while (state.fwait < data + section->sh_offset + section->sh_size) {
-              printf("%*zx:\t9b                   \tfwait\n",
-                                   state.width, (state.fwait++ - state.offset));
+              printf("%*lx:\t9b                   \tfwait\n",
+                             state.width, (long)(state.fwait++ - state.offset));
             }
           }
         }
       }
     }
   } else if (data[4] == 2) {
     for (count = 0; count < repeat_count; ++count) {
       Elf64_Ehdr *header;
       int index;
 
@@ skipping 16 matching lines @@
           if (section->sh_size <= 0xfff) {
             state.width = 4;
           } else if (section->sh_size <= 0xfffffff) {
             state.width = 8;
           } else if (section->sh_size <= 0xfffffffffffLL) {
             state.width = 12;
           } else {
             state.width = 16;
           }
           CheckBounds(data, data_size,
-                      data + section->sh_offset, section->sh_size);
-          res = DecodeChunkAMD64(data + section->sh_offset, section->sh_size,
-                                      ProcessInstruction, ProcessError, &state);
+                      data + section->sh_offset, (size_t)section->sh_size);
+          res = DecodeChunkAMD64(data + section->sh_offset,
+                                 (size_t)section->sh_size,
+                                 ProcessInstruction, ProcessError, &state);
           if (res != 0) {
             return res;
           } else if (state.fwait) {
             while (state.fwait < data + section->sh_offset + section->sh_size) {
-              printf("%*zx:\t9b                   \tfwait\n",
-                                   state.width, (state.fwait++ - state.offset));
+              printf("%*lx:\t9b                   \tfwait\n",
+                             state.width, (long)(state.fwait++ - state.offset));
             }
           }
         }
       }
     }
   } else {
     printf("Unknown ELF class: %s\n", filename);
     exit(1);
   }
   return 0;
@@ skipping 11 matching lines @@
   for (index = initial_index; index < argc; ++index) {
     const char *filename = argv[index];
     int rc = DecodeFile(filename, repeat_count);
     if (rc != 0) {
       printf("file '%s' can not be fully decoded\n", filename);
       return 1;
     }
   }
   return 0;
 }