Tue, 23 Nov 2010 13:22:55 -0800
6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg
1 /*
2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_C1_C1_INSTRUCTION_HPP
26 #define SHARE_VM_C1_C1_INSTRUCTION_HPP
28 #include "c1/c1_Compilation.hpp"
29 #include "c1/c1_LIR.hpp"
30 #include "c1/c1_ValueType.hpp"
31 #include "ci/ciField.hpp"
33 // Predefined classes
34 class ciField;
35 class ValueStack;
36 class InstructionPrinter;
37 class IRScope;
38 class LIR_OprDesc;
39 typedef LIR_OprDesc* LIR_Opr;
42 // Instruction class hierarchy
43 //
44 // All leaf classes in the class hierarchy are concrete classes
45 // (i.e., are instantiated). All other classes are abstract and
46 // serve factoring.
48 class Instruction;
49 class Phi;
50 class Local;
51 class Constant;
52 class AccessField;
53 class LoadField;
54 class StoreField;
55 class AccessArray;
56 class ArrayLength;
57 class AccessIndexed;
58 class LoadIndexed;
59 class StoreIndexed;
60 class NegateOp;
61 class Op2;
62 class ArithmeticOp;
63 class ShiftOp;
64 class LogicOp;
65 class CompareOp;
66 class IfOp;
67 class Convert;
68 class NullCheck;
69 class OsrEntry;
70 class ExceptionObject;
71 class StateSplit;
72 class Invoke;
73 class NewInstance;
74 class NewArray;
75 class NewTypeArray;
76 class NewObjectArray;
77 class NewMultiArray;
78 class TypeCheck;
79 class CheckCast;
80 class InstanceOf;
81 class AccessMonitor;
82 class MonitorEnter;
83 class MonitorExit;
84 class Intrinsic;
85 class BlockBegin;
86 class BlockEnd;
87 class Goto;
88 class If;
89 class IfInstanceOf;
90 class Switch;
91 class TableSwitch;
92 class LookupSwitch;
93 class Return;
94 class Throw;
95 class Base;
96 class RoundFP;
97 class UnsafeOp;
98 class UnsafeRawOp;
99 class UnsafeGetRaw;
100 class UnsafePutRaw;
101 class UnsafeObjectOp;
102 class UnsafeGetObject;
103 class UnsafePutObject;
104 class UnsafePrefetch;
105 class UnsafePrefetchRead;
106 class UnsafePrefetchWrite;
107 class ProfileCall;
108 class ProfileInvoke;
110 // A Value is a reference to the instruction creating the value
111 typedef Instruction* Value;
112 define_array(ValueArray, Value)
113 define_stack(Values, ValueArray)
115 define_array(ValueStackArray, ValueStack*)
116 define_stack(ValueStackStack, ValueStackArray)
118 // BlockClosure is the base class for block traversal/iteration.
120 class BlockClosure: public CompilationResourceObj {
121 public:
122 virtual void block_do(BlockBegin* block) = 0;
123 };
126 // A simple closure class for visiting the values of an Instruction
127 class ValueVisitor: public StackObj {
128 public:
129 virtual void visit(Value* v) = 0;
130 };
133 // Some array and list classes
134 define_array(BlockBeginArray, BlockBegin*)
135 define_stack(_BlockList, BlockBeginArray)
137 class BlockList: public _BlockList {
138 public:
139 BlockList(): _BlockList() {}
140 BlockList(const int size): _BlockList(size) {}
141 BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}
143 void iterate_forward(BlockClosure* closure);
144 void iterate_backward(BlockClosure* closure);
145 void blocks_do(void f(BlockBegin*));
146 void values_do(ValueVisitor* f);
147 void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
148 };
151 // InstructionVisitors provide type-based dispatch for instructions.
152 // For each concrete Instruction class X, a virtual function do_X is
153 // provided. Functionality that needs to be implemented for all classes
154 // (e.g., printing, code generation) is factored out into a specialised
155 // visitor instead of added to the Instruction classes itself.
157 class InstructionVisitor: public StackObj {
158 public:
159 virtual void do_Phi (Phi* x) = 0;
160 virtual void do_Local (Local* x) = 0;
161 virtual void do_Constant (Constant* x) = 0;
162 virtual void do_LoadField (LoadField* x) = 0;
163 virtual void do_StoreField (StoreField* x) = 0;
164 virtual void do_ArrayLength (ArrayLength* x) = 0;
165 virtual void do_LoadIndexed (LoadIndexed* x) = 0;
166 virtual void do_StoreIndexed (StoreIndexed* x) = 0;
167 virtual void do_NegateOp (NegateOp* x) = 0;
168 virtual void do_ArithmeticOp (ArithmeticOp* x) = 0;
169 virtual void do_ShiftOp (ShiftOp* x) = 0;
170 virtual void do_LogicOp (LogicOp* x) = 0;
171 virtual void do_CompareOp (CompareOp* x) = 0;
172 virtual void do_IfOp (IfOp* x) = 0;
173 virtual void do_Convert (Convert* x) = 0;
174 virtual void do_NullCheck (NullCheck* x) = 0;
175 virtual void do_Invoke (Invoke* x) = 0;
176 virtual void do_NewInstance (NewInstance* x) = 0;
177 virtual void do_NewTypeArray (NewTypeArray* x) = 0;
178 virtual void do_NewObjectArray (NewObjectArray* x) = 0;
179 virtual void do_NewMultiArray (NewMultiArray* x) = 0;
180 virtual void do_CheckCast (CheckCast* x) = 0;
181 virtual void do_InstanceOf (InstanceOf* x) = 0;
182 virtual void do_MonitorEnter (MonitorEnter* x) = 0;
183 virtual void do_MonitorExit (MonitorExit* x) = 0;
184 virtual void do_Intrinsic (Intrinsic* x) = 0;
185 virtual void do_BlockBegin (BlockBegin* x) = 0;
186 virtual void do_Goto (Goto* x) = 0;
187 virtual void do_If (If* x) = 0;
188 virtual void do_IfInstanceOf (IfInstanceOf* x) = 0;
189 virtual void do_TableSwitch (TableSwitch* x) = 0;
190 virtual void do_LookupSwitch (LookupSwitch* x) = 0;
191 virtual void do_Return (Return* x) = 0;
192 virtual void do_Throw (Throw* x) = 0;
193 virtual void do_Base (Base* x) = 0;
194 virtual void do_OsrEntry (OsrEntry* x) = 0;
195 virtual void do_ExceptionObject(ExceptionObject* x) = 0;
196 virtual void do_RoundFP (RoundFP* x) = 0;
197 virtual void do_UnsafeGetRaw (UnsafeGetRaw* x) = 0;
198 virtual void do_UnsafePutRaw (UnsafePutRaw* x) = 0;
199 virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
200 virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
201 virtual void do_UnsafePrefetchRead (UnsafePrefetchRead* x) = 0;
202 virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
203 virtual void do_ProfileCall (ProfileCall* x) = 0;
204 virtual void do_ProfileInvoke (ProfileInvoke* x) = 0;
205 };
208 // Hashing support
209 //
210 // Note: This hash functions affect the performance
211 // of ValueMap - make changes carefully!
213 #define HASH1(x1 ) ((intx)(x1))
214 #define HASH2(x1, x2 ) ((HASH1(x1 ) << 7) ^ HASH1(x2))
215 #define HASH3(x1, x2, x3 ) ((HASH2(x1, x2 ) << 7) ^ HASH1(x3))
216 #define HASH4(x1, x2, x3, x4) ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
219 // The following macros are used to implement instruction-specific hashing.
220 // By default, each instruction implements hash() and is_equal(Value), used
221 // for value numbering/common subexpression elimination. The default imple-
222 // mentation disables value numbering. Each instruction which can be value-
223 // numbered, should define corresponding hash() and is_equal(Value) functions
224 // via the macros below. The f arguments specify all the values/op codes, etc.
225 // that need to be identical for two instructions to be identical.
226 //
227 // Note: The default implementation of hash() returns 0 in order to indicate
228 // that the instruction should not be considered for value numbering.
229 // The currently used hash functions do not guarantee that never a 0
230 // is produced. While this is still correct, it may be a performance
231 // bug (no value numbering for that node). However, this situation is
232 // so unlikely, that we are not going to handle it specially.
234 #define HASHING1(class_name, enabled, f1) \
235 virtual intx hash() const { \
236 return (enabled) ? HASH2(name(), f1) : 0; \
237 } \
238 virtual bool is_equal(Value v) const { \
239 if (!(enabled) ) return false; \
240 class_name* _v = v->as_##class_name(); \
241 if (_v == NULL ) return false; \
242 if (f1 != _v->f1) return false; \
243 return true; \
244 } \
247 #define HASHING2(class_name, enabled, f1, f2) \
248 virtual intx hash() const { \
249 return (enabled) ? HASH3(name(), f1, f2) : 0; \
250 } \
251 virtual bool is_equal(Value v) const { \
252 if (!(enabled) ) return false; \
253 class_name* _v = v->as_##class_name(); \
254 if (_v == NULL ) return false; \
255 if (f1 != _v->f1) return false; \
256 if (f2 != _v->f2) return false; \
257 return true; \
258 } \
261 #define HASHING3(class_name, enabled, f1, f2, f3) \
262 virtual intx hash() const { \
263 return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
264 } \
265 virtual bool is_equal(Value v) const { \
266 if (!(enabled) ) return false; \
267 class_name* _v = v->as_##class_name(); \
268 if (_v == NULL ) return false; \
269 if (f1 != _v->f1) return false; \
270 if (f2 != _v->f2) return false; \
271 if (f3 != _v->f3) return false; \
272 return true; \
273 } \
276 // The mother of all instructions...
278 class Instruction: public CompilationResourceObj {
279 private:
280 int _id; // the unique instruction id
281 #ifndef PRODUCT
282 int _printable_bci; // the bci of the instruction for printing
283 #endif
284 int _use_count; // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
285 int _pin_state; // set of PinReason describing the reason for pinning
286 ValueType* _type; // the instruction value type
287 Instruction* _next; // the next instruction if any (NULL for BlockEnd instructions)
288 Instruction* _subst; // the substitution instruction if any
289 LIR_Opr _operand; // LIR specific information
290 unsigned int _flags; // Flag bits
292 ValueStack* _state_before; // Copy of state with input operands still on stack (or NULL)
293 ValueStack* _exception_state; // Copy of state for exception handling
294 XHandlers* _exception_handlers; // Flat list of exception handlers covering this instruction
296 friend class UseCountComputer;
297 friend class BlockBegin;
299 void update_exception_state(ValueStack* state);
301 bool has_printable_bci() const { return NOT_PRODUCT(_printable_bci != -99) PRODUCT_ONLY(false); }
303 protected:
304 void set_type(ValueType* type) {
305 assert(type != NULL, "type must exist");
306 _type = type;
307 }
309 public:
310 void* operator new(size_t size) {
311 Compilation* c = Compilation::current();
312 void* res = c->arena()->Amalloc(size);
313 ((Instruction*)res)->_id = c->get_next_id();
314 return res;
315 }
317 enum InstructionFlag {
318 NeedsNullCheckFlag = 0,
319 CanTrapFlag,
320 DirectCompareFlag,
321 IsEliminatedFlag,
322 IsInitializedFlag,
323 IsLoadedFlag,
324 IsSafepointFlag,
325 IsStaticFlag,
326 IsStrictfpFlag,
327 NeedsStoreCheckFlag,
328 NeedsWriteBarrierFlag,
329 PreservesStateFlag,
330 TargetIsFinalFlag,
331 TargetIsLoadedFlag,
332 TargetIsStrictfpFlag,
333 UnorderedIsTrueFlag,
334 NeedsPatchingFlag,
335 ThrowIncompatibleClassChangeErrorFlag,
336 ProfileMDOFlag,
337 IsLinkedInBlockFlag,
338 InstructionLastFlag
339 };
341 public:
342 bool check_flag(InstructionFlag id) const { return (_flags & (1 << id)) != 0; }
343 void set_flag(InstructionFlag id, bool f) { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
345 // 'globally' used condition values
346 enum Condition {
347 eql, neq, lss, leq, gtr, geq
348 };
350 // Instructions may be pinned for many reasons and under certain conditions
351 // with enough knowledge it's possible to safely unpin them.
352 enum PinReason {
353 PinUnknown = 1 << 0
354 , PinExplicitNullCheck = 1 << 3
355 , PinStackForStateSplit= 1 << 12
356 , PinStateSplitConstructor= 1 << 13
357 , PinGlobalValueNumbering= 1 << 14
358 };
360 static Condition mirror(Condition cond);
361 static Condition negate(Condition cond);
363 // initialization
364 static int number_of_instructions() {
365 return Compilation::current()->number_of_instructions();
366 }
368 // creation
369 Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false)
370 : _use_count(0)
371 #ifndef PRODUCT
372 , _printable_bci(-99)
373 #endif
374 , _pin_state(0)
375 , _type(type)
376 , _next(NULL)
377 , _subst(NULL)
378 , _flags(0)
379 , _operand(LIR_OprFact::illegalOpr)
380 , _state_before(state_before)
381 , _exception_handlers(NULL)
382 {
383 check_state(state_before);
384 assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
385 update_exception_state(_state_before);
386 }
388 // accessors
389 int id() const { return _id; }
390 #ifndef PRODUCT
391 int printable_bci() const { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
392 void set_printable_bci(int bci) { NOT_PRODUCT(_printable_bci = bci;) }
393 #endif
394 int use_count() const { return _use_count; }
395 int pin_state() const { return _pin_state; }
396 bool is_pinned() const { return _pin_state != 0 || PinAllInstructions; }
397 ValueType* type() const { return _type; }
398 Instruction* prev(BlockBegin* block); // use carefully, expensive operation
399 Instruction* next() const { return _next; }
400 bool has_subst() const { return _subst != NULL; }
401 Instruction* subst() { return _subst == NULL ? this : _subst->subst(); }
402 LIR_Opr operand() const { return _operand; }
404 void set_needs_null_check(bool f) { set_flag(NeedsNullCheckFlag, f); }
405 bool needs_null_check() const { return check_flag(NeedsNullCheckFlag); }
406 bool is_linked() const { return check_flag(IsLinkedInBlockFlag); }
407 bool can_be_linked() { return as_Local() == NULL && as_Phi() == NULL; }
409 bool has_uses() const { return use_count() > 0; }
410 ValueStack* state_before() const { return _state_before; }
411 ValueStack* exception_state() const { return _exception_state; }
412 virtual bool needs_exception_state() const { return true; }
413 XHandlers* exception_handlers() const { return _exception_handlers; }
415 // manipulation
416 void pin(PinReason reason) { _pin_state |= reason; }
417 void pin() { _pin_state |= PinUnknown; }
418 // DANGEROUS: only used by EliminateStores
419 void unpin(PinReason reason) { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
421 Instruction* set_next(Instruction* next) {
422 assert(next->has_printable_bci(), "_printable_bci should have been set");
423 assert(next != NULL, "must not be NULL");
424 assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
425 assert(next->can_be_linked(), "shouldn't link these instructions into list");
427 next->set_flag(Instruction::IsLinkedInBlockFlag, true);
428 _next = next;
429 return next;
430 }
432 Instruction* set_next(Instruction* next, int bci) {
433 #ifndef PRODUCT
434 next->set_printable_bci(bci);
435 #endif
436 return set_next(next);
437 }
439 void set_subst(Instruction* subst) {
440 assert(subst == NULL ||
441 type()->base() == subst->type()->base() ||
442 subst->type()->base() == illegalType, "type can't change");
443 _subst = subst;
444 }
445 void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
446 void set_exception_state(ValueStack* s) { check_state(s); _exception_state = s; }
448 // machine-specifics
449 void set_operand(LIR_Opr operand) { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
450 void clear_operand() { _operand = LIR_OprFact::illegalOpr; }
452 // generic
453 virtual Instruction* as_Instruction() { return this; } // to satisfy HASHING1 macro
454 virtual Phi* as_Phi() { return NULL; }
455 virtual Local* as_Local() { return NULL; }
456 virtual Constant* as_Constant() { return NULL; }
457 virtual AccessField* as_AccessField() { return NULL; }
458 virtual LoadField* as_LoadField() { return NULL; }
459 virtual StoreField* as_StoreField() { return NULL; }
460 virtual AccessArray* as_AccessArray() { return NULL; }
461 virtual ArrayLength* as_ArrayLength() { return NULL; }
462 virtual AccessIndexed* as_AccessIndexed() { return NULL; }
463 virtual LoadIndexed* as_LoadIndexed() { return NULL; }
464 virtual StoreIndexed* as_StoreIndexed() { return NULL; }
465 virtual NegateOp* as_NegateOp() { return NULL; }
466 virtual Op2* as_Op2() { return NULL; }
467 virtual ArithmeticOp* as_ArithmeticOp() { return NULL; }
468 virtual ShiftOp* as_ShiftOp() { return NULL; }
469 virtual LogicOp* as_LogicOp() { return NULL; }
470 virtual CompareOp* as_CompareOp() { return NULL; }
471 virtual IfOp* as_IfOp() { return NULL; }
472 virtual Convert* as_Convert() { return NULL; }
473 virtual NullCheck* as_NullCheck() { return NULL; }
474 virtual OsrEntry* as_OsrEntry() { return NULL; }
475 virtual StateSplit* as_StateSplit() { return NULL; }
476 virtual Invoke* as_Invoke() { return NULL; }
477 virtual NewInstance* as_NewInstance() { return NULL; }
478 virtual NewArray* as_NewArray() { return NULL; }
479 virtual NewTypeArray* as_NewTypeArray() { return NULL; }
480 virtual NewObjectArray* as_NewObjectArray() { return NULL; }
481 virtual NewMultiArray* as_NewMultiArray() { return NULL; }
482 virtual TypeCheck* as_TypeCheck() { return NULL; }
483 virtual CheckCast* as_CheckCast() { return NULL; }
484 virtual InstanceOf* as_InstanceOf() { return NULL; }
485 virtual AccessMonitor* as_AccessMonitor() { return NULL; }
486 virtual MonitorEnter* as_MonitorEnter() { return NULL; }
487 virtual MonitorExit* as_MonitorExit() { return NULL; }
488 virtual Intrinsic* as_Intrinsic() { return NULL; }
489 virtual BlockBegin* as_BlockBegin() { return NULL; }
490 virtual BlockEnd* as_BlockEnd() { return NULL; }
491 virtual Goto* as_Goto() { return NULL; }
492 virtual If* as_If() { return NULL; }
493 virtual IfInstanceOf* as_IfInstanceOf() { return NULL; }
494 virtual TableSwitch* as_TableSwitch() { return NULL; }
495 virtual LookupSwitch* as_LookupSwitch() { return NULL; }
496 virtual Return* as_Return() { return NULL; }
497 virtual Throw* as_Throw() { return NULL; }
498 virtual Base* as_Base() { return NULL; }
499 virtual RoundFP* as_RoundFP() { return NULL; }
500 virtual ExceptionObject* as_ExceptionObject() { return NULL; }
501 virtual UnsafeOp* as_UnsafeOp() { return NULL; }
503 virtual void visit(InstructionVisitor* v) = 0;
505 virtual bool can_trap() const { return false; }
507 virtual void input_values_do(ValueVisitor* f) = 0;
508 virtual void state_values_do(ValueVisitor* f);
509 virtual void other_values_do(ValueVisitor* f) { /* usually no other - override on demand */ }
510 void values_do(ValueVisitor* f) { input_values_do(f); state_values_do(f); other_values_do(f); }
512 virtual ciType* exact_type() const { return NULL; }
513 virtual ciType* declared_type() const { return NULL; }
515 // hashing
516 virtual const char* name() const = 0;
517 HASHING1(Instruction, false, id()) // hashing disabled by default
519 // debugging
520 static void check_state(ValueStack* state) PRODUCT_RETURN;
521 void print() PRODUCT_RETURN;
522 void print_line() PRODUCT_RETURN;
523 void print(InstructionPrinter& ip) PRODUCT_RETURN;
524 };
527 // The following macros are used to define base (i.e., non-leaf)
528 // and leaf instruction classes. They define class-name related
529 // generic functionality in one place.
531 #define BASE(class_name, super_class_name) \
532 class class_name: public super_class_name { \
533 public: \
534 virtual class_name* as_##class_name() { return this; } \
537 #define LEAF(class_name, super_class_name) \
538 BASE(class_name, super_class_name) \
539 public: \
540 virtual const char* name() const { return #class_name; } \
541 virtual void visit(InstructionVisitor* v) { v->do_##class_name(this); } \
544 // Debugging support
547 #ifdef ASSERT
548 class AssertValues: public ValueVisitor {
549 void visit(Value* x) { assert((*x) != NULL, "value must exist"); }
550 };
551 #define ASSERT_VALUES { AssertValues assert_value; values_do(&assert_value); }
552 #else
553 #define ASSERT_VALUES
554 #endif // ASSERT
557 // A Phi is a phi function in the sense of SSA form. It stands for
558 // the value of a local variable at the beginning of a join block.
559 // A Phi consists of n operands, one for every incoming branch.
561 LEAF(Phi, Instruction)
562 private:
563 BlockBegin* _block; // the block to which the phi function belongs
564 int _pf_flags; // the flags of the phi function
565 int _index; // to value on operand stack (index < 0) or to local
566 public:
567 // creation
568 Phi(ValueType* type, BlockBegin* b, int index)
569 : Instruction(type->base())
570 , _pf_flags(0)
571 , _block(b)
572 , _index(index)
573 {
574 if (type->is_illegal()) {
575 make_illegal();
576 }
577 }
579 // flags
580 enum Flag {
581 no_flag = 0,
582 visited = 1 << 0,
583 cannot_simplify = 1 << 1
584 };
586 // accessors
587 bool is_local() const { return _index >= 0; }
588 bool is_on_stack() const { return !is_local(); }
589 int local_index() const { assert(is_local(), ""); return _index; }
590 int stack_index() const { assert(is_on_stack(), ""); return -(_index+1); }
592 Value operand_at(int i) const;
593 int operand_count() const;
595 BlockBegin* block() const { return _block; }
597 void set(Flag f) { _pf_flags |= f; }
598 void clear(Flag f) { _pf_flags &= ~f; }
599 bool is_set(Flag f) const { return (_pf_flags & f) != 0; }
601 // Invalidates phis corresponding to merges of locals of two different types
602 // (these should never be referenced, otherwise the bytecodes are illegal)
603 void make_illegal() {
604 set(cannot_simplify);
605 set_type(illegalType);
606 }
608 bool is_illegal() const {
609 return type()->is_illegal();
610 }
612 // generic
613 virtual void input_values_do(ValueVisitor* f) {
614 }
615 };
618 // A local is a placeholder for an incoming argument to a function call.
619 LEAF(Local, Instruction)
620 private:
621 int _java_index; // the local index within the method to which the local belongs
622 public:
623 // creation
624 Local(ValueType* type, int index)
625 : Instruction(type)
626 , _java_index(index)
627 {}
629 // accessors
630 int java_index() const { return _java_index; }
632 // generic
633 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
634 };
637 LEAF(Constant, Instruction)
638 public:
639 // creation
640 Constant(ValueType* type):
641 Instruction(type, NULL, true)
642 {
643 assert(type->is_constant(), "must be a constant");
644 }
646 Constant(ValueType* type, ValueStack* state_before):
647 Instruction(type, state_before, true)
648 {
649 assert(state_before != NULL, "only used for constants which need patching");
650 assert(type->is_constant(), "must be a constant");
651 // since it's patching it needs to be pinned
652 pin();
653 }
655 virtual bool can_trap() const { return state_before() != NULL; }
656 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
658 virtual intx hash() const;
659 virtual bool is_equal(Value v) const;
662 enum CompareResult { not_comparable = -1, cond_false, cond_true };
664 virtual CompareResult compare(Instruction::Condition condition, Value right) const;
665 BlockBegin* compare(Instruction::Condition cond, Value right,
666 BlockBegin* true_sux, BlockBegin* false_sux) const {
667 switch (compare(cond, right)) {
668 case not_comparable:
669 return NULL;
670 case cond_false:
671 return false_sux;
672 case cond_true:
673 return true_sux;
674 default:
675 ShouldNotReachHere();
676 return NULL;
677 }
678 }
679 };
682 BASE(AccessField, Instruction)
683 private:
684 Value _obj;
685 int _offset;
686 ciField* _field;
687 NullCheck* _explicit_null_check; // For explicit null check elimination
689 public:
690 // creation
691 AccessField(Value obj, int offset, ciField* field, bool is_static,
692 ValueStack* state_before, bool is_loaded, bool is_initialized)
693 : Instruction(as_ValueType(field->type()->basic_type()), state_before)
694 , _obj(obj)
695 , _offset(offset)
696 , _field(field)
697 , _explicit_null_check(NULL)
698 {
699 set_needs_null_check(!is_static);
700 set_flag(IsLoadedFlag, is_loaded);
701 set_flag(IsInitializedFlag, is_initialized);
702 set_flag(IsStaticFlag, is_static);
703 ASSERT_VALUES
704 if (!is_loaded || (PatchALot && !field->is_volatile())) {
705 // need to patch if the holder wasn't loaded or we're testing
706 // using PatchALot. Don't allow PatchALot for fields which are
707 // known to be volatile they aren't patchable.
708 set_flag(NeedsPatchingFlag, true);
709 }
710 // pin of all instructions with memory access
711 pin();
712 }
714 // accessors
715 Value obj() const { return _obj; }
716 int offset() const { return _offset; }
717 ciField* field() const { return _field; }
718 BasicType field_type() const { return _field->type()->basic_type(); }
719 bool is_static() const { return check_flag(IsStaticFlag); }
720 bool is_loaded() const { return check_flag(IsLoadedFlag); }
721 bool is_initialized() const { return check_flag(IsInitializedFlag); }
722 NullCheck* explicit_null_check() const { return _explicit_null_check; }
723 bool needs_patching() const { return check_flag(NeedsPatchingFlag); }
725 // manipulation
727 // Under certain circumstances, if a previous NullCheck instruction
728 // proved the target object non-null, we can eliminate the explicit
729 // null check and do an implicit one, simply specifying the debug
730 // information from the NullCheck. This field should only be consulted
731 // if needs_null_check() is true.
732 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
734 // generic
735 virtual bool can_trap() const { return needs_null_check() || needs_patching(); }
736 virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
737 };
740 LEAF(LoadField, AccessField)
741 public:
742 // creation
743 LoadField(Value obj, int offset, ciField* field, bool is_static,
744 ValueStack* state_before, bool is_loaded, bool is_initialized)
745 : AccessField(obj, offset, field, is_static, state_before, is_loaded, is_initialized)
746 {}
748 ciType* declared_type() const;
749 ciType* exact_type() const;
751 // generic
752 HASHING2(LoadField, is_loaded() && !field()->is_volatile(), obj()->subst(), offset()) // cannot be eliminated if not yet loaded or if volatile
753 };
756 LEAF(StoreField, AccessField)
757 private:
758 Value _value;
760 public:
761 // creation
762 StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
763 ValueStack* state_before, bool is_loaded, bool is_initialized)
764 : AccessField(obj, offset, field, is_static, state_before, is_loaded, is_initialized)
765 , _value(value)
766 {
767 set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
768 ASSERT_VALUES
769 pin();
770 }
772 // accessors
773 Value value() const { return _value; }
774 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
776 // generic
777 virtual void input_values_do(ValueVisitor* f) { AccessField::input_values_do(f); f->visit(&_value); }
778 };
781 BASE(AccessArray, Instruction)
782 private:
783 Value _array;
785 public:
786 // creation
787 AccessArray(ValueType* type, Value array, ValueStack* state_before)
788 : Instruction(type, state_before)
789 , _array(array)
790 {
791 set_needs_null_check(true);
792 ASSERT_VALUES
793 pin(); // instruction with side effect (null exception or range check throwing)
794 }
796 Value array() const { return _array; }
798 // generic
799 virtual bool can_trap() const { return needs_null_check(); }
800 virtual void input_values_do(ValueVisitor* f) { f->visit(&_array); }
801 };
804 LEAF(ArrayLength, AccessArray)
805 private:
806 NullCheck* _explicit_null_check; // For explicit null check elimination
808 public:
809 // creation
810 ArrayLength(Value array, ValueStack* state_before)
811 : AccessArray(intType, array, state_before)
812 , _explicit_null_check(NULL) {}
814 // accessors
815 NullCheck* explicit_null_check() const { return _explicit_null_check; }
817 // setters
818 // See LoadField::set_explicit_null_check for documentation
819 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
821 // generic
822 HASHING1(ArrayLength, true, array()->subst())
823 };
826 BASE(AccessIndexed, AccessArray)
827 private:
828 Value _index;
829 Value _length;
830 BasicType _elt_type;
832 public:
833 // creation
834 AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
835 : AccessArray(as_ValueType(elt_type), array, state_before)
836 , _index(index)
837 , _length(length)
838 , _elt_type(elt_type)
839 {
840 ASSERT_VALUES
841 }
843 // accessors
844 Value index() const { return _index; }
845 Value length() const { return _length; }
846 BasicType elt_type() const { return _elt_type; }
848 // perform elimination of range checks involving constants
849 bool compute_needs_range_check();
851 // generic
852 virtual void input_values_do(ValueVisitor* f) { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
853 };
856 LEAF(LoadIndexed, AccessIndexed)
857 private:
858 NullCheck* _explicit_null_check; // For explicit null check elimination
860 public:
861 // creation
862 LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
863 : AccessIndexed(array, index, length, elt_type, state_before)
864 , _explicit_null_check(NULL) {}
866 // accessors
867 NullCheck* explicit_null_check() const { return _explicit_null_check; }
869 // setters
870 // See LoadField::set_explicit_null_check for documentation
871 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
873 ciType* exact_type() const;
874 ciType* declared_type() const;
876 // generic
877 HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
878 };
881 LEAF(StoreIndexed, AccessIndexed)
882 private:
883 Value _value;
885 ciMethod* _profiled_method;
886 int _profiled_bci;
887 public:
888 // creation
889 StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before)
890 : AccessIndexed(array, index, length, elt_type, state_before)
891 , _value(value), _profiled_method(NULL), _profiled_bci(0)
892 {
893 set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
894 set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
895 ASSERT_VALUES
896 pin();
897 }
899 // accessors
900 Value value() const { return _value; }
901 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
902 bool needs_store_check() const { return check_flag(NeedsStoreCheckFlag); }
903 // Helpers for methodDataOop profiling
904 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
905 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
906 void set_profiled_bci(int bci) { _profiled_bci = bci; }
907 bool should_profile() const { return check_flag(ProfileMDOFlag); }
908 ciMethod* profiled_method() const { return _profiled_method; }
909 int profiled_bci() const { return _profiled_bci; }
910 // generic
911 virtual void input_values_do(ValueVisitor* f) { AccessIndexed::input_values_do(f); f->visit(&_value); }
912 };
915 LEAF(NegateOp, Instruction)
916 private:
917 Value _x;
919 public:
920 // creation
921 NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
922 ASSERT_VALUES
923 }
925 // accessors
926 Value x() const { return _x; }
928 // generic
929 virtual void input_values_do(ValueVisitor* f) { f->visit(&_x); }
930 };
933 BASE(Op2, Instruction)
934 private:
935 Bytecodes::Code _op;
936 Value _x;
937 Value _y;
939 public:
940 // creation
941 Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL)
942 : Instruction(type, state_before)
943 , _op(op)
944 , _x(x)
945 , _y(y)
946 {
947 ASSERT_VALUES
948 }
950 // accessors
951 Bytecodes::Code op() const { return _op; }
952 Value x() const { return _x; }
953 Value y() const { return _y; }
955 // manipulators
956 void swap_operands() {
957 assert(is_commutative(), "operation must be commutative");
958 Value t = _x; _x = _y; _y = t;
959 }
961 // generic
962 virtual bool is_commutative() const { return false; }
963 virtual void input_values_do(ValueVisitor* f) { f->visit(&_x); f->visit(&_y); }
964 };
967 LEAF(ArithmeticOp, Op2)
968 public:
969 // creation
970 ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* state_before)
971 : Op2(x->type()->meet(y->type()), op, x, y, state_before)
972 {
973 set_flag(IsStrictfpFlag, is_strictfp);
974 if (can_trap()) pin();
975 }
977 // accessors
978 bool is_strictfp() const { return check_flag(IsStrictfpFlag); }
980 // generic
981 virtual bool is_commutative() const;
982 virtual bool can_trap() const;
983 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
984 };
987 LEAF(ShiftOp, Op2)
988 public:
989 // creation
990 ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
992 // generic
993 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
994 };
997 LEAF(LogicOp, Op2)
998 public:
999 // creation
1000 LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
1002 // generic
1003 virtual bool is_commutative() const;
1004 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1005 };
1008 LEAF(CompareOp, Op2)
1009 public:
1010 // creation
1011 CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1012 : Op2(intType, op, x, y, state_before)
1013 {}
1015 // generic
1016 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1017 };
1020 LEAF(IfOp, Op2)
1021 private:
1022 Value _tval;
1023 Value _fval;
1025 public:
1026 // creation
1027 IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
1028 : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
1029 , _tval(tval)
1030 , _fval(fval)
1031 {
1032 ASSERT_VALUES
1033 assert(tval->type()->tag() == fval->type()->tag(), "types must match");
1034 }
1036 // accessors
1037 virtual bool is_commutative() const;
1038 Bytecodes::Code op() const { ShouldNotCallThis(); return Bytecodes::_illegal; }
1039 Condition cond() const { return (Condition)Op2::op(); }
1040 Value tval() const { return _tval; }
1041 Value fval() const { return _fval; }
1043 // generic
1044 virtual void input_values_do(ValueVisitor* f) { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1045 };
1048 LEAF(Convert, Instruction)
1049 private:
1050 Bytecodes::Code _op;
1051 Value _value;
1053 public:
1054 // creation
1055 Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
1056 ASSERT_VALUES
1057 }
1059 // accessors
1060 Bytecodes::Code op() const { return _op; }
1061 Value value() const { return _value; }
1063 // generic
1064 virtual void input_values_do(ValueVisitor* f) { f->visit(&_value); }
1065 HASHING2(Convert, true, op(), value()->subst())
1066 };
1069 LEAF(NullCheck, Instruction)
1070 private:
1071 Value _obj;
1073 public:
1074 // creation
1075 NullCheck(Value obj, ValueStack* state_before)
1076 : Instruction(obj->type()->base(), state_before)
1077 , _obj(obj)
1078 {
1079 ASSERT_VALUES
1080 set_can_trap(true);
1081 assert(_obj->type()->is_object(), "null check must be applied to objects only");
1082 pin(Instruction::PinExplicitNullCheck);
1083 }
1085 // accessors
1086 Value obj() const { return _obj; }
1088 // setters
1089 void set_can_trap(bool can_trap) { set_flag(CanTrapFlag, can_trap); }
1091 // generic
1092 virtual bool can_trap() const { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
1093 virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
1094 HASHING1(NullCheck, true, obj()->subst())
1095 };
1098 BASE(StateSplit, Instruction)
1099 private:
1100 ValueStack* _state;
1102 protected:
1103 static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
1105 public:
1106 // creation
1107 StateSplit(ValueType* type, ValueStack* state_before = NULL)
1108 : Instruction(type, state_before)
1109 , _state(NULL)
1110 {
1111 pin(PinStateSplitConstructor);
1112 }
1114 // accessors
1115 ValueStack* state() const { return _state; }
1116 IRScope* scope() const; // the state's scope
1118 // manipulation
1119 void set_state(ValueStack* state) { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
1121 // generic
1122 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
1123 virtual void state_values_do(ValueVisitor* f);
1124 };
1127 LEAF(Invoke, StateSplit)
1128 private:
1129 Bytecodes::Code _code;
1130 Value _recv;
1131 Values* _args;
1132 BasicTypeList* _signature;
1133 int _vtable_index;
1134 ciMethod* _target;
1136 public:
1137 // creation
1138 Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
1139 int vtable_index, ciMethod* target, ValueStack* state_before);
1141 // accessors
1142 Bytecodes::Code code() const { return _code; }
1143 Value receiver() const { return _recv; }
1144 bool has_receiver() const { return receiver() != NULL; }
1145 int number_of_arguments() const { return _args->length(); }
1146 Value argument_at(int i) const { return _args->at(i); }
1147 int vtable_index() const { return _vtable_index; }
1148 BasicTypeList* signature() const { return _signature; }
1149 ciMethod* target() const { return _target; }
1151 // Returns false if target is not loaded
1152 bool target_is_final() const { return check_flag(TargetIsFinalFlag); }
1153 bool target_is_loaded() const { return check_flag(TargetIsLoadedFlag); }
1154 // Returns false if target is not loaded
1155 bool target_is_strictfp() const { return check_flag(TargetIsStrictfpFlag); }
1157 // JSR 292 support
1158 bool is_invokedynamic() const { return code() == Bytecodes::_invokedynamic; }
1160 virtual bool needs_exception_state() const { return false; }
1162 // generic
1163 virtual bool can_trap() const { return true; }
1164 virtual void input_values_do(ValueVisitor* f) {
1165 StateSplit::input_values_do(f);
1166 if (has_receiver()) f->visit(&_recv);
1167 for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1168 }
1169 virtual void state_values_do(ValueVisitor *f);
1170 };
1173 LEAF(NewInstance, StateSplit)
1174 private:
1175 ciInstanceKlass* _klass;
1177 public:
1178 // creation
1179 NewInstance(ciInstanceKlass* klass, ValueStack* state_before)
1180 : StateSplit(instanceType, state_before)
1181 , _klass(klass)
1182 {}
1184 // accessors
1185 ciInstanceKlass* klass() const { return _klass; }
1187 virtual bool needs_exception_state() const { return false; }
1189 // generic
1190 virtual bool can_trap() const { return true; }
1191 ciType* exact_type() const;
1192 };
1195 BASE(NewArray, StateSplit)
1196 private:
1197 Value _length;
1199 public:
1200 // creation
1201 NewArray(Value length, ValueStack* state_before)
1202 : StateSplit(objectType, state_before)
1203 , _length(length)
1204 {
1205 // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1206 }
1208 // accessors
1209 Value length() const { return _length; }
1211 virtual bool needs_exception_state() const { return false; }
1213 // generic
1214 virtual bool can_trap() const { return true; }
1215 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_length); }
1216 };
1219 LEAF(NewTypeArray, NewArray)
1220 private:
1221 BasicType _elt_type;
1223 public:
1224 // creation
1225 NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
1226 : NewArray(length, state_before)
1227 , _elt_type(elt_type)
1228 {}
1230 // accessors
1231 BasicType elt_type() const { return _elt_type; }
1232 ciType* exact_type() const;
1233 };
1236 LEAF(NewObjectArray, NewArray)
1237 private:
1238 ciKlass* _klass;
1240 public:
1241 // creation
1242 NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
1244 // accessors
1245 ciKlass* klass() const { return _klass; }
1246 ciType* exact_type() const;
1247 };
1250 LEAF(NewMultiArray, NewArray)
1251 private:
1252 ciKlass* _klass;
1253 Values* _dims;
1255 public:
1256 // creation
1257 NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
1258 ASSERT_VALUES
1259 }
1261 // accessors
1262 ciKlass* klass() const { return _klass; }
1263 Values* dims() const { return _dims; }
1264 int rank() const { return dims()->length(); }
1266 // generic
1267 virtual void input_values_do(ValueVisitor* f) {
1268 // NOTE: we do not call NewArray::input_values_do since "length"
1269 // is meaningless for a multi-dimensional array; passing the
1270 // zeroth element down to NewArray as its length is a bad idea
1271 // since there will be a copy in the "dims" array which doesn't
1272 // get updated, and the value must not be traversed twice. Was bug
1273 // - kbr 4/10/2001
1274 StateSplit::input_values_do(f);
1275 for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
1276 }
1277 };
1280 BASE(TypeCheck, StateSplit)
1281 private:
1282 ciKlass* _klass;
1283 Value _obj;
1285 ciMethod* _profiled_method;
1286 int _profiled_bci;
1288 public:
1289 // creation
1290 TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
1291 : StateSplit(type, state_before), _klass(klass), _obj(obj),
1292 _profiled_method(NULL), _profiled_bci(0) {
1293 ASSERT_VALUES
1294 set_direct_compare(false);
1295 }
1297 // accessors
1298 ciKlass* klass() const { return _klass; }
1299 Value obj() const { return _obj; }
1300 bool is_loaded() const { return klass() != NULL; }
1301 bool direct_compare() const { return check_flag(DirectCompareFlag); }
1303 // manipulation
1304 void set_direct_compare(bool flag) { set_flag(DirectCompareFlag, flag); }
1306 // generic
1307 virtual bool can_trap() const { return true; }
1308 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_obj); }
1310 // Helpers for methodDataOop profiling
1311 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1312 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1313 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1314 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1315 ciMethod* profiled_method() const { return _profiled_method; }
1316 int profiled_bci() const { return _profiled_bci; }
1317 };
1320 LEAF(CheckCast, TypeCheck)
1321 public:
1322 // creation
1323 CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
1324 : TypeCheck(klass, obj, objectType, state_before) {}
1326 void set_incompatible_class_change_check() {
1327 set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
1328 }
1329 bool is_incompatible_class_change_check() const {
1330 return check_flag(ThrowIncompatibleClassChangeErrorFlag);
1331 }
1333 ciType* declared_type() const;
1334 ciType* exact_type() const;
1335 };
1338 LEAF(InstanceOf, TypeCheck)
1339 public:
1340 // creation
1341 InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
1343 virtual bool needs_exception_state() const { return false; }
1344 };
1347 BASE(AccessMonitor, StateSplit)
1348 private:
1349 Value _obj;
1350 int _monitor_no;
1352 public:
1353 // creation
1354 AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
1355 : StateSplit(illegalType, state_before)
1356 , _obj(obj)
1357 , _monitor_no(monitor_no)
1358 {
1359 set_needs_null_check(true);
1360 ASSERT_VALUES
1361 }
1363 // accessors
1364 Value obj() const { return _obj; }
1365 int monitor_no() const { return _monitor_no; }
1367 // generic
1368 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_obj); }
1369 };
1372 LEAF(MonitorEnter, AccessMonitor)
1373 public:
1374 // creation
1375 MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
1376 : AccessMonitor(obj, monitor_no, state_before)
1377 {
1378 ASSERT_VALUES
1379 }
1381 // generic
1382 virtual bool can_trap() const { return true; }
1383 };
1386 LEAF(MonitorExit, AccessMonitor)
1387 public:
1388 // creation
1389 MonitorExit(Value obj, int monitor_no)
1390 : AccessMonitor(obj, monitor_no, NULL)
1391 {
1392 ASSERT_VALUES
1393 }
1394 };
1397 LEAF(Intrinsic, StateSplit)
1398 private:
1399 vmIntrinsics::ID _id;
1400 Values* _args;
1401 Value _recv;
1403 public:
1404 // preserves_state can be set to true for Intrinsics
1405 // which are guaranteed to preserve register state across any slow
1406 // cases; setting it to true does not mean that the Intrinsic can
1407 // not trap, only that if we continue execution in the same basic
1408 // block after the Intrinsic, all of the registers are intact. This
1409 // allows load elimination and common expression elimination to be
1410 // performed across the Intrinsic. The default value is false.
1411 Intrinsic(ValueType* type,
1412 vmIntrinsics::ID id,
1413 Values* args,
1414 bool has_receiver,
1415 ValueStack* state_before,
1416 bool preserves_state,
1417 bool cantrap = true)
1418 : StateSplit(type, state_before)
1419 , _id(id)
1420 , _args(args)
1421 , _recv(NULL)
1422 {
1423 assert(args != NULL, "args must exist");
1424 ASSERT_VALUES
1425 set_flag(PreservesStateFlag, preserves_state);
1426 set_flag(CanTrapFlag, cantrap);
1427 if (has_receiver) {
1428 _recv = argument_at(0);
1429 }
1430 set_needs_null_check(has_receiver);
1432 // some intrinsics can't trap, so don't force them to be pinned
1433 if (!can_trap()) {
1434 unpin(PinStateSplitConstructor);
1435 }
1436 }
1438 // accessors
1439 vmIntrinsics::ID id() const { return _id; }
1440 int number_of_arguments() const { return _args->length(); }
1441 Value argument_at(int i) const { return _args->at(i); }
1443 bool has_receiver() const { return (_recv != NULL); }
1444 Value receiver() const { assert(has_receiver(), "must have receiver"); return _recv; }
1445 bool preserves_state() const { return check_flag(PreservesStateFlag); }
1447 // generic
1448 virtual bool can_trap() const { return check_flag(CanTrapFlag); }
1449 virtual void input_values_do(ValueVisitor* f) {
1450 StateSplit::input_values_do(f);
1451 for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1452 }
1453 };
1456 class LIR_List;
1458 LEAF(BlockBegin, StateSplit)
1459 private:
1460 int _block_id; // the unique block id
1461 int _bci; // start-bci of block
1462 int _depth_first_number; // number of this block in a depth-first ordering
1463 int _linear_scan_number; // number of this block in linear-scan ordering
1464 int _loop_depth; // the loop nesting level of this block
1465 int _loop_index; // number of the innermost loop of this block
1466 int _flags; // the flags associated with this block
1468 // fields used by BlockListBuilder
1469 int _total_preds; // number of predecessors found by BlockListBuilder
1470 BitMap _stores_to_locals; // bit is set when a local variable is stored in the block
1472 // SSA specific fields: (factor out later)
1473 BlockList _successors; // the successors of this block
1474 BlockList _predecessors; // the predecessors of this block
1475 BlockBegin* _dominator; // the dominator of this block
1476 // SSA specific ends
1477 BlockEnd* _end; // the last instruction of this block
1478 BlockList _exception_handlers; // the exception handlers potentially invoked by this block
1479 ValueStackStack* _exception_states; // only for xhandler entries: states of all instructions that have an edge to this xhandler
1480 int _exception_handler_pco; // if this block is the start of an exception handler,
1481 // this records the PC offset in the assembly code of the
1482 // first instruction in this block
1483 Label _label; // the label associated with this block
1484 LIR_List* _lir; // the low level intermediate representation for this block
1486 BitMap _live_in; // set of live LIR_Opr registers at entry to this block
1487 BitMap _live_out; // set of live LIR_Opr registers at exit from this block
1488 BitMap _live_gen; // set of registers used before any redefinition in this block
1489 BitMap _live_kill; // set of registers defined in this block
1491 BitMap _fpu_register_usage;
1492 intArray* _fpu_stack_state; // For x86 FPU code generation with UseLinearScan
1493 int _first_lir_instruction_id; // ID of first LIR instruction in this block
1494 int _last_lir_instruction_id; // ID of last LIR instruction in this block
1496 void iterate_preorder (boolArray& mark, BlockClosure* closure);
1497 void iterate_postorder(boolArray& mark, BlockClosure* closure);
1499 friend class SuxAndWeightAdjuster;
1501 public:
1502 void* operator new(size_t size) {
1503 Compilation* c = Compilation::current();
1504 void* res = c->arena()->Amalloc(size);
1505 ((BlockBegin*)res)->_id = c->get_next_id();
1506 ((BlockBegin*)res)->_block_id = c->get_next_block_id();
1507 return res;
1508 }
1510 // initialization/counting
1511 static int number_of_blocks() {
1512 return Compilation::current()->number_of_blocks();
1513 }
1515 // creation
1516 BlockBegin(int bci)
1517 : StateSplit(illegalType)
1518 , _bci(bci)
1519 , _depth_first_number(-1)
1520 , _linear_scan_number(-1)
1521 , _loop_depth(0)
1522 , _flags(0)
1523 , _dominator(NULL)
1524 , _end(NULL)
1525 , _predecessors(2)
1526 , _successors(2)
1527 , _exception_handlers(1)
1528 , _exception_states(NULL)
1529 , _exception_handler_pco(-1)
1530 , _lir(NULL)
1531 , _loop_index(-1)
1532 , _live_in()
1533 , _live_out()
1534 , _live_gen()
1535 , _live_kill()
1536 , _fpu_register_usage()
1537 , _fpu_stack_state(NULL)
1538 , _first_lir_instruction_id(-1)
1539 , _last_lir_instruction_id(-1)
1540 , _total_preds(0)
1541 , _stores_to_locals()
1542 {
1543 #ifndef PRODUCT
1544 set_printable_bci(bci);
1545 #endif
1546 }
1548 // accessors
1549 int block_id() const { return _block_id; }
1550 int bci() const { return _bci; }
1551 BlockList* successors() { return &_successors; }
1552 BlockBegin* dominator() const { return _dominator; }
1553 int loop_depth() const { return _loop_depth; }
1554 int depth_first_number() const { return _depth_first_number; }
1555 int linear_scan_number() const { return _linear_scan_number; }
1556 BlockEnd* end() const { return _end; }
1557 Label* label() { return &_label; }
1558 LIR_List* lir() const { return _lir; }
1559 int exception_handler_pco() const { return _exception_handler_pco; }
1560 BitMap& live_in() { return _live_in; }
1561 BitMap& live_out() { return _live_out; }
1562 BitMap& live_gen() { return _live_gen; }
1563 BitMap& live_kill() { return _live_kill; }
1564 BitMap& fpu_register_usage() { return _fpu_register_usage; }
1565 intArray* fpu_stack_state() const { return _fpu_stack_state; }
1566 int first_lir_instruction_id() const { return _first_lir_instruction_id; }
1567 int last_lir_instruction_id() const { return _last_lir_instruction_id; }
1568 int total_preds() const { return _total_preds; }
1569 BitMap& stores_to_locals() { return _stores_to_locals; }
1571 // manipulation
1572 void set_dominator(BlockBegin* dom) { _dominator = dom; }
1573 void set_loop_depth(int d) { _loop_depth = d; }
1574 void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
1575 void set_linear_scan_number(int lsn) { _linear_scan_number = lsn; }
1576 void set_end(BlockEnd* end);
1577 void disconnect_from_graph();
1578 static void disconnect_edge(BlockBegin* from, BlockBegin* to);
1579 BlockBegin* insert_block_between(BlockBegin* sux);
1580 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1581 void set_lir(LIR_List* lir) { _lir = lir; }
1582 void set_exception_handler_pco(int pco) { _exception_handler_pco = pco; }
1583 void set_live_in (BitMap map) { _live_in = map; }
1584 void set_live_out (BitMap map) { _live_out = map; }
1585 void set_live_gen (BitMap map) { _live_gen = map; }
1586 void set_live_kill (BitMap map) { _live_kill = map; }
1587 void set_fpu_register_usage(BitMap map) { _fpu_register_usage = map; }
1588 void set_fpu_stack_state(intArray* state) { _fpu_stack_state = state; }
1589 void set_first_lir_instruction_id(int id) { _first_lir_instruction_id = id; }
1590 void set_last_lir_instruction_id(int id) { _last_lir_instruction_id = id; }
1591 void increment_total_preds(int n = 1) { _total_preds += n; }
1592 void init_stores_to_locals(int locals_count) { _stores_to_locals = BitMap(locals_count); _stores_to_locals.clear(); }
1594 // generic
1595 virtual void state_values_do(ValueVisitor* f);
1597 // successors and predecessors
1598 int number_of_sux() const;
1599 BlockBegin* sux_at(int i) const;
1600 void add_successor(BlockBegin* sux);
1601 void remove_successor(BlockBegin* pred);
1602 bool is_successor(BlockBegin* sux) const { return _successors.contains(sux); }
1604 void add_predecessor(BlockBegin* pred);
1605 void remove_predecessor(BlockBegin* pred);
1606 bool is_predecessor(BlockBegin* pred) const { return _predecessors.contains(pred); }
1607 int number_of_preds() const { return _predecessors.length(); }
1608 BlockBegin* pred_at(int i) const { return _predecessors[i]; }
1610 // exception handlers potentially invoked by this block
1611 void add_exception_handler(BlockBegin* b);
1612 bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
1613 int number_of_exception_handlers() const { return _exception_handlers.length(); }
1614 BlockBegin* exception_handler_at(int i) const { return _exception_handlers.at(i); }
1616 // states of the instructions that have an edge to this exception handler
1617 int number_of_exception_states() { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
1618 ValueStack* exception_state_at(int idx) const { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
1619 int add_exception_state(ValueStack* state);
1621 // flags
1622 enum Flag {
1623 no_flag = 0,
1624 std_entry_flag = 1 << 0,
1625 osr_entry_flag = 1 << 1,
1626 exception_entry_flag = 1 << 2,
1627 subroutine_entry_flag = 1 << 3,
1628 backward_branch_target_flag = 1 << 4,
1629 is_on_work_list_flag = 1 << 5,
1630 was_visited_flag = 1 << 6,
1631 parser_loop_header_flag = 1 << 7, // set by parser to identify blocks where phi functions can not be created on demand
1632 critical_edge_split_flag = 1 << 8, // set for all blocks that are introduced when critical edges are split
1633 linear_scan_loop_header_flag = 1 << 9, // set during loop-detection for LinearScan
1634 linear_scan_loop_end_flag = 1 << 10 // set during loop-detection for LinearScan
1635 };
1637 void set(Flag f) { _flags |= f; }
1638 void clear(Flag f) { _flags &= ~f; }
1639 bool is_set(Flag f) const { return (_flags & f) != 0; }
1640 bool is_entry_block() const {
1641 const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
1642 return (_flags & entry_mask) != 0;
1643 }
1645 // iteration
1646 void iterate_preorder (BlockClosure* closure);
1647 void iterate_postorder (BlockClosure* closure);
1649 void block_values_do(ValueVisitor* f);
1651 // loops
1652 void set_loop_index(int ix) { _loop_index = ix; }
1653 int loop_index() const { return _loop_index; }
1655 // merging
1656 bool try_merge(ValueStack* state); // try to merge states at block begin
1657 void merge(ValueStack* state) { bool b = try_merge(state); assert(b, "merge failed"); }
1659 // debugging
1660 void print_block() PRODUCT_RETURN;
1661 void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
1662 };
1665 BASE(BlockEnd, StateSplit)
1666 private:
1667 BlockBegin* _begin;
1668 BlockList* _sux;
1670 protected:
1671 BlockList* sux() const { return _sux; }
1673 void set_sux(BlockList* sux) {
1674 #ifdef ASSERT
1675 assert(sux != NULL, "sux must exist");
1676 for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
1677 #endif
1678 _sux = sux;
1679 }
1681 public:
1682 // creation
1683 BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
1684 : StateSplit(type, state_before)
1685 , _begin(NULL)
1686 , _sux(NULL)
1687 {
1688 set_flag(IsSafepointFlag, is_safepoint);
1689 }
1691 // accessors
1692 bool is_safepoint() const { return check_flag(IsSafepointFlag); }
1693 BlockBegin* begin() const { return _begin; }
1695 // manipulation
1696 void set_begin(BlockBegin* begin);
1698 // successors
1699 int number_of_sux() const { return _sux != NULL ? _sux->length() : 0; }
1700 BlockBegin* sux_at(int i) const { return _sux->at(i); }
1701 BlockBegin* default_sux() const { return sux_at(number_of_sux() - 1); }
1702 BlockBegin** addr_sux_at(int i) const { return _sux->adr_at(i); }
1703 int sux_index(BlockBegin* sux) const { return _sux->find(sux); }
1704 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1705 };
1708 LEAF(Goto, BlockEnd)
1709 public:
1710 enum Direction {
1711 none, // Just a regular goto
1712 taken, not_taken // Goto produced from If
1713 };
1714 private:
1715 ciMethod* _profiled_method;
1716 int _profiled_bci;
1717 Direction _direction;
1718 public:
1719 // creation
1720 Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
1721 : BlockEnd(illegalType, state_before, is_safepoint)
1722 , _direction(none)
1723 , _profiled_method(NULL)
1724 , _profiled_bci(0) {
1725 BlockList* s = new BlockList(1);
1726 s->append(sux);
1727 set_sux(s);
1728 }
1730 Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
1731 , _direction(none)
1732 , _profiled_method(NULL)
1733 , _profiled_bci(0) {
1734 BlockList* s = new BlockList(1);
1735 s->append(sux);
1736 set_sux(s);
1737 }
1739 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1740 ciMethod* profiled_method() const { return _profiled_method; } // set only for profiled branches
1741 int profiled_bci() const { return _profiled_bci; }
1742 Direction direction() const { return _direction; }
1744 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1745 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1746 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1747 void set_direction(Direction d) { _direction = d; }
1748 };
1751 LEAF(If, BlockEnd)
1752 private:
1753 Value _x;
1754 Condition _cond;
1755 Value _y;
1756 ciMethod* _profiled_method;
1757 int _profiled_bci; // Canonicalizer may alter bci of If node
1758 bool _swapped; // Is the order reversed with respect to the original If in the
1759 // bytecode stream?
1760 public:
1761 // creation
1762 // unordered_is_true is valid for float/double compares only
1763 If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
1764 : BlockEnd(illegalType, state_before, is_safepoint)
1765 , _x(x)
1766 , _cond(cond)
1767 , _y(y)
1768 , _profiled_method(NULL)
1769 , _profiled_bci(0)
1770 , _swapped(false)
1771 {
1772 ASSERT_VALUES
1773 set_flag(UnorderedIsTrueFlag, unordered_is_true);
1774 assert(x->type()->tag() == y->type()->tag(), "types must match");
1775 BlockList* s = new BlockList(2);
1776 s->append(tsux);
1777 s->append(fsux);
1778 set_sux(s);
1779 }
1781 // accessors
1782 Value x() const { return _x; }
1783 Condition cond() const { return _cond; }
1784 bool unordered_is_true() const { return check_flag(UnorderedIsTrueFlag); }
1785 Value y() const { return _y; }
1786 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
1787 BlockBegin* tsux() const { return sux_for(true); }
1788 BlockBegin* fsux() const { return sux_for(false); }
1789 BlockBegin* usux() const { return sux_for(unordered_is_true()); }
1790 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1791 ciMethod* profiled_method() const { return _profiled_method; } // set only for profiled branches
1792 int profiled_bci() const { return _profiled_bci; } // set for profiled branches and tiered
1793 bool is_swapped() const { return _swapped; }
1795 // manipulation
1796 void swap_operands() {
1797 Value t = _x; _x = _y; _y = t;
1798 _cond = mirror(_cond);
1799 }
1801 void swap_sux() {
1802 assert(number_of_sux() == 2, "wrong number of successors");
1803 BlockList* s = sux();
1804 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
1805 _cond = negate(_cond);
1806 set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
1807 }
1809 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1810 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1811 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1812 void set_swapped(bool value) { _swapped = value; }
1813 // generic
1814 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
1815 };
1818 LEAF(IfInstanceOf, BlockEnd)
1819 private:
1820 ciKlass* _klass;
1821 Value _obj;
1822 bool _test_is_instance; // jump if instance
1823 int _instanceof_bci;
1825 public:
1826 IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
1827 : BlockEnd(illegalType, NULL, false) // temporary set to false
1828 , _klass(klass)
1829 , _obj(obj)
1830 , _test_is_instance(test_is_instance)
1831 , _instanceof_bci(instanceof_bci)
1832 {
1833 ASSERT_VALUES
1834 assert(instanceof_bci >= 0, "illegal bci");
1835 BlockList* s = new BlockList(2);
1836 s->append(tsux);
1837 s->append(fsux);
1838 set_sux(s);
1839 }
1841 // accessors
1842 //
1843 // Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
1844 // instance of klass; otherwise it tests if it is *not* and instance
1845 // of klass.
1846 //
1847 // Note 2: IfInstanceOf instructions are created by combining an InstanceOf
1848 // and an If instruction. The IfInstanceOf bci() corresponds to the
1849 // bci that the If would have had; the (this->) instanceof_bci() is
1850 // the bci of the original InstanceOf instruction.
1851 ciKlass* klass() const { return _klass; }
1852 Value obj() const { return _obj; }
1853 int instanceof_bci() const { return _instanceof_bci; }
1854 bool test_is_instance() const { return _test_is_instance; }
1855 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
1856 BlockBegin* tsux() const { return sux_for(true); }
1857 BlockBegin* fsux() const { return sux_for(false); }
1859 // manipulation
1860 void swap_sux() {
1861 assert(number_of_sux() == 2, "wrong number of successors");
1862 BlockList* s = sux();
1863 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
1864 _test_is_instance = !_test_is_instance;
1865 }
1867 // generic
1868 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_obj); }
1869 };
1872 BASE(Switch, BlockEnd)
1873 private:
1874 Value _tag;
1876 public:
1877 // creation
1878 Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
1879 : BlockEnd(illegalType, state_before, is_safepoint)
1880 , _tag(tag) {
1881 ASSERT_VALUES
1882 set_sux(sux);
1883 }
1885 // accessors
1886 Value tag() const { return _tag; }
1887 int length() const { return number_of_sux() - 1; }
1889 virtual bool needs_exception_state() const { return false; }
1891 // generic
1892 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_tag); }
1893 };
1896 LEAF(TableSwitch, Switch)
1897 private:
1898 int _lo_key;
1900 public:
1901 // creation
1902 TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
1903 : Switch(tag, sux, state_before, is_safepoint)
1904 , _lo_key(lo_key) {}
1906 // accessors
1907 int lo_key() const { return _lo_key; }
1908 int hi_key() const { return _lo_key + length() - 1; }
1909 };
1912 LEAF(LookupSwitch, Switch)
1913 private:
1914 intArray* _keys;
1916 public:
1917 // creation
1918 LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
1919 : Switch(tag, sux, state_before, is_safepoint)
1920 , _keys(keys) {
1921 assert(keys != NULL, "keys must exist");
1922 assert(keys->length() == length(), "sux & keys have incompatible lengths");
1923 }
1925 // accessors
1926 int key_at(int i) const { return _keys->at(i); }
1927 };
1930 LEAF(Return, BlockEnd)
1931 private:
1932 Value _result;
1934 public:
1935 // creation
1936 Return(Value result) :
1937 BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
1938 _result(result) {}
1940 // accessors
1941 Value result() const { return _result; }
1942 bool has_result() const { return result() != NULL; }
1944 // generic
1945 virtual void input_values_do(ValueVisitor* f) {
1946 BlockEnd::input_values_do(f);
1947 if (has_result()) f->visit(&_result);
1948 }
1949 };
1952 LEAF(Throw, BlockEnd)
1953 private:
1954 Value _exception;
1956 public:
1957 // creation
1958 Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
1959 ASSERT_VALUES
1960 }
1962 // accessors
1963 Value exception() const { return _exception; }
1965 // generic
1966 virtual bool can_trap() const { return true; }
1967 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_exception); }
1968 };
1971 LEAF(Base, BlockEnd)
1972 public:
1973 // creation
1974 Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
1975 assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
1976 assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
1977 BlockList* s = new BlockList(2);
1978 if (osr_entry != NULL) s->append(osr_entry);
1979 s->append(std_entry); // must be default sux!
1980 set_sux(s);
1981 }
1983 // accessors
1984 BlockBegin* std_entry() const { return default_sux(); }
1985 BlockBegin* osr_entry() const { return number_of_sux() < 2 ? NULL : sux_at(0); }
1986 };
1989 LEAF(OsrEntry, Instruction)
1990 public:
1991 // creation
1992 #ifdef _LP64
1993 OsrEntry() : Instruction(longType) { pin(); }
1994 #else
1995 OsrEntry() : Instruction(intType) { pin(); }
1996 #endif
1998 // generic
1999 virtual void input_values_do(ValueVisitor* f) { }
2000 };
2003 // Models the incoming exception at a catch site
2004 LEAF(ExceptionObject, Instruction)
2005 public:
2006 // creation
2007 ExceptionObject() : Instruction(objectType) {
2008 pin();
2009 }
2011 // generic
2012 virtual void input_values_do(ValueVisitor* f) { }
2013 };
2016 // Models needed rounding for floating-point values on Intel.
2017 // Currently only used to represent rounding of double-precision
2018 // values stored into local variables, but could be used to model
2019 // intermediate rounding of single-precision values as well.
2020 LEAF(RoundFP, Instruction)
2021 private:
2022 Value _input; // floating-point value to be rounded
2024 public:
2025 RoundFP(Value input)
2026 : Instruction(input->type()) // Note: should not be used for constants
2027 , _input(input)
2028 {
2029 ASSERT_VALUES
2030 }
2032 // accessors
2033 Value input() const { return _input; }
2035 // generic
2036 virtual void input_values_do(ValueVisitor* f) { f->visit(&_input); }
2037 };
2040 BASE(UnsafeOp, Instruction)
2041 private:
2042 BasicType _basic_type; // ValueType can not express byte-sized integers
2044 protected:
2045 // creation
2046 UnsafeOp(BasicType basic_type, bool is_put)
2047 : Instruction(is_put ? voidType : as_ValueType(basic_type))
2048 , _basic_type(basic_type)
2049 {
2050 //Note: Unsafe ops are not not guaranteed to throw NPE.
2051 // Convservatively, Unsafe operations must be pinned though we could be
2052 // looser about this if we wanted to..
2053 pin();
2054 }
2056 public:
2057 // accessors
2058 BasicType basic_type() { return _basic_type; }
2060 // generic
2061 virtual void input_values_do(ValueVisitor* f) { }
2062 };
2065 BASE(UnsafeRawOp, UnsafeOp)
2066 private:
2067 Value _base; // Base address (a Java long)
2068 Value _index; // Index if computed by optimizer; initialized to NULL
2069 int _log2_scale; // Scale factor: 0, 1, 2, or 3.
2070 // Indicates log2 of number of bytes (1, 2, 4, or 8)
2071 // to scale index by.
2073 protected:
2074 UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
2075 : UnsafeOp(basic_type, is_put)
2076 , _base(addr)
2077 , _index(NULL)
2078 , _log2_scale(0)
2079 {
2080 // Can not use ASSERT_VALUES because index may be NULL
2081 assert(addr != NULL && addr->type()->is_long(), "just checking");
2082 }
2084 UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
2085 : UnsafeOp(basic_type, is_put)
2086 , _base(base)
2087 , _index(index)
2088 , _log2_scale(log2_scale)
2089 {
2090 }
2092 public:
2093 // accessors
2094 Value base() { return _base; }
2095 Value index() { return _index; }
2096 bool has_index() { return (_index != NULL); }
2097 int log2_scale() { return _log2_scale; }
2099 // setters
2100 void set_base (Value base) { _base = base; }
2101 void set_index(Value index) { _index = index; }
2102 void set_log2_scale(int log2_scale) { _log2_scale = log2_scale; }
2104 // generic
2105 virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
2106 f->visit(&_base);
2107 if (has_index()) f->visit(&_index); }
2108 };
2111 LEAF(UnsafeGetRaw, UnsafeRawOp)
2112 private:
2113 bool _may_be_unaligned; // For OSREntry
2115 public:
2116 UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned)
2117 : UnsafeRawOp(basic_type, addr, false) {
2118 _may_be_unaligned = may_be_unaligned;
2119 }
2121 UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned)
2122 : UnsafeRawOp(basic_type, base, index, log2_scale, false) {
2123 _may_be_unaligned = may_be_unaligned;
2124 }
2126 bool may_be_unaligned() { return _may_be_unaligned; }
2127 };
2130 LEAF(UnsafePutRaw, UnsafeRawOp)
2131 private:
2132 Value _value; // Value to be stored
2134 public:
2135 UnsafePutRaw(BasicType basic_type, Value addr, Value value)
2136 : UnsafeRawOp(basic_type, addr, true)
2137 , _value(value)
2138 {
2139 assert(value != NULL, "just checking");
2140 ASSERT_VALUES
2141 }
2143 UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
2144 : UnsafeRawOp(basic_type, base, index, log2_scale, true)
2145 , _value(value)
2146 {
2147 assert(value != NULL, "just checking");
2148 ASSERT_VALUES
2149 }
2151 // accessors
2152 Value value() { return _value; }
2154 // generic
2155 virtual void input_values_do(ValueVisitor* f) { UnsafeRawOp::input_values_do(f);
2156 f->visit(&_value); }
2157 };
2160 BASE(UnsafeObjectOp, UnsafeOp)
2161 private:
2162 Value _object; // Object to be fetched from or mutated
2163 Value _offset; // Offset within object
2164 bool _is_volatile; // true if volatile - dl/JSR166
2165 public:
2166 UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
2167 : UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
2168 {
2169 }
2171 // accessors
2172 Value object() { return _object; }
2173 Value offset() { return _offset; }
2174 bool is_volatile() { return _is_volatile; }
2175 // generic
2176 virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
2177 f->visit(&_object);
2178 f->visit(&_offset); }
2179 };
2182 LEAF(UnsafeGetObject, UnsafeObjectOp)
2183 public:
2184 UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
2185 : UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
2186 {
2187 ASSERT_VALUES
2188 }
2189 };
2192 LEAF(UnsafePutObject, UnsafeObjectOp)
2193 private:
2194 Value _value; // Value to be stored
2195 public:
2196 UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
2197 : UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
2198 , _value(value)
2199 {
2200 ASSERT_VALUES
2201 }
2203 // accessors
2204 Value value() { return _value; }
2206 // generic
2207 virtual void input_values_do(ValueVisitor* f) { UnsafeObjectOp::input_values_do(f);
2208 f->visit(&_value); }
2209 };
2212 BASE(UnsafePrefetch, UnsafeObjectOp)
2213 public:
2214 UnsafePrefetch(Value object, Value offset)
2215 : UnsafeObjectOp(T_VOID, object, offset, false, false)
2216 {
2217 }
2218 };
2221 LEAF(UnsafePrefetchRead, UnsafePrefetch)
2222 public:
2223 UnsafePrefetchRead(Value object, Value offset)
2224 : UnsafePrefetch(object, offset)
2225 {
2226 ASSERT_VALUES
2227 }
2228 };
2231 LEAF(UnsafePrefetchWrite, UnsafePrefetch)
2232 public:
2233 UnsafePrefetchWrite(Value object, Value offset)
2234 : UnsafePrefetch(object, offset)
2235 {
2236 ASSERT_VALUES
2237 }
2238 };
2240 LEAF(ProfileCall, Instruction)
2241 private:
2242 ciMethod* _method;
2243 int _bci_of_invoke;
2244 Value _recv;
2245 ciKlass* _known_holder;
2247 public:
2248 ProfileCall(ciMethod* method, int bci, Value recv, ciKlass* known_holder)
2249 : Instruction(voidType)
2250 , _method(method)
2251 , _bci_of_invoke(bci)
2252 , _recv(recv)
2253 , _known_holder(known_holder)
2254 {
2255 // The ProfileCall has side-effects and must occur precisely where located
2256 pin();
2257 }
2259 ciMethod* method() { return _method; }
2260 int bci_of_invoke() { return _bci_of_invoke; }
2261 Value recv() { return _recv; }
2262 ciKlass* known_holder() { return _known_holder; }
2264 virtual void input_values_do(ValueVisitor* f) { if (_recv != NULL) f->visit(&_recv); }
2265 };
2267 // Use to trip invocation counter of an inlined method
2269 LEAF(ProfileInvoke, Instruction)
2270 private:
2271 ciMethod* _inlinee;
2272 ValueStack* _state;
2274 public:
2275 ProfileInvoke(ciMethod* inlinee, ValueStack* state)
2276 : Instruction(voidType)
2277 , _inlinee(inlinee)
2278 , _state(state)
2279 {
2280 // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
2281 pin();
2282 }
2284 ciMethod* inlinee() { return _inlinee; }
2285 ValueStack* state() { return _state; }
2286 virtual void input_values_do(ValueVisitor*) {}
2287 virtual void state_values_do(ValueVisitor*);
2288 };
2290 class BlockPair: public CompilationResourceObj {
2291 private:
2292 BlockBegin* _from;
2293 BlockBegin* _to;
2294 public:
2295 BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
2296 BlockBegin* from() const { return _from; }
2297 BlockBegin* to() const { return _to; }
2298 bool is_same(BlockBegin* from, BlockBegin* to) const { return _from == from && _to == to; }
2299 bool is_same(BlockPair* p) const { return _from == p->from() && _to == p->to(); }
2300 void set_to(BlockBegin* b) { _to = b; }
2301 void set_from(BlockBegin* b) { _from = b; }
2302 };
2305 define_array(BlockPairArray, BlockPair*)
2306 define_stack(BlockPairList, BlockPairArray)
2309 inline int BlockBegin::number_of_sux() const { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
2310 inline BlockBegin* BlockBegin::sux_at(int i) const { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch"); return _successors.at(i); }
2311 inline void BlockBegin::add_successor(BlockBegin* sux) { assert(_end == NULL, "Would create mismatch with successors of BlockEnd"); _successors.append(sux); }
2313 #undef ASSERT_VALUES
2315 #endif // SHARE_VM_C1_C1_INSTRUCTION_HPP