src/share/vm/memory/modRefBarrierSet.hpp

Fri, 15 Apr 2011 09:36:28 -0400

author
coleenp
date
Fri, 15 Apr 2011 09:36:28 -0400
changeset 2777
8ce625481709
parent 2314
f95d63e2154a
child 2788
c69b1043dfb1
permissions
-rw-r--r--

7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
Summary: Make CDS reorder vtables so that dump time vtables match run time order, so when redefine classes reinitializes them, they aren't in the wrong order.
Reviewed-by: dcubed, acorn

     1 /*
     2  * Copyright (c) 2000, 2010, 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_MEMORY_MODREFBARRIERSET_HPP
    26 #define SHARE_VM_MEMORY_MODREFBARRIERSET_HPP
    28 #include "memory/barrierSet.hpp"
    30 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
    31 // enumerate ref fields that have been modified (since the last
    32 // enumeration), using a card table.
    34 class OopClosure;
    35 class Generation;
    37 class ModRefBarrierSet: public BarrierSet {
    38 public:
    40   ModRefBarrierSet() { _kind = BarrierSet::ModRef; }
    42   bool is_a(BarrierSet::Name bsn) {
    43     return bsn == BarrierSet::ModRef;
    44   }
    46   // Barriers only on ref writes.
    47   bool has_read_ref_barrier() { return false; }
    48   bool has_read_prim_barrier() { return false; }
    49   bool has_write_ref_barrier() { return true; }
    50   bool has_write_prim_barrier() { return false; }
    52   bool read_ref_needs_barrier(void* field) { return false; }
    53   bool read_prim_needs_barrier(HeapWord* field, size_t bytes) { return false; }
    54   virtual bool write_ref_needs_barrier(void* field, oop new_val) = 0;
    55   bool write_prim_needs_barrier(HeapWord* field, size_t bytes,
    56                                 juint val1, juint val2) { return false; }
    58   void write_prim_field(oop obj, size_t offset, size_t bytes,
    59                         juint val1, juint val2) {}
    61   void read_ref_field(void* field) {}
    62   void read_prim_field(HeapWord* field, size_t bytes) {}
    63 protected:
    64   virtual void write_ref_field_work(void* field, oop new_val) = 0;
    65 public:
    66   void write_prim_field(HeapWord* field, size_t bytes,
    67                         juint val1, juint val2) {}
    69   bool has_read_ref_array_opt() { return false; }
    70   bool has_read_prim_array_opt() { return false; }
    71   bool has_write_prim_array_opt() { return false; }
    73   bool has_read_region_opt() { return false; }
    76   // These operations should assert false unless the correponding operation
    77   // above returns true.
    78   void read_ref_array(MemRegion mr) {
    79     assert(false, "can't call");
    80   }
    81   void read_prim_array(MemRegion mr) {
    82     assert(false, "can't call");
    83   }
    84   void write_prim_array(MemRegion mr) {
    85     assert(false, "can't call");
    86   }
    87   void read_region(MemRegion mr) {
    88     assert(false, "can't call");
    89   }
    91   // Invoke "cl->do_oop" on (the address of) every possibly-modifed
    92   // reference field in objects in "sp".  If "clear" is "true", the oops
    93   // are no longer considered possibly modified after application of the
    94   // closure.  If' "before_save_marks" is true, oops in objects allocated
    95   // after the last call to "save_marks" on "sp" will not be considered.
    96   virtual void mod_oop_in_space_iterate(Space* sp, OopClosure* cl,
    97                                         bool clear = false,
    98                                         bool before_save_marks = false) = 0;
   100   // Causes all refs in "mr" to be assumed to be modified.  If "whole_heap"
   101   // is true, the caller asserts that the entire heap is being invalidated,
   102   // which may admit an optimized implementation for some barriers.
   103   virtual void invalidate(MemRegion mr, bool whole_heap = false) = 0;
   105   // The caller guarantees that "mr" contains no references.  (Perhaps it's
   106   // objects have been moved elsewhere.)
   107   virtual void clear(MemRegion mr) = 0;
   109   // Pass along the argument to the superclass.
   110   ModRefBarrierSet(int max_covered_regions) :
   111     BarrierSet(max_covered_regions) {}
   113 #ifndef PRODUCT
   114   // Verifies that the given region contains no modified references.
   115   virtual void verify_clean_region(MemRegion mr) = 0;
   116 #endif
   118 };
   120 #endif // SHARE_VM_MEMORY_MODREFBARRIERSET_HPP

mercurial