| OLD | NEW |
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2011 The Native Client Authors. All rights reserved. | |
| 3 * Use of this source code is governed by a BSD-style license that can be | |
| 4 * found in the LICENSE file. | |
| 5 */ | |
| 6 | |
| 7 #include <assert.h> | |
| 8 #include <stddef.h> | |
| 9 #include <stdio.h> | |
| 10 #include <stdlib.h> | |
| 11 #include <string.h> | |
| 12 | |
| 13 #include "native_client/src/shared/utils/types.h" | |
| 14 #include "native_client/src/trusted/validator_ragel/unreviewed/decoding.h" | |
| 15 | |
| 16 #include "native_client/src/trusted/validator_ragel/gen/decoder_x86_32_instructi
on_consts.h" | |
| 17 | |
| 18 %%{ | |
| 19 machine x86_32_decoder; | |
| 20 alphtype unsigned char; | |
| 21 variable p current_position; | |
| 22 variable pe end_of_data; | |
| 23 variable eof end_of_data; | |
| 24 variable cs current_state; | |
| 25 | |
| 26 include byte_machine "byte_machines.rl"; | |
| 27 | |
| 28 include prefix_actions | |
| 29 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 30 include prefixes_parsing | |
| 31 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 32 include vex_actions_ia32 | |
| 33 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 34 include vex_parsing_ia32 | |
| 35 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 36 include att_suffix_actions | |
| 37 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 38 include set_spurious_prefixes | |
| 39 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 40 include displacement_fields_actions | |
| 41 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 42 include displacement_fields_parsing | |
| 43 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 44 include modrm_actions_ia32 | |
| 45 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 46 include modrm_parsing_ia32 | |
| 47 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 48 include operand_actions_ia32 | |
| 49 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 50 include immediate_fields_actions | |
| 51 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 52 include immediate_fields_parsing_ia32 | |
| 53 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 54 include relative_fields_actions | |
| 55 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 56 include relative_fields_parsing | |
| 57 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 58 include cpuid_actions | |
| 59 "native_client/src/trusted/validator_ragel/unreviewed/parse_instruction.rl"; | |
| 60 | |
| 61 include decode_x86_32 "decoder_x86_32_instruction.rl"; | |
| 62 | |
| 63 main := (one_instruction | |
| 64 @{ | |
| 65 switch (instruction.rm.disp_type) { | |
| 66 case DISPNONE: instruction.rm.offset = 0; break; | |
| 67 case DISP8: instruction.rm.offset = (int8_t) *disp; break; | |
| 68 case DISP16: instruction.rm.offset = | |
| 69 (int16_t) (disp[0] + 256U * disp[1]); | |
| 70 break; | |
| 71 case DISP32: instruction.rm.offset = (int32_t) | |
| 72 (disp[0] + 256U * (disp[1] + 256U * (disp[2] + 256U * (disp[3])))); | |
| 73 break; | |
| 74 case DISP64: assert(FALSE); | |
| 75 } | |
| 76 switch (imm_operand) { | |
| 77 case IMMNONE: instruction.imm[0] = 0; break; | |
| 78 case IMM2: instruction.imm[0] = imm[0] & 0x03; break; | |
| 79 case IMM8: instruction.imm[0] = imm[0]; break; | |
| 80 case IMM16: instruction.imm[0] = (uint64_t) (*imm + 256U * (imm[1])); | |
| 81 break; | |
| 82 case IMM32: instruction.imm[0] = (uint64_t) | |
| 83 (imm[0] + 256U * (imm[1] + 256U * (imm[2] + 256U * (imm[3])))); | |
| 84 break; | |
| 85 } | |
| 86 switch (imm2_operand) { | |
| 87 case IMMNONE: instruction.imm[1] = 0; break; | |
| 88 case IMM2: instruction.imm[1] = imm2[0] & 0x03; break; | |
| 89 case IMM8: instruction.imm[1] = imm2[0]; break; | |
| 90 case IMM16: instruction.imm[1] = (uint64_t) | |
| 91 (imm2[0] + 256U * (imm2[1])); | |
| 92 break; | |
| 93 case IMM32: instruction.imm[1] = (uint64_t) | |
| 94 (imm2[0] + 256U * (imm2[1] + 256U * (imm2[2] + 256U * (imm2[3])))); | |
| 95 break; | |
| 96 } | |
| 97 process_instruction(instruction_start, current_position+1, &instruction, | |
| 98 userdata); | |
| 99 instruction_start = current_position + 1; | |
| 100 SET_DISP_TYPE(DISPNONE); | |
| 101 SET_IMM_TYPE(IMMNONE); | |
| 102 SET_IMM2_TYPE(IMMNONE); | |
| 103 SET_DATA16_PREFIX(FALSE); | |
| 104 SET_LOCK_PREFIX(FALSE); | |
| 105 SET_REPNZ_PREFIX(FALSE); | |
| 106 SET_REPZ_PREFIX(FALSE); | |
| 107 SET_BRANCH_NOT_TAKEN(FALSE); | |
| 108 SET_BRANCH_TAKEN(FALSE); | |
| 109 SET_VEX_PREFIX3(0x00); | |
| 110 SET_ATT_INSTRUCTION_SUFFIX(NULL); | |
| 111 })* | |
| 112 $!{ process_error(current_position, userdata); | |
| 113 result = FALSE; | |
| 114 goto error_detected; | |
| 115 }; | |
| 116 | |
| 117 }%% | |
| 118 | |
| 119 %% write data; | |
| 120 | |
| 121 #define GET_VEX_PREFIX3() vex_prefix3 | |
| 122 #define SET_VEX_PREFIX3(P) vex_prefix3 = (P) | |
| 123 #define SET_DATA16_PREFIX(S) instruction.prefix.data16 = (S) | |
| 124 #define SET_LOCK_PREFIX(S) instruction.prefix.lock = (S) | |
| 125 #define SET_REPZ_PREFIX(S) instruction.prefix.repz = (S) | |
| 126 #define SET_REPNZ_PREFIX(S) instruction.prefix.repnz = (S) | |
| 127 #define SET_BRANCH_TAKEN(S) instruction.prefix.branch_taken = (S) | |
| 128 #define SET_BRANCH_NOT_TAKEN(S) instruction.prefix.branch_not_taken = (S) | |
| 129 #define SET_INSTRUCTION_NAME(N) instruction.name = (N) | |
| 130 #define GET_OPERAND_NAME(N) instruction.operands[(N)].name | |
| 131 #define SET_OPERAND_NAME(N, S) instruction.operands[(N)].name = (S) | |
| 132 #define SET_OPERAND_TYPE(N, S) instruction.operands[(N)].type = (S) | |
| 133 #define SET_OPERANDS_COUNT(N) instruction.operands_count = (N) | |
| 134 #define SET_MODRM_BASE(N) instruction.rm.base = (N) | |
| 135 #define SET_MODRM_INDEX(N) instruction.rm.index = (N) | |
| 136 #define SET_MODRM_SCALE(S) instruction.rm.scale = (S) | |
| 137 #define SET_DISP_TYPE(T) instruction.rm.disp_type = (T) | |
| 138 #define SET_DISP_PTR(P) disp = (P) | |
| 139 #define SET_IMM_TYPE(T) imm_operand = (T) | |
| 140 #define SET_IMM_PTR(P) imm = (P) | |
| 141 #define SET_IMM2_TYPE(T) imm2_operand = (T) | |
| 142 #define SET_IMM2_PTR(P) imm2 = (P) | |
| 143 #define SET_CPU_FEATURE(F) | |
| 144 #define SET_ATT_INSTRUCTION_SUFFIX(S) instruction.att_instruction_suffix = (S) | |
| 145 | |
| 146 enum { | |
| 147 REX_B = 1, | |
| 148 REX_X = 2, | |
| 149 REX_R = 4, | |
| 150 REX_W = 8 | |
| 151 }; | |
| 152 | |
| 153 enum imm_mode { | |
| 154 IMMNONE, | |
| 155 IMM2, | |
| 156 IMM8, | |
| 157 IMM16, | |
| 158 IMM32 | |
| 159 }; | |
| 160 | |
| 161 int DecodeChunkIA32(const uint8_t *data, size_t size, | |
| 162 ProcessInstructionFunc process_instruction, | |
| 163 ProcessDecodingErrorFunc process_error, void *userdata) { | |
| 164 const uint8_t *current_position = data; | |
| 165 const uint8_t *end_of_data = data + size; | |
| 166 const uint8_t *disp = NULL; | |
| 167 const uint8_t *imm = NULL; | |
| 168 const uint8_t *imm2 = NULL; | |
| 169 const uint8_t *instruction_start = current_position; | |
| 170 uint8_t vex_prefix3 = 0x00; | |
| 171 enum imm_mode imm_operand = IMMNONE; | |
| 172 enum imm_mode imm2_operand = IMMNONE; | |
| 173 struct Instruction instruction; | |
| 174 int result = TRUE; | |
| 175 | |
| 176 int current_state; | |
| 177 | |
| 178 /* Not used in ia32_mode. */ | |
| 179 instruction.prefix.rex = 0; | |
| 180 | |
| 181 SET_DISP_TYPE(DISPNONE); | |
| 182 SET_IMM_TYPE(IMMNONE); | |
| 183 SET_IMM2_TYPE(IMMNONE); | |
| 184 SET_DATA16_PREFIX(FALSE); | |
| 185 SET_LOCK_PREFIX(FALSE); | |
| 186 SET_REPNZ_PREFIX(FALSE); | |
| 187 SET_REPZ_PREFIX(FALSE); | |
| 188 SET_BRANCH_NOT_TAKEN(FALSE); | |
| 189 SET_BRANCH_TAKEN(FALSE); | |
| 190 SET_ATT_INSTRUCTION_SUFFIX(NULL); | |
| 191 instruction.prefix.data16_spurious = FALSE; | |
| 192 instruction.prefix.rex_b_spurious = FALSE; | |
| 193 instruction.prefix.rex_x_spurious = FALSE; | |
| 194 instruction.prefix.rex_r_spurious = FALSE; | |
| 195 instruction.prefix.rex_w_spurious = FALSE; | |
| 196 | |
| 197 %% write init; | |
| 198 %% write exec; | |
| 199 | |
| 200 error_detected: | |
| 201 return result; | |
| 202 } | |
| OLD | NEW |