Mercurial > hg > graal-compiler
annotate src/share/vm/opto/divnode.hpp @ 1751:2528b5bd749c
6980262: Memory leak when exception is thrown in static initializer
Summary: Use resource memory instead of c-heap for the exception message
Reviewed-by: phh, jmasa
author | kamg |
---|---|
date | Fri, 27 Aug 2010 15:05:28 -0400 |
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 }; |