MdeModulePkg: Fix some typos of "according"
[mirror_edk2.git] / MdeModulePkg / Universal / EbcDxe / EbcDebugger / EdbDisasmSupport.c
1 /** @file
2
3 Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
4 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
13 **/
14
15 #include "Edb.h"
16
17 extern EDB_DISASM_INSTRUCTION mEdbDisasmInstructionTable[];
18
19 typedef struct {
20 CHAR16 Name[EDB_INSTRUCTION_NAME_MAX_LENGTH];
21 CHAR16 Content[EDB_INSTRUCTION_CONTENT_MAX_LENGTH];
22 CHAR16 Tail;
23 } EDB_INSTRUCTION_STRING;
24
25 EDB_INSTRUCTION_STRING mInstructionString;
26 UINTN mInstructionNameOffset;
27 UINTN mInstructionContentOffset;
28
29 /**
30
31 Set offset for Instruction name and content.
32
33 @param InstructionNameOffset - Instruction name offset
34 @param InstructionContentOffset - Instruction content offset
35
36 **/
37 VOID
38 EdbSetOffset (
39 IN UINTN InstructionNameOffset,
40 IN UINTN InstructionContentOffset
41 )
42 {
43 mInstructionNameOffset = InstructionNameOffset;
44 mInstructionContentOffset = InstructionContentOffset;
45
46 return ;
47 }
48
49 /**
50
51 Pre instruction string construction.
52
53 @return Instruction string
54
55 **/
56 CHAR16 *
57 EdbPreInstructionString (
58 VOID
59 )
60 {
61 ZeroMem (&mInstructionString, sizeof(mInstructionString));
62 mInstructionNameOffset = 0;
63 mInstructionContentOffset = 0;
64
65 return (CHAR16 *)&mInstructionString;
66 }
67
68 /**
69
70 Post instruction string construction.
71
72 @return Instruction string
73
74 **/
75 CHAR16 *
76 EdbPostInstructionString (
77 VOID
78 )
79 {
80 CHAR16 *Char;
81
82 for (Char = (CHAR16 *)&mInstructionString; Char < &mInstructionString.Tail; Char++) {
83 if (*Char == 0) {
84 *Char = L' ';
85 }
86 }
87 mInstructionString.Tail = 0;
88
89 mInstructionNameOffset = 0;
90 mInstructionContentOffset = 0;
91
92 return (CHAR16 *)&mInstructionString;
93 }
94
95 /**
96
97 Get Sign, NaturalUnits, and ConstantUnits of the WORD data.
98
99 @param Data16 - WORD data
100 @param NaturalUnits - Natural Units of the WORD
101 @param ConstantUnits - Constant Units of the WORD
102
103 @return Sign value of WORD
104
105 **/
106 BOOLEAN
107 EdbGetNaturalIndex16 (
108 IN UINT16 Data16,
109 OUT UINTN *NaturalUnits,
110 OUT UINTN *ConstantUnits
111 )
112 {
113 BOOLEAN Sign;
114 UINTN NaturalUnitBit;
115
116 Sign = (BOOLEAN)(Data16 >> 15);
117 NaturalUnitBit = (UINTN)((Data16 >> 12) & 0x7);
118 NaturalUnitBit *= 2;
119 Data16 = Data16 & 0xFFF;
120 *NaturalUnits = (UINTN)(Data16 & ((1 << NaturalUnitBit) - 1));
121 *ConstantUnits = (UINTN)((Data16 >> NaturalUnitBit) & ((1 << (12 - NaturalUnitBit)) - 1));
122
123 return Sign;
124 }
125
126 /**
127
128 Get Sign, NaturalUnits, and ConstantUnits of the DWORD data.
129
130 @param Data32 - DWORD data
131 @param NaturalUnits - Natural Units of the DWORD
132 @param ConstantUnits - Constant Units of the DWORD
133
134 @return Sign value of DWORD
135
136 **/
137 BOOLEAN
138 EdbGetNaturalIndex32 (
139 IN UINT32 Data32,
140 OUT UINTN *NaturalUnits,
141 OUT UINTN *ConstantUnits
142 )
143 {
144 BOOLEAN Sign;
145 UINTN NaturalUnitBit;
146
147 Sign = (BOOLEAN)(Data32 >> 31);
148 NaturalUnitBit = (UINTN)((Data32 >> 28) & 0x7);
149 NaturalUnitBit *= 4;
150 Data32 = Data32 & 0xFFFFFFF;
151 *NaturalUnits = (UINTN)(Data32 & ((1 << NaturalUnitBit) - 1));
152 *ConstantUnits = (UINTN)((Data32 >> NaturalUnitBit) & ((1 << (28 - NaturalUnitBit)) - 1));
153
154 return Sign;
155 }
156
157 /**
158
159 Get Sign, NaturalUnits, and ConstantUnits of the QWORD data.
160
161 @param Data64 - QWORD data
162 @param NaturalUnits - Natural Units of the QWORD
163 @param ConstantUnits - Constant Units of the QWORD
164
165 @return Sign value of QWORD
166
167 **/
168 BOOLEAN
169 EdbGetNaturalIndex64 (
170 IN UINT64 Data64,
171 OUT UINT64 *NaturalUnits,
172 OUT UINT64 *ConstantUnits
173 )
174 {
175 BOOLEAN Sign;
176 UINTN NaturalUnitBit;
177
178 Sign = (BOOLEAN)RShiftU64 (Data64, 63);
179 NaturalUnitBit = (UINTN)(RShiftU64 (Data64, 60) & 0x7);
180 NaturalUnitBit *= 8;
181 Data64 = RShiftU64 (LShiftU64 (Data64, 4), 4);
182 *NaturalUnits = (UINT64)(Data64 & (LShiftU64 (1, NaturalUnitBit) - 1));
183 *ConstantUnits = (UINT64)(RShiftU64 (Data64, NaturalUnitBit) & (LShiftU64 (1, (60 - NaturalUnitBit)) - 1));
184
185 return Sign;
186 }
187
188 /**
189
190 Get Bit Width of the value.
191
192 @param Value - data
193
194 @return Bit width
195
196 **/
197 UINT8
198 EdbGetBitWidth (
199 IN UINT64 Value
200 )
201 {
202 if (Value >= 10000000000000) {
203 return 14;
204 } else if (Value >= 1000000000000) {
205 return 13;
206 } else if (Value >= 100000000000) {
207 return 12;
208 } else if (Value >= 10000000000) {
209 return 11;
210 } else if (Value >= 1000000000) {
211 return 10;
212 } else if (Value >= 100000000) {
213 return 9;
214 } else if (Value >= 10000000) {
215 return 8;
216 } else if (Value >= 1000000) {
217 return 7;
218 } else if (Value >= 100000) {
219 return 6;
220 } else if (Value >= 10000) {
221 return 5;
222 } else if (Value >= 1000) {
223 return 4;
224 } else if (Value >= 100) {
225 return 3;
226 } else if (Value >= 10) {
227 return 2;
228 } else {
229 return 1;
230 }
231 }
232
233 /**
234
235 Print the instruction name.
236
237 @param Name - instruction name
238
239 @return Instruction name offset
240
241 **/
242 UINTN
243 EdbPrintInstructionName (
244 IN CHAR16 *Name
245 )
246 {
247 EDBSPrintWithOffset (
248 mInstructionString.Name,
249 EDB_INSTRUCTION_NAME_MAX_SIZE,
250 mInstructionNameOffset,
251 L"%s",
252 Name
253 );
254 mInstructionNameOffset += StrLen (Name);
255
256 return mInstructionNameOffset;
257 }
258
259 /**
260
261 Print register 1 in operands.
262
263 @param Operands - instruction operands
264
265 @return Instruction content offset
266
267 **/
268 UINTN
269 EdbPrintRegister1 (
270 IN UINT8 Operands
271 )
272 {
273 if ((Operands & OPERAND_M_INDIRECT1) != 0) {
274 EDBSPrintWithOffset (
275 mInstructionString.Content,
276 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
277 mInstructionContentOffset,
278 L"@"
279 );
280 mInstructionContentOffset += 1;
281 }
282 EDBSPrintWithOffset (
283 mInstructionString.Content,
284 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
285 mInstructionContentOffset,
286 L"R%d",
287 (UINTN)(Operands & OPERAND_M_OP1)
288 );
289 mInstructionContentOffset += 2;
290
291 return mInstructionContentOffset;
292 }
293
294 /**
295
296 Print register 2 in operands.
297
298 @param Operands - instruction operands
299
300 @return Instruction content offset
301
302 **/
303 UINTN
304 EdbPrintRegister2 (
305 IN UINT8 Operands
306 )
307 {
308 if ((Operands & OPERAND_M_INDIRECT2) != 0) {
309 EDBSPrintWithOffset (
310 mInstructionString.Content,
311 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
312 mInstructionContentOffset,
313 L"@"
314 );
315 mInstructionContentOffset += 1;
316 }
317 EDBSPrintWithOffset (
318 mInstructionString.Content,
319 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
320 mInstructionContentOffset,
321 L"R%d",
322 (UINTN)((Operands & OPERAND_M_OP2) >> 4)
323 );
324 mInstructionContentOffset += 2;
325
326 return mInstructionContentOffset;
327 }
328
329 /**
330
331 Print dedicated register 1 in operands.
332
333 @param Operands - instruction operands
334
335 @return Instruction content offset
336
337 **/
338 UINTN
339 EdbPrintDedicatedRegister1 (
340 IN UINT8 Operands
341 )
342 {
343 switch (Operands & OPERAND_M_OP1) {
344 case 0:
345 EDBSPrintWithOffset (
346 mInstructionString.Content,
347 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
348 mInstructionContentOffset,
349 L"[FLAGS]"
350 );
351 mInstructionContentOffset += 7;
352 break;
353 case 1:
354 EDBSPrintWithOffset (
355 mInstructionString.Content,
356 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
357 mInstructionContentOffset,
358 L"[IP]"
359 );
360 mInstructionContentOffset += 4;
361 break;
362 }
363
364 return mInstructionContentOffset;
365 }
366
367 /**
368
369 Print dedicated register 2 in operands.
370
371 @param Operands - instruction operands
372
373 @return Instruction content offset
374
375 **/
376 UINTN
377 EdbPrintDedicatedRegister2 (
378 IN UINT8 Operands
379 )
380 {
381 switch ((Operands & OPERAND_M_OP2) >> 4) {
382 case 0:
383 EDBSPrintWithOffset (
384 mInstructionString.Content,
385 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
386 mInstructionContentOffset,
387 L"[FLAGS]"
388 );
389 mInstructionContentOffset += 7;
390 break;
391 case 1:
392 EDBSPrintWithOffset (
393 mInstructionString.Content,
394 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
395 mInstructionContentOffset,
396 L"[IP]"
397 );
398 mInstructionContentOffset += 4;
399 break;
400 }
401
402 return mInstructionContentOffset;
403 }
404
405 /**
406
407 Print the hexical UINTN index data to instruction content.
408
409 @param Sign - Signed bit of UINTN data
410 @param NaturalUnits - natural units of UINTN data
411 @param ConstantUnits - natural units of UINTN data
412
413 @return Instruction content offset
414
415 **/
416 UINTN
417 EdbPrintIndexData (
418 IN BOOLEAN Sign,
419 IN UINTN NaturalUnits,
420 IN UINTN ConstantUnits
421 )
422 {
423 EDBSPrintWithOffset (
424 mInstructionString.Content,
425 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
426 mInstructionContentOffset,
427 L"(%s%d,%s%d)",
428 Sign ? L"-" : L"+",
429 NaturalUnits,
430 Sign ? L"-" : L"+",
431 ConstantUnits
432 );
433 mInstructionContentOffset = mInstructionContentOffset + 5 + EdbGetBitWidth (NaturalUnits) + EdbGetBitWidth (ConstantUnits);
434
435 return mInstructionContentOffset;
436 }
437
438 /**
439
440 Print the hexical QWORD index data to instruction content.
441
442 @param Sign - Signed bit of QWORD data
443 @param NaturalUnits - natural units of QWORD data
444 @param ConstantUnits - natural units of QWORD data
445
446 @return Instruction content offset
447
448 **/
449 UINTN
450 EdbPrintIndexData64 (
451 IN BOOLEAN Sign,
452 IN UINT64 NaturalUnits,
453 IN UINT64 ConstantUnits
454 )
455 {
456 EDBSPrintWithOffset (
457 mInstructionString.Content,
458 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
459 mInstructionContentOffset,
460 L"(%s%ld,%s%ld)",
461 Sign ? L"-" : L"+",
462 NaturalUnits,
463 Sign ? L"-" : L"+",
464 ConstantUnits
465 );
466 mInstructionContentOffset = mInstructionContentOffset + 5 + EdbGetBitWidth (NaturalUnits) + EdbGetBitWidth (ConstantUnits);
467
468 return mInstructionContentOffset;
469 }
470
471 /**
472
473 Print the hexical WORD raw index data to instruction content.
474
475 @param Data16 - WORD data
476
477 @return Instruction content offset
478
479 **/
480 UINTN
481 EdbPrintRawIndexData16 (
482 IN UINT16 Data16
483 )
484 {
485 BOOLEAN Sign;
486 UINTN NaturalUnits;
487 UINTN ConstantUnits;
488 UINTN Offset;
489
490 Sign = EdbGetNaturalIndex16 (Data16, &NaturalUnits, &ConstantUnits);
491 Offset = EdbPrintIndexData (Sign, NaturalUnits, ConstantUnits);
492
493 return Offset;
494 }
495
496 /**
497
498 Print the hexical DWORD raw index data to instruction content.
499
500 @param Data32 - DWORD data
501
502 @return Instruction content offset
503
504 **/
505 UINTN
506 EdbPrintRawIndexData32 (
507 IN UINT32 Data32
508 )
509 {
510 BOOLEAN Sign;
511 UINTN NaturalUnits;
512 UINTN ConstantUnits;
513 UINTN Offset;
514
515 Sign = EdbGetNaturalIndex32 (Data32, &NaturalUnits, &ConstantUnits);
516 Offset = EdbPrintIndexData (Sign, NaturalUnits, ConstantUnits);
517
518 return Offset;
519 }
520
521 /**
522
523 Print the hexical QWORD raw index data to instruction content.
524
525 @param Data64 - QWORD data
526
527 @return Instruction content offset
528
529 **/
530 UINTN
531 EdbPrintRawIndexData64 (
532 IN UINT64 Data64
533 )
534 {
535 BOOLEAN Sign;
536 UINT64 NaturalUnits;
537 UINT64 ConstantUnits;
538 UINTN Offset;
539
540 Sign = EdbGetNaturalIndex64 (Data64, &NaturalUnits, &ConstantUnits);
541 Offset = EdbPrintIndexData64 (Sign, NaturalUnits, ConstantUnits);
542
543 return Offset;
544 }
545
546 /**
547
548 Print the hexical BYTE immediate data to instruction content.
549
550 @param Data - BYTE data
551
552 @return Instruction content offset
553
554 **/
555 UINTN
556 EdbPrintImmData8 (
557 IN UINT8 Data
558 )
559 {
560 EDBSPrintWithOffset (
561 mInstructionString.Content,
562 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
563 mInstructionContentOffset,
564 L"(0x%02x)",
565 (UINTN)Data
566 );
567 mInstructionContentOffset += 6;
568
569 return mInstructionContentOffset;
570 }
571
572 /**
573
574 Print the hexical WORD immediate data to instruction content.
575
576 @param Data - WORD data
577
578 @return Instruction content offset
579
580 **/
581 UINTN
582 EdbPrintImmData16 (
583 IN UINT16 Data
584 )
585 {
586 EDBSPrintWithOffset (
587 mInstructionString.Content,
588 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
589 mInstructionContentOffset,
590 L"(0x%04x)",
591 (UINTN)Data
592 );
593 mInstructionContentOffset += 8;
594
595 return mInstructionContentOffset;
596 }
597
598 /**
599
600 Print the hexical DWORD immediate data to instruction content.
601
602 @param Data - DWORD data
603
604 @return Instruction content offset
605
606 **/
607 UINTN
608 EdbPrintImmData32 (
609 IN UINT32 Data
610 )
611 {
612 EDBSPrintWithOffset (
613 mInstructionString.Content,
614 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
615 mInstructionContentOffset,
616 L"(0x%08x)",
617 (UINTN)Data
618 );
619 mInstructionContentOffset += 12;
620
621 return mInstructionContentOffset;
622 }
623
624 /**
625
626 Print the hexical QWORD immediate data to instruction content.
627
628 @param Data - QWORD data
629
630 @return Instruction content offset
631
632 **/
633 UINTN
634 EdbPrintImmData64 (
635 IN UINT64 Data
636 )
637 {
638 EDBSPrintWithOffset (
639 mInstructionString.Content,
640 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
641 mInstructionContentOffset,
642 L"(0x%016lx)",
643 Data
644 );
645 mInstructionContentOffset += 20;
646
647 return mInstructionContentOffset;
648 }
649
650 /**
651
652 Print the decimal UINTN immediate data to instruction content.
653
654 @param Data - UINTN data
655
656 @return Instruction content offset
657
658 **/
659 UINTN
660 EdbPrintImmDatan (
661 IN UINTN Data
662 )
663 {
664 EDBSPrintWithOffset (
665 mInstructionString.Content,
666 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
667 mInstructionContentOffset,
668 L"(%d)",
669 (UINTN)Data
670 );
671 mInstructionContentOffset = mInstructionContentOffset + 2 + EdbGetBitWidth (Data);
672
673 return mInstructionContentOffset;
674 }
675
676 /**
677
678 Print the decimal QWORD immediate data to instruction content.
679
680 @param Data64 - QWORD data
681
682 @return Instruction content offset
683
684 **/
685 UINTN
686 EdbPrintImmData64n (
687 IN UINT64 Data64
688 )
689 {
690 EDBSPrintWithOffset (
691 mInstructionString.Content,
692 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
693 mInstructionContentOffset,
694 L"(%ld)",
695 Data64
696 );
697 mInstructionContentOffset = mInstructionContentOffset + 2 + EdbGetBitWidth (Data64);
698
699 return mInstructionContentOffset;
700 }
701
702 /**
703
704 Print the hexical BYTE to instruction content.
705
706 @param Data8 - BYTE data
707
708 @return Instruction content offset
709
710 **/
711 UINTN
712 EdbPrintData8 (
713 IN UINT8 Data8
714 )
715 {
716 EDBSPrintWithOffset (
717 mInstructionString.Content,
718 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
719 mInstructionContentOffset,
720 L"0x%02x",
721 (UINTN)Data8
722 );
723 mInstructionContentOffset += 4;
724
725 return mInstructionContentOffset;
726 }
727
728 /**
729
730 Print the hexical WORD to instruction content.
731
732 @param Data16 - WORD data
733
734 @return Instruction content offset
735
736 **/
737 UINTN
738 EdbPrintData16 (
739 IN UINT16 Data16
740 )
741 {
742 EDBSPrintWithOffset (
743 mInstructionString.Content,
744 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
745 mInstructionContentOffset,
746 L"0x%04x",
747 (UINTN)Data16
748 );
749 mInstructionContentOffset += 6;
750
751 return mInstructionContentOffset;
752 }
753
754 /**
755
756 Print the hexical DWORD to instruction content.
757
758 @param Data32 - DWORD data
759
760 @return Instruction content offset
761
762 **/
763 UINTN
764 EdbPrintData32 (
765 IN UINT32 Data32
766 )
767 {
768 EDBSPrintWithOffset (
769 mInstructionString.Content,
770 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
771 mInstructionContentOffset,
772 L"0x%08x",
773 (UINTN)Data32
774 );
775 mInstructionContentOffset += 10;
776
777 return mInstructionContentOffset;
778 }
779
780 /**
781
782 Print the hexical QWORD to instruction content.
783
784 @param Data64 - QWORD data
785
786 @return Instruction content offset
787
788 **/
789 UINTN
790 EdbPrintData64 (
791 IN UINT64 Data64
792 )
793 {
794 EDBSPrintWithOffset (
795 mInstructionString.Content,
796 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
797 mInstructionContentOffset,
798 L"0x%016lx",
799 (UINT64)Data64
800 );
801 mInstructionContentOffset += 18;
802
803 return mInstructionContentOffset;
804 }
805
806 /**
807
808 Print the decimal unsigned UINTN to instruction content.
809
810 @param Data - unsigned UINTN data
811
812 @return Instruction content offset
813
814 **/
815 UINTN
816 EdbPrintDatan (
817 IN UINTN Data
818 )
819 {
820 EDBSPrintWithOffset (
821 mInstructionString.Content,
822 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
823 mInstructionContentOffset,
824 L"%d",
825 (UINTN)Data
826 );
827 mInstructionContentOffset = mInstructionContentOffset + EdbGetBitWidth (Data);
828
829 return mInstructionContentOffset;
830 }
831
832 /**
833
834 Print the decimal unsigned QWORD to instruction content.
835
836 @param Data64 - unsigned QWORD data
837
838 @return Instruction content offset
839
840 **/
841 UINTN
842 EdbPrintData64n (
843 IN UINT64 Data64
844 )
845 {
846 EDBSPrintWithOffset (
847 mInstructionString.Content,
848 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
849 mInstructionContentOffset,
850 L"%ld",
851 Data64
852 );
853 mInstructionContentOffset = mInstructionContentOffset + EdbGetBitWidth (Data64);
854
855 return mInstructionContentOffset;
856 }
857
858 /**
859
860 Print the decimal signed BYTE to instruction content.
861
862 @param Data8 - signed BYTE data
863
864 @return Instruction content offset
865
866 **/
867 UINTN
868 EdbPrintData8s (
869 IN UINT8 Data8
870 )
871 {
872 BOOLEAN Sign;
873
874 Sign = (BOOLEAN)(Data8 >> 7);
875
876 EDBSPrintWithOffset (
877 mInstructionString.Content,
878 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
879 mInstructionContentOffset,
880 L"%s%d",
881 Sign ? L"-" : L"+",
882 (UINTN)(Data8 & 0x7F)
883 );
884 mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data8 & 0x7F);
885
886 return mInstructionContentOffset;
887 }
888
889 /**
890
891 Print the decimal signed WORD to instruction content.
892
893 @param Data16 - signed WORD data
894
895 @return Instruction content offset
896
897 **/
898 UINTN
899 EdbPrintData16s (
900 IN UINT16 Data16
901 )
902 {
903 BOOLEAN Sign;
904
905 Sign = (BOOLEAN)(Data16 >> 15);
906
907 EDBSPrintWithOffset (
908 mInstructionString.Content,
909 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
910 mInstructionContentOffset,
911 L"%s%d",
912 Sign ? L"-" : L"+",
913 (UINTN)(Data16 & 0x7FFF)
914 );
915 mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data16 & 0x7FFF);
916
917 return mInstructionContentOffset;
918 }
919
920 /**
921
922 Print the decimal signed DWORD to instruction content.
923
924 @param Data32 - signed DWORD data
925
926 @return Instruction content offset
927
928 **/
929 UINTN
930 EdbPrintData32s (
931 IN UINT32 Data32
932 )
933 {
934 BOOLEAN Sign;
935
936 Sign = (BOOLEAN)(Data32 >> 31);
937
938 EDBSPrintWithOffset (
939 mInstructionString.Content,
940 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
941 mInstructionContentOffset,
942 L"%s%d",
943 Sign ? L"-" : L"+",
944 (UINTN)(Data32 & 0x7FFFFFFF)
945 );
946 mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data32 & 0x7FFFFFFF);
947
948 return mInstructionContentOffset;
949 }
950
951 /**
952
953 Print the decimal signed QWORD to instruction content.
954
955 @param Data64 - signed QWORD data
956
957 @return Instruction content offset
958
959 **/
960 UINTN
961 EdbPrintData64s (
962 IN UINT64 Data64
963 )
964 {
965 BOOLEAN Sign;
966 INT64 Data64s;
967
968 Sign = (BOOLEAN)RShiftU64 (Data64, 63);
969 Data64s = (INT64)RShiftU64 (LShiftU64 (Data64, 1), 1);
970
971 EDBSPrintWithOffset (
972 mInstructionString.Content,
973 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
974 mInstructionContentOffset,
975 L"%s%ld",
976 Sign ? L"-" : L"+",
977 (UINT64)Data64s
978 );
979 mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data64s);
980
981 return mInstructionContentOffset;
982 }
983
984 /**
985
986 Print the comma to instruction content.
987
988 @return Instruction content offset
989
990 **/
991 UINTN
992 EdbPrintComma (
993 VOID
994 )
995 {
996 EDBSPrintWithOffset (
997 mInstructionString.Content,
998 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
999 mInstructionContentOffset,
1000 L", "
1001 );
1002 mInstructionContentOffset += 2;
1003
1004 return mInstructionContentOffset;
1005 }
1006
1007 /**
1008
1009 Find the symbol string according to address, then print it.
1010
1011 @param Address - instruction address
1012
1013 @retval 1 - symbol string is found and printed
1014 @retval 0 - symbol string not found
1015
1016 **/
1017 UINTN
1018 EdbFindAndPrintSymbol (
1019 IN UINTN Address
1020 )
1021 {
1022 CHAR8 *SymbolStr;
1023
1024 SymbolStr = FindSymbolStr (Address);
1025 if (SymbolStr != NULL) {
1026 EDBSPrintWithOffset (
1027 mInstructionString.Content,
1028 EDB_INSTRUCTION_CONTENT_MAX_SIZE,
1029 mInstructionContentOffset,
1030 L"[%a]",
1031 SymbolStr
1032 );
1033 return 1;
1034 }
1035
1036 return 0;
1037 }
1038
1039 /**
1040
1041 Print the EBC byte code.
1042
1043 @param InstructionAddress - instruction address
1044 @param InstructionNumber - instruction number
1045
1046 **/
1047 VOID
1048 EdbPrintRaw (
1049 IN EFI_PHYSICAL_ADDRESS InstructionAddress,
1050 IN UINTN InstructionNumber
1051 )
1052 {
1053 UINTN LineNumber;
1054 UINTN ByteNumber;
1055 UINTN LineIndex;
1056 UINTN ByteIndex;
1057 CHAR8 *SymbolStr;
1058
1059 if (InstructionNumber == 0) {
1060 return ;
1061 }
1062
1063 LineNumber = InstructionNumber / EDB_BYTECODE_NUMBER_IN_LINE;
1064 ByteNumber = InstructionNumber % EDB_BYTECODE_NUMBER_IN_LINE;
1065 if (ByteNumber == 0) {
1066 LineNumber -= 1;
1067 ByteNumber = EDB_BYTECODE_NUMBER_IN_LINE;
1068 }
1069
1070 //
1071 // Print Symbol
1072 //
1073 SymbolStr = FindSymbolStr ((UINTN)InstructionAddress);
1074 if (SymbolStr != NULL) {
1075 EDBPrint (L"[%a]:\n", SymbolStr);
1076 }
1077
1078 for (LineIndex = 0; LineIndex < LineNumber; LineIndex++) {
1079 EDBPrint (EDB_PRINT_ADDRESS_FORMAT, (UINTN)InstructionAddress);
1080 for (ByteIndex = 0; ByteIndex < EDB_BYTECODE_NUMBER_IN_LINE; ByteIndex++) {
1081 EDBPrint (L"%02x ", *(UINT8 *)(UINTN)InstructionAddress);
1082 InstructionAddress += 1;
1083 }
1084 EDBPrint (L"\n");
1085 }
1086
1087 EDBPrint (EDB_PRINT_ADDRESS_FORMAT, (UINTN)InstructionAddress);
1088 for (ByteIndex = 0; ByteIndex < ByteNumber; ByteIndex++) {
1089 EDBPrint (L"%02x ", *(UINT8 *)(UINTN)InstructionAddress);
1090 InstructionAddress += 1;
1091 }
1092 for (ByteIndex = 0; ByteIndex < EDB_BYTECODE_NUMBER_IN_LINE - ByteNumber; ByteIndex++) {
1093 EDBPrint (L" ");
1094 }
1095
1096 return ;
1097 }
1098
1099 /**
1100
1101 Print the EBC asm code.
1102
1103 @param DebuggerPrivate - EBC Debugger private data structure
1104 @param SystemContext - EBC system context.
1105
1106 @retval EFI_SUCCESS - show disasm successfully
1107
1108 **/
1109 EFI_STATUS
1110 EdbShowDisasm (
1111 IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate,
1112 IN EFI_SYSTEM_CONTEXT SystemContext
1113 )
1114 {
1115 EFI_PHYSICAL_ADDRESS InstructionAddress;
1116 UINTN InstructionNumber;
1117 UINTN InstructionLength;
1118 UINT8 Opcode;
1119 CHAR16 *InstructionString;
1120 // UINTN Result;
1121
1122 InstructionAddress = DebuggerPrivate->InstructionScope;
1123 for (InstructionNumber = 0; InstructionNumber < DebuggerPrivate->InstructionNumber; InstructionNumber++) {
1124
1125 //
1126 // Break each 0x10 instruction
1127 //
1128 if (((InstructionNumber % EFI_DEBUGGER_LINE_NUMBER_IN_PAGE) == 0) &&
1129 (InstructionNumber != 0)) {
1130 if (SetPageBreak ()) {
1131 break;
1132 }
1133 }
1134
1135 Opcode = GET_OPCODE(InstructionAddress);
1136 if ((Opcode < OPCODE_MAX) && (mEdbDisasmInstructionTable[Opcode] != NULL)) {
1137 InstructionLength = mEdbDisasmInstructionTable [Opcode] (InstructionAddress, SystemContext, &InstructionString);
1138 if (InstructionLength != 0) {
1139
1140 //
1141 // Print Source
1142 //
1143 // Result = EdbPrintSource ((UINTN)InstructionAddress, FALSE);
1144
1145 if (!DebuggerPrivate->DebuggerSymbolContext.DisplayCodeOnly) {
1146
1147 EdbPrintRaw (InstructionAddress, InstructionLength);
1148 if (InstructionString != NULL) {
1149 EDBPrint (L"%s\n", InstructionString);
1150 } else {
1151 EDBPrint (L"%s\n", L"<Unknown Instruction>");
1152 }
1153 }
1154
1155 EdbPrintSource ((UINTN)InstructionAddress, TRUE);
1156
1157 InstructionAddress += InstructionLength;
1158 } else {
1159 //
1160 // Something wrong with OPCODE
1161 //
1162 EdbPrintRaw (InstructionAddress, EDB_BYTECODE_NUMBER_IN_LINE);
1163 EDBPrint (L"%s\n", L"<Bad Instruction>");
1164 break;
1165 }
1166 } else {
1167 //
1168 // Something wrong with OPCODE
1169 //
1170 EdbPrintRaw (InstructionAddress, EDB_BYTECODE_NUMBER_IN_LINE);
1171 EDBPrint (L"%s\n", L"<Bad Instruction>");
1172 break;
1173 }
1174 }
1175
1176 return EFI_SUCCESS;
1177 }
1178
1179 /**
1180
1181 Get register value according to the system context, and register index.
1182
1183 @param SystemContext - EBC system context.
1184 @param Index - EBC register index
1185
1186 @return register value
1187
1188 **/
1189 UINT64
1190 GetRegisterValue (
1191 IN EFI_SYSTEM_CONTEXT SystemContext,
1192 IN UINT8 Index
1193 )
1194 {
1195 switch (Index) {
1196 case 0:
1197 return SystemContext.SystemContextEbc->R0;
1198 case 1:
1199 return SystemContext.SystemContextEbc->R1;
1200 case 2:
1201 return SystemContext.SystemContextEbc->R2;
1202 case 3:
1203 return SystemContext.SystemContextEbc->R3;
1204 case 4:
1205 return SystemContext.SystemContextEbc->R4;
1206 case 5:
1207 return SystemContext.SystemContextEbc->R5;
1208 case 6:
1209 return SystemContext.SystemContextEbc->R6;
1210 case 7:
1211 return SystemContext.SystemContextEbc->R7;
1212 default:
1213 ASSERT (FALSE);
1214 break;
1215 }
1216 return 0;
1217 }