VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/Library/CcExitLib/CcInstruction.c

Last change on this file was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 11.4 KB
Line 
1/** @file
2 X64 Instruction function.
3
4 Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include <Base.h>
10#include <Uefi.h>
11#include <Library/BaseMemoryLib.h>
12#include <Register/Intel/Cpuid.h>
13#include <IndustryStandard/InstructionParsing.h>
14#include "CcInstruction.h"
15
16#define MAX_INSTRUCTION_LENGTH 15
17
18/**
19 Return a pointer to the contents of the specified register.
20
21 Based upon the input register, return a pointer to the registers contents
22 in the x86 processor context.
23
24 @param[in] Regs x64 processor context
25 @param[in] Register Register to obtain pointer for
26
27 @return Pointer to the contents of the requested register
28
29**/
30UINT64 *
31CcGetRegisterPointer (
32 IN EFI_SYSTEM_CONTEXT_X64 *Regs,
33 IN UINT8 Register
34 )
35{
36 UINT64 *Reg;
37
38 switch (Register) {
39 case 0:
40 Reg = &Regs->Rax;
41 break;
42 case 1:
43 Reg = &Regs->Rcx;
44 break;
45 case 2:
46 Reg = &Regs->Rdx;
47 break;
48 case 3:
49 Reg = &Regs->Rbx;
50 break;
51 case 4:
52 Reg = &Regs->Rsp;
53 break;
54 case 5:
55 Reg = &Regs->Rbp;
56 break;
57 case 6:
58 Reg = &Regs->Rsi;
59 break;
60 case 7:
61 Reg = &Regs->Rdi;
62 break;
63 case 8:
64 Reg = &Regs->R8;
65 break;
66 case 9:
67 Reg = &Regs->R9;
68 break;
69 case 10:
70 Reg = &Regs->R10;
71 break;
72 case 11:
73 Reg = &Regs->R11;
74 break;
75 case 12:
76 Reg = &Regs->R12;
77 break;
78 case 13:
79 Reg = &Regs->R13;
80 break;
81 case 14:
82 Reg = &Regs->R14;
83 break;
84 case 15:
85 Reg = &Regs->R15;
86 break;
87 default:
88 Reg = NULL;
89 }
90
91 ASSERT (Reg != NULL);
92
93 return Reg;
94}
95
96/**
97 Update the instruction parsing context for displacement bytes.
98
99 @param[in, out] InstructionData Instruction parsing context
100 @param[in] Size The instruction displacement size
101
102**/
103STATIC
104VOID
105UpdateForDisplacement (
106 IN OUT CC_INSTRUCTION_DATA *InstructionData,
107 IN UINTN Size
108 )
109{
110 InstructionData->DisplacementSize = Size;
111 InstructionData->Immediate += Size;
112 InstructionData->End += Size;
113}
114
115/**
116 Determine if an instruction address if RIP relative.
117
118 Examine the instruction parsing context to determine if the address offset
119 is relative to the instruction pointer.
120
121 @param[in] InstructionData Instruction parsing context
122
123 @retval TRUE Instruction addressing is RIP relative
124 @retval FALSE Instruction addressing is not RIP relative
125
126**/
127STATIC
128BOOLEAN
129IsRipRelative (
130 IN CC_INSTRUCTION_DATA *InstructionData
131 )
132{
133 CC_INSTRUCTION_OPCODE_EXT *Ext;
134
135 Ext = &InstructionData->Ext;
136
137 return ((InstructionData->Mode == LongMode64Bit) &&
138 (Ext->ModRm.Mod == 0) &&
139 (Ext->ModRm.Rm == 5) &&
140 (InstructionData->SibPresent == FALSE));
141}
142
143/**
144 Return the effective address of a memory operand.
145
146 Examine the instruction parsing context to obtain the effective memory
147 address of a memory operand.
148
149 @param[in] Regs x64 processor context
150 @param[in] InstructionData Instruction parsing context
151
152 @return The memory operand effective address
153
154**/
155STATIC
156UINT64
157GetEffectiveMemoryAddress (
158 IN EFI_SYSTEM_CONTEXT_X64 *Regs,
159 IN CC_INSTRUCTION_DATA *InstructionData
160 )
161{
162 CC_INSTRUCTION_OPCODE_EXT *Ext;
163 UINT64 EffectiveAddress;
164
165 Ext = &InstructionData->Ext;
166 EffectiveAddress = 0;
167
168 if (IsRipRelative (InstructionData)) {
169 //
170 // RIP-relative displacement is a 32-bit signed value
171 //
172 INT32 RipRelative;
173
174 RipRelative = *(INT32 *)InstructionData->Displacement;
175
176 UpdateForDisplacement (InstructionData, 4);
177
178 //
179 // Negative displacement is handled by standard UINT64 wrap-around.
180 //
181 return Regs->Rip + (UINT64)RipRelative;
182 }
183
184 switch (Ext->ModRm.Mod) {
185 case 1:
186 UpdateForDisplacement (InstructionData, 1);
187 EffectiveAddress += (UINT64)(*(INT8 *)(InstructionData->Displacement));
188 break;
189 case 2:
190 switch (InstructionData->AddrSize) {
191 case Size16Bits:
192 UpdateForDisplacement (InstructionData, 2);
193 EffectiveAddress += (UINT64)(*(INT16 *)(InstructionData->Displacement));
194 break;
195 default:
196 UpdateForDisplacement (InstructionData, 4);
197 EffectiveAddress += (UINT64)(*(INT32 *)(InstructionData->Displacement));
198 break;
199 }
200
201 break;
202 }
203
204 if (InstructionData->SibPresent) {
205 INT64 Displacement;
206
207 if (Ext->Sib.Index != 4) {
208 CopyMem (
209 &Displacement,
210 CcGetRegisterPointer (Regs, Ext->Sib.Index),
211 sizeof (Displacement)
212 );
213 Displacement *= (INT64)(1 << Ext->Sib.Scale);
214
215 //
216 // Negative displacement is handled by standard UINT64 wrap-around.
217 //
218 EffectiveAddress += (UINT64)Displacement;
219 }
220
221 if ((Ext->Sib.Base != 5) || Ext->ModRm.Mod) {
222 EffectiveAddress += *CcGetRegisterPointer (Regs, Ext->Sib.Base);
223 } else {
224 UpdateForDisplacement (InstructionData, 4);
225 EffectiveAddress += (UINT64)(*(INT32 *)(InstructionData->Displacement));
226 }
227 } else {
228 EffectiveAddress += *CcGetRegisterPointer (Regs, Ext->ModRm.Rm);
229 }
230
231 return EffectiveAddress;
232}
233
234/**
235 Decode a ModRM byte.
236
237 Examine the instruction parsing context to decode a ModRM byte and the SIB
238 byte, if present.
239
240 @param[in] Regs x64 processor context
241 @param[in, out] InstructionData Instruction parsing context
242
243**/
244VOID
245CcDecodeModRm (
246 IN EFI_SYSTEM_CONTEXT_X64 *Regs,
247 IN OUT CC_INSTRUCTION_DATA *InstructionData
248 )
249{
250 CC_INSTRUCTION_OPCODE_EXT *Ext;
251 INSTRUCTION_REX_PREFIX *RexPrefix;
252 INSTRUCTION_MODRM *ModRm;
253 INSTRUCTION_SIB *Sib;
254
255 RexPrefix = &InstructionData->RexPrefix;
256 Ext = &InstructionData->Ext;
257 ModRm = &InstructionData->ModRm;
258 Sib = &InstructionData->Sib;
259
260 InstructionData->ModRmPresent = TRUE;
261 ModRm->Uint8 = *(InstructionData->End);
262
263 InstructionData->Displacement++;
264 InstructionData->Immediate++;
265 InstructionData->End++;
266
267 Ext->ModRm.Mod = ModRm->Bits.Mod;
268 Ext->ModRm.Reg = (RexPrefix->Bits.BitR << 3) | ModRm->Bits.Reg;
269 Ext->ModRm.Rm = (RexPrefix->Bits.BitB << 3) | ModRm->Bits.Rm;
270
271 Ext->RegData = *CcGetRegisterPointer (Regs, Ext->ModRm.Reg);
272
273 if (Ext->ModRm.Mod == 3) {
274 Ext->RmData = *CcGetRegisterPointer (Regs, Ext->ModRm.Rm);
275 } else {
276 if (ModRm->Bits.Rm == 4) {
277 InstructionData->SibPresent = TRUE;
278 Sib->Uint8 = *(InstructionData->End);
279
280 InstructionData->Displacement++;
281 InstructionData->Immediate++;
282 InstructionData->End++;
283
284 Ext->Sib.Scale = Sib->Bits.Scale;
285 Ext->Sib.Index = (RexPrefix->Bits.BitX << 3) | Sib->Bits.Index;
286 Ext->Sib.Base = (RexPrefix->Bits.BitB << 3) | Sib->Bits.Base;
287 }
288
289 Ext->RmData = GetEffectiveMemoryAddress (Regs, InstructionData);
290 }
291}
292
293/**
294 Decode instruction prefixes.
295
296 Parse the instruction data to track the instruction prefixes that have
297 been used.
298
299 @param[in] Regs x64 processor context
300 @param[in, out] InstructionData Instruction parsing context
301
302 @retval EFI_SUCCESS Successfully decode Prefixes
303 @retval Others Other error as indicated
304**/
305STATIC
306EFI_STATUS
307DecodePrefixes (
308 IN EFI_SYSTEM_CONTEXT_X64 *Regs,
309 IN OUT CC_INSTRUCTION_DATA *InstructionData
310 )
311{
312 CC_INSTRUCTION_MODE Mode;
313 CC_INSTRUCTION_SIZE ModeDataSize;
314 CC_INSTRUCTION_SIZE ModeAddrSize;
315 UINT8 *Byte;
316 UINT8 ParsedLength;
317
318 ParsedLength = 0;
319
320 //
321 // Always in 64-bit mode
322 //
323 Mode = LongMode64Bit;
324 ModeDataSize = Size32Bits;
325 ModeAddrSize = Size64Bits;
326
327 InstructionData->Mode = Mode;
328 InstructionData->DataSize = ModeDataSize;
329 InstructionData->AddrSize = ModeAddrSize;
330
331 InstructionData->Prefixes = InstructionData->Begin;
332
333 Byte = InstructionData->Prefixes;
334 for ( ; ParsedLength <= MAX_INSTRUCTION_LENGTH; Byte++, InstructionData->PrefixSize++, ParsedLength++) {
335 //
336 // Check the 0x40 to 0x4F range using an if statement here since some
337 // compilers don't like the "case 0x40 ... 0x4F:" syntax. This avoids
338 // 16 case statements below.
339 //
340 if ((*Byte >= REX_PREFIX_START) && (*Byte <= REX_PREFIX_STOP)) {
341 InstructionData->RexPrefix.Uint8 = *Byte;
342 if ((*Byte & REX_64BIT_OPERAND_SIZE_MASK) != 0) {
343 InstructionData->DataSize = Size64Bits;
344 }
345
346 continue;
347 }
348
349 switch (*Byte) {
350 case OVERRIDE_SEGMENT_CS:
351 case OVERRIDE_SEGMENT_DS:
352 case OVERRIDE_SEGMENT_ES:
353 case OVERRIDE_SEGMENT_SS:
354 if (Mode != LongMode64Bit) {
355 InstructionData->SegmentSpecified = TRUE;
356 InstructionData->Segment = (*Byte >> 3) & 3;
357 }
358
359 break;
360
361 case OVERRIDE_SEGMENT_FS:
362 case OVERRIDE_SEGMENT_GS:
363 InstructionData->SegmentSpecified = TRUE;
364 InstructionData->Segment = *Byte & 7;
365 break;
366
367 case OVERRIDE_OPERAND_SIZE:
368 if (InstructionData->RexPrefix.Uint8 == 0) {
369 InstructionData->DataSize =
370 (Mode == LongMode64Bit) ? Size16Bits :
371 (Mode == LongModeCompat32Bit) ? Size16Bits :
372 (Mode == LongModeCompat16Bit) ? Size32Bits : 0;
373 }
374
375 break;
376
377 case OVERRIDE_ADDRESS_SIZE:
378 InstructionData->AddrSize =
379 (Mode == LongMode64Bit) ? Size32Bits :
380 (Mode == LongModeCompat32Bit) ? Size16Bits :
381 (Mode == LongModeCompat16Bit) ? Size32Bits : 0;
382 break;
383
384 case LOCK_PREFIX:
385 break;
386
387 case REPZ_PREFIX:
388 InstructionData->RepMode = RepZ;
389 break;
390
391 case REPNZ_PREFIX:
392 InstructionData->RepMode = RepNZ;
393 break;
394
395 default:
396 InstructionData->OpCodes = Byte;
397 InstructionData->OpCodeSize = (*Byte == TWO_BYTE_OPCODE_ESCAPE) ? 2 : 1;
398
399 InstructionData->End = Byte + InstructionData->OpCodeSize;
400 InstructionData->Displacement = InstructionData->End;
401 InstructionData->Immediate = InstructionData->End;
402 return EFI_SUCCESS;
403 }
404 }
405
406 return EFI_ABORTED;
407}
408
409/**
410 Determine instruction length
411
412 Return the total length of the parsed instruction.
413
414 @param[in] InstructionData Instruction parsing context
415
416 @return Length of parsed instruction
417
418**/
419UINT64
420CcInstructionLength (
421 IN CC_INSTRUCTION_DATA *InstructionData
422 )
423{
424 return (UINT64)(InstructionData->End - InstructionData->Begin);
425}
426
427/**
428 Initialize the instruction parsing context.
429
430 Initialize the instruction parsing context, which includes decoding the
431 instruction prefixes.
432
433 @param[in, out] InstructionData Instruction parsing context
434 @param[in] Ghcb Pointer to the Guest-Hypervisor Communication
435 Block
436 @param[in] Regs x64 processor context
437
438 @retval EFI_SUCCESS Successfully initialize InstructionData
439 @retval Others Other error as indicated
440**/
441EFI_STATUS
442CcInitInstructionData (
443 IN OUT CC_INSTRUCTION_DATA *InstructionData,
444 IN GHCB *Ghcb,
445 IN EFI_SYSTEM_CONTEXT_X64 *Regs
446 )
447{
448 SetMem (InstructionData, sizeof (*InstructionData), 0);
449 InstructionData->Ghcb = Ghcb;
450 InstructionData->Begin = (UINT8 *)Regs->Rip;
451 InstructionData->End = (UINT8 *)Regs->Rip;
452
453 return DecodePrefixes (Regs, InstructionData);
454}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette