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