src/arch/x86/isa/decoder/one_byte_opcodes.isa

   1 // Copyright (c) 2007 The Hewlett-Packard Development Company
   2 // All rights reserved.
   3 //
   4 // Redistribution and use of this software in source and binary forms,
   5 // with or without modification, are permitted provided that the
   6 // following conditions are met:
   7 //
   8 // The software must be used only for Non-Commercial Use which means any
   9 // use which is NOT directed to receiving any direct monetary
  10 // compensation for, or commercial advantage from such use.  Illustrative
  11 // examples of non-commercial use are academic research, personal study,
  12 // teaching, education and corporate research & development.
  13 // Illustrative examples of commercial use are distributing products for
  14 // commercial advantage and providing services using the software for
  15 // commercial advantage.
  16 //
  17 // If you wish to use this software or functionality therein that may be
  18 // covered by patents for commercial use, please contact:
  19 //     Director of Intellectual Property Licensing
  20 //     Office of Strategy and Technology
  21 //     Hewlett-Packard Company
  22 //     1501 Page Mill Road
  23 //     Palo Alto, California  94304
  24 //
  25 // Redistributions of source code must retain the above copyright notice,
  26 // this list of conditions and the following disclaimer.  Redistributions
  27 // in binary form must reproduce the above copyright notice, this list of
  28 // conditions and the following disclaimer in the documentation and/or
  29 // other materials provided with the distribution.  Neither the name of
  30 // the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
  31 // contributors may be used to endorse or promote products derived from
  32 // this software without specific prior written permission.  No right of
  33 // sublicense is granted herewith.  Derivatives of the software and
  34 // output created using the software may be prepared, but only for
  35 // Non-Commercial Uses.  Derivatives of the software may be shared with
  36 // others provided: (i) the others agree to abide by the list of
  37 // conditions herein which includes the Non-Commercial Use restrictions;
  38 // and (ii) such Derivatives of the software include the above copyright
  39 // notice to acknowledge the contribution from this software where
  40 // applicable, this list of conditions and the disclaimer below.
  41 //
  42 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  43 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  44 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  45 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  46 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  47 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  48 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  49 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  50 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  51 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  52 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53 //
  54 // Authors: Gabe Black
  55
  56 ////////////////////////////////////////////////////////////////////
  57 //
  58 // Decode the one byte opcodes
  59 //
  60
  61 0x1: decode OPCODE_OP_TOP5 {
  62     format Inst {
  63         0x00: decode OPCODE_OP_BOTTOM3 {
  64             0x6: decode MODE_SUBMODE {
  65                 0x0: UD2();
  66                 default: WarnUnimpl::push_ES();
  67             }
  68             0x7: decode MODE_SUBMODE {
  69                 0x0: UD2();
  70                 default: WarnUnimpl::pop_ES();
  71             }
  72             default: MultiInst::ADD(OPCODE_OP_BOTTOM3,
  73                                     [Eb,Gb], [Ev,Gv],
  74                                     [Gb,Eb], [Gv,Ev],
  75                                     [rAb,Ib], [rAv,Iz]);
  76         }
  77         0x01: decode OPCODE_OP_BOTTOM3 {
  78             0x6: decode MODE_SUBMODE {
  79                 0x0: UD2();
  80                 default: WarnUnimpl::push_CS();
  81             }
  82             //Any time this is seen, it should generate a two byte opcode
  83             0x7: M5InternalError::error(
  84                 {{"Saw a one byte opcode whose value was 0x0F!"}});
  85             default: MultiInst::OR(OPCODE_OP_BOTTOM3,
  86                                    [Eb,Gb], [Ev,Gv],
  87                                    [Gb,Eb], [Gv,Ev],
  88                                    [rAb,Ib], [rAv,Iz]);
  89         }
  90         0x02: decode OPCODE_OP_BOTTOM3 {
  91             0x6: decode MODE_SUBMODE {
  92                 0x0: UD2();
  93                 default: WarnUnimpl::push_SS();
  94             }
  95             0x7: decode MODE_SUBMODE {
  96                 0x0: UD2();
  97                 default: WarnUnimpl::pop_SS();
  98             }
  99             default: MultiInst::ADC(OPCODE_OP_BOTTOM3,
 100                                     [Eb,Gb], [Ev,Gv],
 101                                     [Gb,Eb], [Gv,Ev],
 102                                     [rAb,Ib], [rAv,Iz]);
 103         }
 104         0x03: decode OPCODE_OP_BOTTOM3 {
 105             0x6: decode MODE_SUBMODE {
 106                 0x0: UD2();
 107                 default: WarnUnimpl::push_DS();
 108             }
 109             0x7: decode MODE_SUBMODE {
 110                 0x0: UD2();
 111                 default: WarnUnimpl::pop_DS();
 112             }
 113             default: MultiInst::SBB(OPCODE_OP_BOTTOM3,
 114                                     [Eb,Gb], [Ev,Gv],
 115                                     [Gb,Eb], [Gv,Ev],
 116                                     [rAb,Ib], [rAv,Iz]);
 117         }
 118         0x04: decode OPCODE_OP_BOTTOM3 {
 119             0x6: M5InternalError::error(
 120                 {{"Tried to execute the ES segment override prefix!"}});
 121             0x7: decode MODE_SUBMODE {
 122                 0x0: UD2();
 123                 default: WarnUnimpl::daa();
 124             }
 125             default: MultiInst::AND(OPCODE_OP_BOTTOM3,
 126                                     [Eb,Gb], [Ev,Gv],
 127                                     [Gb,Eb], [Gv,Ev],
 128                                     [rAb,Ib], [rAv,Iz]);
 129         }
 130         0x05: decode OPCODE_OP_BOTTOM3 {
 131             0x6: M5InternalError::error(
 132                 {{"Tried to execute the CS segment override prefix!"}});
 133             0x7: decode MODE_SUBMODE {
 134                 0x0: UD2();
 135                 default: WarnUnimpl::das();
 136             }
 137             default: MultiInst::SUB(OPCODE_OP_BOTTOM3,
 138                                     [Eb,Gb], [Ev,Gv],
 139                                     [Gb,Eb], [Gv,Ev],
 140                                     [rAb,Ib], [rAv,Iz]);
 141         }
 142         0x06: decode OPCODE_OP_BOTTOM3 {
 143             0x6: M5InternalError::error(
 144                 {{"Tried to execute the SS segment override prefix!"}});
 145             0x7: decode MODE_SUBMODE {
 146                 0x0: UD2();
 147                 default: WarnUnimpl::aaa();
 148             }
 149             default: MultiInst::XOR(OPCODE_OP_BOTTOM3,
 150                                     [Eb,Gb], [Ev,Gv],
 151                                     [Gb,Eb], [Gv,Ev],
 152                                     [rAb,Ib], [rAv,Iz]);
 153         }
 154         0x07: decode OPCODE_OP_BOTTOM3 {
 155             0x6: M5InternalError::error(
 156                 {{"Tried to execute the DS segment override prefix!"}});
 157             0x7: decode MODE_SUBMODE {
 158                 0x0: UD2();
 159                 default: WarnUnimpl::aas();
 160             }
 161             default: MultiInst::CMP(OPCODE_OP_BOTTOM3,
 162                                     [Eb,Gb], [Ev,Gv],
 163                                     [Gb,Eb], [Gv,Ev],
 164                                     [rAb,Ib], [rAv,Iz]);
 165         }
 166         0x08: decode MODE_SUBMODE {
 167             0x0: M5InternalError::error (
 168                 {{"Tried to execute an REX prefix!"}});
 169             default: INC(Bv);
 170         }
 171         0x09: decode MODE_SUBMODE {
 172             0x0: M5InternalError::error (
 173                 {{"Tried to execute an REX prefix!"}});
 174             default: DEC(Bv);
 175         }
 176         0x0A: PUSH(Bv);
 177         0x0B: POP(Bv);
 178         0x0C: decode OPCODE_OP_BOTTOM3 {
 179             0x0: decode MODE_SUBMODE {
 180                 0x0: UD2();
 181                 default: PUSHA();
 182             }
 183             0x1: decode MODE_SUBMODE {
 184                 0x0: UD2();
 185                 default: POPA();
 186             }
 187             0x2: decode MODE_SUBMODE {
 188                 0x0: UD2();
 189                 default: BOUND(Gv,Mv);
 190             }
 191             0x3: decode MODE_SUBMODE {
 192                 //The second operand should really be of size "d", but it's
 193                 //set to "v" in order to have a consistent register size.
 194                 //This shouldn't affect behavior.
 195                 0x0: MOVSXD(Gv,Ev);
 196                 default: WarnUnimpl::arpl_Ew_Gw();
 197             }
 198             0x4: M5InternalError::error(
 199                 {{"Tried to execute the FS segment override prefix!"}});
 200             0x5: M5InternalError::error(
 201                 {{"Tried to execute the GS segment override prefix!"}});
 202             0x6: M5InternalError::error(
 203                 {{"Tried to execute the operand size override prefix!"}});
 204             0x7: M5InternalError::error(
 205                 {{"Tried to execute the DS address size override prefix!"}});
 206         }
 207         0x0D: decode OPCODE_OP_BOTTOM3 {
 208             0x0: PUSH(Iz);
 209             0x1: IMUL(Gv,Ev,Iz);
 210             0x2: PUSH(Ib);
 211             0x3: IMUL(Gv,Ev,Ib);
 212             0x4: StringInst::INS(Yb,rD);
 213             0x5: StringInst::INS(Yz,rD);
 214             0x6: StringInst::OUTS(rD,Xb);
 215             0x7: StringInst::OUTS(rD,Xz);
 216         }
 217         0x0E: decode OPCODE_OP_BOTTOM3 {
 218             0x0: JO(Jb);
 219             0x1: JNO(Jb);
 220             0x2: JB(Jb);
 221             0x3: JNB(Jb);
 222             0x4: JZ(Jb);
 223             0x5: JNZ(Jb);
 224             0x6: JBE(Jb);
 225             0x7: JNBE(Jb);
 226         }
 227         0x0F: decode OPCODE_OP_BOTTOM3 {
 228             0x0: JS(Jb);
 229             0x1: JNS(Jb);
 230             0x2: JP(Jb);
 231             0x3: JNP(Jb);
 232             0x4: JL(Jb);
 233             0x5: JNL(Jb);
 234             0x6: JLE(Jb);
 235             0x7: JNLE(Jb);
 236         }
 237         0x10: decode OPCODE_OP_BOTTOM3 {
 238             //0x0: group1_Eb_Ib();
 239             0x0: decode MODRM_REG {
 240                 0x0: ADD(Eb,Ib);
 241                 0x1: OR(Eb,Ib);
 242                 0x2: ADC(Eb,Ib);
 243                 0x3: SBB(Eb,Ib);
 244                 0x4: AND(Eb,Ib);
 245                 0x5: SUB(Eb,Ib);
 246                 0x6: XOR(Eb,Ib);
 247                 0x7: CMP(Eb,Ib);
 248             }
 249             //0x1: group1_Ev_Iz();
 250             0x1: decode MODRM_REG {
 251                 0x0: ADD(Ev,Iz);
 252                 0x1: OR(Ev,Iz);
 253                 0x2: ADC(Ev,Iz);
 254                 0x3: SBB(Ev,Iz);
 255                 0x4: AND(Ev,Iz);
 256                 0x5: SUB(Ev,Iz);
 257                 0x6: XOR(Ev,Iz);
 258                 0x7: CMP(Ev,Iz);
 259             }
 260             0x2: decode MODE_SUBMODE {
 261                 0x0: UD2();
 262                 //default: group1_Eb_Ib();
 263                 default: decode MODRM_REG {
 264                     0x0: ADD(Eb,Ib);
 265                     0x1: OR(Eb,Ib);
 266                     0x2: ADC(Eb,Ib);
 267                     0x3: SBB(Eb,Ib);
 268                     0x4: AND(Eb,Ib);
 269                     0x5: SUB(Eb,Ib);
 270                     0x6: XOR(Eb,Ib);
 271                     0x7: CMP(Eb,Ib);
 272                 }
 273             }
 274             //0x3: group1_Ev_Ib();
 275             0x3: decode MODRM_REG {
 276                 0x0: ADD(Ev,Ib);
 277                 0x1: OR(Ev,Ib);
 278                 0x2: ADC(Ev,Ib);
 279                 0x3: SBB(Ev,Ib);
 280                 0x4: AND(Ev,Ib);
 281                 0x5: SUB(Ev,Ib);
 282                 0x6: XOR(Ev,Ib);
 283                 0x7: CMP(Ev,Ib);
 284             }
 285             0x4: TEST(Eb,Gb);
 286             0x5: TEST(Ev,Gv);
 287             0x6: XCHG(Eb,Gb);
 288             0x7: XCHG(Ev,Gv);
 289         }
 290         0x11: decode OPCODE_OP_BOTTOM3 {
 291             0x0: MOV(Eb,Gb);
 292             0x1: MOV(Ev,Gv);
 293             0x2: MOV(Gb,Eb);
 294             0x3: MOV(Gv,Ev);
 295             0x4: decode MODRM_REG {
 296                 0x0, 0x1, 0x2,
 297                 0x3, 0x4, 0x5: MOV(Ev,Sv);
 298             }
 299             0x5: LEA(Gv,M);
 300             0x6: decode MODE_SUBMODE {
 301                 0x3, 0x4: MOV_REAL(Sv,Ev);
 302                 default: decode MODRM_REG {
 303                     0x1: UD2(); // Moving to the CS selector is illegal.
 304                     0x2: MOVSS(Sv,Ev);
 305                     0x0, 0x3,
 306                     0x4, 0x5: MOV(Sv,Ev);
 307                     default: UD2();
 308                 }
 309             }
 310             //0x7: group10_Ev();
 311             0x7: decode MODRM_REG {
 312                 0x0: POP(Ev);
 313                 default: UD2();
 314             }
 315         }
 316         0x12: decode OPCODE_OP_BOTTOM3 {
 317             0x0: NOP(); //XXX repe makes this a "pause"
 318             default: XCHG(Bv,rAv);
 319         }
 320         0x13: decode OPCODE_OP_BOTTOM3 {
 321             0x0: CDQE(rAv);
 322             0x1: CQO(rAv,rDv);
 323             0x2: decode MODE_SUBMODE {
 324                 0x0: UD2();
 325                 default: WarnUnimpl::call_far_Ap();
 326             }
 327             0x3: WarnUnimpl::fwait(); //aka wait
 328             0x4: PUSHF();
 329             0x5: POPF();
 330             //The 64 bit versions of both of these should be illegal only
 331             //if CPUID says it isn't supported. For now, we'll just assume
 332             //that it's supported.
 333             0x6: decode MODE_SUBMODE {
 334                 0x0: SAHF_64();
 335                 default: SAHF();
 336             }
 337             0x7: decode MODE_SUBMODE {
 338                 0x0: LAHF_64();
 339                 default: LAHF();
 340             }
 341         }
 342         0x14: decode OPCODE_OP_BOTTOM3 {
 343             0x0: MOV(rAb, Ob);
 344             0x1: MOV(rAv, Ov);
 345             0x2: MOV(Ob, rAb);
 346             0x3: MOV(Ov, rAv);
 347             0x4: StringInst::MOVS(Yb,Xb);
 348             0x5: StringInst::MOVS(Yv,Xv);
 349             0x6: StringTestInst::CMPS(Yb,Xb);
 350             0x7: StringTestInst::CMPS(Yv,Xv);
 351         }
 352         0x15: decode OPCODE_OP_BOTTOM3 {
 353             0x0: TEST(rAb,Ib);
 354             0x1: TEST(rAv,Iz);
 355             0x2: StringInst::STOS(Yb);
 356             0x3: StringInst::STOS(Yv);
 357             0x4: StringInst::LODS(Xb);
 358             0x5: StringInst::LODS(Xv);
 359             0x6: StringTestInst::SCAS(Yb);
 360             0x7: StringTestInst::SCAS(Yv);
 361         }
 362         0x16: MOV(Bb,Ib);
 363         0x17: MOV(Bv,Iv);
 364         0x18: decode OPCODE_OP_BOTTOM3 {
 365             //0x0: group2_Eb_Ib();
 366             0x0: decode MODRM_REG {
 367                 0x0: ROL(Eb,Ib);
 368                 0x1: ROR(Eb,Ib);
 369                 0x2: RCL(Eb,Ib);
 370                 0x3: RCR(Eb,Ib);
 371                 0x4: SAL(Eb,Ib);
 372                 0x5: SHR(Eb,Ib);
 373                 0x6: SAL(Eb,Ib);
 374                 0x7: SAR(Eb,Ib);
 375             }
 376             //0x1: group2_Ev_Ib();
 377             0x1: decode MODRM_REG {
 378                 0x0: ROL(Ev,Ib);
 379                 0x1: ROR(Ev,Ib);
 380                 0x2: RCL(Ev,Ib);
 381                 0x3: RCR(Ev,Ib);
 382                 0x4: SAL(Ev,Ib);
 383                 0x5: SHR(Ev,Ib);
 384                 0x6: SAL(Ev,Ib);
 385                 0x7: SAR(Ev,Ib);
 386             }
 387             0x2: RET_NEAR(Iw);
 388             0x3: RET_NEAR();
 389             0x4: decode MODE_SUBMODE {
 390                 0x0: UD2();
 391                 default: WarnUnimpl::les_Gz_Mp();
 392             }
 393             0x5: decode MODE_SUBMODE {
 394                 0x0: UD2();
 395                 default: WarnUnimpl::lds_Gz_Mp();
 396             }
 397             //0x6: group12_Eb_Ib();
 398             0x6: decode MODRM_REG {
 399                 0x0: MOV(Eb,Ib);
 400                 default: UD2();
 401             }
 402             //0x7: group12_Ev_Iz();
 403             0x7: decode MODRM_REG {
 404                 0x0: MOV(Ev,Iz);
 405                 default: UD2();
 406             }
 407         }
 408         format WarnUnimpl {
 409             0x19: decode OPCODE_OP_BOTTOM3 {
 410                 // The second parameter here should be of size b, but
 411                 // immediate sizes are determined elsewhere and this would
 412                 // confuse the instruction type specialization code.
 413                 0x0: Inst::ENTER(Iw,Iw);
 414                 0x1: Inst::LEAVE();
 415                 0x2: ret_far_Iw();
 416                 0x3: decode MODE_SUBMODE {
 417                     0x3, 0x4: ret_far_real();
 418                     default: Inst::RET_FAR();
 419                 }
 420                 0x4: int3();
 421                 0x5: int_Ib();
 422                 0x6: decode MODE_SUBMODE {
 423                     0x0: Inst::UD2();
 424                     default: into();
 425                 }
 426                 0x7: iret();
 427             }
 428         }
 429         0x1A: decode OPCODE_OP_BOTTOM3 {
 430             //0x0: group2_Eb_1();
 431             0x0: decode MODRM_REG {
 432                 0x0: ROL_1(Eb);
 433                 0x1: ROR_1(Eb);
 434                 0x2: RCL_1(Eb);
 435                 0x3: RCR_1(Eb);
 436                 0x4: SAL_1(Eb);
 437                 0x5: SHR_1(Eb);
 438                 0x6: SAL_1(Eb);
 439                 0x7: SAR_1(Eb);
 440             }
 441             //0x1: group2_Ev_1();
 442             0x1: decode MODRM_REG {
 443                 0x0: ROL_1(Ev);
 444                 0x1: ROR_1(Ev);
 445                 0x2: RCL_1(Ev);
 446                 0x3: RCR_1(Ev);
 447                 0x4: SAL_1(Ev);
 448                 0x5: SHR_1(Ev);
 449                 0x6: SAL_1(Ev);
 450                 0x7: SAR_1(Ev);
 451             }
 452             //0x2: group2_Eb_Cl();
 453             0x2: decode MODRM_REG {
 454                 0x0: ROL(Eb,rCb);
 455                 0x1: ROR(Eb,rCb);
 456                 0x2: RCL(Eb,rCb);
 457                 0x3: RCR(Eb,rCb);
 458                 0x4: SAL(Eb,rCb);
 459                 0x5: SHR(Eb,rCb);
 460                 0x6: SAL(Eb,rCb);
 461                 0x7: SAR(Eb,rCb);
 462             }
 463             //The second operand should have size "b", but to have
 464             //consistent register sizes it's "v". This shouldn't have
 465             //any affect on functionality.
 466             //0x3: group2_Ev_Cl();
 467             0x3: decode MODRM_REG {
 468                 0x0: ROL(Ev,rCv);
 469                 0x1: ROR(Ev,rCv);
 470                 0x2: RCL(Ev,rCv);
 471                 0x3: RCR(Ev,rCv);
 472                 0x4: SAL(Ev,rCv);
 473                 0x5: SHR(Ev,rCv);
 474                 0x6: SAL(Ev,rCv);
 475                 0x7: SAR(Ev,rCv);
 476             }
 477             0x4: decode MODE_SUBMODE {
 478                 0x0: UD2();
 479                 default: WarnUnimpl::aam_Ib();
 480             }
 481             0x5: decode MODE_SUBMODE {
 482                 0x0: UD2();
 483                 default: WarnUnimpl::aad_Ib();
 484             }
 485             0x6: decode MODE_SUBMODE {
 486                 0x0: UD2();
 487                 default: SALC(rAb);
 488             }
 489             0x7: XLAT();
 490         }
 491         ##include "x87.isa"
 492         0x1C: decode OPCODE_OP_BOTTOM3 {
 493             0x0: LOOPNE(Jb);
 494             0x1: LOOPE(Jb);
 495             0x2: LOOP(Jb);
 496             0x3: JRCX(Jb);
 497             0x4: IN(rAb,Ib);
 498             0x5: IN(rAv,Iv);
 499             0x6: OUT(Ib,rAb);
 500             0x7: OUT(Iv,rAv);
 501         }
 502         0x1D: decode OPCODE_OP_BOTTOM3 {
 503             0x0: CALL_NEAR(Jz);
 504             0x1: JMP(Jz);
 505             0x2: decode MODE_SUBMODE {
 506                 0x0: UD2();
 507                 default: WarnUnimpl::jmp_far_Ap();
 508             }
 509             0x3: JMP(Jb);
 510             0x4: IN(rAb,rD);
 511             0x5: IN(rAv,rD);
 512             0x6: OUT(rD,rAb);
 513             0x7: OUT(rD,rAv);
 514         }
 515         0x1E: decode OPCODE_OP_BOTTOM3 {
 516             0x0: M5InternalError::error(
 517                 {{"Tried to execute the lock prefix!"}});
 518             0x1: WarnUnimpl::int1();
 519             0x2: M5InternalError::error(
 520                 {{"Tried to execute the repne prefix!"}});
 521             0x3: M5InternalError::error(
 522                 {{"Tried to execute the rep/repe prefix!"}});
 523             0x4: HLT();
 524             0x5: CMC();
 525             //0x6: group3_Eb();
 526             0x6: decode MODRM_REG {
 527                 0x0: TEST(Eb,Iz);
 528                 0x1: TEST(Eb,Iz);
 529                 0x2: NOT(Eb);
 530                 0x3: NEG(Eb);
 531                 0x4: MUL_B(Eb);
 532                 0x5: IMUL_B(Eb);
 533                 //This should be Eb, but it access the entire word value ax.
 534                 0x6: DIV_B(Ew);
 535                 0x7: IDIV(Eb);
 536             }
 537             //0x7: group3_Ev();
 538             0x7: decode MODRM_REG {
 539                 0x0: TEST(Ev,Iz);
 540                 0x1: TEST(Ev,Iz);
 541                 0x2: NOT(Ev);
 542                 0x3: NEG(Ev);
 543                 0x4: MUL(Ev);
 544                 0x5: IMUL(Ev);
 545                 0x6: DIV(Ev);
 546                 0x7: IDIV(Ev);
 547             }
 548         }
 549         0x1F: decode OPCODE_OP_BOTTOM3 {
 550             0x0: CLC();
 551             0x1: STC();
 552             0x2: WarnUnimpl::cli();
 553             0x3: WarnUnimpl::sti();
 554             0x4: CLD();
 555             0x5: STD();
 556             //0x6: group4();
 557             0x6: decode MODRM_REG {
 558                 0x0: INC(Eb);
 559                 0x1: DEC(Eb);
 560                 default: UD2();
 561             }
 562             //0x7: group5();
 563             0x7: decode MODRM_REG {
 564                 0x0: INC(Ev);
 565                 0x1: DEC(Ev);
 566                 0x2: CALL_NEAR(Ev);
 567                 0x3: WarnUnimpl::call_far_Mp();
 568                 0x4: JMP(Ev);
 569                 0x5: WarnUnimpl::jmp_far_Mp();
 570                 0x6: PUSH(Ev);
 571                 0x7: UD2();
 572             }
 573         }
 574     }
 575     default: FailUnimpl::oneByteOps();
 576 }