Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
1 /*
2 * Copyright (c) 2005, 2011, 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_LIRGENERATOR_HPP
26 #define SHARE_VM_C1_C1_LIRGENERATOR_HPP
28 #include "c1/c1_Instruction.hpp"
29 #include "c1/c1_LIR.hpp"
30 #include "ci/ciMethodData.hpp"
31 #include "utilities/sizes.hpp"
33 // The classes responsible for code emission and register allocation
36 class LIRGenerator;
37 class LIREmitter;
38 class Invoke;
39 class SwitchRange;
40 class LIRItem;
42 define_array(LIRItemArray, LIRItem*)
43 define_stack(LIRItemList, LIRItemArray)
45 class SwitchRange: public CompilationResourceObj {
46 private:
47 int _low_key;
48 int _high_key;
49 BlockBegin* _sux;
50 public:
51 SwitchRange(int start_key, BlockBegin* sux): _low_key(start_key), _high_key(start_key), _sux(sux) {}
52 void set_high_key(int key) { _high_key = key; }
54 int high_key() const { return _high_key; }
55 int low_key() const { return _low_key; }
56 BlockBegin* sux() const { return _sux; }
57 };
59 define_array(SwitchRangeArray, SwitchRange*)
60 define_stack(SwitchRangeList, SwitchRangeArray)
63 class ResolveNode;
65 define_array(NodeArray, ResolveNode*);
66 define_stack(NodeList, NodeArray);
69 // Node objects form a directed graph of LIR_Opr
70 // Edges between Nodes represent moves from one Node to its destinations
71 class ResolveNode: public CompilationResourceObj {
72 private:
73 LIR_Opr _operand; // the source or destinaton
74 NodeList _destinations; // for the operand
75 bool _assigned; // Value assigned to this Node?
76 bool _visited; // Node already visited?
77 bool _start_node; // Start node already visited?
79 public:
80 ResolveNode(LIR_Opr operand)
81 : _operand(operand)
82 , _assigned(false)
83 , _visited(false)
84 , _start_node(false) {};
86 // accessors
87 LIR_Opr operand() const { return _operand; }
88 int no_of_destinations() const { return _destinations.length(); }
89 ResolveNode* destination_at(int i) { return _destinations[i]; }
90 bool assigned() const { return _assigned; }
91 bool visited() const { return _visited; }
92 bool start_node() const { return _start_node; }
94 // modifiers
95 void append(ResolveNode* dest) { _destinations.append(dest); }
96 void set_assigned() { _assigned = true; }
97 void set_visited() { _visited = true; }
98 void set_start_node() { _start_node = true; }
99 };
102 // This is shared state to be used by the PhiResolver so the operand
103 // arrays don't have to be reallocated for reach resolution.
104 class PhiResolverState: public CompilationResourceObj {
105 friend class PhiResolver;
107 private:
108 NodeList _virtual_operands; // Nodes where the operand is a virtual register
109 NodeList _other_operands; // Nodes where the operand is not a virtual register
110 NodeList _vreg_table; // Mapping from virtual register to Node
112 public:
113 PhiResolverState() {}
115 void reset(int max_vregs);
116 };
119 // class used to move value of phi operand to phi function
120 class PhiResolver: public CompilationResourceObj {
121 private:
122 LIRGenerator* _gen;
123 PhiResolverState& _state; // temporary state cached by LIRGenerator
125 ResolveNode* _loop;
126 LIR_Opr _temp;
128 // access to shared state arrays
129 NodeList& virtual_operands() { return _state._virtual_operands; }
130 NodeList& other_operands() { return _state._other_operands; }
131 NodeList& vreg_table() { return _state._vreg_table; }
133 ResolveNode* create_node(LIR_Opr opr, bool source);
134 ResolveNode* source_node(LIR_Opr opr) { return create_node(opr, true); }
135 ResolveNode* destination_node(LIR_Opr opr) { return create_node(opr, false); }
137 void emit_move(LIR_Opr src, LIR_Opr dest);
138 void move_to_temp(LIR_Opr src);
139 void move_temp_to(LIR_Opr dest);
140 void move(ResolveNode* src, ResolveNode* dest);
142 LIRGenerator* gen() {
143 return _gen;
144 }
146 public:
147 PhiResolver(LIRGenerator* _lir_gen, int max_vregs);
148 ~PhiResolver();
150 void move(LIR_Opr src, LIR_Opr dest);
151 };
154 // only the classes below belong in the same file
155 class LIRGenerator: public InstructionVisitor, public BlockClosure {
157 private:
158 Compilation* _compilation;
159 ciMethod* _method; // method that we are compiling
160 PhiResolverState _resolver_state;
161 BlockBegin* _block;
162 int _virtual_register_number;
163 Values _instruction_for_operand;
164 BitMap2D _vreg_flags; // flags which can be set on a per-vreg basis
165 LIR_List* _lir;
166 BarrierSet* _bs;
168 LIRGenerator* gen() {
169 return this;
170 }
172 #ifdef ASSERT
173 LIR_List* lir(const char * file, int line) const {
174 _lir->set_file_and_line(file, line);
175 return _lir;
176 }
177 #endif
178 LIR_List* lir() const {
179 return _lir;
180 }
182 // a simple cache of constants used within a block
183 GrowableArray<LIR_Const*> _constants;
184 LIR_OprList _reg_for_constants;
185 Values _unpinned_constants;
187 friend class PhiResolver;
189 // unified bailout support
190 void bailout(const char* msg) const { compilation()->bailout(msg); }
191 bool bailed_out() const { return compilation()->bailed_out(); }
193 void block_do_prolog(BlockBegin* block);
194 void block_do_epilog(BlockBegin* block);
196 // register allocation
197 LIR_Opr rlock(Value instr); // lock a free register
198 LIR_Opr rlock_result(Value instr);
199 LIR_Opr rlock_result(Value instr, BasicType type);
200 LIR_Opr rlock_byte(BasicType type);
201 LIR_Opr rlock_callee_saved(BasicType type);
203 // get a constant into a register and get track of what register was used
204 LIR_Opr load_constant(Constant* x);
205 LIR_Opr load_constant(LIR_Const* constant);
207 // Given an immediate value, return an operand usable in logical ops.
208 LIR_Opr load_immediate(int x, BasicType type);
210 void set_result(Value x, LIR_Opr opr) {
211 assert(opr->is_valid(), "must set to valid value");
212 assert(x->operand()->is_illegal(), "operand should never change");
213 assert(!opr->is_register() || opr->is_virtual(), "should never set result to a physical register");
214 x->set_operand(opr);
215 assert(opr == x->operand(), "must be");
216 if (opr->is_virtual()) {
217 _instruction_for_operand.at_put_grow(opr->vreg_number(), x, NULL);
218 }
219 }
220 void set_no_result(Value x) { assert(!x->has_uses(), "can't have use"); x->clear_operand(); }
222 friend class LIRItem;
224 LIR_Opr round_item(LIR_Opr opr);
225 LIR_Opr force_to_spill(LIR_Opr value, BasicType t);
227 PhiResolverState& resolver_state() { return _resolver_state; }
229 void move_to_phi(PhiResolver* resolver, Value cur_val, Value sux_val);
230 void move_to_phi(ValueStack* cur_state);
232 // code emission
233 void do_ArithmeticOp_Long (ArithmeticOp* x);
234 void do_ArithmeticOp_Int (ArithmeticOp* x);
235 void do_ArithmeticOp_FPU (ArithmeticOp* x);
237 // platform dependent
238 LIR_Opr getThreadPointer();
240 void do_RegisterFinalizer(Intrinsic* x);
241 void do_getClass(Intrinsic* x);
242 void do_currentThread(Intrinsic* x);
243 void do_MathIntrinsic(Intrinsic* x);
244 void do_ArrayCopy(Intrinsic* x);
245 void do_CompareAndSwap(Intrinsic* x, ValueType* type);
246 void do_AttemptUpdate(Intrinsic* x);
247 void do_NIOCheckIndex(Intrinsic* x);
248 void do_FPIntrinsics(Intrinsic* x);
249 void do_Reference_get(Intrinsic* x);
251 void do_UnsafePrefetch(UnsafePrefetch* x, bool is_store);
253 LIR_Opr call_runtime(BasicTypeArray* signature, LIRItemList* args, address entry, ValueType* result_type, CodeEmitInfo* info);
254 LIR_Opr call_runtime(BasicTypeArray* signature, LIR_OprList* args, address entry, ValueType* result_type, CodeEmitInfo* info);
256 // convenience functions
257 LIR_Opr call_runtime(Value arg1, address entry, ValueType* result_type, CodeEmitInfo* info);
258 LIR_Opr call_runtime(Value arg1, Value arg2, address entry, ValueType* result_type, CodeEmitInfo* info);
260 // GC Barriers
262 // generic interface
264 void pre_barrier(LIR_Opr addr_opr, LIR_Opr pre_val, bool do_load, bool patch, CodeEmitInfo* info);
265 void post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val);
267 // specific implementations
268 // pre barriers
270 void G1SATBCardTableModRef_pre_barrier(LIR_Opr addr_opr, LIR_Opr pre_val,
271 bool do_load, bool patch, CodeEmitInfo* info);
273 // post barriers
275 void G1SATBCardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val);
276 void CardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val);
279 static LIR_Opr result_register_for(ValueType* type, bool callee = false);
281 ciObject* get_jobject_constant(Value value);
283 LIRItemList* invoke_visit_arguments(Invoke* x);
284 void invoke_load_arguments(Invoke* x, LIRItemList* args, const LIR_OprList* arg_list);
286 void trace_block_entry(BlockBegin* block);
288 // volatile field operations are never patchable because a klass
289 // must be loaded to know it's volatile which means that the offset
290 // it always known as well.
291 void volatile_field_store(LIR_Opr value, LIR_Address* address, CodeEmitInfo* info);
292 void volatile_field_load(LIR_Address* address, LIR_Opr result, CodeEmitInfo* info);
294 void put_Object_unsafe(LIR_Opr src, LIR_Opr offset, LIR_Opr data, BasicType type, bool is_volatile);
295 void get_Object_unsafe(LIR_Opr dest, LIR_Opr src, LIR_Opr offset, BasicType type, bool is_volatile);
297 void arithmetic_call_op (Bytecodes::Code code, LIR_Opr result, LIR_OprList* args);
299 void increment_counter(address counter, BasicType type, int step = 1);
300 void increment_counter(LIR_Address* addr, int step = 1);
302 // is_strictfp is only needed for mul and div (and only generates different code on i486)
303 void arithmetic_op(Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, bool is_strictfp, LIR_Opr tmp, CodeEmitInfo* info = NULL);
304 // machine dependent. returns true if it emitted code for the multiply
305 bool strength_reduce_multiply(LIR_Opr left, int constant, LIR_Opr result, LIR_Opr tmp);
307 void store_stack_parameter (LIR_Opr opr, ByteSize offset_from_sp_in_bytes);
309 void jobject2reg_with_patching(LIR_Opr r, ciObject* obj, CodeEmitInfo* info);
311 // this loads the length and compares against the index
312 void array_range_check (LIR_Opr array, LIR_Opr index, CodeEmitInfo* null_check_info, CodeEmitInfo* range_check_info);
313 // For java.nio.Buffer.checkIndex
314 void nio_range_check (LIR_Opr buffer, LIR_Opr index, LIR_Opr result, CodeEmitInfo* info);
316 void arithmetic_op_int (Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, LIR_Opr tmp);
317 void arithmetic_op_long (Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, CodeEmitInfo* info = NULL);
318 void arithmetic_op_fpu (Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, bool is_strictfp, LIR_Opr tmp = LIR_OprFact::illegalOpr);
320 void shift_op (Bytecodes::Code code, LIR_Opr dst_reg, LIR_Opr value, LIR_Opr count, LIR_Opr tmp);
322 void logic_op (Bytecodes::Code code, LIR_Opr dst_reg, LIR_Opr left, LIR_Opr right);
324 void monitor_enter (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no, CodeEmitInfo* info_for_exception, CodeEmitInfo* info);
325 void monitor_exit (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no);
327 void new_instance (LIR_Opr dst, ciInstanceKlass* klass, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info);
329 // machine dependent
330 void cmp_mem_int(LIR_Condition condition, LIR_Opr base, int disp, int c, CodeEmitInfo* info);
331 void cmp_reg_mem(LIR_Condition condition, LIR_Opr reg, LIR_Opr base, int disp, BasicType type, CodeEmitInfo* info);
332 void cmp_reg_mem(LIR_Condition condition, LIR_Opr reg, LIR_Opr base, LIR_Opr disp, BasicType type, CodeEmitInfo* info);
334 void arraycopy_helper(Intrinsic* x, int* flags, ciArrayKlass** expected_type);
336 // returns a LIR_Address to address an array location. May also
337 // emit some code as part of address calculation. If
338 // needs_card_mark is true then compute the full address for use by
339 // both the store and the card mark.
340 LIR_Address* generate_address(LIR_Opr base,
341 LIR_Opr index, int shift,
342 int disp,
343 BasicType type);
344 LIR_Address* generate_address(LIR_Opr base, int disp, BasicType type) {
345 return generate_address(base, LIR_OprFact::illegalOpr, 0, disp, type);
346 }
347 LIR_Address* emit_array_address(LIR_Opr array_opr, LIR_Opr index_opr, BasicType type, bool needs_card_mark);
349 // the helper for generate_address
350 void add_large_constant(LIR_Opr src, int c, LIR_Opr dest);
352 // machine preferences and characteristics
353 bool can_inline_as_constant(Value i) const;
354 bool can_inline_as_constant(LIR_Const* c) const;
355 bool can_store_as_constant(Value i, BasicType type) const;
357 LIR_Opr safepoint_poll_register();
359 void profile_branch(If* if_instr, If::Condition cond);
360 void increment_event_counter_impl(CodeEmitInfo* info,
361 ciMethod *method, int frequency,
362 int bci, bool backedge, bool notify);
363 void increment_event_counter(CodeEmitInfo* info, int bci, bool backedge);
364 void increment_invocation_counter(CodeEmitInfo *info) {
365 if (compilation()->count_invocations()) {
366 increment_event_counter(info, InvocationEntryBci, false);
367 }
368 }
369 void increment_backedge_counter(CodeEmitInfo* info, int bci) {
370 if (compilation()->count_backedges()) {
371 increment_event_counter(info, bci, true);
372 }
373 }
375 CodeEmitInfo* state_for(Instruction* x, ValueStack* state, bool ignore_xhandler = false);
376 CodeEmitInfo* state_for(Instruction* x);
378 // allocates a virtual register for this instruction if
379 // one isn't already allocated. Only for Phi and Local.
380 LIR_Opr operand_for_instruction(Instruction *x);
382 void set_block(BlockBegin* block) { _block = block; }
384 void block_prolog(BlockBegin* block);
385 void block_epilog(BlockBegin* block);
387 void do_root (Instruction* instr);
388 void walk (Instruction* instr);
390 void bind_block_entry(BlockBegin* block);
391 void start_block(BlockBegin* block);
393 LIR_Opr new_register(BasicType type);
394 LIR_Opr new_register(Value value) { return new_register(as_BasicType(value->type())); }
395 LIR_Opr new_register(ValueType* type) { return new_register(as_BasicType(type)); }
397 // returns a register suitable for doing pointer math
398 LIR_Opr new_pointer_register() {
399 #ifdef _LP64
400 return new_register(T_LONG);
401 #else
402 return new_register(T_INT);
403 #endif
404 }
406 static LIR_Condition lir_cond(If::Condition cond) {
407 LIR_Condition l;
408 switch (cond) {
409 case If::eql: l = lir_cond_equal; break;
410 case If::neq: l = lir_cond_notEqual; break;
411 case If::lss: l = lir_cond_less; break;
412 case If::leq: l = lir_cond_lessEqual; break;
413 case If::geq: l = lir_cond_greaterEqual; break;
414 case If::gtr: l = lir_cond_greater; break;
415 };
416 return l;
417 }
419 #ifdef __SOFTFP__
420 void do_soft_float_compare(If *x);
421 #endif // __SOFTFP__
423 void init();
425 SwitchRangeArray* create_lookup_ranges(TableSwitch* x);
426 SwitchRangeArray* create_lookup_ranges(LookupSwitch* x);
427 void do_SwitchRanges(SwitchRangeArray* x, LIR_Opr value, BlockBegin* default_sux);
429 public:
430 Compilation* compilation() const { return _compilation; }
431 FrameMap* frame_map() const { return _compilation->frame_map(); }
432 ciMethod* method() const { return _method; }
433 BlockBegin* block() const { return _block; }
434 IRScope* scope() const { return block()->scope(); }
436 int max_virtual_register_number() const { return _virtual_register_number; }
438 void block_do(BlockBegin* block);
440 // Flags that can be set on vregs
441 enum VregFlag {
442 must_start_in_memory = 0 // needs to be assigned a memory location at beginning, but may then be loaded in a register
443 , callee_saved = 1 // must be in a callee saved register
444 , byte_reg = 2 // must be in a byte register
445 , num_vreg_flags
447 };
449 LIRGenerator(Compilation* compilation, ciMethod* method)
450 : _compilation(compilation)
451 , _method(method)
452 , _virtual_register_number(LIR_OprDesc::vreg_base)
453 , _vreg_flags(NULL, 0, num_vreg_flags) {
454 init();
455 }
457 // for virtual registers, maps them back to Phi's or Local's
458 Instruction* instruction_for_opr(LIR_Opr opr);
459 Instruction* instruction_for_vreg(int reg_num);
461 void set_vreg_flag (int vreg_num, VregFlag f);
462 bool is_vreg_flag_set(int vreg_num, VregFlag f);
463 void set_vreg_flag (LIR_Opr opr, VregFlag f) { set_vreg_flag(opr->vreg_number(), f); }
464 bool is_vreg_flag_set(LIR_Opr opr, VregFlag f) { return is_vreg_flag_set(opr->vreg_number(), f); }
466 // statics
467 static LIR_Opr exceptionOopOpr();
468 static LIR_Opr exceptionPcOpr();
469 static LIR_Opr divInOpr();
470 static LIR_Opr divOutOpr();
471 static LIR_Opr remOutOpr();
472 static LIR_Opr shiftCountOpr();
473 LIR_Opr syncTempOpr();
474 LIR_Opr atomicLockOpr();
476 // returns a register suitable for saving the thread in a
477 // call_runtime_leaf if one is needed.
478 LIR_Opr getThreadTemp();
480 // visitor functionality
481 virtual void do_Phi (Phi* x);
482 virtual void do_Local (Local* x);
483 virtual void do_Constant (Constant* x);
484 virtual void do_LoadField (LoadField* x);
485 virtual void do_StoreField (StoreField* x);
486 virtual void do_ArrayLength (ArrayLength* x);
487 virtual void do_LoadIndexed (LoadIndexed* x);
488 virtual void do_StoreIndexed (StoreIndexed* x);
489 virtual void do_NegateOp (NegateOp* x);
490 virtual void do_ArithmeticOp (ArithmeticOp* x);
491 virtual void do_ShiftOp (ShiftOp* x);
492 virtual void do_LogicOp (LogicOp* x);
493 virtual void do_CompareOp (CompareOp* x);
494 virtual void do_IfOp (IfOp* x);
495 virtual void do_Convert (Convert* x);
496 virtual void do_NullCheck (NullCheck* x);
497 virtual void do_Invoke (Invoke* x);
498 virtual void do_NewInstance (NewInstance* x);
499 virtual void do_NewTypeArray (NewTypeArray* x);
500 virtual void do_NewObjectArray (NewObjectArray* x);
501 virtual void do_NewMultiArray (NewMultiArray* x);
502 virtual void do_CheckCast (CheckCast* x);
503 virtual void do_InstanceOf (InstanceOf* x);
504 virtual void do_MonitorEnter (MonitorEnter* x);
505 virtual void do_MonitorExit (MonitorExit* x);
506 virtual void do_Intrinsic (Intrinsic* x);
507 virtual void do_BlockBegin (BlockBegin* x);
508 virtual void do_Goto (Goto* x);
509 virtual void do_If (If* x);
510 virtual void do_IfInstanceOf (IfInstanceOf* x);
511 virtual void do_TableSwitch (TableSwitch* x);
512 virtual void do_LookupSwitch (LookupSwitch* x);
513 virtual void do_Return (Return* x);
514 virtual void do_Throw (Throw* x);
515 virtual void do_Base (Base* x);
516 virtual void do_OsrEntry (OsrEntry* x);
517 virtual void do_ExceptionObject(ExceptionObject* x);
518 virtual void do_RoundFP (RoundFP* x);
519 virtual void do_UnsafeGetRaw (UnsafeGetRaw* x);
520 virtual void do_UnsafePutRaw (UnsafePutRaw* x);
521 virtual void do_UnsafeGetObject(UnsafeGetObject* x);
522 virtual void do_UnsafePutObject(UnsafePutObject* x);
523 virtual void do_UnsafePrefetchRead (UnsafePrefetchRead* x);
524 virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
525 virtual void do_ProfileCall (ProfileCall* x);
526 virtual void do_ProfileInvoke (ProfileInvoke* x);
527 virtual void do_RuntimeCall (RuntimeCall* x);
528 };
531 class LIRItem: public CompilationResourceObj {
532 private:
533 Value _value;
534 LIRGenerator* _gen;
535 LIR_Opr _result;
536 bool _destroys_register;
537 LIR_Opr _new_result;
539 LIRGenerator* gen() const { return _gen; }
541 public:
542 LIRItem(Value value, LIRGenerator* gen) {
543 _destroys_register = false;
544 _gen = gen;
545 set_instruction(value);
546 }
548 LIRItem(LIRGenerator* gen) {
549 _destroys_register = false;
550 _gen = gen;
551 _result = LIR_OprFact::illegalOpr;
552 set_instruction(NULL);
553 }
555 void set_instruction(Value value) {
556 _value = value;
557 _result = LIR_OprFact::illegalOpr;
558 if (_value != NULL) {
559 _gen->walk(_value);
560 _result = _value->operand();
561 }
562 _new_result = LIR_OprFact::illegalOpr;
563 }
565 Value value() const { return _value; }
566 ValueType* type() const { return value()->type(); }
567 LIR_Opr result() {
568 assert(!_destroys_register || (!_result->is_register() || _result->is_virtual()),
569 "shouldn't use set_destroys_register with physical regsiters");
570 if (_destroys_register && _result->is_register()) {
571 if (_new_result->is_illegal()) {
572 _new_result = _gen->new_register(type());
573 gen()->lir()->move(_result, _new_result);
574 }
575 return _new_result;
576 } else {
577 return _result;
578 }
579 return _result;
580 }
582 void set_result(LIR_Opr opr);
584 void load_item();
585 void load_byte_item();
586 void load_nonconstant();
587 // load any values which can't be expressed as part of a single store instruction
588 void load_for_store(BasicType store_type);
589 void load_item_force(LIR_Opr reg);
591 void dont_load_item() {
592 // do nothing
593 }
595 void set_destroys_register() {
596 _destroys_register = true;
597 }
599 bool is_constant() const { return value()->as_Constant() != NULL; }
600 bool is_stack() { return result()->is_stack(); }
601 bool is_register() { return result()->is_register(); }
603 ciObject* get_jobject_constant() const;
604 jint get_jint_constant() const;
605 jlong get_jlong_constant() const;
606 jfloat get_jfloat_constant() const;
607 jdouble get_jdouble_constant() const;
608 jint get_address_constant() const;
609 };
611 #endif // SHARE_VM_C1_C1_LIRGENERATOR_HPP