< prev index next >

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

Print this page




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


























  50 }
  51 
  52 // Called from init.cpp
  53 void gc_barrier_stubs_init() {
  54   BarrierSet* bs = BarrierSet::barrier_set();
  55 #ifndef ZERO
  56   BarrierSetAssembler* bs_assembler = bs->barrier_set_assembler();
  57   bs_assembler->barrier_stubs_init();
  58 #endif
  59 }


   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 "memory/resourceArea.hpp"
  29 #include "oops/objArrayKlass.inline.hpp"
  30 #include "runtime/thread.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 void BarrierSet::throw_array_null_pointer_store_exception(arrayOop src, arrayOop dst, TRAPS) {
  55   Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
  56   stringStream ss;
  57   ss.print("arraycopy: can not copy null values into %s[]",
  58            bound->external_name());
  59   THROW_MSG(vmSymbols::java_lang_NullPointerException(), ss.as_string());
  60 }
  61 
  62 void BarrierSet::throw_array_store_exception(arrayOop src, arrayOop dst, TRAPS) {
  63   ResourceMark rm(THREAD);
  64   Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
  65   Klass* stype = ObjArrayKlass::cast(src->klass())->element_klass();
  66   stringStream ss;
  67   if (!bound->is_subtype_of(stype)) {
  68     ss.print("arraycopy: type mismatch: can not copy %s[] into %s[]",
  69              stype->external_name(), bound->external_name());
  70   } else {
  71     // oop_arraycopy should return the index in the source array that
  72     // contains the problematic oop.
  73     ss.print("arraycopy: element type mismatch: can not cast one of the elements"
  74              " of %s[] to the type of the destination array, %s",
  75              stype->external_name(), bound->external_name());
  76   }
  77   THROW_MSG(vmSymbols::java_lang_ArrayStoreException(), ss.as_string());
  78 }
  79 
  80 // Called from init.cpp
  81 void gc_barrier_stubs_init() {
  82   BarrierSet* bs = BarrierSet::barrier_set();
  83 #ifndef ZERO
  84   BarrierSetAssembler* bs_assembler = bs->barrier_set_assembler();
  85   bs_assembler->barrier_stubs_init();
  86 #endif
  87 }
< prev index next >