Mercurial > hg > truffle
annotate src/share/vm/opto/divnode.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | c18cbe5936b8 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 // Portions of code courtesy of Clifford Click | |
| 26 | |
| 27 // Optimization - Graph Style | |
| 28 | |
| 29 | |
| 30 //------------------------------DivINode--------------------------------------- | |
| 31 // Integer division | |
| 32 // Note: this is division as defined by JVMS, i.e., MinInt/-1 == MinInt. | |
| 33 // On processors which don't naturally support this special case (e.g., x86), | |
| 34 // the matcher or runtime system must take care of this. | |
| 35 class DivINode : public Node { | |
| 36 public: | |
| 37 DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} | |
| 38 virtual int Opcode() const; | |
| 39 virtual Node *Identity( PhaseTransform *phase ); | |
| 40 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 41 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 42 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 43 virtual uint ideal_reg() const { return Op_RegI; } | |
| 44 }; | |
| 45 | |
| 46 //------------------------------DivLNode--------------------------------------- | |
| 47 // Long division | |
| 48 class DivLNode : public Node { | |
| 49 public: | |
| 50 DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} | |
| 51 virtual int Opcode() const; | |
| 52 virtual Node *Identity( PhaseTransform *phase ); | |
| 53 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 54 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 55 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 56 virtual uint ideal_reg() const { return Op_RegL; } | |
| 57 }; | |
| 58 | |
| 59 //------------------------------DivFNode--------------------------------------- | |
| 60 // Float division | |
| 61 class DivFNode : public Node { | |
| 62 public: | |
| 63 DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {} | |
| 64 virtual int Opcode() const; | |
| 65 virtual Node *Identity( PhaseTransform *phase ); | |
| 66 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 67 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 68 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 69 virtual uint ideal_reg() const { return Op_RegF; } | |
| 70 }; | |
| 71 | |
| 72 //------------------------------DivDNode--------------------------------------- | |
| 73 // Double division | |
| 74 class DivDNode : public Node { | |
| 75 public: | |
| 76 DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {} | |
| 77 virtual int Opcode() const; | |
| 78 virtual Node *Identity( PhaseTransform *phase ); | |
| 79 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 80 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 81 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 82 virtual uint ideal_reg() const { return Op_RegD; } | |
| 83 }; | |
| 84 | |
| 85 //------------------------------ModINode--------------------------------------- | |
| 86 // Integer modulus | |
| 87 class ModINode : public Node { | |
| 88 public: | |
| 89 ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} | |
| 90 virtual int Opcode() const; | |
| 91 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 92 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 93 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 94 virtual uint ideal_reg() const { return Op_RegI; } | |
| 95 }; | |
| 96 | |
| 97 //------------------------------ModLNode--------------------------------------- | |
| 98 // Long modulus | |
| 99 class ModLNode : public Node { | |
| 100 public: | |
| 101 ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} | |
| 102 virtual int Opcode() const; | |
| 103 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 104 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 105 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 106 virtual uint ideal_reg() const { return Op_RegL; } | |
| 107 }; | |
| 108 | |
| 109 //------------------------------ModFNode--------------------------------------- | |
| 110 // Float Modulus | |
| 111 class ModFNode : public Node { | |
| 112 public: | |
| 113 ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} | |
| 114 virtual int Opcode() const; | |
| 115 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 116 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 117 virtual uint ideal_reg() const { return Op_RegF; } | |
| 118 }; | |
| 119 | |
| 120 //------------------------------ModDNode--------------------------------------- | |
| 121 // Double Modulus | |
| 122 class ModDNode : public Node { | |
| 123 public: | |
| 124 ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} | |
| 125 virtual int Opcode() const; | |
| 126 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 127 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 128 virtual uint ideal_reg() const { return Op_RegD; } | |
| 129 }; | |
| 130 | |
| 131 //------------------------------DivModNode--------------------------------------- | |
| 132 // Division with remainder result. | |
| 133 class DivModNode : public MultiNode { | |
| 134 protected: | |
| 135 DivModNode( Node *c, Node *dividend, Node *divisor ); | |
| 136 public: | |
| 137 enum { | |
| 138 div_proj_num = 0, // quotient | |
| 139 mod_proj_num = 1 // remainder | |
| 140 }; | |
| 141 virtual int Opcode() const; | |
| 142 virtual Node *Identity( PhaseTransform *phase ) { return this; } | |
| 143 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; } | |
| 144 virtual const Type *Value( PhaseTransform *phase ) const { return bottom_type(); } | |
| 145 virtual uint hash() const { return Node::hash(); } | |
| 146 virtual bool is_CFG() const { return false; } | |
| 147 virtual uint ideal_reg() const { return NotAMachineReg; } | |
| 148 | |
| 149 ProjNode* div_proj() { return proj_out(div_proj_num); } | |
| 150 ProjNode* mod_proj() { return proj_out(mod_proj_num); } | |
| 151 }; | |
| 152 | |
| 153 //------------------------------DivModINode--------------------------------------- | |
| 154 // Integer division with remainder result. | |
| 155 class DivModINode : public DivModNode { | |
| 156 public: | |
| 157 DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} | |
| 158 virtual int Opcode() const; | |
| 159 virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; } | |
| 160 virtual Node *match( const ProjNode *proj, const Matcher *m ); | |
| 161 | |
| 162 // Make a divmod and associated projections from a div or mod. | |
| 163 static DivModINode* make(Compile* C, Node* div_or_mod); | |
| 164 }; | |
| 165 | |
| 166 //------------------------------DivModLNode--------------------------------------- | |
| 167 // Long division with remainder result. | |
| 168 class DivModLNode : public DivModNode { | |
| 169 public: | |
| 170 DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} | |
| 171 virtual int Opcode() const; | |
| 172 virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; } | |
| 173 virtual Node *match( const ProjNode *proj, const Matcher *m ); | |
| 174 | |
| 175 // Make a divmod and associated projections from a div or mod. | |
| 176 static DivModLNode* make(Compile* C, Node* div_or_mod); | |
| 177 }; |