Mercurial > hg > truffle
annotate src/share/vm/opto/addnode.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | f95d63e2154a |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, 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:
1541
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1541
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:
1541
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_ADDNODE_HPP |
| 26 #define SHARE_VM_OPTO_ADDNODE_HPP | |
| 27 | |
| 28 #include "opto/node.hpp" | |
| 29 #include "opto/opcodes.hpp" | |
| 30 #include "opto/type.hpp" | |
| 31 | |
| 0 | 32 // Portions of code courtesy of Clifford Click |
| 33 | |
| 34 class PhaseTransform; | |
| 35 | |
| 36 //------------------------------AddNode---------------------------------------- | |
| 37 // Classic Add functionality. This covers all the usual 'add' behaviors for | |
| 38 // an algebraic ring. Add-integer, add-float, add-double, and binary-or are | |
| 39 // all inherited from this class. The various identity values are supplied | |
| 40 // by virtual functions. | |
| 41 class AddNode : public Node { | |
| 42 virtual uint hash() const; | |
| 43 public: | |
| 44 AddNode( Node *in1, Node *in2 ) : Node(0,in1,in2) { | |
| 45 init_class_id(Class_Add); | |
| 46 } | |
| 47 | |
| 48 // Handle algebraic identities here. If we have an identity, return the Node | |
| 49 // we are equivalent to. We look for "add of zero" as an identity. | |
| 50 virtual Node *Identity( PhaseTransform *phase ); | |
| 51 | |
| 52 // We also canonicalize the Node, moving constants to the right input, | |
| 53 // and flatten expressions (so that 1+x+2 becomes x+3). | |
| 54 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 55 | |
| 56 // Compute a new Type for this node. Basically we just do the pre-check, | |
| 57 // then call the virtual add() to set the type. | |
| 58 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 59 | |
| 60 // Check if this addition involves the additive identity | |
| 61 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const; | |
| 62 | |
| 63 // Supplied function returns the sum of the inputs. | |
| 64 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 65 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check. | |
| 66 virtual const Type *add_ring( const Type *, const Type * ) const = 0; | |
| 67 | |
| 68 // Supplied function to return the additive identity type | |
| 69 virtual const Type *add_id() const = 0; | |
| 70 | |
| 71 }; | |
| 72 | |
| 73 //------------------------------AddINode--------------------------------------- | |
| 74 // Add 2 integers | |
| 75 class AddINode : public AddNode { | |
| 76 public: | |
| 77 AddINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 78 virtual int Opcode() const; | |
| 79 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 80 virtual const Type *add_id() const { return TypeInt::ZERO; } | |
| 81 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 82 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 83 virtual Node *Identity( PhaseTransform *phase ); | |
| 84 virtual uint ideal_reg() const { return Op_RegI; } | |
| 85 }; | |
| 86 | |
| 87 //------------------------------AddLNode--------------------------------------- | |
| 88 // Add 2 longs | |
| 89 class AddLNode : public AddNode { | |
| 90 public: | |
| 91 AddLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 92 virtual int Opcode() const; | |
| 93 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 94 virtual const Type *add_id() const { return TypeLong::ZERO; } | |
| 95 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 96 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 97 virtual Node *Identity( PhaseTransform *phase ); | |
| 98 virtual uint ideal_reg() const { return Op_RegL; } | |
| 99 }; | |
| 100 | |
| 101 //------------------------------AddFNode--------------------------------------- | |
| 102 // Add 2 floats | |
| 103 class AddFNode : public AddNode { | |
| 104 public: | |
| 105 AddFNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 106 virtual int Opcode() const; | |
| 107 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 108 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const; | |
| 109 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 110 virtual const Type *add_id() const { return TypeF::ZERO; } | |
| 111 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 112 virtual Node *Identity( PhaseTransform *phase ) { return this; } | |
| 113 virtual uint ideal_reg() const { return Op_RegF; } | |
| 114 }; | |
| 115 | |
| 116 //------------------------------AddDNode--------------------------------------- | |
| 117 // Add 2 doubles | |
| 118 class AddDNode : public AddNode { | |
| 119 public: | |
| 120 AddDNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 121 virtual int Opcode() const; | |
| 122 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 123 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const; | |
| 124 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 125 virtual const Type *add_id() const { return TypeD::ZERO; } | |
| 126 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 127 virtual Node *Identity( PhaseTransform *phase ) { return this; } | |
| 128 virtual uint ideal_reg() const { return Op_RegD; } | |
| 129 }; | |
| 130 | |
| 131 //------------------------------AddPNode--------------------------------------- | |
| 132 // Add pointer plus integer to get pointer. NOT commutative, really. | |
| 133 // So not really an AddNode. Lives here, because people associate it with | |
| 134 // an add. | |
| 135 class AddPNode : public Node { | |
| 136 public: | |
| 137 enum { Control, // When is it safe to do this add? | |
| 138 Base, // Base oop, for GC purposes | |
| 139 Address, // Actually address, derived from base | |
| 140 Offset } ; // Offset added to address | |
| 141 AddPNode( Node *base, Node *ptr, Node *off ) : Node(0,base,ptr,off) { | |
| 142 init_class_id(Class_AddP); | |
| 143 } | |
| 144 virtual int Opcode() const; | |
| 145 virtual Node *Identity( PhaseTransform *phase ); | |
| 146 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 147 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 148 virtual const Type *bottom_type() const; | |
| 149 virtual uint ideal_reg() const { return Op_RegP; } | |
| 150 Node *base_node() { assert( req() > Base, "Missing base"); return in(Base); } | |
| 151 static Node* Ideal_base_and_offset(Node* ptr, PhaseTransform* phase, | |
| 152 // second return value: | |
| 153 intptr_t& offset); | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
154 |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
155 // Collect the AddP offset values into the elements array, giving up |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
156 // if there are more than length. |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
157 int unpack_offsets(Node* elements[], int length); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
158 |
| 0 | 159 // Do not match base-ptr edge |
| 160 virtual uint match_edge(uint idx) const; | |
| 161 }; | |
| 162 | |
| 163 //------------------------------OrINode---------------------------------------- | |
| 164 // Logically OR 2 integers. Included with the ADD nodes because it inherits | |
| 165 // all the behavior of addition on a ring. | |
| 166 class OrINode : public AddNode { | |
| 167 public: | |
| 168 OrINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 169 virtual int Opcode() const; | |
| 170 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 171 virtual const Type *add_id() const { return TypeInt::ZERO; } | |
| 172 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 173 virtual Node *Identity( PhaseTransform *phase ); | |
| 174 virtual uint ideal_reg() const { return Op_RegI; } | |
| 175 }; | |
| 176 | |
| 177 //------------------------------OrLNode---------------------------------------- | |
| 178 // Logically OR 2 longs. Included with the ADD nodes because it inherits | |
| 179 // all the behavior of addition on a ring. | |
| 180 class OrLNode : public AddNode { | |
| 181 public: | |
| 182 OrLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 183 virtual int Opcode() const; | |
| 184 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 185 virtual const Type *add_id() const { return TypeLong::ZERO; } | |
| 186 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 187 virtual Node *Identity( PhaseTransform *phase ); | |
| 188 virtual uint ideal_reg() const { return Op_RegL; } | |
| 189 }; | |
| 190 | |
| 191 //------------------------------XorINode--------------------------------------- | |
| 192 // XOR'ing 2 integers | |
| 193 class XorINode : public AddNode { | |
| 194 public: | |
| 195 XorINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 196 virtual int Opcode() const; | |
| 197 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 198 virtual const Type *add_id() const { return TypeInt::ZERO; } | |
| 199 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 200 virtual uint ideal_reg() const { return Op_RegI; } | |
| 201 }; | |
| 202 | |
| 203 //------------------------------XorINode--------------------------------------- | |
| 204 // XOR'ing 2 longs | |
| 205 class XorLNode : public AddNode { | |
| 206 public: | |
| 207 XorLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 208 virtual int Opcode() const; | |
| 209 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 210 virtual const Type *add_id() const { return TypeLong::ZERO; } | |
| 211 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 212 virtual uint ideal_reg() const { return Op_RegL; } | |
| 213 }; | |
| 214 | |
| 215 //------------------------------MaxNode---------------------------------------- | |
| 216 // Max (or min) of 2 values. Included with the ADD nodes because it inherits | |
| 217 // all the behavior of addition on a ring. Only new thing is that we allow | |
| 218 // 2 equal inputs to be equal. | |
| 219 class MaxNode : public AddNode { | |
| 220 public: | |
| 221 MaxNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} | |
| 222 virtual int Opcode() const = 0; | |
| 223 }; | |
| 224 | |
| 225 //------------------------------MaxINode--------------------------------------- | |
| 226 // Maximum of 2 integers. Included with the ADD nodes because it inherits | |
| 227 // all the behavior of addition on a ring. | |
| 228 class MaxINode : public MaxNode { | |
| 229 public: | |
| 230 MaxINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {} | |
| 231 virtual int Opcode() const; | |
| 232 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 233 virtual const Type *add_id() const { return TypeInt::make(min_jint); } | |
| 234 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 235 virtual uint ideal_reg() const { return Op_RegI; } | |
| 236 }; | |
| 237 | |
| 238 //------------------------------MinINode--------------------------------------- | |
| 239 // MINimum of 2 integers. Included with the ADD nodes because it inherits | |
| 240 // all the behavior of addition on a ring. | |
| 241 class MinINode : public MaxNode { | |
| 242 public: | |
| 243 MinINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {} | |
| 244 virtual int Opcode() const; | |
| 245 virtual const Type *add_ring( const Type *, const Type * ) const; | |
| 246 virtual const Type *add_id() const { return TypeInt::make(max_jint); } | |
| 247 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 248 virtual uint ideal_reg() const { return Op_RegI; } | |
| 249 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 250 }; | |
| 1972 | 251 |
| 252 #endif // SHARE_VM_OPTO_ADDNODE_HPP |