annotate src/share/vm/c1/c1_IR.hpp @ 1295:3cf667df43ef

6919934: JSR 292 needs to support x86 C1 Summary: This implements JSR 292 support for C1 x86. Reviewed-by: never, jrose, kvn
author twisti
date Tue, 09 Mar 2010 20:16:19 +0100
parents f70b0d9ab095
children c18cbe5936b8 61b2245abf36
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1253
diff changeset
2 * Copyright 1999-2010 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // An XHandler is a C1 internal description for an exception handler
a61af66fc99e Initial load
duke
parents:
diff changeset
26
a61af66fc99e Initial load
duke
parents:
diff changeset
27 class XHandler: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
28 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
29 ciExceptionHandler* _desc;
a61af66fc99e Initial load
duke
parents:
diff changeset
30
a61af66fc99e Initial load
duke
parents:
diff changeset
31 BlockBegin* _entry_block; // Entry block of xhandler
a61af66fc99e Initial load
duke
parents:
diff changeset
32 LIR_List* _entry_code; // LIR-operations that must be executed before jumping to entry_block
a61af66fc99e Initial load
duke
parents:
diff changeset
33 int _entry_pco; // pco where entry_code (or entry_block if no entry_code) starts
a61af66fc99e Initial load
duke
parents:
diff changeset
34 int _phi_operand; // For resolving of phi functions at begin of entry_block
a61af66fc99e Initial load
duke
parents:
diff changeset
35 int _scope_count; // for filling ExceptionRangeEntry::scope_count
a61af66fc99e Initial load
duke
parents:
diff changeset
36
a61af66fc99e Initial load
duke
parents:
diff changeset
37 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
38 int _lir_op_id; // op_id of the LIR-operation throwing to this handler
a61af66fc99e Initial load
duke
parents:
diff changeset
39 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
40
a61af66fc99e Initial load
duke
parents:
diff changeset
41 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // creation
a61af66fc99e Initial load
duke
parents:
diff changeset
43 XHandler(ciExceptionHandler* desc)
a61af66fc99e Initial load
duke
parents:
diff changeset
44 : _desc(desc)
a61af66fc99e Initial load
duke
parents:
diff changeset
45 , _entry_block(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
46 , _entry_code(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
47 , _entry_pco(-1)
a61af66fc99e Initial load
duke
parents:
diff changeset
48 , _phi_operand(-1)
a61af66fc99e Initial load
duke
parents:
diff changeset
49 , _scope_count(-1)
a61af66fc99e Initial load
duke
parents:
diff changeset
50 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
51 , _lir_op_id(-1)
a61af66fc99e Initial load
duke
parents:
diff changeset
52 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
53 { }
a61af66fc99e Initial load
duke
parents:
diff changeset
54
a61af66fc99e Initial load
duke
parents:
diff changeset
55 XHandler(XHandler* other)
a61af66fc99e Initial load
duke
parents:
diff changeset
56 : _desc(other->_desc)
a61af66fc99e Initial load
duke
parents:
diff changeset
57 , _entry_block(other->_entry_block)
a61af66fc99e Initial load
duke
parents:
diff changeset
58 , _entry_code(other->_entry_code)
a61af66fc99e Initial load
duke
parents:
diff changeset
59 , _entry_pco(other->_entry_pco)
a61af66fc99e Initial load
duke
parents:
diff changeset
60 , _phi_operand(other->_phi_operand)
a61af66fc99e Initial load
duke
parents:
diff changeset
61 , _scope_count(other->_scope_count)
a61af66fc99e Initial load
duke
parents:
diff changeset
62 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
63 , _lir_op_id(other->_lir_op_id)
a61af66fc99e Initial load
duke
parents:
diff changeset
64 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
65 { }
a61af66fc99e Initial load
duke
parents:
diff changeset
66
a61af66fc99e Initial load
duke
parents:
diff changeset
67 // accessors for data of ciExceptionHandler
a61af66fc99e Initial load
duke
parents:
diff changeset
68 int beg_bci() const { return _desc->start(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
69 int end_bci() const { return _desc->limit(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
70 int handler_bci() const { return _desc->handler_bci(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
71 bool is_catch_all() const { return _desc->is_catch_all(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
72 int catch_type() const { return _desc->catch_klass_index(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
73 ciInstanceKlass* catch_klass() const { return _desc->catch_klass(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
74 bool covers(int bci) const { return beg_bci() <= bci && bci < end_bci(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
75
a61af66fc99e Initial load
duke
parents:
diff changeset
76 // accessors for additional fields
a61af66fc99e Initial load
duke
parents:
diff changeset
77 BlockBegin* entry_block() const { return _entry_block; }
a61af66fc99e Initial load
duke
parents:
diff changeset
78 LIR_List* entry_code() const { return _entry_code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
79 int entry_pco() const { return _entry_pco; }
a61af66fc99e Initial load
duke
parents:
diff changeset
80 int phi_operand() const { assert(_phi_operand != -1, "not set"); return _phi_operand; }
a61af66fc99e Initial load
duke
parents:
diff changeset
81 int scope_count() const { assert(_scope_count != -1, "not set"); return _scope_count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
82 DEBUG_ONLY(int lir_op_id() const { return _lir_op_id; });
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84 void set_entry_block(BlockBegin* entry_block) {
a61af66fc99e Initial load
duke
parents:
diff changeset
85 assert(entry_block->is_set(BlockBegin::exception_entry_flag), "must be an exception handler entry");
a61af66fc99e Initial load
duke
parents:
diff changeset
86 assert(entry_block->bci() == handler_bci(), "bci's must correspond");
a61af66fc99e Initial load
duke
parents:
diff changeset
87 _entry_block = entry_block;
a61af66fc99e Initial load
duke
parents:
diff changeset
88 }
a61af66fc99e Initial load
duke
parents:
diff changeset
89 void set_entry_code(LIR_List* entry_code) { _entry_code = entry_code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
90 void set_entry_pco(int entry_pco) { _entry_pco = entry_pco; }
a61af66fc99e Initial load
duke
parents:
diff changeset
91 void set_phi_operand(int phi_operand) { _phi_operand = phi_operand; }
a61af66fc99e Initial load
duke
parents:
diff changeset
92 void set_scope_count(int scope_count) { _scope_count = scope_count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
93 DEBUG_ONLY(void set_lir_op_id(int lir_op_id) { _lir_op_id = lir_op_id; });
a61af66fc99e Initial load
duke
parents:
diff changeset
94
a61af66fc99e Initial load
duke
parents:
diff changeset
95 bool equals(XHandler* other) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
96 };
a61af66fc99e Initial load
duke
parents:
diff changeset
97
a61af66fc99e Initial load
duke
parents:
diff changeset
98 define_array(_XHandlerArray, XHandler*)
a61af66fc99e Initial load
duke
parents:
diff changeset
99 define_stack(_XHandlerList, _XHandlerArray)
a61af66fc99e Initial load
duke
parents:
diff changeset
100
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // XHandlers is the C1 internal list of exception handlers for a method
a61af66fc99e Initial load
duke
parents:
diff changeset
103 class XHandlers: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
104 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
105 _XHandlerList _list;
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // creation
a61af66fc99e Initial load
duke
parents:
diff changeset
109 XHandlers() : _list() { }
a61af66fc99e Initial load
duke
parents:
diff changeset
110 XHandlers(ciMethod* method);
a61af66fc99e Initial load
duke
parents:
diff changeset
111 XHandlers(XHandlers* other);
a61af66fc99e Initial load
duke
parents:
diff changeset
112
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
114 int length() const { return _list.length(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
115 XHandler* handler_at(int i) const { return _list.at(i); }
a61af66fc99e Initial load
duke
parents:
diff changeset
116 bool has_handlers() const { return _list.length() > 0; }
a61af66fc99e Initial load
duke
parents:
diff changeset
117 void append(XHandler* h) { _list.append(h); }
a61af66fc99e Initial load
duke
parents:
diff changeset
118 XHandler* remove_last() { return _list.pop(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
119
a61af66fc99e Initial load
duke
parents:
diff changeset
120 bool could_catch(ciInstanceKlass* klass, bool type_is_exact) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
121 bool equals(XHandlers* others) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
122 };
a61af66fc99e Initial load
duke
parents:
diff changeset
123
a61af66fc99e Initial load
duke
parents:
diff changeset
124
a61af66fc99e Initial load
duke
parents:
diff changeset
125 class IRScope;
a61af66fc99e Initial load
duke
parents:
diff changeset
126 define_array(IRScopeArray, IRScope*)
a61af66fc99e Initial load
duke
parents:
diff changeset
127 define_stack(IRScopeList, IRScopeArray)
a61af66fc99e Initial load
duke
parents:
diff changeset
128
a61af66fc99e Initial load
duke
parents:
diff changeset
129 class Compilation;
a61af66fc99e Initial load
duke
parents:
diff changeset
130 class IRScope: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
131 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
132 // hierarchy
a61af66fc99e Initial load
duke
parents:
diff changeset
133 Compilation* _compilation; // the current compilation
a61af66fc99e Initial load
duke
parents:
diff changeset
134 IRScope* _caller; // the caller scope, or NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
135 int _caller_bci; // the caller bci of the corresponding (inlined) invoke, or < 0
a61af66fc99e Initial load
duke
parents:
diff changeset
136 ValueStack* _caller_state; // the caller state, or NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
137 int _level; // the inlining level
a61af66fc99e Initial load
duke
parents:
diff changeset
138 ciMethod* _method; // the corresponding method
a61af66fc99e Initial load
duke
parents:
diff changeset
139 IRScopeList _callees; // the inlined method scopes
a61af66fc99e Initial load
duke
parents:
diff changeset
140
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // graph
a61af66fc99e Initial load
duke
parents:
diff changeset
142 XHandlers* _xhandlers; // the exception handlers
a61af66fc99e Initial load
duke
parents:
diff changeset
143 int _number_of_locks; // the number of monitor lock slots needed
a61af66fc99e Initial load
duke
parents:
diff changeset
144 bool _monitor_pairing_ok; // the monitor pairing info
a61af66fc99e Initial load
duke
parents:
diff changeset
145 BlockBegin* _start; // the start block, successsors are method entries
a61af66fc99e Initial load
duke
parents:
diff changeset
146
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // lock stack management
a61af66fc99e Initial load
duke
parents:
diff changeset
148 int _lock_stack_size; // number of expression stack elements which, if present,
a61af66fc99e Initial load
duke
parents:
diff changeset
149 // must be spilled to the stack because of exception
a61af66fc99e Initial load
duke
parents:
diff changeset
150 // handling inside inlined methods
a61af66fc99e Initial load
duke
parents:
diff changeset
151
a61af66fc99e Initial load
duke
parents:
diff changeset
152 BitMap _requires_phi_function; // bit is set if phi functions at loop headers are necessary for a local variable
a61af66fc99e Initial load
duke
parents:
diff changeset
153
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // helper functions
a61af66fc99e Initial load
duke
parents:
diff changeset
155 BlockBegin* header_block(BlockBegin* entry, BlockBegin::Flag f, ValueStack* state);
a61af66fc99e Initial load
duke
parents:
diff changeset
156 BlockBegin* build_graph(Compilation* compilation, int osr_bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // creation
a61af66fc99e Initial load
duke
parents:
diff changeset
160 IRScope(Compilation* compilation, IRScope* caller, int caller_bci, ciMethod* method, int osr_bci, bool create_graph = false);
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
163 Compilation* compilation() const { return _compilation; }
a61af66fc99e Initial load
duke
parents:
diff changeset
164 IRScope* caller() const { return _caller; }
a61af66fc99e Initial load
duke
parents:
diff changeset
165 int caller_bci() const { return _caller_bci; }
a61af66fc99e Initial load
duke
parents:
diff changeset
166 ValueStack* caller_state() const { return _caller_state; }
a61af66fc99e Initial load
duke
parents:
diff changeset
167 int level() const { return _level; }
a61af66fc99e Initial load
duke
parents:
diff changeset
168 ciMethod* method() const { return _method; }
a61af66fc99e Initial load
duke
parents:
diff changeset
169 int max_stack() const; // NOTE: expensive
a61af66fc99e Initial load
duke
parents:
diff changeset
170 int lock_stack_size() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
171 assert(_lock_stack_size != -1, "uninitialized");
a61af66fc99e Initial load
duke
parents:
diff changeset
172 return _lock_stack_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
173 }
a61af66fc99e Initial load
duke
parents:
diff changeset
174 BitMap& requires_phi_function() { return _requires_phi_function; }
a61af66fc99e Initial load
duke
parents:
diff changeset
175
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // mutators
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // Needed because caller state is not ready at time of IRScope construction
a61af66fc99e Initial load
duke
parents:
diff changeset
178 void set_caller_state(ValueStack* state) { _caller_state = state; }
a61af66fc99e Initial load
duke
parents:
diff changeset
179 // Needed because caller state changes after IRScope construction.
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // Computes number of expression stack elements whose state must be
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // preserved in the case of an exception; these may be seen by
a61af66fc99e Initial load
duke
parents:
diff changeset
182 // caller scopes. Zero when inlining of methods containing exception
a61af66fc99e Initial load
duke
parents:
diff changeset
183 // handlers is disabled, otherwise a conservative approximation.
a61af66fc99e Initial load
duke
parents:
diff changeset
184 void compute_lock_stack_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186 // hierarchy
a61af66fc99e Initial load
duke
parents:
diff changeset
187 bool is_top_scope() const { return _caller == NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
188 void add_callee(IRScope* callee) { _callees.append(callee); }
a61af66fc99e Initial load
duke
parents:
diff changeset
189 int number_of_callees() const { return _callees.length(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
190 IRScope* callee_no(int i) const { return _callees.at(i); }
a61af66fc99e Initial load
duke
parents:
diff changeset
191 int top_scope_bci() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // accessors, graph
a61af66fc99e Initial load
duke
parents:
diff changeset
194 bool is_valid() const { return start() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
195 XHandlers* xhandlers() const { return _xhandlers; }
a61af66fc99e Initial load
duke
parents:
diff changeset
196 int number_of_locks() const { return _number_of_locks; }
a61af66fc99e Initial load
duke
parents:
diff changeset
197 void set_min_number_of_locks(int n) { if (n > _number_of_locks) _number_of_locks = n; }
a61af66fc99e Initial load
duke
parents:
diff changeset
198 bool monitor_pairing_ok() const { return _monitor_pairing_ok; }
a61af66fc99e Initial load
duke
parents:
diff changeset
199 BlockBegin* start() const { return _start; }
a61af66fc99e Initial load
duke
parents:
diff changeset
200 };
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 //
a61af66fc99e Initial load
duke
parents:
diff changeset
204 // IRScopeDebugInfo records the debug information for a particular IRScope
a61af66fc99e Initial load
duke
parents:
diff changeset
205 // in a particular CodeEmitInfo. This allows the information to be computed
a61af66fc99e Initial load
duke
parents:
diff changeset
206 // once early enough for the OopMap to be available to the LIR and also to be
a61af66fc99e Initial load
duke
parents:
diff changeset
207 // reemited for different pcs using the same CodeEmitInfo without recomputing
a61af66fc99e Initial load
duke
parents:
diff changeset
208 // everything.
a61af66fc99e Initial load
duke
parents:
diff changeset
209 //
a61af66fc99e Initial load
duke
parents:
diff changeset
210
a61af66fc99e Initial load
duke
parents:
diff changeset
211 class IRScopeDebugInfo: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
212 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
213 IRScope* _scope;
a61af66fc99e Initial load
duke
parents:
diff changeset
214 int _bci;
a61af66fc99e Initial load
duke
parents:
diff changeset
215 GrowableArray<ScopeValue*>* _locals;
a61af66fc99e Initial load
duke
parents:
diff changeset
216 GrowableArray<ScopeValue*>* _expressions;
a61af66fc99e Initial load
duke
parents:
diff changeset
217 GrowableArray<MonitorValue*>* _monitors;
a61af66fc99e Initial load
duke
parents:
diff changeset
218 IRScopeDebugInfo* _caller;
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
221 IRScopeDebugInfo(IRScope* scope,
a61af66fc99e Initial load
duke
parents:
diff changeset
222 int bci,
a61af66fc99e Initial load
duke
parents:
diff changeset
223 GrowableArray<ScopeValue*>* locals,
a61af66fc99e Initial load
duke
parents:
diff changeset
224 GrowableArray<ScopeValue*>* expressions,
a61af66fc99e Initial load
duke
parents:
diff changeset
225 GrowableArray<MonitorValue*>* monitors,
a61af66fc99e Initial load
duke
parents:
diff changeset
226 IRScopeDebugInfo* caller):
a61af66fc99e Initial load
duke
parents:
diff changeset
227 _scope(scope)
a61af66fc99e Initial load
duke
parents:
diff changeset
228 , _locals(locals)
a61af66fc99e Initial load
duke
parents:
diff changeset
229 , _bci(bci)
a61af66fc99e Initial load
duke
parents:
diff changeset
230 , _expressions(expressions)
a61af66fc99e Initial load
duke
parents:
diff changeset
231 , _monitors(monitors)
a61af66fc99e Initial load
duke
parents:
diff changeset
232 , _caller(caller) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234
a61af66fc99e Initial load
duke
parents:
diff changeset
235 IRScope* scope() { return _scope; }
a61af66fc99e Initial load
duke
parents:
diff changeset
236 int bci() { return _bci; }
a61af66fc99e Initial load
duke
parents:
diff changeset
237 GrowableArray<ScopeValue*>* locals() { return _locals; }
a61af66fc99e Initial load
duke
parents:
diff changeset
238 GrowableArray<ScopeValue*>* expressions() { return _expressions; }
a61af66fc99e Initial load
duke
parents:
diff changeset
239 GrowableArray<MonitorValue*>* monitors() { return _monitors; }
a61af66fc99e Initial load
duke
parents:
diff changeset
240 IRScopeDebugInfo* caller() { return _caller; }
a61af66fc99e Initial load
duke
parents:
diff changeset
241
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 0
diff changeset
242 //Whether we should reexecute this bytecode for deopt
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 0
diff changeset
243 bool should_reexecute();
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 0
diff changeset
244
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1253
diff changeset
245 void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool topmost, bool is_method_handle_invoke = false) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
246 if (caller() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
247 // Order is significant: Must record caller first.
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 0
diff changeset
248 caller()->record_debug_info(recorder, pc_offset, false/*topmost*/);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
249 }
a61af66fc99e Initial load
duke
parents:
diff changeset
250 DebugToken* locvals = recorder->create_scope_values(locals());
a61af66fc99e Initial load
duke
parents:
diff changeset
251 DebugToken* expvals = recorder->create_scope_values(expressions());
a61af66fc99e Initial load
duke
parents:
diff changeset
252 DebugToken* monvals = recorder->create_monitor_values(monitors());
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 0
diff changeset
253 // reexecute allowed only for the topmost frame
1135
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 948
diff changeset
254 bool reexecute = topmost ? should_reexecute() : false;
1253
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents: 1135
diff changeset
255 bool return_oop = false; // This flag will be ignored since it used only for C2 with escape analysis.
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents: 1135
diff changeset
256 recorder->describe_scope(pc_offset, scope()->method(), bci(), reexecute, is_method_handle_invoke, return_oop, locvals, expvals, monvals);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
257 }
a61af66fc99e Initial load
duke
parents:
diff changeset
258 };
a61af66fc99e Initial load
duke
parents:
diff changeset
259
a61af66fc99e Initial load
duke
parents:
diff changeset
260
a61af66fc99e Initial load
duke
parents:
diff changeset
261 class CodeEmitInfo: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
262 friend class LinearScan;
a61af66fc99e Initial load
duke
parents:
diff changeset
263 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
264 IRScopeDebugInfo* _scope_debug_info;
a61af66fc99e Initial load
duke
parents:
diff changeset
265 IRScope* _scope;
a61af66fc99e Initial load
duke
parents:
diff changeset
266 XHandlers* _exception_handlers;
a61af66fc99e Initial load
duke
parents:
diff changeset
267 OopMap* _oop_map;
a61af66fc99e Initial load
duke
parents:
diff changeset
268 ValueStack* _stack; // used by deoptimization (contains also monitors
a61af66fc99e Initial load
duke
parents:
diff changeset
269 int _bci;
a61af66fc99e Initial load
duke
parents:
diff changeset
270 CodeEmitInfo* _next;
a61af66fc99e Initial load
duke
parents:
diff changeset
271 int _id;
a61af66fc99e Initial load
duke
parents:
diff changeset
272
a61af66fc99e Initial load
duke
parents:
diff changeset
273 FrameMap* frame_map() const { return scope()->compilation()->frame_map(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
274 Compilation* compilation() const { return scope()->compilation(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
275
a61af66fc99e Initial load
duke
parents:
diff changeset
276 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
277
a61af66fc99e Initial load
duke
parents:
diff changeset
278 // use scope from ValueStack
a61af66fc99e Initial load
duke
parents:
diff changeset
279 CodeEmitInfo(int bci, ValueStack* stack, XHandlers* exception_handlers);
a61af66fc99e Initial load
duke
parents:
diff changeset
280
a61af66fc99e Initial load
duke
parents:
diff changeset
281 // used by natives
a61af66fc99e Initial load
duke
parents:
diff changeset
282 CodeEmitInfo(IRScope* scope, int bci)
a61af66fc99e Initial load
duke
parents:
diff changeset
283 : _scope(scope)
a61af66fc99e Initial load
duke
parents:
diff changeset
284 , _bci(bci)
a61af66fc99e Initial load
duke
parents:
diff changeset
285 , _oop_map(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
286 , _scope_debug_info(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
287 , _stack(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
288 , _exception_handlers(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
289 , _next(NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
290 , _id(-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
291 }
a61af66fc99e Initial load
duke
parents:
diff changeset
292
a61af66fc99e Initial load
duke
parents:
diff changeset
293 // make a copy
a61af66fc99e Initial load
duke
parents:
diff changeset
294 CodeEmitInfo(CodeEmitInfo* info, bool lock_stack_only = false);
a61af66fc99e Initial load
duke
parents:
diff changeset
295
a61af66fc99e Initial load
duke
parents:
diff changeset
296 // accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
297 OopMap* oop_map() { return _oop_map; }
a61af66fc99e Initial load
duke
parents:
diff changeset
298 ciMethod* method() const { return _scope->method(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
299 IRScope* scope() const { return _scope; }
a61af66fc99e Initial load
duke
parents:
diff changeset
300 XHandlers* exception_handlers() const { return _exception_handlers; }
a61af66fc99e Initial load
duke
parents:
diff changeset
301 ValueStack* stack() const { return _stack; }
a61af66fc99e Initial load
duke
parents:
diff changeset
302 int bci() const { return _bci; }
a61af66fc99e Initial load
duke
parents:
diff changeset
303
a61af66fc99e Initial load
duke
parents:
diff changeset
304 void add_register_oop(LIR_Opr opr);
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1253
diff changeset
305 void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool is_method_handle_invoke = false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
306
a61af66fc99e Initial load
duke
parents:
diff changeset
307 CodeEmitInfo* next() const { return _next; }
a61af66fc99e Initial load
duke
parents:
diff changeset
308 void set_next(CodeEmitInfo* next) { _next = next; }
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 int id() const { return _id; }
a61af66fc99e Initial load
duke
parents:
diff changeset
311 void set_id(int id) { _id = id; }
a61af66fc99e Initial load
duke
parents:
diff changeset
312 };
a61af66fc99e Initial load
duke
parents:
diff changeset
313
a61af66fc99e Initial load
duke
parents:
diff changeset
314
a61af66fc99e Initial load
duke
parents:
diff changeset
315 class IR: public CompilationResourceObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
316 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
317 Compilation* _compilation; // the current compilation
a61af66fc99e Initial load
duke
parents:
diff changeset
318 IRScope* _top_scope; // the root of the scope hierarchy
a61af66fc99e Initial load
duke
parents:
diff changeset
319 WordSize _locals_size; // the space required for all locals
a61af66fc99e Initial load
duke
parents:
diff changeset
320 int _num_loops; // Total number of loops
a61af66fc99e Initial load
duke
parents:
diff changeset
321 BlockList* _code; // the blocks in code generation order w/ use counts
a61af66fc99e Initial load
duke
parents:
diff changeset
322
a61af66fc99e Initial load
duke
parents:
diff changeset
323 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
324 // creation
a61af66fc99e Initial load
duke
parents:
diff changeset
325 IR(Compilation* compilation, ciMethod* method, int osr_bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
326
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
328 bool is_valid() const { return top_scope()->is_valid(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
329 Compilation* compilation() const { return _compilation; }
a61af66fc99e Initial load
duke
parents:
diff changeset
330 IRScope* top_scope() const { return _top_scope; }
a61af66fc99e Initial load
duke
parents:
diff changeset
331 int number_of_locks() const { return top_scope()->number_of_locks(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
332 ciMethod* method() const { return top_scope()->method(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
333 BlockBegin* start() const { return top_scope()->start(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
334 BlockBegin* std_entry() const { return start()->end()->as_Base()->std_entry(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
335 BlockBegin* osr_entry() const { return start()->end()->as_Base()->osr_entry(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
336 WordSize locals_size() const { return _locals_size; }
a61af66fc99e Initial load
duke
parents:
diff changeset
337 int locals_size_in_words() const { return in_words(_locals_size); }
a61af66fc99e Initial load
duke
parents:
diff changeset
338 BlockList* code() const { return _code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
339 int num_loops() const { return _num_loops; }
a61af66fc99e Initial load
duke
parents:
diff changeset
340 int max_stack() const { return top_scope()->max_stack(); } // expensive
a61af66fc99e Initial load
duke
parents:
diff changeset
341
a61af66fc99e Initial load
duke
parents:
diff changeset
342 // ir manipulation
a61af66fc99e Initial load
duke
parents:
diff changeset
343 void optimize();
a61af66fc99e Initial load
duke
parents:
diff changeset
344 void compute_predecessors();
a61af66fc99e Initial load
duke
parents:
diff changeset
345 void split_critical_edges();
a61af66fc99e Initial load
duke
parents:
diff changeset
346 void compute_code();
a61af66fc99e Initial load
duke
parents:
diff changeset
347 void compute_use_counts();
a61af66fc99e Initial load
duke
parents:
diff changeset
348
a61af66fc99e Initial load
duke
parents:
diff changeset
349 // The linear-scan order and the code emission order are equal, but
a61af66fc99e Initial load
duke
parents:
diff changeset
350 // this may change in future
a61af66fc99e Initial load
duke
parents:
diff changeset
351 BlockList* linear_scan_order() { assert(_code != NULL, "not computed"); return _code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
352
a61af66fc99e Initial load
duke
parents:
diff changeset
353 // iteration
a61af66fc99e Initial load
duke
parents:
diff changeset
354 void iterate_preorder (BlockClosure* closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
355 void iterate_postorder (BlockClosure* closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
356 void iterate_linear_scan_order(BlockClosure* closure);
a61af66fc99e Initial load
duke
parents:
diff changeset
357
a61af66fc99e Initial load
duke
parents:
diff changeset
358 // debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
359 static void print(BlockBegin* start, bool cfg_only, bool live_only = false) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
360 void print(bool cfg_only, bool live_only = false) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
361 void verify() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
362 };
a61af66fc99e Initial load
duke
parents:
diff changeset
363
a61af66fc99e Initial load
duke
parents:
diff changeset
364
a61af66fc99e Initial load
duke
parents:
diff changeset
365 // Globally do instruction substitution and remove substituted
a61af66fc99e Initial load
duke
parents:
diff changeset
366 // instructions from the instruction list.
a61af66fc99e Initial load
duke
parents:
diff changeset
367 //
a61af66fc99e Initial load
duke
parents:
diff changeset
368
a61af66fc99e Initial load
duke
parents:
diff changeset
369 class SubstitutionResolver: public BlockClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
370 static void substitute(Value* v);
a61af66fc99e Initial load
duke
parents:
diff changeset
371
a61af66fc99e Initial load
duke
parents:
diff changeset
372 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
373 SubstitutionResolver(IR* hir) {
a61af66fc99e Initial load
duke
parents:
diff changeset
374 hir->iterate_preorder(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
375 }
a61af66fc99e Initial load
duke
parents:
diff changeset
376
a61af66fc99e Initial load
duke
parents:
diff changeset
377 SubstitutionResolver(BlockBegin* block) {
a61af66fc99e Initial load
duke
parents:
diff changeset
378 block->iterate_preorder(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
379 }
a61af66fc99e Initial load
duke
parents:
diff changeset
380
a61af66fc99e Initial load
duke
parents:
diff changeset
381 virtual void block_do(BlockBegin* block);
a61af66fc99e Initial load
duke
parents:
diff changeset
382 };