MdeModulePkg/Universal/EbcDxe/EbcDebugger/EdbDisasmSupport.c

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