Mercurial > hg > truffle

comparison src/share/vm/shark/sharkBlock.hpp @ 1692:d2ede61b7a12

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6976186: integrate Shark HotSpot changes Summary: Shark is a JIT compiler for Zero that uses the LLVM compiler infrastructure. Reviewed-by: kvn, twisti Contributed-by: Gary Benson <gbenson@redhat.com>
author twisti
date Wed, 11 Aug 2010 05:51:21 -0700
parents
children f95d63e2154a
comparison
equal deleted inserted replaced
1691:4a665be40fd3 1692:d2ede61b7a12
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 };