Move validator_x86_XX.rl out of unreviewed.

src/trusted/validator_ragel/parse_instruction.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.
  */
 
 /*
  * Hand-written Ragel machines and actions used in validator and decoding.
  *
  * Note: this file includes many different machines which are supposed to be
@@ skipping 232 matching lines @@
   VEX_RX = b_xx1_xxxxx @vex_prefix2;
   VEX_RB = b_x1x_xxxxx @vex_prefix2;
   VEX_XB = b_1xx_xxxxx @vex_prefix2;
   VEX_RXB = b_xxx_xxxxx @vex_prefix2;
 }%%
 
 %%{
   machine modrm_actions_ia32;
 
   action modrm_only_base {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(RMFromModRM(*current_position));
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_base_disp {
     SET_MODRM_BASE(RMFromModRM(*current_position));
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_pure_disp {
     // Case where ModRM.mod = 00 and ModRM.r/m = 101.
     SET_MODRM_BASE(NO_REG);
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_pure_index {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(NO_REG);
     SET_MODRM_INDEX(index_registers[IndexFromSIB(*current_position)]);
     SET_MODRM_SCALE(ScaleFromSIB(*current_position));
   }
   action modrm_parse_sib {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(BaseFromSIB(*current_position));
     SET_MODRM_INDEX(index_registers[IndexFromSIB(*current_position)]);
     SET_MODRM_SCALE(ScaleFromSIB(*current_position));
   }
 }%%
 
 %%{
   machine modrm_actions_amd64;
 
   action modrm_only_base {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(BaseFromSIB(*current_position) |
                    BaseExtentionFromREX(GET_REX_PREFIX()) |
                    BaseExtentionFromVEX(GET_VEX_PREFIX2()));
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_base_disp {
     SET_MODRM_BASE(BaseFromSIB(*current_position) |
                    BaseExtentionFromREX(GET_REX_PREFIX()) |
                    BaseExtentionFromVEX(GET_VEX_PREFIX2()));
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_pure_disp {
     // Case where ModRM.mod = 00 and ModRM.r/m = 101.
     // In 64-bit mode it corresponds to RIP-relative addressing.
     SET_MODRM_BASE(REG_RIP);
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
   }
   action modrm_pure_index {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(NO_REG);
     SET_MODRM_INDEX(index_registers[IndexFromSIB(*current_position) |
                                     IndexExtentionFromREX(GET_REX_PREFIX()) |
                                     IndexExtentionFromVEX(GET_VEX_PREFIX2())]);
     SET_MODRM_SCALE(ScaleFromSIB(*current_position));
   }
   action modrm_parse_sib {
-    SET_DISP_TYPE(DISPNONE);
+    SET_DISPLACEMNT_FORMAT(DISPNONE);
     SET_MODRM_BASE(BaseFromSIB(*current_position) |
                    BaseExtentionFromREX(GET_REX_PREFIX()) |
                    BaseExtentionFromVEX(GET_VEX_PREFIX2()));
     SET_MODRM_INDEX(index_registers[IndexFromSIB(*current_position) |
                                     IndexExtentionFromREX(GET_REX_PREFIX()) |
                                     IndexExtentionFromVEX(GET_VEX_PREFIX2())]);
     SET_MODRM_SCALE(ScaleFromSIB(*current_position));
   }
 }%%
 
@@ skipping 21 matching lines @@
   opcode_0 = b_xx_000_xxx;
   opcode_1 = b_xx_001_xxx;
   opcode_2 = b_xx_010_xxx;
   opcode_3 = b_xx_011_xxx;
   opcode_4 = b_xx_100_xxx;
   opcode_5 = b_xx_101_xxx;
   opcode_6 = b_xx_110_xxx;
   opcode_7 = b_xx_111_xxx;
   # Used for segment operations: there only 6 segment registers.
   opcode_s = (any - b_xx_110_xxx - b_xx_111_xxx);
+  # This is used to move operand name detection after first byte of ModRM.
+  opcode_m = (any - b_11_xxx_xxx);
+  opcode_r = b_11_xxx_xxx;
 }%%
 
 %%{
   # For IA32 validator we do not need modrm-parsing actions.
   machine modrm_parsing_ia32_validator;
 
   operand_sib_base_index =
     (b_00_xxx_100 . (any - b_xx_xxx_101)) |
     (b_01_xxx_100 . any . disp8) |
     (b_10_xxx_100 . any . disp32);
@@ skipping 280 matching lines @@
     SET_OPERAND_NAME(3, RMFromModRM(*current_position) |
                         BaseExtentionFromREX(GET_REX_PREFIX()) |
                         BaseExtentionFromVEX(GET_VEX_PREFIX2()));
   }
 }%%
 
 %%{
   machine displacement_fields_parsing;
 
   action disp8_operand {
-    SET_DISP_TYPE(DISP8);
-    SET_DISP_PTR(current_position);
+    SET_DISPLACEMNT_FORMAT(DISP8);
+    SET_DISPLACEMNT_POINTER(current_position);
   }
   action disp32_operand {
-    SET_DISP_TYPE(DISP32);
-    SET_DISP_PTR(current_position - 3);
+    SET_DISPLACEMNT_FORMAT(DISP32);
+    SET_DISPLACEMNT_POINTER(current_position - 3);
   }
   action disp64_operand {
-    SET_DISP_TYPE(DISP64);
-    SET_DISP_PTR(current_position - 7);
+    SET_DISPLACEMNT_FORMAT(DISP64);
+    SET_DISPLACEMNT_POINTER(current_position - 7);
   }
 
   # This action is used to mark transitions corresponding to immediates,
   # displacements and relative jump targets - stuff that we don't have to
   # enumerate in enumeration tests.
   # TODO(shcherbina): find appropriate place for this action.
   action any_byte {}
 
   disp8  = any @disp8_operand $any_byte;
   disp32 = any{4} @disp32_operand $any_byte;
   disp64 = any{8} @disp64_operand $any_byte;
 }%%
 
 %%{
   machine immediate_fields_parsing;
 
   action imm2_operand {
-    SET_IMM_TYPE(IMM2);
-    SET_IMM_PTR(current_position);
+    SET_IMMEDIATE_FORMAT(IMM2);
+    SET_IMMEDIATE_POINTER(current_position);
   }
   action imm8_operand {
-    SET_IMM_TYPE(IMM8);
-    SET_IMM_PTR(current_position);
+    SET_IMMEDIATE_FORMAT(IMM8);
+    SET_IMMEDIATE_POINTER(current_position);
   }
   action imm8_second_operand {
-    SET_IMM2_TYPE(IMM8);
-    SET_IMM2_PTR(current_position);
+    SET_SECOND_IMMEDIATE_FORMAT(IMM8);
+    SET_SECOND_IMMEDIATE_POINTER(current_position);
   }
   action imm16_operand {
-    SET_IMM_TYPE(IMM16);
-    SET_IMM_PTR(current_position - 1);
+    SET_IMMEDIATE_FORMAT(IMM16);
+    SET_IMMEDIATE_POINTER(current_position - 1);
   }
   action imm16_second_operand {
-    SET_IMM2_TYPE(IMM16);
-    SET_IMM2_PTR(current_position - 1);
+    SET_SECOND_IMMEDIATE_FORMAT(IMM16);
+    SET_SECOND_IMMEDIATE_POINTER(current_position - 1);
   }
   action imm32_operand {
-    SET_IMM_TYPE(IMM32);
-    SET_IMM_PTR(current_position - 3);
+    SET_IMMEDIATE_FORMAT(IMM32);
+    SET_IMMEDIATE_POINTER(current_position - 3);
   }
   action imm32_second_operand {
-    SET_IMM2_TYPE(IMM32);
-    SET_IMM2_PTR(current_position - 3);
+    SET_SECOND_IMMEDIATE_FORMAT(IMM32);
+    SET_SECOND_IMMEDIATE_POINTER(current_position - 3);
   }
   action imm64_operand {
-    SET_IMM_TYPE(IMM64);
-    SET_IMM_PTR(current_position - 7);
+    SET_IMMEDIATE_FORMAT(IMM64);
+    SET_IMMEDIATE_POINTER(current_position - 7);
   }
   action imm64_second_operand {
-    SET_IMM2_TYPE(IMM64);
-    SET_IMM2_PTR(current_position - 7);
+    SET_SECOND_IMMEDIATE_FORMAT(IMM64);
+    SET_SECOND_IMMEDIATE_POINTER(current_position - 7);
   }
 
   imm8 = any @imm8_operand $any_byte;
   imm16 = any{2} @imm16_operand $any_byte;
   imm32 = any{4} @imm32_operand $any_byte;
   imm64 = any{8} @imm64_operand $any_byte;
   imm8n2 = any @imm8_second_operand $any_byte;
   imm16n2 = any{2} @imm16_second_operand $any_byte;
 }%%
 
 %%{
   machine relative_fields_decoder_actions;
 
   action rel8_operand {
     SET_MODRM_BASE(REG_RIP);
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
-    SET_DISP_TYPE(DISP8);
-    SET_DISP_PTR(current_position);
+    SET_DISPLACEMNT_FORMAT(DISP8);
+    SET_DISPLACEMNT_POINTER(current_position);
   }
   action rel16_operand {
     SET_MODRM_BASE(REG_RIP);
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
-    SET_DISP_TYPE(DISP16);
-    SET_DISP_PTR(current_position - 1);
+    SET_DISPLACEMNT_FORMAT(DISP16);
+    SET_DISPLACEMNT_POINTER(current_position - 1);
   }
   action rel32_operand {
     SET_MODRM_BASE(REG_RIP);
     SET_MODRM_INDEX(NO_REG);
     SET_MODRM_SCALE(0);
-    SET_DISP_TYPE(DISP32);
-    SET_DISP_PTR(current_position - 3);
+    SET_DISPLACEMNT_FORMAT(DISP32);
+    SET_DISPLACEMNT_POINTER(current_position - 3);
   }
 }%%
 
 %%{
   machine relative_fields_validator_actions;
 
   # rel8 actions are used in relative jumps with 8-bit offset.
   action rel8_operand {
-    Rel8Operand(current_position + 1, data, jump_dests, size,
+    Rel8Operand(current_position + 1, codeblock, jump_dests, size,
                 &instruction_info_collected);
   }
 
   # rel16 actions are used in relative jumps with 16-bit offset.
   # Such instructions should not be included in the validator's DFA, but we can
   # not just exclude them because they are refenced in relative_fields_parsing
   # ragel machine.  Ensure compilations error in case of accidental usage.
   action rel16_operand {
     #error rel16_operand should never be used in nacl
   }
 
   # rel32 actions are used in relative calls and jumps with 32-bit offset.
   action rel32_operand {
-    Rel32Operand(current_position + 1, data, jump_dests, size,
+    Rel32Operand(current_position + 1, codeblock, jump_dests, size,
                  &instruction_info_collected);
   }
+
+  # Action which marks last byte as not immediate.  Most 3DNow! instructions,
+  # some AVX and XOP instructions have this property.
+  #
+  # This action is referenced by decode_x86_32 ragel machine in [autogenerated]
+  # "validator_x86_32_instruction.rl" file.
+  action last_byte_is_not_immediate {
+    instruction_info_collected |= LAST_BYTE_IS_NOT_IMMEDIATE;
+  }
 }%%
 
 %%{
   machine relative_fields_parsing;
 
   rel8  = any @rel8_operand $any_byte;
   rel16 = any{2} @rel16_operand $any_byte;
   rel32 = any{4} @rel32_operand $any_byte;
 }%%
 
@@ skipping 55 matching lines @@
   action att_show_name_suffix_b   { SET_ATT_INSTRUCTION_SUFFIX("b");       }
   action att_show_name_suffix_l   { SET_ATT_INSTRUCTION_SUFFIX("l");       }
   action att_show_name_suffix_ll  { SET_ATT_INSTRUCTION_SUFFIX("ll");      }
   action att_show_name_suffix_t   { SET_ATT_INSTRUCTION_SUFFIX("t");       }
   action att_show_name_suffix_s   { SET_ATT_INSTRUCTION_SUFFIX("s");       }
   action att_show_name_suffix_q   { SET_ATT_INSTRUCTION_SUFFIX("q");       }
   action att_show_name_suffix_w   { SET_ATT_INSTRUCTION_SUFFIX("w");       }
   action att_show_name_suffix_x   { SET_ATT_INSTRUCTION_SUFFIX("x");       }
   action att_show_name_suffix_y   { SET_ATT_INSTRUCTION_SUFFIX("y");       }
 }%%