jdk8-mips64-public/hotspot: comparison src/share/vm/opto/graphKit.cpp

-:e6beb62de02d
+:e1162778c1c8
 /*
-* Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 return st;
 }
-void GraphKit::pre_barrier(Node* ctl,
+void GraphKit::pre_barrier(bool do_load,
+Node* ctl,
 Node* obj,
 Node* adr,
 uint  adr_idx,
 Node* val,
 const TypeOopPtr* val_type,
+Node* pre_val,
 BasicType bt) {
 BarrierSet* bs = Universe::heap()->barrier_set();
 set_control(ctl);
 switch (bs->kind()) {
 case BarrierSet::G1SATBCT:
 case BarrierSet::G1SATBCTLogging:
-g1_write_barrier_pre(obj, adr, adr_idx, val, val_type, bt);
+g1_write_barrier_pre(do_load, obj, adr, adr_idx, val, val_type, pre_val, bt);
 break;
 case BarrierSet::CardTableModRef:
 case BarrierSet::CardTableExtension:
 case BarrierSet::ModRef:
 assert(bt == T_OBJECT, "sanity");
 assert(val != NULL, "not dead path");
 uint adr_idx = C->get_alias_index(adr_type);
 assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" );
-pre_barrier(control(), obj, adr, adr_idx, val, val_type, bt);
+pre_barrier(true /* do_load */,
+control(), obj, adr, adr_idx, val, val_type,
+NULL /* pre_val */,
+bt);
 Node* store = store_to_memory(control(), adr, val, bt, adr_idx);
 post_barrier(control(), store, obj, adr, adr_idx, val, bt, use_precise);
 return store;
 }
 // Final sync IdealKit and GraphKit.
 sync_kit(ideal);
 }
 // G1 pre/post barriers
-void GraphKit::g1_write_barrier_pre(Node* obj,
+void GraphKit::g1_write_barrier_pre(bool do_load,
+Node* obj,
 Node* adr,
 uint alias_idx,
 Node* val,
 const TypeOopPtr* val_type,
+Node* pre_val,
 BasicType bt) {
+// Some sanity checks
+// Note: val is unused in this routine.
+if (do_load) {
+// We need to generate the load of the previous value
+assert(obj != NULL, "must have a base");
+assert(adr != NULL, "where are loading from?");
+assert(pre_val == NULL, "loaded already?");
+assert(val_type != NULL, "need a type");
+} else {
+// In this case both val_type and alias_idx are unused.
+assert(pre_val != NULL, "must be loaded already");
+assert(pre_val->bottom_type()->basic_type() == T_OBJECT, "or we shouldn't be here");
+}
+assert(bt == T_OBJECT, "or we shouldn't be here");
 IdealKit ideal(gvn(), control(), merged_memory(), true);
 Node* tls = __ thread(); // ThreadLocalStorage
 Node* no_ctrl = NULL;
 PtrQueue::byte_offset_of_active());
 const int index_offset   = in_bytes(JavaThread::satb_mark_queue_offset() +  // 656
 PtrQueue::byte_offset_of_index());
 const int buffer_offset  = in_bytes(JavaThread::satb_mark_queue_offset() +  // 652
 PtrQueue::byte_offset_of_buf());
 // Now the actual pointers into the thread
-// set_control( ctl);
 Node* marking_adr = __ AddP(no_base, tls, __ ConX(marking_offset));
 Node* buffer_adr  = __ AddP(no_base, tls, __ ConX(buffer_offset));
 Node* index_adr   = __ AddP(no_base, tls, __ ConX(index_offset));
 // Now some of the values
 Node* marking = __ load(__ ctrl(), marking_adr, TypeInt::INT, active_type, Compile::AliasIdxRaw);
 // if (!marking)
 __ if_then(marking, BoolTest::ne, zero); {
 Node* index   = __ load(__ ctrl(), index_adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw);
-const Type* t1 = adr->bottom_type();
+if (do_load) {
-const Type* t2 = val->bottom_type();
-Node* orig = __ load(no_ctrl, adr, val_type, bt, alias_idx);
-// if (orig != NULL)
-__ if_then(orig, BoolTest::ne, null()); {
-Node* buffer  = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw);
 // load original value
 // alias_idx correct??
+pre_val = __ load(no_ctrl, adr, val_type, bt, alias_idx);
+}
+// if (pre_val != NULL)
+__ if_then(pre_val, BoolTest::ne, null()); {
+Node* buffer  = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw);
 // is the queue for this thread full?
 __ if_then(index, BoolTest::ne, zero, likely); {
 // decrement the index
 // We could refine the type for what it's worth
 // const TypeLong* lidxtype = TypeLong::make(CONST64(0), get_size_from_queue);
 next_indexX = _gvn.transform( new (C, 2) ConvI2LNode(next_index, TypeLong::make(0, max_jlong, Type::WidenMax)) );
 #endif
-// Now get the buffer location we will log the original value into and store it
+// Now get the buffer location we will log the previous value into and store it
 Node *log_addr = __ AddP(no_base, buffer, next_indexX);
-__ store(__ ctrl(), log_addr, orig, T_OBJECT, Compile::AliasIdxRaw);
+__ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw);
 // update the index
 __ store(__ ctrl(), index_adr, next_index, T_INT, Compile::AliasIdxRaw);
 } __ else_(); {
 // logging buffer is full, call the runtime
 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type();
-__ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), "g1_wb_pre", orig, tls);
+__ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), "g1_wb_pre", pre_val, tls);
 } __ end_if();  // (!index)
-} __ end_if();  // (orig != NULL)
+} __ end_if();  // (pre_val != NULL)
 } __ end_if();  // (!marking)
 // Final sync IdealKit and GraphKit.
 sync_kit(ideal);
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/graphKit.cpp

src/share/vm/opto/graphKit.cpp