Move validator_x86_XX.rl out of unreviewed.

src/trusted/validator_ragel/validator_x86_64.rl

Index: src/trusted/validator_ragel/validator_x86_64.rl
===================================================================
--- src/trusted/validator_ragel/validator_x86_64.rl	(revision 9857)
+++ src/trusted/validator_ragel/validator_x86_64.rl	(working copy)
@@ -11,7 +11,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "native_client/src/trusted/validator_ragel/unreviewed/validator_internal.h"
+#include "native_client/src/trusted/validator_ragel/validator_internal.h"
 
 %%{
   machine x86_64_validator;
@@ -124,7 +124,7 @@
        else
          instruction_info_collected |= UNRESTRICTED_RBP_PROCESSED;
        restricted_register = NO_REG;
-       BitmapClearBit(valid_targets, (instruction_start - data));
+       MakeJumpTargetInvalid((instruction_start - data), valid_targets);
     };
 
   # Special %rbp modifications without required sandboxing
@@ -147,7 +147,7 @@
        else
          instruction_info_collected |= UNRESTRICTED_RSP_PROCESSED;
        restricted_register = NO_REG;
-       BitmapClearBit(valid_targets, (instruction_start - data));
+       MakeJumpTargetInvalid((instruction_start - data), valid_targets);
     };
 
   # naclcall or nacljmp.  Note: first "and $~0x1f, %eXX" is a normal instruction
@@ -167,8 +167,8 @@
                                             RMFromModRM(instruction_start[5]) ||
            RMFromModRM(instruction_start[1]) != RMFromModRM(*current_position))
          instruction_info_collected |= UNRECOGNIZED_INSTRUCTION;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
        restricted_register = NO_REG;
      } |
 
@@ -186,8 +186,8 @@
                                            RegFromModRM(instruction_start[5]) ||
            RMFromModRM(instruction_start[1]) != RMFromModRM(*current_position))
          instruction_info_collected |= UNRECOGNIZED_INSTRUCTION;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
        restricted_register = NO_REG;
      } |
 
@@ -214,8 +214,8 @@
                                             RMFromModRM(instruction_start[6]) ||
            RMFromModRM(instruction_start[2]) != RMFromModRM(*current_position))
          instruction_info_collected |= UNRECOGNIZED_INSTRUCTION;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 4);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
+       MakeJumpTargetInvalid((instruction_start - data) + 4, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
        restricted_register = NO_REG;
      } |
 
@@ -242,8 +242,8 @@
                                            RegFromModRM(instruction_start[6]) ||
            RMFromModRM(instruction_start[2]) != RMFromModRM(*current_position))
          instruction_info_collected |= UNRECOGNIZED_INSTRUCTION;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 4);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
+       MakeJumpTargetInvalid((instruction_start - data) + 4, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
        restricted_register = NO_REG;
      };
 
@@ -295,8 +295,8 @@
     string_instruction_rsi_no_rdi
     @{

[Brad Chen, 2012/09/29 00:06:00]

Please comment every action.
# This action redefines the range of the super-instruction
# to include the preceding sandboxing sequence, then
# invalidates jump targets on the interior of the
# super-instructions.
In this case it would also help if you made a procedure for this action, maybe
"RSandboxStringInst"?

[khim, 2012/10/03 22:30:10]

Done.

Functions make absolutely no sense here: we have quite a few magic numbers here.
They tie together action which is triggered and the DFA this action attached to
(magic numbers are offsets in said DFA). We MAY define bunch of constants to
satisfy the style guide but this IMNSHO will just make code less readable: each
particular define will only be used once and instead of having two entities
which are placed close to each other in a file we will have them in two
different files.

        instruction_start -= 6;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 2);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
+       MakeJumpTargetInvalid((instruction_start - data) + 2, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
        restricted_register = NO_REG;
     } |
 
@@ -305,8 +305,8 @@
     string_instruction_rsi_no_rdi
     @{
        instruction_start -= 7;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
        restricted_register = NO_REG;
     };
 
@@ -316,8 +316,8 @@
     (string_instruction_rdi_no_rsi | mmx_sse_rdi_instruction)
     @{
        instruction_start -= 6;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 2);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
+       MakeJumpTargetInvalid((instruction_start - data) + 2, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
        restricted_register = NO_REG;
     } |
 
@@ -326,8 +326,8 @@
     (string_instruction_rdi_no_rsi | mmx_sse_rdi_instruction)
     @{
        instruction_start -= 7;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
        restricted_register = NO_REG;
     };
 
@@ -341,10 +341,10 @@
     string_instruction_rsi_rdi
     @{
        instruction_start -= 12;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 2);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 8);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 12);
+       MakeJumpTargetInvalid((instruction_start - data) + 2, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 8, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 12, valid_targets);
        restricted_register = NO_REG;
     } |
 
@@ -355,10 +355,10 @@
     string_instruction_rsi_rdi
     @{
        instruction_start -= 13;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 2);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 6);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 9);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 13);
+       MakeJumpTargetInvalid((instruction_start - data) + 2, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 6, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 9, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 13, valid_targets);
        restricted_register = NO_REG;
     } |
 
@@ -369,10 +369,10 @@
     string_instruction_rsi_rdi
     @{
        instruction_start -= 13;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 9);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 13);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 9, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 13, valid_targets);
        restricted_register = NO_REG;
     } |
 
@@ -383,10 +383,10 @@
     string_instruction_rsi_rdi
     @{
        instruction_start -= 14;
-       BitmapClearBit(valid_targets, (instruction_start - data) + 3);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 7);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 10);
-       BitmapClearBit(valid_targets, (instruction_start - data) + 14);
+       MakeJumpTargetInvalid((instruction_start - data) + 3, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 7, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 10, valid_targets);
+       MakeJumpTargetInvalid((instruction_start - data) + 14, valid_targets);
        restricted_register = NO_REG;
     };
 
@@ -425,7 +425,7 @@
 
   main := ((call_alignment | normal_instruction | special_instruction)
      >{
-       BitmapSetBit(valid_targets, current_position - data);
+       MakeJumpTargetValid(current_position - data, valid_targets);
      }
      @{
        if ((instruction_info_collected &