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