VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (23 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156854
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Universal/EbcDxe/EbcExecute.c

    r80721 r99404  
    1010#include "EbcExecute.h"
    1111#include "EbcDebuggerHook.h"
    12 
    1312
    1413//
    … …  
    1615// size of operands or data.
    1716//
    18 #define DATA_SIZE_INVALID 0
    19 #define DATA_SIZE_8       1
    20 #define DATA_SIZE_16      2
    21 #define DATA_SIZE_32      4
    22 #define DATA_SIZE_64      8
    23 #define DATA_SIZE_N       48 // 4 or 8
     17#define DATA_SIZE_INVALID  0
     18#define DATA_SIZE_8        1
     19#define DATA_SIZE_16       2
     20#define DATA_SIZE_32       4
     21#define DATA_SIZE_64       8
     22#define DATA_SIZE_N        48 // 4 or 8
    2423//
    2524// Structure we'll use to dispatch opcodes to execute functions.
    2625//
    2726typedef struct {
    28   EFI_STATUS (*ExecuteFunction) (IN VM_CONTEXT * VmPtr);
    29 }
    30 VM_TABLE_ENTRY;
     27  EFI_STATUS (*ExecuteFunction)(
     28    IN VM_CONTEXT  *VmPtr
     29    );
     30} VM_TABLE_ENTRY;
    3131
    3232typedef
    3333UINT64
    3434(*DATA_MANIP_EXEC_FUNCTION) (
    35   IN VM_CONTEXT * VmPtr,
    36   IN UINT64     Op1,
    37   IN UINT64     Op2
     35  IN VM_CONTEXT  *VmPtr,
     36  IN UINT64      Op1,
     37  IN UINT64      Op2
    3838  );
    3939
    … …  
    6262INT16
    6363VmReadIndex16 (
    64   IN VM_CONTEXT     *VmPtr,
    65   IN UINT32         CodeOffset
     64  IN VM_CONTEXT  *VmPtr,
     65  IN UINT32      CodeOffset
    6666  );
    6767
    … …  
    7878INT32
    7979VmReadIndex32 (
    80   IN VM_CONTEXT     *VmPtr,
    81   IN UINT32         CodeOffset
     80  IN VM_CONTEXT  *VmPtr,
     81  IN UINT32      CodeOffset
    8282  );
    8383
    … …  
    9494INT64
    9595VmReadIndex64 (
    96   IN VM_CONTEXT     *VmPtr,
    97   IN UINT32         CodeOffset
     96  IN VM_CONTEXT  *VmPtr,
     97  IN UINT32      CodeOffset
    9898  );
    9999
    … …  
    109109UINT8
    110110VmReadMem8 (
    111   IN VM_CONTEXT   *VmPtr,
    112   IN UINTN        Addr
     111  IN VM_CONTEXT  *VmPtr,
     112  IN UINTN       Addr
    113113  );
    114114
    … …  
    124124UINT16
    125125VmReadMem16 (
    126   IN VM_CONTEXT *VmPtr,
    127   IN UINTN      Addr
     126  IN VM_CONTEXT  *VmPtr,
     127  IN UINTN       Addr
    128128  );
    129129
    … …  
    139139UINT32
    140140VmReadMem32 (
    141   IN VM_CONTEXT *VmPtr,
    142   IN UINTN      Addr
     141  IN VM_CONTEXT  *VmPtr,
     142  IN UINTN       Addr
    143143  );
    144144
    … …  
    154154UINT64
    155155VmReadMem64 (
    156   IN VM_CONTEXT   *VmPtr,
    157   IN UINTN        Addr
     156  IN VM_CONTEXT  *VmPtr,
     157  IN UINTN       Addr
    158158  );
    159159
    … …  
    169169UINTN
    170170VmReadMemN (
    171   IN VM_CONTEXT    *VmPtr,
    172   IN UINTN         Addr
     171  IN VM_CONTEXT  *VmPtr,
     172  IN UINTN       Addr
    173173  );
    174174
    … …  
    198198EFI_STATUS
    199199VmWriteMem8 (
    200   IN VM_CONTEXT    *VmPtr,
    201   IN UINTN         Addr,
    202   IN UINT8         Data
     200  IN VM_CONTEXT  *VmPtr,
     201  IN UINTN       Addr,
     202  IN UINT8       Data
    203203  );
    204204
    … …  
    228228EFI_STATUS
    229229VmWriteMem16 (
    230   IN VM_CONTEXT   *VmPtr,
    231   IN UINTN        Addr,
    232   IN UINT16       Data
     230  IN VM_CONTEXT  *VmPtr,
     231  IN UINTN       Addr,
     232  IN UINT16      Data
    233233  );
    234234
    … …  
    258258EFI_STATUS
    259259VmWriteMem32 (
    260   IN VM_CONTEXT   *VmPtr,
    261   IN UINTN        Addr,
    262   IN UINT32       Data
     260  IN VM_CONTEXT  *VmPtr,
     261  IN UINTN       Addr,
     262  IN UINT32      Data
    263263  );
    264264
    … …  
    277277UINT16
    278278VmReadCode16 (
    279   IN VM_CONTEXT *VmPtr,
    280   IN UINT32     Offset
     279  IN VM_CONTEXT  *VmPtr,
     280  IN UINT32      Offset
    281281  );
    282282
    … …  
    295295UINT32
    296296VmReadCode32 (
    297   IN VM_CONTEXT *VmPtr,
    298   IN UINT32     Offset
     297  IN VM_CONTEXT  *VmPtr,
     298  IN UINT32      Offset
    299299  );
    300300
    … …  
    313313UINT64
    314314VmReadCode64 (
    315   IN VM_CONTEXT *VmPtr,
    316   IN UINT32     Offset
     315  IN VM_CONTEXT  *VmPtr,
     316  IN UINT32      Offset
    317317  );
    318318
    … …  
    333333INT8
    334334VmReadImmed8 (
    335   IN VM_CONTEXT *VmPtr,
    336   IN UINT32     Offset
     335  IN VM_CONTEXT  *VmPtr,
     336  IN UINT32      Offset
    337337  );
    338338
    … …  
    353353INT16
    354354VmReadImmed16 (
    355   IN VM_CONTEXT *VmPtr,
    356   IN UINT32     Offset
     355  IN VM_CONTEXT  *VmPtr,
     356  IN UINT32      Offset
    357357  );
    358358
    … …  
    373373INT32
    374374VmReadImmed32 (
    375   IN VM_CONTEXT *VmPtr,
    376   IN UINT32     Offset
     375  IN VM_CONTEXT  *VmPtr,
     376  IN UINT32      Offset
    377377  );
    378378
    … …  
    393393INT64
    394394VmReadImmed64 (
    395   IN VM_CONTEXT *VmPtr,
    396   IN UINT32     Offset
     395  IN VM_CONTEXT  *VmPtr,
     396  IN UINT32      Offset
    397397  );
    398398
    … …  
    418418UINTN
    419419ConvertStackAddr (
    420   IN VM_CONTEXT    *VmPtr,
    421   IN UINTN         Addr
     420  IN VM_CONTEXT  *VmPtr,
     421  IN UINTN       Addr
    422422  );
    423423
    … …  
    442442EFI_STATUS
    443443ExecuteDataManip (
    444   IN VM_CONTEXT   *VmPtr,
    445   IN BOOLEAN      IsSignedOp
     444  IN VM_CONTEXT  *VmPtr,
     445  IN BOOLEAN     IsSignedOp
    446446  );
    447447
    … …  
    449449// Functions that execute VM opcodes
    450450//
     451
    451452/**
    452453  Execute the EBC BREAK instruction.
    … …  
    459460EFI_STATUS
    460461ExecuteBREAK (
    461   IN VM_CONTEXT *VmPtr
     462  IN VM_CONTEXT  *VmPtr
    462463  );
    463464
    … …  
    489490EFI_STATUS
    490491ExecuteJMP (
    491   IN VM_CONTEXT *VmPtr
     492  IN VM_CONTEXT  *VmPtr
    492493  );
    493494
    … …  
    505506EFI_STATUS
    506507ExecuteJMP8 (
    507   IN VM_CONTEXT *VmPtr
     508  IN VM_CONTEXT  *VmPtr
    508509  );
    509510
    … …  
    526527EFI_STATUS
    527528ExecuteCALL (
    528   IN VM_CONTEXT *VmPtr
     529  IN VM_CONTEXT  *VmPtr
    529530  );
    530531
    … …  
    542543EFI_STATUS
    543544ExecuteRET (
    544   IN VM_CONTEXT *VmPtr
     545  IN VM_CONTEXT  *VmPtr
    545546  );
    546547
    … …  
    559560EFI_STATUS
    560561ExecuteCMP (
    561   IN VM_CONTEXT *VmPtr
     562  IN VM_CONTEXT  *VmPtr
    562563  );
    563564
    … …  
    576577EFI_STATUS
    577578ExecuteCMPI (
    578   IN VM_CONTEXT *VmPtr
     579  IN VM_CONTEXT  *VmPtr
    579580  );
    580581
    … …  
    602603EFI_STATUS
    603604ExecuteMOVxx (
    604   IN VM_CONTEXT *VmPtr
     605  IN VM_CONTEXT  *VmPtr
    605606  );
    606607
    … …  
    628629EFI_STATUS
    629630ExecuteMOVI (
    630   IN VM_CONTEXT *VmPtr
     631  IN VM_CONTEXT  *VmPtr
    631632  );
    632633
    … …  
    647648EFI_STATUS
    648649ExecuteMOVIn (
    649   IN VM_CONTEXT *VmPtr
     650  IN VM_CONTEXT  *VmPtr
    650651  );
    651652
    … …  
    666667EFI_STATUS
    667668ExecuteMOVREL (
    668   IN VM_CONTEXT *VmPtr
     669  IN VM_CONTEXT  *VmPtr
    669670  );
    670671
    … …  
    682683EFI_STATUS
    683684ExecutePUSHn (
    684   IN VM_CONTEXT *VmPtr
     685  IN VM_CONTEXT  *VmPtr
    685686  );
    686687
    … …  
    698699EFI_STATUS
    699700ExecutePUSH (
    700   IN VM_CONTEXT *VmPtr
     701  IN VM_CONTEXT  *VmPtr
    701702  );
    702703
    … …  
    714715EFI_STATUS
    715716ExecutePOPn (
    716   IN VM_CONTEXT *VmPtr
     717  IN VM_CONTEXT  *VmPtr
    717718  );
    718719
    … …  
    730731EFI_STATUS
    731732ExecutePOP (
    732   IN VM_CONTEXT *VmPtr
     733  IN VM_CONTEXT  *VmPtr
    733734  );
    734735
    … …  
    752753EFI_STATUS
    753754ExecuteSignedDataManip (
    754   IN VM_CONTEXT   *VmPtr
     755  IN VM_CONTEXT  *VmPtr
    755756  );
    756757
    … …  
    774775EFI_STATUS
    775776ExecuteUnsignedDataManip (
    776   IN VM_CONTEXT   *VmPtr
     777  IN VM_CONTEXT  *VmPtr
    777778  );
    778779
    … …  
    791792EFI_STATUS
    792793ExecuteLOADSP (
    793   IN VM_CONTEXT *VmPtr
     794  IN VM_CONTEXT  *VmPtr
    794795  );
    795796
    … …  
    808809EFI_STATUS
    809810ExecuteSTORESP (
    810   IN VM_CONTEXT *VmPtr
     811  IN VM_CONTEXT  *VmPtr
    811812  );
    812813
    … …  
    832833EFI_STATUS
    833834ExecuteMOVsnd (
    834   IN VM_CONTEXT *VmPtr
     835  IN VM_CONTEXT  *VmPtr
    835836  );
    836837
    … …  
    856857EFI_STATUS
    857858ExecuteMOVsnw (
    858   IN VM_CONTEXT *VmPtr
     859  IN VM_CONTEXT  *VmPtr
    859860  );
    860861
    … …  
    862863// Data manipulation subfunctions
    863864//
     865
    864866/**
    865867  Execute the EBC NOT instruction.s
    … …  
    877879UINT64
    878880ExecuteNOT (
    879   IN VM_CONTEXT     *VmPtr,
    880   IN UINT64         Op1,
    881   IN UINT64         Op2
     881  IN VM_CONTEXT  *VmPtr,
     882  IN UINT64      Op1,
     883  IN UINT64      Op2
    882884  );
    883885
    … …  
    897899UINT64
    898900ExecuteNEG (
    899   IN VM_CONTEXT   *VmPtr,
    900   IN UINT64       Op1,
    901   IN UINT64       Op2
     901  IN VM_CONTEXT  *VmPtr,
     902  IN UINT64      Op1,
     903  IN UINT64      Op2
    902904  );
    903905
    … …  
    917919UINT64
    918920ExecuteADD (
    919   IN VM_CONTEXT   *VmPtr,
    920   IN UINT64       Op1,
    921   IN UINT64       Op2
     921  IN VM_CONTEXT  *VmPtr,
     922  IN UINT64      Op1,
     923  IN UINT64      Op2
    922924  );
    923925
    … …  
    937939UINT64
    938940ExecuteSUB (
    939   IN VM_CONTEXT   *VmPtr,
    940   IN UINT64       Op1,
    941   IN UINT64       Op2
     941  IN VM_CONTEXT  *VmPtr,
     942  IN UINT64      Op1,
     943  IN UINT64      Op2
    942944  );
    943945
    … …  
    957959UINT64
    958960ExecuteMUL (
    959   IN VM_CONTEXT   *VmPtr,
    960   IN UINT64       Op1,
    961   IN UINT64       Op2
     961  IN VM_CONTEXT  *VmPtr,
     962  IN UINT64      Op1,
     963  IN UINT64      Op2
    962964  );
    963965
    … …  
    977979UINT64
    978980ExecuteMULU (
    979   IN VM_CONTEXT   *VmPtr,
    980   IN UINT64       Op1,
    981   IN UINT64       Op2
     981  IN VM_CONTEXT  *VmPtr,
     982  IN UINT64      Op1,
     983  IN UINT64      Op2
    982984  );
    983985
    … …  
    997999UINT64
    9981000ExecuteDIV (
    999   IN VM_CONTEXT   *VmPtr,
    1000   IN UINT64       Op1,
    1001   IN UINT64       Op2
     1001  IN VM_CONTEXT  *VmPtr,
     1002  IN UINT64      Op1,
     1003  IN UINT64      Op2
    10021004  );
    10031005
    … …  
    10171019UINT64
    10181020ExecuteDIVU (
    1019   IN VM_CONTEXT   *VmPtr,
    1020   IN UINT64       Op1,
    1021   IN UINT64       Op2
     1021  IN VM_CONTEXT  *VmPtr,
     1022  IN UINT64      Op1,
     1023  IN UINT64      Op2
    10221024  );
    10231025
    … …  
    10371039UINT64
    10381040ExecuteMOD (
    1039   IN VM_CONTEXT   *VmPtr,
    1040   IN UINT64       Op1,
    1041   IN UINT64       Op2
     1041  IN VM_CONTEXT  *VmPtr,
     1042  IN UINT64      Op1,
     1043  IN UINT64      Op2
    10421044  );
    10431045
    … …  
    10571059UINT64
    10581060ExecuteMODU (
    1059   IN VM_CONTEXT   *VmPtr,
    1060   IN UINT64       Op1,
    1061   IN UINT64       Op2
     1061  IN VM_CONTEXT  *VmPtr,
     1062  IN UINT64      Op1,
     1063  IN UINT64      Op2
    10621064  );
    10631065
    … …  
    10771079UINT64
    10781080ExecuteAND (
    1079   IN VM_CONTEXT   *VmPtr,
    1080   IN UINT64       Op1,
    1081   IN UINT64       Op2
     1081  IN VM_CONTEXT  *VmPtr,
     1082  IN UINT64      Op1,
     1083  IN UINT64      Op2
    10821084  );
    10831085
    … …  
    10971099UINT64
    10981100ExecuteOR (
    1099   IN VM_CONTEXT   *VmPtr,
    1100   IN UINT64       Op1,
    1101   IN UINT64       Op2
     1101  IN VM_CONTEXT  *VmPtr,
     1102  IN UINT64      Op1,
     1103  IN UINT64      Op2
    11021104  );
    11031105
    … …  
    11171119UINT64
    11181120ExecuteXOR (
    1119   IN VM_CONTEXT   *VmPtr,
    1120   IN UINT64       Op1,
    1121   IN UINT64       Op2
     1121  IN VM_CONTEXT  *VmPtr,
     1122  IN UINT64      Op1,
     1123  IN UINT64      Op2
    11221124  );
    11231125
    … …  
    11371139UINT64
    11381140ExecuteSHL (
    1139   IN VM_CONTEXT   *VmPtr,
    1140   IN UINT64       Op1,
    1141   IN UINT64       Op2
     1141  IN VM_CONTEXT  *VmPtr,
     1142  IN UINT64      Op1,
     1143  IN UINT64      Op2
    11421144  );
    11431145
    … …  
    11571159UINT64
    11581160ExecuteSHR (
    1159   IN VM_CONTEXT   *VmPtr,
    1160   IN UINT64       Op1,
    1161   IN UINT64       Op2
     1161  IN VM_CONTEXT  *VmPtr,
     1162  IN UINT64      Op1,
     1163  IN UINT64      Op2
    11621164  );
    11631165
    … …  
    11771179UINT64
    11781180ExecuteASHR (
    1179   IN VM_CONTEXT   *VmPtr,
    1180   IN UINT64       Op1,
    1181   IN UINT64       Op2
     1181  IN VM_CONTEXT  *VmPtr,
     1182  IN UINT64      Op1,
     1183  IN UINT64      Op2
    11821184  );
    11831185
    … …  
    11971199UINT64
    11981200ExecuteEXTNDB (
    1199   IN VM_CONTEXT   *VmPtr,
    1200   IN UINT64       Op1,
    1201   IN UINT64       Op2
     1201  IN VM_CONTEXT  *VmPtr,
     1202  IN UINT64      Op1,
     1203  IN UINT64      Op2
    12021204  );
    12031205
    … …  
    12171219UINT64
    12181220ExecuteEXTNDW (
    1219   IN VM_CONTEXT   *VmPtr,
    1220   IN UINT64       Op1,
    1221   IN UINT64       Op2
     1221  IN VM_CONTEXT  *VmPtr,
     1222  IN UINT64      Op1,
     1223  IN UINT64      Op2
    12221224  );
    12231225
    … …  
    12371239UINT64
    12381240ExecuteEXTNDD (
    1239   IN VM_CONTEXT   *VmPtr,
    1240   IN UINT64       Op1,
    1241   IN UINT64       Op2
     1241  IN VM_CONTEXT  *VmPtr,
     1242  IN UINT64      Op1,
     1243  IN UINT64      Op2
    12421244  );
    12431245
    … …  
    12461248// call these functions to perform the operation.
    12471249//
    1248 CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {
     1250CONST DATA_MANIP_EXEC_FUNCTION  mDataManipDispatchTable[] = {
    12491251  ExecuteNOT,
    12501252  ExecuteNEG,
    … …  
    12681270};
    12691271
    1270 CONST VM_TABLE_ENTRY           mVmOpcodeTable[] = {
    1271   { ExecuteBREAK },            // opcode 0x00
    1272   { ExecuteJMP },              // opcode 0x01
    1273   { ExecuteJMP8 },              // opcode 0x02
    1274   { ExecuteCALL },              // opcode 0x03
    1275   { ExecuteRET },              // opcode 0x04
    1276   { ExecuteCMP },              // opcode 0x05 CMPeq
    1277   { ExecuteCMP },              // opcode 0x06 CMPlte
    1278   { ExecuteCMP },              // opcode 0x07 CMPgte
    1279   { ExecuteCMP },              // opcode 0x08 CMPulte
    1280   { ExecuteCMP },              // opcode 0x09 CMPugte
     1272CONST VM_TABLE_ENTRY  mVmOpcodeTable[] = {
     1273  { ExecuteBREAK             }, // opcode 0x00
     1274  { ExecuteJMP               }, // opcode 0x01
     1275  { ExecuteJMP8              }, // opcode 0x02
     1276  { ExecuteCALL              }, // opcode 0x03
     1277  { ExecuteRET               }, // opcode 0x04
     1278  { ExecuteCMP               }, // opcode 0x05 CMPeq
     1279  { ExecuteCMP               }, // opcode 0x06 CMPlte
     1280  { ExecuteCMP               }, // opcode 0x07 CMPgte
     1281  { ExecuteCMP               }, // opcode 0x08 CMPulte
     1282  { ExecuteCMP               }, // opcode 0x09 CMPugte
    12811283  { ExecuteUnsignedDataManip }, // opcode 0x0A NOT
    1282   { ExecuteSignedDataManip },  // opcode 0x0B NEG
    1283   { ExecuteSignedDataManip },  // opcode 0x0C ADD
    1284   { ExecuteSignedDataManip },  // opcode 0x0D SUB
    1285   { ExecuteSignedDataManip },  // opcode 0x0E MUL
     1284  { ExecuteSignedDataManip   }, // opcode 0x0B NEG
     1285  { ExecuteSignedDataManip   }, // opcode 0x0C ADD
     1286  { ExecuteSignedDataManip   }, // opcode 0x0D SUB
     1287  { ExecuteSignedDataManip   }, // opcode 0x0E MUL
    12861288  { ExecuteUnsignedDataManip }, // opcode 0x0F MULU
    1287   { ExecuteSignedDataManip },  // opcode 0x10 DIV
     1289  { ExecuteSignedDataManip   }, // opcode 0x10 DIV
    12881290  { ExecuteUnsignedDataManip }, // opcode 0x11 DIVU
    1289   { ExecuteSignedDataManip },  // opcode 0x12 MOD
     1291  { ExecuteSignedDataManip   }, // opcode 0x12 MOD
    12901292  { ExecuteUnsignedDataManip }, // opcode 0x13 MODU
    12911293  { ExecuteUnsignedDataManip }, // opcode 0x14 AND
    … …  
    12941296  { ExecuteUnsignedDataManip }, // opcode 0x17 SHL
    12951297  { ExecuteUnsignedDataManip }, // opcode 0x18 SHR
    1296   { ExecuteSignedDataManip },  // opcode 0x19 ASHR
     1298  { ExecuteSignedDataManip   }, // opcode 0x19 ASHR
    12971299  { ExecuteUnsignedDataManip }, // opcode 0x1A EXTNDB
    12981300  { ExecuteUnsignedDataManip }, // opcode 0x1B EXTNDW
    12991301  { ExecuteUnsignedDataManip }, // opcode 0x1C EXTNDD
    1300   { ExecuteMOVxx },            // opcode 0x1D MOVBW
    1301   { ExecuteMOVxx },            // opcode 0x1E MOVWW
    1302   { ExecuteMOVxx },            // opcode 0x1F MOVDW
    1303   { ExecuteMOVxx },            // opcode 0x20 MOVQW
    1304   { ExecuteMOVxx },            // opcode 0x21 MOVBD
    1305   { ExecuteMOVxx },            // opcode 0x22 MOVWD
    1306   { ExecuteMOVxx },            // opcode 0x23 MOVDD
    1307   { ExecuteMOVxx },            // opcode 0x24 MOVQD
    1308   { ExecuteMOVsnw },            // opcode 0x25 MOVsnw
    1309   { ExecuteMOVsnd },            // opcode 0x26 MOVsnd
    1310   { NULL },                    // opcode 0x27
    1311   { ExecuteMOVxx },            // opcode 0x28 MOVqq
    1312   { ExecuteLOADSP },            // opcode 0x29 LOADSP SP1, R2
    1313   { ExecuteSTORESP },          // opcode 0x2A STORESP R1, SP2
    1314   { ExecutePUSH },              // opcode 0x2B PUSH {@}R1 [imm16]
    1315   { ExecutePOP },              // opcode 0x2C POP {@}R1 [imm16]
    1316   { ExecuteCMPI },              // opcode 0x2D CMPIEQ
    1317   { ExecuteCMPI },              // opcode 0x2E CMPILTE
    1318   { ExecuteCMPI },              // opcode 0x2F CMPIGTE
    1319   { ExecuteCMPI },              // opcode 0x30 CMPIULTE
    1320   { ExecuteCMPI },              // opcode 0x31 CMPIUGTE
    1321   { ExecuteMOVxx },            // opcode 0x32 MOVN
    1322   { ExecuteMOVxx },            // opcode 0x33 MOVND
    1323   { NULL },                    // opcode 0x34
    1324   { ExecutePUSHn },            // opcode 0x35
    1325   { ExecutePOPn },              // opcode 0x36
    1326   { ExecuteMOVI },              // opcode 0x37 - mov immediate data
    1327   { ExecuteMOVIn },            // opcode 0x38 - mov immediate natural
    1328   { ExecuteMOVREL },            // opcode 0x39 - move data relative to PC
    1329   { NULL },                    // opcode 0x3a
    1330   { NULL },                    // opcode 0x3b
    1331   { NULL },                    // opcode 0x3c
    1332   { NULL },                    // opcode 0x3d
    1333   { NULL },                    // opcode 0x3e
    1334   { NULL }                      // opcode 0x3f
     1302  { ExecuteMOVxx             }, // opcode 0x1D MOVBW
     1303  { ExecuteMOVxx             }, // opcode 0x1E MOVWW
     1304  { ExecuteMOVxx             }, // opcode 0x1F MOVDW
     1305  { ExecuteMOVxx             }, // opcode 0x20 MOVQW
     1306  { ExecuteMOVxx             }, // opcode 0x21 MOVBD
     1307  { ExecuteMOVxx             }, // opcode 0x22 MOVWD
     1308  { ExecuteMOVxx             }, // opcode 0x23 MOVDD
     1309  { ExecuteMOVxx             }, // opcode 0x24 MOVQD
     1310  { ExecuteMOVsnw            }, // opcode 0x25 MOVsnw
     1311  { ExecuteMOVsnd            }, // opcode 0x26 MOVsnd
     1312  { NULL                     }, // opcode 0x27
     1313  { ExecuteMOVxx             }, // opcode 0x28 MOVqq
     1314  { ExecuteLOADSP            }, // opcode 0x29 LOADSP SP1, R2
     1315  { ExecuteSTORESP           }, // opcode 0x2A STORESP R1, SP2
     1316  { ExecutePUSH              }, // opcode 0x2B PUSH {@}R1 [imm16]
     1317  { ExecutePOP               }, // opcode 0x2C POP {@}R1 [imm16]
     1318  { ExecuteCMPI              }, // opcode 0x2D CMPIEQ
     1319  { ExecuteCMPI              }, // opcode 0x2E CMPILTE
     1320  { ExecuteCMPI              }, // opcode 0x2F CMPIGTE
     1321  { ExecuteCMPI              }, // opcode 0x30 CMPIULTE
     1322  { ExecuteCMPI              }, // opcode 0x31 CMPIUGTE
     1323  { ExecuteMOVxx             }, // opcode 0x32 MOVN
     1324  { ExecuteMOVxx             }, // opcode 0x33 MOVND
     1325  { NULL                     }, // opcode 0x34
     1326  { ExecutePUSHn             }, // opcode 0x35
     1327  { ExecutePOPn              }, // opcode 0x36
     1328  { ExecuteMOVI              }, // opcode 0x37 - mov immediate data
     1329  { ExecuteMOVIn             }, // opcode 0x38 - mov immediate natural
     1330  { ExecuteMOVREL            }, // opcode 0x39 - move data relative to PC
     1331  { NULL                     }, // opcode 0x3a
     1332  { NULL                     }, // opcode 0x3b
     1333  { NULL                     }, // opcode 0x3c
     1334  { NULL                     }, // opcode 0x3d
     1335  { NULL                     }, // opcode 0x3e
     1336  { NULL                     }  // opcode 0x3f
    13351337};
    13361338
    … …  
    13381340// Length of JMP instructions, depending on upper two bits of opcode.
    13391341//
    1340 CONST UINT8                    mJMPLen[] = { 2, 2, 6, 10 };
     1342CONST UINT8  mJMPLen[] = { 2, 2, 6, 10 };
    13411343
    13421344/**
    … …  
    13571359EFIAPI
    13581360EbcExecuteInstructions (
    1359   IN EFI_EBC_VM_TEST_PROTOCOL *This,
    1360   IN VM_CONTEXT               *VmPtr,
    1361   IN OUT UINTN                *InstructionCount
     1361  IN EFI_EBC_VM_TEST_PROTOCOL  *This,
     1362  IN VM_CONTEXT                *VmPtr,
     1363  IN OUT UINTN                 *InstructionCount
    13621364  )
    13631365{
    … …  
    13841386  //
    13851387  while (InstructionsLeft != 0) {
    1386     ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
    1387     if (ExecFunc == (UINTN) NULL) {
     1388    ExecFunc = (UINTN)mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
     1389    if (ExecFunc == (UINTN)NULL) {
    13881390      EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);
    13891391      return EFI_UNSUPPORTED;
    … …  
    14041406}
    14051407
    1406 
    14071408/**
    14081409  Execute an EBC image from an entry point or from a published protocol.
    … …  
    14161417EFI_STATUS
    14171418EbcExecute (
    1418   IN VM_CONTEXT *VmPtr
     1419  IN VM_CONTEXT  *VmPtr
    14191420  )
    14201421{
    … …  
    14321433  // Make sure the magic value has been put on the stack before we got here.
    14331434  //
    1434   if (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE) {
     1435  if (*VmPtr->StackMagicPtr != (UINTN)VM_STACK_KEY_VALUE) {
    14351436    StackCorrupted = 1;
    14361437  }
    14371438
    1438   VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->Gpr[0] + 8);
     1439  VmPtr->FramePtr = (VOID *)((UINT8 *)(UINTN)VmPtr->Gpr[0] + 8);
    14391440
    14401441  //
    … …  
    14421443  //
    14431444  DEBUG_CODE_BEGIN ();
    1444     Status = gBS->LocateProtocol (
    1445                     &gEfiEbcSimpleDebuggerProtocolGuid,
    1446                     NULL,
    1447                     (VOID **) &EbcSimpleDebugger
    1448                     );
    1449     if (EFI_ERROR (Status)) {
    1450       EbcSimpleDebugger = NULL;
    1451     }
     1445  Status = gBS->LocateProtocol (
     1446                  &gEfiEbcSimpleDebuggerProtocolGuid,
     1447                  NULL,
     1448                  (VOID **)&EbcSimpleDebugger
     1449                  );
     1450  if (EFI_ERROR (Status)) {
     1451    EbcSimpleDebugger = NULL;
     1452  }
     1453
    14521454  DEBUG_CODE_END ();
    14531455
    … …  
    14571459  // which could then be used in a disassembly listing to find the problem.
    14581460  //
    1459   VmPtr->EntryPoint = (VOID *) VmPtr->Ip;
     1461  VmPtr->EntryPoint = (VOID *)VmPtr->Ip;
    14601462
    14611463  //
    … …  
    14691471    //
    14701472    DEBUG_CODE_BEGIN ();
    1471       if (EbcSimpleDebugger != NULL) {
    1472         EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr);
    1473       }
     1473    if (EbcSimpleDebugger != NULL) {
     1474      EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr);
     1475    }
     1476
    14741477    DEBUG_CODE_END ();
    14751478
    … …  
    14781481    // function pointer is null then generate an exception.
    14791482    //
    1480     ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
    1481     if (ExecFunc == (UINTN) NULL) {
     1483    ExecFunc = (UINTN)mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
     1484    if (ExecFunc == (UINTN)NULL) {
    14821485      EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);
    14831486      Status = EFI_UNSUPPORTED;
    … …  
    15061509      EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr);
    15071510    }
     1511
    15081512    //
    15091513    // Make sure stack has not been corrupted. Only report it once though.
    15101514    //
    1511     if ((StackCorrupted == 0) && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) {
     1515    if ((StackCorrupted == 0) && (*VmPtr->StackMagicPtr != (UINTN)VM_STACK_KEY_VALUE)) {
    15121516      EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);
    15131517      StackCorrupted = 1;
    15141518    }
    1515     if ((StackCorrupted == 0) && ((UINT64)VmPtr->Gpr[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {
     1519
     1520    if ((StackCorrupted == 0) && ((UINT64)VmPtr->Gpr[0] <= (UINT64)(UINTN)VmPtr->StackTop)) {
    15161521      EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);
    15171522      StackCorrupted = 1;
    … …  
    15201525
    15211526Done:
    1522   mVmPtr          = NULL;
     1527  mVmPtr = NULL;
    15231528
    15241529  return Status;
    15251530}
    1526 
    15271531
    15281532/**
    … …  
    15491553EFI_STATUS
    15501554ExecuteMOVxx (
    1551   IN VM_CONTEXT *VmPtr
     1555  IN VM_CONTEXT  *VmPtr
    15521556  )
    15531557{
    … …  
    15661570
    15671571  Opcode    = GETOPCODE (VmPtr);
    1568   OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE);
     1572  OpcMasked = (UINT8)(Opcode & OPCODE_M_OPCODE);
    15691573
    15701574  //
    … …  
    15761580  // Assume no indexes
    15771581  //
    1578   Index64Op1  = 0;
    1579   Index64Op2  = 0;
    1580   Data64      = 0;
     1582  Index64Op1 = 0;
     1583  Index64Op2 = 0;
     1584  Data64     = 0;
    15811585
    15821586  //
    … …  
    15951599      //
    15961600      if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
    1597         Index16     = VmReadIndex16 (VmPtr, 2);
    1598         Index64Op1  = (INT64) Index16;
    1599         Size += sizeof (UINT16);
     1601        Index16    = VmReadIndex16 (VmPtr, 2);
     1602        Index64Op1 = (INT64)Index16;
     1603        Size      += sizeof (UINT16);
    16001604      }
    16011605
    16021606      if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
    1603         Index16     = VmReadIndex16 (VmPtr, Size);
    1604         Index64Op2  = (INT64) Index16;
    1605         Size += sizeof (UINT16);
     1607        Index16    = VmReadIndex16 (VmPtr, Size);
     1608        Index64Op2 = (INT64)Index16;
     1609        Size      += sizeof (UINT16);
    16061610      }
    16071611    } else if ((OpcMasked <= OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVND)) {
    … …  
    16101614      //
    16111615      if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
    1612         Index32     = VmReadIndex32 (VmPtr, 2);
    1613         Index64Op1  = (INT64) Index32;
    1614         Size += sizeof (UINT32);
     1616        Index32    = VmReadIndex32 (VmPtr, 2);
     1617        Index64Op1 = (INT64)Index32;
     1618        Size      += sizeof (UINT32);
    16151619      }
    16161620
    16171621      if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
    1618         Index32     = VmReadIndex32 (VmPtr, Size);
    1619         Index64Op2  = (INT64) Index32;
    1620         Size += sizeof (UINT32);
     1622        Index32    = VmReadIndex32 (VmPtr, Size);
     1623        Index64Op2 = (INT64)Index32;
     1624        Size      += sizeof (UINT32);
    16211625      }
    16221626    } else if (OpcMasked == OPCODE_MOVQQ) {
    … …  
    16261630      if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
    16271631        Index64Op1 = VmReadIndex64 (VmPtr, 2);
    1628         Size += sizeof (UINT64);
     1632        Size      += sizeof (UINT64);
    16291633      }
    16301634
    16311635      if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
    16321636        Index64Op2 = VmReadIndex64 (VmPtr, Size);
    1633         Size += sizeof (UINT64);
     1637        Size      += sizeof (UINT64);
    16341638      }
    16351639    } else {
    … …  
    16451649    }
    16461650  }
     1651
    16471652  //
    16481653  // Determine the size of the move, and create a mask for it so we can
    … …  
    16501655  //
    16511656  if ((OpcMasked == OPCODE_MOVBW) || (OpcMasked == OPCODE_MOVBD)) {
    1652     MoveSize  = DATA_SIZE_8;
    1653     DataMask  = 0xFF;
     1657    MoveSize = DATA_SIZE_8;
     1658    DataMask = 0xFF;
    16541659  } else if ((OpcMasked == OPCODE_MOVWW) || (OpcMasked == OPCODE_MOVWD)) {
    1655     MoveSize  = DATA_SIZE_16;
    1656     DataMask  = 0xFFFF;
     1660    MoveSize = DATA_SIZE_16;
     1661    DataMask = 0xFFFF;
    16571662  } else if ((OpcMasked == OPCODE_MOVDW) || (OpcMasked == OPCODE_MOVDD)) {
    1658     MoveSize  = DATA_SIZE_32;
    1659     DataMask  = 0xFFFFFFFF;
     1663    MoveSize = DATA_SIZE_32;
     1664    DataMask = 0xFFFFFFFF;
    16601665  } else if ((OpcMasked == OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVQQ)) {
    1661     MoveSize  = DATA_SIZE_64;
    1662     DataMask  = (UINT64)~0;
     1666    MoveSize = DATA_SIZE_64;
     1667    DataMask = (UINT64) ~0;
    16631668  } else if ((OpcMasked == OPCODE_MOVNW) || (OpcMasked == OPCODE_MOVND)) {
    1664     MoveSize  = DATA_SIZE_N;
    1665     DataMask  = (UINT64)~0 >> (64 - 8 * sizeof (UINTN));
     1669    MoveSize = DATA_SIZE_N;
     1670    DataMask = (UINT64) ~0 >> (64 - 8 * sizeof (UINTN));
    16661671  } else {
    16671672    //
    … …  
    16711676    return EFI_UNSUPPORTED;
    16721677  }
     1678
    16731679  //
    16741680  // Now get the source address
    … …  
    16781684    // Indirect form @R2. Compute address of operand2
    16791685    //
    1680     Source = (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
     1686    Source = (UINTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
    16811687    //
    16821688    // Now get the data from the source. Always 0-extend and let the compiler
    … …  
    16841690    //
    16851691    switch (MoveSize) {
    1686     case DATA_SIZE_8:
    1687       Data64 = (UINT64) (UINT8) VmReadMem8 (VmPtr, Source);
    1688       break;
    1689 
    1690     case DATA_SIZE_16:
    1691       Data64 = (UINT64) (UINT16) VmReadMem16 (VmPtr, Source);
    1692       break;
    1693 
    1694     case DATA_SIZE_32:
    1695       Data64 = (UINT64) (UINT32) VmReadMem32 (VmPtr, Source);
    1696       break;
    1697 
    1698     case DATA_SIZE_64:
    1699       Data64 = (UINT64) VmReadMem64 (VmPtr, Source);
    1700       break;
    1701 
    1702     case DATA_SIZE_N:
    1703       Data64 = (UINT64) (UINTN) VmReadMemN (VmPtr, Source);
    1704       break;
    1705 
    1706     default:
    1707       //
    1708       // not reached
    1709       //
    1710       break;
     1692      case DATA_SIZE_8:
     1693        Data64 = (UINT64)(UINT8)VmReadMem8 (VmPtr, Source);
     1694        break;
     1695
     1696      case DATA_SIZE_16:
     1697        Data64 = (UINT64)(UINT16)VmReadMem16 (VmPtr, Source);
     1698        break;
     1699
     1700      case DATA_SIZE_32:
     1701        Data64 = (UINT64)(UINT32)VmReadMem32 (VmPtr, Source);
     1702        break;
     1703
     1704      case DATA_SIZE_64:
     1705        Data64 = (UINT64)VmReadMem64 (VmPtr, Source);
     1706        break;
     1707
     1708      case DATA_SIZE_N:
     1709        Data64 = (UINT64)(UINTN)VmReadMemN (VmPtr, Source);
     1710        break;
     1711
     1712      default:
     1713        //
     1714        // not reached
     1715        //
     1716        break;
    17111717    }
    17121718  } else {
    … …  
    17141720    // Not indirect source: MOVxx {@}Rx, Ry [Index]
    17151721    //
    1716     Data64 = (UINT64) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
     1722    Data64 = (UINT64)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
    17171723    //
    17181724    // Did Operand2 have an index? If so, treat as two signed values since
    … …  
    17381744          (OPERAND1_REGNUM (Operands) == 0) &&
    17391745          (OPERAND1_INDIRECT (Operands))
    1740           ) {
    1741         Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64);
     1746          )
     1747      {
     1748        Data64 = (UINT64)ConvertStackAddr (VmPtr, (UINTN)(INT64)Data64);
    17421749      }
    17431750    }
    17441751  }
     1752
    17451753  //
    17461754  // Now write it back
    … …  
    17501758    // Reuse the Source variable to now be dest.
    17511759    //
    1752     Source = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index64Op1);
     1760    Source = (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index64Op1);
    17531761    //
    17541762    // Do the write based on the size
    17551763    //
    17561764    switch (MoveSize) {
    1757     case DATA_SIZE_8:
    1758       VmWriteMem8 (VmPtr, Source, (UINT8) Data64);
    1759       break;
    1760 
    1761     case DATA_SIZE_16:
    1762       VmWriteMem16 (VmPtr, Source, (UINT16) Data64);
    1763       break;
    1764 
    1765     case DATA_SIZE_32:
    1766       VmWriteMem32 (VmPtr, Source, (UINT32) Data64);
    1767       break;
    1768 
    1769     case DATA_SIZE_64:
    1770       VmWriteMem64 (VmPtr, Source, Data64);
    1771       break;
    1772 
    1773     case DATA_SIZE_N:
    1774       VmWriteMemN (VmPtr, Source, (UINTN) Data64);
    1775       break;
    1776 
    1777     default:
    1778       //
    1779       // not reached
    1780       //
    1781       break;
     1765      case DATA_SIZE_8:
     1766        VmWriteMem8 (VmPtr, Source, (UINT8)Data64);
     1767        break;
     1768
     1769      case DATA_SIZE_16:
     1770        VmWriteMem16 (VmPtr, Source, (UINT16)Data64);
     1771        break;
     1772
     1773      case DATA_SIZE_32:
     1774        VmWriteMem32 (VmPtr, Source, (UINT32)Data64);
     1775        break;
     1776
     1777      case DATA_SIZE_64:
     1778        VmWriteMem64 (VmPtr, Source, Data64);
     1779        break;
     1780
     1781      case DATA_SIZE_N:
     1782        VmWriteMemN (VmPtr, Source, (UINTN)Data64);
     1783        break;
     1784
     1785      default:
     1786        //
     1787        // not reached
     1788        //
     1789        break;
    17821790    }
    17831791  } else {
    … …  
    17941802      return EFI_UNSUPPORTED;
    17951803    }
     1804
    17961805    //
    17971806    // Direct storage in register. Clear unused bits and store back to
    … …  
    18001809    VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;
    18011810  }
     1811
    18021812  //
    18031813  // Advance the instruction pointer
    … …  
    18071817}
    18081818
    1809 
    18101819/**
    18111820  Execute the EBC BREAK instruction.
    … …  
    18181827EFI_STATUS
    18191828ExecuteBREAK (
    1820   IN VM_CONTEXT *VmPtr
     1829  IN VM_CONTEXT  *VmPtr
    18211830  )
    18221831{
    … …  
    18281837  INT32       Offset;
    18291838
    1830   Thunk = NULL;
     1839  Thunk    = NULL;
    18311840  Operands = GETOPERANDS (VmPtr);
    18321841  switch (Operands) {
    1833   //
    1834   // Runaway program break. Generate an exception and terminate
    1835   //
    1836   case 0:
    1837     EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
    1838     break;
    1839 
    1840   //
    1841   // Get VM version -- return VM revision number in R7
    1842   //
    1843   case 1:
    1844     //
    1845     // Bits:
    1846     //  63-17 = 0
    1847     //  16-8  = Major version
    1848     //  7-0   = Minor version
    1849     //
    1850     VmPtr->Gpr[7] = GetVmVersion ();
    1851     break;
    1852 
    1853   //
    1854   // Debugger breakpoint
    1855   //
    1856   case 3:
    1857     VmPtr->StopFlags |= STOPFLAG_BREAKPOINT;
    1858     //
    1859     // See if someone has registered a handler
    1860     //
    1861     EbcDebugSignalException (
    1862       EXCEPT_EBC_BREAKPOINT,
    1863       EXCEPTION_FLAG_NONE,
    1864       VmPtr
    1865       );
    1866     break;
    1867 
    1868   //
    1869   // System call, which there are none, so NOP it.
    1870   //
    1871   case 4:
    1872     break;
    1873 
    1874   //
    1875   // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot)
    1876   // "offset from self" pointer to the EBC entry point.
    1877   // After we're done, *(UINT64 *)R7 will be the address of the new thunk.
    1878   //
    1879   case 5:
    1880     Offset            = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->Gpr[7]);
    1881     U64EbcEntryPoint  = (UINT64) (VmPtr->Gpr[7] + Offset + 4);
    1882     EbcEntryPoint     = (VOID *) (UINTN) U64EbcEntryPoint;
    1883 
    1884     //
    1885     // Now create a new thunk
    1886     //
    1887     Status = EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);
    1888     if (EFI_ERROR (Status)) {
    1889       return Status;
    1890     }
    1891 
    1892     //
    1893     // Finally replace the EBC entry point memory with the thunk address
    1894     //
    1895     VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[7], (UINT64) (UINTN) Thunk);
    1896     break;
    1897 
    1898   //
    1899   // Compiler setting version per value in R7
    1900   //
    1901   case 6:
    1902     VmPtr->CompilerVersion = (UINT32) VmPtr->Gpr[7];
    1903     //
    1904     // Check compiler version against VM version?
    1905     //
    1906     break;
    1907 
    1908   //
    1909   // Unhandled break code. Signal exception.
    1910   //
    1911   default:
    1912     EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
    1913     break;
    1914   }
     1842    //
     1843    // Runaway program break. Generate an exception and terminate
     1844    //
     1845    case 0:
     1846      EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
     1847      break;
     1848
     1849    //
     1850    // Get VM version -- return VM revision number in R7
     1851    //
     1852    case 1:
     1853      //
     1854      // Bits:
     1855      //  63-17 = 0
     1856      //  16-8  = Major version
     1857      //  7-0   = Minor version
     1858      //
     1859      VmPtr->Gpr[7] = GetVmVersion ();
     1860      break;
     1861
     1862    //
     1863    // Debugger breakpoint
     1864    //
     1865    case 3:
     1866      VmPtr->StopFlags |= STOPFLAG_BREAKPOINT;
     1867      //
     1868      // See if someone has registered a handler
     1869      //
     1870      EbcDebugSignalException (
     1871        EXCEPT_EBC_BREAKPOINT,
     1872        EXCEPTION_FLAG_NONE,
     1873        VmPtr
     1874        );
     1875      break;
     1876
     1877    //
     1878    // System call, which there are none, so NOP it.
     1879    //
     1880    case 4:
     1881      break;
     1882
     1883    //
     1884    // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot)
     1885    // "offset from self" pointer to the EBC entry point.
     1886    // After we're done, *(UINT64 *)R7 will be the address of the new thunk.
     1887    //
     1888    case 5:
     1889      Offset           = (INT32)VmReadMem32 (VmPtr, (UINTN)VmPtr->Gpr[7]);
     1890      U64EbcEntryPoint = (UINT64)(VmPtr->Gpr[7] + Offset + 4);
     1891      EbcEntryPoint    = (VOID *)(UINTN)U64EbcEntryPoint;
     1892
     1893      //
     1894      // Now create a new thunk
     1895      //
     1896      Status = EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);
     1897      if (EFI_ERROR (Status)) {
     1898        return Status;
     1899      }
     1900
     1901      //
     1902      // Finally replace the EBC entry point memory with the thunk address
     1903      //
     1904      VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[7], (UINT64)(UINTN)Thunk);
     1905      break;
     1906
     1907    //
     1908    // Compiler setting version per value in R7
     1909    //
     1910    case 6:
     1911      VmPtr->CompilerVersion = (UINT32)VmPtr->Gpr[7];
     1912      //
     1913      // Check compiler version against VM version?
     1914      //
     1915      break;
     1916
     1917    //
     1918    // Unhandled break code. Signal exception.
     1919    //
     1920    default:
     1921      EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
     1922      break;
     1923  }
     1924
    19151925  //
    19161926  // Advance IP
    … …  
    19191929  return EFI_SUCCESS;
    19201930}
    1921 
    19221931
    19231932/**
    … …  
    19481957EFI_STATUS
    19491958ExecuteJMP (
    1950   IN VM_CONTEXT *VmPtr
     1959  IN VM_CONTEXT  *VmPtr
    19511960  )
    19521961{
    … …  
    19731982  // If we haven't met the condition, then simply advance the IP and return.
    19741983  //
    1975   CompareSet    = (UINT8) (((Operand & JMP_M_CS) != 0) ? 1 : 0);
    1976   ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
     1984  CompareSet    = (UINT8)(((Operand & JMP_M_CS) != 0) ? 1 : 0);
     1985  ConditionFlag = (UINT8)VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
    19771986  if ((Operand & CONDITION_M_CONDITIONAL) != 0) {
    19781987    if (CompareSet != ConditionFlag) {
    … …  
    19831992    }
    19841993  }
     1994
    19851995  //
    19861996  // Check for 64-bit form and do it right away since it's the most
    … …  
    20002010      return EFI_UNSUPPORTED;
    20012011    }
     2012
    20022013    //
    20032014    // 64-bit immediate data is full address. Read the immediate data,
    20042015    // check for alignment, and jump absolute.
    20052016    //
    2006     Data64 = (UINT64) VmReadImmed64 (VmPtr, 2);
    2007     if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) {
     2017    Data64 = (UINT64)VmReadImmed64 (VmPtr, 2);
     2018    if (!IS_ALIGNED ((UINTN)Data64, sizeof (UINT16))) {
    20082019      EbcDebugSignalException (
    20092020        EXCEPT_EBC_ALIGNMENT_CHECK,
    … …  
    20202031    EbcDebuggerHookJMPStart (VmPtr);
    20212032    if ((Operand & JMP_M_RELATIVE) != 0) {
    2022       VmPtr->Ip += (UINTN) Data64 + Size;
     2033      VmPtr->Ip += (UINTN)Data64 + Size;
    20232034    } else {
    2024       VmPtr->Ip = (VMIP) (UINTN) Data64;
    2025     }
     2035      VmPtr->Ip = (VMIP)(UINTN)Data64;
     2036    }
     2037
    20262038    EbcDebuggerHookJMPEnd (VmPtr);
    20272039
    20282040    return EFI_SUCCESS;
    20292041  }
     2042
    20302043  //
    20312044  // 32-bit forms:
    … …  
    20442057    Index32 = 0;
    20452058  }
     2059
    20462060  //
    20472061  // Get the register data. If R == 0, then special case where it's ignored.
    … …  
    20502064    Data64 = 0;
    20512065  } else {
    2052     Data64 = (UINT64) OPERAND1_REGDATA (VmPtr, Operand);
    2053   }
     2066    Data64 = (UINT64)OPERAND1_REGDATA (VmPtr, Operand);
     2067  }
     2068
    20542069  //
    20552070  // Decode the forms
    … …  
    20592074    // Form: JMP32 @Rx {Index32}
    20602075    //
    2061     Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32);
    2062     if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {
     2076    Addr = VmReadMemN (VmPtr, (UINTN)Data64 + Index32);
     2077    if (!IS_ALIGNED ((UINTN)Addr, sizeof (UINT16))) {
    20632078      EbcDebugSignalException (
    20642079        EXCEPT_EBC_ALIGNMENT_CHECK,
    … …  
    20722087    EbcDebuggerHookJMPStart (VmPtr);
    20732088    if ((Operand & JMP_M_RELATIVE) != 0) {
    2074       VmPtr->Ip += (UINTN) Addr + Size;
     2089      VmPtr->Ip += (UINTN)Addr + Size;
    20752090    } else {
    2076       VmPtr->Ip = (VMIP) Addr;
    2077     }
     2091      VmPtr->Ip = (VMIP)Addr;
     2092    }
     2093
    20782094    EbcDebuggerHookJMPEnd (VmPtr);
    2079 
    20802095  } else {
    20812096    //
    20822097    // Form: JMP32 Rx {Immed32}
    20832098    //
    2084     Addr = (UINTN) (Data64 + Index32);
    2085     if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {
     2099    Addr = (UINTN)(Data64 + Index32);
     2100    if (!IS_ALIGNED ((UINTN)Addr, sizeof (UINT16))) {
    20862101      EbcDebugSignalException (
    20872102        EXCEPT_EBC_ALIGNMENT_CHECK,
    … …  
    20952110    EbcDebuggerHookJMPStart (VmPtr);
    20962111    if ((Operand & JMP_M_RELATIVE) != 0) {
    2097       VmPtr->Ip += (UINTN) Addr + Size;
     2112      VmPtr->Ip += (UINTN)Addr + Size;
    20982113    } else {
    2099       VmPtr->Ip = (VMIP) Addr;
    2100     }
     2114      VmPtr->Ip = (VMIP)Addr;
     2115    }
     2116
    21012117    EbcDebuggerHookJMPEnd (VmPtr);
    2102 
    21032118  }
    21042119
    21052120  return EFI_SUCCESS;
    21062121}
    2107 
    21082122
    21092123/**
    … …  
    21202134EFI_STATUS
    21212135ExecuteJMP8 (
    2122   IN VM_CONTEXT *VmPtr
    2123   )
    2124 {
    2125   UINT8 Opcode;
    2126   UINT8 ConditionFlag;
    2127   UINT8 CompareSet;
    2128   INT8  Offset;
     2136  IN VM_CONTEXT  *VmPtr
     2137  )
     2138{
     2139  UINT8  Opcode;
     2140  UINT8  ConditionFlag;
     2141  UINT8  CompareSet;
     2142  INT8   Offset;
    21292143
    21302144  //
    … …  
    21322146  //
    21332147  Opcode        = GETOPCODE (VmPtr);
    2134   CompareSet    = (UINT8) (((Opcode & JMP_M_CS) != 0) ? 1 : 0);
    2135   ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
     2148  CompareSet    = (UINT8)(((Opcode & JMP_M_CS) != 0) ? 1 : 0);
     2149  ConditionFlag = (UINT8)VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
    21362150
    21372151  //
    … …  
    21462160    }
    21472161  }
     2162
    21482163  //
    21492164  // Get the offset from the instruction stream. It's relative to the
    … …  
    21602175}
    21612176
    2162 
    21632177/**
    21642178  Execute the EBC MOVI.
    … …  
    21842198EFI_STATUS
    21852199ExecuteMOVI (
    2186   IN VM_CONTEXT *VmPtr
     2200  IN VM_CONTEXT  *VmPtr
    21872201  )
    21882202{
    … …  
    21982212  // Get the opcode and operands byte so we can get R1 and R2
    21992213  //
    2200   Opcode    = GETOPCODE (VmPtr);
    2201   Operands  = GETOPERANDS (VmPtr);
     2214  Opcode   = GETOPCODE (VmPtr);
     2215  Operands = GETOPERANDS (VmPtr);
    22022216
    22032217  //
    … …  
    22112225    Size    = 2;
    22122226  }
     2227
    22132228  //
    22142229  // Extract the immediate data. Sign-extend always.
    22152230  //
    22162231  if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    2217     ImmData64 = (INT64) (INT16) VmReadImmed16 (VmPtr, Size);
    2218     Size += 2;
     2232    ImmData64 = (INT64)(INT16)VmReadImmed16 (VmPtr, Size);
     2233    Size     += 2;
    22192234  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    2220     ImmData64 = (INT64) (INT32) VmReadImmed32 (VmPtr, Size);
    2221     Size += 4;
     2235    ImmData64 = (INT64)(INT32)VmReadImmed32 (VmPtr, Size);
     2236    Size     += 4;
    22222237  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    2223     ImmData64 = (INT64) VmReadImmed64 (VmPtr, Size);
    2224     Size += 8;
     2238    ImmData64 = (INT64)VmReadImmed64 (VmPtr, Size);
     2239    Size     += 8;
    22252240  } else {
    22262241    //
    … …  
    22342249    return EFI_UNSUPPORTED;
    22352250  }
     2251
    22362252  //
    22372253  // Now write back the result
    … …  
    22492265      return EFI_UNSUPPORTED;
    22502266    }
     2267
    22512268    //
    22522269    // Writing directly to a register. Clear unused bits.
    … …  
    22592276      Mask64 = 0x00000000FFFFFFFF;
    22602277    } else {
    2261       Mask64 = (UINT64)~0;
     2278      Mask64 = (UINT64) ~0;
    22622279    }
    22632280
    … …  
    22672284    // Get the address then write back based on size of the move
    22682285    //
    2269     Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
     2286    Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
    22702287    if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {
    2271       VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64);
     2288      VmWriteMem8 (VmPtr, (UINTN)Op1, (UINT8)ImmData64);
    22722289    } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {
    2273       VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64);
     2290      VmWriteMem16 (VmPtr, (UINTN)Op1, (UINT16)ImmData64);
    22742291    } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {
    2275       VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64);
     2292      VmWriteMem32 (VmPtr, (UINTN)Op1, (UINT32)ImmData64);
    22762293    } else {
    2277       VmWriteMem64 (VmPtr, (UINTN) Op1, (UINT64) ImmData64);
    2278     }
    2279   }
     2294      VmWriteMem64 (VmPtr, (UINTN)Op1, (UINT64)ImmData64);
     2295    }
     2296  }
     2297
    22802298  //
    22812299  // Advance the instruction pointer
    … …  
    22852303}
    22862304
    2287 
    22882305/**
    22892306  Execute the EBC MOV immediate natural. This instruction moves an immediate
    … …  
    23022319EFI_STATUS
    23032320ExecuteMOVIn (
    2304   IN VM_CONTEXT *VmPtr
     2321  IN VM_CONTEXT  *VmPtr
    23052322  )
    23062323{
    … …  
    23172334  // Get the opcode and operands byte so we can get R1 and R2
    23182335  //
    2319   Opcode    = GETOPCODE (VmPtr);
    2320   Operands  = GETOPERANDS (VmPtr);
     2336  Opcode   = GETOPCODE (VmPtr);
     2337  Operands = GETOPERANDS (VmPtr);
    23212338
    23222339  //
    … …  
    23302347    Size    = 2;
    23312348  }
     2349
    23322350  //
    23332351  // Extract the immediate data and convert to a 64-bit index.
    23342352  //
    23352353  if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    2336     ImmedIndex16  = VmReadIndex16 (VmPtr, Size);
    2337     ImmedIndex64  = (INT64) ImmedIndex16;
    2338     Size += 2;
     2354    ImmedIndex16 = VmReadIndex16 (VmPtr, Size);
     2355    ImmedIndex64 = (INT64)ImmedIndex16;
     2356    Size        += 2;
    23392357  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    2340     ImmedIndex32  = VmReadIndex32 (VmPtr, Size);
    2341     ImmedIndex64  = (INT64) ImmedIndex32;
    2342     Size += 4;
     2358    ImmedIndex32 = VmReadIndex32 (VmPtr, Size);
     2359    ImmedIndex64 = (INT64)ImmedIndex32;
     2360    Size        += 4;
    23432361  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    23442362    ImmedIndex64 = VmReadIndex64 (VmPtr, Size);
    2345     Size += 8;
     2363    Size        += 8;
    23462364  } else {
    23472365    //
    … …  
    23552373    return EFI_UNSUPPORTED;
    23562374  }
     2375
    23572376  //
    23582377  // Now write back the result
    … …  
    23772396    // Get the address
    23782397    //
    2379     Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
    2380     VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN)(INTN) ImmedIndex64);
    2381   }
     2398    Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
     2399    VmWriteMemN (VmPtr, (UINTN)Op1, (UINTN)(INTN)ImmedIndex64);
     2400  }
     2401
    23822402  //
    23832403  // Advance the instruction pointer
    … …  
    23872407}
    23882408
    2389 
    23902409/**
    23912410  Execute the EBC MOVREL instruction.
    … …  
    24042423EFI_STATUS
    24052424ExecuteMOVREL (
    2406   IN VM_CONTEXT *VmPtr
     2425  IN VM_CONTEXT  *VmPtr
    24072426  )
    24082427{
    … …  
    24182437  // Get the opcode and operands byte so we can get R1 and R2
    24192438  //
    2420   Opcode    = GETOPCODE (VmPtr);
    2421   Operands  = GETOPERANDS (VmPtr);
     2439  Opcode   = GETOPCODE (VmPtr);
     2440  Operands = GETOPERANDS (VmPtr);
    24222441
    24232442  //
    … …  
    24312450    Size    = 2;
    24322451  }
     2452
    24332453  //
    24342454  // Get the immediate data.
    24352455  //
    24362456  if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    2437     ImmData64 = (INT64) VmReadImmed16 (VmPtr, Size);
    2438     Size += 2;
     2457    ImmData64 = (INT64)VmReadImmed16 (VmPtr, Size);
     2458    Size     += 2;
    24392459  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    2440     ImmData64 = (INT64) VmReadImmed32 (VmPtr, Size);
    2441     Size += 4;
     2460    ImmData64 = (INT64)VmReadImmed32 (VmPtr, Size);
     2461    Size     += 4;
    24422462  } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    24432463    ImmData64 = VmReadImmed64 (VmPtr, Size);
    2444     Size += 8;
     2464    Size     += 8;
    24452465  } else {
    24462466    //
    … …  
    24542474    return EFI_UNSUPPORTED;
    24552475  }
     2476
    24562477  //
    24572478  // Compute the value and write back the result
    24582479  //
    2459   Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size);
     2480  Op2 = (UINT64)((INT64)((UINT64)(UINTN)VmPtr->Ip) + (INT64)ImmData64 + Size);
    24602481  if (!OPERAND1_INDIRECT (Operands)) {
    24612482    //
    … …  
    24712492    }
    24722493
    2473     VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2;
     2494    VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (VM_REGISTER)Op2;
    24742495  } else {
    24752496    //
    … …  
    24782499    // we're talking addresses here.
    24792500    //
    2480     Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
    2481     VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2);
    2482   }
     2501    Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
     2502    VmWriteMemN (VmPtr, (UINTN)Op1, (UINTN)Op2);
     2503  }
     2504
    24832505  //
    24842506  // Advance the instruction pointer
    … …  
    24872509  return EFI_SUCCESS;
    24882510}
    2489 
    24902511
    24912512/**
    … …  
    25102531EFI_STATUS
    25112532ExecuteMOVsnw (
    2512   IN VM_CONTEXT *VmPtr
     2533  IN VM_CONTEXT  *VmPtr
    25132534  )
    25142535{
    … …  
    25232544  // Get the opcode and operand bytes
    25242545  //
    2525   Opcode              = GETOPCODE (VmPtr);
    2526   Operands            = GETOPERANDS (VmPtr);
    2527 
    2528   Op1Index            = Op2Index = 0;
     2546  Opcode   = GETOPCODE (VmPtr);
     2547  Operands = GETOPERANDS (VmPtr);
     2548
     2549  Op1Index = Op2Index = 0;
    25292550
    25302551  //
    … …  
    25322553  //
    25332554  Size = 2;
    2534   if ((Opcode & OPCODE_M_IMMED_OP1) !=0) {
     2555  if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
    25352556    if (OPERAND1_INDIRECT (Operands)) {
    25362557      Op1Index = VmReadIndex16 (VmPtr, 2);
    … …  
    25592580    Size += sizeof (UINT16);
    25602581  }
     2582
    25612583  //
    25622584  // Get the data from the source.
    … …  
    25642586  Op2 = (UINT64)(INT64)(INTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);
    25652587  if (OPERAND2_INDIRECT (Operands)) {
    2566     Op2 = (UINT64)(INT64)(INTN)VmReadMemN (VmPtr, (UINTN) Op2);
    2567   }
     2588    Op2 = (UINT64)(INT64)(INTN)VmReadMemN (VmPtr, (UINTN)Op2);
     2589  }
     2590
    25682591  //
    25692592  // Now write back the result.
    … …  
    25722595    VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;
    25732596  } else {
    2574     VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);
    2575   }
     2597    VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN)Op2);
     2598  }
     2599
    25762600  //
    25772601  // Advance the instruction pointer
    … …  
    25802604  return EFI_SUCCESS;
    25812605}
    2582 
    25832606
    25842607/**
    … …  
    26032626EFI_STATUS
    26042627ExecuteMOVsnd (
    2605   IN VM_CONTEXT *VmPtr
     2628  IN VM_CONTEXT  *VmPtr
    26062629  )
    26072630{
    … …  
    26162639  // Get the opcode and operand bytes
    26172640  //
    2618   Opcode              = GETOPCODE (VmPtr);
    2619   Operands            = GETOPERANDS (VmPtr);
    2620 
    2621   Op1Index            = Op2Index = 0;
     2641  Opcode   = GETOPCODE (VmPtr);
     2642  Operands = GETOPERANDS (VmPtr);
     2643
     2644  Op1Index = Op2Index = 0;
    26222645
    26232646  //
    … …  
    26522675    Size += sizeof (UINT32);
    26532676  }
     2677
    26542678  //
    26552679  // Get the data from the source.
    … …  
    26572681  Op2 = (UINT64)(INT64)(INTN)(INT64)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);
    26582682  if (OPERAND2_INDIRECT (Operands)) {
    2659     Op2 = (UINT64)(INT64)(INTN)(INT64)VmReadMemN (VmPtr, (UINTN) Op2);
    2660   }
     2683    Op2 = (UINT64)(INT64)(INTN)(INT64)VmReadMemN (VmPtr, (UINTN)Op2);
     2684  }
     2685
    26612686  //
    26622687  // Now write back the result.
    … …  
    26652690    VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;
    26662691  } else {
    2667     VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);
    2668   }
     2692    VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN)Op2);
     2693  }
     2694
    26692695  //
    26702696  // Advance the instruction pointer
    … …  
    26742700}
    26752701
    2676 
    26772702/**
    26782703  Execute the EBC PUSHn instruction
    … …  
    26882713EFI_STATUS
    26892714ExecutePUSHn (
    2690   IN VM_CONTEXT *VmPtr
    2691   )
    2692 {
    2693   UINT8 Opcode;
    2694   UINT8 Operands;
    2695   INT16 Index16;
    2696   UINTN DataN;
     2715  IN VM_CONTEXT  *VmPtr
     2716  )
     2717{
     2718  UINT8  Opcode;
     2719  UINT8  Operands;
     2720  INT16  Index16;
     2721  UINTN  DataN;
    26972722
    26982723  //
    26992724  // Get opcode and operands
    27002725  //
    2701   Opcode    = GETOPCODE (VmPtr);
    2702   Operands  = GETOPERANDS (VmPtr);
     2726  Opcode   = GETOPCODE (VmPtr);
     2727  Operands = GETOPERANDS (VmPtr);
    27032728
    27042729  //
    … …  
    27142739    VmPtr->Ip += 4;
    27152740  } else {
    2716     Index16 = 0;
     2741    Index16    = 0;
    27172742    VmPtr->Ip += 2;
    27182743  }
     2744
    27192745  //
    27202746  // Get the data to push
    27212747  //
    27222748  if (OPERAND1_INDIRECT (Operands)) {
    2723     DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
    2724   } else {
    2725     DataN = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16);
    2726   }
     2749    DataN = VmReadMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
     2750  } else {
     2751    DataN = (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16);
     2752  }
     2753
    27272754  //
    27282755  // Adjust the stack down.
    27292756  //
    27302757  VmPtr->Gpr[0] -= sizeof (UINTN);
    2731   VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], DataN);
     2758  VmWriteMemN (VmPtr, (UINTN)VmPtr->Gpr[0], DataN);
    27322759  return EFI_SUCCESS;
    27332760}
    2734 
    27352761
    27362762/**
    … …  
    27472773EFI_STATUS
    27482774ExecutePUSH (
    2749   IN VM_CONTEXT *VmPtr
     2775  IN VM_CONTEXT  *VmPtr
    27502776  )
    27512777{
    … …  
    27592785  // Get opcode and operands
    27602786  //
    2761   Opcode    = GETOPCODE (VmPtr);
    2762   Operands  = GETOPERANDS (VmPtr);
     2787  Opcode   = GETOPCODE (VmPtr);
     2788  Operands = GETOPERANDS (VmPtr);
    27632789  //
    27642790  // Get immediate index if present, then advance the IP.
    … …  
    27732799    VmPtr->Ip += 4;
    27742800  } else {
    2775     Index16 = 0;
     2801    Index16    = 0;
    27762802    VmPtr->Ip += 2;
    27772803  }
     2804
    27782805  //
    27792806  // Get the data to push
    … …  
    27812808  if ((Opcode & PUSHPOP_M_64) != 0) {
    27822809    if (OPERAND1_INDIRECT (Operands)) {
    2783       Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
     2810      Data64 = VmReadMem64 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
    27842811    } else {
    2785       Data64 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
    2786     }
     2812      Data64 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
     2813    }
     2814
    27872815    //
    27882816    // Adjust the stack down, then write back the data
    27892817    //
    27902818    VmPtr->Gpr[0] -= sizeof (UINT64);
    2791     VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], Data64);
     2819    VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[0], Data64);
    27922820  } else {
    27932821    //
    … …  
    27952823    //
    27962824    if (OPERAND1_INDIRECT (Operands)) {
    2797       Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
     2825      Data32 = VmReadMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
    27982826    } else {
    2799       Data32 = (UINT32) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
    2800     }
     2827      Data32 = (UINT32)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
     2828    }
     2829
    28012830    //
    28022831    // Adjust the stack down and write the data
    28032832    //
    28042833    VmPtr->Gpr[0] -= sizeof (UINT32);
    2805     VmWriteMem32 (VmPtr, (UINTN) VmPtr->Gpr[0], Data32);
     2834    VmWriteMem32 (VmPtr, (UINTN)VmPtr->Gpr[0], Data32);
    28062835  }
    28072836
    28082837  return EFI_SUCCESS;
    28092838}
    2810 
    28112839
    28122840/**
    … …  
    28232851EFI_STATUS
    28242852ExecutePOPn (
    2825   IN VM_CONTEXT *VmPtr
    2826   )
    2827 {
    2828   UINT8 Opcode;
    2829   UINT8 Operands;
    2830   INT16 Index16;
    2831   UINTN DataN;
     2853  IN VM_CONTEXT  *VmPtr
     2854  )
     2855{
     2856  UINT8  Opcode;
     2857  UINT8  Operands;
     2858  INT16  Index16;
     2859  UINTN  DataN;
    28322860
    28332861  //
    28342862  // Get opcode and operands
    28352863  //
    2836   Opcode    = GETOPCODE (VmPtr);
    2837   Operands  = GETOPERANDS (VmPtr);
     2864  Opcode   = GETOPCODE (VmPtr);
     2865  Operands = GETOPERANDS (VmPtr);
    28382866  //
    28392867  // Get immediate data if present, and advance the IP
    … …  
    28482876    VmPtr->Ip += 4;
    28492877  } else {
    2850     Index16 = 0;
     2878    Index16    = 0;
    28512879    VmPtr->Ip += 2;
    28522880  }
     2881
    28532882  //
    28542883  // Read the data off the stack, then adjust the stack pointer
    28552884  //
    2856   DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);
     2885  DataN          = VmReadMemN (VmPtr, (UINTN)VmPtr->Gpr[0]);
    28572886  VmPtr->Gpr[0] += sizeof (UINTN);
    28582887  //
    … …  
    28602889  //
    28612890  if (OPERAND1_INDIRECT (Operands)) {
    2862     VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);
    2863   } else {
    2864     VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) (UINTN) (DataN + Index16);
     2891    VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);
     2892  } else {
     2893    VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64)(UINT64)(UINTN)(DataN + Index16);
    28652894  }
    28662895
    28672896  return EFI_SUCCESS;
    28682897}
    2869 
    28702898
    28712899/**
    … …  
    28822910EFI_STATUS
    28832911ExecutePOP (
    2884   IN VM_CONTEXT *VmPtr
     2912  IN VM_CONTEXT  *VmPtr
    28852913  )
    28862914{
    … …  
    28942922  // Get opcode and operands
    28952923  //
    2896   Opcode    = GETOPCODE (VmPtr);
    2897   Operands  = GETOPERANDS (VmPtr);
     2924  Opcode   = GETOPCODE (VmPtr);
     2925  Operands = GETOPERANDS (VmPtr);
    28982926  //
    28992927  // Get immediate data if present, and advance the IP.
    … …  
    29082936    VmPtr->Ip += 4;
    29092937  } else {
    2910     Index16 = 0;
     2938    Index16    = 0;
    29112939    VmPtr->Ip += 2;
    29122940  }
     2941
    29132942  //
    29142943  // Get the data off the stack, then write it to the appropriate location
    … …  
    29182947    // Read the data off the stack, then adjust the stack pointer
    29192948    //
    2920     Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);
     2949    Data64         = VmReadMem64 (VmPtr, (UINTN)VmPtr->Gpr[0]);
    29212950    VmPtr->Gpr[0] += sizeof (UINT64);
    29222951    //
    … …  
    29242953    //
    29252954    if (OPERAND1_INDIRECT (Operands)) {
    2926       VmWriteMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);
     2955      VmWriteMem64 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);
    29272956    } else {
    29282957      VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 + Index16;
    … …  
    29322961    // 32-bit pop. Read it off the stack and adjust the stack pointer
    29332962    //
    2934     Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->Gpr[0]);
     2963    Data32         = (INT32)VmReadMem32 (VmPtr, (UINTN)VmPtr->Gpr[0]);
    29352964    VmPtr->Gpr[0] += sizeof (UINT32);
    29362965    //
    … …  
    29382967    //
    29392968    if (OPERAND1_INDIRECT (Operands)) {
    2940       VmWriteMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);
     2969      VmWriteMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);
    29412970    } else {
    2942       VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;
     2971      VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64)Data32 + Index16;
    29432972    }
    29442973  }
    … …  
    29462975  return EFI_SUCCESS;
    29472976}
    2948 
    29492977
    29502978/**
    … …  
    29662994EFI_STATUS
    29672995ExecuteCALL (
    2968   IN VM_CONTEXT *VmPtr
    2969   )
    2970 {
    2971   UINT8 Opcode;
    2972   UINT8 Operands;
    2973   INT32 Immed32;
    2974   UINT8 Size;
    2975   INT64 Immed64;
    2976   VOID  *FramePtr;
     2996  IN VM_CONTEXT  *VmPtr
     2997  )
     2998{
     2999  UINT8  Opcode;
     3000  UINT8  Operands;
     3001  INT32  Immed32;
     3002  UINT8  Size;
     3003  INT64  Immed64;
     3004  VOID   *FramePtr;
    29773005
    29783006  //
    29793007  // Get opcode and operands
    29803008  //
    2981   Opcode    = GETOPCODE (VmPtr);
    2982   Operands  = GETOPERANDS (VmPtr);
     3009  Opcode   = GETOPCODE (VmPtr);
     3010  Operands = GETOPERANDS (VmPtr);
    29833011
    29843012  if ((Operands & OPERAND_M_NATIVE_CALL) != 0) {
    … …  
    29913019  // Assign these as well to avoid compiler warnings
    29923020  //
    2993   Immed64   = 0;
    2994   Immed32   = 0;
    2995 
    2996   FramePtr  = VmPtr->FramePtr;
     3021  Immed64 = 0;
     3022  Immed32 = 0;
     3023
     3024  FramePtr = VmPtr->FramePtr;
    29973025  //
    29983026  // Determine the instruction size, and get immediate data if present
    … …  
    30173045    Size = 2;
    30183046  }
     3047
    30193048  //
    30203049  // If it's a call to EBC, adjust the stack pointer down 16 bytes and
    … …  
    30233052  if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {
    30243053    VmPtr->Gpr[0] -= 8;
    3025     VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
    3026     VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
    3027     VmPtr->Gpr[0] -= 8;
    3028     VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));
    3029   }
     3054    VmWriteMemN (VmPtr, (UINTN)VmPtr->Gpr[0], (UINTN)FramePtr);
     3055    VmPtr->FramePtr = (VOID *)(UINTN)VmPtr->Gpr[0];
     3056    VmPtr->Gpr[0]  -= 8;
     3057    VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[0], (UINT64)(UINTN)(VmPtr->Ip + Size));
     3058  }
     3059
    30303060  //
    30313061  // If 64-bit data, then absolute jump only
    … …  
    30363066    //
    30373067    if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {
    3038       VmPtr->Ip = (VMIP) (UINTN) Immed64;
     3068      VmPtr->Ip = (VMIP)(UINTN)Immed64;
    30393069    } else {
    30403070      //
    30413071      // Call external function, get the return value, and advance the IP
    30423072      //
    3043       EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);
     3073      EbcLLCALLEX (VmPtr, (UINTN)Immed64, (UINTN)VmPtr->Gpr[0], FramePtr, Size);
    30443074    }
    30453075  } else {
    … …  
    30503080    //
    30513081    if (OPERAND1_REGNUM (Operands) != 0) {
    3052       Immed64 = (UINT64) (UINTN) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
    3053     }
     3082      Immed64 = (UINT64)(UINTN)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
     3083    }
     3084
    30543085    //
    30553086    // Get final address
    30563087    //
    30573088    if (OPERAND1_INDIRECT (Operands)) {
    3058       Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32));
     3089      Immed64 = (INT64)(UINT64)(UINTN)VmReadMemN (VmPtr, (UINTN)(Immed64 + Immed32));
    30593090    } else {
    30603091      Immed64 += Immed32;
    30613092    }
     3093
    30623094    //
    30633095    // Now determine if external call, and then if relative or absolute
    … …  
    30713103        VmPtr->Ip += Immed64 + Size;
    30723104      } else {
    3073         VmPtr->Ip = (VMIP) (UINTN) Immed64;
     3105        VmPtr->Ip = (VMIP)(UINTN)Immed64;
    30743106      }
    30753107    } else {
    … …  
    30783110      //
    30793111      if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {
    3080         EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->Gpr[0], FramePtr, Size);
     3112        EbcLLCALLEX (VmPtr, (UINTN)(Immed64 + VmPtr->Ip + Size), (UINTN)VmPtr->Gpr[0], FramePtr, Size);
    30813113      } else {
    30823114        if ((VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) != 0) {
    … …  
    30843116        }
    30853117
    3086         EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);
     3118        EbcLLCALLEX (VmPtr, (UINTN)Immed64, (UINTN)VmPtr->Gpr[0], FramePtr, Size);
    30873119      }
    30883120    }
    … …  
    30983130}
    30993131
    3100 
    31013132/**
    31023133  Execute the EBC RET instruction.
    … …  
    31123143EFI_STATUS
    31133144ExecuteRET (
    3114   IN VM_CONTEXT *VmPtr
    3115   )
    3116 {
    3117 
     3145  IN VM_CONTEXT  *VmPtr
     3146  )
     3147{
    31183148  EbcDebuggerHookRETStart (VmPtr);
    31193149
    … …  
    31223152  // flag and return
    31233153  //
    3124   if (VmPtr->StackRetAddr == (UINT64) VmPtr->Gpr[0]) {
     3154  if (VmPtr->StackRetAddr == (UINT64)VmPtr->Gpr[0]) {
    31253155    VmPtr->StopFlags |= STOPFLAG_APP_DONE;
    31263156  } else {
    … …  
    31293159    // to it
    31303160    //
    3131     if (!IS_ALIGNED ((UINTN) VmPtr->Gpr[0], sizeof (UINT16))) {
     3161    if (!IS_ALIGNED ((UINTN)VmPtr->Gpr[0], sizeof (UINT16))) {
    31323162      EbcDebugSignalException (
    31333163        EXCEPT_EBC_ALIGNMENT_CHECK,
    … …  
    31363166        );
    31373167    }
     3168
    31383169    //
    31393170    // Restore the IP and frame pointer from the stack
    31403171    //
    3141     VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);
    3142     VmPtr->Gpr[0] += 8;
    3143     VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);
    3144     VmPtr->Gpr[0] += 8;
    3145   }
    3146 
     3172    VmPtr->Ip       = (VMIP)(UINTN)VmReadMem64 (VmPtr, (UINTN)VmPtr->Gpr[0]);
     3173    VmPtr->Gpr[0]  += 8;
     3174    VmPtr->FramePtr = (VOID *)VmReadMemN (VmPtr, (UINTN)VmPtr->Gpr[0]);
     3175    VmPtr->Gpr[0]  += 8;
     3176  }
    31473177
    31483178  EbcDebuggerHookRETEnd (VmPtr);
    … …  
    31503180  return EFI_SUCCESS;
    31513181}
    3152 
    31533182
    31543183/**
    … …  
    31663195EFI_STATUS
    31673196ExecuteCMP (
    3168   IN VM_CONTEXT *VmPtr
     3197  IN VM_CONTEXT  *VmPtr
    31693198  )
    31703199{
    … …  
    31803209  // Get opcode and operands
    31813210  //
    3182   Opcode    = GETOPCODE (VmPtr);
    3183   Operands  = GETOPERANDS (VmPtr);
     3211  Opcode   = GETOPCODE (VmPtr);
     3212  Operands = GETOPERANDS (VmPtr);
    31843213  //
    31853214  // Get the register data we're going to compare to
    … …  
    32013230    Size    = 2;
    32023231  }
     3232
    32033233  //
    32043234  // Now get Op2
    … …  
    32063236  if (OPERAND2_INDIRECT (Operands)) {
    32073237    if ((Opcode & OPCODE_M_64BIT) != 0) {
    3208       Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16));
     3238      Op2 = (INT64)VmReadMem64 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16));
    32093239    } else {
    32103240      //
    32113241      // 32-bit operations. 0-extend the values for all cases.
    32123242      //
    3213       Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));
     3243      Op2 = (INT64)(UINT64)((UINT32)VmReadMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));
    32143244    }
    32153245  } else {
    32163246    Op2 = VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;
    32173247  }
     3248
    32183249  //
    32193250  // Now do the compare
    … …  
    32253256    //
    32263257    switch (Opcode & OPCODE_M_OPCODE) {
    3227     case OPCODE_CMPEQ:
    3228       if (Op1 == Op2) {
    3229         Flag = 1;
    3230       }
    3231       break;
    3232 
    3233     case OPCODE_CMPLTE:
    3234       if (Op1 <= Op2) {
    3235         Flag = 1;
    3236       }
    3237       break;
    3238 
    3239     case OPCODE_CMPGTE:
    3240       if (Op1 >= Op2) {
    3241         Flag = 1;
    3242       }
    3243       break;
    3244 
    3245     case OPCODE_CMPULTE:
    3246       if ((UINT64) Op1 <= (UINT64) Op2) {
    3247         Flag = 1;
    3248       }
    3249       break;
    3250 
    3251     case OPCODE_CMPUGTE:
    3252       if ((UINT64) Op1 >= (UINT64) Op2) {
    3253         Flag = 1;
    3254       }
    3255       break;
    3256 
    3257     default:
    3258       ASSERT (0);
     3258      case OPCODE_CMPEQ:
     3259        if (Op1 == Op2) {
     3260          Flag = 1;
     3261        }
     3262
     3263        break;
     3264
     3265      case OPCODE_CMPLTE:
     3266        if (Op1 <= Op2) {
     3267          Flag = 1;
     3268        }
     3269
     3270        break;
     3271
     3272      case OPCODE_CMPGTE:
     3273        if (Op1 >= Op2) {
     3274          Flag = 1;
     3275        }
     3276
     3277        break;
     3278
     3279      case OPCODE_CMPULTE:
     3280        if ((UINT64)Op1 <= (UINT64)Op2) {
     3281          Flag = 1;
     3282        }
     3283
     3284        break;
     3285
     3286      case OPCODE_CMPUGTE:
     3287        if ((UINT64)Op1 >= (UINT64)Op2) {
     3288          Flag = 1;
     3289        }
     3290
     3291        break;
     3292
     3293      default:
     3294        ASSERT (0);
    32593295    }
    32603296  } else {
    … …  
    32633299    //
    32643300    switch (Opcode & OPCODE_M_OPCODE) {
    3265     case OPCODE_CMPEQ:
    3266       if ((INT32) Op1 == (INT32) Op2) {
    3267         Flag = 1;
    3268       }
    3269       break;
    3270 
    3271     case OPCODE_CMPLTE:
    3272       if ((INT32) Op1 <= (INT32) Op2) {
    3273         Flag = 1;
    3274       }
    3275       break;
    3276 
    3277     case OPCODE_CMPGTE:
    3278       if ((INT32) Op1 >= (INT32) Op2) {
    3279         Flag = 1;
    3280       }
    3281       break;
    3282 
    3283     case OPCODE_CMPULTE:
    3284       if ((UINT32) Op1 <= (UINT32) Op2) {
    3285         Flag = 1;
    3286       }
    3287       break;
    3288 
    3289     case OPCODE_CMPUGTE:
    3290       if ((UINT32) Op1 >= (UINT32) Op2) {
    3291         Flag = 1;
    3292       }
    3293       break;
    3294 
    3295     default:
    3296       ASSERT (0);
    3297     }
    3298   }
     3301      case OPCODE_CMPEQ:
     3302        if ((INT32)Op1 == (INT32)Op2) {
     3303          Flag = 1;
     3304        }
     3305
     3306        break;
     3307
     3308      case OPCODE_CMPLTE:
     3309        if ((INT32)Op1 <= (INT32)Op2) {
     3310          Flag = 1;
     3311        }
     3312
     3313        break;
     3314
     3315      case OPCODE_CMPGTE:
     3316        if ((INT32)Op1 >= (INT32)Op2) {
     3317          Flag = 1;
     3318        }
     3319
     3320        break;
     3321
     3322      case OPCODE_CMPULTE:
     3323        if ((UINT32)Op1 <= (UINT32)Op2) {
     3324          Flag = 1;
     3325        }
     3326
     3327        break;
     3328
     3329      case OPCODE_CMPUGTE:
     3330        if ((UINT32)Op1 >= (UINT32)Op2) {
     3331          Flag = 1;
     3332        }
     3333
     3334        break;
     3335
     3336      default:
     3337        ASSERT (0);
     3338    }
     3339  }
     3340
    32993341  //
    33003342  // Now set the flag accordingly for the comparison
    … …  
    33053347    VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);
    33063348  }
     3349
    33073350  //
    33083351  // Advance the IP
    … …  
    33123355}
    33133356
    3314 
    33153357/**
    33163358  Execute the EBC CMPI instruction
    … …  
    33273369EFI_STATUS
    33283370ExecuteCMPI (
    3329   IN VM_CONTEXT *VmPtr
     3371  IN VM_CONTEXT  *VmPtr
    33303372  )
    33313373{
    … …  
    33413383  // Get opcode and operands
    33423384  //
    3343   Opcode    = GETOPCODE (VmPtr);
    3344   Operands  = GETOPERANDS (VmPtr);
     3385  Opcode   = GETOPCODE (VmPtr);
     3386  Operands = GETOPERANDS (VmPtr);
    33453387
    33463388  //
    … …  
    33503392  if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {
    33513393    Index16 = VmReadIndex16 (VmPtr, 2);
    3352     Size += 2;
     3394    Size   += 2;
    33533395  } else {
    33543396    Index16 = 0;
    33553397  }
     3398
    33563399  //
    33573400  // Get operand1 data we're going to compare to
    33583401  //
    3359   Op1 = (INT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
     3402  Op1 = (INT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
    33603403  if (OPERAND1_INDIRECT (Operands)) {
    33613404    //
    … …  
    33633406    //
    33643407    if ((Opcode & OPCODE_M_CMPI64) != 0) {
    3365       Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16);
     3408      Op1 = (INT64)VmReadMem64 (VmPtr, (UINTN)Op1 + Index16);
    33663409    } else {
    3367       Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16);
     3410      Op1 = (INT64)VmReadMem32 (VmPtr, (UINTN)Op1 + Index16);
    33683411    }
    33693412  } else {
    … …  
    33823425    }
    33833426  }
     3427
    33843428  //
    33853429  // Get immediate data -- 16- or 32-bit sign extended
    33863430  //
    33873431  if ((Opcode & OPCODE_M_CMPI32_DATA) != 0) {
    3388     Op2 = (INT64) VmReadImmed32 (VmPtr, Size);
     3432    Op2   = (INT64)VmReadImmed32 (VmPtr, Size);
    33893433    Size += 4;
    33903434  } else {
    … …  
    33923436    // 16-bit immediate data. Sign extend always.
    33933437    //
    3394     Op2 = (INT64) ((INT16) VmReadImmed16 (VmPtr, Size));
     3438    Op2   = (INT64)((INT16)VmReadImmed16 (VmPtr, Size));
    33953439    Size += 2;
    33963440  }
     3441
    33973442  //
    33983443  // Now do the compare
    … …  
    34043449    //
    34053450    switch (Opcode & OPCODE_M_OPCODE) {
    3406     case OPCODE_CMPIEQ:
    3407       if (Op1 == (INT64) Op2) {
    3408         Flag = 1;
    3409       }
    3410       break;
    3411 
    3412     case OPCODE_CMPILTE:
    3413       if (Op1 <= (INT64) Op2) {
    3414         Flag = 1;
    3415       }
    3416       break;
    3417 
    3418     case OPCODE_CMPIGTE:
    3419       if (Op1 >= (INT64) Op2) {
    3420         Flag = 1;
    3421       }
    3422       break;
    3423 
    3424     case OPCODE_CMPIULTE:
    3425       if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) {
    3426         Flag = 1;
    3427       }
    3428       break;
    3429 
    3430     case OPCODE_CMPIUGTE:
    3431       if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) {
    3432         Flag = 1;
    3433       }
    3434       break;
    3435 
    3436     default:
    3437       ASSERT (0);
     3451      case OPCODE_CMPIEQ:
     3452        if (Op1 == (INT64)Op2) {
     3453          Flag = 1;
     3454        }
     3455
     3456        break;
     3457
     3458      case OPCODE_CMPILTE:
     3459        if (Op1 <= (INT64)Op2) {
     3460          Flag = 1;
     3461        }
     3462
     3463        break;
     3464
     3465      case OPCODE_CMPIGTE:
     3466        if (Op1 >= (INT64)Op2) {
     3467          Flag = 1;
     3468        }
     3469
     3470        break;
     3471
     3472      case OPCODE_CMPIULTE:
     3473        if ((UINT64)Op1 <= (UINT64)((UINT32)Op2)) {
     3474          Flag = 1;
     3475        }
     3476
     3477        break;
     3478
     3479      case OPCODE_CMPIUGTE:
     3480        if ((UINT64)Op1 >= (UINT64)((UINT32)Op2)) {
     3481          Flag = 1;
     3482        }
     3483
     3484        break;
     3485
     3486      default:
     3487        ASSERT (0);
    34383488    }
    34393489  } else {
    … …  
    34423492    //
    34433493    switch (Opcode & OPCODE_M_OPCODE) {
    3444     case OPCODE_CMPIEQ:
    3445       if ((INT32) Op1 == Op2) {
    3446         Flag = 1;
    3447       }
    3448       break;
    3449 
    3450     case OPCODE_CMPILTE:
    3451       if ((INT32) Op1 <= Op2) {
    3452         Flag = 1;
    3453       }
    3454       break;
    3455 
    3456     case OPCODE_CMPIGTE:
    3457       if ((INT32) Op1 >= Op2) {
    3458         Flag = 1;
    3459       }
    3460       break;
    3461 
    3462     case OPCODE_CMPIULTE:
    3463       if ((UINT32) Op1 <= (UINT32) Op2) {
    3464         Flag = 1;
    3465       }
    3466       break;
    3467 
    3468     case OPCODE_CMPIUGTE:
    3469       if ((UINT32) Op1 >= (UINT32) Op2) {
    3470         Flag = 1;
    3471       }
    3472       break;
    3473 
    3474     default:
    3475       ASSERT (0);
    3476     }
    3477   }
     3494      case OPCODE_CMPIEQ:
     3495        if ((INT32)Op1 == Op2) {
     3496          Flag = 1;
     3497        }
     3498
     3499        break;
     3500
     3501      case OPCODE_CMPILTE:
     3502        if ((INT32)Op1 <= Op2) {
     3503          Flag = 1;
     3504        }
     3505
     3506        break;
     3507
     3508      case OPCODE_CMPIGTE:
     3509        if ((INT32)Op1 >= Op2) {
     3510          Flag = 1;
     3511        }
     3512
     3513        break;
     3514
     3515      case OPCODE_CMPIULTE:
     3516        if ((UINT32)Op1 <= (UINT32)Op2) {
     3517          Flag = 1;
     3518        }
     3519
     3520        break;
     3521
     3522      case OPCODE_CMPIUGTE:
     3523        if ((UINT32)Op1 >= (UINT32)Op2) {
     3524          Flag = 1;
     3525        }
     3526
     3527        break;
     3528
     3529      default:
     3530        ASSERT (0);
     3531    }
     3532  }
     3533
    34783534  //
    34793535  // Now set the flag accordingly for the comparison
    … …  
    34843540    VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);
    34853541  }
     3542
    34863543  //
    34873544  // Advance the IP
    … …  
    34913548}
    34923549
    3493 
    34943550/**
    34953551  Execute the EBC NOT instruction.s
    … …  
    35073563UINT64
    35083564ExecuteNOT (
    3509   IN VM_CONTEXT     *VmPtr,
    3510   IN UINT64         Op1,
    3511   IN UINT64         Op2
     3565  IN VM_CONTEXT  *VmPtr,
     3566  IN UINT64      Op1,
     3567  IN UINT64      Op2
    35123568  )
    35133569{
    35143570  return ~Op2;
    35153571}
    3516 
    35173572
    35183573/**
    … …  
    35313586UINT64
    35323587ExecuteNEG (
    3533   IN VM_CONTEXT   *VmPtr,
    3534   IN UINT64       Op1,
    3535   IN UINT64       Op2
     3588  IN VM_CONTEXT  *VmPtr,
     3589  IN UINT64      Op1,
     3590  IN UINT64      Op2
    35363591  )
    35373592{
    35383593  return ~Op2 + 1;
    35393594}
    3540 
    35413595
    35423596/**
    … …  
    35553609UINT64
    35563610ExecuteADD (
    3557   IN VM_CONTEXT   *VmPtr,
    3558   IN UINT64       Op1,
    3559   IN UINT64       Op2
     3611  IN VM_CONTEXT  *VmPtr,
     3612  IN UINT64      Op1,
     3613  IN UINT64      Op2
    35603614  )
    35613615{
    35623616  return Op1 + Op2;
    35633617}
    3564 
    35653618
    35663619/**
    … …  
    35793632UINT64
    35803633ExecuteSUB (
    3581   IN VM_CONTEXT   *VmPtr,
    3582   IN UINT64       Op1,
    3583   IN UINT64       Op2
     3634  IN VM_CONTEXT  *VmPtr,
     3635  IN UINT64      Op1,
     3636  IN UINT64      Op2
    35843637  )
    35853638{
    35863639  if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
    3587     return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2));
    3588   } else {
    3589     return (UINT64) ((INT64) ((INT32) ((INT32) Op1 - (INT32) Op2)));
    3590   }
    3591 }
    3592 
     3640    return (UINT64)((INT64)((INT64)Op1 - (INT64)Op2));
     3641  } else {
     3642    return (UINT64)((INT64)((INT32)((INT32)Op1 - (INT32)Op2)));
     3643  }
     3644}
    35933645
    35943646/**
    … …  
    36073659UINT64
    36083660ExecuteMUL (
    3609   IN VM_CONTEXT   *VmPtr,
    3610   IN UINT64       Op1,
    3611   IN UINT64       Op2
     3661  IN VM_CONTEXT  *VmPtr,
     3662  IN UINT64      Op1,
     3663  IN UINT64      Op2
    36123664  )
    36133665{
    … …  
    36153667    return MultS64x64 ((INT64)Op1, (INT64)Op2);
    36163668  } else {
    3617     return (UINT64) ((INT64) ((INT32) ((INT32) Op1 * (INT32) Op2)));
    3618   }
    3619 }
    3620 
     3669    return (UINT64)((INT64)((INT32)((INT32)Op1 * (INT32)Op2)));
     3670  }
     3671}
    36213672
    36223673/**
    … …  
    36353686UINT64
    36363687ExecuteMULU (
    3637   IN VM_CONTEXT   *VmPtr,
    3638   IN UINT64       Op1,
    3639   IN UINT64       Op2
     3688  IN VM_CONTEXT  *VmPtr,
     3689  IN UINT64      Op1,
     3690  IN UINT64      Op2
    36403691  )
    36413692{
    … …  
    36433694    return MultU64x64 (Op1, Op2);
    36443695  } else {
    3645     return (UINT64) ((UINT32) ((UINT32) Op1 * (UINT32) Op2));
    3646   }
    3647 }
    3648 
     3696    return (UINT64)((UINT32)((UINT32)Op1 * (UINT32)Op2));
     3697  }
     3698}
    36493699
    36503700/**
    … …  
    36633713UINT64
    36643714ExecuteDIV (
    3665   IN VM_CONTEXT   *VmPtr,
    3666   IN UINT64       Op1,
    3667   IN UINT64       Op2
    3668   )
    3669 {
    3670   INT64   Remainder;
     3715  IN VM_CONTEXT  *VmPtr,
     3716  IN UINT64      Op1,
     3717  IN UINT64      Op2
     3718  )
     3719{
     3720  INT64  Remainder;
    36713721
    36723722  //
    … …  
    36833733  } else {
    36843734    if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
    3685       return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder));
     3735      return (UINT64)(DivS64x64Remainder (Op1, Op2, &Remainder));
    36863736    } else {
    3687       return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2));
    3688     }
    3689   }
    3690 }
    3691 
     3737      return (UINT64)((INT64)((INT32)Op1 / (INT32)Op2));
     3738    }
     3739  }
     3740}
    36923741
    36933742/**
    … …  
    37063755UINT64
    37073756ExecuteDIVU (
    3708   IN VM_CONTEXT   *VmPtr,
    3709   IN UINT64       Op1,
    3710   IN UINT64       Op2
     3757  IN VM_CONTEXT  *VmPtr,
     3758  IN UINT64      Op1,
     3759  IN UINT64      Op2
    37113760  )
    37123761{
    … …  
    37283777    //
    37293778    if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
    3730       return (UINT64) (DivU64x64Remainder (Op1, Op2, &Remainder));
     3779      return (UINT64)(DivU64x64Remainder (Op1, Op2, &Remainder));
    37313780    } else {
    3732       return (UINT64) ((UINT32) Op1 / (UINT32) Op2);
    3733     }
    3734   }
    3735 }
    3736 
     3781      return (UINT64)((UINT32)Op1 / (UINT32)Op2);
     3782    }
     3783  }
     3784}
    37373785
    37383786/**
    … …  
    37513799UINT64
    37523800ExecuteMOD (
    3753   IN VM_CONTEXT   *VmPtr,
    3754   IN UINT64       Op1,
    3755   IN UINT64       Op2
    3756   )
    3757 {
    3758   INT64   Remainder;
     3801  IN VM_CONTEXT  *VmPtr,
     3802  IN UINT64      Op1,
     3803  IN UINT64      Op2
     3804  )
     3805{
     3806  INT64  Remainder;
    37593807
    37603808  //
    … …  
    37743822}
    37753823
    3776 
    37773824/**
    37783825  Execute the EBC MODU instruction.
    … …  
    37903837UINT64
    37913838ExecuteMODU (
    3792   IN VM_CONTEXT   *VmPtr,
    3793   IN UINT64       Op1,
    3794   IN UINT64       Op2
     3839  IN VM_CONTEXT  *VmPtr,
     3840  IN UINT64      Op1,
     3841  IN UINT64      Op2
    37953842  )
    37963843{
    … …  
    38133860}
    38143861
    3815 
    38163862/**
    38173863  Execute the EBC AND instruction.
    … …  
    38293875UINT64
    38303876ExecuteAND (
    3831   IN VM_CONTEXT   *VmPtr,
    3832   IN UINT64       Op1,
    3833   IN UINT64       Op2
     3877  IN VM_CONTEXT  *VmPtr,
     3878  IN UINT64      Op1,
     3879  IN UINT64      Op2
    38343880  )
    38353881{
    38363882  return Op1 & Op2;
    38373883}
    3838 
    38393884
    38403885/**
    … …  
    38533898UINT64
    38543899ExecuteOR (
    3855   IN VM_CONTEXT   *VmPtr,
    3856   IN UINT64       Op1,
    3857   IN UINT64       Op2
     3900  IN VM_CONTEXT  *VmPtr,
     3901  IN UINT64      Op1,
     3902  IN UINT64      Op2
    38583903  )
    38593904{
    38603905  return Op1 | Op2;
    38613906}
    3862 
    38633907
    38643908/**
    … …  
    38773921UINT64
    38783922ExecuteXOR (
    3879   IN VM_CONTEXT   *VmPtr,
    3880   IN UINT64       Op1,
    3881   IN UINT64       Op2
     3923  IN VM_CONTEXT  *VmPtr,
     3924  IN UINT64      Op1,
     3925  IN UINT64      Op2
    38823926  )
    38833927{
    38843928  return Op1 ^ Op2;
    38853929}
    3886 
    38873930
    38883931/**
    … …  
    39013944UINT64
    39023945ExecuteSHL (
    3903   IN VM_CONTEXT   *VmPtr,
    3904   IN UINT64       Op1,
    3905   IN UINT64       Op2
     3946  IN VM_CONTEXT  *VmPtr,
     3947  IN UINT64      Op1,
     3948  IN UINT64      Op2
    39063949  )
    39073950{
    … …  
    39093952    return LShiftU64 (Op1, (UINTN)Op2);
    39103953  } else {
    3911     return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2));
    3912   }
    3913 }
    3914 
     3954    return (UINT64)((UINT32)((UINT32)Op1 << (UINT32)Op2));
     3955  }
     3956}
    39153957
    39163958/**
    … …  
    39293971UINT64
    39303972ExecuteSHR (
    3931   IN VM_CONTEXT   *VmPtr,
    3932   IN UINT64       Op1,
    3933   IN UINT64       Op2
     3973  IN VM_CONTEXT  *VmPtr,
     3974  IN UINT64      Op1,
     3975  IN UINT64      Op2
    39343976  )
    39353977{
    … …  
    39373979    return RShiftU64 (Op1, (UINTN)Op2);
    39383980  } else {
    3939     return (UINT64) ((UINT32) Op1 >> (UINT32) Op2);
    3940   }
    3941 }
    3942 
     3981    return (UINT64)((UINT32)Op1 >> (UINT32)Op2);
     3982  }
     3983}
    39433984
    39443985/**
    … …  
    39573998UINT64
    39583999ExecuteASHR (
    3959   IN VM_CONTEXT   *VmPtr,
    3960   IN UINT64       Op1,
    3961   IN UINT64       Op2
     4000  IN VM_CONTEXT  *VmPtr,
     4001  IN UINT64      Op1,
     4002  IN UINT64      Op2
    39624003  )
    39634004{
    … …  
    39654006    return ARShiftU64 (Op1, (UINTN)Op2);
    39664007  } else {
    3967     return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2));
    3968   }
    3969 }
    3970 
     4008    return (UINT64)((INT64)((INT32)Op1 >> (UINT32)Op2));
     4009  }
     4010}
    39714011
    39724012/**
    … …  
    39854025UINT64
    39864026ExecuteEXTNDB (
    3987   IN VM_CONTEXT   *VmPtr,
    3988   IN UINT64       Op1,
    3989   IN UINT64       Op2
    3990   )
    3991 {
    3992   INT8  Data8;
    3993   INT64 Data64;
     4027  IN VM_CONTEXT  *VmPtr,
     4028  IN UINT64      Op1,
     4029  IN UINT64      Op2
     4030  )
     4031{
     4032  INT8   Data8;
     4033  INT64  Data64;
     4034
    39944035  //
    39954036  // Convert to byte, then return as 64-bit signed value to let compiler
    39964037  // sign-extend the value
    39974038  //
    3998   Data8   = (INT8) Op2;
    3999   Data64  = (INT64) Data8;
    4000 
    4001   return (UINT64) Data64;
    4002 }
    4003 
     4039  Data8  = (INT8)Op2;
     4040  Data64 = (INT64)Data8;
     4041
     4042  return (UINT64)Data64;
     4043}
    40044044
    40054045/**
    … …  
    40184058UINT64
    40194059ExecuteEXTNDW (
    4020   IN VM_CONTEXT   *VmPtr,
    4021   IN UINT64       Op1,
    4022   IN UINT64       Op2
    4023   )
    4024 {
    4025   INT16 Data16;
    4026   INT64 Data64;
     4060  IN VM_CONTEXT  *VmPtr,
     4061  IN UINT64      Op1,
     4062  IN UINT64      Op2
     4063  )
     4064{
     4065  INT16  Data16;
     4066  INT64  Data64;
     4067
    40274068  //
    40284069  // Convert to word, then return as 64-bit signed value to let compiler
    40294070  // sign-extend the value
    40304071  //
    4031   Data16  = (INT16) Op2;
    4032   Data64  = (INT64) Data16;
    4033 
    4034   return (UINT64) Data64;
    4035 }
     4072  Data16 = (INT16)Op2;
     4073  Data64 = (INT64)Data16;
     4074
     4075  return (UINT64)Data64;
     4076}
     4077
    40364078//
    40374079// Execute the EBC EXTNDD instruction.
    … …  
    40584100UINT64
    40594101ExecuteEXTNDD (
    4060   IN VM_CONTEXT   *VmPtr,
    4061   IN UINT64       Op1,
    4062   IN UINT64       Op2
    4063   )
    4064 {
    4065   INT32 Data32;
    4066   INT64 Data64;
     4102  IN VM_CONTEXT  *VmPtr,
     4103  IN UINT64      Op1,
     4104  IN UINT64      Op2
     4105  )
     4106{
     4107  INT32  Data32;
     4108  INT64  Data64;
     4109
    40674110  //
    40684111  // Convert to 32-bit value, then return as 64-bit signed value to let compiler
    40694112  // sign-extend the value
    40704113  //
    4071   Data32  = (INT32) Op2;
    4072   Data64  = (INT64) Data32;
    4073 
    4074   return (UINT64) Data64;
    4075 }
    4076 
     4114  Data32 = (INT32)Op2;
     4115  Data64 = (INT64)Data32;
     4116
     4117  return (UINT64)Data64;
     4118}
    40774119
    40784120/**
    … …  
    40954137EFI_STATUS
    40964138ExecuteSignedDataManip (
    4097   IN VM_CONTEXT   *VmPtr
     4139  IN VM_CONTEXT  *VmPtr
    40984140  )
    40994141{
    … …  
    41044146  return ExecuteDataManip (VmPtr, TRUE);
    41054147}
    4106 
    41074148
    41084149/**
    … …  
    41254166EFI_STATUS
    41264167ExecuteUnsignedDataManip (
    4127   IN VM_CONTEXT   *VmPtr
     4168  IN VM_CONTEXT  *VmPtr
    41284169  )
    41294170{
    … …  
    41344175  return ExecuteDataManip (VmPtr, FALSE);
    41354176}
    4136 
    41374177
    41384178/**
    … …  
    41564196EFI_STATUS
    41574197ExecuteDataManip (
    4158   IN VM_CONTEXT   *VmPtr,
    4159   IN BOOLEAN      IsSignedOp
     4198  IN VM_CONTEXT  *VmPtr,
     4199  IN BOOLEAN     IsSignedOp
    41604200  )
    41614201{
    … …  
    41714211  // Get opcode and operands
    41724212  //
    4173   Opcode    = GETOPCODE (VmPtr);
    4174   Operands  = GETOPERANDS (VmPtr);
     4213  Opcode   = GETOPCODE (VmPtr);
     4214  Operands = GETOPERANDS (VmPtr);
    41754215
    41764216  //
    … …  
    41924232    Size    = 2;
    41934233  }
     4234
    41944235  //
    41954236  // Now get operand2 (source). It's of format {@}R2 {Index16|Immed16}
    41964237  //
    4197   Op2 = (UINT64) VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;
     4238  Op2 = (UINT64)VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;
    41984239  if (OPERAND2_INDIRECT (Operands)) {
    41994240    //
    … …  
    42014242    //
    42024243    if ((Opcode & DATAMANIP_M_64) != 0) {
    4203       Op2 = VmReadMem64 (VmPtr, (UINTN) Op2);
     4244      Op2 = VmReadMem64 (VmPtr, (UINTN)Op2);
    42044245    } else {
    42054246      //
    … …  
    42074248      //
    42084249      if (IsSignedOp) {
    4209         Op2 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op2));
     4250        Op2 = (UINT64)(INT64)((INT32)VmReadMem32 (VmPtr, (UINTN)Op2));
    42104251      } else {
    4211         Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2);
     4252        Op2 = (UINT64)VmReadMem32 (VmPtr, (UINTN)Op2);
    42124253      }
    42134254    }
    … …  
    42154256    if ((Opcode & DATAMANIP_M_64) == 0) {
    42164257      if (IsSignedOp) {
    4217         Op2 = (UINT64) (INT64) ((INT32) Op2);
     4258        Op2 = (UINT64)(INT64)((INT32)Op2);
    42184259      } else {
    4219         Op2 = (UINT64) ((UINT32) Op2);
     4260        Op2 = (UINT64)((UINT32)Op2);
    42204261      }
    42214262    }
    42224263  }
     4264
    42234265  //
    42244266  // Get operand1 (destination and sometimes also an actual operand)
    42254267  // of form {@}R1
    42264268  //
    4227   Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
     4269  Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
    42284270  if (OPERAND1_INDIRECT (Operands)) {
    42294271    if ((Opcode & DATAMANIP_M_64) != 0) {
    4230       Op1 = VmReadMem64 (VmPtr, (UINTN) Op1);
     4272      Op1 = VmReadMem64 (VmPtr, (UINTN)Op1);
    42314273    } else {
    42324274      if (IsSignedOp) {
    4233         Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1));
     4275        Op1 = (UINT64)(INT64)((INT32)VmReadMem32 (VmPtr, (UINTN)Op1));
    42344276      } else {
    4235         Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1);
     4277        Op1 = (UINT64)VmReadMem32 (VmPtr, (UINTN)Op1);
    42364278      }
    42374279    }
    … …  
    42394281    if ((Opcode & DATAMANIP_M_64) == 0) {
    42404282      if (IsSignedOp) {
    4241         Op1 = (UINT64) (INT64) ((INT32) Op1);
     4283        Op1 = (UINT64)(INT64)((INT32)Op1);
    42424284      } else {
    4243         Op1 = (UINT64) ((UINT32) Op1);
     4285        Op1 = (UINT64)((UINT32)Op1);
    42444286      }
    42454287    }
    42464288  }
     4289
    42474290  //
    42484291  // Dispatch to the computation function
    … …  
    42504293  DataManipDispatchTableIndex = (Opcode & OPCODE_M_OPCODE) - OPCODE_NOT;
    42514294  if ((DataManipDispatchTableIndex < 0) ||
    4252       (DataManipDispatchTableIndex >= ARRAY_SIZE (mDataManipDispatchTable))) {
     4295      (DataManipDispatchTableIndex >= ARRAY_SIZE (mDataManipDispatchTable)))
     4296  {
    42534297    EbcDebugSignalException (
    42544298      EXCEPT_EBC_INVALID_OPCODE,
    … …  
    42644308    Op2 = mDataManipDispatchTable[DataManipDispatchTableIndex](VmPtr, Op1, Op2);
    42654309  }
     4310
    42664311  //
    42674312  // Write back the result.
    42684313  //
    42694314  if (OPERAND1_INDIRECT (Operands)) {
    4270     Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
     4315    Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
    42714316    if ((Opcode & DATAMANIP_M_64) != 0) {
    4272       VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);
     4317      VmWriteMem64 (VmPtr, (UINTN)Op1, Op2);
    42734318    } else {
    4274       VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);
     4319      VmWriteMem32 (VmPtr, (UINTN)Op1, (UINT32)Op2);
    42754320    }
    42764321  } else {
    … …  
    42844329    }
    42854330  }
     4331
    42864332  //
    42874333  // Advance the instruction pointer
    … …  
    42914337}
    42924338
    4293 
    42944339/**
    42954340  Execute the EBC LOADSP instruction.
    … …  
    43064351EFI_STATUS
    43074352ExecuteLOADSP (
    4308   IN VM_CONTEXT *VmPtr
    4309   )
    4310 {
    4311   UINT8 Operands;
     4353  IN VM_CONTEXT  *VmPtr
     4354  )
     4355{
     4356  UINT8  Operands;
    43124357
    43134358  //
    … …  
    43204365  //
    43214366  switch (OPERAND1_REGNUM (Operands)) {
    4322   //
    4323   // Set flags
    4324   //
    4325   case 0:
    4326     //
    4327     // Spec states that this instruction will not modify reserved bits in
    4328     // the flags register.
    4329     //
    4330     VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);
    4331     break;
    4332 
    4333   default:
    4334     EbcDebugSignalException (
    4335       EXCEPT_EBC_INSTRUCTION_ENCODING,
    4336       EXCEPTION_FLAG_WARNING,
    4337       VmPtr
    4338       );
    4339     VmPtr->Ip += 2;
    4340     return EFI_UNSUPPORTED;
     4367    //
     4368    // Set flags
     4369    //
     4370    case 0:
     4371      //
     4372      // Spec states that this instruction will not modify reserved bits in
     4373      // the flags register.
     4374      //
     4375      VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);
     4376      break;
     4377
     4378    default:
     4379      EbcDebugSignalException (
     4380        EXCEPT_EBC_INSTRUCTION_ENCODING,
     4381        EXCEPTION_FLAG_WARNING,
     4382        VmPtr
     4383        );
     4384      VmPtr->Ip += 2;
     4385      return EFI_UNSUPPORTED;
    43414386  }
    43424387
    … …  
    43454390}
    43464391
    4347 
    43484392/**
    43494393  Execute the EBC STORESP instruction.
    … …  
    43604404EFI_STATUS
    43614405ExecuteSTORESP (
    4362   IN VM_CONTEXT *VmPtr
    4363   )
    4364 {
    4365   UINT8 Operands;
     4406  IN VM_CONTEXT  *VmPtr
     4407  )
     4408{
     4409  UINT8  Operands;
    43664410
    43674411  //
    … …  
    43744418  //
    43754419  switch (OPERAND2_REGNUM (Operands)) {
    4376   //
    4377   // Get flags
    4378   //
    4379   case 0:
    4380     //
    4381     // Retrieve the value in the flags register, then clear reserved bits
    4382     //
    4383     VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID);
    4384     break;
    4385 
    4386   //
    4387   // Get IP -- address of following instruction
    4388   //
    4389   case 1:
    4390     VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;
    4391     break;
    4392 
    4393   default:
    4394     EbcDebugSignalException (
    4395       EXCEPT_EBC_INSTRUCTION_ENCODING,
    4396       EXCEPTION_FLAG_WARNING,
    4397       VmPtr
    4398       );
    4399     VmPtr->Ip += 2;
    4400     return EFI_UNSUPPORTED;
    4401     break;
     4420    //
     4421    // Get flags
     4422    //
     4423    case 0:
     4424      //
     4425      // Retrieve the value in the flags register, then clear reserved bits
     4426      //
     4427      VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64)(VmPtr->Flags & VMFLAGS_ALL_VALID);
     4428      break;
     4429
     4430    //
     4431    // Get IP -- address of following instruction
     4432    //
     4433    case 1:
     4434      VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64)(UINTN)VmPtr->Ip + 2;
     4435      break;
     4436
     4437    default:
     4438      EbcDebugSignalException (
     4439        EXCEPT_EBC_INSTRUCTION_ENCODING,
     4440        EXCEPTION_FLAG_WARNING,
     4441        VmPtr
     4442        );
     4443      VmPtr->Ip += 2;
     4444      return EFI_UNSUPPORTED;
     4445      break;
    44024446  }
    44034447
    … …  
    44054449  return EFI_SUCCESS;
    44064450}
    4407 
    44084451
    44094452/**
    … …  
    44314474INT16
    44324475VmReadIndex16 (
    4433   IN VM_CONTEXT     *VmPtr,
    4434   IN UINT32         CodeOffset
     4476  IN VM_CONTEXT  *VmPtr,
     4477  IN UINT32      CodeOffset
    44354478  )
    44364479{
    … …  
    44504493  // Get the mask for NaturalUnits. First get the number of bits from the index.
    44514494  //
    4452   NBits = (INT16) ((Index & 0x7000) >> 12);
     4495  NBits = (INT16)((Index & 0x7000) >> 12);
    44534496
    44544497  //
    … …  
    44604503  // Now using the number of bits, create a mask.
    44614504  //
    4462   Mask = (INT16) ((INT16)~0 << NBits);
     4505  Mask = (INT16)((INT16) ~0 << NBits);
    44634506
    44644507  //
    44654508  // Now using the mask, extract NaturalUnits from the lower bits of the index.
    44664509  //
    4467   NaturalUnits = (INT16) (Index &~Mask);
     4510  NaturalUnits = (INT16)(Index &~Mask);
    44684511
    44694512  //
    44704513  // Now compute ConstUnits
    44714514  //
    4472   ConstUnits       = (INT16) (((Index &~0xF000) & Mask) >> NBits);
    4473 
    4474   Offset  = (INT16) (NaturalUnits * sizeof (UINTN) + ConstUnits);
     4515  ConstUnits = (INT16)(((Index &~0xF000) & Mask) >> NBits);
     4516
     4517  Offset = (INT16)(NaturalUnits * sizeof (UINTN) + ConstUnits);
    44754518
    44764519  //
    … …  
    44834526    // Offset = -1 * Offset;
    44844527    //
    4485     Offset = (INT16) ((INT32) Offset * -1);
     4528    Offset = (INT16)((INT32)Offset * -1);
    44864529  }
    44874530
    44884531  return Offset;
    44894532}
    4490 
    44914533
    44924534/**
    … …  
    45024544INT32
    45034545VmReadIndex32 (
    4504   IN VM_CONTEXT     *VmPtr,
    4505   IN UINT32         CodeOffset
     4546  IN VM_CONTEXT  *VmPtr,
     4547  IN UINT32      CodeOffset
    45064548  )
    45074549{
    … …  
    45284570  // Now using the number of bits, create a mask.
    45294571  //
    4530   Mask = (INT32)~0 << NBits;
     4572  Mask = (INT32) ~0 << NBits;
    45314573
    45324574  //
    … …  
    45384580  // Now compute ConstUnits
    45394581  //
    4540   ConstUnits       = ((Index &~0xF0000000) & Mask) >> NBits;
    4541 
    4542   Offset  = NaturalUnits * sizeof (UINTN) + ConstUnits;
     4582  ConstUnits = ((Index &~0xF0000000) & Mask) >> NBits;
     4583
     4584  Offset = NaturalUnits * sizeof (UINTN) + ConstUnits;
    45434585
    45444586  //
    … …  
    45514593  return Offset;
    45524594}
    4553 
    45544595
    45554596/**
    … …  
    45654606INT64
    45664607VmReadIndex64 (
    4567   IN VM_CONTEXT     *VmPtr,
    4568   IN UINT32         CodeOffset
     4608  IN VM_CONTEXT  *VmPtr,
     4609  IN UINT32      CodeOffset
    45694610  )
    45704611{
    … …  
    45914632  // Now using the number of bits, create a mask.
    45924633  //
    4593   Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits));
     4634  Mask = (LShiftU64 ((UINT64) ~0, (UINTN)NBits));
    45944635
    45954636  //
    … …  
    46034644  ConstUnits = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits);
    46044645
    4605   Offset  = MultU64x64 ((UINT64) NaturalUnits, sizeof (UINTN)) + ConstUnits;
     4646  Offset = MultU64x64 ((UINT64)NaturalUnits, sizeof (UINTN)) + ConstUnits;
    46064647
    46074648  //
    … …  
    46144655  return Offset;
    46154656}
    4616 
    46174657
    46184658/**
    … …  
    46414681EFI_STATUS
    46424682VmWriteMem8 (
    4643   IN VM_CONTEXT    *VmPtr,
    4644   IN UINTN         Addr,
    4645   IN UINT8         Data
     4683  IN VM_CONTEXT  *VmPtr,
     4684  IN UINTN       Addr,
     4685  IN UINT8       Data
    46464686  )
    46474687{
    … …  
    46494689  // Convert the address if it's in the stack gap
    46504690  //
    4651   Addr            = ConvertStackAddr (VmPtr, Addr);
    4652   *(UINT8 *) Addr = Data;
     4691  Addr           = ConvertStackAddr (VmPtr, Addr);
     4692  *(UINT8 *)Addr = Data;
    46534693  return EFI_SUCCESS;
    46544694}
    … …  
    46794719EFI_STATUS
    46804720VmWriteMem16 (
    4681   IN VM_CONTEXT   *VmPtr,
    4682   IN UINTN        Addr,
    4683   IN UINT16       Data
     4721  IN VM_CONTEXT  *VmPtr,
     4722  IN UINTN       Addr,
     4723  IN UINT16      Data
    46844724  )
    46854725{
    … …  
    46954735  //
    46964736  if (IS_ALIGNED (Addr, sizeof (UINT16))) {
    4697     *(UINT16 *) Addr = Data;
     4737    *(UINT16 *)Addr = Data;
    46984738  } else {
    46994739    //
    … …  
    47014741    //
    47024742    MemoryFence ();
    4703     if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8) Data)) != EFI_SUCCESS) {
     4743    if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8)Data)) != EFI_SUCCESS) {
    47044744      return Status;
    47054745    }
    47064746
    47074747    MemoryFence ();
    4708     if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8) (Data >> 8))) != EFI_SUCCESS) {
     4748    if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8)(Data >> 8))) != EFI_SUCCESS) {
    47094749      return Status;
    47104750    }
    … …  
    47154755  return EFI_SUCCESS;
    47164756}
    4717 
    47184757
    47194758/**
    … …  
    47424781EFI_STATUS
    47434782VmWriteMem32 (
    4744   IN VM_CONTEXT   *VmPtr,
    4745   IN UINTN        Addr,
    4746   IN UINT32       Data
     4783  IN VM_CONTEXT  *VmPtr,
     4784  IN UINTN       Addr,
     4785  IN UINT32      Data
    47474786  )
    47484787{
    … …  
    47584797  //
    47594798  if (IS_ALIGNED (Addr, sizeof (UINT32))) {
    4760     *(UINT32 *) Addr = Data;
     4799    *(UINT32 *)Addr = Data;
    47614800  } else {
    47624801    //
    … …  
    47644803    //
    47654804    MemoryFence ();
    4766     if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16) Data)) != EFI_SUCCESS) {
     4805    if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16)Data)) != EFI_SUCCESS) {
    47674806      return Status;
    47684807    }
    47694808
    47704809    MemoryFence ();
    4771     if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16) (Data >> 16))) != EFI_SUCCESS) {
     4810    if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16)(Data >> 16))) != EFI_SUCCESS) {
    47724811      return Status;
    47734812    }
    … …  
    47784817  return EFI_SUCCESS;
    47794818}
    4780 
    47814819
    47824820/**
    … …  
    48054843EFI_STATUS
    48064844VmWriteMem64 (
    4807   IN VM_CONTEXT   *VmPtr,
    4808   IN UINTN        Addr,
    4809   IN UINT64       Data
     4845  IN VM_CONTEXT  *VmPtr,
     4846  IN UINTN       Addr,
     4847  IN UINT64      Data
    48104848  )
    48114849{
    … …  
    48214859  //
    48224860  if (IS_ALIGNED (Addr, sizeof (UINT64))) {
    4823     *(UINT64 *) Addr = Data;
     4861    *(UINT64 *)Addr = Data;
    48244862  } else {
    48254863    //
    … …  
    48274865    //
    48284866    MemoryFence ();
    4829     if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32) Data)) != EFI_SUCCESS) {
     4867    if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32)Data)) != EFI_SUCCESS) {
    48304868      return Status;
    48314869    }
    48324870
    48334871    MemoryFence ();
    4834     if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32) RShiftU64(Data, 32))) != EFI_SUCCESS) {
     4872    if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32)RShiftU64 (Data, 32))) != EFI_SUCCESS) {
    48354873      return Status;
    48364874    }
    … …  
    48414879  return EFI_SUCCESS;
    48424880}
    4843 
    48444881
    48454882/**
    … …  
    48684905EFI_STATUS
    48694906VmWriteMemN (
    4870   IN VM_CONTEXT   *VmPtr,
    4871   IN UINTN        Addr,
    4872   IN UINTN        Data
     4907  IN VM_CONTEXT  *VmPtr,
     4908  IN UINTN       Addr,
     4909  IN UINTN       Data
    48734910  )
    48744911{
    … …  
    48874924  //
    48884925  if (IS_ALIGNED (Addr, sizeof (UINTN))) {
    4889     *(UINTN *) Addr = Data;
     4926    *(UINTN *)Addr = Data;
    48904927  } else {
    48914928    for (Index = 0; Index < sizeof (UINTN) / sizeof (UINT32); Index++) {
    48924929      MemoryFence ();
    4893       Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32) Data);
     4930      Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32)Data);
    48944931      MemoryFence ();
    4895       Data = (UINTN) RShiftU64 ((UINT64)Data, 32);
     4932      Data = (UINTN)RShiftU64 ((UINT64)Data, 32);
    48964933    }
    48974934  }
    … …  
    48994936  return Status;
    49004937}
    4901 
    49024938
    49034939/**
    … …  
    49174953INT8
    49184954VmReadImmed8 (
    4919   IN VM_CONTEXT *VmPtr,
    4920   IN UINT32     Offset
     4955  IN VM_CONTEXT  *VmPtr,
     4956  IN UINT32      Offset
    49214957  )
    49224958{
    … …  
    49244960  // Simply return the data in flat memory space
    49254961  //
    4926   return * (INT8 *) (VmPtr->Ip + Offset);
     4962  return *(INT8 *)(VmPtr->Ip + Offset);
    49274963}
    49284964
    … …  
    49434979INT16
    49444980VmReadImmed16 (
    4945   IN VM_CONTEXT *VmPtr,
    4946   IN UINT32     Offset
     4981  IN VM_CONTEXT  *VmPtr,
     4982  IN UINT32      Offset
    49474983  )
    49484984{
    … …  
    49504986  // Read direct if aligned
    49514987  //
    4952   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (INT16))) {
    4953     return * (INT16 *) (VmPtr->Ip + Offset);
     4988  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (INT16))) {
     4989    return *(INT16 *)(VmPtr->Ip + Offset);
    49544990  } else {
    49554991    //
    … …  
    49624998      );
    49634999  }
     5000
    49645001  //
    49655002  // Return unaligned data
    49665003  //
    4967   return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));
    4968 }
    4969 
     5004  return (INT16)(*(UINT8 *)(VmPtr->Ip + Offset) + (*(UINT8 *)(VmPtr->Ip + Offset + 1) << 8));
     5005}
    49705006
    49715007/**
    … …  
    49855021INT32
    49865022VmReadImmed32 (
    4987   IN VM_CONTEXT *VmPtr,
    4988   IN UINT32     Offset
     5023  IN VM_CONTEXT  *VmPtr,
     5024  IN UINT32      Offset
    49895025  )
    49905026{
    … …  
    49945030  // Read direct if aligned
    49955031  //
    4996   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {
    4997     return * (INT32 *) (VmPtr->Ip + Offset);
    4998   }
     5032  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT32))) {
     5033    return *(INT32 *)(VmPtr->Ip + Offset);
     5034  }
     5035
    49995036  //
    50005037  // Return unaligned data
    50015038  //
    5002   Data  = (UINT32) VmReadCode16 (VmPtr, Offset);
     5039  Data  = (UINT32)VmReadCode16 (VmPtr, Offset);
    50035040  Data |= (UINT32)(VmReadCode16 (VmPtr, Offset + 2) << 16);
    50045041  return Data;
    50055042}
    5006 
    50075043
    50085044/**
    … …  
    50225058INT64
    50235059VmReadImmed64 (
    5024   IN VM_CONTEXT *VmPtr,
    5025   IN UINT32     Offset
     5060  IN VM_CONTEXT  *VmPtr,
     5061  IN UINT32      Offset
    50265062  )
    50275063{
    … …  
    50335069  // Read direct if aligned
    50345070  //
    5035   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {
    5036     return * (UINT64 *) (VmPtr->Ip + Offset);
    5037   }
     5071  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT64))) {
     5072    return *(UINT64 *)(VmPtr->Ip + Offset);
     5073  }
     5074
    50385075  //
    50395076  // Return unaligned data.
    50405077  //
    5041   Ptr             = (UINT8 *) &Data64;
    5042   Data32          = VmReadCode32 (VmPtr, Offset);
    5043   *(UINT32 *) Ptr = Data32;
    5044   Ptr            += sizeof (Data32);
    5045   Data32          = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
    5046   *(UINT32 *) Ptr = Data32;
     5078  Ptr            = (UINT8 *)&Data64;
     5079  Data32         = VmReadCode32 (VmPtr, Offset);
     5080  *(UINT32 *)Ptr = Data32;
     5081  Ptr           += sizeof (Data32);
     5082  Data32         = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
     5083  *(UINT32 *)Ptr = Data32;
    50475084  return Data64;
    50485085}
    5049 
    50505086
    50515087/**
    … …  
    50635099UINT16
    50645100VmReadCode16 (
    5065   IN VM_CONTEXT *VmPtr,
    5066   IN UINT32     Offset
     5101  IN VM_CONTEXT  *VmPtr,
     5102  IN UINT32      Offset
    50675103  )
    50685104{
    … …  
    50705106  // Read direct if aligned
    50715107  //
    5072   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT16))) {
    5073     return * (UINT16 *) (VmPtr->Ip + Offset);
     5108  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT16))) {
     5109    return *(UINT16 *)(VmPtr->Ip + Offset);
    50745110  } else {
    50755111    //
    … …  
    50825118      );
    50835119  }
     5120
    50845121  //
    50855122  // Return unaligned data
    50865123  //
    5087   return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));
    5088 }
    5089 
     5124  return (UINT16)(*(UINT8 *)(VmPtr->Ip + Offset) + (*(UINT8 *)(VmPtr->Ip + Offset + 1) << 8));
     5125}
    50905126
    50915127/**
    … …  
    51035139UINT32
    51045140VmReadCode32 (
    5105   IN VM_CONTEXT *VmPtr,
    5106   IN UINT32     Offset
     5141  IN VM_CONTEXT  *VmPtr,
     5142  IN UINT32      Offset
    51075143  )
    51085144{
    51095145  UINT32  Data;
     5146
    51105147  //
    51115148  // Read direct if aligned
    51125149  //
    5113   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {
    5114     return * (UINT32 *) (VmPtr->Ip + Offset);
    5115   }
     5150  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT32))) {
     5151    return *(UINT32 *)(VmPtr->Ip + Offset);
     5152  }
     5153
    51165154  //
    51175155  // Return unaligned data
    51185156  //
    5119   Data = (UINT32) VmReadCode16 (VmPtr, Offset);
     5157  Data  = (UINT32)VmReadCode16 (VmPtr, Offset);
    51205158  Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16);
    51215159  return Data;
    51225160}
    51235161
    5124 
    51255162/**
    51265163  Reads 64-bit unsigned data from the code stream.
    … …  
    51375174UINT64
    51385175VmReadCode64 (
    5139   IN VM_CONTEXT *VmPtr,
    5140   IN UINT32     Offset
     5176  IN VM_CONTEXT  *VmPtr,
     5177  IN UINT32      Offset
    51415178  )
    51425179{
    … …  
    51485185  // Read direct if aligned
    51495186  //
    5150   if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {
    5151     return * (UINT64 *) (VmPtr->Ip + Offset);
    5152   }
     5187  if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT64))) {
     5188    return *(UINT64 *)(VmPtr->Ip + Offset);
     5189  }
     5190
    51535191  //
    51545192  // Return unaligned data.
    51555193  //
    5156   Ptr             = (UINT8 *) &Data64;
    5157   Data32          = VmReadCode32 (VmPtr, Offset);
    5158   *(UINT32 *) Ptr = Data32;
    5159   Ptr            += sizeof (Data32);
    5160   Data32          = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
    5161   *(UINT32 *) Ptr = Data32;
     5194  Ptr            = (UINT8 *)&Data64;
     5195  Data32         = VmReadCode32 (VmPtr, Offset);
     5196  *(UINT32 *)Ptr = Data32;
     5197  Ptr           += sizeof (Data32);
     5198  Data32         = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
     5199  *(UINT32 *)Ptr = Data32;
    51625200  return Data64;
    51635201}
    5164 
    51655202
    51665203/**
    … …  
    51755212UINT8
    51765213VmReadMem8 (
    5177   IN VM_CONTEXT   *VmPtr,
    5178   IN UINTN        Addr
     5214  IN VM_CONTEXT  *VmPtr,
     5215  IN UINTN       Addr
    51795216  )
    51805217{
    … …  
    51865223  // Simply return the data in flat memory space
    51875224  //
    5188   return * (UINT8 *) Addr;
     5225  return *(UINT8 *)Addr;
    51895226}
    51905227
    … …  
    52005237UINT16
    52015238VmReadMem16 (
    5202   IN VM_CONTEXT *VmPtr,
    5203   IN UINTN      Addr
     5239  IN VM_CONTEXT  *VmPtr,
     5240  IN UINTN       Addr
    52045241  )
    52055242{
    … …  
    52125249  //
    52135250  if (IS_ALIGNED (Addr, sizeof (UINT16))) {
    5214     return * (UINT16 *) Addr;
    5215   }
     5251    return *(UINT16 *)Addr;
     5252  }
     5253
    52165254  //
    52175255  // Return unaligned data
    52185256  //
    5219   return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8));
     5257  return (UINT16)(*(UINT8 *)Addr + (*(UINT8 *)(Addr + 1) << 8));
    52205258}
    52215259
    … …  
    52315269UINT32
    52325270VmReadMem32 (
    5233   IN VM_CONTEXT *VmPtr,
    5234   IN UINTN      Addr
     5271  IN VM_CONTEXT  *VmPtr,
     5272  IN UINTN       Addr
    52355273  )
    52365274{
    … …  
    52455283  //
    52465284  if (IS_ALIGNED (Addr, sizeof (UINT32))) {
    5247     return * (UINT32 *) Addr;
    5248   }
     5285    return *(UINT32 *)Addr;
     5286  }
     5287
    52495288  //
    52505289  // Return unaligned data
    52515290  //
    5252   Data = (UINT32) VmReadMem16 (VmPtr, Addr);
     5291  Data  = (UINT32)VmReadMem16 (VmPtr, Addr);
    52535292  Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16);
    52545293  return Data;
    … …  
    52665305UINT64
    52675306VmReadMem64 (
    5268   IN VM_CONTEXT   *VmPtr,
    5269   IN UINTN        Addr
     5307  IN VM_CONTEXT  *VmPtr,
     5308  IN UINTN       Addr
    52705309  )
    52715310{
    … …  
    52825321  //
    52835322  if (IS_ALIGNED (Addr, sizeof (UINT64))) {
    5284     return * (UINT64 *) Addr;
    5285   }
     5323    return *(UINT64 *)Addr;
     5324  }
     5325
    52865326  //
    52875327  // Return unaligned data. Assume little endian.
    52885328  //
    52895329  Data32 = VmReadMem32 (VmPtr, Addr);
    5290   Data  = (UINT64) VmReadMem32 (VmPtr, Addr + sizeof (UINT32));
    5291   Data  = LShiftU64 (Data, 32) | Data32;
     5330  Data   = (UINT64)VmReadMem32 (VmPtr, Addr + sizeof (UINT32));
     5331  Data   = LShiftU64 (Data, 32) | Data32;
    52925332  return Data;
    52935333}
    5294 
    52955334
    52965335/**
    … …  
    53155354UINTN
    53165355ConvertStackAddr (
    5317   IN VM_CONTEXT    *VmPtr,
    5318   IN UINTN         Addr
    5319   )
    5320 {
    5321   ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));
     5356  IN VM_CONTEXT  *VmPtr,
     5357  IN UINTN       Addr
     5358  )
     5359{
     5360  ASSERT (((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));
    53225361  return Addr;
    53235362}
    5324 
    53255363
    53265364/**
    … …  
    53355373UINTN
    53365374VmReadMemN (
    5337   IN VM_CONTEXT    *VmPtr,
    5338   IN UINTN         Addr
    5339   )
    5340 {
    5341   UINTN   Data;
     5375  IN VM_CONTEXT  *VmPtr,
     5376  IN UINTN       Addr
     5377  )
     5378{
     5379  UINTN            Data;
    53425380  volatile UINT32  Size;
    5343   UINT8   *FromPtr;
    5344   UINT8   *ToPtr;
     5381  UINT8            *FromPtr;
     5382  UINT8            *ToPtr;
     5383
    53455384  //
    53465385  // Convert the address if it's in the stack gap
    … …  
    53515390  //
    53525391  if (IS_ALIGNED (Addr, sizeof (UINTN))) {
    5353     return * (UINTN *) Addr;
    5354   }
     5392    return *(UINTN *)Addr;
     5393  }
     5394
    53555395  //
    53565396  // Return unaligned data
    53575397  //
    53585398  Data    = 0;
    5359   FromPtr = (UINT8 *) Addr;
    5360   ToPtr   = (UINT8 *) &Data;
     5399  FromPtr = (UINT8 *)Addr;
     5400  ToPtr   = (UINT8 *)&Data;
    53615401
    53625402  for (Size = 0; Size < sizeof (Data); Size++) {
    … …  
    53805420  )
    53815421{
    5382   return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));
    5383 }
     5422  return (UINT64)(((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));
     5423}
Note: See TracChangeset for help on using the changeset viewer.

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