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 hierarchy:
27 // - SharkStateScanner
28 // - SharkCacherDecacher
29 // - SharkDecacher
30 // - SharkJavaCallDecacher
31 // - SharkVMCallDecacher
32 // - SharkTrapDecacher
33 // - SharkCacher
34 // - SharkJavaCallCacher
35 // - SharkVMCallCacher
36 // - SharkFunctionEntryCacher
37 // - SharkNormalEntryCacher
38 // - SharkOSREntryCacher
39
40 class SharkCacherDecacher : public SharkStateScanner {
41 protected:
42 SharkCacherDecacher(SharkFunction* function)
43 : SharkStateScanner(function) {}
44
45 // Helper
46 protected:
47 static int adjusted_offset(SharkValue* value, int offset) {
48 if (value->is_two_word())
49 offset--;
50 return offset;
51 }
52 };
53
54 class SharkDecacher : public SharkCacherDecacher {
55 protected:
56 SharkDecacher(SharkFunction* function, int bci)
57 : SharkCacherDecacher(function), _bci(bci) {}
58
59 private:
60 int _bci;
61
62 protected:
63 int bci() const {
64 return _bci;
65 }
66
67 private:
68 int _pc_offset;
69 OopMap* _oopmap;
70 GrowableArray<ScopeValue*>* _exparray;
71 GrowableArray<MonitorValue*>* _monarray;
72 GrowableArray<ScopeValue*>* _locarray;
73
74 private:
75 int pc_offset() const {
76 return _pc_offset;
77 }
78 OopMap* oopmap() const {
79 return _oopmap;
80 }
81 GrowableArray<ScopeValue*>* exparray() const {
82 return _exparray;
83 }
84 GrowableArray<MonitorValue*>* monarray() const {
85 return _monarray;
86 }
87 GrowableArray<ScopeValue*>* locarray() const {
88 return _locarray;
89 }
90
91 // Callbacks
92 protected:
93 void start_frame();
94
95 void start_stack(int stack_depth);
96 void process_stack_slot(int index, SharkValue** value, int offset);
97
98 void start_monitors(int num_monitors);
99 void process_monitor(int index, int box_offset, int obj_offset);
100
101 void process_oop_tmp_slot(llvm::Value** value, int offset);
102 void process_method_slot(llvm::Value** value, int offset);
103 void process_pc_slot(int offset);
104
105 void start_locals();
106 void process_local_slot(int index, SharkValue** value, int offset);
107
108 void end_frame();
109
110 // oopmap and debuginfo helpers
111 private:
112 static int oopmap_slot_munge(int offset) {
113 return SharkStack::oopmap_slot_munge(offset);
114 }
115 static VMReg slot2reg(int offset) {
116 return SharkStack::slot2reg(offset);
117 }
118 static Location slot2loc(int offset, Location::Type type) {
119 return Location::new_stk_loc(type, offset * wordSize);
120 }
121 static LocationValue* slot2lv(int offset, Location::Type type) {
122 return new LocationValue(slot2loc(offset, type));
123 }
124 static Location::Type location_type(SharkValue** addr, bool maybe_two_word) {
125 // low addresses this end
126 // Type 32-bit 64-bit
127 // ----------------------------------------------------
128 // stack[0] local[3] jobject oop oop
129 // stack[1] local[2] NULL normal lng
130 // stack[2] local[1] jlong normal invalid
131 // stack[3] local[0] jint normal normal
132 //
133 // high addresses this end
134
135 SharkValue *value = *addr;
136 if (value) {
137 if (value->is_jobject())
138 return Location::oop;
139 #ifdef _LP64
140 if (value->is_two_word())
141 return Location::invalid;
142 #endif // _LP64
143 return Location::normal;
144 }
145 else {
146 if (maybe_two_word) {
147 value = *(addr - 1);
148 if (value && value->is_two_word()) {
149 #ifdef _LP64
150 if (value->is_jlong())
151 return Location::lng;
152 if (value->is_jdouble())
153 return Location::dbl;
154 ShouldNotReachHere();
155 #else
156 return Location::normal;
157 #endif // _LP64
158 }
159 }
160 return Location::invalid;
161 }
162 }
163
164 // Stack slot helpers
165 protected:
166 virtual bool stack_slot_needs_write(int index, SharkValue* value) = 0;
167 virtual bool stack_slot_needs_oopmap(int index, SharkValue* value) = 0;
168 virtual bool stack_slot_needs_debuginfo(int index, SharkValue* value) = 0;
169
170 static Location::Type stack_location_type(int index, SharkValue** addr) {
171 return location_type(addr, *addr == NULL);
172 }
173
174 // Local slot helpers
175 protected:
176 virtual bool local_slot_needs_write(int index, SharkValue* value) = 0;
177 virtual bool local_slot_needs_oopmap(int index, SharkValue* value) = 0;
178 virtual bool local_slot_needs_debuginfo(int index, SharkValue* value) = 0;
179
180 static Location::Type local_location_type(int index, SharkValue** addr) {
181 return location_type(addr, index > 0);
182 }
183
184 // Writer helper
185 protected:
186 void write_value_to_frame(const llvm::Type* type,
187 llvm::Value* value,
188 int offset);
189 };
190
191 class SharkJavaCallDecacher : public SharkDecacher {
192 public:
193 SharkJavaCallDecacher(SharkFunction* function, int bci, ciMethod* callee)
194 : SharkDecacher(function, bci), _callee(callee) {}
195
196 private:
197 ciMethod* _callee;
198
199 protected:
200 ciMethod* callee() const {
201 return _callee;
202 }
203
204 // Stack slot helpers
205 protected:
206 bool stack_slot_needs_write(int index, SharkValue* value) {
207 return value && (index < callee()->arg_size() || value->is_jobject());
208 }
209 bool stack_slot_needs_oopmap(int index, SharkValue* value) {
210 return value && value->is_jobject() && index >= callee()->arg_size();
211 }
212 bool stack_slot_needs_debuginfo(int index, SharkValue* value) {
213 return index >= callee()->arg_size();
214 }
215
216 // Local slot helpers
217 protected:
218 bool local_slot_needs_write(int index, SharkValue* value) {
219 return value && value->is_jobject();
220 }
221 bool local_slot_needs_oopmap(int index, SharkValue* value) {
222 return value && value->is_jobject();
223 }
224 bool local_slot_needs_debuginfo(int index, SharkValue* value) {
225 return true;
226 }
227 };
228
229 class SharkVMCallDecacher : public SharkDecacher {
230 public:
231 SharkVMCallDecacher(SharkFunction* function, int bci)
232 : SharkDecacher(function, bci) {}
233
234 // Stack slot helpers
235 protected:
236 bool stack_slot_needs_write(int index, SharkValue* value) {
237 return value && value->is_jobject();
238 }
239 bool stack_slot_needs_oopmap(int index, SharkValue* value) {
240 return value && value->is_jobject();
241 }
242 bool stack_slot_needs_debuginfo(int index, SharkValue* value) {
243 return true;
244 }
245
246 // Local slot helpers
247 protected:
248 bool local_slot_needs_write(int index, SharkValue* value) {
249 return value && value->is_jobject();
250 }
251 bool local_slot_needs_oopmap(int index, SharkValue* value) {
252 return value && value->is_jobject();
253 }
254 bool local_slot_needs_debuginfo(int index, SharkValue* value) {
255 return true;
256 }
257 };
258
259 class SharkTrapDecacher : public SharkDecacher {
260 public:
261 SharkTrapDecacher(SharkFunction* function, int bci)
262 : SharkDecacher(function, bci) {}
263
264 // Stack slot helpers
265 protected:
266 bool stack_slot_needs_write(int index, SharkValue* value) {
267 return value != NULL;
268 }
269 bool stack_slot_needs_oopmap(int index, SharkValue* value) {
270 return value && value->is_jobject();
271 }
272 bool stack_slot_needs_debuginfo(int index, SharkValue* value) {
273 return true;
274 }
275
276 // Local slot helpers
277 protected:
278 bool local_slot_needs_write(int index, SharkValue* value) {
279 return value != NULL;
280 }
281 bool local_slot_needs_oopmap(int index, SharkValue* value) {
282 return value && value->is_jobject();
283 }
284 bool local_slot_needs_debuginfo(int index, SharkValue* value) {
285 return true;
286 }
287 };
288
289 class SharkCacher : public SharkCacherDecacher {
290 protected:
291 SharkCacher(SharkFunction* function)
292 : SharkCacherDecacher(function) {}
293
294 // Callbacks
295 protected:
296 void process_stack_slot(int index, SharkValue** value, int offset);
297
298 void process_oop_tmp_slot(llvm::Value** value, int offset);
299 virtual void process_method_slot(llvm::Value** value, int offset);
300
301 virtual void process_local_slot(int index, SharkValue** value, int offset);
302
303 // Stack slot helper
304 protected:
305 virtual bool stack_slot_needs_read(int index, SharkValue* value) = 0;
306
307 // Local slot helper
308 protected:
309 virtual bool local_slot_needs_read(int index, SharkValue* value) {
310 return value && value->is_jobject();
311 }
312
313 // Writer helper
314 protected:
315 llvm::Value* read_value_from_frame(const llvm::Type* type, int offset);
316 };
317
318 class SharkJavaCallCacher : public SharkCacher {
319 public:
320 SharkJavaCallCacher(SharkFunction* function, ciMethod* callee)
321 : SharkCacher(function), _callee(callee) {}
322
323 private:
324 ciMethod* _callee;
325
326 protected:
327 ciMethod* callee() const {
328 return _callee;
329 }
330
331 // Stack slot helper
332 protected:
333 bool stack_slot_needs_read(int index, SharkValue* value) {
334 return value && (index < callee()->return_type()->size() ||
335 value->is_jobject());
336 }
337 };
338
339 class SharkVMCallCacher : public SharkCacher {
340 public:
341 SharkVMCallCacher(SharkFunction* function)
342 : SharkCacher(function) {}
343
344 // Stack slot helper
345 protected:
346 bool stack_slot_needs_read(int index, SharkValue* value) {
347 return value && value->is_jobject();
348 }
349 };
350
351 class SharkFunctionEntryCacher : public SharkCacher {
352 public:
353 SharkFunctionEntryCacher(SharkFunction* function, llvm::Value* method)
354 : SharkCacher(function), _method(method) {}
355
356 private:
357 llvm::Value* _method;
358
359 private:
360 llvm::Value* method() const {
361 return _method;
362 }
363
364 // Method slot callback
365 protected:
366 void process_method_slot(llvm::Value** value, int offset);
367
368 // Stack slot helper
369 protected:
370 bool stack_slot_needs_read(int index, SharkValue* value) {
371 ShouldNotReachHere(); // entry block shouldn't have stack
372 }
373
374 // Local slot helper
375 protected:
376 bool local_slot_needs_read(int index, SharkValue* value) {
377 return value != NULL;
378 }
379 };
380
381 class SharkNormalEntryCacher : public SharkFunctionEntryCacher {
382 public:
383 SharkNormalEntryCacher(SharkFunction* function, llvm::Value* method)
384 : SharkFunctionEntryCacher(function, method) {}
385 };
386
387 class SharkOSREntryCacher : public SharkFunctionEntryCacher {
388 public:
389 SharkOSREntryCacher(SharkFunction* function,
390 llvm::Value* method,
391 llvm::Value* osr_buf)
392 : SharkFunctionEntryCacher(function, method),
393 _osr_buf(
394 builder()->CreateBitCast(
395 osr_buf,
396 llvm::PointerType::getUnqual(
397 llvm::ArrayType::get(
398 SharkType::intptr_type(),
399 max_locals() + max_monitors() * 2)))) {}
400
401 private:
402 llvm::Value* _osr_buf;
403
404 private:
405 llvm::Value* osr_buf() const {
406 return _osr_buf;
407 }
408
409 // Callbacks
410 protected:
411 void process_monitor(int index, int box_offset, int obj_offset);
412 void process_local_slot(int index, SharkValue** value, int offset);
413
414 // Helper
415 private:
416 llvm::Value* CreateAddressOfOSRBufEntry(int offset, const llvm::Type* type);
417 };