]> git.proxmox.com Git - mirror_edk2.git/blob - EdkModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c
projects / mirror_edk2.git / blob
? search:


279f4202b659cdcb9e2cc61db364bd359840b158
[mirror_edk2.git] / EdkModulePkg / Universal / Ebc / Dxe / Ipf / EbcSupport.c
1 /*++
2
3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 EbcSupport.c
15
16 Abstract:
17
18 This module contains EBC support routines that are customized based on
19 the target processor.
20
21 --*/
22
23 #include "EbcInt.h"
24 #include "EbcExecute.h"
25
26 #define VM_STACK_SIZE (1024 * 32)
27
28 #define EBC_THUNK_SIZE 128
29
30 //
31 // For code execution, thunks must be aligned on 16-byte boundary
32 //
33 #define EBC_THUNK_ALIGNMENT 16
34
35 //
36 // Opcodes for IPF instructions. We'll need to hand-create thunk code (stuffing
37 // bits) to insert a jump to the interpreter.
38 //
39 #define OPCODE_NOP (UINT64) 0x00008000000
40 #define OPCODE_BR_COND_SPTK_FEW (UINT64) 0x00100000000
41 #define OPCODE_MOV_BX_RX (UINT64) 0x00E00100000
42
43 //
44 // Opcode for MOVL instruction
45 //
46 #define MOVL_OPCODE 0x06
47
48 VOID
49 EbcAsmLLCALLEX (
50 IN UINTN CallAddr,
51 IN UINTN EbcSp
52 );
53
54 STATIC
55 EFI_STATUS
56 WriteBundle (
57 IN VOID *MemPtr,
58 IN UINT8 Template,
59 IN UINT64 Slot0,
60 IN UINT64 Slot1,
61 IN UINT64 Slot2
62 );
63
64 STATIC
65 VOID
66 PushU64 (
67 VM_CONTEXT *VmPtr,
68 UINT64 Arg
69 )
70 {
71 //
72 // Advance the VM stack down, and then copy the argument to the stack.
73 // Hope it's aligned.
74 //
75 VmPtr->R[0] -= sizeof (UINT64);
76 *(UINT64 *) VmPtr->R[0] = Arg;
77 }
78
79 STATIC
80 UINT64
81 EbcInterpret (
82 UINT64 Arg1,
83 ...
84 )
85 {
86 //
87 // Create a new VM context on the stack
88 //
89 VM_CONTEXT VmContext;
90 UINTN Addr;
91 VA_LIST List;
92 UINT64 Arg2;
93 UINT64 Arg3;
94 UINT64 Arg4;
95 UINT64 Arg5;
96 UINT64 Arg6;
97 UINT64 Arg7;
98 UINT64 Arg8;
99 UINTN Arg9Addr;
100 //
101 // Get the EBC entry point from the processor register. Make sure you don't
102 // call any functions before this or you could mess up the register the
103 // entry point is passed in.
104 //
105 Addr = EbcLLGetEbcEntryPoint ();
106 //
107 // Need the args off the stack.
108 //
109 VA_START (List, Arg1);
110 Arg2 = VA_ARG (List, UINT64);
111 Arg3 = VA_ARG (List, UINT64);
112 Arg4 = VA_ARG (List, UINT64);
113 Arg5 = VA_ARG (List, UINT64);
114 Arg6 = VA_ARG (List, UINT64);
115 Arg7 = VA_ARG (List, UINT64);
116 Arg8 = VA_ARG (List, UINT64);
117 Arg9Addr = (UINTN) List;
118 //
119 // Now clear out our context
120 //
121 ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
122 //
123 // Set the VM instruction pointer to the correct location in memory.
124 //
125 VmContext.Ip = (VMIP) Addr;
126 //
127 // Initialize the stack pointer for the EBC. Get the current system stack
128 // pointer and adjust it down by the max needed for the interpreter.
129 //
130 Addr = (UINTN) Arg9Addr;
131 //
132 // NOTE: Eventually we should have the interpreter allocate memory
133 // for stack space which it will use during its execution. This
134 // would likely improve performance because the interpreter would
135 // no longer be required to test each memory access and adjust
136 // those reading from the stack gap.
137 //
138 // For IPF, the stack looks like (assuming 10 args passed)
139 // arg10
140 // arg9 (Bottom of high stack)
141 // [ stack gap for interpreter execution ]
142 // [ magic value for detection of stack corruption ]
143 // arg8 (Top of low stack)
144 // arg7....
145 // arg1
146 // [ 64-bit return address ]
147 // [ ebc stack ]
148 // If the EBC accesses memory in the stack gap, then we assume that it's
149 // actually trying to access args9 and greater. Therefore we need to
150 // adjust memory accesses in this region to point above the stack gap.
151 //
152 VmContext.HighStackBottom = (UINTN) Addr;
153 //
154 // Now adjust the EBC stack pointer down to leave a gap for interpreter
155 // execution. Then stuff a magic value there.
156 //
157 VmContext.R[0] = (UINT64) Addr;
158 VmContext.R[0] -= VM_STACK_SIZE;
159 PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
160 VmContext.StackMagicPtr = (UINTN *) VmContext.R[0];
161 VmContext.LowStackTop = (UINTN) VmContext.R[0];
162 //
163 // Push the EBC arguments on the stack. Does not matter that they may not
164 // all be valid.
165 //
166 PushU64 (&VmContext, Arg8);
167 PushU64 (&VmContext, Arg7);
168 PushU64 (&VmContext, Arg6);
169 PushU64 (&VmContext, Arg5);
170 PushU64 (&VmContext, Arg4);
171 PushU64 (&VmContext, Arg3);
172 PushU64 (&VmContext, Arg2);
173 PushU64 (&VmContext, Arg1);
174 //
175 // Push a bogus return address on the EBC stack because the
176 // interpreter expects one there. For stack alignment purposes on IPF,
177 // EBC return addresses are always 16 bytes. Push a bogus value as well.
178 //
179 PushU64 (&VmContext, 0);
180 PushU64 (&VmContext, 0xDEADBEEFDEADBEEF);
181 VmContext.StackRetAddr = (UINT64) VmContext.R[0];
182 //
183 // Begin executing the EBC code
184 //
185 EbcExecute (&VmContext);
186 //
187 // Return the value in R[7] unless there was an error
188 //
189 return (UINT64) VmContext.R[7];
190 }
191
192 STATIC
193 UINT64
194 ExecuteEbcImageEntryPoint (
195 IN EFI_HANDLE ImageHandle,
196 IN EFI_SYSTEM_TABLE *SystemTable
197 )
198 /*++
199
200 Routine Description:
201
202 IPF implementation.
203
204 Begin executing an EBC image. The address of the entry point is passed
205 in via a processor register, so we'll need to make a call to get the
206 value.
207
208 Arguments:
209
210 ImageHandle - image handle for the EBC application we're executing
211 SystemTable - standard system table passed into an driver's entry point
212
213 Returns:
214
215 The value returned by the EBC application we're going to run.
216
217 --*/
218 {
219 //
220 // Create a new VM context on the stack
221 //
222 VM_CONTEXT VmContext;
223 UINTN Addr;
224
225 //
226 // Get the EBC entry point from the processor register. Make sure you don't
227 // call any functions before this or you could mess up the register the
228 // entry point is passed in.
229 //
230 Addr = EbcLLGetEbcEntryPoint ();
231
232 //
233 // Now clear out our context
234 //
235 ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
236
237 //
238 // Save the image handle so we can track the thunks created for this image
239 //
240 VmContext.ImageHandle = ImageHandle;
241 VmContext.SystemTable = SystemTable;
242
243 //
244 // Set the VM instruction pointer to the correct location in memory.
245 //
246 VmContext.Ip = (VMIP) Addr;
247
248 //
249 // Get the stack pointer. This is the bottom of the upper stack.
250 //
251 Addr = EbcLLGetStackPointer ();
252 VmContext.HighStackBottom = (UINTN) Addr;
253 VmContext.R[0] = (INT64) Addr;
254
255 //
256 // Allocate stack space for the interpreter. Then put a magic value
257 // at the bottom so we can detect stack corruption.
258 //
259 VmContext.R[0] -= VM_STACK_SIZE;
260 PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
261 VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0];
262
263 //
264 // When we thunk to external native code, we copy the last 8 qwords from
265 // the EBC stack into the processor registers, and adjust the stack pointer
266 // up. If the caller is not passing 8 parameters, then we've moved the
267 // stack pointer up into the stack gap. If this happens, then the caller
268 // can mess up the stack gap contents (in particular our magic value).
269 // Therefore, leave another gap below the magic value. Pick 10 qwords down,
270 // just as a starting point.
271 //
272 VmContext.R[0] -= 10 * sizeof (UINT64);
273
274 //
275 // Align the stack pointer such that after pushing the system table,
276 // image handle, and return address on the stack, it's aligned on a 16-byte
277 // boundary as required for IPF.
278 //
279 VmContext.R[0] &= (INT64)~0x0f;
280 VmContext.LowStackTop = (UINTN) VmContext.R[0];
281 //
282 // Simply copy the image handle and system table onto the EBC stack.
283 // Greatly simplifies things by not having to spill the args
284 //
285 PushU64 (&VmContext, (UINT64) SystemTable);
286 PushU64 (&VmContext, (UINT64) ImageHandle);
287
288 //
289 // Interpreter assumes 64-bit return address is pushed on the stack.
290 // IPF does not do this so pad the stack accordingly. Also, a
291 // "return address" is 16 bytes as required for IPF stack alignments.
292 //
293 PushU64 (&VmContext, (UINT64) 0);
294 PushU64 (&VmContext, (UINT64) 0x1234567887654321);
295 VmContext.StackRetAddr = (UINT64) VmContext.R[0];
296
297 //
298 // Begin executing the EBC code
299 //
300 EbcExecute (&VmContext);
301
302 //
303 // Return the value in R[7] unless there was an error
304 //
305 return (UINT64) VmContext.R[7];
306 }
307
308 EFI_STATUS
309 EbcCreateThunks (
310 IN EFI_HANDLE ImageHandle,
311 IN VOID *EbcEntryPoint,
312 OUT VOID **Thunk,
313 IN UINT32 Flags
314 )
315 /*++
316
317 Routine Description:
318
319 Create thunks for an EBC image entry point, or an EBC protocol service.
320
321 Arguments:
322
323 ImageHandle - Image handle for the EBC image. If not null, then we're
324 creating a thunk for an image entry point.
325 EbcEntryPoint - Address of the EBC code that the thunk is to call
326 Thunk - Returned thunk we create here
327 Flags - Flags indicating options for creating the thunk
328
329 Returns:
330
331 Standard EFI status.
332
333 --*/
334 {
335 UINT8 *Ptr;
336 UINT8 *ThunkBase;
337 UINT64 Addr;
338 UINT64 Code[3]; // Code in a bundle
339 UINT64 RegNum; // register number for MOVL
340 UINT64 I; // bits of MOVL immediate data
341 UINT64 Ic; // bits of MOVL immediate data
342 UINT64 Imm5c; // bits of MOVL immediate data
343 UINT64 Imm9d; // bits of MOVL immediate data
344 UINT64 Imm7b; // bits of MOVL immediate data
345 UINT64 Br; // branch register for loading and jumping
346 UINT64 *Data64Ptr;
347 UINT32 ThunkSize;
348 UINT32 Size;
349 EFI_STATUS Status;
350
351 //
352 // Check alignment of pointer to EBC code, which must always be aligned
353 // on a 2-byte boundary.
354 //
355 if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
356 return EFI_INVALID_PARAMETER;
357 }
358 //
359 // Allocate memory for the thunk. Make the (most likely incorrect) assumption
360 // that the returned buffer is not aligned, so round up to the next
361 // alignment size.
362 //
363 Size = EBC_THUNK_SIZE + EBC_THUNK_ALIGNMENT - 1;
364 ThunkSize = Size;
365 Status = gBS->AllocatePool (
366 EfiBootServicesData,
367 Size,
368 (VOID *) &Ptr
369 );
370 if (Status != EFI_SUCCESS) {
371 return EFI_OUT_OF_RESOURCES;
372 }
373 //
374 // Save the start address of the buffer.
375 //
376 ThunkBase = Ptr;
377
378 //
379 // Make sure it's aligned for code execution. If not, then
380 // round up.
381 //
382 if ((UINT32) (UINTN) Ptr & (EBC_THUNK_ALIGNMENT - 1)) {
383 Ptr = (UINT8 *) (((UINTN) Ptr + (EBC_THUNK_ALIGNMENT - 1)) &~ (UINT64) (EBC_THUNK_ALIGNMENT - 1));
384 }
385 //
386 // Return the pointer to the thunk to the caller to user as the
387 // image entry point.
388 //
389 *Thunk = (VOID *) Ptr;
390
391 //
392 // Clear out the thunk entry
393 // ZeroMem(Ptr, Size);
394 //
395 // For IPF, when you do a call via a function pointer, the function pointer
396 // actually points to a function descriptor which consists of a 64-bit
397 // address of the function, followed by a 64-bit gp for the function being
398 // called. See the the Software Conventions and Runtime Architecture Guide
399 // for details.
400 // So first off in our thunk, create a descriptor for our actual thunk code.
401 // This means we need to create a pointer to the thunk code (which follows
402 // the descriptor we're going to create), followed by the gp of the Vm
403 // interpret function we're going to eventually execute.
404 //
405 Data64Ptr = (UINT64 *) Ptr;
406
407 //
408 // Write the function's entry point (which is our thunk code that follows
409 // this descriptor we're creating).
410 //
411 *Data64Ptr = (UINT64) (Data64Ptr + 2);
412 //
413 // Get the gp from the descriptor for EbcInterpret and stuff it in our thunk
414 // descriptor.
415 //
416 *(Data64Ptr + 1) = *(UINT64 *) ((UINT64 *) (UINTN) EbcInterpret + 1);
417 //
418 // Advance our thunk data pointer past the descriptor. Since the
419 // descriptor consists of 16 bytes, the pointer is still aligned for
420 // IPF code execution (on 16-byte boundary).
421 //
422 Ptr += sizeof (UINT64) * 2;
423
424 //
425 // *************************** MAGIC BUNDLE ********************************
426 //
427 // Write magic code bundle for: movl r8 = 0xca112ebcca112ebc to help the VM
428 // to recognize it is a thunk.
429 //
430 Addr = (UINT64) 0xCA112EBCCA112EBC;
431
432 //
433 // Now generate the code bytes. First is nop.m 0x0
434 //
435 Code[0] = OPCODE_NOP;
436
437 //
438 // Next is simply Addr[62:22] (41 bits) of the address
439 //
440 Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
441
442 //
443 // Extract bits from the address for insertion into the instruction
444 // i = Addr[63:63]
445 //
446 I = RShiftU64 (Addr, 63) & 0x01;
447 //
448 // ic = Addr[21:21]
449 //
450 Ic = RShiftU64 (Addr, 21) & 0x01;
451 //
452 // imm5c = Addr[20:16] for 5 bits
453 //
454 Imm5c = RShiftU64 (Addr, 16) & 0x1F;
455 //
456 // imm9d = Addr[15:7] for 9 bits
457 //
458 Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
459 //
460 // imm7b = Addr[6:0] for 7 bits
461 //
462 Imm7b = Addr & 0x7F;
463
464 //
465 // The EBC entry point will be put into r8, so r8 can be used here
466 // temporary. R8 is general register and is auto-serialized.
467 //
468 RegNum = 8;
469
470 //
471 // Next is jumbled data, including opcode and rest of address
472 //
473 Code[2] = LShiftU64 (Imm7b, 13);
474 Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
475 Code[2] = Code[2] | LShiftU64 (Ic, 21);
476 Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
477 Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
478 Code[2] = Code[2] | LShiftU64 (I, 36);
479 Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
480 Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
481
482 WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
483
484 //
485 // *************************** FIRST BUNDLE ********************************
486 //
487 // Write code bundle for: movl r8 = EBC_ENTRY_POINT so we pass
488 // the ebc entry point in to the interpreter function via a processor
489 // register.
490 // Note -- we could easily change this to pass in a pointer to a structure
491 // that contained, among other things, the EBC image's entry point. But
492 // for now pass it directly.
493 //
494 Ptr += 16;
495 Addr = (UINT64) EbcEntryPoint;
496
497 //
498 // Now generate the code bytes. First is nop.m 0x0
499 //
500 Code[0] = OPCODE_NOP;
501
502 //
503 // Next is simply Addr[62:22] (41 bits) of the address
504 //
505 Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
506
507 //
508 // Extract bits from the address for insertion into the instruction
509 // i = Addr[63:63]
510 //
511 I = RShiftU64 (Addr, 63) & 0x01;
512 //
513 // ic = Addr[21:21]
514 //
515 Ic = RShiftU64 (Addr, 21) & 0x01;
516 //
517 // imm5c = Addr[20:16] for 5 bits
518 //
519 Imm5c = RShiftU64 (Addr, 16) & 0x1F;
520 //
521 // imm9d = Addr[15:7] for 9 bits
522 //
523 Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
524 //
525 // imm7b = Addr[6:0] for 7 bits
526 //
527 Imm7b = Addr & 0x7F;
528
529 //
530 // Put the EBC entry point in r8, which is the location of the return value
531 // for functions.
532 //
533 RegNum = 8;
534
535 //
536 // Next is jumbled data, including opcode and rest of address
537 //
538 Code[2] = LShiftU64 (Imm7b, 13);
539 Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
540 Code[2] = Code[2] | LShiftU64 (Ic, 21);
541 Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
542 Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
543 Code[2] = Code[2] | LShiftU64 (I, 36);
544 Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
545 Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
546
547 WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
548
549 //
550 // *************************** NEXT BUNDLE *********************************
551 //
552 // Write code bundle for:
553 // movl rx = offset_of(EbcInterpret|ExecuteEbcImageEntryPoint)
554 //
555 // Advance pointer to next bundle, then compute the offset from this bundle
556 // to the address of the entry point of the interpreter.
557 //
558 Ptr += 16;
559 if (Flags & FLAG_THUNK_ENTRY_POINT) {
560 Addr = (UINT64) ExecuteEbcImageEntryPoint;
561 } else {
562 Addr = (UINT64) EbcInterpret;
563 }
564 //
565 // Indirection on Itanium-based systems
566 //
567 Addr = *(UINT64 *) Addr;
568
569 //
570 // Now write the code to load the offset into a register
571 //
572 Code[0] = OPCODE_NOP;
573
574 //
575 // Next is simply Addr[62:22] (41 bits) of the address
576 //
577 Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
578
579 //
580 // Extract bits from the address for insertion into the instruction
581 // i = Addr[63:63]
582 //
583 I = RShiftU64 (Addr, 63) & 0x01;
584 //
585 // ic = Addr[21:21]
586 //
587 Ic = RShiftU64 (Addr, 21) & 0x01;
588 //
589 // imm5c = Addr[20:16] for 5 bits
590 //
591 Imm5c = RShiftU64 (Addr, 16) & 0x1F;
592 //
593 // imm9d = Addr[15:7] for 9 bits
594 //
595 Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
596 //
597 // imm7b = Addr[6:0] for 7 bits
598 //
599 Imm7b = Addr & 0x7F;
600
601 //
602 // Put it in r31, a scratch register
603 //
604 RegNum = 31;
605
606 //
607 // Next is jumbled data, including opcode and rest of address
608 //
609 Code[2] = LShiftU64(Imm7b, 13);
610 Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
611 Code[2] = Code[2] | LShiftU64 (Ic, 21);
612 Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
613 Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
614 Code[2] = Code[2] | LShiftU64 (I, 36);
615 Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
616 Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
617
618 WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
619
620 //
621 // *************************** NEXT BUNDLE *********************************
622 //
623 // Load branch register with EbcInterpret() function offset from the bundle
624 // address: mov b6 = RegNum
625 //
626 // See volume 3 page 4-29 of the Arch. Software Developer's Manual.
627 //
628 // Advance pointer to next bundle
629 //
630 Ptr += 16;
631 Code[0] = OPCODE_NOP;
632 Code[1] = OPCODE_NOP;
633 Code[2] = OPCODE_MOV_BX_RX;
634
635 //
636 // Pick a branch register to use. Then fill in the bits for the branch
637 // register and user register (same user register as previous bundle).
638 //
639 Br = 6;
640 Code[2] |= LShiftU64 (Br, 6);
641 Code[2] |= LShiftU64 (RegNum, 13);
642 WriteBundle ((VOID *) Ptr, 0x0d, Code[0], Code[1], Code[2]);
643
644 //
645 // *************************** NEXT BUNDLE *********************************
646 //
647 // Now do the branch: (p0) br.cond.sptk.few b6
648 //
649 // Advance pointer to next bundle.
650 // Fill in the bits for the branch register (same reg as previous bundle)
651 //
652 Ptr += 16;
653 Code[0] = OPCODE_NOP;
654 Code[1] = OPCODE_NOP;
655 Code[2] = OPCODE_BR_COND_SPTK_FEW;
656 Code[2] |= LShiftU64 (Br, 13);
657 WriteBundle ((VOID *) Ptr, 0x1d, Code[0], Code[1], Code[2]);
658
659 //
660 // Add the thunk to our list of allocated thunks so we can do some cleanup
661 // when the image is unloaded. Do this last since the Add function flushes
662 // the instruction cache for us.
663 //
664 EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
665
666 //
667 // Done
668 //
669 return EFI_SUCCESS;
670 }
671
672 STATIC
673 EFI_STATUS
674 WriteBundle (
675 IN VOID *MemPtr,
676 IN UINT8 Template,
677 IN UINT64 Slot0,
678 IN UINT64 Slot1,
679 IN UINT64 Slot2
680 )
681 /*++
682
683 Routine Description:
684
685 Given raw bytes of Itanium based code, format them into a bundle and
686 write them out.
687
688 Arguments:
689
690 MemPtr - pointer to memory location to write the bundles to
691 Template - 5-bit template
692 Slot0-2 - instruction slot data for the bundle
693
694 Returns:
695
696 EFI_INVALID_PARAMETER - Pointer is not aligned
697 - No more than 5 bits in template
698 - More than 41 bits used in code
699 EFI_SUCCESS - All data is written.
700
701 --*/
702 {
703 UINT8 *BPtr;
704 UINT32 Index;
705 UINT64 Low64;
706 UINT64 High64;
707
708 //
709 // Verify pointer is aligned
710 //
711 if ((UINT64) MemPtr & 0xF) {
712 return EFI_INVALID_PARAMETER;
713 }
714 //
715 // Verify no more than 5 bits in template
716 //
717 if (Template &~0x1F) {
718 return EFI_INVALID_PARAMETER;
719 }
720 //
721 // Verify max of 41 bits used in code
722 //
723 if ((Slot0 | Slot1 | Slot2) &~0x1ffffffffff) {
724 return EFI_INVALID_PARAMETER;
725 }
726
727 Low64 = LShiftU64 (Slot1, 46);
728 Low64 = Low64 | LShiftU64 (Slot0, 5) | Template;
729
730 High64 = RShiftU64 (Slot1, 18);
731 High64 = High64 | LShiftU64 (Slot2, 23);
732
733 //
734 // Now write it all out
735 //
736 BPtr = (UINT8 *) MemPtr;
737 for (Index = 0; Index < 8; Index++) {
738 *BPtr = (UINT8) Low64;
739 Low64 = RShiftU64 (Low64, 8);
740 BPtr++;
741 }
742
743 for (Index = 0; Index < 8; Index++) {
744 *BPtr = (UINT8) High64;
745 High64 = RShiftU64 (High64, 8);
746 BPtr++;
747 }
748
749 return EFI_SUCCESS;
750 }
751
752 VOID
753 EbcLLCALLEX (
754 IN VM_CONTEXT *VmPtr,
755 IN UINTN FuncAddr,
756 IN UINTN NewStackPointer,
757 IN VOID *FramePtr,
758 IN UINT8 Size
759 )
760 /*++
761
762 Routine Description:
763
764 This function is called to execute an EBC CALLEX instruction.
765 The function check the callee's content to see whether it is common native
766 code or a thunk to another piece of EBC code.
767 If the callee is common native code, use EbcLLCAllEXASM to manipulate,
768 otherwise, set the VM->IP to target EBC code directly to avoid another VM
769 be startup which cost time and stack space.
770
771 Arguments:
772
773 VmPtr - Pointer to a VM context.
774 FuncAddr - Callee's address
775 NewStackPointer - New stack pointer after the call
776 FramePtr - New frame pointer after the call
777 Size - The size of call instruction
778
779 Returns:
780
781 None.
782
783 --*/
784 {
785 UINTN IsThunk;
786 UINTN TargetEbcAddr;
787 UINTN CodeOne18;
788 UINTN CodeOne23;
789 UINTN CodeTwoI;
790 UINTN CodeTwoIc;
791 UINTN CodeTwo7b;
792 UINTN CodeTwo5c;
793 UINTN CodeTwo9d;
794 UINTN CalleeAddr;
795
796 IsThunk = 1;
797 TargetEbcAddr = 0;
798
799 //
800 // FuncAddr points to the descriptor of the target instructions.
801 //
802 CalleeAddr = *((UINT64 *)FuncAddr);
803
804 //
805 // Processor specific code to check whether the callee is a thunk to EBC.
806 //
807 if (*((UINT64 *)CalleeAddr) != 0xBCCA000100000005) {
808 IsThunk = 0;
809 goto Action;
810 }
811 if (*((UINT64 *)CalleeAddr + 1) != 0x697623C1004A112E) {
812 IsThunk = 0;
813 goto Action;
814 }
815
816 CodeOne18 = RShiftU64 (*((UINT64 *)CalleeAddr + 2), 46) & 0x3FFFF;
817 CodeOne23 = (*((UINT64 *)CalleeAddr + 3)) & 0x7FFFFF;
818 CodeTwoI = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 59) & 0x1;
819 CodeTwoIc = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 44) & 0x1;
820 CodeTwo7b = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 36) & 0x7F;
821 CodeTwo5c = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 45) & 0x1F;
822 CodeTwo9d = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 50) & 0x1FF;
823
824 TargetEbcAddr = CodeTwo7b;
825 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo9d, 7);
826 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo5c, 16);
827 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoIc, 21);
828 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne18, 22);
829 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne23, 40);
830 TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoI, 63);
831
832 Action:
833 if (IsThunk == 1){
834 //
835 // The callee is a thunk to EBC, adjust the stack pointer down 16 bytes and
836 // put our return address and frame pointer on the VM stack.
837 // Then set the VM's IP to new EBC code.
838 //
839 VmPtr->R[0] -= 8;
840 VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr);
841 VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0];
842 VmPtr->R[0] -= 8;
843 VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (VmPtr->Ip + Size));
844
845 VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
846 } else {
847 //
848 // The callee is not a thunk to EBC, call native code.
849 //
850 EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
851
852 //
853 // Get return value and advance the IP.
854 //
855 VmPtr->R[7] = EbcLLGetReturnValue ();
856 VmPtr->Ip += Size;
857 }
858 }
859
860 VOID
861 EbcLLCALLEXNative (
862 IN UINTN CallAddr,
863 IN UINTN EbcSp,
864 IN VOID *FramePtr
865 )
866 /*++
867
868 Routine Description:
869 Implements the EBC CALLEX instruction to call an external function, which
870 seems to be native code.
871
872 We'll copy the entire EBC stack frame down below itself in memory and use
873 that copy for passing parameters.
874
875 Arguments:
876 CallAddr - address (function pointer) of function to call
877 EbcSp - current EBC stack pointer
878 FramePtr - current EBC frame pointer.
879
880 Returns:
881 NA
882
883 --*/
884 {
885 UINTN FrameSize;
886 VOID *Destination;
887 VOID *Source;
888 //
889 // The stack for an EBC function looks like this:
890 // FramePtr (8)
891 // RetAddr (8)
892 // Locals (n)
893 // Stack for passing args (m)
894 //
895 // Pad the frame size with 64 bytes because the low-level code we call
896 // will move the stack pointer up assuming worst-case 8 args in registers.
897 //
898 FrameSize = (UINTN) FramePtr - (UINTN) EbcSp + 64;
899 Source = (VOID *) EbcSp;
900 Destination = (VOID *) ((UINT8 *) EbcSp - FrameSize - CPU_STACK_ALIGNMENT);
901 Destination = (VOID *) ((UINTN) ((UINTN) Destination + CPU_STACK_ALIGNMENT - 1) &~((UINTN) CPU_STACK_ALIGNMENT - 1));
902 gBS->CopyMem (Destination, Source, FrameSize);
903 EbcAsmLLCALLEX ((UINTN) CallAddr, (UINTN) Destination);
904 }
EFI Development Kit II mirror for PVE