< prev index next >

src/hotspot/share/gc/shared/barrierSet.cpp

Print this page

  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  */
 24 
 25 #include "precompiled.hpp"

 26 #include "gc/shared/barrierSet.hpp"
 27 #include "gc/shared/barrierSetAssembler.hpp"
 28 #include "gc/shared/barrierSetNMethod.hpp"


 29 #include "runtime/continuation.hpp"
 30 #include "runtime/javaThread.hpp"
 31 #include "utilities/debug.hpp"
 32 #include "utilities/macros.hpp"
 33 
 34 BarrierSet* BarrierSet::_barrier_set = NULL;
 35 
 36 void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
 37   assert(_barrier_set == NULL, "Already initialized");
 38   _barrier_set = barrier_set;
 39 
 40   // Notify barrier set of the current (main) thread.  Normally the
 41   // Thread constructor deals with this, but the main thread is
 42   // created before we get here.  Verify it isn't yet on the thread
 43   // list, else we'd also need to call BarrierSet::on_thread_attach.
 44   // This is the only thread that can exist at this point; the Thread
 45   // constructor objects to other threads being created before the
 46   // barrier set is available.
 47   assert(Thread::current()->is_Java_thread(),
 48          "Expected main thread to be a JavaThread");
 49   assert(!JavaThread::current()->on_thread_list(),
 50          "Main thread already on thread list.");
 51   _barrier_set->on_thread_create(Thread::current());
 52 }
 53 



























 54 static BarrierSetNMethod* select_barrier_set_nmethod(BarrierSetNMethod* barrier_set_nmethod) {
 55   if (barrier_set_nmethod != NULL) {
 56     // The GC needs nmethod entry barriers to do concurrent GC
 57     return barrier_set_nmethod;
 58   } else {
 59     // The GC needs nmethod entry barriers to deal with continuations
 60     // and code cache unloading
 61     return NOT_ARM32(new BarrierSetNMethod()) ARM32_ONLY(nullptr);
 62   }
 63 }
 64 
 65 BarrierSet::BarrierSet(BarrierSetAssembler* barrier_set_assembler,
 66                        BarrierSetC1* barrier_set_c1,
 67                        BarrierSetC2* barrier_set_c2,
 68                        BarrierSetNMethod* barrier_set_nmethod,
 69                        const FakeRtti& fake_rtti) :
 70     _fake_rtti(fake_rtti),
 71     _barrier_set_assembler(barrier_set_assembler),
 72     _barrier_set_c1(barrier_set_c1),
 73     _barrier_set_c2(barrier_set_c2),

  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  */
 24 
 25 #include "precompiled.hpp"
 26 #include "classfile/vmSymbols.hpp"
 27 #include "gc/shared/barrierSet.hpp"
 28 #include "gc/shared/barrierSetAssembler.hpp"
 29 #include "gc/shared/barrierSetNMethod.hpp"
 30 #include "memory/resourceArea.hpp"
 31 #include "oops/objArrayKlass.inline.hpp"
 32 #include "runtime/continuation.hpp"
 33 #include "runtime/javaThread.hpp"
 34 #include "utilities/debug.hpp"
 35 #include "utilities/macros.hpp"
 36 
 37 BarrierSet* BarrierSet::_barrier_set = NULL;
 38 
 39 void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
 40   assert(_barrier_set == NULL, "Already initialized");
 41   _barrier_set = barrier_set;
 42 
 43   // Notify barrier set of the current (main) thread.  Normally the
 44   // Thread constructor deals with this, but the main thread is
 45   // created before we get here.  Verify it isn't yet on the thread
 46   // list, else we'd also need to call BarrierSet::on_thread_attach.
 47   // This is the only thread that can exist at this point; the Thread
 48   // constructor objects to other threads being created before the
 49   // barrier set is available.
 50   assert(Thread::current()->is_Java_thread(),
 51          "Expected main thread to be a JavaThread");
 52   assert(!JavaThread::current()->on_thread_list(),
 53          "Main thread already on thread list.");
 54   _barrier_set->on_thread_create(Thread::current());
 55 }
 56 
 57 void BarrierSet::throw_array_null_pointer_store_exception(arrayOop src, arrayOop dst, TRAPS) {
 58   ResourceMark rm(THREAD);
 59   Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
 60   stringStream ss;
 61   ss.print("arraycopy: can not copy null values into %s[]",
 62            bound->external_name());
 63   THROW_MSG(vmSymbols::java_lang_NullPointerException(), ss.as_string());
 64 }
 65 
 66 void BarrierSet::throw_array_store_exception(arrayOop src, arrayOop dst, TRAPS) {
 67   ResourceMark rm(THREAD);
 68   Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
 69   Klass* stype = ObjArrayKlass::cast(src->klass())->element_klass();
 70   stringStream ss;
 71   if (!bound->is_subtype_of(stype)) {
 72     ss.print("arraycopy: type mismatch: can not copy %s[] into %s[]",
 73              stype->external_name(), bound->external_name());
 74   } else {
 75     // oop_arraycopy should return the index in the source array that
 76     // contains the problematic oop.
 77     ss.print("arraycopy: element type mismatch: can not cast one of the elements"
 78              " of %s[] to the type of the destination array, %s",
 79              stype->external_name(), bound->external_name());
 80   }
 81   THROW_MSG(vmSymbols::java_lang_ArrayStoreException(), ss.as_string());
 82 }
 83 
 84 static BarrierSetNMethod* select_barrier_set_nmethod(BarrierSetNMethod* barrier_set_nmethod) {
 85   if (barrier_set_nmethod != NULL) {
 86     // The GC needs nmethod entry barriers to do concurrent GC
 87     return barrier_set_nmethod;
 88   } else {
 89     // The GC needs nmethod entry barriers to deal with continuations
 90     // and code cache unloading
 91     return NOT_ARM32(new BarrierSetNMethod()) ARM32_ONLY(nullptr);
 92   }
 93 }
 94 
 95 BarrierSet::BarrierSet(BarrierSetAssembler* barrier_set_assembler,
 96                        BarrierSetC1* barrier_set_c1,
 97                        BarrierSetC2* barrier_set_c2,
 98                        BarrierSetNMethod* barrier_set_nmethod,
 99                        const FakeRtti& fake_rtti) :
100     _fake_rtti(fake_rtti),
101     _barrier_set_assembler(barrier_set_assembler),
102     _barrier_set_c1(barrier_set_c1),
103     _barrier_set_c2(barrier_set_c2),
< prev index next >