1 /*
2 * Copyright (c) 1999, 2010, 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 #ifndef SHARE_VM_SHARK_SHARKBLOCK_HPP
27 #define SHARE_VM_SHARK_SHARKBLOCK_HPP
28
29 #include "ci/ciMethod.hpp"
30 #include "ci/ciStreams.hpp"
31 #include "memory/allocation.hpp"
32 #include "shark/llvmHeaders.hpp"
33 #include "shark/sharkBuilder.hpp"
34 #include "shark/sharkConstant.hpp"
35 #include "shark/sharkInvariants.hpp"
36 #include "shark/sharkState.hpp"
37 #include "shark/sharkValue.hpp"
38 #include "utilities/debug.hpp"
39
40 class SharkState;
41
42 class SharkBlock : public SharkTargetInvariants {
43 protected:
44 SharkBlock(const SharkTargetInvariants* parent)
45 : SharkTargetInvariants(parent),
46 _iter(target()),
47 _current_state(NULL) {}
48
49 SharkBlock(const SharkCompileInvariants* parent, ciMethod* target)
50 : SharkTargetInvariants(parent, target),
51 _iter(target),
52 _current_state(NULL) {}
53
54 private:
55 ciBytecodeStream _iter;
56 SharkState* _current_state;
57
58 public:
59 ciBytecodeStream* iter() {
60 return &_iter;
61 }
62 Bytecodes::Code bc() {
63 return iter()->cur_bc();
64 }
65 int bci() {
66 return iter()->cur_bci();
67 }
68
69 // Entry state
70 protected:
71 virtual SharkState* entry_state();
72
73 // Current state
74 private:
75 SharkState* initial_current_state();
76
77 public:
78 SharkState* current_state() {
79 if (_current_state == NULL)
80 set_current_state(initial_current_state());
81 return _current_state;
82 }
83
84 protected:
85 void set_current_state(SharkState* current_state) {
86 _current_state = current_state;
87 }
88
89 // Local variables
90 protected:
91 SharkValue* local(int index) {
92 SharkValue *value = current_state()->local(index);
93 assert(value != NULL, "shouldn't be");
94 assert(value->is_one_word() ||
95 (index + 1 < max_locals() &&
96 current_state()->local(index + 1) == NULL), "should be");
97 return value;
98 }
99 void set_local(int index, SharkValue* value) {
100 assert(value != NULL, "shouldn't be");
101 current_state()->set_local(index, value);
102 if (value->is_two_word())
103 current_state()->set_local(index + 1, NULL);
104 }
105
106 // Expression stack (raw)
107 protected:
108 void xpush(SharkValue* value) {
109 current_state()->push(value);
110 }
111 SharkValue* xpop() {
112 return current_state()->pop();
113 }
114 SharkValue* xstack(int slot) {
115 SharkValue *value = current_state()->stack(slot);
116 assert(value != NULL, "shouldn't be");
117 assert(value->is_one_word() ||
118 (slot > 0 &&
119 current_state()->stack(slot - 1) == NULL), "should be");
120 return value;
121 }
122 int xstack_depth() {
123 return current_state()->stack_depth();
124 }
125
126 // Expression stack (cooked)
127 protected:
128 void push(SharkValue* value) {
129 assert(value != NULL, "shouldn't be");
130 xpush(value);
131 if (value->is_two_word())
132 xpush(NULL);
133 }
134 SharkValue* pop() {
135 int size = current_state()->stack(0) == NULL ? 2 : 1;
136 if (size == 2)
137 xpop();
138 SharkValue *value = xpop();
139 assert(value && value->size() == size, "should be");
140 return value;
141 }
142 SharkValue* pop_result(BasicType type) {
143 SharkValue *result = pop();
144
145 #ifdef ASSERT
146 switch (result->basic_type()) {
147 case T_BOOLEAN:
148 case T_BYTE:
149 case T_CHAR:
150 case T_SHORT:
151 assert(type == T_INT, "type mismatch");
152 break;
153
154 case T_ARRAY:
155 assert(type == T_OBJECT, "type mismatch");
156 break;
157
158 default:
159 assert(result->basic_type() == type, "type mismatch");
160 }
161 #endif // ASSERT
162
163 return result;
164 }
165
166 // Code generation
167 public:
168 virtual void emit_IR();
169
170 protected:
171 void parse_bytecode(int start, int limit);
172
173 // Helpers
174 protected:
175 virtual void do_zero_check(SharkValue* value);
176
177 // Zero checking
178 protected:
179 void check_null(SharkValue* object) {
180 zero_check(object);
181 }
182 void check_divide_by_zero(SharkValue* value) {
183 zero_check(value);
184 }
185 private:
186 void zero_check(SharkValue* value) {
187 if (!value->zero_checked())
188 do_zero_check(value);
189 }
190
191 // Safepoints
192 protected:
193 virtual void maybe_add_backedge_safepoint();
194
195 // Traps
196 protected:
197 virtual bool has_trap();
198 virtual int trap_request();
199 virtual int trap_bci();
200 virtual void do_trap(int trap_request);
201
202 // arraylength
203 protected:
204 virtual void do_arraylength();
205
206 // *aload and *astore
207 protected:
208 virtual void do_aload(BasicType basic_type);
209 virtual void do_astore(BasicType basic_type);
210
211 // *div and *rem
212 private:
213 void do_idiv() {
214 do_div_or_rem(false, false);
215 }
216 void do_irem() {
217 do_div_or_rem(false, true);
218 }
219 void do_ldiv() {
220 do_div_or_rem(true, false);
221 }
222 void do_lrem() {
223 do_div_or_rem(true, true);
224 }
225 void do_div_or_rem(bool is_long, bool is_rem);
226
227 // get* and put*
228 private:
229 void do_getstatic() {
230 do_field_access(true, false);
231 }
232 void do_getfield() {
233 do_field_access(true, true);
234 }
235 void do_putstatic() {
236 do_field_access(false, false);
237 }
238 void do_putfield() {
239 do_field_access(false, true);
240 }
241 void do_field_access(bool is_get, bool is_field);
242
243 // lcmp and [fd]cmp[lg]
244 private:
245 void do_lcmp();
246 void do_fcmp(bool is_double, bool unordered_is_greater);
247
248 // *return and athrow
249 protected:
250 virtual void do_return(BasicType type);
251 virtual void do_athrow();
252
253 // goto*
254 protected:
255 virtual void do_goto();
256
257 // jsr* and ret
258 protected:
259 virtual void do_jsr();
260 virtual void do_ret();
261
262 // if*
263 protected:
264 virtual void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);
265
266 // *switch
267 protected:
268 int switch_default_dest();
269 int switch_table_length();
270 int switch_key(int i);
271 int switch_dest(int i);
272
273 virtual void do_switch();
274
275 // invoke*
276 protected:
277 virtual void do_call();
278
279 // checkcast and instanceof
280 protected:
281 virtual void do_instance_check();
282 virtual bool maybe_do_instanceof_if();
283
284 // new and *newarray
285 protected:
286 virtual void do_new();
287 virtual void do_newarray();
288 virtual void do_anewarray();
289 virtual void do_multianewarray();
290
291 // monitorenter and monitorexit
292 protected:
293 virtual void do_monitorenter();
294 virtual void do_monitorexit();
295 };
296
297 #endif // SHARE_VM_SHARK_SHARKBLOCK_HPP