001 /*
002 * This file is part of the Jikes RVM project (http://jikesrvm.org).
003 *
004 * This file is licensed to You under the Eclipse Public License (EPL);
005 * You may not use this file except in compliance with the License. You
006 * may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/eclipse-1.0.php
009 *
010 * See the COPYRIGHT.txt file distributed with this work for information
011 * regarding copyright ownership.
012 */
013 /*
014 * NOTE: Operator.java is mechanically generated from
015 * Operator.template using the operator definitions in
016 * OperatorList.dat and ia32OperatorList.dat
017 *
018 * DO NOT MANUALLY EDIT THE JAVA FILE.
019 */
020
021 package org.jikesrvm.compilers.opt.ir;
022
023 import org.jikesrvm.*;
024 import org.jikesrvm.ArchitectureSpecificOpt.PhysicalDefUse;
025 import org.jikesrvm.compilers.opt.*;
026 import org.jikesrvm.compilers.opt.instrsched.OperatorClass;
027 import org.jikesrvm.compilers.opt.util.Bits;
028
029 /**
030 * An Operator represents the operator of an {@link Instruction}.
031 * For each operator in the IR, we create exactly one Operator instance
032 * to represent it. These instances are all stored in static fields
033 * of {@link Operators}. Since only one instance is created for each
034 * semantic operator, they can be compared using <code>==</code>.
035 * <p>
036 * A common coding practive is to implement the {@link Operators}
037 * interface to be able to reference the IR operators within a class
038 * without having to prepend 'Operators.' everywhere.
039 *
040 * @see Operators
041 * @see Instruction
042 * @see OperatorNames
043 */
044 public final class Operator {
045
046 /**
047 * The operators opcode.
048 * This value serves as a unique id suitable for use in switches
049 */
050 public final char opcode;
051
052 /**
053 * Encoding of the operator's InstructionFormat.
054 * This field is only meant to be directly referenced
055 * from the mechanically generated InstructionFormat
056 * classes defined in the instructionFormats package.
057 * {@link Instruction} contains an explanation
058 * of the role of InstructionFormats in the IR.
059 */
060 public final byte format;
061
062 /**
063 * encoding of operator traits (characteristics)
064 */
065 private final int traits;
066
067 /**
068 * How many operands of the operator are (pure) defs?
069 */
070 private final int numberDefs;
071
072 /**
073 * How many operands of the operator are both defs and uses?
074 * Only non-zero on IA32, 390.
075 */
076 private final int numberDefUses;
077
078 /**
079 * How many operands of the operator are pure uses?
080 * Only contains a valid value for non-variableLength operators
081 */
082 private final int numberUses;
083
084 /**
085 * Physical registers that are implicitly defined by the operator.
086 */
087 public final int implicitDefs;
088
089 /**
090 * Physical registers that are implicitly used by the operator.
091 */
092 public final int implicitUses;
093
094
095 /**
096 * Operator Class of the operator; used for instruction scheduling.
097 */
098 OperatorClass opClass;
099
100 /**
101 * Sets the operator class.
102 *
103 * @param opClass operator class
104 */
105 public void setOpClass(OperatorClass opClass) {
106 this.opClass = opClass;
107 }
108
109 /**
110 * Gets the operator class.
111 *
112 * @return operator class
113 */
114 public OperatorClass getOpClass() {
115 return opClass;
116 }
117
118
119 /**
120 * Returns the string representation of this operator.
121 *
122 * @return the name of the operator
123 */
124 @Override
125 public String toString() {
126 return OperatorNames.toString(this);
127 }
128
129 /**
130 * Returns the number of operands that are defs.
131 * By convention, operands are ordered in instructions
132 * such that all defs are first, followed by all
133 * combined defs/uses, followed by all pure uses.
134 *
135 * @return number of operands that are pure defs
136 */
137 public int getNumberOfPureDefs() {
138 if (VM.VerifyAssertions) VM._assert(!hasVarDefs());
139 return numberDefs;
140 }
141
142 /**
143 * Returns the number of operands that are pure defs
144 * and are not in the variable-length part of the operand list.
145 * By convention, operands are ordered in instructions
146 * such that all defs are first, followed by all
147 * combined defs/uses, followed by all pure uses.
148 *
149 * @return how many non-variable operands are pure defs
150 */
151 public int getNumberOfFixedPureDefs() {
152 return numberDefs;
153 }
154
155 /**
156 * Returns the number of operands that are pure uses
157 * and are not in the variable-length part of the operand list.
158 * By convention, operands are ordered in instructions
159 * such that all defs are first, followed by all
160 * combined defs/uses, followed by all pure uses.
161 *
162 * @return how many non-variable operands are pure uses
163 */
164 public int getNumberOfFixedPureUses() {
165 return numberUses;
166 }
167
168 /**
169 * Returns the number of operands that are defs
170 * and uses.
171 * By convention, operands are ordered in instructions
172 * such that all defs are first, followed by all
173 * combined defs/uses, followed by all pure uses.
174 *
175 * @return number of operands that are combined defs and uses
176 */
177 public int getNumberOfDefUses() {
178 return numberDefUses;
179 }
180
181 /**
182 * Returns the number of operands that are pure uses.
183 * By convention, operands are ordered in instructions
184 * such that all defs are first, followed by all
185 * combined defs/uses, followed by all pure uses.
186 *
187 * @return number of operands that are pure uses
188 */
189 public int getNumberOfPureUses() {
190 return numberUses;
191 }
192
193 /**
194 * Returns the number of operands that are defs
195 * (either pure defs or combined def/uses).
196 * By convention, operands are ordered in instructions
197 * such that all defs are first, followed by all
198 * combined defs/uses, followed by all pure uses.
199 *
200 * @return number of operands that are defs
201 */
202 public int getNumberOfDefs() {
203 if (VM.VerifyAssertions) VM._assert(!hasVarDefs());
204 return numberDefs + numberDefUses;
205 }
206
207 /**
208 * Returns the number of operands that are uses
209 * (either combined def/uses or pure uses).
210 * By convention, operands are ordered in instructions
211 * such that all defs are first, followed by all
212 * combined defs/uses, followed by all pure uses.
213 *
214 * @return how many operands are uses
215 */
216 public int getNumberOfUses() {
217 if (VM.VerifyAssertions) VM._assert(!hasVarUses());
218 return numberDefUses + numberUses;
219 }
220
221 /**
222 * Returns the number of operands that are pure uses
223 * and are not in the variable-length part of the operand list.
224 * By convention, operands are ordered in instructions
225 * such that all defs are first, followed by all
226 * combined defs/uses, followed by all pure uses.
227 *
228 * @return how many non-variable operands are pure uses
229 */
230 public int getNumberOfPureFixedUses() {
231 return numberUses;
232 }
233
234 /**
235 * Returns the number of operands that are uses
236 * (either combined use/defs or pure uses)
237 * and are not in the variable-length part of the operand list.
238 * By convention, operands are ordered in instructions
239 * such that all defs are first, followed by all
240 * combined defs/uses, followed by all pure uses.
241 *
242 * @return number of non-variable operands are uses
243 */
244 public int getNumberOfFixedUses() {
245 return numberDefUses + numberUses;
246 }
247
248 /**
249 * Returns the number of physical registers that are
250 * implicitly defined by this operator.
251 *
252 * @return number of implicit defs
253 */
254 public int getNumberOfImplicitDefs() {
255 return Integer.bitCount(implicitDefs);
256 }
257
258 /**
259 * Returns the number of physical registers that are
260 * implicitly used by this operator.
261 *
262 * @return number of implicit uses
263 */
264 public int getNumberOfImplicitUses() {
265 return Integer.bitCount(implicitUses);
266 }
267
268 /*
269 * The following are used to encode operator traits in OperatorList.dat.
270 * Had to make a few of them public (yuck) to let us get at them
271 * from InstructionFormat.java.
272 */
273 // operator has no interesting traits
274 public static final int none = 0x00000000;
275 // operator is a simple move operation from one "register" to another
276 private static final int move = 0x00000001;
277 // operator is an intraprocedural branch of some form
278 private static final int branch = 0x00000002;
279 // operator is some kind of call (interprocedural branch)
280 private static final int call = 0x00000004;
281 // modifer for branches/calls
282 private static final int conditional = 0x00000008;
283 // modifier for branches/calls, mostly on MIR
284 private static final int indirect = 0x00000010;
285 // an explicit load of a value from memory
286 private static final int load = 0x00000020;
287 // operator is modeled as a load by memory system, mostly on MIR
288 private static final int memAsLoad = 0x00000040;
289 // an explicit store of a value to memory
290 private static final int store = 0x00000080;
291 // operator is modeled as a store by memory system, mostly on MIR
292 private static final int memAsStore = 0x00000100;
293 // is an exception throw
294 private static final int ethrow = 0x00000200;
295 // an immediate PEI (null_check, int_zero_check, but _not_ call);
296 private static final int immedPEI = 0x00000400;
297 // operator is some kind of compare (val,val)-> cond
298 private static final int compare = 0x00000800;
299 // an explicit memory allocation
300 private static final int alloc = 0x00001000;
301 // a return instruction (interprocedural branch)
302 private static final int ret = 0x00002000;
303 // operator has a variable number of uses
304 public static final int varUses = 0x00004000;
305 // operator has a variable number of defs
306 public static final int varDefs = 0x00008000;
307 // operator is a potential thread switch point for some reason
308 // other than being a call/immedPEI
309 private static final int tsp = 0x00010000;
310 // operator is an acquire (monitorenter/lock) HIR only
311 private static final int acquire = 0x00020000;
312 // operator is a relase (monitorexit/unlock) HIR only
313 private static final int release = 0x00040000;
314 // operator either directly or indirectly may casue dynamic linking
315 private static final int dynLink = 0x00080000;
316 // operator is a yield point
317 private static final int yieldPoint = 0x00100000;
318 // operator pops floating-point stack after performing defs
319 private static final int fpPop = 0x00200000;
320 // operator pushs floating-point stack before performing defs
321 private static final int fpPush = 0x00400000;
322 // operator is commutative
323 private static final int commutative = 0x00800000;
324
325 /**
326 * Does the operator represent a simple move (the value is unchanged)
327 * from one "register" location to another "register" location?
328 *
329 * @return <code>true</code> if the operator is a simple move
330 * or <code>false</code> if it is not.
331 */
332 public boolean isMove() {
333 return (traits & move) != 0;
334 }
335
336 /**
337 * Is the operator an intraprocedural branch?
338 *
339 * @return <code>true</code> if the operator is am
340 * intraprocedural branch or <code>false</code> if it is not.
341 */
342 public boolean isBranch() {
343 return (traits & branch) != 0;
344 }
345
346 /**
347 * Is the operator a conditional intraprocedural branch?
348 *
349 * @return <code>true</code> if the operator is a conditoonal
350 * intraprocedural branch or <code>false</code> if it is not.
351 */
352 public boolean isConditionalBranch() {
353 return (traits & (branch|conditional)) == (branch|conditional);
354 }
355
356 /**
357 * Is the operator an unconditional intraprocedural branch?
358 * We consider various forms of switches to be unconditional
359 * intraprocedural branches, even though they are multi-way branches
360 * and we may not no exactly which target will be taken.
361 * This turns out to be the right thing to do, since some
362 * arm of the switch will always be taken (unlike conditional branches).
363 *
364 * @return <code>true</code> if the operator is an unconditional
365 * intraprocedural branch or <code>false</code> if it is not.
366 */
367 public boolean isUnconditionalBranch() {
368 return (traits & (branch|conditional)) == branch;
369 }
370
371 /**
372 * Is the operator a direct intraprocedural branch?
373 * In the HIR and LIR we consider switches to be direct branches,
374 * because their targets are known precisely.
375 *
376 * @return <code>true</code> if the operator is a direct
377 * intraprocedural branch or <code>false</code> if it is not.
378 */
379 public boolean isDirectBranch() {
380 return (traits & (branch|indirect)) == branch;
381 }
382
383 /**
384 * Is the operator an indirect intraprocedural branch?
385 *
386 * @return <code>true</code> if the operator is an indirect
387 * interprocedural branch or <code>false</code> if it is not.
388 */
389 public boolean isIndirectBranch() {
390 return (traits & (branch|indirect)) == (branch|indirect);
391 }
392
393 /**
394 * Is the operator a call (one kind of interprocedural branch)?
395 *
396 * @return <code>true</code> if the operator is a call
397 * or <code>false</code> if it is not.
398 */
399 public boolean isCall() {
400 return (traits & call) != 0;
401 }
402
403 /**
404 * Is the operator a conditional call?
405 * We only allow conditional calls in the MIR, since they
406 * tend to only be directly implementable on some architecutres.
407 *
408 * @return <code>true</code> if the operator is a
409 * conditional call or <code>false</code> if it is not.
410 */
411 public boolean isConditionalCall() {
412 return (traits & (call|conditional)) == (call|conditional);
413 }
414
415 /**
416 * Is the operator an unconditional call?
417 * Really only an interesting question in the MIR, since
418 * it is by definition true for all HIR and LIR calls.
419 *
420 * @return <code>true</code> if the operator is an unconditional
421 * call or <code>false</code> if it is not.
422 */
423 public boolean isUnconditionalCall() {
424 return (traits & (call|conditional)) == call;
425 }
426
427 /**
428 * Is the operator a direct call?
429 * Only interesting on the MIR. In the HIR and LIR we pretend that
430 * all calls are "direct" even though most of them aren't.
431 *
432 * @return <code>true</code> if the operator is a direct call
433 * or <code>false</code> if it is not.
434 */
435 public boolean isDirectCall() {
436 return (traits & (call|indirect)) == call;
437 }
438
439 /**
440 * Is the operator an indirect call?
441 * Only interesting on the MIR. In the HIR and LIR we pretend that
442 * all calls are "direct" even though most of them aren't.
443 *
444 * @return <code>true</code> if the operator is an indirect call
445 * or <code>false</code> if it is not.
446 */
447 public boolean isIndirectCall() {
448 return (traits & (call|indirect)) == (call|indirect);
449 }
450
451 /**
452 * Is the operator an explicit load of a finite set of values from
453 * a finite set of memory locations (load, load multiple, _not_ call)?
454 *
455 * @return <code>true</code> if the operator is an explicit load
456 * or <code>false</code> if it is not.
457 */
458 public boolean isExplicitLoad() {
459 return (traits & load) != 0;
460 }
461
462 /**
463 * Should the operator be treated as a load from some unknown location(s)
464 * for the purposes of scheduling and/or modeling the memory subsystem?
465 *
466 * @return <code>true</code> if the operator is an implicit load
467 * or <code>false</code> if it is not.
468 */
469 public boolean isImplicitLoad() {
470 return (traits & (load|memAsLoad|call)) != 0;
471 }
472
473 /**
474 * Is the operator an explicit store of a finite set of values to
475 * a finite set of memory locations (store, store multiple, _not_ call)?
476 *
477 * @return <code>true</code> if the operator is an explicit store
478 * or <code>false</code> if it is not.
479 */
480 public boolean isExplicitStore() {
481 return (traits & store) != 0;
482 }
483
484 /**
485 * Should the operator be treated as a store to some unknown location(s)
486 * for the purposes of scheduling and/or modeling the memory subsystem?
487 *
488 * @return <code>true</code> if the operator is an implicit store
489 * or <code>false</code> if it is not.
490 */
491 public boolean isImplicitStore() {
492 return (traits & (store|memAsStore|call)) != 0;
493 }
494
495 /**
496 * Is the operator a throw of a Java exception?
497 *
498 * @return <code>true</code> if the operator is a throw
499 * or <code>false</code> if it is not.
500 */
501 public boolean isThrow() {
502 return (traits & ethrow) != 0;
503 }
504
505 /**
506 * Is the operator a PEI (Potentially Excepting Instruction)?
507 *
508 * @return <code>true</code> if the operator is a PEI
509 * or <code>false</code> if it is not.
510 */
511 public boolean isPEI() {
512 return (traits & (ethrow|immedPEI)) != 0;
513 }
514
515 /**
516 * Is the operator a potential GC point?
517 *
518 * @return <code>true</code> if the operator is a potential
519 * GC point or <code>false</code> if it is not.
520 */
521 public boolean isGCPoint() {
522 return isPEI() || ((traits & (alloc|tsp)) != 0);
523 }
524
525 /**
526 * is the operator a potential thread switch point?
527 *
528 * @return <code>true</code> if the operator is a potential
529 * threadswitch point or <code>false</code> if it is not.
530 */
531 public boolean isTSPoint() {
532 return isGCPoint();
533 }
534
535 /**
536 * Is the operator a compare (val,val) => condition?
537 *
538 * @return <code>true</code> if the operator is a compare
539 * or <code>false</code> if it is not.
540 */
541 public boolean isCompare() {
542 return (traits & compare) != 0;
543 }
544
545 /**
546 * Is the operator an actual memory allocation instruction
547 * (NEW, NEWARRAY, etc)?
548 *
549 * @return <code>true</code> if the operator is an allocation
550 * or <code>false</code> if it is not.
551 */
552 public boolean isAllocation() {
553 return (traits & alloc) != 0;
554 }
555
556 /**
557 * Is the operator a return (interprocedural branch)?
558 *
559 * @return <code>true</code> if the operator is a return
560 * or <code>false</code> if it is not.
561 */
562 public boolean isReturn() {
563 return (traits & ret) != 0;
564 }
565
566 /**
567 * Can the operator have a variable number of uses?
568 *
569 * @return <code>true</code> if the operator has a variable number
570 * of uses or <code>false</code> if it does not.
571 */
572 public boolean hasVarUses() {
573 return (traits & varUses) != 0;
574 }
575
576 /**
577 * Can the operator have a variable number of uses?
578 *
579 * @return <code>true</code> if the operator has a variable number
580 * of uses or <code>false</code> if it does not.
581 */
582 public boolean hasVarDefs() {
583 return (traits & varDefs) != 0;
584 }
585
586 /**
587 * Can the operator have a variable number of uses or defs?
588 *
589 * @return <code>true</code> if the operator has a variable number
590 * of uses or defs or <code>false</code> if it does not.
591 */
592 public boolean hasVarUsesOrDefs() {
593 return (traits & (varUses | varDefs)) != 0;
594 }
595
596 /**
597 * Is the operator an acquire (monitorenter/lock)?
598 *
599 * @return <code>true</code> if the operator is an acquire
600 * or <code>false</code> if it is not.
601 */
602 public boolean isAcquire() {
603 return (traits & acquire) != 0;
604 }
605
606 /**
607 * Is the operator a release (monitorexit/unlock)?
608 *
609 * @return <code>true</code> if the operator is a release
610 * or <code>false</code> if it is not.
611 */
612 public boolean isRelease() {
613 return (traits & release) != 0;
614 }
615
616 /**
617 * Could the operator either directly or indirectly
618 * cause dynamic class loading?
619 *
620 * @return <code>true</code> if the operator is a dynamic linking point
621 * or <code>false</code> if it is not.
622 */
623 public boolean isDynamicLinkingPoint() {
624 return (traits & dynLink) != 0;
625 }
626
627 /**
628 * Is the operator a yield point?
629 *
630 * @return <code>true</code> if the operator is a yield point
631 * or <code>false</code> if it is not.
632 */
633 public boolean isYieldPoint() {
634 return (traits & yieldPoint) != 0;
635 }
636
637 /**
638 * Does the operator pop the floating-point stack?
639 *
640 * @return <code>true</code> if the operator pops the floating-point
641 * stack.
642 * or <code>false</code> if not.
643 */
644 public boolean isFpPop() {
645 return (traits & fpPop) != 0;
646 }
647
648 /**
649 * Does the operator push on the floating-point stack?
650 *
651 * @return <code>true</code> if the operator pushes on the floating-point
652 * stack.
653 * or <code>false</code> if not.
654 */
655 public boolean isFpPush() {
656 return (traits & fpPush) != 0;
657 }
658
659 /**
660 * Is the operator commutative?
661 *
662 * @return <code>true</code> if the operator is commutative.
663 * or <code>false</code> if not.
664 */
665 public boolean isCommutative() {
666 return (traits & commutative) != 0;
667 }
668
669
670 public static final Operator[] OperatorArray = {
671 new Operator((char)0, InstructionFormat.Nullary_format, //GET_CAUGHT_EXCEPTION
672 (none | InstructionFormat.Nullary_traits),
673 1, 0, 0,
674 PhysicalDefUse.mask,
675 PhysicalDefUse.mask),
676 new Operator((char)1, InstructionFormat.CacheOp_format, //SET_CAUGHT_EXCEPTION
677 (none | InstructionFormat.CacheOp_traits),
678 0, 0, 1,
679 PhysicalDefUse.mask,
680 PhysicalDefUse.mask),
681 new Operator((char)2, InstructionFormat.New_format, //NEW
682 (alloc | immedPEI | InstructionFormat.New_traits),
683 1, 0, 1,
684 PhysicalDefUse.mask,
685 PhysicalDefUse.mask),
686 new Operator((char)3, InstructionFormat.New_format, //NEW_UNRESOLVED
687 (alloc | immedPEI | dynLink | InstructionFormat.New_traits),
688 1, 0, 1,
689 PhysicalDefUse.mask,
690 PhysicalDefUse.mask),
691 new Operator((char)4, InstructionFormat.NewArray_format, //NEWARRAY
692 (alloc | immedPEI | InstructionFormat.NewArray_traits),
693 1, 0, 2,
694 PhysicalDefUse.mask,
695 PhysicalDefUse.mask),
696 new Operator((char)5, InstructionFormat.NewArray_format, //NEWARRAY_UNRESOLVED
697 (alloc | immedPEI | dynLink | InstructionFormat.NewArray_traits),
698 1, 0, 2,
699 PhysicalDefUse.mask,
700 PhysicalDefUse.mask),
701 new Operator((char)6, InstructionFormat.Athrow_format, //ATHROW
702 (ethrow | InstructionFormat.Athrow_traits),
703 0, 0, 1,
704 PhysicalDefUse.mask,
705 PhysicalDefUse.mask),
706 new Operator((char)7, InstructionFormat.TypeCheck_format, //CHECKCAST
707 (immedPEI | InstructionFormat.TypeCheck_traits),
708 1, 0, 3,
709 PhysicalDefUse.mask,
710 PhysicalDefUse.mask),
711 new Operator((char)8, InstructionFormat.TypeCheck_format, //CHECKCAST_NOTNULL
712 (immedPEI | InstructionFormat.TypeCheck_traits),
713 1, 0, 3,
714 PhysicalDefUse.mask,
715 PhysicalDefUse.mask),
716 new Operator((char)9, InstructionFormat.TypeCheck_format, //CHECKCAST_UNRESOLVED
717 (immedPEI | dynLink | InstructionFormat.TypeCheck_traits),
718 1, 0, 3,
719 PhysicalDefUse.mask,
720 PhysicalDefUse.mask),
721 new Operator((char)10, InstructionFormat.TypeCheck_format, //MUST_IMPLEMENT_INTERFACE
722 (immedPEI | InstructionFormat.TypeCheck_traits),
723 1, 0, 3,
724 PhysicalDefUse.mask,
725 PhysicalDefUse.mask),
726 new Operator((char)11, InstructionFormat.InstanceOf_format, //INSTANCEOF
727 (none | InstructionFormat.InstanceOf_traits),
728 1, 0, 3,
729 PhysicalDefUse.mask,
730 PhysicalDefUse.mask),
731 new Operator((char)12, InstructionFormat.InstanceOf_format, //INSTANCEOF_NOTNULL
732 (none | InstructionFormat.InstanceOf_traits),
733 1, 0, 3,
734 PhysicalDefUse.mask,
735 PhysicalDefUse.mask),
736 new Operator((char)13, InstructionFormat.InstanceOf_format, //INSTANCEOF_UNRESOLVED
737 (immedPEI | dynLink | InstructionFormat.InstanceOf_traits),
738 1, 0, 3,
739 PhysicalDefUse.mask,
740 PhysicalDefUse.mask),
741 new Operator((char)14, InstructionFormat.MonitorOp_format, //MONITORENTER
742 (memAsLoad | memAsStore | acquire | tsp | InstructionFormat.MonitorOp_traits),
743 0, 0, 2,
744 PhysicalDefUse.mask,
745 PhysicalDefUse.mask),
746 new Operator((char)15, InstructionFormat.MonitorOp_format, //MONITOREXIT
747 (memAsLoad | memAsStore | release | tsp | immedPEI | InstructionFormat.MonitorOp_traits),
748 0, 0, 2,
749 PhysicalDefUse.mask,
750 PhysicalDefUse.mask),
751 new Operator((char)16, InstructionFormat.Multianewarray_format, //NEWOBJMULTIARRAY
752 (alloc | immedPEI | dynLink | InstructionFormat.Multianewarray_traits),
753 1, 0, 1,
754 PhysicalDefUse.mask,
755 PhysicalDefUse.mask),
756 new Operator((char)17, InstructionFormat.GetStatic_format, //GETSTATIC
757 (load | InstructionFormat.GetStatic_traits),
758 1, 0, 2,
759 PhysicalDefUse.mask,
760 PhysicalDefUse.mask),
761 new Operator((char)18, InstructionFormat.PutStatic_format, //PUTSTATIC
762 (store | InstructionFormat.PutStatic_traits),
763 0, 0, 3,
764 PhysicalDefUse.mask,
765 PhysicalDefUse.mask),
766 new Operator((char)19, InstructionFormat.GetField_format, //GETFIELD
767 (load | InstructionFormat.GetField_traits),
768 1, 0, 4,
769 PhysicalDefUse.mask,
770 PhysicalDefUse.mask),
771 new Operator((char)20, InstructionFormat.PutField_format, //PUTFIELD
772 (store | InstructionFormat.PutField_traits),
773 0, 0, 5,
774 PhysicalDefUse.mask,
775 PhysicalDefUse.mask),
776 new Operator((char)21, InstructionFormat.ZeroCheck_format, //INT_ZERO_CHECK
777 (immedPEI | InstructionFormat.ZeroCheck_traits),
778 1, 0, 1,
779 PhysicalDefUse.mask,
780 PhysicalDefUse.mask),
781 new Operator((char)22, InstructionFormat.ZeroCheck_format, //LONG_ZERO_CHECK
782 (immedPEI | InstructionFormat.ZeroCheck_traits),
783 1, 0, 1,
784 PhysicalDefUse.mask,
785 PhysicalDefUse.mask),
786 new Operator((char)23, InstructionFormat.BoundsCheck_format, //BOUNDS_CHECK
787 (immedPEI | InstructionFormat.BoundsCheck_traits),
788 1, 0, 3,
789 PhysicalDefUse.mask,
790 PhysicalDefUse.mask),
791 new Operator((char)24, InstructionFormat.StoreCheck_format, //OBJARRAY_STORE_CHECK
792 (immedPEI | InstructionFormat.StoreCheck_traits),
793 1, 0, 3,
794 PhysicalDefUse.mask,
795 PhysicalDefUse.mask),
796 new Operator((char)25, InstructionFormat.StoreCheck_format, //OBJARRAY_STORE_CHECK_NOTNULL
797 (immedPEI | InstructionFormat.StoreCheck_traits),
798 1, 0, 3,
799 PhysicalDefUse.mask,
800 PhysicalDefUse.mask),
801 new Operator((char)26, InstructionFormat.InlineGuard_format, //IG_PATCH_POINT
802 (branch | conditional | InstructionFormat.InlineGuard_traits),
803 0, 0, 5,
804 PhysicalDefUse.mask,
805 PhysicalDefUse.mask),
806 new Operator((char)27, InstructionFormat.InlineGuard_format, //IG_CLASS_TEST
807 (branch | conditional | InstructionFormat.InlineGuard_traits),
808 0, 0, 5,
809 PhysicalDefUse.mask,
810 PhysicalDefUse.mask),
811 new Operator((char)28, InstructionFormat.InlineGuard_format, //IG_METHOD_TEST
812 (branch | conditional | InstructionFormat.InlineGuard_traits),
813 0, 0, 5,
814 PhysicalDefUse.mask,
815 PhysicalDefUse.mask),
816 new Operator((char)29, InstructionFormat.TableSwitch_format, //TABLESWITCH
817 (branch | InstructionFormat.TableSwitch_traits),
818 0, 0, 7,
819 PhysicalDefUse.mask,
820 PhysicalDefUse.mask),
821 new Operator((char)30, InstructionFormat.LookupSwitch_format, //LOOKUPSWITCH
822 (branch | InstructionFormat.LookupSwitch_traits),
823 0, 0, 5,
824 PhysicalDefUse.mask,
825 PhysicalDefUse.mask),
826 new Operator((char)31, InstructionFormat.ALoad_format, //INT_ALOAD
827 (load | InstructionFormat.ALoad_traits),
828 1, 0, 4,
829 PhysicalDefUse.mask,
830 PhysicalDefUse.mask),
831 new Operator((char)32, InstructionFormat.ALoad_format, //LONG_ALOAD
832 (load | InstructionFormat.ALoad_traits),
833 1, 0, 4,
834 PhysicalDefUse.mask,
835 PhysicalDefUse.mask),
836 new Operator((char)33, InstructionFormat.ALoad_format, //FLOAT_ALOAD
837 (load | InstructionFormat.ALoad_traits),
838 1, 0, 4,
839 PhysicalDefUse.mask,
840 PhysicalDefUse.mask),
841 new Operator((char)34, InstructionFormat.ALoad_format, //DOUBLE_ALOAD
842 (load | InstructionFormat.ALoad_traits),
843 1, 0, 4,
844 PhysicalDefUse.mask,
845 PhysicalDefUse.mask),
846 new Operator((char)35, InstructionFormat.ALoad_format, //REF_ALOAD
847 (load | InstructionFormat.ALoad_traits),
848 1, 0, 4,
849 PhysicalDefUse.mask,
850 PhysicalDefUse.mask),
851 new Operator((char)36, InstructionFormat.ALoad_format, //UBYTE_ALOAD
852 (load | InstructionFormat.ALoad_traits),
853 1, 0, 4,
854 PhysicalDefUse.mask,
855 PhysicalDefUse.mask),
856 new Operator((char)37, InstructionFormat.ALoad_format, //BYTE_ALOAD
857 (load | InstructionFormat.ALoad_traits),
858 1, 0, 4,
859 PhysicalDefUse.mask,
860 PhysicalDefUse.mask),
861 new Operator((char)38, InstructionFormat.ALoad_format, //USHORT_ALOAD
862 (load | InstructionFormat.ALoad_traits),
863 1, 0, 4,
864 PhysicalDefUse.mask,
865 PhysicalDefUse.mask),
866 new Operator((char)39, InstructionFormat.ALoad_format, //SHORT_ALOAD
867 (load | InstructionFormat.ALoad_traits),
868 1, 0, 4,
869 PhysicalDefUse.mask,
870 PhysicalDefUse.mask),
871 new Operator((char)40, InstructionFormat.AStore_format, //INT_ASTORE
872 (store | InstructionFormat.AStore_traits),
873 0, 0, 5,
874 PhysicalDefUse.mask,
875 PhysicalDefUse.mask),
876 new Operator((char)41, InstructionFormat.AStore_format, //LONG_ASTORE
877 (store | InstructionFormat.AStore_traits),
878 0, 0, 5,
879 PhysicalDefUse.mask,
880 PhysicalDefUse.mask),
881 new Operator((char)42, InstructionFormat.AStore_format, //FLOAT_ASTORE
882 (store | InstructionFormat.AStore_traits),
883 0, 0, 5,
884 PhysicalDefUse.mask,
885 PhysicalDefUse.mask),
886 new Operator((char)43, InstructionFormat.AStore_format, //DOUBLE_ASTORE
887 (store | InstructionFormat.AStore_traits),
888 0, 0, 5,
889 PhysicalDefUse.mask,
890 PhysicalDefUse.mask),
891 new Operator((char)44, InstructionFormat.AStore_format, //REF_ASTORE
892 (store | InstructionFormat.AStore_traits),
893 0, 0, 5,
894 PhysicalDefUse.mask,
895 PhysicalDefUse.mask),
896 new Operator((char)45, InstructionFormat.AStore_format, //BYTE_ASTORE
897 (store | InstructionFormat.AStore_traits),
898 0, 0, 5,
899 PhysicalDefUse.mask,
900 PhysicalDefUse.mask),
901 new Operator((char)46, InstructionFormat.AStore_format, //SHORT_ASTORE
902 (store | InstructionFormat.AStore_traits),
903 0, 0, 5,
904 PhysicalDefUse.mask,
905 PhysicalDefUse.mask),
906 new Operator((char)47, InstructionFormat.IfCmp_format, //INT_IFCMP
907 (branch | conditional | InstructionFormat.IfCmp_traits),
908 1, 0, 5,
909 PhysicalDefUse.mask,
910 PhysicalDefUse.mask),
911 new Operator((char)48, InstructionFormat.IfCmp2_format, //INT_IFCMP2
912 (branch | conditional | InstructionFormat.IfCmp2_traits),
913 1, 0, 8,
914 PhysicalDefUse.mask,
915 PhysicalDefUse.mask),
916 new Operator((char)49, InstructionFormat.IfCmp_format, //LONG_IFCMP
917 (branch | conditional | InstructionFormat.IfCmp_traits),
918 1, 0, 5,
919 PhysicalDefUse.mask,
920 PhysicalDefUse.mask),
921 new Operator((char)50, InstructionFormat.IfCmp_format, //FLOAT_IFCMP
922 (branch | conditional | InstructionFormat.IfCmp_traits),
923 1, 0, 5,
924 PhysicalDefUse.mask,
925 PhysicalDefUse.mask),
926 new Operator((char)51, InstructionFormat.IfCmp_format, //DOUBLE_IFCMP
927 (branch | conditional | InstructionFormat.IfCmp_traits),
928 1, 0, 5,
929 PhysicalDefUse.mask,
930 PhysicalDefUse.mask),
931 new Operator((char)52, InstructionFormat.IfCmp_format, //REF_IFCMP
932 (branch | conditional | InstructionFormat.IfCmp_traits),
933 1, 0, 5,
934 PhysicalDefUse.mask,
935 PhysicalDefUse.mask),
936 new Operator((char)53, InstructionFormat.Label_format, //LABEL
937 (none | InstructionFormat.Label_traits),
938 0, 0, 1,
939 PhysicalDefUse.mask,
940 PhysicalDefUse.mask),
941 new Operator((char)54, InstructionFormat.BBend_format, //BBEND
942 (none | InstructionFormat.BBend_traits),
943 0, 0, 1,
944 PhysicalDefUse.mask,
945 PhysicalDefUse.mask),
946 new Operator((char)55, InstructionFormat.Empty_format, //UNINT_BEGIN
947 (none | InstructionFormat.Empty_traits),
948 0, 0, 0,
949 PhysicalDefUse.mask,
950 PhysicalDefUse.mask),
951 new Operator((char)56, InstructionFormat.Empty_format, //UNINT_END
952 (none | InstructionFormat.Empty_traits),
953 0, 0, 0,
954 PhysicalDefUse.mask,
955 PhysicalDefUse.mask),
956 new Operator((char)57, InstructionFormat.Empty_format, //FENCE
957 (memAsLoad | memAsStore | release | InstructionFormat.Empty_traits),
958 0, 0, 0,
959 PhysicalDefUse.mask,
960 PhysicalDefUse.mask),
961 new Operator((char)58, InstructionFormat.Empty_format, //READ_CEILING
962 (memAsLoad | memAsStore | acquire | InstructionFormat.Empty_traits),
963 0, 0, 0,
964 PhysicalDefUse.mask,
965 PhysicalDefUse.mask),
966 new Operator((char)59, InstructionFormat.Empty_format, //WRITE_FLOOR
967 (memAsLoad | memAsStore | release | InstructionFormat.Empty_traits),
968 0, 0, 0,
969 PhysicalDefUse.mask,
970 PhysicalDefUse.mask),
971 new Operator((char)60, InstructionFormat.Phi_format, //PHI
972 (none | InstructionFormat.Phi_traits),
973 1, 0, 0,
974 PhysicalDefUse.mask,
975 PhysicalDefUse.mask),
976 new Operator((char)61, InstructionFormat.Unary_format, //SPLIT
977 (none | InstructionFormat.Unary_traits),
978 1, 0, 1,
979 PhysicalDefUse.mask,
980 PhysicalDefUse.mask),
981 new Operator((char)62, InstructionFormat.GuardedUnary_format, //PI
982 (none | InstructionFormat.GuardedUnary_traits),
983 1, 0, 2,
984 PhysicalDefUse.mask,
985 PhysicalDefUse.mask),
986 new Operator((char)63, InstructionFormat.Empty_format, //NOP
987 (none | InstructionFormat.Empty_traits),
988 0, 0, 0,
989 PhysicalDefUse.mask,
990 PhysicalDefUse.mask),
991 new Operator((char)64, InstructionFormat.Move_format, //INT_MOVE
992 (move | InstructionFormat.Move_traits),
993 1, 0, 1,
994 PhysicalDefUse.mask,
995 PhysicalDefUse.mask),
996 new Operator((char)65, InstructionFormat.Move_format, //LONG_MOVE
997 (move | InstructionFormat.Move_traits),
998 1, 0, 1,
999 PhysicalDefUse.mask,
1000 PhysicalDefUse.mask),
1001 new Operator((char)66, InstructionFormat.Move_format, //FLOAT_MOVE
1002 (move | InstructionFormat.Move_traits),
1003 1, 0, 1,
1004 PhysicalDefUse.mask,
1005 PhysicalDefUse.mask),
1006 new Operator((char)67, InstructionFormat.Move_format, //DOUBLE_MOVE
1007 (move | InstructionFormat.Move_traits),
1008 1, 0, 1,
1009 PhysicalDefUse.mask,
1010 PhysicalDefUse.mask),
1011 new Operator((char)68, InstructionFormat.Move_format, //REF_MOVE
1012 (move | InstructionFormat.Move_traits),
1013 1, 0, 1,
1014 PhysicalDefUse.mask,
1015 PhysicalDefUse.mask),
1016 new Operator((char)69, InstructionFormat.Move_format, //GUARD_MOVE
1017 (move | InstructionFormat.Move_traits),
1018 1, 0, 1,
1019 PhysicalDefUse.mask,
1020 PhysicalDefUse.mask),
1021 new Operator((char)70, InstructionFormat.CondMove_format, //INT_COND_MOVE
1022 (compare | InstructionFormat.CondMove_traits),
1023 1, 0, 5,
1024 PhysicalDefUse.mask,
1025 PhysicalDefUse.mask),
1026 new Operator((char)71, InstructionFormat.CondMove_format, //LONG_COND_MOVE
1027 (compare | InstructionFormat.CondMove_traits),
1028 1, 0, 5,
1029 PhysicalDefUse.mask,
1030 PhysicalDefUse.mask),
1031 new Operator((char)72, InstructionFormat.CondMove_format, //FLOAT_COND_MOVE
1032 (compare | InstructionFormat.CondMove_traits),
1033 1, 0, 5,
1034 PhysicalDefUse.mask,
1035 PhysicalDefUse.mask),
1036 new Operator((char)73, InstructionFormat.CondMove_format, //DOUBLE_COND_MOVE
1037 (compare | InstructionFormat.CondMove_traits),
1038 1, 0, 5,
1039 PhysicalDefUse.mask,
1040 PhysicalDefUse.mask),
1041 new Operator((char)74, InstructionFormat.CondMove_format, //REF_COND_MOVE
1042 (compare | InstructionFormat.CondMove_traits),
1043 1, 0, 5,
1044 PhysicalDefUse.mask,
1045 PhysicalDefUse.mask),
1046 new Operator((char)75, InstructionFormat.CondMove_format, //GUARD_COND_MOVE
1047 (compare | InstructionFormat.CondMove_traits),
1048 1, 0, 5,
1049 PhysicalDefUse.mask,
1050 PhysicalDefUse.mask),
1051 new Operator((char)76, InstructionFormat.Binary_format, //GUARD_COMBINE
1052 (none | InstructionFormat.Binary_traits),
1053 1, 0, 2,
1054 PhysicalDefUse.mask,
1055 PhysicalDefUse.mask),
1056 new Operator((char)77, InstructionFormat.Binary_format, //REF_ADD
1057 (commutative | InstructionFormat.Binary_traits),
1058 1, 0, 2,
1059 PhysicalDefUse.mask,
1060 PhysicalDefUse.mask),
1061 new Operator((char)78, InstructionFormat.Binary_format, //INT_ADD
1062 (commutative | InstructionFormat.Binary_traits),
1063 1, 0, 2,
1064 PhysicalDefUse.mask,
1065 PhysicalDefUse.mask),
1066 new Operator((char)79, InstructionFormat.Binary_format, //LONG_ADD
1067 (commutative | InstructionFormat.Binary_traits),
1068 1, 0, 2,
1069 PhysicalDefUse.mask,
1070 PhysicalDefUse.mask),
1071 new Operator((char)80, InstructionFormat.Binary_format, //FLOAT_ADD
1072 (commutative | InstructionFormat.Binary_traits),
1073 1, 0, 2,
1074 PhysicalDefUse.mask,
1075 PhysicalDefUse.mask),
1076 new Operator((char)81, InstructionFormat.Binary_format, //DOUBLE_ADD
1077 (commutative | InstructionFormat.Binary_traits),
1078 1, 0, 2,
1079 PhysicalDefUse.mask,
1080 PhysicalDefUse.mask),
1081 new Operator((char)82, InstructionFormat.Binary_format, //REF_SUB
1082 (none | InstructionFormat.Binary_traits),
1083 1, 0, 2,
1084 PhysicalDefUse.mask,
1085 PhysicalDefUse.mask),
1086 new Operator((char)83, InstructionFormat.Binary_format, //INT_SUB
1087 (none | InstructionFormat.Binary_traits),
1088 1, 0, 2,
1089 PhysicalDefUse.mask,
1090 PhysicalDefUse.mask),
1091 new Operator((char)84, InstructionFormat.Binary_format, //LONG_SUB
1092 (none | InstructionFormat.Binary_traits),
1093 1, 0, 2,
1094 PhysicalDefUse.mask,
1095 PhysicalDefUse.mask),
1096 new Operator((char)85, InstructionFormat.Binary_format, //FLOAT_SUB
1097 (none | InstructionFormat.Binary_traits),
1098 1, 0, 2,
1099 PhysicalDefUse.mask,
1100 PhysicalDefUse.mask),
1101 new Operator((char)86, InstructionFormat.Binary_format, //DOUBLE_SUB
1102 (none | InstructionFormat.Binary_traits),
1103 1, 0, 2,
1104 PhysicalDefUse.mask,
1105 PhysicalDefUse.mask),
1106 new Operator((char)87, InstructionFormat.Binary_format, //INT_MUL
1107 (commutative | InstructionFormat.Binary_traits),
1108 1, 0, 2,
1109 PhysicalDefUse.mask,
1110 PhysicalDefUse.mask),
1111 new Operator((char)88, InstructionFormat.Binary_format, //LONG_MUL
1112 (commutative | InstructionFormat.Binary_traits),
1113 1, 0, 2,
1114 PhysicalDefUse.mask,
1115 PhysicalDefUse.mask),
1116 new Operator((char)89, InstructionFormat.Binary_format, //FLOAT_MUL
1117 (commutative | InstructionFormat.Binary_traits),
1118 1, 0, 2,
1119 PhysicalDefUse.mask,
1120 PhysicalDefUse.mask),
1121 new Operator((char)90, InstructionFormat.Binary_format, //DOUBLE_MUL
1122 (commutative | InstructionFormat.Binary_traits),
1123 1, 0, 2,
1124 PhysicalDefUse.mask,
1125 PhysicalDefUse.mask),
1126 new Operator((char)91, InstructionFormat.GuardedBinary_format, //INT_DIV
1127 (none | InstructionFormat.GuardedBinary_traits),
1128 1, 0, 3,
1129 PhysicalDefUse.mask,
1130 PhysicalDefUse.mask),
1131 new Operator((char)92, InstructionFormat.GuardedBinary_format, //LONG_DIV
1132 (none | InstructionFormat.GuardedBinary_traits),
1133 1, 0, 3,
1134 PhysicalDefUse.mask,
1135 PhysicalDefUse.mask),
1136 new Operator((char)93, InstructionFormat.Binary_format, //FLOAT_DIV
1137 (none | InstructionFormat.Binary_traits),
1138 1, 0, 2,
1139 PhysicalDefUse.mask,
1140 PhysicalDefUse.mask),
1141 new Operator((char)94, InstructionFormat.Binary_format, //DOUBLE_DIV
1142 (none | InstructionFormat.Binary_traits),
1143 1, 0, 2,
1144 PhysicalDefUse.mask,
1145 PhysicalDefUse.mask),
1146 new Operator((char)95, InstructionFormat.GuardedBinary_format, //INT_REM
1147 (none | InstructionFormat.GuardedBinary_traits),
1148 1, 0, 3,
1149 PhysicalDefUse.mask,
1150 PhysicalDefUse.mask),
1151 new Operator((char)96, InstructionFormat.GuardedBinary_format, //LONG_REM
1152 (none | InstructionFormat.GuardedBinary_traits),
1153 1, 0, 3,
1154 PhysicalDefUse.mask,
1155 PhysicalDefUse.mask),
1156 new Operator((char)97, InstructionFormat.Binary_format, //FLOAT_REM
1157 (none | InstructionFormat.Binary_traits),
1158 1, 0, 2,
1159 PhysicalDefUse.maskIEEEMagicUses,
1160 PhysicalDefUse.mask),
1161 new Operator((char)98, InstructionFormat.Binary_format, //DOUBLE_REM
1162 (none | InstructionFormat.Binary_traits),
1163 1, 0, 2,
1164 PhysicalDefUse.maskIEEEMagicUses,
1165 PhysicalDefUse.mask),
1166 new Operator((char)99, InstructionFormat.Unary_format, //REF_NEG
1167 (none | InstructionFormat.Unary_traits),
1168 1, 0, 1,
1169 PhysicalDefUse.mask,
1170 PhysicalDefUse.mask),
1171 new Operator((char)100, InstructionFormat.Unary_format, //INT_NEG
1172 (none | InstructionFormat.Unary_traits),
1173 1, 0, 1,
1174 PhysicalDefUse.mask,
1175 PhysicalDefUse.mask),
1176 new Operator((char)101, InstructionFormat.Unary_format, //LONG_NEG
1177 (none | InstructionFormat.Unary_traits),
1178 1, 0, 1,
1179 PhysicalDefUse.mask,
1180 PhysicalDefUse.mask),
1181 new Operator((char)102, InstructionFormat.Unary_format, //FLOAT_NEG
1182 (none | InstructionFormat.Unary_traits),
1183 1, 0, 1,
1184 PhysicalDefUse.mask,
1185 PhysicalDefUse.mask),
1186 new Operator((char)103, InstructionFormat.Unary_format, //DOUBLE_NEG
1187 (none | InstructionFormat.Unary_traits),
1188 1, 0, 1,
1189 PhysicalDefUse.mask,
1190 PhysicalDefUse.mask),
1191 new Operator((char)104, InstructionFormat.Unary_format, //FLOAT_SQRT
1192 (none | InstructionFormat.Unary_traits),
1193 1, 0, 1,
1194 PhysicalDefUse.mask,
1195 PhysicalDefUse.mask),
1196 new Operator((char)105, InstructionFormat.Unary_format, //DOUBLE_SQRT
1197 (none | InstructionFormat.Unary_traits),
1198 1, 0, 1,
1199 PhysicalDefUse.mask,
1200 PhysicalDefUse.mask),
1201 new Operator((char)106, InstructionFormat.Binary_format, //REF_SHL
1202 (none | InstructionFormat.Binary_traits),
1203 1, 0, 2,
1204 PhysicalDefUse.mask,
1205 PhysicalDefUse.mask),
1206 new Operator((char)107, InstructionFormat.Binary_format, //INT_SHL
1207 (none | InstructionFormat.Binary_traits),
1208 1, 0, 2,
1209 PhysicalDefUse.mask,
1210 PhysicalDefUse.mask),
1211 new Operator((char)108, InstructionFormat.Binary_format, //LONG_SHL
1212 (none | InstructionFormat.Binary_traits),
1213 1, 0, 2,
1214 PhysicalDefUse.mask,
1215 PhysicalDefUse.mask),
1216 new Operator((char)109, InstructionFormat.Binary_format, //REF_SHR
1217 (none | InstructionFormat.Binary_traits),
1218 1, 0, 2,
1219 PhysicalDefUse.mask,
1220 PhysicalDefUse.mask),
1221 new Operator((char)110, InstructionFormat.Binary_format, //INT_SHR
1222 (none | InstructionFormat.Binary_traits),
1223 1, 0, 2,
1224 PhysicalDefUse.mask,
1225 PhysicalDefUse.mask),
1226 new Operator((char)111, InstructionFormat.Binary_format, //LONG_SHR
1227 (none | InstructionFormat.Binary_traits),
1228 1, 0, 2,
1229 PhysicalDefUse.mask,
1230 PhysicalDefUse.mask),
1231 new Operator((char)112, InstructionFormat.Binary_format, //REF_USHR
1232 (none | InstructionFormat.Binary_traits),
1233 1, 0, 2,
1234 PhysicalDefUse.mask,
1235 PhysicalDefUse.mask),
1236 new Operator((char)113, InstructionFormat.Binary_format, //INT_USHR
1237 (none | InstructionFormat.Binary_traits),
1238 1, 0, 2,
1239 PhysicalDefUse.mask,
1240 PhysicalDefUse.mask),
1241 new Operator((char)114, InstructionFormat.Binary_format, //LONG_USHR
1242 (none | InstructionFormat.Binary_traits),
1243 1, 0, 2,
1244 PhysicalDefUse.mask,
1245 PhysicalDefUse.mask),
1246 new Operator((char)115, InstructionFormat.Binary_format, //REF_AND
1247 (commutative | InstructionFormat.Binary_traits),
1248 1, 0, 2,
1249 PhysicalDefUse.mask,
1250 PhysicalDefUse.mask),
1251 new Operator((char)116, InstructionFormat.Binary_format, //INT_AND
1252 (commutative | InstructionFormat.Binary_traits),
1253 1, 0, 2,
1254 PhysicalDefUse.mask,
1255 PhysicalDefUse.mask),
1256 new Operator((char)117, InstructionFormat.Binary_format, //LONG_AND
1257 (commutative | InstructionFormat.Binary_traits),
1258 1, 0, 2,
1259 PhysicalDefUse.mask,
1260 PhysicalDefUse.mask),
1261 new Operator((char)118, InstructionFormat.Binary_format, //REF_OR
1262 (commutative | InstructionFormat.Binary_traits),
1263 1, 0, 2,
1264 PhysicalDefUse.mask,
1265 PhysicalDefUse.mask),
1266 new Operator((char)119, InstructionFormat.Binary_format, //INT_OR
1267 (commutative | InstructionFormat.Binary_traits),
1268 1, 0, 2,
1269 PhysicalDefUse.mask,
1270 PhysicalDefUse.mask),
1271 new Operator((char)120, InstructionFormat.Binary_format, //LONG_OR
1272 (commutative | InstructionFormat.Binary_traits),
1273 1, 0, 2,
1274 PhysicalDefUse.mask,
1275 PhysicalDefUse.mask),
1276 new Operator((char)121, InstructionFormat.Binary_format, //REF_XOR
1277 (commutative | InstructionFormat.Binary_traits),
1278 1, 0, 2,
1279 PhysicalDefUse.mask,
1280 PhysicalDefUse.mask),
1281 new Operator((char)122, InstructionFormat.Binary_format, //INT_XOR
1282 (commutative | InstructionFormat.Binary_traits),
1283 1, 0, 2,
1284 PhysicalDefUse.mask,
1285 PhysicalDefUse.mask),
1286 new Operator((char)123, InstructionFormat.Unary_format, //REF_NOT
1287 (none | InstructionFormat.Unary_traits),
1288 1, 0, 1,
1289 PhysicalDefUse.mask,
1290 PhysicalDefUse.mask),
1291 new Operator((char)124, InstructionFormat.Unary_format, //INT_NOT
1292 (none | InstructionFormat.Unary_traits),
1293 1, 0, 1,
1294 PhysicalDefUse.mask,
1295 PhysicalDefUse.mask),
1296 new Operator((char)125, InstructionFormat.Unary_format, //LONG_NOT
1297 (none | InstructionFormat.Unary_traits),
1298 1, 0, 1,
1299 PhysicalDefUse.mask,
1300 PhysicalDefUse.mask),
1301 new Operator((char)126, InstructionFormat.Binary_format, //LONG_XOR
1302 (commutative | InstructionFormat.Binary_traits),
1303 1, 0, 2,
1304 PhysicalDefUse.mask,
1305 PhysicalDefUse.mask),
1306 new Operator((char)127, InstructionFormat.Unary_format, //INT_2ADDRSigExt
1307 (none | InstructionFormat.Unary_traits),
1308 1, 0, 1,
1309 PhysicalDefUse.mask,
1310 PhysicalDefUse.mask),
1311 new Operator((char)128, InstructionFormat.Unary_format, //INT_2ADDRZerExt
1312 (none | InstructionFormat.Unary_traits),
1313 1, 0, 1,
1314 PhysicalDefUse.mask,
1315 PhysicalDefUse.mask),
1316 new Operator((char)129, InstructionFormat.Unary_format, //LONG_2ADDR
1317 (none | InstructionFormat.Unary_traits),
1318 1, 0, 1,
1319 PhysicalDefUse.mask,
1320 PhysicalDefUse.mask),
1321 new Operator((char)130, InstructionFormat.Unary_format, //ADDR_2INT
1322 (none | InstructionFormat.Unary_traits),
1323 1, 0, 1,
1324 PhysicalDefUse.mask,
1325 PhysicalDefUse.mask),
1326 new Operator((char)131, InstructionFormat.Unary_format, //ADDR_2LONG
1327 (none | InstructionFormat.Unary_traits),
1328 1, 0, 1,
1329 PhysicalDefUse.mask,
1330 PhysicalDefUse.mask),
1331 new Operator((char)132, InstructionFormat.Unary_format, //INT_2LONG
1332 (none | InstructionFormat.Unary_traits),
1333 1, 0, 1,
1334 PhysicalDefUse.mask,
1335 PhysicalDefUse.mask),
1336 new Operator((char)133, InstructionFormat.Unary_format, //INT_2FLOAT
1337 (none | InstructionFormat.Unary_traits),
1338 1, 0, 1,
1339 PhysicalDefUse.maskIEEEMagicUses,
1340 PhysicalDefUse.mask),
1341 new Operator((char)134, InstructionFormat.Unary_format, //INT_2DOUBLE
1342 (none | InstructionFormat.Unary_traits),
1343 1, 0, 1,
1344 PhysicalDefUse.maskIEEEMagicUses,
1345 PhysicalDefUse.mask),
1346 new Operator((char)135, InstructionFormat.Unary_format, //LONG_2INT
1347 (none | InstructionFormat.Unary_traits),
1348 1, 0, 1,
1349 PhysicalDefUse.mask,
1350 PhysicalDefUse.mask),
1351 new Operator((char)136, InstructionFormat.Unary_format, //LONG_2FLOAT
1352 (none | InstructionFormat.Unary_traits),
1353 1, 0, 1,
1354 PhysicalDefUse.mask,
1355 PhysicalDefUse.mask),
1356 new Operator((char)137, InstructionFormat.Unary_format, //LONG_2DOUBLE
1357 (none | InstructionFormat.Unary_traits),
1358 1, 0, 1,
1359 PhysicalDefUse.mask,
1360 PhysicalDefUse.mask),
1361 new Operator((char)138, InstructionFormat.Unary_format, //FLOAT_2INT
1362 (none | InstructionFormat.Unary_traits),
1363 1, 0, 1,
1364 PhysicalDefUse.mask,
1365 PhysicalDefUse.mask),
1366 new Operator((char)139, InstructionFormat.Unary_format, //FLOAT_2LONG
1367 (none | InstructionFormat.Unary_traits),
1368 1, 0, 1,
1369 PhysicalDefUse.mask,
1370 PhysicalDefUse.mask),
1371 new Operator((char)140, InstructionFormat.Unary_format, //FLOAT_2DOUBLE
1372 (none | InstructionFormat.Unary_traits),
1373 1, 0, 1,
1374 PhysicalDefUse.mask,
1375 PhysicalDefUse.mask),
1376 new Operator((char)141, InstructionFormat.Unary_format, //DOUBLE_2INT
1377 (none | InstructionFormat.Unary_traits),
1378 1, 0, 1,
1379 PhysicalDefUse.mask,
1380 PhysicalDefUse.mask),
1381 new Operator((char)142, InstructionFormat.Unary_format, //DOUBLE_2LONG
1382 (none | InstructionFormat.Unary_traits),
1383 1, 0, 1,
1384 PhysicalDefUse.mask,
1385 PhysicalDefUse.mask),
1386 new Operator((char)143, InstructionFormat.Unary_format, //DOUBLE_2FLOAT
1387 (none | InstructionFormat.Unary_traits),
1388 1, 0, 1,
1389 PhysicalDefUse.mask,
1390 PhysicalDefUse.mask),
1391 new Operator((char)144, InstructionFormat.Unary_format, //INT_2BYTE
1392 (none | InstructionFormat.Unary_traits),
1393 1, 0, 1,
1394 PhysicalDefUse.mask,
1395 PhysicalDefUse.mask),
1396 new Operator((char)145, InstructionFormat.Unary_format, //INT_2USHORT
1397 (none | InstructionFormat.Unary_traits),
1398 1, 0, 1,
1399 PhysicalDefUse.mask,
1400 PhysicalDefUse.mask),
1401 new Operator((char)146, InstructionFormat.Unary_format, //INT_2SHORT
1402 (none | InstructionFormat.Unary_traits),
1403 1, 0, 1,
1404 PhysicalDefUse.mask,
1405 PhysicalDefUse.mask),
1406 new Operator((char)147, InstructionFormat.Binary_format, //LONG_CMP
1407 (compare | InstructionFormat.Binary_traits),
1408 1, 0, 2,
1409 PhysicalDefUse.mask,
1410 PhysicalDefUse.mask),
1411 new Operator((char)148, InstructionFormat.Binary_format, //FLOAT_CMPL
1412 (compare | InstructionFormat.Binary_traits),
1413 1, 0, 2,
1414 PhysicalDefUse.mask,
1415 PhysicalDefUse.mask),
1416 new Operator((char)149, InstructionFormat.Binary_format, //FLOAT_CMPG
1417 (compare | InstructionFormat.Binary_traits),
1418 1, 0, 2,
1419 PhysicalDefUse.mask,
1420 PhysicalDefUse.mask),
1421 new Operator((char)150, InstructionFormat.Binary_format, //DOUBLE_CMPL
1422 (compare | InstructionFormat.Binary_traits),
1423 1, 0, 2,
1424 PhysicalDefUse.mask,
1425 PhysicalDefUse.mask),
1426 new Operator((char)151, InstructionFormat.Binary_format, //DOUBLE_CMPG
1427 (compare | InstructionFormat.Binary_traits),
1428 1, 0, 2,
1429 PhysicalDefUse.mask,
1430 PhysicalDefUse.mask),
1431 new Operator((char)152, InstructionFormat.Return_format, //RETURN
1432 (ret | InstructionFormat.Return_traits),
1433 0, 0, 1,
1434 PhysicalDefUse.mask,
1435 PhysicalDefUse.mask),
1436 new Operator((char)153, InstructionFormat.NullCheck_format, //NULL_CHECK
1437 (immedPEI | InstructionFormat.NullCheck_traits),
1438 1, 0, 1,
1439 PhysicalDefUse.mask,
1440 PhysicalDefUse.mask),
1441 new Operator((char)154, InstructionFormat.Goto_format, //GOTO
1442 (branch | InstructionFormat.Goto_traits),
1443 0, 0, 1,
1444 PhysicalDefUse.mask,
1445 PhysicalDefUse.mask),
1446 new Operator((char)155, InstructionFormat.Unary_format, //BOOLEAN_NOT
1447 (none | InstructionFormat.Unary_traits),
1448 1, 0, 1,
1449 PhysicalDefUse.mask,
1450 PhysicalDefUse.mask),
1451 new Operator((char)156, InstructionFormat.BooleanCmp_format, //BOOLEAN_CMP_INT
1452 (compare | InstructionFormat.BooleanCmp_traits),
1453 1, 0, 4,
1454 PhysicalDefUse.mask,
1455 PhysicalDefUse.mask),
1456 new Operator((char)157, InstructionFormat.BooleanCmp_format, //BOOLEAN_CMP_ADDR
1457 (compare | InstructionFormat.BooleanCmp_traits),
1458 1, 0, 4,
1459 PhysicalDefUse.mask,
1460 PhysicalDefUse.mask),
1461 new Operator((char)158, InstructionFormat.BooleanCmp_format, //BOOLEAN_CMP_LONG
1462 (compare | InstructionFormat.BooleanCmp_traits),
1463 1, 0, 4,
1464 PhysicalDefUse.mask,
1465 PhysicalDefUse.mask),
1466 new Operator((char)159, InstructionFormat.BooleanCmp_format, //BOOLEAN_CMP_FLOAT
1467 (compare | InstructionFormat.BooleanCmp_traits),
1468 1, 0, 4,
1469 PhysicalDefUse.mask,
1470 PhysicalDefUse.mask),
1471 new Operator((char)160, InstructionFormat.BooleanCmp_format, //BOOLEAN_CMP_DOUBLE
1472 (compare | InstructionFormat.BooleanCmp_traits),
1473 1, 0, 4,
1474 PhysicalDefUse.mask,
1475 PhysicalDefUse.mask),
1476 new Operator((char)161, InstructionFormat.Load_format, //BYTE_LOAD
1477 (load | InstructionFormat.Load_traits),
1478 1, 0, 4,
1479 PhysicalDefUse.mask,
1480 PhysicalDefUse.mask),
1481 new Operator((char)162, InstructionFormat.Load_format, //UBYTE_LOAD
1482 (load | InstructionFormat.Load_traits),
1483 1, 0, 4,
1484 PhysicalDefUse.mask,
1485 PhysicalDefUse.mask),
1486 new Operator((char)163, InstructionFormat.Load_format, //SHORT_LOAD
1487 (load | InstructionFormat.Load_traits),
1488 1, 0, 4,
1489 PhysicalDefUse.mask,
1490 PhysicalDefUse.mask),
1491 new Operator((char)164, InstructionFormat.Load_format, //USHORT_LOAD
1492 (load | InstructionFormat.Load_traits),
1493 1, 0, 4,
1494 PhysicalDefUse.mask,
1495 PhysicalDefUse.mask),
1496 new Operator((char)165, InstructionFormat.Load_format, //REF_LOAD
1497 (load | InstructionFormat.Load_traits),
1498 1, 0, 4,
1499 PhysicalDefUse.mask,
1500 PhysicalDefUse.mask),
1501 new Operator((char)166, InstructionFormat.Store_format, //REF_STORE
1502 (store | InstructionFormat.Store_traits),
1503 0, 0, 5,
1504 PhysicalDefUse.mask,
1505 PhysicalDefUse.mask),
1506 new Operator((char)167, InstructionFormat.Load_format, //INT_LOAD
1507 (load | InstructionFormat.Load_traits),
1508 1, 0, 4,
1509 PhysicalDefUse.mask,
1510 PhysicalDefUse.mask),
1511 new Operator((char)168, InstructionFormat.Load_format, //LONG_LOAD
1512 (load | InstructionFormat.Load_traits),
1513 1, 0, 4,
1514 PhysicalDefUse.mask,
1515 PhysicalDefUse.mask),
1516 new Operator((char)169, InstructionFormat.Load_format, //FLOAT_LOAD
1517 (load | InstructionFormat.Load_traits),
1518 1, 0, 4,
1519 PhysicalDefUse.mask,
1520 PhysicalDefUse.mask),
1521 new Operator((char)170, InstructionFormat.Load_format, //DOUBLE_LOAD
1522 (load | InstructionFormat.Load_traits),
1523 1, 0, 4,
1524 PhysicalDefUse.mask,
1525 PhysicalDefUse.mask),
1526 new Operator((char)171, InstructionFormat.Store_format, //BYTE_STORE
1527 (store | InstructionFormat.Store_traits),
1528 0, 0, 5,
1529 PhysicalDefUse.mask,
1530 PhysicalDefUse.mask),
1531 new Operator((char)172, InstructionFormat.Store_format, //SHORT_STORE
1532 (store | InstructionFormat.Store_traits),
1533 0, 0, 5,
1534 PhysicalDefUse.mask,
1535 PhysicalDefUse.mask),
1536 new Operator((char)173, InstructionFormat.Store_format, //INT_STORE
1537 (store | InstructionFormat.Store_traits),
1538 0, 0, 5,
1539 PhysicalDefUse.mask,
1540 PhysicalDefUse.mask),
1541 new Operator((char)174, InstructionFormat.Store_format, //LONG_STORE
1542 (store | InstructionFormat.Store_traits),
1543 0, 0, 5,
1544 PhysicalDefUse.mask,
1545 PhysicalDefUse.mask),
1546 new Operator((char)175, InstructionFormat.Store_format, //FLOAT_STORE
1547 (store | InstructionFormat.Store_traits),
1548 0, 0, 5,
1549 PhysicalDefUse.mask,
1550 PhysicalDefUse.mask),
1551 new Operator((char)176, InstructionFormat.Store_format, //DOUBLE_STORE
1552 (store | InstructionFormat.Store_traits),
1553 0, 0, 5,
1554 PhysicalDefUse.mask,
1555 PhysicalDefUse.mask),
1556 new Operator((char)177, InstructionFormat.Prepare_format, //PREPARE_INT
1557 (load | acquire | InstructionFormat.Prepare_traits),
1558 1, 0, 4,
1559 PhysicalDefUse.mask,
1560 PhysicalDefUse.mask),
1561 new Operator((char)178, InstructionFormat.Prepare_format, //PREPARE_ADDR
1562 (load | acquire | InstructionFormat.Prepare_traits),
1563 1, 0, 4,
1564 PhysicalDefUse.mask,
1565 PhysicalDefUse.mask),
1566 new Operator((char)179, InstructionFormat.Prepare_format, //PREPARE_LONG
1567 (load | acquire | InstructionFormat.Prepare_traits),
1568 1, 0, 4,
1569 PhysicalDefUse.mask,
1570 PhysicalDefUse.mask),
1571 new Operator((char)180, InstructionFormat.Attempt_format, //ATTEMPT_INT
1572 (load | store | compare | release | InstructionFormat.Attempt_traits),
1573 1, 0, 6,
1574 PhysicalDefUse.mask,
1575 PhysicalDefUse.mask),
1576 new Operator((char)181, InstructionFormat.Attempt_format, //ATTEMPT_ADDR
1577 (load | store | compare | release | InstructionFormat.Attempt_traits),
1578 1, 0, 6,
1579 PhysicalDefUse.mask,
1580 PhysicalDefUse.mask),
1581 new Operator((char)182, InstructionFormat.Attempt_format, //ATTEMPT_LONG
1582 (load | store | compare | release | InstructionFormat.Attempt_traits),
1583 1, 0, 6,
1584 PhysicalDefUse.mask,
1585 PhysicalDefUse.mask),
1586 new Operator((char)183, InstructionFormat.Call_format, //CALL
1587 (call | memAsLoad | memAsStore | dynLink | immedPEI | InstructionFormat.Call_traits),
1588 1, 0, 3,
1589 PhysicalDefUse.maskcallDefs,
1590 PhysicalDefUse.maskcallUses),
1591 new Operator((char)184, InstructionFormat.Call_format, //SYSCALL
1592 (call | memAsLoad | memAsStore | InstructionFormat.Call_traits),
1593 1, 0, 3,
1594 PhysicalDefUse.maskcallDefs,
1595 PhysicalDefUse.maskcallUses),
1596 new Operator((char)185, InstructionFormat.Empty_format, //YIELDPOINT_PROLOGUE
1597 (tsp | yieldPoint | InstructionFormat.Empty_traits),
1598 0, 0, 0,
1599 PhysicalDefUse.mask,
1600 PhysicalDefUse.mask),
1601 new Operator((char)186, InstructionFormat.Empty_format, //YIELDPOINT_EPILOGUE
1602 (tsp | yieldPoint | InstructionFormat.Empty_traits),
1603 0, 0, 0,
1604 PhysicalDefUse.mask,
1605 PhysicalDefUse.mask),
1606 new Operator((char)187, InstructionFormat.Empty_format, //YIELDPOINT_BACKEDGE
1607 (tsp | yieldPoint | InstructionFormat.Empty_traits),
1608 0, 0, 0,
1609 PhysicalDefUse.mask,
1610 PhysicalDefUse.mask),
1611 new Operator((char)188, InstructionFormat.OsrPoint_format, //YIELDPOINT_OSR
1612 (tsp | yieldPoint | InstructionFormat.OsrPoint_traits),
1613 0, 0, 1,
1614 PhysicalDefUse.mask,
1615 PhysicalDefUse.mask),
1616 new Operator((char)189, InstructionFormat.OsrBarrier_format, //OSR_BARRIER
1617 (none | InstructionFormat.OsrBarrier_traits),
1618 0, 0, 1,
1619 PhysicalDefUse.mask,
1620 PhysicalDefUse.mask),
1621 new Operator((char)190, InstructionFormat.Prologue_format, //IR_PROLOGUE
1622 (immedPEI | InstructionFormat.Prologue_traits),
1623 0, 0, 0,
1624 PhysicalDefUse.mask,
1625 PhysicalDefUse.mask),
1626 new Operator((char)191, InstructionFormat.CacheOp_format, //RESOLVE
1627 (tsp | dynLink | immedPEI | InstructionFormat.CacheOp_traits),
1628 0, 0, 1,
1629 PhysicalDefUse.mask,
1630 PhysicalDefUse.mask),
1631 new Operator((char)192, InstructionFormat.Unary_format, //RESOLVE_MEMBER
1632 (tsp | dynLink | immedPEI | InstructionFormat.Unary_traits),
1633 1, 0, 1,
1634 PhysicalDefUse.mask,
1635 PhysicalDefUse.mask),
1636 new Operator((char)193, InstructionFormat.Nullary_format, //GET_TIME_BASE
1637 (none | InstructionFormat.Nullary_traits),
1638 1, 0, 0,
1639 PhysicalDefUse.mask,
1640 PhysicalDefUse.mask),
1641 new Operator((char)194, InstructionFormat.InstrumentedCounter_format, //INSTRUMENTED_EVENT_COUNTER
1642 (none | InstructionFormat.InstrumentedCounter_traits),
1643 0, 0, 3,
1644 PhysicalDefUse.mask,
1645 PhysicalDefUse.mask),
1646 new Operator((char)195, InstructionFormat.TrapIf_format, //TRAP_IF
1647 (immedPEI | InstructionFormat.TrapIf_traits),
1648 1, 0, 4,
1649 PhysicalDefUse.mask,
1650 PhysicalDefUse.mask),
1651 new Operator((char)196, InstructionFormat.Trap_format, //TRAP
1652 (immedPEI | InstructionFormat.Trap_traits),
1653 1, 0, 1,
1654 PhysicalDefUse.mask,
1655 PhysicalDefUse.mask),
1656 new Operator((char)197, InstructionFormat.Unary_format, //FLOAT_AS_INT_BITS
1657 (none | InstructionFormat.Unary_traits),
1658 1, 0, 1,
1659 PhysicalDefUse.mask,
1660 PhysicalDefUse.mask),
1661 new Operator((char)198, InstructionFormat.Unary_format, //INT_BITS_AS_FLOAT
1662 (none | InstructionFormat.Unary_traits),
1663 1, 0, 1,
1664 PhysicalDefUse.mask,
1665 PhysicalDefUse.mask),
1666 new Operator((char)199, InstructionFormat.Unary_format, //DOUBLE_AS_LONG_BITS
1667 (none | InstructionFormat.Unary_traits),
1668 1, 0, 1,
1669 PhysicalDefUse.mask,
1670 PhysicalDefUse.mask),
1671 new Operator((char)200, InstructionFormat.Unary_format, //LONG_BITS_AS_DOUBLE
1672 (none | InstructionFormat.Unary_traits),
1673 1, 0, 1,
1674 PhysicalDefUse.mask,
1675 PhysicalDefUse.mask),
1676 new Operator((char)201, InstructionFormat.GuardedUnary_format, //ARRAYLENGTH
1677 (none | InstructionFormat.GuardedUnary_traits),
1678 1, 0, 2,
1679 PhysicalDefUse.mask,
1680 PhysicalDefUse.mask),
1681 new Operator((char)202, InstructionFormat.GuardedUnary_format, //GET_OBJ_TIB
1682 (none | InstructionFormat.GuardedUnary_traits),
1683 1, 0, 2,
1684 PhysicalDefUse.mask,
1685 PhysicalDefUse.mask),
1686 new Operator((char)203, InstructionFormat.Unary_format, //GET_CLASS_TIB
1687 (none | InstructionFormat.Unary_traits),
1688 1, 0, 1,
1689 PhysicalDefUse.mask,
1690 PhysicalDefUse.mask),
1691 new Operator((char)204, InstructionFormat.Unary_format, //GET_TYPE_FROM_TIB
1692 (none | InstructionFormat.Unary_traits),
1693 1, 0, 1,
1694 PhysicalDefUse.mask,
1695 PhysicalDefUse.mask),
1696 new Operator((char)205, InstructionFormat.Unary_format, //GET_SUPERCLASS_IDS_FROM_TIB
1697 (none | InstructionFormat.Unary_traits),
1698 1, 0, 1,
1699 PhysicalDefUse.mask,
1700 PhysicalDefUse.mask),
1701 new Operator((char)206, InstructionFormat.Unary_format, //GET_DOES_IMPLEMENT_FROM_TIB
1702 (none | InstructionFormat.Unary_traits),
1703 1, 0, 1,
1704 PhysicalDefUse.mask,
1705 PhysicalDefUse.mask),
1706 new Operator((char)207, InstructionFormat.Unary_format, //GET_ARRAY_ELEMENT_TIB_FROM_TIB
1707 (none | InstructionFormat.Unary_traits),
1708 1, 0, 1,
1709 PhysicalDefUse.mask,
1710 PhysicalDefUse.mask),
1711 new Operator((char)208, InstructionFormat.LowTableSwitch_format, //LOWTABLESWITCH
1712 (branch | InstructionFormat.LowTableSwitch_traits),
1713 0, 0, 1,
1714 PhysicalDefUse.mask,
1715 PhysicalDefUse.mask),
1716 //////////////////////////
1717 // END Architecture Independent opcodes.
1718 // BEGIN Architecture Dependent opcodes & MIR.
1719 //////////////////////////
1720 new Operator((char)(0 + Operators.ARCH_INDEPENDENT_END_opcode), //ADDRESS_CONSTANT
1721 InstructionFormat.Unassigned_format,
1722 (none),
1723 0,0,0,
1724 PhysicalDefUse.mask,
1725 PhysicalDefUse.mask),
1726 new Operator((char)(1 + Operators.ARCH_INDEPENDENT_END_opcode), //INT_CONSTANT
1727 InstructionFormat.Unassigned_format,
1728 (none),
1729 0,0,0,
1730 PhysicalDefUse.mask,
1731 PhysicalDefUse.mask),
1732 new Operator((char)(2 + Operators.ARCH_INDEPENDENT_END_opcode), //LONG_CONSTANT
1733 InstructionFormat.Unassigned_format,
1734 (none),
1735 0,0,0,
1736 PhysicalDefUse.mask,
1737 PhysicalDefUse.mask),
1738 new Operator((char)(3 + Operators.ARCH_INDEPENDENT_END_opcode), //REGISTER
1739 InstructionFormat.Unassigned_format,
1740 (none),
1741 0,0,0,
1742 PhysicalDefUse.mask,
1743 PhysicalDefUse.mask),
1744 new Operator((char)(4 + Operators.ARCH_INDEPENDENT_END_opcode), //OTHER_OPERAND
1745 InstructionFormat.Unassigned_format,
1746 (none),
1747 0,0,0,
1748 PhysicalDefUse.mask,
1749 PhysicalDefUse.mask),
1750 new Operator((char)(5 + Operators.ARCH_INDEPENDENT_END_opcode), //NULL
1751 InstructionFormat.Unassigned_format,
1752 (none),
1753 0,0,0,
1754 PhysicalDefUse.mask,
1755 PhysicalDefUse.mask),
1756 new Operator((char)(6 + Operators.ARCH_INDEPENDENT_END_opcode), //BRANCH_TARGET
1757 InstructionFormat.Unassigned_format,
1758 (none),
1759 0,0,0,
1760 PhysicalDefUse.mask,
1761 PhysicalDefUse.mask),
1762 new Operator((char)(7 + Operators.ARCH_INDEPENDENT_END_opcode), //MATERIALIZE_FP_CONSTANT
1763 InstructionFormat.Binary_format,
1764 (none | InstructionFormat.Binary_traits),
1765 1, 0, 2,
1766 PhysicalDefUse.mask,
1767 PhysicalDefUse.mask),
1768 new Operator((char)(8 + Operators.ARCH_INDEPENDENT_END_opcode), //GET_CURRENT_PROCESSOR
1769 InstructionFormat.Nullary_format,
1770 (none | InstructionFormat.Nullary_traits),
1771 1, 0, 0,
1772 PhysicalDefUse.mask,
1773 PhysicalDefUse.mask),
1774 new Operator((char)(9 + Operators.ARCH_INDEPENDENT_END_opcode), //ROUND_TO_ZERO
1775 InstructionFormat.Empty_format,
1776 (none | InstructionFormat.Empty_traits),
1777 0, 0, 0,
1778 PhysicalDefUse.mask,
1779 PhysicalDefUse.mask),
1780 new Operator((char)(10 + Operators.ARCH_INDEPENDENT_END_opcode), //CLEAR_FLOATING_POINT_STATE
1781 InstructionFormat.Empty_format,
1782 (none | InstructionFormat.Empty_traits),
1783 0, 0, 0,
1784 PhysicalDefUse.mask,
1785 PhysicalDefUse.mask),
1786 new Operator((char)(11 + Operators.ARCH_INDEPENDENT_END_opcode), //PREFETCH
1787 InstructionFormat.CacheOp_format,
1788 (none | InstructionFormat.CacheOp_traits),
1789 0, 0, 1,
1790 PhysicalDefUse.mask,
1791 PhysicalDefUse.mask),
1792 new Operator((char)(12 + Operators.ARCH_INDEPENDENT_END_opcode), //PAUSE
1793 InstructionFormat.Empty_format,
1794 (none | InstructionFormat.Empty_traits),
1795 0, 0, 0,
1796 PhysicalDefUse.mask,
1797 PhysicalDefUse.mask),
1798 new Operator((char)(13 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_ADD
1799 InstructionFormat.Binary_format,
1800 (none | InstructionFormat.Binary_traits),
1801 1, 0, 2,
1802 PhysicalDefUse.mask,
1803 PhysicalDefUse.mask),
1804 new Operator((char)(14 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_SUB
1805 InstructionFormat.Binary_format,
1806 (none | InstructionFormat.Binary_traits),
1807 1, 0, 2,
1808 PhysicalDefUse.mask,
1809 PhysicalDefUse.mask),
1810 new Operator((char)(15 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_MUL
1811 InstructionFormat.Binary_format,
1812 (none | InstructionFormat.Binary_traits),
1813 1, 0, 2,
1814 PhysicalDefUse.mask,
1815 PhysicalDefUse.mask),
1816 new Operator((char)(16 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_DIV
1817 InstructionFormat.Binary_format,
1818 (none | InstructionFormat.Binary_traits),
1819 1, 0, 2,
1820 PhysicalDefUse.mask,
1821 PhysicalDefUse.mask),
1822 new Operator((char)(17 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_NEG
1823 InstructionFormat.Unary_format,
1824 (none | InstructionFormat.Unary_traits),
1825 1, 0, 1,
1826 PhysicalDefUse.mask,
1827 PhysicalDefUse.mask),
1828 new Operator((char)(18 + Operators.ARCH_INDEPENDENT_END_opcode), //FP_REM
1829 InstructionFormat.Binary_format,
1830 (none | InstructionFormat.Binary_traits),
1831 1, 0, 2,
1832 PhysicalDefUse.mask,
1833 PhysicalDefUse.mask),
1834 new Operator((char)(19 + Operators.ARCH_INDEPENDENT_END_opcode), //INT_2FP
1835 InstructionFormat.Unary_format,
1836 (none | InstructionFormat.Unary_traits),
1837 1, 0, 1,
1838 PhysicalDefUse.mask,
1839 PhysicalDefUse.mask),
1840 new Operator((char)(20 + Operators.ARCH_INDEPENDENT_END_opcode), //LONG_2FP
1841 InstructionFormat.Unary_format,
1842 (none | InstructionFormat.Unary_traits),
1843 1, 0, 1,
1844 PhysicalDefUse.mask,
1845 PhysicalDefUse.mask),
1846 new Operator((char)(21 + Operators.ARCH_INDEPENDENT_END_opcode), //CMP_CMOV
1847 InstructionFormat.CondMove_format,
1848 (compare | InstructionFormat.CondMove_traits),
1849 1, 0, 5,
1850 PhysicalDefUse.mask,
1851 PhysicalDefUse.mask),
1852 new Operator((char)(22 + Operators.ARCH_INDEPENDENT_END_opcode), //FCMP_CMOV
1853 InstructionFormat.CondMove_format,
1854 (compare | InstructionFormat.CondMove_traits),
1855 1, 0, 5,
1856 PhysicalDefUse.mask,
1857 PhysicalDefUse.mask),
1858 new Operator((char)(23 + Operators.ARCH_INDEPENDENT_END_opcode), //LCMP_CMOV
1859 InstructionFormat.CondMove_format,
1860 (compare | InstructionFormat.CondMove_traits),
1861 1, 0, 5,
1862 PhysicalDefUse.mask,
1863 PhysicalDefUse.mask),
1864 new Operator((char)(24 + Operators.ARCH_INDEPENDENT_END_opcode), //CMP_FCMOV
1865 InstructionFormat.CondMove_format,
1866 (compare | InstructionFormat.CondMove_traits),
1867 1, 0, 5,
1868 PhysicalDefUse.mask,
1869 PhysicalDefUse.mask),
1870 new Operator((char)(25 + Operators.ARCH_INDEPENDENT_END_opcode), //FCMP_FCMOV
1871 InstructionFormat.CondMove_format,
1872 (compare | InstructionFormat.CondMove_traits),
1873 1, 0, 5,
1874 PhysicalDefUse.mask,
1875 PhysicalDefUse.mask),
1876 new Operator((char)(26 + Operators.ARCH_INDEPENDENT_END_opcode), //CALL_SAVE_VOLATILE
1877 InstructionFormat.MIR_Call_format,
1878 (call | immedPEI | InstructionFormat.MIR_Call_traits),
1879 2, 0, 2,
1880 PhysicalDefUse.maskcallDefs,
1881 PhysicalDefUse.maskcallUses),
1882 new Operator((char)(27 + Operators.ARCH_INDEPENDENT_END_opcode), //MIR_START
1883 InstructionFormat.Unassigned_format,
1884 (none),
1885 0,0,0,
1886 PhysicalDefUse.mask,
1887 PhysicalDefUse.mask),
1888 new Operator((char)(28 + Operators.ARCH_INDEPENDENT_END_opcode), //REQUIRE_ESP
1889 InstructionFormat.MIR_UnaryNoRes_format,
1890 (none | InstructionFormat.MIR_UnaryNoRes_traits),
1891 0, 0, 1,
1892 PhysicalDefUse.mask,
1893 PhysicalDefUse.mask),
1894 new Operator((char)(29 + Operators.ARCH_INDEPENDENT_END_opcode), //ADVISE_ESP
1895 InstructionFormat.MIR_UnaryNoRes_format,
1896 (none | InstructionFormat.MIR_UnaryNoRes_traits),
1897 0, 0, 1,
1898 PhysicalDefUse.mask,
1899 PhysicalDefUse.mask),
1900 new Operator((char)(30 + Operators.ARCH_INDEPENDENT_END_opcode), //MIR_LOWTABLESWITCH
1901 InstructionFormat.MIR_LowTableSwitch_format,
1902 (branch | InstructionFormat.MIR_LowTableSwitch_traits),
1903 0, 1, 1,
1904 PhysicalDefUse.mask,
1905 PhysicalDefUse.mask),
1906 new Operator((char)(31 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_METHODSTART
1907 InstructionFormat.MIR_Nullary_format,
1908 (none | InstructionFormat.MIR_Nullary_traits),
1909 1, 0, 0,
1910 PhysicalDefUse.mask,
1911 PhysicalDefUse.mask),
1912 new Operator((char)(32 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FCLEAR
1913 InstructionFormat.MIR_UnaryNoRes_format,
1914 (none | InstructionFormat.MIR_UnaryNoRes_traits),
1915 0, 0, 1,
1916 PhysicalDefUse.mask,
1917 PhysicalDefUse.mask),
1918 new Operator((char)(33 + Operators.ARCH_INDEPENDENT_END_opcode), //DUMMY_DEF
1919 InstructionFormat.MIR_Nullary_format,
1920 (none | InstructionFormat.MIR_Nullary_traits),
1921 1, 0, 0,
1922 PhysicalDefUse.mask,
1923 PhysicalDefUse.mask),
1924 new Operator((char)(34 + Operators.ARCH_INDEPENDENT_END_opcode), //DUMMY_USE
1925 InstructionFormat.MIR_UnaryNoRes_format,
1926 (none | InstructionFormat.MIR_UnaryNoRes_traits),
1927 0, 0, 1,
1928 PhysicalDefUse.mask,
1929 PhysicalDefUse.mask),
1930 new Operator((char)(35 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FMOV_ENDING_LIVE_RANGE
1931 InstructionFormat.MIR_Move_format,
1932 (move | InstructionFormat.MIR_Move_traits),
1933 1, 0, 1,
1934 PhysicalDefUse.mask,
1935 PhysicalDefUse.mask),
1936 new Operator((char)(36 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FMOV
1937 InstructionFormat.MIR_Move_format,
1938 (move | InstructionFormat.MIR_Move_traits),
1939 1, 0, 1,
1940 PhysicalDefUse.mask,
1941 PhysicalDefUse.mask),
1942 new Operator((char)(37 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_TRAPIF
1943 InstructionFormat.MIR_TrapIf_format,
1944 (immedPEI | InstructionFormat.MIR_TrapIf_traits),
1945 1, 0, 4,
1946 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1947 PhysicalDefUse.mask),
1948 new Operator((char)(38 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_OFFSET
1949 InstructionFormat.MIR_CaseLabel_format,
1950 (none | InstructionFormat.MIR_CaseLabel_traits),
1951 0, 0, 2,
1952 PhysicalDefUse.mask,
1953 PhysicalDefUse.mask),
1954 new Operator((char)(39 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_LOCK_CMPXCHG
1955 InstructionFormat.MIR_CompareExchange_format,
1956 (compare | InstructionFormat.MIR_CompareExchange_traits),
1957 0, 2, 1,
1958 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1959 PhysicalDefUse.mask),
1960 new Operator((char)(40 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_LOCK_CMPXCHG8B
1961 InstructionFormat.MIR_CompareExchange8B_format,
1962 (compare | InstructionFormat.MIR_CompareExchange8B_traits),
1963 0, 3, 2,
1964 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1965 PhysicalDefUse.mask),
1966 new Operator((char)(41 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ADC
1967 InstructionFormat.MIR_BinaryAcc_format,
1968 (none | InstructionFormat.MIR_BinaryAcc_traits),
1969 0, 1, 1,
1970 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1971 PhysicalDefUse.maskCF),
1972 new Operator((char)(42 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ADD
1973 InstructionFormat.MIR_BinaryAcc_format,
1974 (none | InstructionFormat.MIR_BinaryAcc_traits),
1975 0, 1, 1,
1976 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1977 PhysicalDefUse.mask),
1978 new Operator((char)(43 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_AND
1979 InstructionFormat.MIR_BinaryAcc_format,
1980 (none | InstructionFormat.MIR_BinaryAcc_traits),
1981 0, 1, 1,
1982 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
1983 PhysicalDefUse.mask),
1984 new Operator((char)(44 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_BSWAP
1985 InstructionFormat.MIR_UnaryAcc_format,
1986 (none | InstructionFormat.MIR_UnaryAcc_traits),
1987 0, 1, 0,
1988 PhysicalDefUse.mask,
1989 PhysicalDefUse.mask),
1990 new Operator((char)(45 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_BT
1991 InstructionFormat.MIR_Test_format,
1992 (none | InstructionFormat.MIR_Test_traits),
1993 0, 0, 2,
1994 PhysicalDefUse.maskCF,
1995 PhysicalDefUse.mask),
1996 new Operator((char)(46 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_BTC
1997 InstructionFormat.MIR_Test_format,
1998 (none | InstructionFormat.MIR_Test_traits),
1999 0, 0, 2,
2000 PhysicalDefUse.maskCF,
2001 PhysicalDefUse.mask),
2002 new Operator((char)(47 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_BTR
2003 InstructionFormat.MIR_Test_format,
2004 (none | InstructionFormat.MIR_Test_traits),
2005 0, 0, 2,
2006 PhysicalDefUse.maskCF,
2007 PhysicalDefUse.mask),
2008 new Operator((char)(48 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_BTS
2009 InstructionFormat.MIR_Test_format,
2010 (none | InstructionFormat.MIR_Test_traits),
2011 0, 0, 2,
2012 PhysicalDefUse.maskCF,
2013 PhysicalDefUse.mask),
2014 new Operator((char)(49 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SYSCALL
2015 InstructionFormat.MIR_Call_format,
2016 (call | InstructionFormat.MIR_Call_traits),
2017 2, 0, 2,
2018 PhysicalDefUse.maskcallDefs,
2019 PhysicalDefUse.maskcallUses),
2020 new Operator((char)(50 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CALL
2021 InstructionFormat.MIR_Call_format,
2022 (call | immedPEI | InstructionFormat.MIR_Call_traits),
2023 2, 0, 2,
2024 PhysicalDefUse.maskcallDefs,
2025 PhysicalDefUse.maskcallUses),
2026 new Operator((char)(51 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CDQ
2027 InstructionFormat.MIR_ConvertDW2QW_format,
2028 (none | InstructionFormat.MIR_ConvertDW2QW_traits),
2029 1, 1, 0,
2030 PhysicalDefUse.mask,
2031 PhysicalDefUse.mask),
2032 new Operator((char)(52 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CDO
2033 InstructionFormat.MIR_ConvertDW2QW_format,
2034 (none | InstructionFormat.MIR_ConvertDW2QW_traits),
2035 1, 1, 0,
2036 PhysicalDefUse.mask,
2037 PhysicalDefUse.mask),
2038 new Operator((char)(53 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CDQE
2039 InstructionFormat.MIR_ConvertDW2QW_format,
2040 (none | InstructionFormat.MIR_ConvertDW2QW_traits),
2041 1, 1, 0,
2042 PhysicalDefUse.mask,
2043 PhysicalDefUse.mask),
2044 new Operator((char)(54 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMOV
2045 InstructionFormat.MIR_CondMove_format,
2046 (none | InstructionFormat.MIR_CondMove_traits),
2047 0, 1, 2,
2048 PhysicalDefUse.mask,
2049 PhysicalDefUse.maskCF_OF_PF_SF_ZF),
2050 new Operator((char)(55 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMP
2051 InstructionFormat.MIR_Compare_format,
2052 (compare | InstructionFormat.MIR_Compare_traits),
2053 0, 0, 2,
2054 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2055 PhysicalDefUse.mask),
2056 new Operator((char)(56 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPXCHG
2057 InstructionFormat.MIR_CompareExchange_format,
2058 (compare | InstructionFormat.MIR_CompareExchange_traits),
2059 0, 2, 1,
2060 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2061 PhysicalDefUse.mask),
2062 new Operator((char)(57 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPXCHG8B
2063 InstructionFormat.MIR_CompareExchange8B_format,
2064 (compare | InstructionFormat.MIR_CompareExchange8B_traits),
2065 0, 3, 2,
2066 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2067 PhysicalDefUse.mask),
2068 new Operator((char)(58 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_DEC
2069 InstructionFormat.MIR_UnaryAcc_format,
2070 (none | InstructionFormat.MIR_UnaryAcc_traits),
2071 0, 1, 0,
2072 PhysicalDefUse.maskAF_OF_PF_SF_ZF,
2073 PhysicalDefUse.mask),
2074 new Operator((char)(59 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_DIV
2075 InstructionFormat.MIR_Divide_format,
2076 (none | InstructionFormat.MIR_Divide_traits),
2077 0, 2, 2,
2078 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2079 PhysicalDefUse.mask),
2080 new Operator((char)(60 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FADD
2081 InstructionFormat.MIR_BinaryAcc_format,
2082 (none | InstructionFormat.MIR_BinaryAcc_traits),
2083 0, 1, 1,
2084 PhysicalDefUse.maskC0_C1_C2_C3,
2085 PhysicalDefUse.mask),
2086 new Operator((char)(61 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FADDP
2087 InstructionFormat.MIR_BinaryAcc_format,
2088 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2089 0, 1, 1,
2090 PhysicalDefUse.maskC0_C1_C2_C3,
2091 PhysicalDefUse.mask),
2092 new Operator((char)(62 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FCHS
2093 InstructionFormat.MIR_UnaryAcc_format,
2094 (none | InstructionFormat.MIR_UnaryAcc_traits),
2095 0, 1, 0,
2096 PhysicalDefUse.maskC0_C1_C2_C3,
2097 PhysicalDefUse.mask),
2098 new Operator((char)(63 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FCMOV
2099 InstructionFormat.MIR_CondMove_format,
2100 (none | InstructionFormat.MIR_CondMove_traits),
2101 0, 1, 2,
2102 PhysicalDefUse.maskC0_C1_C2_C3,
2103 PhysicalDefUse.maskCF_PF_ZF),
2104 new Operator((char)(64 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FCOMI
2105 InstructionFormat.MIR_Compare_format,
2106 (compare | InstructionFormat.MIR_Compare_traits),
2107 0, 0, 2,
2108 PhysicalDefUse.maskCF_PF_ZF,
2109 PhysicalDefUse.mask),
2110 new Operator((char)(65 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FCOMIP
2111 InstructionFormat.MIR_Compare_format,
2112 (compare | fpPop | InstructionFormat.MIR_Compare_traits),
2113 0, 0, 2,
2114 PhysicalDefUse.maskCF_PF_ZF,
2115 PhysicalDefUse.mask),
2116 new Operator((char)(66 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FDIV
2117 InstructionFormat.MIR_BinaryAcc_format,
2118 (none | InstructionFormat.MIR_BinaryAcc_traits),
2119 0, 1, 1,
2120 PhysicalDefUse.maskC0_C1_C2_C3,
2121 PhysicalDefUse.mask),
2122 new Operator((char)(67 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FDIVP
2123 InstructionFormat.MIR_BinaryAcc_format,
2124 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2125 0, 1, 1,
2126 PhysicalDefUse.maskC0_C1_C2_C3,
2127 PhysicalDefUse.mask),
2128 new Operator((char)(68 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FDIVR
2129 InstructionFormat.MIR_BinaryAcc_format,
2130 (none | InstructionFormat.MIR_BinaryAcc_traits),
2131 0, 1, 1,
2132 PhysicalDefUse.maskC0_C1_C2_C3,
2133 PhysicalDefUse.mask),
2134 new Operator((char)(69 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FDIVRP
2135 InstructionFormat.MIR_BinaryAcc_format,
2136 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2137 0, 1, 1,
2138 PhysicalDefUse.maskC0_C1_C2_C3,
2139 PhysicalDefUse.mask),
2140 new Operator((char)(70 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FEXAM
2141 InstructionFormat.MIR_UnaryNoRes_format,
2142 (none | InstructionFormat.MIR_UnaryNoRes_traits),
2143 0, 0, 1,
2144 PhysicalDefUse.maskC0_C1_C2_C3,
2145 PhysicalDefUse.mask),
2146 new Operator((char)(71 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FXCH
2147 InstructionFormat.MIR_XChng_format,
2148 (none | InstructionFormat.MIR_XChng_traits),
2149 0, 2, 0,
2150 PhysicalDefUse.maskC0_C1_C2_C3,
2151 PhysicalDefUse.mask),
2152 new Operator((char)(72 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FFREE
2153 InstructionFormat.MIR_Nullary_format,
2154 (none | InstructionFormat.MIR_Nullary_traits),
2155 1, 0, 0,
2156 PhysicalDefUse.maskC0_C1_C2_C3,
2157 PhysicalDefUse.mask),
2158 new Operator((char)(73 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FIADD
2159 InstructionFormat.MIR_BinaryAcc_format,
2160 (none | InstructionFormat.MIR_BinaryAcc_traits),
2161 0, 1, 1,
2162 PhysicalDefUse.maskC0_C1_C2_C3,
2163 PhysicalDefUse.mask),
2164 new Operator((char)(74 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FIDIV
2165 InstructionFormat.MIR_BinaryAcc_format,
2166 (none | InstructionFormat.MIR_BinaryAcc_traits),
2167 0, 1, 1,
2168 PhysicalDefUse.maskC0_C1_C2_C3,
2169 PhysicalDefUse.mask),
2170 new Operator((char)(75 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FIDIVR
2171 InstructionFormat.MIR_BinaryAcc_format,
2172 (none | InstructionFormat.MIR_BinaryAcc_traits),
2173 0, 1, 1,
2174 PhysicalDefUse.maskC0_C1_C2_C3,
2175 PhysicalDefUse.mask),
2176 new Operator((char)(76 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FILD
2177 InstructionFormat.MIR_Move_format,
2178 (fpPush | InstructionFormat.MIR_Move_traits),
2179 1, 0, 1,
2180 PhysicalDefUse.maskC0_C1_C2_C3,
2181 PhysicalDefUse.mask),
2182 new Operator((char)(77 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FIMUL
2183 InstructionFormat.MIR_BinaryAcc_format,
2184 (none | InstructionFormat.MIR_BinaryAcc_traits),
2185 0, 1, 1,
2186 PhysicalDefUse.maskC0_C1_C2_C3,
2187 PhysicalDefUse.mask),
2188 new Operator((char)(78 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FINIT
2189 InstructionFormat.MIR_Empty_format,
2190 (none | InstructionFormat.MIR_Empty_traits),
2191 0, 0, 0,
2192 PhysicalDefUse.maskC0_C1_C2_C3,
2193 PhysicalDefUse.mask),
2194 new Operator((char)(79 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FIST
2195 InstructionFormat.MIR_Move_format,
2196 (none | InstructionFormat.MIR_Move_traits),
2197 1, 0, 1,
2198 PhysicalDefUse.maskC0_C1_C2_C3,
2199 PhysicalDefUse.mask),
2200 new Operator((char)(80 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FISTP
2201 InstructionFormat.MIR_Move_format,
2202 (fpPop | InstructionFormat.MIR_Move_traits),
2203 1, 0, 1,
2204 PhysicalDefUse.maskC0_C1_C2_C3,
2205 PhysicalDefUse.mask),
2206 new Operator((char)(81 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FISUB
2207 InstructionFormat.MIR_BinaryAcc_format,
2208 (none | InstructionFormat.MIR_BinaryAcc_traits),
2209 0, 1, 1,
2210 PhysicalDefUse.maskC0_C1_C2_C3,
2211 PhysicalDefUse.mask),
2212 new Operator((char)(82 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FISUBR
2213 InstructionFormat.MIR_BinaryAcc_format,
2214 (none | InstructionFormat.MIR_BinaryAcc_traits),
2215 0, 1, 1,
2216 PhysicalDefUse.maskC0_C1_C2_C3,
2217 PhysicalDefUse.mask),
2218 new Operator((char)(83 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLD
2219 InstructionFormat.MIR_Move_format,
2220 (fpPush | InstructionFormat.MIR_Move_traits),
2221 1, 0, 1,
2222 PhysicalDefUse.maskC0_C1_C2_C3,
2223 PhysicalDefUse.mask),
2224 new Operator((char)(84 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDCW
2225 InstructionFormat.MIR_UnaryNoRes_format,
2226 (none | InstructionFormat.MIR_UnaryNoRes_traits),
2227 0, 0, 1,
2228 PhysicalDefUse.maskC0_C1_C2_C3,
2229 PhysicalDefUse.mask),
2230 new Operator((char)(85 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLD1
2231 InstructionFormat.MIR_Nullary_format,
2232 (fpPush | InstructionFormat.MIR_Nullary_traits),
2233 1, 0, 0,
2234 PhysicalDefUse.maskC0_C1_C2_C3,
2235 PhysicalDefUse.mask),
2236 new Operator((char)(86 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDL2T
2237 InstructionFormat.MIR_Nullary_format,
2238 (fpPush | InstructionFormat.MIR_Nullary_traits),
2239 1, 0, 0,
2240 PhysicalDefUse.maskC0_C1_C2_C3,
2241 PhysicalDefUse.mask),
2242 new Operator((char)(87 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDL2E
2243 InstructionFormat.MIR_Nullary_format,
2244 (fpPush | InstructionFormat.MIR_Nullary_traits),
2245 1, 0, 0,
2246 PhysicalDefUse.maskC0_C1_C2_C3,
2247 PhysicalDefUse.mask),
2248 new Operator((char)(88 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDPI
2249 InstructionFormat.MIR_Nullary_format,
2250 (fpPush | InstructionFormat.MIR_Nullary_traits),
2251 1, 0, 0,
2252 PhysicalDefUse.maskC0_C1_C2_C3,
2253 PhysicalDefUse.mask),
2254 new Operator((char)(89 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDLG2
2255 InstructionFormat.MIR_Nullary_format,
2256 (fpPush | InstructionFormat.MIR_Nullary_traits),
2257 1, 0, 0,
2258 PhysicalDefUse.maskC0_C1_C2_C3,
2259 PhysicalDefUse.mask),
2260 new Operator((char)(90 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDLN2
2261 InstructionFormat.MIR_Nullary_format,
2262 (fpPush | InstructionFormat.MIR_Nullary_traits),
2263 1, 0, 0,
2264 PhysicalDefUse.maskC0_C1_C2_C3,
2265 PhysicalDefUse.mask),
2266 new Operator((char)(91 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FLDZ
2267 InstructionFormat.MIR_Nullary_format,
2268 (fpPush | InstructionFormat.MIR_Nullary_traits),
2269 1, 0, 0,
2270 PhysicalDefUse.maskC0_C1_C2_C3,
2271 PhysicalDefUse.mask),
2272 new Operator((char)(92 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FMUL
2273 InstructionFormat.MIR_BinaryAcc_format,
2274 (none | InstructionFormat.MIR_BinaryAcc_traits),
2275 0, 1, 1,
2276 PhysicalDefUse.maskC0_C1_C2_C3,
2277 PhysicalDefUse.mask),
2278 new Operator((char)(93 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FMULP
2279 InstructionFormat.MIR_BinaryAcc_format,
2280 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2281 0, 1, 1,
2282 PhysicalDefUse.maskC0_C1_C2_C3,
2283 PhysicalDefUse.mask),
2284 new Operator((char)(94 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FNSTCW
2285 InstructionFormat.MIR_UnaryNoRes_format,
2286 (none | InstructionFormat.MIR_UnaryNoRes_traits),
2287 0, 0, 1,
2288 PhysicalDefUse.maskC0_C1_C2_C3,
2289 PhysicalDefUse.mask),
2290 new Operator((char)(95 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FNINIT
2291 InstructionFormat.MIR_Empty_format,
2292 (none | InstructionFormat.MIR_Empty_traits),
2293 0, 0, 0,
2294 PhysicalDefUse.maskC0_C1_C2_C3,
2295 PhysicalDefUse.mask),
2296 new Operator((char)(96 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FNSAVE
2297 InstructionFormat.MIR_FSave_format,
2298 (none | InstructionFormat.MIR_FSave_traits),
2299 0, 0, 1,
2300 PhysicalDefUse.maskC0_C1_C2_C3,
2301 PhysicalDefUse.mask),
2302 new Operator((char)(97 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FPREM
2303 InstructionFormat.MIR_BinaryAcc_format,
2304 (none | InstructionFormat.MIR_BinaryAcc_traits),
2305 0, 1, 1,
2306 PhysicalDefUse.maskC0_C1_C2_C3,
2307 PhysicalDefUse.mask),
2308 new Operator((char)(98 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FRSTOR
2309 InstructionFormat.MIR_FSave_format,
2310 (none | InstructionFormat.MIR_FSave_traits),
2311 0, 0, 1,
2312 PhysicalDefUse.maskC0_C1_C2_C3,
2313 PhysicalDefUse.mask),
2314 new Operator((char)(99 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FST
2315 InstructionFormat.MIR_Move_format,
2316 (none | InstructionFormat.MIR_Move_traits),
2317 1, 0, 1,
2318 PhysicalDefUse.maskC0_C1_C2_C3,
2319 PhysicalDefUse.mask),
2320 new Operator((char)(100 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSTCW
2321 InstructionFormat.MIR_UnaryNoRes_format,
2322 (none | InstructionFormat.MIR_UnaryNoRes_traits),
2323 0, 0, 1,
2324 PhysicalDefUse.maskC0_C1_C2_C3,
2325 PhysicalDefUse.mask),
2326 new Operator((char)(101 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSTP
2327 InstructionFormat.MIR_Move_format,
2328 (fpPop | InstructionFormat.MIR_Move_traits),
2329 1, 0, 1,
2330 PhysicalDefUse.maskC0_C1_C2_C3,
2331 PhysicalDefUse.mask),
2332 new Operator((char)(102 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSUB
2333 InstructionFormat.MIR_BinaryAcc_format,
2334 (none | InstructionFormat.MIR_BinaryAcc_traits),
2335 0, 1, 1,
2336 PhysicalDefUse.maskC0_C1_C2_C3,
2337 PhysicalDefUse.mask),
2338 new Operator((char)(103 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSUBP
2339 InstructionFormat.MIR_BinaryAcc_format,
2340 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2341 0, 1, 1,
2342 PhysicalDefUse.maskC0_C1_C2_C3,
2343 PhysicalDefUse.mask),
2344 new Operator((char)(104 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSUBR
2345 InstructionFormat.MIR_BinaryAcc_format,
2346 (none | InstructionFormat.MIR_BinaryAcc_traits),
2347 0, 1, 1,
2348 PhysicalDefUse.maskC0_C1_C2_C3,
2349 PhysicalDefUse.mask),
2350 new Operator((char)(105 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FSUBRP
2351 InstructionFormat.MIR_BinaryAcc_format,
2352 (fpPop | InstructionFormat.MIR_BinaryAcc_traits),
2353 0, 1, 1,
2354 PhysicalDefUse.maskC0_C1_C2_C3,
2355 PhysicalDefUse.mask),
2356 new Operator((char)(106 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FUCOMI
2357 InstructionFormat.MIR_Compare_format,
2358 (compare | InstructionFormat.MIR_Compare_traits),
2359 0, 0, 2,
2360 PhysicalDefUse.maskCF_PF_ZF,
2361 PhysicalDefUse.mask),
2362 new Operator((char)(107 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_FUCOMIP
2363 InstructionFormat.MIR_Compare_format,
2364 (compare | InstructionFormat.MIR_Compare_traits),
2365 0, 0, 2,
2366 PhysicalDefUse.maskCF_PF_ZF,
2367 PhysicalDefUse.mask),
2368 new Operator((char)(108 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_IDIV
2369 InstructionFormat.MIR_Divide_format,
2370 (none | InstructionFormat.MIR_Divide_traits),
2371 0, 2, 2,
2372 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2373 PhysicalDefUse.mask),
2374 new Operator((char)(109 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_IMUL1
2375 InstructionFormat.MIR_Multiply_format,
2376 (none | InstructionFormat.MIR_Multiply_traits),
2377 1, 1, 1,
2378 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2379 PhysicalDefUse.mask),
2380 new Operator((char)(110 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_IMUL2
2381 InstructionFormat.MIR_BinaryAcc_format,
2382 (none | InstructionFormat.MIR_BinaryAcc_traits),
2383 0, 1, 1,
2384 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2385 PhysicalDefUse.mask),
2386 new Operator((char)(111 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_INC
2387 InstructionFormat.MIR_UnaryAcc_format,
2388 (none | InstructionFormat.MIR_UnaryAcc_traits),
2389 0, 1, 0,
2390 PhysicalDefUse.maskAF_OF_PF_SF_ZF,
2391 PhysicalDefUse.mask),
2392 new Operator((char)(112 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_INT
2393 InstructionFormat.MIR_Trap_format,
2394 (immedPEI | InstructionFormat.MIR_Trap_traits),
2395 1, 0, 1,
2396 PhysicalDefUse.mask,
2397 PhysicalDefUse.mask),
2398 new Operator((char)(113 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_JCC
2399 InstructionFormat.MIR_CondBranch_format,
2400 (branch | conditional | InstructionFormat.MIR_CondBranch_traits),
2401 0, 0, 3,
2402 PhysicalDefUse.mask,
2403 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF),
2404 new Operator((char)(114 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_JCC2
2405 InstructionFormat.MIR_CondBranch2_format,
2406 (branch | conditional | InstructionFormat.MIR_CondBranch2_traits),
2407 0, 0, 6,
2408 PhysicalDefUse.mask,
2409 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF),
2410 new Operator((char)(115 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_JMP
2411 InstructionFormat.MIR_Branch_format,
2412 (branch | InstructionFormat.MIR_Branch_traits),
2413 0, 0, 1,
2414 PhysicalDefUse.mask,
2415 PhysicalDefUse.mask),
2416 new Operator((char)(116 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_LEA
2417 InstructionFormat.MIR_Lea_format,
2418 (none | InstructionFormat.MIR_Lea_traits),
2419 1, 0, 1,
2420 PhysicalDefUse.mask,
2421 PhysicalDefUse.mask),
2422 new Operator((char)(117 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_LOCK
2423 InstructionFormat.MIR_Empty_format,
2424 (none | InstructionFormat.MIR_Empty_traits),
2425 0, 0, 0,
2426 PhysicalDefUse.mask,
2427 PhysicalDefUse.mask),
2428 new Operator((char)(118 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOV
2429 InstructionFormat.MIR_Move_format,
2430 (move | InstructionFormat.MIR_Move_traits),
2431 1, 0, 1,
2432 PhysicalDefUse.mask,
2433 PhysicalDefUse.mask),
2434 new Operator((char)(119 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVZX__B
2435 InstructionFormat.MIR_Unary_format,
2436 (move | InstructionFormat.MIR_Unary_traits),
2437 1, 0, 1,
2438 PhysicalDefUse.mask,
2439 PhysicalDefUse.mask),
2440 new Operator((char)(120 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSX__B
2441 InstructionFormat.MIR_Unary_format,
2442 (move | InstructionFormat.MIR_Unary_traits),
2443 1, 0, 1,
2444 PhysicalDefUse.mask,
2445 PhysicalDefUse.mask),
2446 new Operator((char)(121 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVZX__W
2447 InstructionFormat.MIR_Unary_format,
2448 (move | InstructionFormat.MIR_Unary_traits),
2449 1, 0, 1,
2450 PhysicalDefUse.mask,
2451 PhysicalDefUse.mask),
2452 new Operator((char)(122 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSX__W
2453 InstructionFormat.MIR_Unary_format,
2454 (move | InstructionFormat.MIR_Unary_traits),
2455 1, 0, 1,
2456 PhysicalDefUse.mask,
2457 PhysicalDefUse.mask),
2458 new Operator((char)(123 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVZXQ__B
2459 InstructionFormat.MIR_Unary_format,
2460 (move | InstructionFormat.MIR_Unary_traits),
2461 1, 0, 1,
2462 PhysicalDefUse.mask,
2463 PhysicalDefUse.mask),
2464 new Operator((char)(124 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSXQ__B
2465 InstructionFormat.MIR_Unary_format,
2466 (move | InstructionFormat.MIR_Unary_traits),
2467 1, 0, 1,
2468 PhysicalDefUse.mask,
2469 PhysicalDefUse.mask),
2470 new Operator((char)(125 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVZXQ__W
2471 InstructionFormat.MIR_Unary_format,
2472 (move | InstructionFormat.MIR_Unary_traits),
2473 1, 0, 1,
2474 PhysicalDefUse.mask,
2475 PhysicalDefUse.mask),
2476 new Operator((char)(126 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSXQ__W
2477 InstructionFormat.MIR_Unary_format,
2478 (move | InstructionFormat.MIR_Unary_traits),
2479 1, 0, 1,
2480 PhysicalDefUse.mask,
2481 PhysicalDefUse.mask),
2482 new Operator((char)(127 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MUL
2483 InstructionFormat.MIR_Multiply_format,
2484 (none | InstructionFormat.MIR_Multiply_traits),
2485 1, 1, 1,
2486 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2487 PhysicalDefUse.mask),
2488 new Operator((char)(128 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_NEG
2489 InstructionFormat.MIR_UnaryAcc_format,
2490 (none | InstructionFormat.MIR_UnaryAcc_traits),
2491 0, 1, 0,
2492 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2493 PhysicalDefUse.mask),
2494 new Operator((char)(129 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_NOT
2495 InstructionFormat.MIR_UnaryAcc_format,
2496 (none | InstructionFormat.MIR_UnaryAcc_traits),
2497 0, 1, 0,
2498 PhysicalDefUse.mask,
2499 PhysicalDefUse.mask),
2500 new Operator((char)(130 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_OR
2501 InstructionFormat.MIR_BinaryAcc_format,
2502 (none | InstructionFormat.MIR_BinaryAcc_traits),
2503 0, 1, 1,
2504 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2505 PhysicalDefUse.mask),
2506 new Operator((char)(131 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MFENCE
2507 InstructionFormat.MIR_Empty_format,
2508 (none | InstructionFormat.MIR_Empty_traits),
2509 0, 0, 0,
2510 PhysicalDefUse.mask,
2511 PhysicalDefUse.mask),
2512 new Operator((char)(132 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_PAUSE
2513 InstructionFormat.MIR_Empty_format,
2514 (none | InstructionFormat.MIR_Empty_traits),
2515 0, 0, 0,
2516 PhysicalDefUse.mask,
2517 PhysicalDefUse.mask),
2518 new Operator((char)(133 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_PREFETCHNTA
2519 InstructionFormat.MIR_CacheOp_format,
2520 (none | InstructionFormat.MIR_CacheOp_traits),
2521 0, 0, 1,
2522 PhysicalDefUse.mask,
2523 PhysicalDefUse.mask),
2524 new Operator((char)(134 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_POP
2525 InstructionFormat.MIR_Nullary_format,
2526 (none | InstructionFormat.MIR_Nullary_traits),
2527 1, 0, 0,
2528 PhysicalDefUse.maskESP,
2529 PhysicalDefUse.maskESP),
2530 new Operator((char)(135 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_PUSH
2531 InstructionFormat.MIR_UnaryNoRes_format,
2532 (none | InstructionFormat.MIR_UnaryNoRes_traits),
2533 0, 0, 1,
2534 PhysicalDefUse.maskESP,
2535 PhysicalDefUse.maskESP),
2536 new Operator((char)(136 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_RCL
2537 InstructionFormat.MIR_BinaryAcc_format,
2538 (none | InstructionFormat.MIR_BinaryAcc_traits),
2539 0, 1, 1,
2540 PhysicalDefUse.maskCF_OF,
2541 PhysicalDefUse.maskCF),
2542 new Operator((char)(137 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_RCR
2543 InstructionFormat.MIR_BinaryAcc_format,
2544 (none | InstructionFormat.MIR_BinaryAcc_traits),
2545 0, 1, 1,
2546 PhysicalDefUse.maskCF_OF,
2547 PhysicalDefUse.maskCF),
2548 new Operator((char)(138 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ROL
2549 InstructionFormat.MIR_BinaryAcc_format,
2550 (none | InstructionFormat.MIR_BinaryAcc_traits),
2551 0, 1, 1,
2552 PhysicalDefUse.maskCF_OF,
2553 PhysicalDefUse.mask),
2554 new Operator((char)(139 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ROR
2555 InstructionFormat.MIR_BinaryAcc_format,
2556 (none | InstructionFormat.MIR_BinaryAcc_traits),
2557 0, 1, 1,
2558 PhysicalDefUse.maskCF_OF,
2559 PhysicalDefUse.mask),
2560 new Operator((char)(140 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_RET
2561 InstructionFormat.MIR_Return_format,
2562 (ret | InstructionFormat.MIR_Return_traits),
2563 0, 0, 3,
2564 PhysicalDefUse.maskESP,
2565 PhysicalDefUse.maskESP),
2566 new Operator((char)(141 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SAL
2567 InstructionFormat.MIR_BinaryAcc_format,
2568 (none | InstructionFormat.MIR_BinaryAcc_traits),
2569 0, 1, 1,
2570 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2571 PhysicalDefUse.mask),
2572 new Operator((char)(142 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SAR
2573 InstructionFormat.MIR_BinaryAcc_format,
2574 (none | InstructionFormat.MIR_BinaryAcc_traits),
2575 0, 1, 1,
2576 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2577 PhysicalDefUse.mask),
2578 new Operator((char)(143 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SHL
2579 InstructionFormat.MIR_BinaryAcc_format,
2580 (none | InstructionFormat.MIR_BinaryAcc_traits),
2581 0, 1, 1,
2582 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2583 PhysicalDefUse.mask),
2584 new Operator((char)(144 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SHR
2585 InstructionFormat.MIR_BinaryAcc_format,
2586 (none | InstructionFormat.MIR_BinaryAcc_traits),
2587 0, 1, 1,
2588 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2589 PhysicalDefUse.mask),
2590 new Operator((char)(145 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SBB
2591 InstructionFormat.MIR_BinaryAcc_format,
2592 (none | InstructionFormat.MIR_BinaryAcc_traits),
2593 0, 1, 1,
2594 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2595 PhysicalDefUse.maskCF),
2596 new Operator((char)(146 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SET__B
2597 InstructionFormat.MIR_Set_format,
2598 (none | InstructionFormat.MIR_Set_traits),
2599 1, 0, 1,
2600 PhysicalDefUse.mask,
2601 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF),
2602 new Operator((char)(147 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SHLD
2603 InstructionFormat.MIR_DoubleShift_format,
2604 (none | InstructionFormat.MIR_DoubleShift_traits),
2605 0, 1, 2,
2606 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2607 PhysicalDefUse.mask),
2608 new Operator((char)(148 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SHRD
2609 InstructionFormat.MIR_DoubleShift_format,
2610 (none | InstructionFormat.MIR_DoubleShift_traits),
2611 0, 1, 2,
2612 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2613 PhysicalDefUse.mask),
2614 new Operator((char)(149 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SUB
2615 InstructionFormat.MIR_BinaryAcc_format,
2616 (none | InstructionFormat.MIR_BinaryAcc_traits),
2617 0, 1, 1,
2618 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2619 PhysicalDefUse.mask),
2620 new Operator((char)(150 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_TEST
2621 InstructionFormat.MIR_Test_format,
2622 (none | InstructionFormat.MIR_Test_traits),
2623 0, 0, 2,
2624 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2625 PhysicalDefUse.mask),
2626 new Operator((char)(151 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_XOR
2627 InstructionFormat.MIR_BinaryAcc_format,
2628 (none | InstructionFormat.MIR_BinaryAcc_traits),
2629 0, 1, 1,
2630 PhysicalDefUse.maskAF_CF_OF_PF_SF_ZF,
2631 PhysicalDefUse.mask),
2632 new Operator((char)(152 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_RDTSC
2633 InstructionFormat.MIR_RDTSC_format,
2634 (none | InstructionFormat.MIR_RDTSC_traits),
2635 2, 0, 0,
2636 PhysicalDefUse.maskCF_OF,
2637 PhysicalDefUse.mask),
2638 new Operator((char)(153 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ADDSS
2639 InstructionFormat.MIR_BinaryAcc_format,
2640 (none | InstructionFormat.MIR_BinaryAcc_traits),
2641 0, 1, 1,
2642 PhysicalDefUse.mask,
2643 PhysicalDefUse.mask),
2644 new Operator((char)(154 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SUBSS
2645 InstructionFormat.MIR_BinaryAcc_format,
2646 (none | InstructionFormat.MIR_BinaryAcc_traits),
2647 0, 1, 1,
2648 PhysicalDefUse.mask,
2649 PhysicalDefUse.mask),
2650 new Operator((char)(155 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MULSS
2651 InstructionFormat.MIR_BinaryAcc_format,
2652 (none | InstructionFormat.MIR_BinaryAcc_traits),
2653 0, 1, 1,
2654 PhysicalDefUse.mask,
2655 PhysicalDefUse.mask),
2656 new Operator((char)(156 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_DIVSS
2657 InstructionFormat.MIR_BinaryAcc_format,
2658 (none | InstructionFormat.MIR_BinaryAcc_traits),
2659 0, 1, 1,
2660 PhysicalDefUse.mask,
2661 PhysicalDefUse.mask),
2662 new Operator((char)(157 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ADDSD
2663 InstructionFormat.MIR_BinaryAcc_format,
2664 (none | InstructionFormat.MIR_BinaryAcc_traits),
2665 0, 1, 1,
2666 PhysicalDefUse.mask,
2667 PhysicalDefUse.mask),
2668 new Operator((char)(158 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SUBSD
2669 InstructionFormat.MIR_BinaryAcc_format,
2670 (none | InstructionFormat.MIR_BinaryAcc_traits),
2671 0, 1, 1,
2672 PhysicalDefUse.mask,
2673 PhysicalDefUse.mask),
2674 new Operator((char)(159 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MULSD
2675 InstructionFormat.MIR_BinaryAcc_format,
2676 (none | InstructionFormat.MIR_BinaryAcc_traits),
2677 0, 1, 1,
2678 PhysicalDefUse.mask,
2679 PhysicalDefUse.mask),
2680 new Operator((char)(160 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_DIVSD
2681 InstructionFormat.MIR_BinaryAcc_format,
2682 (none | InstructionFormat.MIR_BinaryAcc_traits),
2683 0, 1, 1,
2684 PhysicalDefUse.mask,
2685 PhysicalDefUse.mask),
2686 new Operator((char)(161 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ANDPS
2687 InstructionFormat.MIR_BinaryAcc_format,
2688 (none | InstructionFormat.MIR_BinaryAcc_traits),
2689 0, 1, 1,
2690 PhysicalDefUse.mask,
2691 PhysicalDefUse.mask),
2692 new Operator((char)(162 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ANDPD
2693 InstructionFormat.MIR_BinaryAcc_format,
2694 (none | InstructionFormat.MIR_BinaryAcc_traits),
2695 0, 1, 1,
2696 PhysicalDefUse.mask,
2697 PhysicalDefUse.mask),
2698 new Operator((char)(163 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ANDNPS
2699 InstructionFormat.MIR_BinaryAcc_format,
2700 (none | InstructionFormat.MIR_BinaryAcc_traits),
2701 0, 1, 1,
2702 PhysicalDefUse.mask,
2703 PhysicalDefUse.mask),
2704 new Operator((char)(164 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ANDNPD
2705 InstructionFormat.MIR_BinaryAcc_format,
2706 (none | InstructionFormat.MIR_BinaryAcc_traits),
2707 0, 1, 1,
2708 PhysicalDefUse.mask,
2709 PhysicalDefUse.mask),
2710 new Operator((char)(165 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ORPS
2711 InstructionFormat.MIR_BinaryAcc_format,
2712 (none | InstructionFormat.MIR_BinaryAcc_traits),
2713 0, 1, 1,
2714 PhysicalDefUse.mask,
2715 PhysicalDefUse.mask),
2716 new Operator((char)(166 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_ORPD
2717 InstructionFormat.MIR_BinaryAcc_format,
2718 (none | InstructionFormat.MIR_BinaryAcc_traits),
2719 0, 1, 1,
2720 PhysicalDefUse.mask,
2721 PhysicalDefUse.mask),
2722 new Operator((char)(167 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_XORPS
2723 InstructionFormat.MIR_BinaryAcc_format,
2724 (none | InstructionFormat.MIR_BinaryAcc_traits),
2725 0, 1, 1,
2726 PhysicalDefUse.mask,
2727 PhysicalDefUse.mask),
2728 new Operator((char)(168 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_XORPD
2729 InstructionFormat.MIR_BinaryAcc_format,
2730 (none | InstructionFormat.MIR_BinaryAcc_traits),
2731 0, 1, 1,
2732 PhysicalDefUse.mask,
2733 PhysicalDefUse.mask),
2734 new Operator((char)(169 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_UCOMISS
2735 InstructionFormat.MIR_Compare_format,
2736 (compare | InstructionFormat.MIR_Compare_traits),
2737 0, 0, 2,
2738 PhysicalDefUse.maskCF_PF_ZF,
2739 PhysicalDefUse.mask),
2740 new Operator((char)(170 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_UCOMISD
2741 InstructionFormat.MIR_Compare_format,
2742 (compare | InstructionFormat.MIR_Compare_traits),
2743 0, 0, 2,
2744 PhysicalDefUse.maskCF_PF_ZF,
2745 PhysicalDefUse.mask),
2746 new Operator((char)(171 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPEQSS
2747 InstructionFormat.MIR_BinaryAcc_format,
2748 (none | InstructionFormat.MIR_BinaryAcc_traits),
2749 0, 1, 1,
2750 PhysicalDefUse.mask,
2751 PhysicalDefUse.mask),
2752 new Operator((char)(172 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPLTSS
2753 InstructionFormat.MIR_BinaryAcc_format,
2754 (none | InstructionFormat.MIR_BinaryAcc_traits),
2755 0, 1, 1,
2756 PhysicalDefUse.mask,
2757 PhysicalDefUse.mask),
2758 new Operator((char)(173 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPLESS
2759 InstructionFormat.MIR_BinaryAcc_format,
2760 (none | InstructionFormat.MIR_BinaryAcc_traits),
2761 0, 1, 1,
2762 PhysicalDefUse.mask,
2763 PhysicalDefUse.mask),
2764 new Operator((char)(174 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPUNORDSS
2765 InstructionFormat.MIR_BinaryAcc_format,
2766 (none | InstructionFormat.MIR_BinaryAcc_traits),
2767 0, 1, 1,
2768 PhysicalDefUse.mask,
2769 PhysicalDefUse.mask),
2770 new Operator((char)(175 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNESS
2771 InstructionFormat.MIR_BinaryAcc_format,
2772 (none | InstructionFormat.MIR_BinaryAcc_traits),
2773 0, 1, 1,
2774 PhysicalDefUse.mask,
2775 PhysicalDefUse.mask),
2776 new Operator((char)(176 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNLTSS
2777 InstructionFormat.MIR_BinaryAcc_format,
2778 (none | InstructionFormat.MIR_BinaryAcc_traits),
2779 0, 1, 1,
2780 PhysicalDefUse.mask,
2781 PhysicalDefUse.mask),
2782 new Operator((char)(177 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNLESS
2783 InstructionFormat.MIR_BinaryAcc_format,
2784 (none | InstructionFormat.MIR_BinaryAcc_traits),
2785 0, 1, 1,
2786 PhysicalDefUse.mask,
2787 PhysicalDefUse.mask),
2788 new Operator((char)(178 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPORDSS
2789 InstructionFormat.MIR_BinaryAcc_format,
2790 (none | InstructionFormat.MIR_BinaryAcc_traits),
2791 0, 1, 1,
2792 PhysicalDefUse.mask,
2793 PhysicalDefUse.mask),
2794 new Operator((char)(179 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPEQSD
2795 InstructionFormat.MIR_BinaryAcc_format,
2796 (none | InstructionFormat.MIR_BinaryAcc_traits),
2797 0, 1, 1,
2798 PhysicalDefUse.mask,
2799 PhysicalDefUse.mask),
2800 new Operator((char)(180 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPLTSD
2801 InstructionFormat.MIR_BinaryAcc_format,
2802 (none | InstructionFormat.MIR_BinaryAcc_traits),
2803 0, 1, 1,
2804 PhysicalDefUse.mask,
2805 PhysicalDefUse.mask),
2806 new Operator((char)(181 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPLESD
2807 InstructionFormat.MIR_BinaryAcc_format,
2808 (none | InstructionFormat.MIR_BinaryAcc_traits),
2809 0, 1, 1,
2810 PhysicalDefUse.mask,
2811 PhysicalDefUse.mask),
2812 new Operator((char)(182 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPUNORDSD
2813 InstructionFormat.MIR_BinaryAcc_format,
2814 (none | InstructionFormat.MIR_BinaryAcc_traits),
2815 0, 1, 1,
2816 PhysicalDefUse.mask,
2817 PhysicalDefUse.mask),
2818 new Operator((char)(183 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNESD
2819 InstructionFormat.MIR_BinaryAcc_format,
2820 (none | InstructionFormat.MIR_BinaryAcc_traits),
2821 0, 1, 1,
2822 PhysicalDefUse.mask,
2823 PhysicalDefUse.mask),
2824 new Operator((char)(184 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNLTSD
2825 InstructionFormat.MIR_BinaryAcc_format,
2826 (none | InstructionFormat.MIR_BinaryAcc_traits),
2827 0, 1, 1,
2828 PhysicalDefUse.mask,
2829 PhysicalDefUse.mask),
2830 new Operator((char)(185 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPNLESD
2831 InstructionFormat.MIR_BinaryAcc_format,
2832 (none | InstructionFormat.MIR_BinaryAcc_traits),
2833 0, 1, 1,
2834 PhysicalDefUse.mask,
2835 PhysicalDefUse.mask),
2836 new Operator((char)(186 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CMPORDSD
2837 InstructionFormat.MIR_BinaryAcc_format,
2838 (none | InstructionFormat.MIR_BinaryAcc_traits),
2839 0, 1, 1,
2840 PhysicalDefUse.mask,
2841 PhysicalDefUse.mask),
2842 new Operator((char)(187 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVLPD
2843 InstructionFormat.MIR_Move_format,
2844 (move | InstructionFormat.MIR_Move_traits),
2845 1, 0, 1,
2846 PhysicalDefUse.mask,
2847 PhysicalDefUse.mask),
2848 new Operator((char)(188 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVLPS
2849 InstructionFormat.MIR_Move_format,
2850 (move | InstructionFormat.MIR_Move_traits),
2851 1, 0, 1,
2852 PhysicalDefUse.mask,
2853 PhysicalDefUse.mask),
2854 new Operator((char)(189 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSS
2855 InstructionFormat.MIR_Move_format,
2856 (move | InstructionFormat.MIR_Move_traits),
2857 1, 0, 1,
2858 PhysicalDefUse.mask,
2859 PhysicalDefUse.mask),
2860 new Operator((char)(190 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVSD
2861 InstructionFormat.MIR_Move_format,
2862 (move | InstructionFormat.MIR_Move_traits),
2863 1, 0, 1,
2864 PhysicalDefUse.mask,
2865 PhysicalDefUse.mask),
2866 new Operator((char)(191 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVD
2867 InstructionFormat.MIR_Move_format,
2868 (move | InstructionFormat.MIR_Move_traits),
2869 1, 0, 1,
2870 PhysicalDefUse.mask,
2871 PhysicalDefUse.mask),
2872 new Operator((char)(192 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_MOVQ
2873 InstructionFormat.MIR_Move_format,
2874 (move | InstructionFormat.MIR_Move_traits),
2875 1, 0, 1,
2876 PhysicalDefUse.mask,
2877 PhysicalDefUse.mask),
2878 new Operator((char)(193 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_PSLLQ
2879 InstructionFormat.MIR_BinaryAcc_format,
2880 (none | InstructionFormat.MIR_BinaryAcc_traits),
2881 0, 1, 1,
2882 PhysicalDefUse.mask,
2883 PhysicalDefUse.mask),
2884 new Operator((char)(194 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_PSRLQ
2885 InstructionFormat.MIR_BinaryAcc_format,
2886 (none | InstructionFormat.MIR_BinaryAcc_traits),
2887 0, 1, 1,
2888 PhysicalDefUse.mask,
2889 PhysicalDefUse.mask),
2890 new Operator((char)(195 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SQRTSS
2891 InstructionFormat.MIR_Unary_format,
2892 (none | InstructionFormat.MIR_Unary_traits),
2893 1, 0, 1,
2894 PhysicalDefUse.maskC0_C1_C2_C3,
2895 PhysicalDefUse.mask),
2896 new Operator((char)(196 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_SQRTSD
2897 InstructionFormat.MIR_Unary_format,
2898 (none | InstructionFormat.MIR_Unary_traits),
2899 1, 0, 1,
2900 PhysicalDefUse.maskC0_C1_C2_C3,
2901 PhysicalDefUse.mask),
2902 new Operator((char)(197 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSI2SS
2903 InstructionFormat.MIR_Unary_format,
2904 (move | InstructionFormat.MIR_Unary_traits),
2905 1, 0, 1,
2906 PhysicalDefUse.mask,
2907 PhysicalDefUse.mask),
2908 new Operator((char)(198 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSS2SD
2909 InstructionFormat.MIR_Unary_format,
2910 (move | InstructionFormat.MIR_Unary_traits),
2911 1, 0, 1,
2912 PhysicalDefUse.mask,
2913 PhysicalDefUse.mask),
2914 new Operator((char)(199 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSS2SI
2915 InstructionFormat.MIR_Unary_format,
2916 (move | InstructionFormat.MIR_Unary_traits),
2917 1, 0, 1,
2918 PhysicalDefUse.mask,
2919 PhysicalDefUse.mask),
2920 new Operator((char)(200 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTTSS2SI
2921 InstructionFormat.MIR_Unary_format,
2922 (move | InstructionFormat.MIR_Unary_traits),
2923 1, 0, 1,
2924 PhysicalDefUse.mask,
2925 PhysicalDefUse.mask),
2926 new Operator((char)(201 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSI2SD
2927 InstructionFormat.MIR_Unary_format,
2928 (move | InstructionFormat.MIR_Unary_traits),
2929 1, 0, 1,
2930 PhysicalDefUse.mask,
2931 PhysicalDefUse.mask),
2932 new Operator((char)(202 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSD2SS
2933 InstructionFormat.MIR_Unary_format,
2934 (move | InstructionFormat.MIR_Unary_traits),
2935 1, 0, 1,
2936 PhysicalDefUse.mask,
2937 PhysicalDefUse.mask),
2938 new Operator((char)(203 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSD2SI
2939 InstructionFormat.MIR_Unary_format,
2940 (move | InstructionFormat.MIR_Unary_traits),
2941 1, 0, 1,
2942 PhysicalDefUse.mask,
2943 PhysicalDefUse.mask),
2944 new Operator((char)(204 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTTSD2SI
2945 InstructionFormat.MIR_Unary_format,
2946 (move | InstructionFormat.MIR_Unary_traits),
2947 1, 0, 1,
2948 PhysicalDefUse.mask,
2949 PhysicalDefUse.mask),
2950 new Operator((char)(205 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSI2SDQ
2951 InstructionFormat.MIR_Unary_format,
2952 (move | InstructionFormat.MIR_Unary_traits),
2953 1, 0, 1,
2954 PhysicalDefUse.mask,
2955 PhysicalDefUse.mask),
2956 new Operator((char)(206 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTSD2SIQ
2957 InstructionFormat.MIR_Unary_format,
2958 (move | InstructionFormat.MIR_Unary_traits),
2959 1, 0, 1,
2960 PhysicalDefUse.mask,
2961 PhysicalDefUse.mask),
2962 new Operator((char)(207 + Operators.ARCH_INDEPENDENT_END_opcode), //IA32_CVTTSD2SIQ
2963 InstructionFormat.MIR_Unary_format,
2964 (move | InstructionFormat.MIR_Unary_traits),
2965 1, 0, 1,
2966 PhysicalDefUse.mask,
2967 PhysicalDefUse.mask),
2968 new Operator((char)(208 + Operators.ARCH_INDEPENDENT_END_opcode), //MIR_END
2969 InstructionFormat.Unassigned_format,
2970 (none),
2971 0,0,0,
2972 PhysicalDefUse.mask,
2973 PhysicalDefUse.mask),
2974 null };
2975
2976 // For HIR/LIR
2977 private Operator(char opcode, byte format, int traits,
2978 int numDefs, int numDefUses, int numUses,
2979 int iDefs, int iUses) {
2980 this.opcode = opcode;
2981 this.format = format;
2982 this.traits = traits;
2983 this.numberDefs = numDefs;
2984 this.numberDefUses= numDefUses;
2985 this.numberUses = numUses;
2986 this.implicitDefs = iDefs;
2987 this.implicitUses = iUses;
2988 }
2989
2990 }