< prev index next >

src/hotspot/cpu/ppc/gc/g1/g1BarrierSetAssembler_ppc.cpp

BarrierSetC1_v2

324 
325 void G1BarrierSetAssembler::resolve_jobject(MacroAssembler* masm, Register value, Register tmp1, Register tmp2, bool needs_frame) {  
326   Label done, not_weak;                                                                                                              
327   __ cmpdi(CCR0, value, 0);                                                                                                          
328   __ beq(CCR0, done);         // Use NULL as-is.                                                                                     
329 
330   __ clrrdi(tmp1, value, JNIHandles::weak_tag_size);                                                                                 
331   __ andi_(tmp2, value, JNIHandles::weak_tag_mask);                                                                                  
332   __ ld(value, 0, tmp1);      // Resolve (untagged) jobject.                                                                         
333 
334   __ beq(CCR0, not_weak);     // Test for jweak tag.                                                                                 
335   __ verify_oop(value);                                                                                                              
336   g1_write_barrier_pre(masm, IN_ROOT | ON_PHANTOM_OOP_REF,                                                                           
337                        noreg, noreg, value,                                                                                          
338                        tmp1, tmp2, needs_frame);                                                                                     
339   __ bind(not_weak);                                                                                                                 
340   __ verify_oop(value);                                                                                                              
341   __ bind(done);                                                                                                                     
342 }                                                                                                                                    
343 
                                                                                                                                     
                                                                                                                                     
344 #undef __                                                                                                                            
345 #define __ ce->masm()->                                                                                                              
346 
347 void G1BarrierSetAssembler::gen_g1_pre_barrier_stub(LIR_Assembler* ce, G1PreBarrierStub* stub) {                                     
348   G1BarrierSetC1* bs = (G1BarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();                                                 
349   // At this point we know that marking is in progress.                                                                              
350   // If do_load() is true then we have to emit the                                                                                   
351   // load of the previous value; otherwise it has already                                                                            
352   // been loaded into _pre_val.                                                                                                      
353 
354   __ bind(*stub->entry());                                                                                                           
355 
356   assert(stub->pre_val()->is_register(), "Precondition.");                                                                           
357   Register pre_val_reg = stub->pre_val()->as_register();                                                                             
358 
359   if (stub->do_load()) {                                                                                                             
360     ce->mem2reg(stub->addr(), stub->pre_val(), T_OBJECT, stub->patch_code(), stub->info(), false /*wide*/, false /*unaligned*/);     
361   }                                                                                                                                  
362 

324 
325 void G1BarrierSetAssembler::resolve_jobject(MacroAssembler* masm, Register value, Register tmp1, Register tmp2, bool needs_frame) {
326   Label done, not_weak;
327   __ cmpdi(CCR0, value, 0);
328   __ beq(CCR0, done);         // Use NULL as-is.
329 
330   __ clrrdi(tmp1, value, JNIHandles::weak_tag_size);
331   __ andi_(tmp2, value, JNIHandles::weak_tag_mask);
332   __ ld(value, 0, tmp1);      // Resolve (untagged) jobject.
333 
334   __ beq(CCR0, not_weak);     // Test for jweak tag.
335   __ verify_oop(value);
336   g1_write_barrier_pre(masm, IN_ROOT | ON_PHANTOM_OOP_REF,
337                        noreg, noreg, value,
338                        tmp1, tmp2, needs_frame);
339   __ bind(not_weak);
340   __ verify_oop(value);
341   __ bind(done);
342 }
343 
344 #ifdef COMPILER1
345 
346 #undef __
347 #define __ ce->masm()->
348 
349 void G1BarrierSetAssembler::gen_g1_pre_barrier_stub(LIR_Assembler* ce, G1PreBarrierStub* stub) {
350   G1BarrierSetC1* bs = (G1BarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();
351   // At this point we know that marking is in progress.
352   // If do_load() is true then we have to emit the
353   // load of the previous value; otherwise it has already
354   // been loaded into _pre_val.
355 
356   __ bind(*stub->entry());
357 
358   assert(stub->pre_val()->is_register(), "Precondition.");
359   Register pre_val_reg = stub->pre_val()->as_register();
360 
361   if (stub->do_load()) {
362     ce->mem2reg(stub->addr(), stub->pre_val(), T_OBJECT, stub->patch_code(), stub->info(), false /*wide*/, false /*unaligned*/);
363   }
364 

526   __ bind(ret);                                                                                                                      
527   __ ld(tmp2, -16, R1_SP);                                                                                                           
528   __ ld(addr, -8, R1_SP);                                                                                                            
529   __ blr();                                                                                                                          
530 
531   __ bind(refill);                                                                                                                   
532   const int nbytes_save = (MacroAssembler::num_volatile_regs + stack_slots) * BytesPerWord;                                          
533   __ save_volatile_gprs(R1_SP, -nbytes_save); // except R0                                                                           
534   __ mflr(R0);                                                                                                                       
535   __ std(R0, _abi(lr), R1_SP);                                                                                                       
536   __ push_frame_reg_args(nbytes_save, R0); // dummy frame for C call                                                                 
537   __ call_VM_leaf(CAST_FROM_FN_PTR(address, DirtyCardQueueSet::handle_zero_index_for_thread), R16_thread);                           
538   __ pop_frame();                                                                                                                    
539   __ ld(R0, _abi(lr), R1_SP);                                                                                                        
540   __ mtlr(R0);                                                                                                                       
541   __ restore_volatile_gprs(R1_SP, -nbytes_save); // except R0                                                                        
542   __ b(restart);                                                                                                                     
543 }                                                                                                                                    
544 
545 #undef __                                                                                                                            
                                                                                                                                     
                                                                                                                                     

528   __ bind(ret);
529   __ ld(tmp2, -16, R1_SP);
530   __ ld(addr, -8, R1_SP);
531   __ blr();
532 
533   __ bind(refill);
534   const int nbytes_save = (MacroAssembler::num_volatile_regs + stack_slots) * BytesPerWord;
535   __ save_volatile_gprs(R1_SP, -nbytes_save); // except R0
536   __ mflr(R0);
537   __ std(R0, _abi(lr), R1_SP);
538   __ push_frame_reg_args(nbytes_save, R0); // dummy frame for C call
539   __ call_VM_leaf(CAST_FROM_FN_PTR(address, DirtyCardQueueSet::handle_zero_index_for_thread), R16_thread);
540   __ pop_frame();
541   __ ld(R0, _abi(lr), R1_SP);
542   __ mtlr(R0);
543   __ restore_volatile_gprs(R1_SP, -nbytes_save); // except R0
544   __ b(restart);
545 }
546 
547 #undef __
548 
549 #endif // COMPILER1
< prev index next >