VirtualBox

Changeset 65879 in vbox


Ignore:
Timestamp:
Feb 25, 2017 2:00:07 PM (8 years ago)
Author:
vboxsync
Message:

IEM,DIS: Updates

Location:
trunk/src/VBox
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Disassembler/DisasmTables.cpp

    r65878 r65879  
    101101    OP("or %eAX,%Iz",        IDX_ParseFixedReg,  IDX_ParseImmZ,  0,          OP_OR,      OP_PARM_REG_EAX,    OP_PARM_Iz,     OP_PARM_NONE,   DISOPTYPE_HARMLESS),
    102102    OP("push CS",            IDX_ParseFixedReg,  0,              0,          OP_PUSH,    OP_PARM_REG_CS,     OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS | DISOPTYPE_INVALID_64 | DISOPTYPE_POTENTIALLY_DANGEROUS),
    103     OP("2-BYTE ESCAPE",      IDX_ParseTwoByteEsc, 0,             0,          OP_2B_ESC,  OP_PARM_NONE,       OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS),
     103    OP("EscTwo0f",           IDX_ParseTwoByteEsc, 0,             0,          OP_2B_ESC,  OP_PARM_NONE,       OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS),
    104104
    105105    /* 1 */

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsOneByte.cpp.h

    r65876 r65879  
    250250/**
    251251 * @opcode      0x0f
    252  * @mnemonic    2byteescape
    253  * @encoding    two0f
     252 * @opmnemonic  EscTwo0f
     253 * @openc       two0f
    254254 * @opdisenum   OP_2B_ESC
    255255 * @ophints     harmless
    … …  
    278278        return FNIEMOP_CALL(g_apfnTwoByteMap[(uintptr_t)b * 4 + pVCpu->iem.s.idxPrefix]);
    279279    }
     280    /* @opdone */
    280281
    281282    /*
    … …  
    291292/**
    292293 * @opcode      0x10
    293  * @opmnemonic  adc
    294  * @op1         reg:Eb
    295  * @op2         rm:Gb
    296  * @opmaps      one
    297  * @oppfx       none
    298  * @openc       ModR/M
     294 * @opgroup     op_gen_arith_bin
    299295 * @opfltest    cf
    300296 * @opflmodify  of,sf,zf,af,pf,cf
    301  * @ophints     harmless
    302  * @opgroup     op_gen_arith_bin
    303297 * @optest      op1=1 op2=1 efl&~=cf -> op1=2 efl&|=of,sf,zf,af
    304298 * @optest      op1=1 op2=1 efl|=cf  -> op1=3 efl&|=of,sf,zf,af
    … …  
    306300FNIEMOP_DEF(iemOp_adc_Eb_Gb)
    307301{
    308     IEMOP_MNEMONIC(adc_Eb_Gb, "adc Eb,Gb");
     302    IEMOP_MNEMONIC2(MR, ADC, adc, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    309303    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_adc);
    310304}
    … …  
    313307/**
    314308 * @opcode      0x11
     309 * @opgroup     op_gen_arith_bin
     310 * @opfltest    cf
     311 * @opflmodify  of,sf,zf,af,pf,cf
    315312 */
    316313FNIEMOP_DEF(iemOp_adc_Ev_Gv)
    317314{
    318     IEMOP_MNEMONIC(adc_Ev_Gv, "adc Ev,Gv");
     315    IEMOP_MNEMONIC2(MR, ADC, adc, Ev, Gv, DISOPTYPE_HARMLESS, 0);
    319316    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_rv, &g_iemAImpl_adc);
    320317}
    … …  
    323320/**
    324321 * @opcode      0x12
     322 * @opgroup     op_gen_arith_bin
     323 * @opfltest    cf
     324 * @opflmodify  of,sf,zf,af,pf,cf
    325325 */
    326326FNIEMOP_DEF(iemOp_adc_Gb_Eb)
    327327{
    328     IEMOP_MNEMONIC(adc_Gb_Eb, "adc Gb,Eb");
     328    IEMOP_MNEMONIC2(RM, ADC, adc, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    329329    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_adc);
    330330}
    … …  
    333333/**
    334334 * @opcode      0x13
     335 * @opgroup     op_gen_arith_bin
     336 * @opfltest    cf
     337 * @opflmodify  of,sf,zf,af,pf,cf
    335338 */
    336339FNIEMOP_DEF(iemOp_adc_Gv_Ev)
    337340{
    338     IEMOP_MNEMONIC(adc_Gv_Ev, "adc Gv,Ev");
     341    IEMOP_MNEMONIC2(RM, ADC, adc, Gv, Ev, DISOPTYPE_HARMLESS, 0);
    339342    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rv_rm, &g_iemAImpl_adc);
    340343}
    … …  
    343346/**
    344347 * @opcode      0x14
     348 * @opgroup     op_gen_arith_bin
     349 * @opfltest    cf
     350 * @opflmodify  of,sf,zf,af,pf,cf
    345351 */
    346352FNIEMOP_DEF(iemOp_adc_Al_Ib)
    347353{
    348     IEMOP_MNEMONIC(adc_al_Ib, "adc al,Ib");
     354    IEMOP_MNEMONIC2(FIXED, ADC, adc, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    349355    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_adc);
    350356}
    … …  
    353359/**
    354360 * @opcode      0x15
     361 * @opgroup     op_gen_arith_bin
     362 * @opfltest    cf
     363 * @opflmodify  of,sf,zf,af,pf,cf
    355364 */
    356365FNIEMOP_DEF(iemOp_adc_eAX_Iz)
    357366{
    358     IEMOP_MNEMONIC(adc_rAX_Iz, "adc rAX,Iz");
     367    IEMOP_MNEMONIC2(FIXED, ADC, adc, rAX, Iz, DISOPTYPE_HARMLESS, 0);
    359368    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rAX_Iz, &g_iemAImpl_adc);
    360369}
    … …  
    366375FNIEMOP_DEF(iemOp_push_SS)
    367376{
    368     IEMOP_MNEMONIC(push_ss, "push ss");
     377    IEMOP_MNEMONIC1(FIXED, PUSH, push, SS, DISOPTYPE_HARMLESS | DISOPTYPE_INVALID_64 | DISOPTYPE_RRM_DANGEROUS, 0);
    369378    IEMOP_HLP_NO_64BIT();
    370379    return FNIEMOP_CALL_1(iemOpCommonPushSReg, X86_SREG_SS);
    … …  
    374383/**
    375384 * @opcode      0x17
     385 * @opgroup     op_gen_arith_bin
     386 * @opfltest    cf
     387 * @opflmodify  of,sf,zf,af,pf,cf
    376388 */
    377389FNIEMOP_DEF(iemOp_pop_SS)
    378390{
    379     IEMOP_MNEMONIC(pop_ss, "pop ss"); /** @todo implies instruction fusing? */
     391    IEMOP_MNEMONIC1(FIXED, POP, pop, SS, DISOPTYPE_HARMLESS | DISOPTYPE_INHIBIT_IRQS | DISOPTYPE_INVALID_64 | DISOPTYPE_RRM_DANGEROUS , 0);
    380392    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    381393    IEMOP_HLP_NO_64BIT();
    … …  
    386398/**
    387399 * @opcode      0x18
     400 * @opgroup     op_gen_arith_bin
     401 * @opfltest    cf
     402 * @opflmodify  of,sf,zf,af,pf,cf
    388403 */
    389404FNIEMOP_DEF(iemOp_sbb_Eb_Gb)
    390405{
    391     IEMOP_MNEMONIC(sbb_Eb_Gb, "sbb Eb,Gb");
     406    IEMOP_MNEMONIC2(MR, SBB, sbb, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    392407    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_sbb);
    393408}
    … …  
    396411/**
    397412 * @opcode      0x19
     413 * @opgroup     op_gen_arith_bin
     414 * @opfltest    cf
     415 * @opflmodify  of,sf,zf,af,pf,cf
    398416 */
    399417FNIEMOP_DEF(iemOp_sbb_Ev_Gv)
    400418{
    401     IEMOP_MNEMONIC(sbb_Ev_Gv, "sbb Ev,Gv");
     419    IEMOP_MNEMONIC2(MR, SBB, sbb, Ev, Gv, DISOPTYPE_HARMLESS, 0);
    402420    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_rv, &g_iemAImpl_sbb);
    403421}
    … …  
    406424/**
    407425 * @opcode      0x1a
     426 * @opgroup     op_gen_arith_bin
     427 * @opfltest    cf
     428 * @opflmodify  of,sf,zf,af,pf,cf
    408429 */
    409430FNIEMOP_DEF(iemOp_sbb_Gb_Eb)
    410431{
    411     IEMOP_MNEMONIC(sbb_Gb_Eb, "sbb Gb,Eb");
     432    IEMOP_MNEMONIC2(RM, SBB, sbb, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    412433    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_sbb);
    413434}
    … …  
    416437/**
    417438 * @opcode      0x1b
     439 * @opgroup     op_gen_arith_bin
     440 * @opfltest    cf
     441 * @opflmodify  of,sf,zf,af,pf,cf
    418442 */
    419443FNIEMOP_DEF(iemOp_sbb_Gv_Ev)
    420444{
    421     IEMOP_MNEMONIC(sbb_Gv_Ev, "sbb Gv,Ev");
     445    IEMOP_MNEMONIC2(RM, SBB, sbb, Gv, Ev, DISOPTYPE_HARMLESS, 0);
    422446    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rv_rm, &g_iemAImpl_sbb);
    423447}
    … …  
    426450/**
    427451 * @opcode      0x1c
     452 * @opgroup     op_gen_arith_bin
     453 * @opfltest    cf
     454 * @opflmodify  of,sf,zf,af,pf,cf
    428455 */
    429456FNIEMOP_DEF(iemOp_sbb_Al_Ib)
    430457{
    431     IEMOP_MNEMONIC(sbb_al_Ib, "sbb al,Ib");
     458    IEMOP_MNEMONIC2(FIXED, SBB, sbb, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
    432459    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_sbb);
    433460}
    … …  
    436463/**
    437464 * @opcode      0x1d
     465 * @opgroup     op_gen_arith_bin
     466 * @opfltest    cf
     467 * @opflmodify  of,sf,zf,af,pf,cf
    438468 */
    439469FNIEMOP_DEF(iemOp_sbb_eAX_Iz)
    440470{
    441     IEMOP_MNEMONIC(sbb_rAX_Iz, "sbb rAX,Iz");
     471    IEMOP_MNEMONIC2(FIXED, SBB, sbb, rAX, Iz, DISOPTYPE_HARMLESS, 0);
    442472    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rAX_Iz, &g_iemAImpl_sbb);
    443473}
    … …  
    446476/**
    447477 * @opcode      0x1e
     478 * @opgroup     op_stack_sreg
    448479 */
    449480FNIEMOP_DEF(iemOp_push_DS)
    450481{
    451     IEMOP_MNEMONIC(push_ds, "push ds");
     482    IEMOP_MNEMONIC1(FIXED, PUSH, push, DS, DISOPTYPE_HARMLESS | DISOPTYPE_INVALID_64, 0);
    452483    IEMOP_HLP_NO_64BIT();
    453484    return FNIEMOP_CALL_1(iemOpCommonPushSReg, X86_SREG_DS);
    … …  
    457488/**
    458489 * @opcode      0x1f
     490 * @opgroup     op_stack_sreg
    459491 */
    460492FNIEMOP_DEF(iemOp_pop_DS)
    461493{
    462     IEMOP_MNEMONIC(pop_ds, "pop ds");
     494    IEMOP_MNEMONIC1(FIXED, POP, pop, DS, DISOPTYPE_HARMLESS | DISOPTYPE_INVALID_64 | DISOPTYPE_RRM_DANGEROUS, 0);
    463495    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    464496    IEMOP_HLP_NO_64BIT();

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsPython.py

    r65876 r65879  
    9797## \@op[1-4] types
    9898##
    99 ## First value entry is the normal IDX_ParseXXX handler (IDX_UseModRM == IDX_ParseModRM).
    100 ## Second value entry is the location (g_kdOpLocations).
    101 ## Third value entry is disassembler format string version of the type.
     99## Value fields:
     100##    - 0: the normal IDX_ParseXXX handler (IDX_UseModRM == IDX_ParseModRM).
     101##    - 1: the location (g_kdOpLocations).
     102##    - 2: disassembler format string version of the type.
     103##    - 3: disassembler OP_PARAM_XXX (XXX only).
    102104##
    103105## Note! See the A.2.1 in SDM vol 2 for the type names.
    104106g_kdOpTypes = {
    105107    # Fixed addresses
    106     'Ap':   ( 'IDX_ParseImmAddrF',  'imm', '%Ap',  ),
     108    'Ap':   ( 'IDX_ParseImmAddrF',  'imm',    '%Ap',  'Ap',      ),
    107109
    108110    # ModR/M.rm
    109     'Eb':   ( 'IDX_UseModRM',       'rm',  '%Eb',  ),
    110     'Ew':   ( 'IDX_UseModRM',       'rm',  '%Ew',  ),
    111     'Ev':   ( 'IDX_UseModRM',       'rm',  '%Ev',  ),
     111    'Eb':   ( 'IDX_UseModRM',       'rm',     '%Eb',  'Eb',      ),
     112    'Ew':   ( 'IDX_UseModRM',       'rm',     '%Ew',  'Ew',      ),
     113    'Ev':   ( 'IDX_UseModRM',       'rm',     '%Ev',  'Ev',      ),
    112114
    113115    # ModR/M.rm - memory only.
    114     'Ma':   ( 'IDX_UseModRM',        'rm', '%Ma',  ), ##< Only used by BOUND.
     116    'Ma':   ( 'IDX_UseModRM',        'rm',    '%Ma',  'Ma',      ), ##< Only used by BOUND.
    115117
    116118    # ModR/M.reg
    117     'Gb':   ( 'IDX_UseModRM',       'reg', '%Gb',  ),
    118     'Gw':   ( 'IDX_UseModRM',       'reg', '%Gw',  ),
    119     'Gv':   ( 'IDX_UseModRM',       'reg', '%Gv',  ),
     119    'Gb':   ( 'IDX_UseModRM',       'reg',    '%Gb',  'Gb',      ),
     120    'Gw':   ( 'IDX_UseModRM',       'reg',    '%Gw',  'Gw',      ),
     121    'Gv':   ( 'IDX_UseModRM',       'reg',    '%Gv',  'Gv',      ),
    120122
    121123    # Immediate values.
    122     'Ib':   ( 'IDX_ParseImmByte',   'imm', '%Ib',  ), ##< NB! Could be IDX_ParseImmByteSX for some instructions.
    123     'Iw':   ( 'IDX_ParseImmUshort', 'imm', '%Iw',  ),
    124     'Id':   ( 'IDX_ParseImmUlong',  'imm', '%Id',  ),
    125     'Iq':   ( 'IDX_ParseImmQword',  'imm', '%Iq',  ),
    126     'Iv':   ( 'IDX_ParseImmV',      'imm', '%Iv',  ), ##< o16: word, o32: dword, o64: qword
    127     'Iz':   ( 'IDX_ParseImmZ',      'imm', '%Iz',  ), ##< o16: word, o32|o64:dword
     124    'Ib':   ( 'IDX_ParseImmByte',   'imm',    '%Ib',  'Ib',      ), ##< NB! Could be IDX_ParseImmByteSX for some instructions.
     125    'Iw':   ( 'IDX_ParseImmUshort', 'imm',    '%Iw',  'Iw',      ),
     126    'Id':   ( 'IDX_ParseImmUlong',  'imm',    '%Id',  'Id',      ),
     127    'Iq':   ( 'IDX_ParseImmQword',  'imm',    '%Iq',  'Iq',      ),
     128    'Iv':   ( 'IDX_ParseImmV',      'imm',    '%Iv',  'Iv',      ), ##< o16: word, o32: dword, o64: qword
     129    'Iz':   ( 'IDX_ParseImmZ',      'imm',    '%Iz',  'Iz',      ), ##< o16: word, o32|o64:dword
    128130
    129131    # Address operands (no ModR/M).
    130     'Ob':   ( 'IDX_ParseImmAddr',   'imm', '%Ob',  ),
    131     'Ov':   ( 'IDX_ParseImmAddr',   'imm', '%Ov',  ),
     132    'Ob':   ( 'IDX_ParseImmAddr',   'imm',    '%Ob',  'Ob',      ),
     133    'Ov':   ( 'IDX_ParseImmAddr',   'imm',    '%Ov',  'Ov',      ),
    132134
    133135    # Relative jump targets
    134     'Jb':   ( 'IDX_ParseImmBRel',   'imm', '%Jb',  ),
    135     'Jv':   ( 'IDX_ParseImmVRel',   'imm', '%Jv',  ),
     136    'Jb':   ( 'IDX_ParseImmBRel',   'imm',    '%Jb',  'Jb',      ),
     137    'Jv':   ( 'IDX_ParseImmVRel',   'imm',    '%Jv',  'Jv',      ),
    136138
    137139    # DS:rSI
    138     'Xb':   ( 'IDX_ParseXb',        'rSI', '%eSI', ),
    139     'Xv':   ( 'IDX_ParseXv',        'rSI', '%eSI', ),
     140    'Xb':   ( 'IDX_ParseXb',        'rSI',    '%eSI', 'Xb',      ),
     141    'Xv':   ( 'IDX_ParseXv',        'rSI',    '%eSI', 'Xv',      ),
    140142    # ES:rDI
    141     'Yb':   ( 'IDX_ParseYb',        'rDI', '%eDI', ),
    142     'Yv':   ( 'IDX_ParseYv',        'rDI', '%eDI', ),
    143 
    144     'Fv':   ( 'IDX_ParseFixedReg',  'rFLAGS', '%Fv', ),
     143    'Yb':   ( 'IDX_ParseYb',        'rDI',    '%eDI', 'Yb',      ),
     144    'Yv':   ( 'IDX_ParseYv',        'rDI',    '%eDI', 'Yv',      ),
     145
     146    'Fv':   ( 'IDX_ParseFixedReg',  'rFLAGS', '%Fv',  'Fv',      ),
    145147
    146148    # Fixed registers.
    147     'AL':   ( 'IDX_ParseFixedReg',  'AL',  'al'   ),
    148     'rAX':  ( 'IDX_ParseFixedReg',  'rAX', '%eAX', ),
    149     'CS':   ( 'IDX_ParseFixedReg',  'CS',  'cs'   ), # 8086: push CS
    150     'DS':   ( 'IDX_ParseFixedReg',  'DS',  'ds'   ),
    151     'ES':   ( 'IDX_ParseFixedReg',  'ES',  'es'   ),
    152     'FS':   ( 'IDX_ParseFixedReg',  'FS',  'fs'   ),
    153     'GS':   ( 'IDX_ParseFixedReg',  'GS',  'gs'   ),
    154     'SS':   ( 'IDX_ParseFixedReg',  'SS',  'ss'   ),
     149    'AL':   ( 'IDX_ParseFixedReg',  'AL',     'al',   'REG_AL',  ),
     150    'rAX':  ( 'IDX_ParseFixedReg',  'rAX',    '%eAX', 'REG_EAX', ),
     151    'CS':   ( 'IDX_ParseFixedReg',  'CS',     'cs',   'REG_CS',  ), # 8086: push CS
     152    'DS':   ( 'IDX_ParseFixedReg',  'DS',     'ds',   'REG_DS',  ),
     153    'ES':   ( 'IDX_ParseFixedReg',  'ES',     'es',   'REG_ES',  ),
     154    'FS':   ( 'IDX_ParseFixedReg',  'FS',     'fs',   'REG_FS',  ),
     155    'GS':   ( 'IDX_ParseFixedReg',  'GS',     'gs',   'REG_GS',  ),
     156    'SS':   ( 'IDX_ParseFixedReg',  'SS',     'ss',   'REG_SS',  ),
    155157};
    156158
    … …  
    338340    };
    339341
    340     def __init__(self, sName, asLeadOpcodes = None, sSelector = 'byte', sEncoding = 'legacy'):
     342    def __init__(self, sName, asLeadOpcodes = None, sSelector = 'byte', sEncoding = 'legacy', sDisParse = None):
    341343        assert sSelector in self.kdSelectors;
    342344        assert sEncoding in self.kdEncodings;
    … …  
    346348            for sOpcode in asLeadOpcodes:
    347349                assert _isValidOpcodeByte(sOpcode);
     350        assert sDisParse is None or sDisParse.startswith('IDX_Parse');
    348351
    349352        self.sName          = sName;
    … …  
    352355        self.sEncoding      = sEncoding;        ##< The encoding, see kdSelectors.
    353356        self.aoInstructions = [];               # type: Instruction
     357        self.sDisParse      = sDisParse;        ##< IDX_ParseXXX.
    354358
    355359    def getTableSize(self):
    … …  
    995999    'grp11_c7_r':   InstructionMap('grp11_c7_r',asLeadOpcodes = ['0xc7',], sSelector = '11'),    # xbegin
    9961000
    997     'two0f':        InstructionMap('two0f',     asLeadOpcodes = ['0x0f',]),
     1001    'two0f':        InstructionMap('two0f',     asLeadOpcodes = ['0x0f',], sDisParse = 'IDX_ParseTwoByteEsc'),
    9981002    'grp6':         InstructionMap('grp6',      asLeadOpcodes = ['0x0f', '0x00',], sSelector = '/r'),
    9991003    'grp7_m':       InstructionMap('grp7_m',    asLeadOpcodes = ['0x0f', '0x01',], sSelector = '!11 /r'),
    … …  
    15751579        """
    15761580        Tag:        \@openc
    1577         Value:      ModR/M|TBD
     1581        Value:      ModR/M|fixed|prefix|<map name>
    15781582
    15791583        The instruction operand encoding style.
    … …  
    15841588        sEncoding = self.flattenAllSections(aasSections);
    15851589        if sEncoding in g_kdEncodings:
     1590            pass;
     1591        elif sEncoding in g_dInstructionMaps:
    15861592            pass;
    15871593        elif not _isValidOpcodeByte(sEncoding):
    … …  
    21482154                elif sCurTag == '@default':
    21492155                    sFlatDefault = self.flattenAllSections(aasSections);
     2156                elif '@op' + sCurTag[1:] in self.dTagHandlers:
     2157                    self.errorComment(iCurTagLine, 'Did you mean "@op%s" rather than "%s"?' % (sCurTag[1:], sCurTag));
     2158                elif sCurTag in ['@encoding', '@opencoding']:
     2159                    self.errorComment(iCurTagLine, 'Did you mean "@openc" rather than "%s"?' % (sCurTag,));
    21502160
    21512161                #
    … …  
    25742584
    25752585    if cErrors != 0:
    2576         raise Exception('%d parse errors' % (cErrors,));
     2586        #raise Exception('%d parse errors' % (cErrors,));
     2587        sys.exit(1);
    25772588    return True;
    25782589
    … …  
    26262637                for iOperand, oOperand in enumerate(oInstr.aoOperands):
    26272638                    sTmp += ' ' if iOperand == 0 else ',';
    2628                     sTmp += g_kdOpTypes[oOperand.sType][2];
     2639                    if g_kdOpTypes[oOperand.sType][2][0] != '%':        ## @todo remove upper() later.
     2640                        sTmp += g_kdOpTypes[oOperand.sType][2].upper(); ## @todo remove upper() later.
     2641                    else:
     2642                        sTmp += g_kdOpTypes[oOperand.sType][2];
    26292643                sTmp += '",';
    26302644                asColumns = [ sTmp, ];
    … …  
    26342648                #
    26352649                iStart = len(asColumns);
     2650                #print 'debug: %s' % (oInstr,);
    26362651                if oInstr.sEncoding is None:
    26372652                    pass;
    … …  
    26502665                elif oInstr.sEncoding == 'vex3':
    26512666                    asColumns.append('IDX_ParseVex3b,')
     2667                elif oInstr.sEncoding in g_dInstructionMaps:
     2668                    asColumns.append(g_dInstructionMaps[oInstr.sEncoding].sDisParse + ',');
    26522669                else:
    26532670                    ## @todo
    … …  
    26912708                iStart = len(asColumns)
    26922709                for oOperand in oInstr.aoOperands:
    2693                     asColumns.append('OP_PARM_' + oOperand.sType + ',');
     2710                    asColumns.append('OP_PARM_' + g_kdOpTypes[oOperand.sType][3] + ',');
    26942711                asColumns.extend(['OP_PARM_NONE,'] * (cMaxOperands - (len(asColumns) - iStart)));
    26952712
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