1/*
2 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23package org.graalvm.compiler.core.common.type;
24
25import static jdk.vm.ci.meta.MetaUtil.getSimpleName;
26
27import java.util.Arrays;
28import java.util.Objects;
29import java.util.function.Function;
30
31import org.graalvm.compiler.core.common.calc.FloatConvert;
32import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Add;
33import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.And;
34import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Div;
35import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Mul;
36import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.MulHigh;
37import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Or;
38import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Rem;
39import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Sub;
40import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.UMulHigh;
41import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Xor;
42import org.graalvm.compiler.core.common.type.ArithmeticOpTable.IntegerConvertOp.Narrow;
43import org.graalvm.compiler.core.common.type.ArithmeticOpTable.IntegerConvertOp.SignExtend;
44import org.graalvm.compiler.core.common.type.ArithmeticOpTable.IntegerConvertOp.ZeroExtend;
45import org.graalvm.compiler.core.common.type.ArithmeticOpTable.ShiftOp.Shl;
46import org.graalvm.compiler.core.common.type.ArithmeticOpTable.ShiftOp.Shr;
47import org.graalvm.compiler.core.common.type.ArithmeticOpTable.ShiftOp.UShr;
48import org.graalvm.compiler.core.common.type.ArithmeticOpTable.UnaryOp.Abs;
49import org.graalvm.compiler.core.common.type.ArithmeticOpTable.UnaryOp.Neg;
50import org.graalvm.compiler.core.common.type.ArithmeticOpTable.UnaryOp.Not;
51import org.graalvm.compiler.core.common.type.ArithmeticOpTable.UnaryOp.Sqrt;
52import org.graalvm.util.CollectionsUtil;
53
54import jdk.vm.ci.meta.Constant;
55import jdk.vm.ci.meta.JavaKind;
56
57/**
58 * Information about arithmetic operations.
59 */
60public final class ArithmeticOpTable {
61
62    private final UnaryOp<Neg> neg;
63    private final BinaryOp<Add> add;
64    private final BinaryOp<Sub> sub;
65
66    private final BinaryOp<Mul> mul;
67    private final BinaryOp<MulHigh> mulHigh;
68    private final BinaryOp<UMulHigh> umulHigh;
69    private final BinaryOp<Div> div;
70    private final BinaryOp<Rem> rem;
71
72    private final UnaryOp<Not> not;
73    private final BinaryOp<And> and;
74    private final BinaryOp<Or> or;
75    private final BinaryOp<Xor> xor;
76
77    private final ShiftOp<Shl> shl;
78    private final ShiftOp<Shr> shr;
79    private final ShiftOp<UShr> ushr;
80
81    private final UnaryOp<Abs> abs;
82    private final UnaryOp<Sqrt> sqrt;
83
84    private final IntegerConvertOp<ZeroExtend> zeroExtend;
85    private final IntegerConvertOp<SignExtend> signExtend;
86    private final IntegerConvertOp<Narrow> narrow;
87
88    private final FloatConvertOp[] floatConvert;
89    private final int hash;
90
91    public static ArithmeticOpTable forStamp(Stamp s) {
92        if (s instanceof ArithmeticStamp) {
93            return ((ArithmeticStamp) s).getOps();
94        } else {
95            return EMPTY;
96        }
97    }
98
99    public static final ArithmeticOpTable EMPTY = new ArithmeticOpTable(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null);
100
101    public interface ArithmeticOpWrapper {
102
103        <OP> UnaryOp<OP> wrapUnaryOp(UnaryOp<OP> op);
104
105        <OP> BinaryOp<OP> wrapBinaryOp(BinaryOp<OP> op);
106
107        <OP> ShiftOp<OP> wrapShiftOp(ShiftOp<OP> op);
108
109        <OP> IntegerConvertOp<OP> wrapIntegerConvertOp(IntegerConvertOp<OP> op);
110
111        FloatConvertOp wrapFloatConvertOp(FloatConvertOp op);
112    }
113
114    private static <T> T wrapIfNonNull(Function<T, T> wrapper, T obj) {
115        if (obj == null) {
116            return null;
117        } else {
118            return wrapper.apply(obj);
119        }
120    }
121
122    public static ArithmeticOpTable wrap(ArithmeticOpWrapper wrapper, ArithmeticOpTable inner) {
123        UnaryOp<Neg> neg = wrapIfNonNull(wrapper::wrapUnaryOp, inner.getNeg());
124        BinaryOp<Add> add = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getAdd());
125        BinaryOp<Sub> sub = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getSub());
126
127        BinaryOp<Mul> mul = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getMul());
128        BinaryOp<MulHigh> mulHigh = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getMulHigh());
129        BinaryOp<UMulHigh> umulHigh = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getUMulHigh());
130        BinaryOp<Div> div = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getDiv());
131        BinaryOp<Rem> rem = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getRem());
132
133        UnaryOp<Not> not = wrapIfNonNull(wrapper::wrapUnaryOp, inner.getNot());
134        BinaryOp<And> and = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getAnd());
135        BinaryOp<Or> or = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getOr());
136        BinaryOp<Xor> xor = wrapIfNonNull(wrapper::wrapBinaryOp, inner.getXor());
137
138        ShiftOp<Shl> shl = wrapIfNonNull(wrapper::wrapShiftOp, inner.getShl());
139        ShiftOp<Shr> shr = wrapIfNonNull(wrapper::wrapShiftOp, inner.getShr());
140        ShiftOp<UShr> ushr = wrapIfNonNull(wrapper::wrapShiftOp, inner.getUShr());
141
142        UnaryOp<Abs> abs = wrapIfNonNull(wrapper::wrapUnaryOp, inner.getAbs());
143        UnaryOp<Sqrt> sqrt = wrapIfNonNull(wrapper::wrapUnaryOp, inner.getSqrt());
144
145        IntegerConvertOp<ZeroExtend> zeroExtend = wrapIfNonNull(wrapper::wrapIntegerConvertOp, inner.getZeroExtend());
146        IntegerConvertOp<SignExtend> signExtend = wrapIfNonNull(wrapper::wrapIntegerConvertOp, inner.getSignExtend());
147        IntegerConvertOp<Narrow> narrow = wrapIfNonNull(wrapper::wrapIntegerConvertOp, inner.getNarrow());
148
149        FloatConvertOp[] floatConvert = CollectionsUtil.filterAndMapToArray(inner.floatConvert, Objects::nonNull, wrapper::wrapFloatConvertOp, FloatConvertOp[]::new);
150        return new ArithmeticOpTable(neg, add, sub, mul, mulHigh, umulHigh, div, rem, not, and, or, xor, shl, shr, ushr, abs, sqrt, zeroExtend, signExtend, narrow, floatConvert);
151    }
152
153    protected ArithmeticOpTable(UnaryOp<Neg> neg, BinaryOp<Add> add, BinaryOp<Sub> sub, BinaryOp<Mul> mul, BinaryOp<MulHigh> mulHigh, BinaryOp<UMulHigh> umulHigh, BinaryOp<Div> div, BinaryOp<Rem> rem,
154                    UnaryOp<Not> not, BinaryOp<And> and, BinaryOp<Or> or, BinaryOp<Xor> xor, ShiftOp<Shl> shl, ShiftOp<Shr> shr, ShiftOp<UShr> ushr, UnaryOp<Abs> abs, UnaryOp<Sqrt> sqrt,
155                    IntegerConvertOp<ZeroExtend> zeroExtend, IntegerConvertOp<SignExtend> signExtend, IntegerConvertOp<Narrow> narrow, FloatConvertOp... floatConvert) {
156        this.neg = neg;
157        this.add = add;
158        this.sub = sub;
159        this.mul = mul;
160        this.mulHigh = mulHigh;
161        this.umulHigh = umulHigh;
162        this.div = div;
163        this.rem = rem;
164        this.not = not;
165        this.and = and;
166        this.or = or;
167        this.xor = xor;
168        this.shl = shl;
169        this.shr = shr;
170        this.ushr = ushr;
171        this.abs = abs;
172        this.sqrt = sqrt;
173        this.zeroExtend = zeroExtend;
174        this.signExtend = signExtend;
175        this.narrow = narrow;
176        this.floatConvert = new FloatConvertOp[FloatConvert.values().length];
177        for (FloatConvertOp op : floatConvert) {
178            this.floatConvert[op.getFloatConvert().ordinal()] = op;
179        }
180
181        this.hash = Objects.hash(neg, add, sub, mul, div, rem, not, and, or, xor, shl, shr, ushr, abs, sqrt, zeroExtend, signExtend, narrow);
182    }
183
184    @Override
185    public int hashCode() {
186        return hash;
187    }
188
189    /**
190     * Describes the unary negation operation.
191     */
192    public UnaryOp<Neg> getNeg() {
193        return neg;
194    }
195
196    /**
197     * Describes the addition operation.
198     */
199    public BinaryOp<Add> getAdd() {
200        return add;
201    }
202
203    /**
204     * Describes the subtraction operation.
205     */
206    public BinaryOp<Sub> getSub() {
207        return sub;
208    }
209
210    /**
211     * Describes the multiplication operation.
212     */
213    public BinaryOp<Mul> getMul() {
214        return mul;
215    }
216
217    /**
218     * Describes a signed operation that multiples the upper 32-bits of two long values.
219     */
220    public BinaryOp<MulHigh> getMulHigh() {
221        return mulHigh;
222    }
223
224    /**
225     * Describes an unsigned operation that multiples the upper 32-bits of two long values.
226     */
227    public BinaryOp<UMulHigh> getUMulHigh() {
228        return umulHigh;
229    }
230
231    /**
232     * Describes the division operation.
233     */
234    public BinaryOp<Div> getDiv() {
235        return div;
236    }
237
238    /**
239     * Describes the remainder operation.
240     */
241    public BinaryOp<Rem> getRem() {
242        return rem;
243    }
244
245    /**
246     * Describes the bitwise not operation.
247     */
248    public UnaryOp<Not> getNot() {
249        return not;
250    }
251
252    /**
253     * Describes the bitwise and operation.
254     */
255    public BinaryOp<And> getAnd() {
256        return and;
257    }
258
259    /**
260     * Describes the bitwise or operation.
261     */
262    public BinaryOp<Or> getOr() {
263        return or;
264    }
265
266    /**
267     * Describes the bitwise xor operation.
268     */
269    public BinaryOp<Xor> getXor() {
270        return xor;
271    }
272
273    /**
274     * Describes the shift left operation.
275     */
276    public ShiftOp<Shl> getShl() {
277        return shl;
278    }
279
280    /**
281     * Describes the signed shift right operation.
282     */
283    public ShiftOp<Shr> getShr() {
284        return shr;
285    }
286
287    /**
288     * Describes the unsigned shift right operation.
289     */
290    public ShiftOp<UShr> getUShr() {
291        return ushr;
292    }
293
294    /**
295     * Describes the absolute value operation.
296     */
297    public UnaryOp<Abs> getAbs() {
298        return abs;
299    }
300
301    /**
302     * Describes the square root operation.
303     */
304    public UnaryOp<Sqrt> getSqrt() {
305        return sqrt;
306    }
307
308    /**
309     * Describes the zero extend conversion.
310     */
311    public IntegerConvertOp<ZeroExtend> getZeroExtend() {
312        return zeroExtend;
313    }
314
315    /**
316     * Describes the sign extend conversion.
317     */
318    public IntegerConvertOp<SignExtend> getSignExtend() {
319        return signExtend;
320    }
321
322    /**
323     * Describes the narrowing conversion.
324     */
325    public IntegerConvertOp<Narrow> getNarrow() {
326        return narrow;
327    }
328
329    /**
330     * Describes integer/float/double conversions.
331     */
332    public FloatConvertOp getFloatConvert(FloatConvert op) {
333        return floatConvert[op.ordinal()];
334    }
335
336    public static String toString(Op... ops) {
337        return CollectionsUtil.mapAndJoin(ops, o -> o == null ? "null" : o.operator + "{" + getSimpleName(o.getClass(), false) + "}", ",");
338    }
339
340    private boolean opsEquals(ArithmeticOpTable that) {
341        // @formatter:off
342        return Objects.equals(neg, that.neg) &&
343               Objects.equals(add, that.add) &&
344               Objects.equals(sub, that.sub) &&
345               Objects.equals(mul, that.mul) &&
346               Objects.equals(mulHigh, that.mulHigh) &&
347               Objects.equals(umulHigh, that.umulHigh) &&
348               Objects.equals(div, that.div) &&
349               Objects.equals(rem, that.rem) &&
350               Objects.equals(not, that.not) &&
351               Objects.equals(and, that.and) &&
352               Objects.equals(or, that.or) &&
353               Objects.equals(xor, that.xor) &&
354               Objects.equals(shl, that.shl) &&
355               Objects.equals(shr, that.shr) &&
356               Objects.equals(ushr, that.ushr) &&
357               Objects.equals(abs, that.abs) &&
358               Objects.equals(sqrt, that.sqrt) &&
359               Objects.equals(zeroExtend, that.zeroExtend) &&
360               Objects.equals(signExtend, that.signExtend) &&
361               Objects.equals(narrow, that.narrow);
362        // @formatter:on
363    }
364
365    @Override
366    public boolean equals(Object obj) {
367        if (this == obj) {
368            return true;
369        }
370        if (obj == null) {
371            return false;
372        }
373        if (getClass() != obj.getClass()) {
374            return false;
375        }
376        ArithmeticOpTable that = (ArithmeticOpTable) obj;
377        if (opsEquals(that)) {
378            if (Arrays.equals(this.floatConvert, that.floatConvert)) {
379                return true;
380            }
381        }
382        return false;
383    }
384
385    @Override
386    public String toString() {
387        return getClass().getSimpleName() + "[" + toString(neg, add, sub, mul, mulHigh, umulHigh, div, rem, not, and, or, xor, shl, shr, ushr, abs, sqrt, zeroExtend, signExtend, narrow) +
388                        ",floatConvert[" + toString(floatConvert) + "]]";
389    }
390
391    public abstract static class Op {
392
393        private final String operator;
394
395        protected Op(String operator) {
396            this.operator = operator;
397        }
398
399        @Override
400        public String toString() {
401            return operator;
402        }
403
404        @Override
405        public int hashCode() {
406            return operator.hashCode();
407        }
408
409        @Override
410        public boolean equals(Object obj) {
411            if (this == obj) {
412                return true;
413            }
414            if (obj == null) {
415                return false;
416            }
417            if (getClass() != obj.getClass()) {
418                return false;
419            }
420            Op that = (Op) obj;
421            if (operator.equals(that.operator)) {
422                return true;
423            }
424            return true;
425        }
426    }
427
428    /**
429     * Describes a unary arithmetic operation.
430     */
431    public abstract static class UnaryOp<T> extends Op {
432
433        public abstract static class Neg extends UnaryOp<Neg> {
434
435            protected Neg() {
436                super("-");
437            }
438        }
439
440        public abstract static class Not extends UnaryOp<Not> {
441
442            protected Not() {
443                super("~");
444            }
445        }
446
447        public abstract static class Abs extends UnaryOp<Abs> {
448
449            protected Abs() {
450                super("ABS");
451            }
452        }
453
454        public abstract static class Sqrt extends UnaryOp<Sqrt> {
455
456            protected Sqrt() {
457                super("SQRT");
458            }
459        }
460
461        protected UnaryOp(String operation) {
462            super(operation);
463        }
464
465        /**
466         * Apply the operation to a {@link Constant}.
467         */
468        public abstract Constant foldConstant(Constant value);
469
470        /**
471         * Apply the operation to a {@link Stamp}.
472         */
473        public abstract Stamp foldStamp(Stamp stamp);
474
475        public UnaryOp<T> unwrap() {
476            return this;
477        }
478    }
479
480    /**
481     * Describes a binary arithmetic operation.
482     */
483    public abstract static class BinaryOp<T> extends Op {
484
485        public abstract static class Add extends BinaryOp<Add> {
486
487            protected Add(boolean associative, boolean commutative) {
488                super("+", associative, commutative);
489            }
490        }
491
492        public abstract static class Sub extends BinaryOp<Sub> {
493
494            protected Sub(boolean associative, boolean commutative) {
495                super("-", associative, commutative);
496            }
497        }
498
499        public abstract static class Mul extends BinaryOp<Mul> {
500
501            protected Mul(boolean associative, boolean commutative) {
502                super("*", associative, commutative);
503            }
504        }
505
506        public abstract static class MulHigh extends BinaryOp<MulHigh> {
507
508            protected MulHigh(boolean associative, boolean commutative) {
509                super("*H", associative, commutative);
510            }
511        }
512
513        public abstract static class UMulHigh extends BinaryOp<UMulHigh> {
514
515            protected UMulHigh(boolean associative, boolean commutative) {
516                super("|*H|", associative, commutative);
517            }
518        }
519
520        public abstract static class Div extends BinaryOp<Div> {
521
522            protected Div(boolean associative, boolean commutative) {
523                super("/", associative, commutative);
524            }
525        }
526
527        public abstract static class Rem extends BinaryOp<Rem> {
528
529            protected Rem(boolean associative, boolean commutative) {
530                super("%", associative, commutative);
531            }
532        }
533
534        public abstract static class And extends BinaryOp<And> {
535
536            protected And(boolean associative, boolean commutative) {
537                super("&", associative, commutative);
538            }
539        }
540
541        public abstract static class Or extends BinaryOp<Or> {
542
543            protected Or(boolean associative, boolean commutative) {
544                super("|", associative, commutative);
545            }
546        }
547
548        public abstract static class Xor extends BinaryOp<Xor> {
549
550            protected Xor(boolean associative, boolean commutative) {
551                super("^", associative, commutative);
552            }
553        }
554
555        private final boolean associative;
556        private final boolean commutative;
557
558        protected BinaryOp(String operation, boolean associative, boolean commutative) {
559            super(operation);
560            this.associative = associative;
561            this.commutative = commutative;
562        }
563
564        /**
565         * Apply the operation to two {@linkplain Constant Constants}.
566         */
567        public abstract Constant foldConstant(Constant a, Constant b);
568
569        /**
570         * Apply the operation to two {@linkplain Stamp Stamps}.
571         */
572        public abstract Stamp foldStamp(Stamp a, Stamp b);
573
574        /**
575         * Checks whether this operation is associative. An operation is associative when
576         * {@code (a . b) . c == a . (b . c)} for all a, b, c. Note that you still have to be
577         * careful with inverses. For example the integer subtraction operation will report
578         * {@code true} here, since you can still reassociate as long as the correct negations are
579         * inserted.
580         */
581        public final boolean isAssociative() {
582            return associative;
583        }
584
585        /**
586         * Checks whether this operation is commutative. An operation is commutative when
587         * {@code a . b == b . a} for all a, b.
588         */
589        public final boolean isCommutative() {
590            return commutative;
591        }
592
593        /**
594         * Check whether a {@link Constant} is a neutral element for this operation. A neutral
595         * element is any element {@code n} where {@code a . n == a} for all a.
596         *
597         * @param n the {@link Constant} that should be tested
598         * @return true iff for all {@code a}: {@code a . n == a}
599         */
600        public boolean isNeutral(Constant n) {
601            return false;
602        }
603
604        /**
605         * Check whether this operation has a zero {@code z == a . a} for each a. Examples of
606         * operations having such an element are subtraction and exclusive-or. Note that this may be
607         * different from the numbers tested by {@link #isNeutral}.
608         *
609         * @param stamp a {@link Stamp}
610         * @return a unique {@code z} such that {@code z == a . a} for each {@code a} in
611         *         {@code stamp} if it exists, otherwise {@code null}
612         */
613        public Constant getZero(Stamp stamp) {
614            return null;
615        }
616
617        public BinaryOp<T> unwrap() {
618            return this;
619        }
620
621        @Override
622        public int hashCode() {
623            final int prime = 31;
624            int result = super.hashCode();
625            result = prime * result + (associative ? 1231 : 1237);
626            result = prime * result + (commutative ? 1231 : 1237);
627            return result;
628        }
629
630        @Override
631        public boolean equals(Object obj) {
632            if (this == obj) {
633                return true;
634            }
635            if (!super.equals(obj)) {
636                return false;
637            }
638            if (getClass() != obj.getClass()) {
639                return false;
640            }
641            BinaryOp<?> that = (BinaryOp<?>) obj;
642            if (associative != that.associative) {
643                return false;
644            }
645            if (commutative != that.commutative) {
646                return false;
647            }
648            return true;
649        }
650
651        @Override
652        public String toString() {
653            if (associative) {
654                if (commutative) {
655                    return super.toString() + "[AC]";
656                } else {
657                    return super.toString() + "[A]";
658                }
659            } else if (commutative) {
660                return super.toString() + "[C]";
661            }
662            return super.toString();
663        }
664    }
665
666    /**
667     * Describes a shift operation. The right argument of a shift operation always has kind
668     * {@link JavaKind#Int}.
669     */
670    public abstract static class ShiftOp<OP> extends Op {
671
672        public abstract static class Shl extends ShiftOp<Shl> {
673
674            public Shl() {
675                super("<<");
676            }
677        }
678
679        public abstract static class Shr extends ShiftOp<Shr> {
680
681            public Shr() {
682                super(">>");
683            }
684        }
685
686        public abstract static class UShr extends ShiftOp<UShr> {
687
688            public UShr() {
689                super(">>>");
690            }
691        }
692
693        protected ShiftOp(String operation) {
694            super(operation);
695        }
696
697        /**
698         * Apply the shift to a constant.
699         */
700        public abstract Constant foldConstant(Constant c, int amount);
701
702        /**
703         * Apply the shift to a stamp.
704         */
705        public abstract Stamp foldStamp(Stamp s, IntegerStamp amount);
706
707        /**
708         * Get the shift amount mask for a given result stamp.
709         */
710        public abstract int getShiftAmountMask(Stamp s);
711    }
712
713    public abstract static class FloatConvertOp extends UnaryOp<FloatConvertOp> {
714
715        private final FloatConvert op;
716
717        protected FloatConvertOp(FloatConvert op) {
718            super(op.name());
719            this.op = op;
720        }
721
722        public FloatConvert getFloatConvert() {
723            return op;
724        }
725
726        @Override
727        public FloatConvertOp unwrap() {
728            return this;
729        }
730
731        @Override
732        public int hashCode() {
733            final int prime = 31;
734            return prime * super.hashCode() + op.hashCode();
735        }
736
737        @Override
738        public boolean equals(Object obj) {
739            if (this == obj) {
740                return true;
741            }
742            if (!super.equals(obj)) {
743                return false;
744            }
745            if (getClass() != obj.getClass()) {
746                return false;
747            }
748            FloatConvertOp that = (FloatConvertOp) obj;
749            if (op != that.op) {
750                return false;
751            }
752            return true;
753        }
754    }
755
756    public abstract static class IntegerConvertOp<T> extends Op {
757
758        public abstract static class ZeroExtend extends IntegerConvertOp<ZeroExtend> {
759
760            protected ZeroExtend() {
761                super("ZeroExtend");
762            }
763        }
764
765        public abstract static class SignExtend extends IntegerConvertOp<SignExtend> {
766
767            protected SignExtend() {
768                super("SignExtend");
769            }
770        }
771
772        public abstract static class Narrow extends IntegerConvertOp<Narrow> {
773
774            protected Narrow() {
775                super("Narrow");
776            }
777
778            @Override
779            public Stamp invertStamp(int inputBits, int resultBits, Stamp outStamp) {
780                return null;
781            }
782        }
783
784        protected IntegerConvertOp(String op) {
785            super(op);
786        }
787
788        public abstract Constant foldConstant(int inputBits, int resultBits, Constant value);
789
790        public abstract Stamp foldStamp(int inputBits, int resultBits, Stamp stamp);
791
792        public IntegerConvertOp<T> unwrap() {
793            return this;
794        }
795
796        /**
797         * Computes the stamp of the input for the given output stamp.
798         */
799        public abstract Stamp invertStamp(int inputBits, int resultBits, Stamp outStamp);
800    }
801}
802