Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/opto/divnode.hpp@bd441136a5ce (annotated)

src/share/vm/opto/divnode.hpp

Thu, 19 Mar 2009 09:13:24 -0700

author
kvn
date
Thu, 19 Mar 2009 09:13:24 -0700
changeset 1082
bd441136a5ce
parent 435
a61af66fc99e
child 1907
c18cbe5936b8
permissions
-rw-r--r--

Merge

duke@435 1 /*
duke@435 2 * Copyright 1997-2005 Sun Microsystems, Inc. All Rights Reserved.
duke@435 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435 4 *
duke@435 5 * This code is free software; you can redistribute it and/or modify it
duke@435 6 * under the terms of the GNU General Public License version 2 only, as
duke@435 7 * published by the Free Software Foundation.
duke@435 8 *
duke@435 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@435 13 * accompanied this code).
duke@435 14 *
duke@435 15 * You should have received a copy of the GNU General Public License version
duke@435 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@435 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435 18 *
duke@435 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435 20 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@435 21 * have any questions.
duke@435 22 *
duke@435 23 */
duke@435 24
duke@435 25 // Portions of code courtesy of Clifford Click
duke@435 26
duke@435 27 // Optimization - Graph Style
duke@435 28
duke@435 29
duke@435 30 //------------------------------DivINode---------------------------------------
duke@435 31 // Integer division
duke@435 32 // Note: this is division as defined by JVMS, i.e., MinInt/-1 == MinInt.
duke@435 33 // On processors which don't naturally support this special case (e.g., x86),
duke@435 34 // the matcher or runtime system must take care of this.
duke@435 35 class DivINode : public Node {
duke@435 36 public:
duke@435 37 DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
duke@435 38 virtual int Opcode() const;
duke@435 39 virtual Node *Identity( PhaseTransform *phase );
duke@435 40 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 41 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 42 virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435 43 virtual uint ideal_reg() const { return Op_RegI; }
duke@435 44 };
duke@435 45
duke@435 46 //------------------------------DivLNode---------------------------------------
duke@435 47 // Long division
duke@435 48 class DivLNode : public Node {
duke@435 49 public:
duke@435 50 DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
duke@435 51 virtual int Opcode() const;
duke@435 52 virtual Node *Identity( PhaseTransform *phase );
duke@435 53 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 54 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 55 virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435 56 virtual uint ideal_reg() const { return Op_RegL; }
duke@435 57 };
duke@435 58
duke@435 59 //------------------------------DivFNode---------------------------------------
duke@435 60 // Float division
duke@435 61 class DivFNode : public Node {
duke@435 62 public:
duke@435 63 DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {}
duke@435 64 virtual int Opcode() const;
duke@435 65 virtual Node *Identity( PhaseTransform *phase );
duke@435 66 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 67 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 68 virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435 69 virtual uint ideal_reg() const { return Op_RegF; }
duke@435 70 };
duke@435 71
duke@435 72 //------------------------------DivDNode---------------------------------------
duke@435 73 // Double division
duke@435 74 class DivDNode : public Node {
duke@435 75 public:
duke@435 76 DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {}
duke@435 77 virtual int Opcode() const;
duke@435 78 virtual Node *Identity( PhaseTransform *phase );
duke@435 79 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 80 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 81 virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435 82 virtual uint ideal_reg() const { return Op_RegD; }
duke@435 83 };
duke@435 84
duke@435 85 //------------------------------ModINode---------------------------------------
duke@435 86 // Integer modulus
duke@435 87 class ModINode : public Node {
duke@435 88 public:
duke@435 89 ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
duke@435 90 virtual int Opcode() const;
duke@435 91 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 92 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 93 virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435 94 virtual uint ideal_reg() const { return Op_RegI; }
duke@435 95 };
duke@435 96
duke@435 97 //------------------------------ModLNode---------------------------------------
duke@435 98 // Long modulus
duke@435 99 class ModLNode : public Node {
duke@435 100 public:
duke@435 101 ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
duke@435 102 virtual int Opcode() const;
duke@435 103 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 104 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435 105 virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435 106 virtual uint ideal_reg() const { return Op_RegL; }
duke@435 107 };
duke@435 108
duke@435 109 //------------------------------ModFNode---------------------------------------
duke@435 110 // Float Modulus
duke@435 111 class ModFNode : public Node {
duke@435 112 public:
duke@435 113 ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
duke@435 114 virtual int Opcode() const;
duke@435 115 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 116 virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435 117 virtual uint ideal_reg() const { return Op_RegF; }
duke@435 118 };
duke@435 119
duke@435 120 //------------------------------ModDNode---------------------------------------
duke@435 121 // Double Modulus
duke@435 122 class ModDNode : public Node {
duke@435 123 public:
duke@435 124 ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {}
duke@435 125 virtual int Opcode() const;
duke@435 126 virtual const Type *Value( PhaseTransform *phase ) const;
duke@435 127 virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435 128 virtual uint ideal_reg() const { return Op_RegD; }
duke@435 129 };
duke@435 130
duke@435 131 //------------------------------DivModNode---------------------------------------
duke@435 132 // Division with remainder result.
duke@435 133 class DivModNode : public MultiNode {
duke@435 134 protected:
duke@435 135 DivModNode( Node *c, Node *dividend, Node *divisor );
duke@435 136 public:
duke@435 137 enum {
duke@435 138 div_proj_num = 0, // quotient
duke@435 139 mod_proj_num = 1 // remainder
duke@435 140 };
duke@435 141 virtual int Opcode() const;
duke@435 142 virtual Node *Identity( PhaseTransform *phase ) { return this; }
duke@435 143 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; }
duke@435 144 virtual const Type *Value( PhaseTransform *phase ) const { return bottom_type(); }
duke@435 145 virtual uint hash() const { return Node::hash(); }
duke@435 146 virtual bool is_CFG() const { return false; }
duke@435 147 virtual uint ideal_reg() const { return NotAMachineReg; }
duke@435 148
duke@435 149 ProjNode* div_proj() { return proj_out(div_proj_num); }
duke@435 150 ProjNode* mod_proj() { return proj_out(mod_proj_num); }
duke@435 151 };
duke@435 152
duke@435 153 //------------------------------DivModINode---------------------------------------
duke@435 154 // Integer division with remainder result.
duke@435 155 class DivModINode : public DivModNode {
duke@435 156 public:
duke@435 157 DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
duke@435 158 virtual int Opcode() const;
duke@435 159 virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; }
duke@435 160 virtual Node *match( const ProjNode *proj, const Matcher *m );
duke@435 161
duke@435 162 // Make a divmod and associated projections from a div or mod.
duke@435 163 static DivModINode* make(Compile* C, Node* div_or_mod);
duke@435 164 };
duke@435 165
duke@435 166 //------------------------------DivModLNode---------------------------------------
duke@435 167 // Long division with remainder result.
duke@435 168 class DivModLNode : public DivModNode {
duke@435 169 public:
duke@435 170 DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
duke@435 171 virtual int Opcode() const;
duke@435 172 virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; }
duke@435 173 virtual Node *match( const ProjNode *proj, const Matcher *m );
duke@435 174
duke@435 175 // Make a divmod and associated projections from a div or mod.
duke@435 176 static DivModLNode* make(Compile* C, Node* div_or_mod);
duke@435 177 };

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial