|
1692
|
1 /*
|
|
|
2 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
|
|
|
3 * Copyright 2008, 2009 Red Hat, Inc.
|
|
|
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
5 *
|
|
|
6 * This code is free software; you can redistribute it and/or modify it
|
|
|
7 * under the terms of the GNU General Public License version 2 only, as
|
|
|
8 * published by the Free Software Foundation.
|
|
|
9 *
|
|
|
10 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
13 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
14 * accompanied this code).
|
|
|
15 *
|
|
|
16 * You should have received a copy of the GNU General Public License version
|
|
|
17 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
19 *
|
|
|
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
|
21 * or visit www.oracle.com if you need additional information or have any
|
|
|
22 * questions.
|
|
|
23 *
|
|
|
24 */
|
|
|
25
|
|
|
26 class SharkState;
|
|
|
27
|
|
|
28 class SharkBlock : public SharkTargetInvariants {
|
|
|
29 protected:
|
|
|
30 SharkBlock(const SharkTargetInvariants* parent)
|
|
|
31 : SharkTargetInvariants(parent),
|
|
|
32 _iter(target()),
|
|
|
33 _current_state(NULL) {}
|
|
|
34
|
|
|
35 SharkBlock(const SharkCompileInvariants* parent, ciMethod* target)
|
|
|
36 : SharkTargetInvariants(parent, target),
|
|
|
37 _iter(target),
|
|
|
38 _current_state(NULL) {}
|
|
|
39
|
|
|
40 private:
|
|
|
41 ciBytecodeStream _iter;
|
|
|
42 SharkState* _current_state;
|
|
|
43
|
|
|
44 public:
|
|
|
45 ciBytecodeStream* iter() {
|
|
|
46 return &_iter;
|
|
|
47 }
|
|
|
48 Bytecodes::Code bc() {
|
|
|
49 return iter()->cur_bc();
|
|
|
50 }
|
|
|
51 int bci() {
|
|
|
52 return iter()->cur_bci();
|
|
|
53 }
|
|
|
54
|
|
|
55 // Entry state
|
|
|
56 protected:
|
|
|
57 virtual SharkState* entry_state();
|
|
|
58
|
|
|
59 // Current state
|
|
|
60 private:
|
|
|
61 SharkState* initial_current_state();
|
|
|
62
|
|
|
63 public:
|
|
|
64 SharkState* current_state() {
|
|
|
65 if (_current_state == NULL)
|
|
|
66 set_current_state(initial_current_state());
|
|
|
67 return _current_state;
|
|
|
68 }
|
|
|
69
|
|
|
70 protected:
|
|
|
71 void set_current_state(SharkState* current_state) {
|
|
|
72 _current_state = current_state;
|
|
|
73 }
|
|
|
74
|
|
|
75 // Local variables
|
|
|
76 protected:
|
|
|
77 SharkValue* local(int index) {
|
|
|
78 SharkValue *value = current_state()->local(index);
|
|
|
79 assert(value != NULL, "shouldn't be");
|
|
|
80 assert(value->is_one_word() ||
|
|
|
81 (index + 1 < max_locals() &&
|
|
|
82 current_state()->local(index + 1) == NULL), "should be");
|
|
|
83 return value;
|
|
|
84 }
|
|
|
85 void set_local(int index, SharkValue* value) {
|
|
|
86 assert(value != NULL, "shouldn't be");
|
|
|
87 current_state()->set_local(index, value);
|
|
|
88 if (value->is_two_word())
|
|
|
89 current_state()->set_local(index + 1, NULL);
|
|
|
90 }
|
|
|
91
|
|
|
92 // Expression stack (raw)
|
|
|
93 protected:
|
|
|
94 void xpush(SharkValue* value) {
|
|
|
95 current_state()->push(value);
|
|
|
96 }
|
|
|
97 SharkValue* xpop() {
|
|
|
98 return current_state()->pop();
|
|
|
99 }
|
|
|
100 SharkValue* xstack(int slot) {
|
|
|
101 SharkValue *value = current_state()->stack(slot);
|
|
|
102 assert(value != NULL, "shouldn't be");
|
|
|
103 assert(value->is_one_word() ||
|
|
|
104 (slot > 0 &&
|
|
|
105 current_state()->stack(slot - 1) == NULL), "should be");
|
|
|
106 return value;
|
|
|
107 }
|
|
|
108 int xstack_depth() {
|
|
|
109 return current_state()->stack_depth();
|
|
|
110 }
|
|
|
111
|
|
|
112 // Expression stack (cooked)
|
|
|
113 protected:
|
|
|
114 void push(SharkValue* value) {
|
|
|
115 assert(value != NULL, "shouldn't be");
|
|
|
116 xpush(value);
|
|
|
117 if (value->is_two_word())
|
|
|
118 xpush(NULL);
|
|
|
119 }
|
|
|
120 SharkValue* pop() {
|
|
|
121 int size = current_state()->stack(0) == NULL ? 2 : 1;
|
|
|
122 if (size == 2)
|
|
|
123 xpop();
|
|
|
124 SharkValue *value = xpop();
|
|
|
125 assert(value && value->size() == size, "should be");
|
|
|
126 return value;
|
|
|
127 }
|
|
|
128 SharkValue* pop_result(BasicType type) {
|
|
|
129 SharkValue *result = pop();
|
|
|
130
|
|
|
131 #ifdef ASSERT
|
|
|
132 switch (result->basic_type()) {
|
|
|
133 case T_BOOLEAN:
|
|
|
134 case T_BYTE:
|
|
|
135 case T_CHAR:
|
|
|
136 case T_SHORT:
|
|
|
137 assert(type == T_INT, "type mismatch");
|
|
|
138 break;
|
|
|
139
|
|
|
140 case T_ARRAY:
|
|
|
141 assert(type == T_OBJECT, "type mismatch");
|
|
|
142 break;
|
|
|
143
|
|
|
144 default:
|
|
|
145 assert(result->basic_type() == type, "type mismatch");
|
|
|
146 }
|
|
|
147 #endif // ASSERT
|
|
|
148
|
|
|
149 return result;
|
|
|
150 }
|
|
|
151
|
|
|
152 // Code generation
|
|
|
153 public:
|
|
|
154 virtual void emit_IR();
|
|
|
155
|
|
|
156 protected:
|
|
|
157 void parse_bytecode(int start, int limit);
|
|
|
158
|
|
|
159 // Helpers
|
|
|
160 protected:
|
|
|
161 virtual void do_zero_check(SharkValue* value);
|
|
|
162
|
|
|
163 // Zero checking
|
|
|
164 protected:
|
|
|
165 void check_null(SharkValue* object) {
|
|
|
166 zero_check(object);
|
|
|
167 }
|
|
|
168 void check_divide_by_zero(SharkValue* value) {
|
|
|
169 zero_check(value);
|
|
|
170 }
|
|
|
171 private:
|
|
|
172 void zero_check(SharkValue* value) {
|
|
|
173 if (!value->zero_checked())
|
|
|
174 do_zero_check(value);
|
|
|
175 }
|
|
|
176
|
|
|
177 // Safepoints
|
|
|
178 protected:
|
|
|
179 virtual void maybe_add_backedge_safepoint();
|
|
|
180
|
|
|
181 // Traps
|
|
|
182 protected:
|
|
|
183 virtual bool has_trap();
|
|
|
184 virtual int trap_request();
|
|
|
185 virtual int trap_bci();
|
|
|
186 virtual void do_trap(int trap_request);
|
|
|
187
|
|
|
188 // arraylength
|
|
|
189 protected:
|
|
|
190 virtual void do_arraylength();
|
|
|
191
|
|
|
192 // *aload and *astore
|
|
|
193 protected:
|
|
|
194 virtual void do_aload(BasicType basic_type);
|
|
|
195 virtual void do_astore(BasicType basic_type);
|
|
|
196
|
|
|
197 // *div and *rem
|
|
|
198 private:
|
|
|
199 void do_idiv() {
|
|
|
200 do_div_or_rem(false, false);
|
|
|
201 }
|
|
|
202 void do_irem() {
|
|
|
203 do_div_or_rem(false, true);
|
|
|
204 }
|
|
|
205 void do_ldiv() {
|
|
|
206 do_div_or_rem(true, false);
|
|
|
207 }
|
|
|
208 void do_lrem() {
|
|
|
209 do_div_or_rem(true, true);
|
|
|
210 }
|
|
|
211 void do_div_or_rem(bool is_long, bool is_rem);
|
|
|
212
|
|
|
213 // get* and put*
|
|
|
214 private:
|
|
|
215 void do_getstatic() {
|
|
|
216 do_field_access(true, false);
|
|
|
217 }
|
|
|
218 void do_getfield() {
|
|
|
219 do_field_access(true, true);
|
|
|
220 }
|
|
|
221 void do_putstatic() {
|
|
|
222 do_field_access(false, false);
|
|
|
223 }
|
|
|
224 void do_putfield() {
|
|
|
225 do_field_access(false, true);
|
|
|
226 }
|
|
|
227 void do_field_access(bool is_get, bool is_field);
|
|
|
228
|
|
|
229 // lcmp and [fd]cmp[lg]
|
|
|
230 private:
|
|
|
231 void do_lcmp();
|
|
|
232 void do_fcmp(bool is_double, bool unordered_is_greater);
|
|
|
233
|
|
|
234 // *return and athrow
|
|
|
235 protected:
|
|
|
236 virtual void do_return(BasicType type);
|
|
|
237 virtual void do_athrow();
|
|
|
238
|
|
|
239 // goto*
|
|
|
240 protected:
|
|
|
241 virtual void do_goto();
|
|
|
242
|
|
|
243 // jsr* and ret
|
|
|
244 protected:
|
|
|
245 virtual void do_jsr();
|
|
|
246 virtual void do_ret();
|
|
|
247
|
|
|
248 // if*
|
|
|
249 protected:
|
|
|
250 virtual void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);
|
|
|
251
|
|
|
252 // *switch
|
|
|
253 protected:
|
|
|
254 int switch_default_dest();
|
|
|
255 int switch_table_length();
|
|
|
256 int switch_key(int i);
|
|
|
257 int switch_dest(int i);
|
|
|
258
|
|
|
259 virtual void do_switch();
|
|
|
260
|
|
|
261 // invoke*
|
|
|
262 protected:
|
|
|
263 virtual void do_call();
|
|
|
264
|
|
|
265 // checkcast and instanceof
|
|
|
266 protected:
|
|
|
267 virtual void do_instance_check();
|
|
|
268 virtual bool maybe_do_instanceof_if();
|
|
|
269
|
|
|
270 // new and *newarray
|
|
|
271 protected:
|
|
|
272 virtual void do_new();
|
|
|
273 virtual void do_newarray();
|
|
|
274 virtual void do_anewarray();
|
|
|
275 virtual void do_multianewarray();
|
|
|
276
|
|
|
277 // monitorenter and monitorexit
|
|
|
278 protected:
|
|
|
279 virtual void do_monitorenter();
|
|
|
280 virtual void do_monitorexit();
|
|
|
281 };
|
