Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/.hgtags	Fri Oct 18 10:37:26 2013 +0000
     1.2 +++ b/.hgtags	Fri Oct 18 19:44:40 2013 -0700
     1.3 @@ -383,3 +383,5 @@
     1.4  58043478c26d4e8bf48700acea5f97aba8b417d4 hs25-b52
     1.5  6209b0ed51c086d4127bac0e086c8f326d1764d7 jdk8-b110
     1.6  562a3d356de67670b4172b82aca2d30743449e04 hs25-b53
     1.7 +f6962730bbde82f279a0ae3a1c14bc5e58096c6e jdk8-b111
     1.8 +4a845c7a463844cead9e1e1641d6bcfb8a77f1c7 hs25-b54

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1HeapRegionTable.java	Fri Oct 18 19:44:40 2013 -0700
     2.3 @@ -0,0 +1,119 @@
     2.4 +/*
     2.5 + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
     2.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     2.7 + *
     2.8 + * This code is free software; you can redistribute it and/or modify it
     2.9 + * under the terms of the GNU General Public License version 2 only, as
    2.10 + * published by the Free Software Foundation.
    2.11 + *
    2.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
    2.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    2.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    2.15 + * version 2 for more details (a copy is included in the LICENSE file that
    2.16 + * accompanied this code).
    2.17 + *
    2.18 + * You should have received a copy of the GNU General Public License version
    2.19 + * 2 along with this work; if not, write to the Free Software Foundation,
    2.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    2.21 + *
    2.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    2.23 + * or visit www.oracle.com if you need additional information or have any
    2.24 + * questions.
    2.25 + *
    2.26 + */
    2.27 +
    2.28 +package sun.jvm.hotspot.gc_implementation.g1;
    2.29 +
    2.30 +import java.util.Iterator;
    2.31 +import java.util.Observable;
    2.32 +import java.util.Observer;
    2.33 +
    2.34 +import sun.jvm.hotspot.debugger.Address;
    2.35 +import sun.jvm.hotspot.runtime.VM;
    2.36 +import sun.jvm.hotspot.runtime.VMObject;
    2.37 +import sun.jvm.hotspot.runtime.VMObjectFactory;
    2.38 +import sun.jvm.hotspot.types.AddressField;
    2.39 +import sun.jvm.hotspot.types.CIntegerField;
    2.40 +import sun.jvm.hotspot.types.Type;
    2.41 +import sun.jvm.hotspot.types.TypeDataBase;
    2.42 +
    2.43 +// Mirror class for G1HeapRegionTable. It's essentially an index -> HeapRegion map.
    2.44 +
    2.45 +public class G1HeapRegionTable extends VMObject {
    2.46 +    // HeapRegion** _base;
    2.47 +    static private AddressField baseField;
    2.48 +    // uint _length;
    2.49 +    static private CIntegerField lengthField;
    2.50 +    // HeapRegion** _biased_base
    2.51 +    static private AddressField biasedBaseField;
    2.52 +    // size_t _bias
    2.53 +    static private CIntegerField biasField;
    2.54 +    // uint _shift_by
    2.55 +    static private CIntegerField shiftByField;
    2.56 +
    2.57 +    static {
    2.58 +        VM.registerVMInitializedObserver(new Observer() {
    2.59 +                public void update(Observable o, Object data) {
    2.60 +                    initialize(VM.getVM().getTypeDataBase());
    2.61 +                }
    2.62 +            });
    2.63 +    }
    2.64 +
    2.65 +    static private synchronized void initialize(TypeDataBase db) {
    2.66 +        Type type = db.lookupType("G1HeapRegionTable");
    2.67 +
    2.68 +        baseField = type.getAddressField("_base");
    2.69 +        lengthField = type.getCIntegerField("_length");
    2.70 +        biasedBaseField = type.getAddressField("_biased_base");
    2.71 +        biasField = type.getCIntegerField("_bias");
    2.72 +        shiftByField = type.getCIntegerField("_shift_by");
    2.73 +    }
    2.74 +
    2.75 +    private HeapRegion at(long index) {
    2.76 +        Address arrayAddr = baseField.getValue(addr);
    2.77 +        // Offset of &_base[index]
    2.78 +        long offset = index * VM.getVM().getAddressSize();
    2.79 +        Address regionAddr = arrayAddr.getAddressAt(offset);
    2.80 +        return (HeapRegion) VMObjectFactory.newObject(HeapRegion.class,
    2.81 +                                                      regionAddr);
    2.82 +    }
    2.83 +
    2.84 +    public long length() {
    2.85 +        return lengthField.getValue(addr);
    2.86 +    }
    2.87 +
    2.88 +    public long bias() {
    2.89 +        return biasField.getValue(addr);
    2.90 +    }
    2.91 +
    2.92 +    public long shiftBy() {
    2.93 +        return shiftByField.getValue(addr);
    2.94 +    }
    2.95 +
    2.96 +    private class HeapRegionIterator implements Iterator<HeapRegion> {
    2.97 +        private long index;
    2.98 +        private long length;
    2.99 +
   2.100 +        @Override
   2.101 +        public boolean hasNext() { return index < length; }
   2.102 +
   2.103 +        @Override
   2.104 +        public HeapRegion next() { return at(index++);    }
   2.105 +
   2.106 +        @Override
   2.107 +        public void remove()     { /* not supported */    }
   2.108 +
   2.109 +        HeapRegionIterator(Address addr) {
   2.110 +            index = 0;
   2.111 +            length = length();
   2.112 +        }
   2.113 +    }
   2.114 +
   2.115 +    public Iterator<HeapRegion> heapRegionIterator() {
   2.116 +        return new HeapRegionIterator(addr);
   2.117 +    }
   2.118 +
   2.119 +    public G1HeapRegionTable(Address addr) {
   2.120 +        super(addr);
   2.121 +    }
   2.122 +}

     3.1 --- a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java	Fri Oct 18 10:37:26 2013 +0000
     3.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java	Fri Oct 18 19:44:40 2013 -0700
     3.3 @@ -1,5 +1,5 @@
     3.4  /*
     3.5 - * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
     3.6 + * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
     3.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3.8   *
     3.9   * This code is free software; you can redistribute it and/or modify it
    3.10 @@ -37,13 +37,11 @@
    3.11  import sun.jvm.hotspot.types.Type;
    3.12  import sun.jvm.hotspot.types.TypeDataBase;
    3.13  
    3.14 -// Mirror class for HeapRegionSeq. It's essentially an index -> HeapRegion map.
    3.15 +// Mirror class for HeapRegionSeq. It essentially encapsulates the G1HeapRegionTable.
    3.16  
    3.17  public class HeapRegionSeq extends VMObject {
    3.18 -    // HeapRegion** _regions;
    3.19 -    static private AddressField regionsField;
    3.20 -    // uint _length;
    3.21 -    static private CIntegerField lengthField;
    3.22 +    // G1HeapRegionTable _regions
    3.23 +    static private long regionsFieldOffset;
    3.24  
    3.25      static {
    3.26          VM.registerVMInitializedObserver(new Observer() {
    3.27 @@ -56,44 +54,21 @@
    3.28      static private synchronized void initialize(TypeDataBase db) {
    3.29          Type type = db.lookupType("HeapRegionSeq");
    3.30  
    3.31 -        regionsField = type.getAddressField("_regions");
    3.32 -        lengthField = type.getCIntegerField("_length");
    3.33 +        regionsFieldOffset = type.getField("_regions").getOffset();
    3.34      }
    3.35  
    3.36 -    private HeapRegion at(long index) {
    3.37 -        Address arrayAddr = regionsField.getValue(addr);
    3.38 -        // Offset of &_region[index]
    3.39 -        long offset = index * VM.getVM().getAddressSize();
    3.40 -        Address regionAddr = arrayAddr.getAddressAt(offset);
    3.41 -        return (HeapRegion) VMObjectFactory.newObject(HeapRegion.class,
    3.42 -                                                      regionAddr);
    3.43 +    private G1HeapRegionTable regions() {
    3.44 +        Address regionsAddr = addr.addOffsetTo(regionsFieldOffset);
    3.45 +        return (G1HeapRegionTable) VMObjectFactory.newObject(G1HeapRegionTable.class,
    3.46 +                                                             regionsAddr);
    3.47      }
    3.48  
    3.49      public long length() {
    3.50 -        return lengthField.getValue(addr);
    3.51 -    }
    3.52 -
    3.53 -    private class HeapRegionIterator implements Iterator<HeapRegion> {
    3.54 -        private long index;
    3.55 -        private long length;
    3.56 -
    3.57 -        @Override
    3.58 -        public boolean hasNext() { return index < length; }
    3.59 -
    3.60 -        @Override
    3.61 -        public HeapRegion next() { return at(index++);    }
    3.62 -
    3.63 -        @Override
    3.64 -        public void remove()     { /* not supported */    }
    3.65 -
    3.66 -        HeapRegionIterator(Address addr) {
    3.67 -            index = 0;
    3.68 -            length = length();
    3.69 -        }
    3.70 +        return regions().length();
    3.71      }
    3.72  
    3.73      public Iterator<HeapRegion> heapRegionIterator() {
    3.74 -        return new HeapRegionIterator(addr);
    3.75 +        return regions().heapRegionIterator();
    3.76      }
    3.77  
    3.78      public HeapRegionSeq(Address addr) {

     4.1 --- a/make/hotspot_version	Fri Oct 18 10:37:26 2013 +0000
     4.2 +++ b/make/hotspot_version	Fri Oct 18 19:44:40 2013 -0700
     4.3 @@ -35,7 +35,7 @@
     4.4  
     4.5  HS_MAJOR_VER=25
     4.6  HS_MINOR_VER=0
     4.7 -HS_BUILD_NUMBER=54
     4.8 +HS_BUILD_NUMBER=55
     4.9  
    4.10  JDK_MAJOR_VER=1
    4.11  JDK_MINOR_VER=8

     5.1 --- a/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Fri Oct 18 10:37:26 2013 +0000
     5.2 +++ b/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Fri Oct 18 19:44:40 2013 -0700
     5.3 @@ -3100,6 +3100,10 @@
     5.4    }
     5.5  }
     5.6  
     5.7 +void LIR_Assembler::emit_profile_type(LIR_OpProfileType* op) {
     5.8 +  fatal("Type profiling not implemented on this platform");
     5.9 +}
    5.10 +
    5.11  void LIR_Assembler::align_backward_branch_target() {
    5.12    __ align(OptoLoopAlignment);
    5.13  }

     6.1 --- a/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Fri Oct 18 10:37:26 2013 +0000
     6.2 +++ b/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Fri Oct 18 19:44:40 2013 -0700
     6.3 @@ -1076,6 +1076,25 @@
     6.4  
     6.5    __ verify_not_null_oop(Oexception);
     6.6  
     6.7 +#ifdef ASSERT
     6.8 +  // check that fields in JavaThread for exception oop and issuing pc are
     6.9 +  // empty before writing to them
    6.10 +  Label oop_empty;
    6.11 +  Register scratch = I7;  // We can use I7 here because it's overwritten later anyway.
    6.12 +  __ ld_ptr(Address(G2_thread, JavaThread::exception_oop_offset()), scratch);
    6.13 +  __ br_null(scratch, false, Assembler::pt, oop_empty);
    6.14 +  __ delayed()->nop();
    6.15 +  __ stop("exception oop already set");
    6.16 +  __ bind(oop_empty);
    6.17 +
    6.18 +  Label pc_empty;
    6.19 +  __ ld_ptr(Address(G2_thread, JavaThread::exception_pc_offset()), scratch);
    6.20 +  __ br_null(scratch, false, Assembler::pt, pc_empty);
    6.21 +  __ delayed()->nop();
    6.22 +  __ stop("exception pc already set");
    6.23 +  __ bind(pc_empty);
    6.24 +#endif
    6.25 +
    6.26    // save the exception and issuing pc in the thread
    6.27    __ st_ptr(Oexception,  G2_thread, in_bytes(JavaThread::exception_oop_offset()));
    6.28    __ st_ptr(Oissuing_pc, G2_thread, in_bytes(JavaThread::exception_pc_offset()));

     7.1 --- a/src/cpu/sparc/vm/globals_sparc.hpp	Fri Oct 18 10:37:26 2013 +0000
     7.2 +++ b/src/cpu/sparc/vm/globals_sparc.hpp	Fri Oct 18 19:44:40 2013 -0700
     7.3 @@ -76,6 +76,8 @@
     7.4  // GC Ergo Flags
     7.5  define_pd_global(uintx, CMSYoungGenPerWorker, 16*M);  // default max size of CMS young gen, per GC worker thread
     7.6  
     7.7 +define_pd_global(uintx, TypeProfileLevel, 0);
     7.8 +
     7.9  #define ARCH_FLAGS(develop, product, diagnostic, experimental, notproduct) \
    7.10                                                                              \
    7.11    product(intx, UseVIS, 99,                                                 \

     8.1 --- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp	Fri Oct 18 10:37:26 2013 +0000
     8.2 +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp	Fri Oct 18 19:44:40 2013 -0700
     8.3 @@ -3581,6 +3581,7 @@
     8.4    // the pending exception will be picked up the interpreter.
     8.5    __ ld_ptr(G2_thread, in_bytes(JavaThread::exception_oop_offset()), Oexception);
     8.6    __ st_ptr(G0, G2_thread, in_bytes(JavaThread::exception_oop_offset()));
     8.7 +  __ st_ptr(G0, G2_thread, in_bytes(JavaThread::exception_pc_offset()));
     8.8    __ bind(noException);
     8.9  
    8.10    // deallocate the deoptimization frame taking care to preserve the return values

     9.1 --- a/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Fri Oct 18 10:37:26 2013 +0000
     9.2 +++ b/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Fri Oct 18 19:44:40 2013 -0700
     9.3 @@ -3632,6 +3632,161 @@
     9.4    }
     9.5  }
     9.6  
     9.7 +void LIR_Assembler::emit_profile_type(LIR_OpProfileType* op) {
     9.8 +  Register obj = op->obj()->as_register();
     9.9 +  Register tmp = op->tmp()->as_pointer_register();
    9.10 +  Address mdo_addr = as_Address(op->mdp()->as_address_ptr());
    9.11 +  ciKlass* exact_klass = op->exact_klass();
    9.12 +  intptr_t current_klass = op->current_klass();
    9.13 +  bool not_null = op->not_null();
    9.14 +  bool no_conflict = op->no_conflict();
    9.15 +
    9.16 +  Label update, next, none;
    9.17 +
    9.18 +  bool do_null = !not_null;
    9.19 +  bool exact_klass_set = exact_klass != NULL && ciTypeEntries::valid_ciklass(current_klass) == exact_klass;
    9.20 +  bool do_update = !TypeEntries::is_type_unknown(current_klass) && !exact_klass_set;
    9.21 +
    9.22 +  assert(do_null || do_update, "why are we here?");
    9.23 +  assert(!TypeEntries::was_null_seen(current_klass) || do_update, "why are we here?");
    9.24 +
    9.25 +  __ verify_oop(obj);
    9.26 +
    9.27 +  if (tmp != obj) {
    9.28 +    __ mov(tmp, obj);
    9.29 +  }
    9.30 +  if (do_null) {
    9.31 +    __ testptr(tmp, tmp);
    9.32 +    __ jccb(Assembler::notZero, update);
    9.33 +    if (!TypeEntries::was_null_seen(current_klass)) {
    9.34 +      __ orptr(mdo_addr, TypeEntries::null_seen);
    9.35 +    }
    9.36 +    if (do_update) {
    9.37 +#ifndef ASSERT
    9.38 +      __ jmpb(next);
    9.39 +    }
    9.40 +#else
    9.41 +      __ jmp(next);
    9.42 +    }
    9.43 +  } else {
    9.44 +    __ testptr(tmp, tmp);
    9.45 +    __ jccb(Assembler::notZero, update);
    9.46 +    __ stop("unexpect null obj");
    9.47 +#endif
    9.48 +  }
    9.49 +
    9.50 +  __ bind(update);
    9.51 +
    9.52 +  if (do_update) {
    9.53 +#ifdef ASSERT
    9.54 +    if (exact_klass != NULL) {
    9.55 +      Label ok;
    9.56 +      __ load_klass(tmp, tmp);
    9.57 +      __ push(tmp);
    9.58 +      __ mov_metadata(tmp, exact_klass->constant_encoding());
    9.59 +      __ cmpptr(tmp, Address(rsp, 0));
    9.60 +      __ jccb(Assembler::equal, ok);
    9.61 +      __ stop("exact klass and actual klass differ");
    9.62 +      __ bind(ok);
    9.63 +      __ pop(tmp);
    9.64 +    }
    9.65 +#endif
    9.66 +    if (!no_conflict) {
    9.67 +      if (exact_klass == NULL || TypeEntries::is_type_none(current_klass)) {
    9.68 +        if (exact_klass != NULL) {
    9.69 +          __ mov_metadata(tmp, exact_klass->constant_encoding());
    9.70 +        } else {
    9.71 +          __ load_klass(tmp, tmp);
    9.72 +        }
    9.73 +
    9.74 +        __ xorptr(tmp, mdo_addr);
    9.75 +        __ testptr(tmp, TypeEntries::type_klass_mask);
    9.76 +        // klass seen before, nothing to do. The unknown bit may have been
    9.77 +        // set already but no need to check.
    9.78 +        __ jccb(Assembler::zero, next);
    9.79 +
    9.80 +        __ testptr(tmp, TypeEntries::type_unknown);
    9.81 +        __ jccb(Assembler::notZero, next); // already unknown. Nothing to do anymore.
    9.82 +
    9.83 +        if (TypeEntries::is_type_none(current_klass)) {
    9.84 +          __ cmpptr(mdo_addr, 0);
    9.85 +          __ jccb(Assembler::equal, none);
    9.86 +          __ cmpptr(mdo_addr, TypeEntries::null_seen);
    9.87 +          __ jccb(Assembler::equal, none);
    9.88 +          // There is a chance that the checks above (re-reading profiling
    9.89 +          // data from memory) fail if another thread has just set the
    9.90 +          // profiling to this obj's klass
    9.91 +          __ xorptr(tmp, mdo_addr);
    9.92 +          __ testptr(tmp, TypeEntries::type_klass_mask);
    9.93 +          __ jccb(Assembler::zero, next);
    9.94 +        }
    9.95 +      } else {
    9.96 +        assert(ciTypeEntries::valid_ciklass(current_klass) != NULL &&
    9.97 +               ciTypeEntries::valid_ciklass(current_klass) != exact_klass, "conflict only");
    9.98 +
    9.99 +        __ movptr(tmp, mdo_addr);
   9.100 +        __ testptr(tmp, TypeEntries::type_unknown);
   9.101 +        __ jccb(Assembler::notZero, next); // already unknown. Nothing to do anymore.
   9.102 +      }
   9.103 +
   9.104 +      // different than before. Cannot keep accurate profile.
   9.105 +      __ orptr(mdo_addr, TypeEntries::type_unknown);
   9.106 +
   9.107 +      if (TypeEntries::is_type_none(current_klass)) {
   9.108 +        __ jmpb(next);
   9.109 +
   9.110 +        __ bind(none);
   9.111 +        // first time here. Set profile type.
   9.112 +        __ movptr(mdo_addr, tmp);
   9.113 +      }
   9.114 +    } else {
   9.115 +      // There's a single possible klass at this profile point
   9.116 +      assert(exact_klass != NULL, "should be");
   9.117 +      if (TypeEntries::is_type_none(current_klass)) {
   9.118 +        __ mov_metadata(tmp, exact_klass->constant_encoding());
   9.119 +        __ xorptr(tmp, mdo_addr);
   9.120 +        __ testptr(tmp, TypeEntries::type_klass_mask);
   9.121 +#ifdef ASSERT
   9.122 +        __ jcc(Assembler::zero, next);
   9.123 +
   9.124 +        {
   9.125 +          Label ok;
   9.126 +          __ push(tmp);
   9.127 +          __ cmpptr(mdo_addr, 0);
   9.128 +          __ jcc(Assembler::equal, ok);
   9.129 +          __ cmpptr(mdo_addr, TypeEntries::null_seen);
   9.130 +          __ jcc(Assembler::equal, ok);
   9.131 +          // may have been set by another thread
   9.132 +          __ mov_metadata(tmp, exact_klass->constant_encoding());
   9.133 +          __ xorptr(tmp, mdo_addr);
   9.134 +          __ testptr(tmp, TypeEntries::type_mask);
   9.135 +          __ jcc(Assembler::zero, ok);
   9.136 +
   9.137 +          __ stop("unexpected profiling mismatch");
   9.138 +          __ bind(ok);
   9.139 +          __ pop(tmp);
   9.140 +        }
   9.141 +#else
   9.142 +        __ jccb(Assembler::zero, next);
   9.143 +#endif
   9.144 +        // first time here. Set profile type.
   9.145 +        __ movptr(mdo_addr, tmp);
   9.146 +      } else {
   9.147 +        assert(ciTypeEntries::valid_ciklass(current_klass) != NULL &&
   9.148 +               ciTypeEntries::valid_ciklass(current_klass) != exact_klass, "inconsistent");
   9.149 +
   9.150 +        __ movptr(tmp, mdo_addr);
   9.151 +        __ testptr(tmp, TypeEntries::type_unknown);
   9.152 +        __ jccb(Assembler::notZero, next); // already unknown. Nothing to do anymore.
   9.153 +
   9.154 +        __ orptr(mdo_addr, TypeEntries::type_unknown);
   9.155 +      }
   9.156 +    }
   9.157 +
   9.158 +    __ bind(next);
   9.159 +  }
   9.160 +}
   9.161 +
   9.162  void LIR_Assembler::emit_delay(LIR_OpDelay*) {
   9.163    Unimplemented();
   9.164  }

    10.1 --- a/src/cpu/x86/vm/globals_x86.hpp	Fri Oct 18 10:37:26 2013 +0000
    10.2 +++ b/src/cpu/x86/vm/globals_x86.hpp	Fri Oct 18 19:44:40 2013 -0700
    10.3 @@ -79,6 +79,8 @@
    10.4  // GC Ergo Flags
    10.5  define_pd_global(uintx, CMSYoungGenPerWorker, 64*M);  // default max size of CMS young gen, per GC worker thread
    10.6  
    10.7 +define_pd_global(uintx, TypeProfileLevel, 11);
    10.8 +
    10.9  #define ARCH_FLAGS(develop, product, diagnostic, experimental, notproduct) \
   10.10                                                                              \
   10.11    develop(bool, IEEEPrecision, true,                                        \

    11.1 --- a/src/cpu/x86/vm/interp_masm_x86_32.cpp	Fri Oct 18 10:37:26 2013 +0000
    11.2 +++ b/src/cpu/x86/vm/interp_masm_x86_32.cpp	Fri Oct 18 19:44:40 2013 -0700
    11.3 @@ -1046,6 +1046,158 @@
    11.4    }
    11.5  }
    11.6  
    11.7 +void InterpreterMacroAssembler::profile_obj_type(Register obj, const Address& mdo_addr) {
    11.8 +  Label update, next, none;
    11.9 +
   11.10 +  verify_oop(obj);
   11.11 +
   11.12 +  testptr(obj, obj);
   11.13 +  jccb(Assembler::notZero, update);
   11.14 +  orptr(mdo_addr, TypeEntries::null_seen);
   11.15 +  jmpb(next);
   11.16 +
   11.17 +  bind(update);
   11.18 +  load_klass(obj, obj);
   11.19 +
   11.20 +  xorptr(obj, mdo_addr);
   11.21 +  testptr(obj, TypeEntries::type_klass_mask);
   11.22 +  jccb(Assembler::zero, next); // klass seen before, nothing to
   11.23 +                               // do. The unknown bit may have been
   11.24 +                               // set already but no need to check.
   11.25 +
   11.26 +  testptr(obj, TypeEntries::type_unknown);
   11.27 +  jccb(Assembler::notZero, next); // already unknown. Nothing to do anymore.
   11.28 +
   11.29 +  cmpptr(mdo_addr, 0);
   11.30 +  jccb(Assembler::equal, none);
   11.31 +  cmpptr(mdo_addr, TypeEntries::null_seen);
   11.32 +  jccb(Assembler::equal, none);
   11.33 +  // There is a chance that the checks above (re-reading profiling
   11.34 +  // data from memory) fail if another thread has just set the
   11.35 +  // profiling to this obj's klass
   11.36 +  xorptr(obj, mdo_addr);
   11.37 +  testptr(obj, TypeEntries::type_klass_mask);
   11.38 +  jccb(Assembler::zero, next);
   11.39 +
   11.40 +  // different than before. Cannot keep accurate profile.
   11.41 +  orptr(mdo_addr, TypeEntries::type_unknown);
   11.42 +  jmpb(next);
   11.43 +
   11.44 +  bind(none);
   11.45 +  // first time here. Set profile type.
   11.46 +  movptr(mdo_addr, obj);
   11.47 +
   11.48 +  bind(next);
   11.49 +}
   11.50 +
   11.51 +void InterpreterMacroAssembler::profile_arguments_type(Register mdp, Register callee, Register tmp, bool is_virtual) {
   11.52 +  if (!ProfileInterpreter) {
   11.53 +    return;
   11.54 +  }
   11.55 +
   11.56 +  if (MethodData::profile_arguments() || MethodData::profile_return()) {
   11.57 +    Label profile_continue;
   11.58 +
   11.59 +    test_method_data_pointer(mdp, profile_continue);
   11.60 +
   11.61 +    int off_to_start = is_virtual ? in_bytes(VirtualCallData::virtual_call_data_size()) : in_bytes(CounterData::counter_data_size());
   11.62 +
   11.63 +    cmpb(Address(mdp, in_bytes(DataLayout::tag_offset()) - off_to_start), is_virtual ? DataLayout::virtual_call_type_data_tag : DataLayout::call_type_data_tag);
   11.64 +    jcc(Assembler::notEqual, profile_continue);
   11.65 +
   11.66 +    if (MethodData::profile_arguments()) {
   11.67 +      Label done;
   11.68 +      int off_to_args = in_bytes(TypeEntriesAtCall::args_data_offset());
   11.69 +      addptr(mdp, off_to_args);
   11.70 +
   11.71 +      for (int i = 0; i < TypeProfileArgsLimit; i++) {
   11.72 +        if (i > 0 || MethodData::profile_return()) {
   11.73 +          // If return value type is profiled we may have no argument to profile
   11.74 +          movl(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::cell_count_offset())-off_to_args));
   11.75 +          subl(tmp, i*TypeStackSlotEntries::per_arg_count());
   11.76 +          cmpl(tmp, TypeStackSlotEntries::per_arg_count());
   11.77 +          jcc(Assembler::less, done);
   11.78 +        }
   11.79 +        movptr(tmp, Address(callee, Method::const_offset()));
   11.80 +        load_unsigned_short(tmp, Address(tmp, ConstMethod::size_of_parameters_offset()));
   11.81 +        // stack offset o (zero based) from the start of the argument
   11.82 +        // list, for n arguments translates into offset n - o - 1 from
   11.83 +        // the end of the argument list
   11.84 +        subl(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::stack_slot_offset(i))-off_to_args));
   11.85 +        subl(tmp, 1);
   11.86 +        Address arg_addr = argument_address(tmp);
   11.87 +        movptr(tmp, arg_addr);
   11.88 +
   11.89 +        Address mdo_arg_addr(mdp, in_bytes(TypeEntriesAtCall::argument_type_offset(i))-off_to_args);
   11.90 +        profile_obj_type(tmp, mdo_arg_addr);
   11.91 +
   11.92 +        int to_add = in_bytes(TypeStackSlotEntries::per_arg_size());
   11.93 +        addptr(mdp, to_add);
   11.94 +        off_to_args += to_add;
   11.95 +      }
   11.96 +
   11.97 +      if (MethodData::profile_return()) {
   11.98 +        movl(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::cell_count_offset())-off_to_args));
   11.99 +        subl(tmp, TypeProfileArgsLimit*TypeStackSlotEntries::per_arg_count());
  11.100 +      }
  11.101 +
  11.102 +      bind(done);
  11.103 +
  11.104 +      if (MethodData::profile_return()) {
  11.105 +        // We're right after the type profile for the last
  11.106 +        // argument. tmp is the number of cell left in the
  11.107 +        // CallTypeData/VirtualCallTypeData to reach its end. Non null
  11.108 +        // if there's a return to profile.
  11.109 +        assert(ReturnTypeEntry::static_cell_count() < TypeStackSlotEntries::per_arg_count(), "can't move past ret type");
  11.110 +        shll(tmp, exact_log2(DataLayout::cell_size));
  11.111 +        addptr(mdp, tmp);
  11.112 +      }
  11.113 +      movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp);
  11.114 +    } else {
  11.115 +      assert(MethodData::profile_return(), "either profile call args or call ret");
  11.116 +      update_mdp_by_constant(mdp, in_bytes(ReturnTypeEntry::size()));
  11.117 +    }
  11.118 +
  11.119 +    // mdp points right after the end of the
  11.120 +    // CallTypeData/VirtualCallTypeData, right after the cells for the
  11.121 +    // return value type if there's one
  11.122 +
  11.123 +    bind(profile_continue);
  11.124 +  }
  11.125 +}
  11.126 +
  11.127 +void InterpreterMacroAssembler::profile_return_type(Register mdp, Register ret, Register tmp) {
  11.128 +  assert_different_registers(mdp, ret, tmp, rsi);
  11.129 +  if (ProfileInterpreter && MethodData::profile_return()) {
  11.130 +    Label profile_continue, done;
  11.131 +
  11.132 +    test_method_data_pointer(mdp, profile_continue);
  11.133 +
  11.134 +    if (MethodData::profile_return_jsr292_only()) {
  11.135 +      // If we don't profile all invoke bytecodes we must make sure
  11.136 +      // it's a bytecode we indeed profile. We can't go back to the
  11.137 +      // begining of the ProfileData we intend to update to check its
  11.138 +      // type because we're right after it and we don't known its
  11.139 +      // length
  11.140 +      Label do_profile;
  11.141 +      cmpb(Address(rsi, 0), Bytecodes::_invokedynamic);
  11.142 +      jcc(Assembler::equal, do_profile);
  11.143 +      cmpb(Address(rsi, 0), Bytecodes::_invokehandle);
  11.144 +      jcc(Assembler::equal, do_profile);
  11.145 +      get_method(tmp);
  11.146 +      cmpb(Address(tmp, Method::intrinsic_id_offset_in_bytes()), vmIntrinsics::_compiledLambdaForm);
  11.147 +      jcc(Assembler::notEqual, profile_continue);
  11.148 +
  11.149 +      bind(do_profile);
  11.150 +    }
  11.151 +
  11.152 +    Address mdo_ret_addr(mdp, -in_bytes(ReturnTypeEntry::size()));
  11.153 +    mov(tmp, ret);
  11.154 +    profile_obj_type(tmp, mdo_ret_addr);
  11.155 +
  11.156 +    bind(profile_continue);
  11.157 +  }
  11.158 +}
  11.159  
  11.160  void InterpreterMacroAssembler::profile_call(Register mdp) {
  11.161    if (ProfileInterpreter) {

    12.1 --- a/src/cpu/x86/vm/interp_masm_x86_32.hpp	Fri Oct 18 10:37:26 2013 +0000
    12.2 +++ b/src/cpu/x86/vm/interp_masm_x86_32.hpp	Fri Oct 18 19:44:40 2013 -0700
    12.3 @@ -215,6 +215,9 @@
    12.4  
    12.5    void profile_taken_branch(Register mdp, Register bumped_count);
    12.6    void profile_not_taken_branch(Register mdp);
    12.7 +  void profile_obj_type(Register obj, const Address& mdo_addr);
    12.8 +  void profile_arguments_type(Register mdp, Register callee, Register tmp, bool is_virtual);
    12.9 +  void profile_return_type(Register mdp, Register ret, Register tmp);
   12.10    void profile_call(Register mdp);
   12.11    void profile_final_call(Register mdp);
   12.12    void profile_virtual_call(Register receiver, Register mdp, Register scratch2,

    13.1 --- a/src/cpu/x86/vm/interp_masm_x86_64.cpp	Fri Oct 18 10:37:26 2013 +0000
    13.2 +++ b/src/cpu/x86/vm/interp_masm_x86_64.cpp	Fri Oct 18 19:44:40 2013 -0700
    13.3 @@ -1067,6 +1067,159 @@
    13.4    }
    13.5  }
    13.6  
    13.7 +void InterpreterMacroAssembler::profile_obj_type(Register obj, const Address& mdo_addr) {
    13.8 +  Label update, next, none;
    13.9 +
   13.10 +  verify_oop(obj);
   13.11 +
   13.12 +  testptr(obj, obj);
   13.13 +  jccb(Assembler::notZero, update);
   13.14 +  orptr(mdo_addr, TypeEntries::null_seen);
   13.15 +  jmpb(next);
   13.16 +
   13.17 +  bind(update);
   13.18 +  load_klass(obj, obj);
   13.19 +
   13.20 +  xorptr(obj, mdo_addr);
   13.21 +  testptr(obj, TypeEntries::type_klass_mask);
   13.22 +  jccb(Assembler::zero, next); // klass seen before, nothing to
   13.23 +                               // do. The unknown bit may have been
   13.24 +                               // set already but no need to check.
   13.25 +
   13.26 +  testptr(obj, TypeEntries::type_unknown);
   13.27 +  jccb(Assembler::notZero, next); // already unknown. Nothing to do anymore.
   13.28 +
   13.29 +  // There is a chance that by the time we do these checks (re-reading
   13.30 +  // profiling data from memory) another thread has set the profling
   13.31 +  // to this obj's klass and we set the profiling as unknow
   13.32 +  // erroneously
   13.33 +  cmpptr(mdo_addr, 0);
   13.34 +  jccb(Assembler::equal, none);
   13.35 +  cmpptr(mdo_addr, TypeEntries::null_seen);
   13.36 +  jccb(Assembler::equal, none);
   13.37 +  // There is a chance that the checks above (re-reading profiling
   13.38 +  // data from memory) fail if another thread has just set the
   13.39 +  // profiling to this obj's klass
   13.40 +  xorptr(obj, mdo_addr);
   13.41 +  testptr(obj, TypeEntries::type_klass_mask);
   13.42 +  jccb(Assembler::zero, next);
   13.43 +
   13.44 +  // different than before. Cannot keep accurate profile.
   13.45 +  orptr(mdo_addr, TypeEntries::type_unknown);
   13.46 +  jmpb(next);
   13.47 +
   13.48 +  bind(none);
   13.49 +  // first time here. Set profile type.
   13.50 +  movptr(mdo_addr, obj);
   13.51 +
   13.52 +  bind(next);
   13.53 +}
   13.54 +
   13.55 +void InterpreterMacroAssembler::profile_arguments_type(Register mdp, Register callee, Register tmp, bool is_virtual) {
   13.56 +  if (!ProfileInterpreter) {
   13.57 +    return;
   13.58 +  }
   13.59 +
   13.60 +  if (MethodData::profile_arguments() || MethodData::profile_return()) {
   13.61 +    Label profile_continue;
   13.62 +
   13.63 +    test_method_data_pointer(mdp, profile_continue);
   13.64 +
   13.65 +    int off_to_start = is_virtual ? in_bytes(VirtualCallData::virtual_call_data_size()) : in_bytes(CounterData::counter_data_size());
   13.66 +
   13.67 +    cmpb(Address(mdp, in_bytes(DataLayout::tag_offset()) - off_to_start), is_virtual ? DataLayout::virtual_call_type_data_tag : DataLayout::call_type_data_tag);
   13.68 +    jcc(Assembler::notEqual, profile_continue);
   13.69 +
   13.70 +    if (MethodData::profile_arguments()) {
   13.71 +      Label done;
   13.72 +      int off_to_args = in_bytes(TypeEntriesAtCall::args_data_offset());
   13.73 +      addptr(mdp, off_to_args);
   13.74 +
   13.75 +      for (int i = 0; i < TypeProfileArgsLimit; i++) {
   13.76 +        if (i > 0 || MethodData::profile_return()) {
   13.77 +          // If return value type is profiled we may have no argument to profile
   13.78 +          movq(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::cell_count_offset())-off_to_args));
   13.79 +          subl(tmp, i*TypeStackSlotEntries::per_arg_count());
   13.80 +          cmpl(tmp, TypeStackSlotEntries::per_arg_count());
   13.81 +          jcc(Assembler::less, done);
   13.82 +        }
   13.83 +        movptr(tmp, Address(callee, Method::const_offset()));
   13.84 +        load_unsigned_short(tmp, Address(tmp, ConstMethod::size_of_parameters_offset()));
   13.85 +        subq(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::stack_slot_offset(i))-off_to_args));
   13.86 +        subl(tmp, 1);
   13.87 +        Address arg_addr = argument_address(tmp);
   13.88 +        movptr(tmp, arg_addr);
   13.89 +
   13.90 +        Address mdo_arg_addr(mdp, in_bytes(TypeEntriesAtCall::argument_type_offset(i))-off_to_args);
   13.91 +        profile_obj_type(tmp, mdo_arg_addr);
   13.92 +
   13.93 +        int to_add = in_bytes(TypeStackSlotEntries::per_arg_size());
   13.94 +        addptr(mdp, to_add);
   13.95 +        off_to_args += to_add;
   13.96 +      }
   13.97 +
   13.98 +      if (MethodData::profile_return()) {
   13.99 +        movq(tmp, Address(mdp, in_bytes(TypeEntriesAtCall::cell_count_offset())-off_to_args));
  13.100 +        subl(tmp, TypeProfileArgsLimit*TypeStackSlotEntries::per_arg_count());
  13.101 +      }
  13.102 +
  13.103 +      bind(done);
  13.104 +
  13.105 +      if (MethodData::profile_return()) {
  13.106 +        // We're right after the type profile for the last
  13.107 +        // argument. tmp is the number of cell left in the
  13.108 +        // CallTypeData/VirtualCallTypeData to reach its end. Non null
  13.109 +        // if there's a return to profile.
  13.110 +        assert(ReturnTypeEntry::static_cell_count() < TypeStackSlotEntries::per_arg_count(), "can't move past ret type");
  13.111 +        shll(tmp, exact_log2(DataLayout::cell_size));
  13.112 +        addptr(mdp, tmp);
  13.113 +      }
  13.114 +      movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp);
  13.115 +    } else {
  13.116 +      assert(MethodData::profile_return(), "either profile call args or call ret");
  13.117 +      update_mdp_by_constant(mdp, in_bytes(ReturnTypeEntry::size()));
  13.118 +    }
  13.119 +
  13.120 +    // mdp points right after the end of the
  13.121 +    // CallTypeData/VirtualCallTypeData, right after the cells for the
  13.122 +    // return value type if there's one
  13.123 +
  13.124 +    bind(profile_continue);
  13.125 +  }
  13.126 +}
  13.127 +
  13.128 +void InterpreterMacroAssembler::profile_return_type(Register mdp, Register ret, Register tmp) {
  13.129 +  assert_different_registers(mdp, ret, tmp, r13);
  13.130 +  if (ProfileInterpreter && MethodData::profile_return()) {
  13.131 +    Label profile_continue, done;
  13.132 +
  13.133 +    test_method_data_pointer(mdp, profile_continue);
  13.134 +
  13.135 +    if (MethodData::profile_return_jsr292_only()) {
  13.136 +      // If we don't profile all invoke bytecodes we must make sure
  13.137 +      // it's a bytecode we indeed profile. We can't go back to the
  13.138 +      // begining of the ProfileData we intend to update to check its
  13.139 +      // type because we're right after it and we don't known its
  13.140 +      // length
  13.141 +      Label do_profile;
  13.142 +      cmpb(Address(r13, 0), Bytecodes::_invokedynamic);
  13.143 +      jcc(Assembler::equal, do_profile);
  13.144 +      cmpb(Address(r13, 0), Bytecodes::_invokehandle);
  13.145 +      jcc(Assembler::equal, do_profile);
  13.146 +      get_method(tmp);
  13.147 +      cmpb(Address(tmp, Method::intrinsic_id_offset_in_bytes()), vmIntrinsics::_compiledLambdaForm);
  13.148 +      jcc(Assembler::notEqual, profile_continue);
  13.149 +
  13.150 +      bind(do_profile);
  13.151 +    }
  13.152 +
  13.153 +    Address mdo_ret_addr(mdp, -in_bytes(ReturnTypeEntry::size()));
  13.154 +    mov(tmp, ret);
  13.155 +    profile_obj_type(tmp, mdo_ret_addr);
  13.156 +
  13.157 +    bind(profile_continue);
  13.158 +  }
  13.159 +}
  13.160  
  13.161  void InterpreterMacroAssembler::profile_call(Register mdp) {
  13.162    if (ProfileInterpreter) {

    14.1 --- a/src/cpu/x86/vm/interp_masm_x86_64.hpp	Fri Oct 18 10:37:26 2013 +0000
    14.2 +++ b/src/cpu/x86/vm/interp_masm_x86_64.hpp	Fri Oct 18 19:44:40 2013 -0700
    14.3 @@ -224,6 +224,9 @@
    14.4  
    14.5    void profile_taken_branch(Register mdp, Register bumped_count);
    14.6    void profile_not_taken_branch(Register mdp);
    14.7 +  void profile_obj_type(Register obj, const Address& mdo_addr);
    14.8 +  void profile_arguments_type(Register mdp, Register callee, Register tmp, bool is_virtual);
    14.9 +  void profile_return_type(Register mdp, Register ret, Register tmp);
   14.10    void profile_call(Register mdp);
   14.11    void profile_final_call(Register mdp);
   14.12    void profile_virtual_call(Register receiver, Register mdp,

    15.1 --- a/src/cpu/x86/vm/macroAssembler_x86.hpp	Fri Oct 18 10:37:26 2013 +0000
    15.2 +++ b/src/cpu/x86/vm/macroAssembler_x86.hpp	Fri Oct 18 19:44:40 2013 -0700
    15.3 @@ -773,6 +773,7 @@
    15.4    void orptr(Register dst, Address src) { LP64_ONLY(orq(dst, src)) NOT_LP64(orl(dst, src)); }
    15.5    void orptr(Register dst, Register src) { LP64_ONLY(orq(dst, src)) NOT_LP64(orl(dst, src)); }
    15.6    void orptr(Register dst, int32_t src) { LP64_ONLY(orq(dst, src)) NOT_LP64(orl(dst, src)); }
    15.7 +  void orptr(Address dst, int32_t imm32) { LP64_ONLY(orq(dst, imm32)) NOT_LP64(orl(dst, imm32)); }
    15.8  
    15.9    void testptr(Register src, int32_t imm32) {  LP64_ONLY(testq(src, imm32)) NOT_LP64(testl(src, imm32)); }
   15.10    void testptr(Register src1, Register src2);

    16.1 --- a/src/cpu/x86/vm/templateInterpreter_x86_32.cpp	Fri Oct 18 10:37:26 2013 +0000
    16.2 +++ b/src/cpu/x86/vm/templateInterpreter_x86_32.cpp	Fri Oct 18 19:44:40 2013 -0700
    16.3 @@ -194,6 +194,12 @@
    16.4    __ restore_bcp();
    16.5    __ restore_locals();
    16.6  
    16.7 +  if (incoming_state == atos) {
    16.8 +    Register mdp = rbx;
    16.9 +    Register tmp = rcx;
   16.10 +    __ profile_return_type(mdp, rax, tmp);
   16.11 +  }
   16.12 +
   16.13    Label L_got_cache, L_giant_index;
   16.14    if (EnableInvokeDynamic) {
   16.15      __ cmpb(Address(rsi, 0), Bytecodes::_invokedynamic);

    17.1 --- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Fri Oct 18 10:37:26 2013 +0000
    17.2 +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Fri Oct 18 19:44:40 2013 -0700
    17.3 @@ -177,6 +177,12 @@
    17.4    __ restore_bcp();
    17.5    __ restore_locals();
    17.6  
    17.7 +  if (state == atos) {
    17.8 +    Register mdp = rbx;
    17.9 +    Register tmp = rcx;
   17.10 +    __ profile_return_type(mdp, rax, tmp);
   17.11 +  }
   17.12 +
   17.13    Label L_got_cache, L_giant_index;
   17.14    if (EnableInvokeDynamic) {
   17.15      __ cmpb(Address(r13, 0), Bytecodes::_invokedynamic);

    18.1 --- a/src/cpu/x86/vm/templateTable_x86_32.cpp	Fri Oct 18 10:37:26 2013 +0000
    18.2 +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp	Fri Oct 18 19:44:40 2013 -0700
    18.3 @@ -2970,6 +2970,7 @@
    18.4  
    18.5    // profile this call
    18.6    __ profile_final_call(rax);
    18.7 +  __ profile_arguments_type(rax, method, rsi, true);
    18.8  
    18.9    __ jump_from_interpreted(method, rax);
   18.10  
   18.11 @@ -2984,6 +2985,7 @@
   18.12  
   18.13    // get target Method* & entry point
   18.14    __ lookup_virtual_method(rax, index, method);
   18.15 +  __ profile_arguments_type(rdx, method, rsi, true);
   18.16    __ jump_from_interpreted(method, rdx);
   18.17  }
   18.18  
   18.19 @@ -3013,6 +3015,7 @@
   18.20    __ null_check(rcx);
   18.21    // do the call
   18.22    __ profile_call(rax);
   18.23 +  __ profile_arguments_type(rax, rbx, rsi, false);
   18.24    __ jump_from_interpreted(rbx, rax);
   18.25  }
   18.26  
   18.27 @@ -3023,6 +3026,7 @@
   18.28    prepare_invoke(byte_no, rbx);  // get f1 Method*
   18.29    // do the call
   18.30    __ profile_call(rax);
   18.31 +  __ profile_arguments_type(rax, rbx, rsi, false);
   18.32    __ jump_from_interpreted(rbx, rax);
   18.33  }
   18.34  
   18.35 @@ -3082,6 +3086,8 @@
   18.36    __ testptr(rbx, rbx);
   18.37    __ jcc(Assembler::zero, no_such_method);
   18.38  
   18.39 +  __ profile_arguments_type(rdx, rbx, rsi, true);
   18.40 +
   18.41    // do the call
   18.42    // rcx: receiver
   18.43    // rbx,: Method*
   18.44 @@ -3138,6 +3144,7 @@
   18.45  
   18.46    // FIXME: profile the LambdaForm also
   18.47    __ profile_final_call(rax);
   18.48 +  __ profile_arguments_type(rdx, rbx_method, rsi, true);
   18.49  
   18.50    __ jump_from_interpreted(rbx_method, rdx);
   18.51  }
   18.52 @@ -3171,6 +3178,7 @@
   18.53    // %%% should make a type profile for any invokedynamic that takes a ref argument
   18.54    // profile this call
   18.55    __ profile_call(rsi);
   18.56 +  __ profile_arguments_type(rdx, rbx, rsi, false);
   18.57  
   18.58    __ verify_oop(rax_callsite);
   18.59  

    19.1 --- a/src/cpu/x86/vm/templateTable_x86_64.cpp	Fri Oct 18 10:37:26 2013 +0000
    19.2 +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp	Fri Oct 18 19:44:40 2013 -0700
    19.3 @@ -3026,6 +3026,7 @@
    19.4  
    19.5    // profile this call
    19.6    __ profile_final_call(rax);
    19.7 +  __ profile_arguments_type(rax, method, r13, true);
    19.8  
    19.9    __ jump_from_interpreted(method, rax);
   19.10  
   19.11 @@ -3040,6 +3041,7 @@
   19.12  
   19.13    // get target Method* & entry point
   19.14    __ lookup_virtual_method(rax, index, method);
   19.15 +  __ profile_arguments_type(rdx, method, r13, true);
   19.16    __ jump_from_interpreted(method, rdx);
   19.17  }
   19.18  
   19.19 @@ -3069,6 +3071,7 @@
   19.20    __ null_check(rcx);
   19.21    // do the call
   19.22    __ profile_call(rax);
   19.23 +  __ profile_arguments_type(rax, rbx, r13, false);
   19.24    __ jump_from_interpreted(rbx, rax);
   19.25  }
   19.26  
   19.27 @@ -3079,6 +3082,7 @@
   19.28    prepare_invoke(byte_no, rbx);  // get f1 Method*
   19.29    // do the call
   19.30    __ profile_call(rax);
   19.31 +  __ profile_arguments_type(rax, rbx, r13, false);
   19.32    __ jump_from_interpreted(rbx, rax);
   19.33  }
   19.34  
   19.35 @@ -3136,6 +3140,8 @@
   19.36    __ testptr(rbx, rbx);
   19.37    __ jcc(Assembler::zero, no_such_method);
   19.38  
   19.39 +  __ profile_arguments_type(rdx, rbx, r13, true);
   19.40 +
   19.41    // do the call
   19.42    // rcx: receiver
   19.43    // rbx,: Method*
   19.44 @@ -3193,6 +3199,7 @@
   19.45  
   19.46    // FIXME: profile the LambdaForm also
   19.47    __ profile_final_call(rax);
   19.48 +  __ profile_arguments_type(rdx, rbx_method, r13, true);
   19.49  
   19.50    __ jump_from_interpreted(rbx_method, rdx);
   19.51  }
   19.52 @@ -3226,6 +3233,7 @@
   19.53    // %%% should make a type profile for any invokedynamic that takes a ref argument
   19.54    // profile this call
   19.55    __ profile_call(r13);
   19.56 +  __ profile_arguments_type(rdx, rbx_method, r13, false);
   19.57  
   19.58    __ verify_oop(rax_callsite);
   19.59  

    20.1 --- a/src/share/vm/c1/c1_Canonicalizer.cpp	Fri Oct 18 10:37:26 2013 +0000
    20.2 +++ b/src/share/vm/c1/c1_Canonicalizer.cpp	Fri Oct 18 19:44:40 2013 -0700
    20.3 @@ -935,6 +935,7 @@
    20.4  void Canonicalizer::do_UnsafePrefetchRead (UnsafePrefetchRead*  x) {}
    20.5  void Canonicalizer::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {}
    20.6  void Canonicalizer::do_ProfileCall(ProfileCall* x) {}
    20.7 +void Canonicalizer::do_ProfileReturnType(ProfileReturnType* x) {}
    20.8  void Canonicalizer::do_ProfileInvoke(ProfileInvoke* x) {}
    20.9  void Canonicalizer::do_RuntimeCall(RuntimeCall* x) {}
   20.10  void Canonicalizer::do_RangeCheckPredicate(RangeCheckPredicate* x) {}

    21.1 --- a/src/share/vm/c1/c1_Canonicalizer.hpp	Fri Oct 18 10:37:26 2013 +0000
    21.2 +++ b/src/share/vm/c1/c1_Canonicalizer.hpp	Fri Oct 18 19:44:40 2013 -0700
    21.3 @@ -104,6 +104,7 @@
    21.4    virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x);
    21.5    virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
    21.6    virtual void do_ProfileCall    (ProfileCall*     x);
    21.7 +  virtual void do_ProfileReturnType (ProfileReturnType*  x);
    21.8    virtual void do_ProfileInvoke  (ProfileInvoke*   x);
    21.9    virtual void do_RuntimeCall    (RuntimeCall*     x);
   21.10    virtual void do_MemBar         (MemBar*          x);

    22.1 --- a/src/share/vm/c1/c1_Compilation.cpp	Fri Oct 18 10:37:26 2013 +0000
    22.2 +++ b/src/share/vm/c1/c1_Compilation.cpp	Fri Oct 18 19:44:40 2013 -0700
    22.3 @@ -601,6 +601,17 @@
    22.4    }
    22.5  }
    22.6  
    22.7 +ciKlass* Compilation::cha_exact_type(ciType* type) {
    22.8 +  if (type != NULL && type->is_loaded() && type->is_instance_klass()) {
    22.9 +    ciInstanceKlass* ik = type->as_instance_klass();
   22.10 +    assert(ik->exact_klass() == NULL, "no cha for final klass");
   22.11 +    if (DeoptC1 && UseCHA && !(ik->has_subklass() || ik->is_interface())) {
   22.12 +      dependency_recorder()->assert_leaf_type(ik);
   22.13 +      return ik;
   22.14 +    }
   22.15 +  }
   22.16 +  return NULL;
   22.17 +}
   22.18  
   22.19  void Compilation::print_timers() {
   22.20    // tty->print_cr("    Native methods         : %6.3f s, Average : %2.3f", CompileBroker::_t_native_compilation.seconds(), CompileBroker::_t_native_compilation.seconds() / CompileBroker::_total_native_compile_count);

    23.1 --- a/src/share/vm/c1/c1_Compilation.hpp	Fri Oct 18 10:37:26 2013 +0000
    23.2 +++ b/src/share/vm/c1/c1_Compilation.hpp	Fri Oct 18 19:44:40 2013 -0700
    23.3 @@ -246,6 +246,8 @@
    23.4        (RangeCheckElimination || UseLoopInvariantCodeMotion) &&
    23.5        method()->method_data()->trap_count(Deoptimization::Reason_none) == 0;
    23.6    }
    23.7 +
    23.8 +  ciKlass* cha_exact_type(ciType* type);
    23.9  };
   23.10  
   23.11  

    24.1 --- a/src/share/vm/c1/c1_Compiler.cpp	Fri Oct 18 10:37:26 2013 +0000
    24.2 +++ b/src/share/vm/c1/c1_Compiler.cpp	Fri Oct 18 19:44:40 2013 -0700
    24.3 @@ -42,26 +42,16 @@
    24.4  #include "runtime/interfaceSupport.hpp"
    24.5  #include "runtime/sharedRuntime.hpp"
    24.6  
    24.7 -volatile int Compiler::_runtimes = uninitialized;
    24.8  
    24.9 -Compiler::Compiler() {
   24.10 -}
   24.11 +Compiler::Compiler () {}
   24.12  
   24.13 -
   24.14 -Compiler::~Compiler() {
   24.15 -  Unimplemented();
   24.16 -}
   24.17 -
   24.18 -
   24.19 -void Compiler::initialize_all() {
   24.20 +void Compiler::init_c1_runtime() {
   24.21    BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
   24.22    Arena* arena = new (mtCompiler) Arena();
   24.23    Runtime1::initialize(buffer_blob);
   24.24    FrameMap::initialize();
   24.25    // initialize data structures
   24.26    ValueType::initialize(arena);
   24.27 -  // Instruction::initialize();
   24.28 -  // BlockBegin::initialize();
   24.29    GraphBuilder::initialize();
   24.30    // note: to use more than one instance of LinearScan at a time this function call has to
   24.31    //       be moved somewhere outside of this constructor:
   24.32 @@ -70,32 +60,33 @@
   24.33  
   24.34  
   24.35  void Compiler::initialize() {
   24.36 -  if (_runtimes != initialized) {
   24.37 -    initialize_runtimes( initialize_all, &_runtimes);
   24.38 +  // Buffer blob must be allocated per C1 compiler thread at startup
   24.39 +  BufferBlob* buffer_blob = init_buffer_blob();
   24.40 +
   24.41 +  if (should_perform_init()) {
   24.42 +    if (buffer_blob == NULL) {
   24.43 +      // When we come here we are in state 'initializing'; entire C1 compilation
   24.44 +      // can be shut down.
   24.45 +      set_state(failed);
   24.46 +    } else {
   24.47 +      init_c1_runtime();
   24.48 +      set_state(initialized);
   24.49 +    }
   24.50    }
   24.51 -  mark_initialized();
   24.52  }
   24.53  
   24.54 -
   24.55 -BufferBlob* Compiler::get_buffer_blob(ciEnv* env) {
   24.56 +BufferBlob* Compiler::init_buffer_blob() {
   24.57    // Allocate buffer blob once at startup since allocation for each
   24.58    // compilation seems to be too expensive (at least on Intel win32).
   24.59 -  BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
   24.60 -  if (buffer_blob != NULL) {
   24.61 -    return buffer_blob;
   24.62 -  }
   24.63 +  assert (CompilerThread::current()->get_buffer_blob() == NULL, "Should initialize only once");
   24.64  
   24.65    // setup CodeBuffer.  Preallocate a BufferBlob of size
   24.66    // NMethodSizeLimit plus some extra space for constants.
   24.67    int code_buffer_size = Compilation::desired_max_code_buffer_size() +
   24.68      Compilation::desired_max_constant_size();
   24.69  
   24.70 -  buffer_blob = BufferBlob::create("Compiler1 temporary CodeBuffer",
   24.71 -                                   code_buffer_size);
   24.72 -  if (buffer_blob == NULL) {
   24.73 -    CompileBroker::handle_full_code_cache();
   24.74 -    env->record_failure("CodeCache is full");
   24.75 -  } else {
   24.76 +  BufferBlob* buffer_blob = BufferBlob::create("C1 temporary CodeBuffer", code_buffer_size);
   24.77 +  if (buffer_blob != NULL) {
   24.78      CompilerThread::current()->set_buffer_blob(buffer_blob);
   24.79    }
   24.80  
   24.81 @@ -104,15 +95,8 @@
   24.82  
   24.83  
   24.84  void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
   24.85 -  BufferBlob* buffer_blob = Compiler::get_buffer_blob(env);
   24.86 -  if (buffer_blob == NULL) {
   24.87 -    return;
   24.88 -  }
   24.89 -
   24.90 -  if (!is_initialized()) {
   24.91 -    initialize();
   24.92 -  }
   24.93 -
   24.94 +  BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
   24.95 +  assert(buffer_blob != NULL, "Must exist");
   24.96    // invoke compilation
   24.97    {
   24.98      // We are nested here because we need for the destructor

    25.1 --- a/src/share/vm/c1/c1_Compiler.hpp	Fri Oct 18 10:37:26 2013 +0000
    25.2 +++ b/src/share/vm/c1/c1_Compiler.hpp	Fri Oct 18 19:44:40 2013 -0700
    25.3 @@ -30,11 +30,9 @@
    25.4  // There is one instance of the Compiler per CompilerThread.
    25.5  
    25.6  class Compiler: public AbstractCompiler {
    25.7 -
    25.8   private:
    25.9 -
   25.10 - // Tracks whether runtime has been initialized
   25.11 - static volatile int _runtimes;
   25.12 +  static void init_c1_runtime();
   25.13 +  BufferBlob* init_buffer_blob();
   25.14  
   25.15   public:
   25.16    // Creation
   25.17 @@ -46,19 +44,12 @@
   25.18  
   25.19    virtual bool is_c1()                           { return true; };
   25.20  
   25.21 -  BufferBlob* get_buffer_blob(ciEnv* env);
   25.22 -
   25.23    // Missing feature tests
   25.24    virtual bool supports_native()                 { return true; }
   25.25    virtual bool supports_osr   ()                 { return true; }
   25.26  
   25.27 -  // Customization
   25.28 -  virtual bool needs_adapters         ()         { return false; }
   25.29 -  virtual bool needs_stubs            ()         { return false; }
   25.30 -
   25.31    // Initialization
   25.32    virtual void initialize();
   25.33 -  static  void initialize_all();
   25.34  
   25.35    // Compilation entry point for methods
   25.36    virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci);

    26.1 --- a/src/share/vm/c1/c1_GraphBuilder.cpp	Fri Oct 18 10:37:26 2013 +0000
    26.2 +++ b/src/share/vm/c1/c1_GraphBuilder.cpp	Fri Oct 18 19:44:40 2013 -0700
    26.3 @@ -1466,9 +1466,22 @@
    26.4      // State at end of inlined method is the state of the caller
    26.5      // without the method parameters on stack, including the
    26.6      // return value, if any, of the inlined method on operand stack.
    26.7 +    int invoke_bci = state()->caller_state()->bci();
    26.8      set_state(state()->caller_state()->copy_for_parsing());
    26.9      if (x != NULL) {
   26.10        state()->push(x->type(), x);
   26.11 +      if (profile_calls() && MethodData::profile_return() && x->type()->is_object_kind()) {
   26.12 +        ciMethod* caller = state()->scope()->method();
   26.13 +        ciMethodData* md = caller->method_data_or_null();
   26.14 +        ciProfileData* data = md->bci_to_data(invoke_bci);
   26.15 +        if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
   26.16 +          bool has_return = data->is_CallTypeData() ? ((ciCallTypeData*)data)->has_return() : ((ciVirtualCallTypeData*)data)->has_return();
   26.17 +          // May not be true in case of an inlined call through a method handle intrinsic.
   26.18 +          if (has_return) {
   26.19 +            profile_return_type(x, method(), caller, invoke_bci);
   26.20 +          }
   26.21 +        }
   26.22 +      }
   26.23      }
   26.24      Goto* goto_callee = new Goto(continuation(), false);
   26.25  
   26.26 @@ -1658,6 +1671,42 @@
   26.27    return compilation()->dependency_recorder();
   26.28  }
   26.29  
   26.30 +// How many arguments do we want to profile?
   26.31 +Values* GraphBuilder::args_list_for_profiling(int& start, bool may_have_receiver) {
   26.32 +  int n = 0;
   26.33 +  assert(start == 0, "should be initialized");
   26.34 +  if (MethodData::profile_arguments()) {
   26.35 +    ciProfileData* data = method()->method_data()->bci_to_data(bci());
   26.36 +    if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
   26.37 +      n = data->is_CallTypeData() ? data->as_CallTypeData()->number_of_arguments() : data->as_VirtualCallTypeData()->number_of_arguments();
   26.38 +      bool has_receiver = may_have_receiver && Bytecodes::has_receiver(method()->java_code_at_bci(bci()));
   26.39 +      start = has_receiver ? 1 : 0;
   26.40 +    }
   26.41 +  }
   26.42 +  if (n > 0) {
   26.43 +    return new Values(n);
   26.44 +  }
   26.45 +  return NULL;
   26.46 +}
   26.47 +
   26.48 +// Collect arguments that we want to profile in a list
   26.49 +Values* GraphBuilder::collect_args_for_profiling(Values* args, bool may_have_receiver) {
   26.50 +  int start = 0;
   26.51 +  Values* obj_args = args_list_for_profiling(start, may_have_receiver);
   26.52 +  if (obj_args == NULL) {
   26.53 +    return NULL;
   26.54 +  }
   26.55 +  int s = obj_args->size();
   26.56 +  for (int i = start, j = 0; j < s; i++) {
   26.57 +    if (args->at(i)->type()->is_object_kind()) {
   26.58 +      obj_args->push(args->at(i));
   26.59 +      j++;
   26.60 +    }
   26.61 +  }
   26.62 +  assert(s == obj_args->length(), "missed on arg?");
   26.63 +  return obj_args;
   26.64 +}
   26.65 +
   26.66  
   26.67  void GraphBuilder::invoke(Bytecodes::Code code) {
   26.68    bool will_link;
   26.69 @@ -1957,7 +2006,7 @@
   26.70        } else if (exact_target != NULL) {
   26.71          target_klass = exact_target->holder();
   26.72        }
   26.73 -      profile_call(target, recv, target_klass);
   26.74 +      profile_call(target, recv, target_klass, collect_args_for_profiling(args, false), false);
   26.75      }
   26.76    }
   26.77  
   26.78 @@ -1972,6 +2021,9 @@
   26.79        push(result_type, result);
   26.80      }
   26.81    }
   26.82 +  if (profile_calls() && MethodData::profile_return() && result_type->is_object_kind()) {
   26.83 +    profile_return_type(result, target);
   26.84 +  }
   26.85  }
   26.86  
   26.87  
   26.88 @@ -3509,7 +3561,7 @@
   26.89            recv = args->at(0);
   26.90            null_check(recv);
   26.91          }
   26.92 -        profile_call(callee, recv, NULL);
   26.93 +        profile_call(callee, recv, NULL, collect_args_for_profiling(args, true), true);
   26.94        }
   26.95      }
   26.96    }
   26.97 @@ -3520,6 +3572,10 @@
   26.98    Value value = append_split(result);
   26.99    if (result_type != voidType) push(result_type, value);
  26.100  
  26.101 +  if (callee != method() && profile_calls() && MethodData::profile_return() && result_type->is_object_kind()) {
  26.102 +    profile_return_type(result, callee);
  26.103 +  }
  26.104 +
  26.105    // done
  26.106    return true;
  26.107  }
  26.108 @@ -3763,7 +3819,28 @@
  26.109      compilation()->set_would_profile(true);
  26.110  
  26.111      if (profile_calls()) {
  26.112 -      profile_call(callee, recv, holder_known ? callee->holder() : NULL);
  26.113 +      int start = 0;
  26.114 +      Values* obj_args = args_list_for_profiling(start, has_receiver);
  26.115 +      if (obj_args != NULL) {
  26.116 +        int s = obj_args->size();
  26.117 +        // if called through method handle invoke, some arguments may have been popped
  26.118 +        for (int i = args_base+start, j = 0; j < obj_args->size() && i < state()->stack_size(); ) {
  26.119 +          Value v = state()->stack_at_inc(i);
  26.120 +          if (v->type()->is_object_kind()) {
  26.121 +            obj_args->push(v);
  26.122 +            j++;
  26.123 +          }
  26.124 +        }
  26.125 +#ifdef ASSERT
  26.126 +        {
  26.127 +          bool ignored_will_link;
  26.128 +          ciSignature* declared_signature = NULL;
  26.129 +          ciMethod* real_target = method()->get_method_at_bci(bci(), ignored_will_link, &declared_signature);
  26.130 +          assert(s == obj_args->length() || real_target->is_method_handle_intrinsic(), "missed on arg?");
  26.131 +        }
  26.132 +#endif
  26.133 +      }
  26.134 +      profile_call(callee, recv, holder_known ? callee->holder() : NULL, obj_args, true);
  26.135      }
  26.136    }
  26.137  
  26.138 @@ -4251,8 +4328,23 @@
  26.139  }
  26.140  #endif // PRODUCT
  26.141  
  26.142 -void GraphBuilder::profile_call(ciMethod* callee, Value recv, ciKlass* known_holder) {
  26.143 -  append(new ProfileCall(method(), bci(), callee, recv, known_holder));
  26.144 +void GraphBuilder::profile_call(ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined) {
  26.145 +  append(new ProfileCall(method(), bci(), callee, recv, known_holder, obj_args, inlined));
  26.146 +}
  26.147 +
  26.148 +void GraphBuilder::profile_return_type(Value ret, ciMethod* callee, ciMethod* m, int invoke_bci) {
  26.149 +  assert((m == NULL) == (invoke_bci < 0), "invalid method and invalid bci together");
  26.150 +  if (m == NULL) {
  26.151 +    m = method();
  26.152 +  }
  26.153 +  if (invoke_bci < 0) {
  26.154 +    invoke_bci = bci();
  26.155 +  }
  26.156 +  ciMethodData* md = m->method_data_or_null();
  26.157 +  ciProfileData* data = md->bci_to_data(invoke_bci);
  26.158 +  if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
  26.159 +    append(new ProfileReturnType(m , invoke_bci, callee, ret));
  26.160 +  }
  26.161  }
  26.162  
  26.163  void GraphBuilder::profile_invocation(ciMethod* callee, ValueStack* state) {

    27.1 --- a/src/share/vm/c1/c1_GraphBuilder.hpp	Fri Oct 18 10:37:26 2013 +0000
    27.2 +++ b/src/share/vm/c1/c1_GraphBuilder.hpp	Fri Oct 18 19:44:40 2013 -0700
    27.3 @@ -374,7 +374,8 @@
    27.4  
    27.5    void print_inlining(ciMethod* callee, const char* msg = NULL, bool success = true);
    27.6  
    27.7 -  void profile_call(ciMethod* callee, Value recv, ciKlass* predicted_holder);
    27.8 +  void profile_call(ciMethod* callee, Value recv, ciKlass* predicted_holder, Values* obj_args, bool inlined);
    27.9 +  void profile_return_type(Value ret, ciMethod* callee, ciMethod* m = NULL, int bci = -1);
   27.10    void profile_invocation(ciMethod* inlinee, ValueStack* state);
   27.11  
   27.12    // Shortcuts to profiling control.
   27.13 @@ -386,6 +387,9 @@
   27.14    bool profile_inlined_calls() { return _compilation->profile_inlined_calls(); }
   27.15    bool profile_checkcasts()    { return _compilation->profile_checkcasts();    }
   27.16  
   27.17 +  Values* args_list_for_profiling(int& start, bool may_have_receiver);
   27.18 +  Values* collect_args_for_profiling(Values* args, bool may_have_receiver);
   27.19 +
   27.20   public:
   27.21    NOT_PRODUCT(void print_stats();)
   27.22  

    28.1 --- a/src/share/vm/c1/c1_Instruction.cpp	Fri Oct 18 10:37:26 2013 +0000
    28.2 +++ b/src/share/vm/c1/c1_Instruction.cpp	Fri Oct 18 19:44:40 2013 -0700
    28.3 @@ -104,6 +104,14 @@
    28.4    }
    28.5  }
    28.6  
    28.7 +ciType* Instruction::exact_type() const {
    28.8 +  ciType* t =  declared_type();
    28.9 +  if (t != NULL && t->is_klass()) {
   28.10 +    return t->as_klass()->exact_klass();
   28.11 +  }
   28.12 +  return NULL;
   28.13 +}
   28.14 +
   28.15  
   28.16  #ifndef PRODUCT
   28.17  void Instruction::check_state(ValueStack* state) {
   28.18 @@ -135,9 +143,7 @@
   28.19  
   28.20  // perform constant and interval tests on index value
   28.21  bool AccessIndexed::compute_needs_range_check() {
   28.22 -
   28.23    if (length()) {
   28.24 -
   28.25      Constant* clength = length()->as_Constant();
   28.26      Constant* cindex = index()->as_Constant();
   28.27      if (clength && cindex) {
   28.28 @@ -157,34 +163,8 @@
   28.29  }
   28.30  
   28.31  
   28.32 -ciType* Local::exact_type() const {
   28.33 -  ciType* type = declared_type();
   28.34 -
   28.35 -  // for primitive arrays, the declared type is the exact type
   28.36 -  if (type->is_type_array_klass()) {
   28.37 -    return type;
   28.38 -  } else if (type->is_instance_klass()) {
   28.39 -    ciInstanceKlass* ik = (ciInstanceKlass*)type;
   28.40 -    if (ik->is_loaded() && ik->is_final() && !ik->is_interface()) {
   28.41 -      return type;
   28.42 -    }
   28.43 -  } else if (type->is_obj_array_klass()) {
   28.44 -    ciObjArrayKlass* oak = (ciObjArrayKlass*)type;
   28.45 -    ciType* base = oak->base_element_type();
   28.46 -    if (base->is_instance_klass()) {
   28.47 -      ciInstanceKlass* ik = base->as_instance_klass();
   28.48 -      if (ik->is_loaded() && ik->is_final()) {
   28.49 -        return type;
   28.50 -      }
   28.51 -    } else if (base->is_primitive_type()) {
   28.52 -      return type;
   28.53 -    }
   28.54 -  }
   28.55 -  return NULL;
   28.56 -}
   28.57 -
   28.58  ciType* Constant::exact_type() const {
   28.59 -  if (type()->is_object()) {
   28.60 +  if (type()->is_object() && type()->as_ObjectType()->is_loaded()) {
   28.61      return type()->as_ObjectType()->exact_type();
   28.62    }
   28.63    return NULL;
   28.64 @@ -192,19 +172,18 @@
   28.65  
   28.66  ciType* LoadIndexed::exact_type() const {
   28.67    ciType* array_type = array()->exact_type();
   28.68 -  if (array_type == NULL) {
   28.69 -    return NULL;
   28.70 -  }
   28.71 -  assert(array_type->is_array_klass(), "what else?");
   28.72 -  ciArrayKlass* ak = (ciArrayKlass*)array_type;
   28.73 +  if (array_type != NULL) {
   28.74 +    assert(array_type->is_array_klass(), "what else?");
   28.75 +    ciArrayKlass* ak = (ciArrayKlass*)array_type;
   28.76  
   28.77 -  if (ak->element_type()->is_instance_klass()) {
   28.78 -    ciInstanceKlass* ik = (ciInstanceKlass*)ak->element_type();
   28.79 -    if (ik->is_loaded() && ik->is_final()) {
   28.80 -      return ik;
   28.81 +    if (ak->element_type()->is_instance_klass()) {
   28.82 +      ciInstanceKlass* ik = (ciInstanceKlass*)ak->element_type();
   28.83 +      if (ik->is_loaded() && ik->is_final()) {
   28.84 +        return ik;
   28.85 +      }
   28.86      }
   28.87    }
   28.88 -  return NULL;
   28.89 +  return Instruction::exact_type();
   28.90  }
   28.91  
   28.92  
   28.93 @@ -224,22 +203,6 @@
   28.94  }
   28.95  
   28.96  
   28.97 -ciType* LoadField::exact_type() const {
   28.98 -  ciType* type = declared_type();
   28.99 -  // for primitive arrays, the declared type is the exact type
  28.100 -  if (type->is_type_array_klass()) {
  28.101 -    return type;
  28.102 -  }
  28.103 -  if (type->is_instance_klass()) {
  28.104 -    ciInstanceKlass* ik = (ciInstanceKlass*)type;
  28.105 -    if (ik->is_loaded() && ik->is_final()) {
  28.106 -      return type;
  28.107 -    }
  28.108 -  }
  28.109 -  return NULL;
  28.110 -}
  28.111 -
  28.112 -
  28.113  ciType* NewTypeArray::exact_type() const {
  28.114    return ciTypeArrayKlass::make(elt_type());
  28.115  }
  28.116 @@ -264,16 +227,6 @@
  28.117    return klass();
  28.118  }
  28.119  
  28.120 -ciType* CheckCast::exact_type() const {
  28.121 -  if (klass()->is_instance_klass()) {
  28.122 -    ciInstanceKlass* ik = (ciInstanceKlass*)klass();
  28.123 -    if (ik->is_loaded() && ik->is_final()) {
  28.124 -      return ik;
  28.125 -    }
  28.126 -  }
  28.127 -  return NULL;
  28.128 -}
  28.129 -
  28.130  // Implementation of ArithmeticOp
  28.131  
  28.132  bool ArithmeticOp::is_commutative() const {

    29.1 --- a/src/share/vm/c1/c1_Instruction.hpp	Fri Oct 18 10:37:26 2013 +0000
    29.2 +++ b/src/share/vm/c1/c1_Instruction.hpp	Fri Oct 18 19:44:40 2013 -0700
    29.3 @@ -107,6 +107,7 @@
    29.4  class         UnsafePrefetchRead;
    29.5  class         UnsafePrefetchWrite;
    29.6  class   ProfileCall;
    29.7 +class   ProfileReturnType;
    29.8  class   ProfileInvoke;
    29.9  class   RuntimeCall;
   29.10  class   MemBar;
   29.11 @@ -211,6 +212,7 @@
   29.12    virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) = 0;
   29.13    virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
   29.14    virtual void do_ProfileCall    (ProfileCall*     x) = 0;
   29.15 +  virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;
   29.16    virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
   29.17    virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
   29.18    virtual void do_MemBar         (MemBar*          x) = 0;
   29.19 @@ -322,6 +324,36 @@
   29.20      _type = type;
   29.21    }
   29.22  
   29.23 +  // Helper class to keep track of which arguments need a null check
   29.24 +  class ArgsNonNullState {
   29.25 +  private:
   29.26 +    int _nonnull_state; // mask identifying which args are nonnull
   29.27 +  public:
   29.28 +    ArgsNonNullState()
   29.29 +      : _nonnull_state(AllBits) {}
   29.30 +
   29.31 +    // Does argument number i needs a null check?
   29.32 +    bool arg_needs_null_check(int i) const {
   29.33 +      // No data is kept for arguments starting at position 33 so
   29.34 +      // conservatively assume that they need a null check.
   29.35 +      if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
   29.36 +        return is_set_nth_bit(_nonnull_state, i);
   29.37 +      }
   29.38 +      return true;
   29.39 +    }
   29.40 +
   29.41 +    // Set whether argument number i needs a null check or not
   29.42 +    void set_arg_needs_null_check(int i, bool check) {
   29.43 +      if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
   29.44 +        if (check) {
   29.45 +          _nonnull_state |= nth_bit(i);
   29.46 +        } else {
   29.47 +          _nonnull_state &= ~(nth_bit(i));
   29.48 +        }
   29.49 +      }
   29.50 +    }
   29.51 +  };
   29.52 +
   29.53   public:
   29.54    void* operator new(size_t size) throw() {
   29.55      Compilation* c = Compilation::current();
   29.56 @@ -566,7 +598,7 @@
   29.57    virtual void other_values_do(ValueVisitor* f)   { /* usually no other - override on demand */ }
   29.58            void       values_do(ValueVisitor* f)   { input_values_do(f); state_values_do(f); other_values_do(f); }
   29.59  
   29.60 -  virtual ciType* exact_type() const             { return NULL; }
   29.61 +  virtual ciType* exact_type() const;
   29.62    virtual ciType* declared_type() const          { return NULL; }
   29.63  
   29.64    // hashing
   29.65 @@ -689,7 +721,6 @@
   29.66    int java_index() const                         { return _java_index; }
   29.67  
   29.68    virtual ciType* declared_type() const          { return _declared_type; }
   29.69 -  virtual ciType* exact_type() const;
   29.70  
   29.71    // generic
   29.72    virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
   29.73 @@ -806,7 +837,6 @@
   29.74    {}
   29.75  
   29.76    ciType* declared_type() const;
   29.77 -  ciType* exact_type() const;
   29.78  
   29.79    // generic
   29.80    HASHING2(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if needs patching or if volatile
   29.81 @@ -1299,6 +1329,7 @@
   29.82  
   29.83    virtual bool needs_exception_state() const     { return false; }
   29.84  
   29.85 +  ciType* exact_type() const                     { return NULL; }
   29.86    ciType* declared_type() const;
   29.87  
   29.88    // generic
   29.89 @@ -1422,7 +1453,6 @@
   29.90    }
   29.91  
   29.92    ciType* declared_type() const;
   29.93 -  ciType* exact_type() const;
   29.94  };
   29.95  
   29.96  
   29.97 @@ -1490,7 +1520,7 @@
   29.98    vmIntrinsics::ID _id;
   29.99    Values*          _args;
  29.100    Value            _recv;
  29.101 -  int              _nonnull_state; // mask identifying which args are nonnull
  29.102 +  ArgsNonNullState _nonnull_state;
  29.103  
  29.104   public:
  29.105    // preserves_state can be set to true for Intrinsics
  29.106 @@ -1511,7 +1541,6 @@
  29.107    , _id(id)
  29.108    , _args(args)
  29.109    , _recv(NULL)
  29.110 -  , _nonnull_state(AllBits)
  29.111    {
  29.112      assert(args != NULL, "args must exist");
  29.113      ASSERT_VALUES
  29.114 @@ -1537,21 +1566,12 @@
  29.115    Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
  29.116    bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
  29.117  
  29.118 -  bool arg_needs_null_check(int i) {
  29.119 -    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
  29.120 -      return is_set_nth_bit(_nonnull_state, i);
  29.121 -    }
  29.122 -    return true;
  29.123 +  bool arg_needs_null_check(int i) const {
  29.124 +    return _nonnull_state.arg_needs_null_check(i);
  29.125    }
  29.126  
  29.127    void set_arg_needs_null_check(int i, bool check) {
  29.128 -    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
  29.129 -      if (check) {
  29.130 -        _nonnull_state |= nth_bit(i);
  29.131 -      } else {
  29.132 -        _nonnull_state &= ~(nth_bit(i));
  29.133 -      }
  29.134 -    }
  29.135 +    _nonnull_state.set_arg_needs_null_check(i, check);
  29.136    }
  29.137  
  29.138    // generic
  29.139 @@ -2450,34 +2470,87 @@
  29.140  
  29.141  LEAF(ProfileCall, Instruction)
  29.142   private:
  29.143 -  ciMethod* _method;
  29.144 -  int       _bci_of_invoke;
  29.145 -  ciMethod* _callee;         // the method that is called at the given bci
  29.146 -  Value     _recv;
  29.147 -  ciKlass*  _known_holder;
  29.148 +  ciMethod*        _method;
  29.149 +  int              _bci_of_invoke;
  29.150 +  ciMethod*        _callee;         // the method that is called at the given bci
  29.151 +  Value            _recv;
  29.152 +  ciKlass*         _known_holder;
  29.153 +  Values*          _obj_args;       // arguments for type profiling
  29.154 +  ArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
  29.155 +  bool             _inlined;        // Are we profiling a call that is inlined
  29.156  
  29.157   public:
  29.158 -  ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder)
  29.159 +  ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
  29.160      : Instruction(voidType)
  29.161      , _method(method)
  29.162      , _bci_of_invoke(bci)
  29.163      , _callee(callee)
  29.164      , _recv(recv)
  29.165      , _known_holder(known_holder)
  29.166 +    , _obj_args(obj_args)
  29.167 +    , _inlined(inlined)
  29.168    {
  29.169      // The ProfileCall has side-effects and must occur precisely where located
  29.170      pin();
  29.171    }
  29.172  
  29.173 -  ciMethod* method()      { return _method; }
  29.174 -  int bci_of_invoke()     { return _bci_of_invoke; }
  29.175 -  ciMethod* callee()      { return _callee; }
  29.176 -  Value recv()            { return _recv; }
  29.177 -  ciKlass* known_holder() { return _known_holder; }
  29.178 -
  29.179 -  virtual void input_values_do(ValueVisitor* f)   { if (_recv != NULL) f->visit(&_recv); }
  29.180 +  ciMethod* method()             const { return _method; }
  29.181 +  int bci_of_invoke()            const { return _bci_of_invoke; }
  29.182 +  ciMethod* callee()             const { return _callee; }
  29.183 +  Value recv()                   const { return _recv; }
  29.184 +  ciKlass* known_holder()        const { return _known_holder; }
  29.185 +  int nb_profiled_args()         const { return _obj_args == NULL ? 0 : _obj_args->length(); }
  29.186 +  Value profiled_arg_at(int i)   const { return _obj_args->at(i); }
  29.187 +  bool arg_needs_null_check(int i) const {
  29.188 +    return _nonnull_state.arg_needs_null_check(i);
  29.189 +  }
  29.190 +  bool inlined()                 const { return _inlined; }
  29.191 +
  29.192 +  void set_arg_needs_null_check(int i, bool check) {
  29.193 +    _nonnull_state.set_arg_needs_null_check(i, check);
  29.194 +  }
  29.195 +
  29.196 +  virtual void input_values_do(ValueVisitor* f)   {
  29.197 +    if (_recv != NULL) {
  29.198 +      f->visit(&_recv);
  29.199 +    }
  29.200 +    for (int i = 0; i < nb_profiled_args(); i++) {
  29.201 +      f->visit(_obj_args->adr_at(i));
  29.202 +    }
  29.203 +  }
  29.204  };
  29.205  
  29.206 +LEAF(ProfileReturnType, Instruction)
  29.207 + private:
  29.208 +  ciMethod*        _method;
  29.209 +  ciMethod*        _callee;
  29.210 +  int              _bci_of_invoke;
  29.211 +  Value            _ret;
  29.212 +
  29.213 + public:
  29.214 +  ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
  29.215 +    : Instruction(voidType)
  29.216 +    , _method(method)
  29.217 +    , _callee(callee)
  29.218 +    , _bci_of_invoke(bci)
  29.219 +    , _ret(ret)
  29.220 +  {
  29.221 +    set_needs_null_check(true);
  29.222 +    // The ProfileType has side-effects and must occur precisely where located
  29.223 +    pin();
  29.224 +  }
  29.225 +
  29.226 +  ciMethod* method()             const { return _method; }
  29.227 +  ciMethod* callee()             const { return _callee; }
  29.228 +  int bci_of_invoke()            const { return _bci_of_invoke; }
  29.229 +  Value ret()                    const { return _ret; }
  29.230 +
  29.231 +  virtual void input_values_do(ValueVisitor* f)   {
  29.232 +    if (_ret != NULL) {
  29.233 +      f->visit(&_ret);
  29.234 +    }
  29.235 +  }
  29.236 +};
  29.237  
  29.238  // Call some C runtime function that doesn't safepoint,
  29.239  // optionally passing the current thread as the first argument.

    30.1 --- a/src/share/vm/c1/c1_InstructionPrinter.cpp	Fri Oct 18 10:37:26 2013 +0000
    30.2 +++ b/src/share/vm/c1/c1_InstructionPrinter.cpp	Fri Oct 18 19:44:40 2013 -0700
    30.3 @@ -892,10 +892,24 @@
    30.4    if (x->known_holder() != NULL) {
    30.5      output()->print(", ");
    30.6      print_klass(x->known_holder());
    30.7 +    output()->print(" ");
    30.8 +  }
    30.9 +  for (int i = 0; i < x->nb_profiled_args(); i++) {
   30.10 +    if (i > 0) output()->print(", ");
   30.11 +    print_value(x->profiled_arg_at(i));
   30.12 +    if (x->arg_needs_null_check(i)) {
   30.13 +      output()->print(" [NC]");
   30.14 +    }
   30.15    }
   30.16    output()->put(')');
   30.17  }
   30.18  
   30.19 +void InstructionPrinter::do_ProfileReturnType(ProfileReturnType* x) {
   30.20 +  output()->print("profile ret type ");
   30.21 +  print_value(x->ret());
   30.22 +  output()->print(" %s.%s", x->method()->holder()->name()->as_utf8(), x->method()->name()->as_utf8());
   30.23 +  output()->put(')');
   30.24 +}
   30.25  void InstructionPrinter::do_ProfileInvoke(ProfileInvoke* x) {
   30.26    output()->print("profile_invoke ");
   30.27    output()->print(" %s.%s", x->inlinee()->holder()->name()->as_utf8(), x->inlinee()->name()->as_utf8());

    31.1 --- a/src/share/vm/c1/c1_InstructionPrinter.hpp	Fri Oct 18 10:37:26 2013 +0000
    31.2 +++ b/src/share/vm/c1/c1_InstructionPrinter.hpp	Fri Oct 18 19:44:40 2013 -0700
    31.3 @@ -132,6 +132,7 @@
    31.4    virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x);
    31.5    virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
    31.6    virtual void do_ProfileCall    (ProfileCall*     x);
    31.7 +  virtual void do_ProfileReturnType (ProfileReturnType*  x);
    31.8    virtual void do_ProfileInvoke  (ProfileInvoke*   x);
    31.9    virtual void do_RuntimeCall    (RuntimeCall*     x);
   31.10    virtual void do_MemBar         (MemBar*          x);

    32.1 --- a/src/share/vm/c1/c1_LIR.cpp	Fri Oct 18 10:37:26 2013 +0000
    32.2 +++ b/src/share/vm/c1/c1_LIR.cpp	Fri Oct 18 19:44:40 2013 -0700
    32.3 @@ -1001,6 +1001,17 @@
    32.4        assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
    32.5        break;
    32.6      }
    32.7 +
    32.8 +// LIR_OpProfileType:
    32.9 +    case lir_profile_type: {
   32.10 +      assert(op->as_OpProfileType() != NULL, "must be");
   32.11 +      LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;
   32.12 +
   32.13 +      do_input(opProfileType->_mdp); do_temp(opProfileType->_mdp);
   32.14 +      do_input(opProfileType->_obj);
   32.15 +      do_temp(opProfileType->_tmp);
   32.16 +      break;
   32.17 +    }
   32.18    default:
   32.19      ShouldNotReachHere();
   32.20    }
   32.21 @@ -1151,6 +1162,10 @@
   32.22    masm->emit_profile_call(this);
   32.23  }
   32.24  
   32.25 +void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
   32.26 +  masm->emit_profile_type(this);
   32.27 +}
   32.28 +
   32.29  // LIR_List
   32.30  LIR_List::LIR_List(Compilation* compilation, BlockBegin* block)
   32.31    : _operations(8)
   32.32 @@ -1803,6 +1818,8 @@
   32.33       case lir_cas_int:               s = "cas_int";      break;
   32.34       // LIR_OpProfileCall
   32.35       case lir_profile_call:          s = "profile_call";  break;
   32.36 +     // LIR_OpProfileType
   32.37 +     case lir_profile_type:          s = "profile_type";  break;
   32.38       // LIR_OpAssert
   32.39  #ifdef ASSERT
   32.40       case lir_assert:                s = "assert";        break;
   32.41 @@ -2086,6 +2103,15 @@
   32.42    tmp1()->print(out);          out->print(" ");
   32.43  }
   32.44  
   32.45 +// LIR_OpProfileType
   32.46 +void LIR_OpProfileType::print_instr(outputStream* out) const {
   32.47 +  out->print("exact = "); exact_klass()->print_name_on(out);
   32.48 +  out->print("current = "); ciTypeEntries::print_ciklass(out, current_klass());
   32.49 +  mdp()->print(out);          out->print(" ");
   32.50 +  obj()->print(out);          out->print(" ");
   32.51 +  tmp()->print(out);          out->print(" ");
   32.52 +}
   32.53 +
   32.54  #endif // PRODUCT
   32.55  
   32.56  // Implementation of LIR_InsertionBuffer

    33.1 --- a/src/share/vm/c1/c1_LIR.hpp	Fri Oct 18 10:37:26 2013 +0000
    33.2 +++ b/src/share/vm/c1/c1_LIR.hpp	Fri Oct 18 19:44:40 2013 -0700
    33.3 @@ -882,6 +882,7 @@
    33.4  class    LIR_OpTypeCheck;
    33.5  class    LIR_OpCompareAndSwap;
    33.6  class    LIR_OpProfileCall;
    33.7 +class    LIR_OpProfileType;
    33.8  #ifdef ASSERT
    33.9  class    LIR_OpAssert;
   33.10  #endif
   33.11 @@ -1005,6 +1006,7 @@
   33.12    , end_opCompareAndSwap
   33.13    , begin_opMDOProfile
   33.14      , lir_profile_call
   33.15 +    , lir_profile_type
   33.16    , end_opMDOProfile
   33.17    , begin_opAssert
   33.18      , lir_assert
   33.19 @@ -1145,6 +1147,7 @@
   33.20    virtual LIR_OpTypeCheck* as_OpTypeCheck() { return NULL; }
   33.21    virtual LIR_OpCompareAndSwap* as_OpCompareAndSwap() { return NULL; }
   33.22    virtual LIR_OpProfileCall* as_OpProfileCall() { return NULL; }
   33.23 +  virtual LIR_OpProfileType* as_OpProfileType() { return NULL; }
   33.24  #ifdef ASSERT
   33.25    virtual LIR_OpAssert* as_OpAssert() { return NULL; }
   33.26  #endif
   33.27 @@ -1925,8 +1928,8 @@
   33.28  
   33.29   public:
   33.30    // Destroys recv
   33.31 -  LIR_OpProfileCall(LIR_Code code, ciMethod* profiled_method, int profiled_bci, ciMethod* profiled_callee, LIR_Opr mdo, LIR_Opr recv, LIR_Opr t1, ciKlass* known_holder)
   33.32 -    : LIR_Op(code, LIR_OprFact::illegalOpr, NULL)  // no result, no info
   33.33 +  LIR_OpProfileCall(ciMethod* profiled_method, int profiled_bci, ciMethod* profiled_callee, LIR_Opr mdo, LIR_Opr recv, LIR_Opr t1, ciKlass* known_holder)
   33.34 +    : LIR_Op(lir_profile_call, LIR_OprFact::illegalOpr, NULL)  // no result, no info
   33.35      , _profiled_method(profiled_method)
   33.36      , _profiled_bci(profiled_bci)
   33.37      , _profiled_callee(profiled_callee)
   33.38 @@ -1948,6 +1951,45 @@
   33.39    virtual void print_instr(outputStream* out) const PRODUCT_RETURN;
   33.40  };
   33.41  
   33.42 +// LIR_OpProfileType
   33.43 +class LIR_OpProfileType : public LIR_Op {
   33.44 + friend class LIR_OpVisitState;
   33.45 +
   33.46 + private:
   33.47 +  LIR_Opr      _mdp;
   33.48 +  LIR_Opr      _obj;
   33.49 +  LIR_Opr      _tmp;
   33.50 +  ciKlass*     _exact_klass;   // non NULL if we know the klass statically (no need to load it from _obj)
   33.51 +  intptr_t     _current_klass; // what the profiling currently reports
   33.52 +  bool         _not_null;      // true if we know statically that _obj cannot be null
   33.53 +  bool         _no_conflict;   // true if we're profling parameters, _exact_klass is not NULL and we know
   33.54 +                               // _exact_klass it the only possible type for this parameter in any context.
   33.55 +
   33.56 + public:
   33.57 +  // Destroys recv
   33.58 +  LIR_OpProfileType(LIR_Opr mdp, LIR_Opr obj, ciKlass* exact_klass, intptr_t current_klass, LIR_Opr tmp, bool not_null, bool no_conflict)
   33.59 +    : LIR_Op(lir_profile_type, LIR_OprFact::illegalOpr, NULL)  // no result, no info
   33.60 +    , _mdp(mdp)
   33.61 +    , _obj(obj)
   33.62 +    , _exact_klass(exact_klass)
   33.63 +    , _current_klass(current_klass)
   33.64 +    , _tmp(tmp)
   33.65 +    , _not_null(not_null)
   33.66 +    , _no_conflict(no_conflict) { }
   33.67 +
   33.68 +  LIR_Opr      mdp()              const             { return _mdp;              }
   33.69 +  LIR_Opr      obj()              const             { return _obj;              }
   33.70 +  LIR_Opr      tmp()              const             { return _tmp;              }
   33.71 +  ciKlass*     exact_klass()      const             { return _exact_klass;      }
   33.72 +  intptr_t     current_klass()    const             { return _current_klass;    }
   33.73 +  bool         not_null()         const             { return _not_null;         }
   33.74 +  bool         no_conflict()      const             { return _no_conflict;      }
   33.75 +
   33.76 +  virtual void emit_code(LIR_Assembler* masm);
   33.77 +  virtual LIR_OpProfileType* as_OpProfileType() { return this; }
   33.78 +  virtual void print_instr(outputStream* out) const PRODUCT_RETURN;
   33.79 +};
   33.80 +
   33.81  class LIR_InsertionBuffer;
   33.82  
   33.83  //--------------------------------LIR_List---------------------------------------------------
   33.84 @@ -2247,7 +2289,10 @@
   33.85                    ciMethod* profiled_method, int profiled_bci);
   33.86    // MethodData* profiling
   33.87    void profile_call(ciMethod* method, int bci, ciMethod* callee, LIR_Opr mdo, LIR_Opr recv, LIR_Opr t1, ciKlass* cha_klass) {
   33.88 -    append(new LIR_OpProfileCall(lir_profile_call, method, bci, callee, mdo, recv, t1, cha_klass));
   33.89 +    append(new LIR_OpProfileCall(method, bci, callee, mdo, recv, t1, cha_klass));
   33.90 +  }
   33.91 +  void profile_type(LIR_Address* mdp, LIR_Opr obj, ciKlass* exact_klass, intptr_t current_klass, LIR_Opr tmp, bool not_null, bool no_conflict) {
   33.92 +    append(new LIR_OpProfileType(LIR_OprFact::address(mdp), obj, exact_klass, current_klass, tmp, not_null, no_conflict));
   33.93    }
   33.94  
   33.95    void xadd(LIR_Opr src, LIR_Opr add, LIR_Opr res, LIR_Opr tmp) { append(new LIR_Op2(lir_xadd, src, add, res, tmp)); }

    34.1 --- a/src/share/vm/c1/c1_LIRAssembler.hpp	Fri Oct 18 10:37:26 2013 +0000
    34.2 +++ b/src/share/vm/c1/c1_LIRAssembler.hpp	Fri Oct 18 19:44:40 2013 -0700
    34.3 @@ -208,6 +208,7 @@
    34.4    void emit_call(LIR_OpJavaCall* op);
    34.5    void emit_rtcall(LIR_OpRTCall* op);
    34.6    void emit_profile_call(LIR_OpProfileCall* op);
    34.7 +  void emit_profile_type(LIR_OpProfileType* op);
    34.8    void emit_delay(LIR_OpDelay* op);
    34.9  
   34.10    void arith_op(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr dest, CodeEmitInfo* info, bool pop_fpu_stack);

    35.1 --- a/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Oct 18 10:37:26 2013 +0000
    35.2 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Oct 18 19:44:40 2013 -0700
    35.3 @@ -2571,6 +2571,78 @@
    35.4  }
    35.5  
    35.6  
    35.7 +ciKlass* LIRGenerator::profile_arg_type(ciMethodData* md, int md_base_offset, int md_offset, intptr_t profiled_k, Value arg, LIR_Opr& mdp, bool not_null, ciKlass* signature_k) {
    35.8 +  ciKlass* result = NULL;
    35.9 +  bool do_null = !not_null && !TypeEntries::was_null_seen(profiled_k);
   35.10 +  bool do_update = !TypeEntries::is_type_unknown(profiled_k);
   35.11 +  // known not to be null or null bit already set and already set to
   35.12 +  // unknown: nothing we can do to improve profiling
   35.13 +  if (!do_null && !do_update) {
   35.14 +    return result;
   35.15 +  }
   35.16 +
   35.17 +  ciKlass* exact_klass = NULL;
   35.18 +  Compilation* comp = Compilation::current();
   35.19 +  if (do_update) {
   35.20 +    // try to find exact type, using CHA if possible, so that loading
   35.21 +    // the klass from the object can be avoided
   35.22 +    ciType* type = arg->exact_type();
   35.23 +    if (type == NULL) {
   35.24 +      type = arg->declared_type();
   35.25 +      type = comp->cha_exact_type(type);
   35.26 +    }
   35.27 +    assert(type == NULL || type->is_klass(), "type should be class");
   35.28 +    exact_klass = (type != NULL && type->is_loaded()) ? (ciKlass*)type : NULL;
   35.29 +
   35.30 +    do_update = exact_klass == NULL || ciTypeEntries::valid_ciklass(profiled_k) != exact_klass;
   35.31 +  }
   35.32 +
   35.33 +  if (!do_null && !do_update) {
   35.34 +    return result;
   35.35 +  }
   35.36 +
   35.37 +  ciKlass* exact_signature_k = NULL;
   35.38 +  if (do_update) {
   35.39 +    // Is the type from the signature exact (the only one possible)?
   35.40 +    exact_signature_k = signature_k->exact_klass();
   35.41 +    if (exact_signature_k == NULL) {
   35.42 +      exact_signature_k = comp->cha_exact_type(signature_k);
   35.43 +    } else {
   35.44 +      result = exact_signature_k;
   35.45 +      do_update = false;
   35.46 +      // Known statically. No need to emit any code: prevent
   35.47 +      // LIR_Assembler::emit_profile_type() from emitting useless code
   35.48 +      profiled_k = ciTypeEntries::with_status(result, profiled_k);
   35.49 +    }
   35.50 +    if (exact_signature_k != NULL && exact_klass != exact_signature_k) {
   35.51 +      assert(exact_klass == NULL, "arg and signature disagree?");
   35.52 +      // sometimes the type of the signature is better than the best type
   35.53 +      // the compiler has
   35.54 +      exact_klass = exact_signature_k;
   35.55 +      do_update = exact_klass == NULL || ciTypeEntries::valid_ciklass(profiled_k) != exact_klass;
   35.56 +    }
   35.57 +  }
   35.58 +
   35.59 +  if (!do_null && !do_update) {
   35.60 +    return result;
   35.61 +  }
   35.62 +
   35.63 +  if (mdp == LIR_OprFact::illegalOpr) {
   35.64 +    mdp = new_register(T_METADATA);
   35.65 +    __ metadata2reg(md->constant_encoding(), mdp);
   35.66 +    if (md_base_offset != 0) {
   35.67 +      LIR_Address* base_type_address = new LIR_Address(mdp, md_base_offset, T_ADDRESS);
   35.68 +      mdp = new_pointer_register();
   35.69 +      __ leal(LIR_OprFact::address(base_type_address), mdp);
   35.70 +    }
   35.71 +  }
   35.72 +  LIRItem value(arg, this);
   35.73 +  value.load_item();
   35.74 +  __ profile_type(new LIR_Address(mdp, md_offset, T_METADATA),
   35.75 +                  value.result(), exact_klass, profiled_k, new_pointer_register(), not_null, exact_signature_k != NULL);
   35.76 +  return result;
   35.77 +}
   35.78 +
   35.79  void LIRGenerator::do_Base(Base* x) {
   35.80    __ std_entry(LIR_OprFact::illegalOpr);
   35.81    // Emit moves from physical registers / stack slots to virtual registers
   35.82 @@ -3004,12 +3076,52 @@
   35.83    }
   35.84  }
   35.85  
   35.86 +void LIRGenerator::profile_arguments(ProfileCall* x) {
   35.87 +  if (MethodData::profile_arguments()) {
   35.88 +    int bci = x->bci_of_invoke();
   35.89 +    ciMethodData* md = x->method()->method_data_or_null();
   35.90 +    ciProfileData* data = md->bci_to_data(bci);
   35.91 +    if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
   35.92 +      ByteSize extra = data->is_CallTypeData() ? CallTypeData::args_data_offset() : VirtualCallTypeData::args_data_offset();
   35.93 +      int base_offset = md->byte_offset_of_slot(data, extra);
   35.94 +      LIR_Opr mdp = LIR_OprFact::illegalOpr;
   35.95 +      ciTypeStackSlotEntries* args = data->is_CallTypeData() ? ((ciCallTypeData*)data)->args() : ((ciVirtualCallTypeData*)data)->args();
   35.96 +
   35.97 +      Bytecodes::Code bc = x->method()->java_code_at_bci(bci);
   35.98 +      int start = 0;
   35.99 +      int stop = data->is_CallTypeData() ? ((ciCallTypeData*)data)->number_of_arguments() : ((ciVirtualCallTypeData*)data)->number_of_arguments();
  35.100 +      if (x->nb_profiled_args() < stop) {
  35.101 +        // if called through method handle invoke, some arguments may have been popped
  35.102 +        stop = x->nb_profiled_args();
  35.103 +      }
  35.104 +      ciSignature* sig = x->callee()->signature();
  35.105 +      // method handle call to virtual method
  35.106 +      bool has_receiver = x->inlined() && !x->callee()->is_static() && !Bytecodes::has_receiver(bc);
  35.107 +      ciSignatureStream sig_stream(sig, has_receiver ? x->callee()->holder() : NULL);
  35.108 +      for (int i = 0; i < stop; i++) {
  35.109 +        int off = in_bytes(TypeEntriesAtCall::argument_type_offset(i)) - in_bytes(TypeEntriesAtCall::args_data_offset());
  35.110 +        ciKlass* exact = profile_arg_type(md, base_offset, off,
  35.111 +                                          args->type(i), x->profiled_arg_at(i+start), mdp,
  35.112 +                                          !x->arg_needs_null_check(i+start), sig_stream.next_klass());
  35.113 +        if (exact != NULL) {
  35.114 +          md->set_argument_type(bci, i, exact);
  35.115 +        }
  35.116 +      }
  35.117 +    }
  35.118 +  }
  35.119 +}
  35.120 +
  35.121  void LIRGenerator::do_ProfileCall(ProfileCall* x) {
  35.122    // Need recv in a temporary register so it interferes with the other temporaries
  35.123    LIR_Opr recv = LIR_OprFact::illegalOpr;
  35.124    LIR_Opr mdo = new_register(T_OBJECT);
  35.125    // tmp is used to hold the counters on SPARC
  35.126    LIR_Opr tmp = new_pointer_register();
  35.127 +
  35.128 +  if (x->nb_profiled_args() > 0) {
  35.129 +    profile_arguments(x);
  35.130 +  }
  35.131 +
  35.132    if (x->recv() != NULL) {
  35.133      LIRItem value(x->recv(), this);
  35.134      value.load_item();
  35.135 @@ -3019,6 +3131,21 @@
  35.136    __ profile_call(x->method(), x->bci_of_invoke(), x->callee(), mdo, recv, tmp, x->known_holder());
  35.137  }
  35.138  
  35.139 +void LIRGenerator::do_ProfileReturnType(ProfileReturnType* x) {
  35.140 +  int bci = x->bci_of_invoke();
  35.141 +  ciMethodData* md = x->method()->method_data_or_null();
  35.142 +  ciProfileData* data = md->bci_to_data(bci);
  35.143 +  assert(data->is_CallTypeData() || data->is_VirtualCallTypeData(), "wrong profile data type");
  35.144 +  ciReturnTypeEntry* ret = data->is_CallTypeData() ? ((ciCallTypeData*)data)->ret() : ((ciVirtualCallTypeData*)data)->ret();
  35.145 +  LIR_Opr mdp = LIR_OprFact::illegalOpr;
  35.146 +  ciKlass* exact = profile_arg_type(md, 0, md->byte_offset_of_slot(data, ret->type_offset()),
  35.147 +                                    ret->type(), x->ret(), mdp,
  35.148 +                                    !x->needs_null_check(), x->callee()->signature()->return_type()->as_klass());
  35.149 +  if (exact != NULL) {
  35.150 +    md->set_return_type(bci, exact);
  35.151 +  }
  35.152 +}
  35.153 +
  35.154  void LIRGenerator::do_ProfileInvoke(ProfileInvoke* x) {
  35.155    // We can safely ignore accessors here, since c2 will inline them anyway,
  35.156    // accessors are also always mature.
  35.157 @@ -3053,7 +3180,11 @@
  35.158    int offset = -1;
  35.159    LIR_Opr counter_holder;
  35.160    if (level == CompLevel_limited_profile) {
  35.161 -    address counters_adr = method->ensure_method_counters();
  35.162 +    MethodCounters* counters_adr = method->ensure_method_counters();
  35.163 +    if (counters_adr == NULL) {
  35.164 +      bailout("method counters allocation failed");
  35.165 +      return;
  35.166 +    }
  35.167      counter_holder = new_pointer_register();
  35.168      __ move(LIR_OprFact::intptrConst(counters_adr), counter_holder);
  35.169      offset = in_bytes(backedge ? MethodCounters::backedge_counter_offset() :

    36.1 --- a/src/share/vm/c1/c1_LIRGenerator.hpp	Fri Oct 18 10:37:26 2013 +0000
    36.2 +++ b/src/share/vm/c1/c1_LIRGenerator.hpp	Fri Oct 18 19:44:40 2013 -0700
    36.3 @@ -434,6 +434,8 @@
    36.4    void do_ThreadIDIntrinsic(Intrinsic* x);
    36.5    void do_ClassIDIntrinsic(Intrinsic* x);
    36.6  #endif
    36.7 +  ciKlass* profile_arg_type(ciMethodData* md, int md_first_offset, int md_offset, intptr_t profiled_k, Value arg, LIR_Opr& mdp, bool not_null, ciKlass* signature_k);
    36.8 +  void profile_arguments(ProfileCall* x);
    36.9  
   36.10   public:
   36.11    Compilation*  compilation() const              { return _compilation; }
   36.12 @@ -534,6 +536,7 @@
   36.13    virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x);
   36.14    virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
   36.15    virtual void do_ProfileCall    (ProfileCall*     x);
   36.16 +  virtual void do_ProfileReturnType (ProfileReturnType* x);
   36.17    virtual void do_ProfileInvoke  (ProfileInvoke*   x);
   36.18    virtual void do_RuntimeCall    (RuntimeCall*     x);
   36.19    virtual void do_MemBar         (MemBar*          x);

    37.1 --- a/src/share/vm/c1/c1_Optimizer.cpp	Fri Oct 18 10:37:26 2013 +0000
    37.2 +++ b/src/share/vm/c1/c1_Optimizer.cpp	Fri Oct 18 19:44:40 2013 -0700
    37.3 @@ -531,6 +531,7 @@
    37.4    void do_UnsafePrefetchRead (UnsafePrefetchRead*  x);
    37.5    void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
    37.6    void do_ProfileCall    (ProfileCall*     x);
    37.7 +  void do_ProfileReturnType (ProfileReturnType*  x);
    37.8    void do_ProfileInvoke  (ProfileInvoke*   x);
    37.9    void do_RuntimeCall    (RuntimeCall*     x);
   37.10    void do_MemBar         (MemBar*          x);
   37.11 @@ -657,6 +658,8 @@
   37.12    void handle_Intrinsic       (Intrinsic* x);
   37.13    void handle_ExceptionObject (ExceptionObject* x);
   37.14    void handle_Phi             (Phi* x);
   37.15 +  void handle_ProfileCall     (ProfileCall* x);
   37.16 +  void handle_ProfileReturnType (ProfileReturnType* x);
   37.17  };
   37.18  
   37.19  
   37.20 @@ -715,7 +718,9 @@
   37.21  void NullCheckVisitor::do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) {}
   37.22  void NullCheckVisitor::do_UnsafePrefetchRead (UnsafePrefetchRead*  x) {}
   37.23  void NullCheckVisitor::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {}
   37.24 -void NullCheckVisitor::do_ProfileCall    (ProfileCall*     x) { nce()->clear_last_explicit_null_check(); }
   37.25 +void NullCheckVisitor::do_ProfileCall    (ProfileCall*     x) { nce()->clear_last_explicit_null_check();
   37.26 +                                                                nce()->handle_ProfileCall(x); }
   37.27 +void NullCheckVisitor::do_ProfileReturnType (ProfileReturnType* x) { nce()->handle_ProfileReturnType(x); }
   37.28  void NullCheckVisitor::do_ProfileInvoke  (ProfileInvoke*   x) {}
   37.29  void NullCheckVisitor::do_RuntimeCall    (RuntimeCall*     x) {}
   37.30  void NullCheckVisitor::do_MemBar         (MemBar*          x) {}
   37.31 @@ -1134,6 +1139,15 @@
   37.32    }
   37.33  }
   37.34  
   37.35 +void NullCheckEliminator::handle_ProfileCall(ProfileCall* x) {
   37.36 +  for (int i = 0; i < x->nb_profiled_args(); i++) {
   37.37 +    x->set_arg_needs_null_check(i, !set_contains(x->profiled_arg_at(i)));
   37.38 +  }
   37.39 +}
   37.40 +
   37.41 +void NullCheckEliminator::handle_ProfileReturnType(ProfileReturnType* x) {
   37.42 +  x->set_needs_null_check(!set_contains(x->ret()));
   37.43 +}
   37.44  
   37.45  void Optimizer::eliminate_null_checks() {
   37.46    ResourceMark rm;

    38.1 --- a/src/share/vm/c1/c1_RangeCheckElimination.hpp	Fri Oct 18 10:37:26 2013 +0000
    38.2 +++ b/src/share/vm/c1/c1_RangeCheckElimination.hpp	Fri Oct 18 19:44:40 2013 -0700
    38.3 @@ -162,7 +162,8 @@
    38.4      void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) { /* nothing to do */ };
    38.5      void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) { /* nothing to do */ };
    38.6      void do_ProfileCall    (ProfileCall*     x) { /* nothing to do */ };
    38.7 -    void do_ProfileInvoke  (ProfileInvoke*  x)  { /* nothing to do */ };
    38.8 +    void do_ProfileReturnType (ProfileReturnType*  x) { /* nothing to do */ };
    38.9 +    void do_ProfileInvoke  (ProfileInvoke*   x) { /* nothing to do */ };
   38.10      void do_RuntimeCall    (RuntimeCall*     x) { /* nothing to do */ };
   38.11      void do_MemBar         (MemBar*          x) { /* nothing to do */ };
   38.12      void do_RangeCheckPredicate(RangeCheckPredicate* x) { /* nothing to do */ };

    39.1 --- a/src/share/vm/c1/c1_Runtime1.cpp	Fri Oct 18 10:37:26 2013 +0000
    39.2 +++ b/src/share/vm/c1/c1_Runtime1.cpp	Fri Oct 18 19:44:40 2013 -0700
    39.3 @@ -542,8 +542,7 @@
    39.4      // exception handler can cause class loading, which might throw an
    39.5      // exception and those fields are expected to be clear during
    39.6      // normal bytecode execution.
    39.7 -    thread->set_exception_oop(NULL);
    39.8 -    thread->set_exception_pc(NULL);
    39.9 +    thread->clear_exception_oop_and_pc();
   39.10  
   39.11      continuation = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, false, false);
   39.12      // If an exception was thrown during exception dispatch, the exception oop may have changed

    40.1 --- a/src/share/vm/c1/c1_ValueMap.hpp	Fri Oct 18 10:37:26 2013 +0000
    40.2 +++ b/src/share/vm/c1/c1_ValueMap.hpp	Fri Oct 18 19:44:40 2013 -0700
    40.3 @@ -203,6 +203,7 @@
    40.4    void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) { /* nothing to do */ }
    40.5    void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) { /* nothing to do */ }
    40.6    void do_ProfileCall    (ProfileCall*     x) { /* nothing to do */ }
    40.7 +  void do_ProfileReturnType (ProfileReturnType*  x) { /* nothing to do */ }
    40.8    void do_ProfileInvoke  (ProfileInvoke*   x) { /* nothing to do */ };
    40.9    void do_RuntimeCall    (RuntimeCall*     x) { /* nothing to do */ };
   40.10    void do_MemBar         (MemBar*          x) { /* nothing to do */ };

    41.1 --- a/src/share/vm/ci/ciClassList.hpp	Fri Oct 18 10:37:26 2013 +0000
    41.2 +++ b/src/share/vm/ci/ciClassList.hpp	Fri Oct 18 19:44:40 2013 -0700
    41.3 @@ -102,6 +102,7 @@
    41.4  friend class ciMethodHandle;           \
    41.5  friend class ciMethodType;             \
    41.6  friend class ciReceiverTypeData;       \
    41.7 +friend class ciTypeEntries;            \
    41.8  friend class ciSymbol;                 \
    41.9  friend class ciArray;                  \
   41.10  friend class ciObjArray;               \

    42.1 --- a/src/share/vm/ci/ciEnv.cpp	Fri Oct 18 10:37:26 2013 +0000
    42.2 +++ b/src/share/vm/ci/ciEnv.cpp	Fri Oct 18 19:44:40 2013 -0700
    42.3 @@ -1154,9 +1154,12 @@
    42.4    GUARDED_VM_ENTRY(return _factory->get_unloaded_object_constant();)
    42.5  }
    42.6  
    42.7 -void ciEnv::dump_replay_data(outputStream* out) {
    42.8 -  VM_ENTRY_MARK;
    42.9 -  MutexLocker ml(Compile_lock);
   42.10 +// ------------------------------------------------------------------
   42.11 +// ciEnv::dump_replay_data*
   42.12 +
   42.13 +// Don't change thread state and acquire any locks.
   42.14 +// Safe to call from VM error reporter.
   42.15 +void ciEnv::dump_replay_data_unsafe(outputStream* out) {
   42.16    ResourceMark rm;
   42.17  #if INCLUDE_JVMTI
   42.18    out->print_cr("JvmtiExport can_access_local_variables %d",     _jvmti_can_access_local_variables);
   42.19 @@ -1181,3 +1184,10 @@
   42.20                  entry_bci, comp_level);
   42.21    out->flush();
   42.22  }
   42.23 +
   42.24 +void ciEnv::dump_replay_data(outputStream* out) {
   42.25 +  GUARDED_VM_ENTRY(
   42.26 +    MutexLocker ml(Compile_lock);
   42.27 +    dump_replay_data_unsafe(out);
   42.28 +  )
   42.29 +}

    43.1 --- a/src/share/vm/ci/ciEnv.hpp	Fri Oct 18 10:37:26 2013 +0000
    43.2 +++ b/src/share/vm/ci/ciEnv.hpp	Fri Oct 18 19:44:40 2013 -0700
    43.3 @@ -452,6 +452,7 @@
    43.4  
    43.5    // Dump the compilation replay data for the ciEnv to the stream.
    43.6    void dump_replay_data(outputStream* out);
    43.7 +  void dump_replay_data_unsafe(outputStream* out);
    43.8  };
    43.9  
   43.10  #endif // SHARE_VM_CI_CIENV_HPP

    44.1 --- a/src/share/vm/ci/ciInstanceKlass.cpp	Fri Oct 18 10:37:26 2013 +0000
    44.2 +++ b/src/share/vm/ci/ciInstanceKlass.cpp	Fri Oct 18 19:44:40 2013 -0700
    44.3 @@ -671,7 +671,6 @@
    44.4  
    44.5  
    44.6  void ciInstanceKlass::dump_replay_data(outputStream* out) {
    44.7 -  ASSERT_IN_VM;
    44.8    ResourceMark rm;
    44.9  
   44.10    InstanceKlass* ik = get_instanceKlass();

    45.1 --- a/src/share/vm/ci/ciInstanceKlass.hpp	Fri Oct 18 10:37:26 2013 +0000
    45.2 +++ b/src/share/vm/ci/ciInstanceKlass.hpp	Fri Oct 18 19:44:40 2013 -0700
    45.3 @@ -235,6 +235,13 @@
    45.4    bool is_instance_klass() const { return true; }
    45.5    bool is_java_klass() const     { return true; }
    45.6  
    45.7 +  virtual ciKlass* exact_klass() {
    45.8 +    if (is_loaded() && is_final() && !is_interface()) {
    45.9 +      return this;
   45.10 +    }
   45.11 +    return NULL;
   45.12 +  }
   45.13 +
   45.14    // Dump the current state of this klass for compilation replay.
   45.15    virtual void dump_replay_data(outputStream* out);
   45.16  };

    46.1 --- a/src/share/vm/ci/ciKlass.cpp	Fri Oct 18 10:37:26 2013 +0000
    46.2 +++ b/src/share/vm/ci/ciKlass.cpp	Fri Oct 18 19:44:40 2013 -0700
    46.3 @@ -66,7 +66,9 @@
    46.4  // ------------------------------------------------------------------
    46.5  // ciKlass::is_subtype_of
    46.6  bool ciKlass::is_subtype_of(ciKlass* that) {
    46.7 -  assert(is_loaded() && that->is_loaded(), "must be loaded");
    46.8 +  assert(this->is_loaded(), err_msg("must be loaded: %s", this->name()->as_quoted_ascii()));
    46.9 +  assert(that->is_loaded(), err_msg("must be loaded: %s", that->name()->as_quoted_ascii()));
   46.10 +
   46.11    // Check to see if the klasses are identical.
   46.12    if (this == that) {
   46.13      return true;
   46.14 @@ -83,8 +85,8 @@
   46.15  // ------------------------------------------------------------------
   46.16  // ciKlass::is_subclass_of
   46.17  bool ciKlass::is_subclass_of(ciKlass* that) {
   46.18 -  assert(is_loaded() && that->is_loaded(), "must be loaded");
   46.19 -  // Check to see if the klasses are identical.
   46.20 +  assert(this->is_loaded(), err_msg("must be loaded: %s", this->name()->as_quoted_ascii()));
   46.21 +  assert(that->is_loaded(), err_msg("must be loaded: %s", that->name()->as_quoted_ascii()));
   46.22  
   46.23    VM_ENTRY_MARK;
   46.24    Klass* this_klass = get_Klass();

    47.1 --- a/src/share/vm/ci/ciKlass.hpp	Fri Oct 18 10:37:26 2013 +0000
    47.2 +++ b/src/share/vm/ci/ciKlass.hpp	Fri Oct 18 19:44:40 2013 -0700
    47.3 @@ -41,6 +41,7 @@
    47.4    friend class ciEnv;
    47.5    friend class ciField;
    47.6    friend class ciMethod;
    47.7 +  friend class ciMethodData;
    47.8    friend class ciObjArrayKlass;
    47.9  
   47.10  private:
   47.11 @@ -121,6 +122,8 @@
   47.12    // What kind of ciObject is this?
   47.13    bool is_klass() const { return true; }
   47.14  
   47.15 +  virtual ciKlass* exact_klass() = 0;
   47.16 +
   47.17    void print_name_on(outputStream* st);
   47.18  };
   47.19  

    48.1 --- a/src/share/vm/ci/ciMethod.cpp	Fri Oct 18 10:37:26 2013 +0000
    48.2 +++ b/src/share/vm/ci/ciMethod.cpp	Fri Oct 18 19:44:40 2013 -0700
    48.3 @@ -846,7 +846,9 @@
    48.4  // Return true if allocation was successful or no MDO is required.
    48.5  bool ciMethod::ensure_method_data(methodHandle h_m) {
    48.6    EXCEPTION_CONTEXT;
    48.7 -  if (is_native() || is_abstract() || h_m()->is_accessor()) return true;
    48.8 +  if (is_native() || is_abstract() || h_m()->is_accessor()) {
    48.9 +    return true;
   48.10 +  }
   48.11    if (h_m()->method_data() == NULL) {
   48.12      Method::build_interpreter_method_data(h_m, THREAD);
   48.13      if (HAS_PENDING_EXCEPTION) {
   48.14 @@ -903,22 +905,21 @@
   48.15  // NULL otherwise.
   48.16  ciMethodData* ciMethod::method_data_or_null() {
   48.17    ciMethodData *md = method_data();
   48.18 -  if (md->is_empty()) return NULL;
   48.19 +  if (md->is_empty()) {
   48.20 +    return NULL;
   48.21 +  }
   48.22    return md;
   48.23  }
   48.24  
   48.25  // ------------------------------------------------------------------
   48.26  // ciMethod::ensure_method_counters
   48.27  //
   48.28 -address ciMethod::ensure_method_counters() {
   48.29 +MethodCounters* ciMethod::ensure_method_counters() {
   48.30    check_is_loaded();
   48.31    VM_ENTRY_MARK;
   48.32    methodHandle mh(THREAD, get_Method());
   48.33 -  MethodCounters *counter = mh->method_counters();
   48.34 -  if (counter == NULL) {
   48.35 -    counter = Method::build_method_counters(mh(), CHECK_AND_CLEAR_NULL);
   48.36 -  }
   48.37 -  return (address)counter;
   48.38 +  MethodCounters* method_counters = mh->get_method_counters(CHECK_NULL);
   48.39 +  return method_counters;
   48.40  }
   48.41  
   48.42  // ------------------------------------------------------------------
   48.43 @@ -1247,7 +1248,6 @@
   48.44  #undef FETCH_FLAG_FROM_VM
   48.45  
   48.46  void ciMethod::dump_replay_data(outputStream* st) {
   48.47 -  ASSERT_IN_VM;
   48.48    ResourceMark rm;
   48.49    Method* method = get_Method();
   48.50    MethodCounters* mcs = method->method_counters();

    49.1 --- a/src/share/vm/ci/ciMethod.hpp	Fri Oct 18 10:37:26 2013 +0000
    49.2 +++ b/src/share/vm/ci/ciMethod.hpp	Fri Oct 18 19:44:40 2013 -0700
    49.3 @@ -265,7 +265,7 @@
    49.4    bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;
    49.5    bool check_call(int refinfo_index, bool is_static) const;
    49.6    bool ensure_method_data();  // make sure it exists in the VM also
    49.7 -  address ensure_method_counters();
    49.8 +  MethodCounters* ensure_method_counters();
    49.9    int instructions_size();
   49.10    int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC
   49.11  

    50.1 --- a/src/share/vm/ci/ciMethodData.cpp	Fri Oct 18 10:37:26 2013 +0000
    50.2 +++ b/src/share/vm/ci/ciMethodData.cpp	Fri Oct 18 19:44:40 2013 -0700
    50.3 @@ -78,7 +78,9 @@
    50.4  
    50.5  void ciMethodData::load_data() {
    50.6    MethodData* mdo = get_MethodData();
    50.7 -  if (mdo == NULL) return;
    50.8 +  if (mdo == NULL) {
    50.9 +    return;
   50.10 +  }
   50.11  
   50.12    // To do: don't copy the data if it is not "ripe" -- require a minimum #
   50.13    // of invocations.
   50.14 @@ -123,7 +125,7 @@
   50.15  #endif
   50.16  }
   50.17  
   50.18 -void ciReceiverTypeData::translate_receiver_data_from(ProfileData* data) {
   50.19 +void ciReceiverTypeData::translate_receiver_data_from(const ProfileData* data) {
   50.20    for (uint row = 0; row < row_limit(); row++) {
   50.21      Klass* k = data->as_ReceiverTypeData()->receiver(row);
   50.22      if (k != NULL) {
   50.23 @@ -134,6 +136,18 @@
   50.24  }
   50.25  
   50.26  
   50.27 +void ciTypeStackSlotEntries::translate_type_data_from(const TypeStackSlotEntries* entries) {
   50.28 +  for (int i = 0; i < _number_of_entries; i++) {
   50.29 +    intptr_t k = entries->type(i);
   50.30 +    TypeStackSlotEntries::set_type(i, translate_klass(k));
   50.31 +  }
   50.32 +}
   50.33 +
   50.34 +void ciReturnTypeEntry::translate_type_data_from(const ReturnTypeEntry* ret) {
   50.35 +  intptr_t k = ret->type();
   50.36 +  set_type(translate_klass(k));
   50.37 +}
   50.38 +
   50.39  // Get the data at an arbitrary (sort of) data index.
   50.40  ciProfileData* ciMethodData::data_at(int data_index) {
   50.41    if (out_of_bounds(data_index)) {
   50.42 @@ -164,6 +178,10 @@
   50.43      return new ciMultiBranchData(data_layout);
   50.44    case DataLayout::arg_info_data_tag:
   50.45      return new ciArgInfoData(data_layout);
   50.46 +  case DataLayout::call_type_data_tag:
   50.47 +    return new ciCallTypeData(data_layout);
   50.48 +  case DataLayout::virtual_call_type_data_tag:
   50.49 +    return new ciVirtualCallTypeData(data_layout);
   50.50    };
   50.51  }
   50.52  
   50.53 @@ -286,6 +304,34 @@
   50.54    }
   50.55  }
   50.56  
   50.57 +void ciMethodData::set_argument_type(int bci, int i, ciKlass* k) {
   50.58 +  VM_ENTRY_MARK;
   50.59 +  MethodData* mdo = get_MethodData();
   50.60 +  if (mdo != NULL) {
   50.61 +    ProfileData* data = mdo->bci_to_data(bci);
   50.62 +    if (data->is_CallTypeData()) {
   50.63 +      data->as_CallTypeData()->set_argument_type(i, k->get_Klass());
   50.64 +    } else {
   50.65 +      assert(data->is_VirtualCallTypeData(), "no arguments!");
   50.66 +      data->as_VirtualCallTypeData()->set_argument_type(i, k->get_Klass());
   50.67 +    }
   50.68 +  }
   50.69 +}
   50.70 +
   50.71 +void ciMethodData::set_return_type(int bci, ciKlass* k) {
   50.72 +  VM_ENTRY_MARK;
   50.73 +  MethodData* mdo = get_MethodData();
   50.74 +  if (mdo != NULL) {
   50.75 +    ProfileData* data = mdo->bci_to_data(bci);
   50.76 +    if (data->is_CallTypeData()) {
   50.77 +      data->as_CallTypeData()->set_return_type(k->get_Klass());
   50.78 +    } else {
   50.79 +      assert(data->is_VirtualCallTypeData(), "no arguments!");
   50.80 +      data->as_VirtualCallTypeData()->set_return_type(k->get_Klass());
   50.81 +    }
   50.82 +  }
   50.83 +}
   50.84 +
   50.85  bool ciMethodData::has_escape_info() {
   50.86    return eflag_set(MethodData::estimated);
   50.87  }
   50.88 @@ -373,7 +419,6 @@
   50.89  }
   50.90  
   50.91  void ciMethodData::dump_replay_data(outputStream* out) {
   50.92 -  ASSERT_IN_VM;
   50.93    ResourceMark rm;
   50.94    MethodData* mdo = get_MethodData();
   50.95    Method* method = mdo->method();
   50.96 @@ -477,7 +522,50 @@
   50.97    }
   50.98  }
   50.99  
  50.100 -void ciReceiverTypeData::print_receiver_data_on(outputStream* st) {
  50.101 +void ciTypeEntries::print_ciklass(outputStream* st, intptr_t k) {
  50.102 +  if (TypeEntries::is_type_none(k)) {
  50.103 +    st->print("none");
  50.104 +  } else if (TypeEntries::is_type_unknown(k)) {
  50.105 +    st->print("unknown");
  50.106 +  } else {
  50.107 +    valid_ciklass(k)->print_name_on(st);
  50.108 +  }
  50.109 +  if (TypeEntries::was_null_seen(k)) {
  50.110 +    st->print(" (null seen)");
  50.111 +  }
  50.112 +}
  50.113 +
  50.114 +void ciTypeStackSlotEntries::print_data_on(outputStream* st) const {
  50.115 +  for (int i = 0; i < _number_of_entries; i++) {
  50.116 +    _pd->tab(st);
  50.117 +    st->print("%d: stack (%u) ", i, stack_slot(i));
  50.118 +    print_ciklass(st, type(i));
  50.119 +    st->cr();
  50.120 +  }
  50.121 +}
  50.122 +
  50.123 +void ciReturnTypeEntry::print_data_on(outputStream* st) const {
  50.124 +  _pd->tab(st);
  50.125 +  st->print("ret ");
  50.126 +  print_ciklass(st, type());
  50.127 +  st->cr();
  50.128 +}
  50.129 +
  50.130 +void ciCallTypeData::print_data_on(outputStream* st) const {
  50.131 +  print_shared(st, "ciCallTypeData");
  50.132 +  if (has_arguments()) {
  50.133 +    tab(st, true);
  50.134 +    st->print("argument types");
  50.135 +    args()->print_data_on(st);
  50.136 +  }
  50.137 +  if (has_return()) {
  50.138 +    tab(st, true);
  50.139 +    st->print("return type");
  50.140 +    ret()->print_data_on(st);
  50.141 +  }
  50.142 +}
  50.143 +
  50.144 +void ciReceiverTypeData::print_receiver_data_on(outputStream* st) const {
  50.145    uint row;
  50.146    int entries = 0;
  50.147    for (row = 0; row < row_limit(); row++) {
  50.148 @@ -493,13 +581,28 @@
  50.149    }
  50.150  }
  50.151  
  50.152 -void ciReceiverTypeData::print_data_on(outputStream* st) {
  50.153 +void ciReceiverTypeData::print_data_on(outputStream* st) const {
  50.154    print_shared(st, "ciReceiverTypeData");
  50.155    print_receiver_data_on(st);
  50.156  }
  50.157  
  50.158 -void ciVirtualCallData::print_data_on(outputStream* st) {
  50.159 +void ciVirtualCallData::print_data_on(outputStream* st) const {
  50.160    print_shared(st, "ciVirtualCallData");
  50.161    rtd_super()->print_receiver_data_on(st);
  50.162  }
  50.163 +
  50.164 +void ciVirtualCallTypeData::print_data_on(outputStream* st) const {
  50.165 +  print_shared(st, "ciVirtualCallTypeData");
  50.166 +  rtd_super()->print_receiver_data_on(st);
  50.167 +  if (has_arguments()) {
  50.168 +    tab(st, true);
  50.169 +    st->print("argument types");
  50.170 +    args()->print_data_on(st);
  50.171 +  }
  50.172 +  if (has_return()) {
  50.173 +    tab(st, true);
  50.174 +    st->print("return type");
  50.175 +    ret()->print_data_on(st);
  50.176 +  }
  50.177 +}
  50.178  #endif

    51.1 --- a/src/share/vm/ci/ciMethodData.hpp	Fri Oct 18 10:37:26 2013 +0000
    51.2 +++ b/src/share/vm/ci/ciMethodData.hpp	Fri Oct 18 19:44:40 2013 -0700
    51.3 @@ -41,6 +41,8 @@
    51.4  class ciArrayData;
    51.5  class ciMultiBranchData;
    51.6  class ciArgInfoData;
    51.7 +class ciCallTypeData;
    51.8 +class ciVirtualCallTypeData;
    51.9  
   51.10  typedef ProfileData ciProfileData;
   51.11  
   51.12 @@ -59,6 +61,103 @@
   51.13    ciJumpData(DataLayout* layout) : JumpData(layout) {};
   51.14  };
   51.15  
   51.16 +class ciTypeEntries {
   51.17 +protected:
   51.18 +  static intptr_t translate_klass(intptr_t k) {
   51.19 +    Klass* v = TypeEntries::valid_klass(k);
   51.20 +    if (v != NULL) {
   51.21 +      ciKlass* klass = CURRENT_ENV->get_klass(v);
   51.22 +      return with_status(klass, k);
   51.23 +    }
   51.24 +    return with_status(NULL, k);
   51.25 +  }
   51.26 +
   51.27 +public:
   51.28 +  static ciKlass* valid_ciklass(intptr_t k) {
   51.29 +    if (!TypeEntries::is_type_none(k) &&
   51.30 +        !TypeEntries::is_type_unknown(k)) {
   51.31 +      return (ciKlass*)TypeEntries::klass_part(k);
   51.32 +    } else {
   51.33 +      return NULL;
   51.34 +    }
   51.35 +  }
   51.36 +
   51.37 +  static intptr_t with_status(ciKlass* k, intptr_t in) {
   51.38 +    return TypeEntries::with_status((intptr_t)k, in);
   51.39 +  }
   51.40 +
   51.41 +#ifndef PRODUCT
   51.42 +  static void print_ciklass(outputStream* st, intptr_t k);
   51.43 +#endif
   51.44 +};
   51.45 +
   51.46 +class ciTypeStackSlotEntries : public TypeStackSlotEntries, ciTypeEntries {
   51.47 +public:
   51.48 +  void translate_type_data_from(const TypeStackSlotEntries* args);
   51.49 +
   51.50 +  ciKlass* valid_type(int i) const {
   51.51 +    return valid_ciklass(type(i));
   51.52 +  }
   51.53 +
   51.54 +#ifndef PRODUCT
   51.55 +  void print_data_on(outputStream* st) const;
   51.56 +#endif
   51.57 +};
   51.58 +
   51.59 +class ciReturnTypeEntry : public ReturnTypeEntry, ciTypeEntries {
   51.60 +public:
   51.61 +  void translate_type_data_from(const ReturnTypeEntry* ret);
   51.62 +
   51.63 +  ciKlass* valid_type() const {
   51.64 +    return valid_ciklass(type());
   51.65 +  }
   51.66 +
   51.67 +#ifndef PRODUCT
   51.68 +  void print_data_on(outputStream* st) const;
   51.69 +#endif
   51.70 +};
   51.71 +
   51.72 +class ciCallTypeData : public CallTypeData {
   51.73 +public:
   51.74 +  ciCallTypeData(DataLayout* layout) : CallTypeData(layout) {}
   51.75 +
   51.76 +  ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)CallTypeData::args(); }
   51.77 +  ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)CallTypeData::ret(); }
   51.78 +
   51.79 +  void translate_type_data_from(const ProfileData* data) {
   51.80 +    if (has_arguments()) {
   51.81 +      args()->translate_type_data_from(data->as_CallTypeData()->args());
   51.82 +    }
   51.83 +    if (has_return()) {
   51.84 +      ret()->translate_type_data_from(data->as_CallTypeData()->ret());
   51.85 +    }
   51.86 +  }
   51.87 +
   51.88 +  intptr_t argument_type(int i) const {
   51.89 +    assert(has_arguments(), "no arg type profiling data");
   51.90 +    return args()->type(i);
   51.91 +  }
   51.92 +
   51.93 +  ciKlass* valid_argument_type(int i) const {
   51.94 +    assert(has_arguments(), "no arg type profiling data");
   51.95 +    return args()->valid_type(i);
   51.96 +  }
   51.97 +
   51.98 +  intptr_t return_type() const {
   51.99 +    assert(has_return(), "no ret type profiling data");
  51.100 +    return ret()->type();
  51.101 +  }
  51.102 +
  51.103 +  ciKlass* valid_return_type() const {
  51.104 +    assert(has_return(), "no ret type profiling data");
  51.105 +    return ret()->valid_type();
  51.106 +  }
  51.107 +
  51.108 +#ifndef PRODUCT
  51.109 +  void print_data_on(outputStream* st) const;
  51.110 +#endif
  51.111 +};
  51.112 +
  51.113  class ciReceiverTypeData : public ReceiverTypeData {
  51.114  public:
  51.115    ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {};
  51.116 @@ -69,7 +168,7 @@
  51.117                    (intptr_t) recv);
  51.118    }
  51.119  
  51.120 -  ciKlass* receiver(uint row) {
  51.121 +  ciKlass* receiver(uint row) const {
  51.122      assert((uint)row < row_limit(), "oob");
  51.123      ciKlass* recv = (ciKlass*)intptr_at(receiver0_offset + row * receiver_type_row_cell_count);
  51.124      assert(recv == NULL || recv->is_klass(), "wrong type");
  51.125 @@ -77,19 +176,19 @@
  51.126    }
  51.127  
  51.128    // Copy & translate from oop based ReceiverTypeData
  51.129 -  virtual void translate_from(ProfileData* data) {
  51.130 +  virtual void translate_from(const ProfileData* data) {
  51.131      translate_receiver_data_from(data);
  51.132    }
  51.133 -  void translate_receiver_data_from(ProfileData* data);
  51.134 +  void translate_receiver_data_from(const ProfileData* data);
  51.135  #ifndef PRODUCT
  51.136 -  void print_data_on(outputStream* st);
  51.137 -  void print_receiver_data_on(outputStream* st);
  51.138 +  void print_data_on(outputStream* st) const;
  51.139 +  void print_receiver_data_on(outputStream* st) const;
  51.140  #endif
  51.141  };
  51.142  
  51.143  class ciVirtualCallData : public VirtualCallData {
  51.144    // Fake multiple inheritance...  It's a ciReceiverTypeData also.
  51.145 -  ciReceiverTypeData* rtd_super() { return (ciReceiverTypeData*) this; }
  51.146 +  ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
  51.147  
  51.148  public:
  51.149    ciVirtualCallData(DataLayout* layout) : VirtualCallData(layout) {};
  51.150 @@ -103,11 +202,65 @@
  51.151    }
  51.152  
  51.153    // Copy & translate from oop based VirtualCallData
  51.154 -  virtual void translate_from(ProfileData* data) {
  51.155 +  virtual void translate_from(const ProfileData* data) {
  51.156      rtd_super()->translate_receiver_data_from(data);
  51.157    }
  51.158  #ifndef PRODUCT
  51.159 -  void print_data_on(outputStream* st);
  51.160 +  void print_data_on(outputStream* st) const;
  51.161 +#endif
  51.162 +};
  51.163 +
  51.164 +class ciVirtualCallTypeData : public VirtualCallTypeData {
  51.165 +private:
  51.166 +  // Fake multiple inheritance...  It's a ciReceiverTypeData also.
  51.167 +  ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
  51.168 +public:
  51.169 +  ciVirtualCallTypeData(DataLayout* layout) : VirtualCallTypeData(layout) {}
  51.170 +
  51.171 +  void set_receiver(uint row, ciKlass* recv) {
  51.172 +    rtd_super()->set_receiver(row, recv);
  51.173 +  }
  51.174 +
  51.175 +  ciKlass* receiver(uint row) const {
  51.176 +    return rtd_super()->receiver(row);
  51.177 +  }
  51.178 +
  51.179 +  ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)VirtualCallTypeData::args(); }
  51.180 +  ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)VirtualCallTypeData::ret(); }
  51.181 +
  51.182 +  // Copy & translate from oop based VirtualCallData
  51.183 +  virtual void translate_from(const ProfileData* data) {
  51.184 +    rtd_super()->translate_receiver_data_from(data);
  51.185 +    if (has_arguments()) {
  51.186 +      args()->translate_type_data_from(data->as_VirtualCallTypeData()->args());
  51.187 +    }
  51.188 +    if (has_return()) {
  51.189 +      ret()->translate_type_data_from(data->as_VirtualCallTypeData()->ret());
  51.190 +    }
  51.191 +  }
  51.192 +
  51.193 +  intptr_t argument_type(int i) const {
  51.194 +    assert(has_arguments(), "no arg type profiling data");
  51.195 +    return args()->type(i);
  51.196 +  }
  51.197 +
  51.198 +  ciKlass* valid_argument_type(int i) const {
  51.199 +    assert(has_arguments(), "no arg type profiling data");
  51.200 +    return args()->valid_type(i);
  51.201 +  }
  51.202 +
  51.203 +  intptr_t return_type() const {
  51.204 +    assert(has_return(), "no ret type profiling data");
  51.205 +    return ret()->type();
  51.206 +  }
  51.207 +
  51.208 +  ciKlass* valid_return_type() const {
  51.209 +    assert(has_return(), "no ret type profiling data");
  51.210 +    return ret()->valid_type();
  51.211 +  }
  51.212 +
  51.213 +#ifndef PRODUCT
  51.214 +  void print_data_on(outputStream* st) const;
  51.215  #endif
  51.216  };
  51.217  
  51.218 @@ -232,8 +385,6 @@
  51.219  public:
  51.220    bool is_method_data() const { return true; }
  51.221  
  51.222 -  void set_mature() { _state = mature_state; }
  51.223 -
  51.224    bool is_empty()  { return _state == empty_state; }
  51.225    bool is_mature() { return _state == mature_state; }
  51.226  
  51.227 @@ -249,6 +400,10 @@
  51.228    // Also set the numer of loops and blocks in the method.
  51.229    // Again, this is used to determine if a method is trivial.
  51.230    void set_compilation_stats(short loops, short blocks);
  51.231 +  // If the compiler finds a profiled type that is known statically
  51.232 +  // for sure, set it in the MethodData
  51.233 +  void set_argument_type(int bci, int i, ciKlass* k);
  51.234 +  void set_return_type(int bci, ciKlass* k);
  51.235  
  51.236    void load_data();
  51.237  

    52.1 --- a/src/share/vm/ci/ciObjArrayKlass.cpp	Fri Oct 18 10:37:26 2013 +0000
    52.2 +++ b/src/share/vm/ci/ciObjArrayKlass.cpp	Fri Oct 18 19:44:40 2013 -0700
    52.3 @@ -179,3 +179,16 @@
    52.4  ciObjArrayKlass* ciObjArrayKlass::make(ciKlass* element_klass) {
    52.5    GUARDED_VM_ENTRY(return make_impl(element_klass);)
    52.6  }
    52.7 +
    52.8 +ciKlass* ciObjArrayKlass::exact_klass() {
    52.9 +  ciType* base = base_element_type();
   52.10 +  if (base->is_instance_klass()) {
   52.11 +    ciInstanceKlass* ik = base->as_instance_klass();
   52.12 +    if (ik->exact_klass() != NULL) {
   52.13 +      return this;
   52.14 +    }
   52.15 +  } else if (base->is_primitive_type()) {
   52.16 +    return this;
   52.17 +  }
   52.18 +  return NULL;
   52.19 +}

    53.1 --- a/src/share/vm/ci/ciObjArrayKlass.hpp	Fri Oct 18 10:37:26 2013 +0000
    53.2 +++ b/src/share/vm/ci/ciObjArrayKlass.hpp	Fri Oct 18 19:44:40 2013 -0700
    53.3 @@ -73,6 +73,8 @@
    53.4    bool is_obj_array_klass() const { return true; }
    53.5  
    53.6    static ciObjArrayKlass* make(ciKlass* element_klass);
    53.7 +
    53.8 +  virtual ciKlass* exact_klass();
    53.9  };
   53.10  
   53.11  #endif // SHARE_VM_CI_CIOBJARRAYKLASS_HPP

    54.1 --- a/src/share/vm/ci/ciReplay.cpp	Fri Oct 18 10:37:26 2013 +0000
    54.2 +++ b/src/share/vm/ci/ciReplay.cpp	Fri Oct 18 19:44:40 2013 -0700
    54.3 @@ -965,14 +965,12 @@
    54.4      tty->cr();
    54.5    } else {
    54.6      EXCEPTION_CONTEXT;
    54.7 -    MethodCounters* mcs = method->method_counters();
    54.8      // m->_instructions_size = rec->instructions_size;
    54.9      m->_instructions_size = -1;
   54.10      m->_interpreter_invocation_count = rec->interpreter_invocation_count;
   54.11      m->_interpreter_throwout_count = rec->interpreter_throwout_count;
   54.12 -    if (mcs == NULL) {
   54.13 -      mcs = Method::build_method_counters(method, CHECK_AND_CLEAR);
   54.14 -    }
   54.15 +    MethodCounters* mcs = method->get_method_counters(CHECK_AND_CLEAR);
   54.16 +    guarantee(mcs != NULL, "method counters allocation failed");
   54.17      mcs->invocation_counter()->_counter = rec->invocation_counter;
   54.18      mcs->backedge_counter()->_counter = rec->backedge_counter;
   54.19    }

    55.1 --- a/src/share/vm/ci/ciStreams.hpp	Fri Oct 18 10:37:26 2013 +0000
    55.2 +++ b/src/share/vm/ci/ciStreams.hpp	Fri Oct 18 19:44:40 2013 -0700
    55.3 @@ -277,11 +277,14 @@
    55.4  class ciSignatureStream : public StackObj {
    55.5  private:
    55.6    ciSignature* _sig;
    55.7 -  int    _pos;
    55.8 +  int          _pos;
    55.9 +  // holder is a method's holder
   55.10 +  ciKlass*     _holder;
   55.11  public:
   55.12 -  ciSignatureStream(ciSignature* signature) {
   55.13 +  ciSignatureStream(ciSignature* signature, ciKlass* holder = NULL) {
   55.14      _sig = signature;
   55.15      _pos = 0;
   55.16 +    _holder = holder;
   55.17    }
   55.18  
   55.19    bool at_return_type() { return _pos == _sig->count(); }
   55.20 @@ -301,6 +304,23 @@
   55.21        return _sig->type_at(_pos);
   55.22      }
   55.23    }
   55.24 +
   55.25 +  // next klass in the signature
   55.26 +  ciKlass* next_klass() {
   55.27 +    ciKlass* sig_k;
   55.28 +    if (_holder != NULL) {
   55.29 +      sig_k = _holder;
   55.30 +      _holder = NULL;
   55.31 +    } else {
   55.32 +      while (!type()->is_klass()) {
   55.33 +        next();
   55.34 +      }
   55.35 +      assert(!at_return_type(), "passed end of signature");
   55.36 +      sig_k = type()->as_klass();
   55.37 +      next();
   55.38 +    }
   55.39 +    return sig_k;
   55.40 +  }
   55.41  };
   55.42  
   55.43  

    56.1 --- a/src/share/vm/ci/ciTypeArrayKlass.hpp	Fri Oct 18 10:37:26 2013 +0000
    56.2 +++ b/src/share/vm/ci/ciTypeArrayKlass.hpp	Fri Oct 18 19:44:40 2013 -0700
    56.3 @@ -57,6 +57,10 @@
    56.4  
    56.5    // Make an array klass corresponding to the specified primitive type.
    56.6    static ciTypeArrayKlass* make(BasicType type);
    56.7 +
    56.8 +  virtual ciKlass* exact_klass() {
    56.9 +    return this;
   56.10 +  }
   56.11  };
   56.12  
   56.13  #endif // SHARE_VM_CI_CITYPEARRAYKLASS_HPP

    57.1 --- a/src/share/vm/classfile/defaultMethods.cpp	Fri Oct 18 10:37:26 2013 +0000
    57.2 +++ b/src/share/vm/classfile/defaultMethods.cpp	Fri Oct 18 19:44:40 2013 -0700
    57.3 @@ -857,7 +857,6 @@
    57.4    m->set_max_locals(params);
    57.5    m->constMethod()->set_stackmap_data(NULL);
    57.6    m->set_code(code_start);
    57.7 -  m->set_force_inline(true);
    57.8  
    57.9    return m;
   57.10  }

    58.1 --- a/src/share/vm/classfile/verifier.cpp	Fri Oct 18 10:37:26 2013 +0000
    58.2 +++ b/src/share/vm/classfile/verifier.cpp	Fri Oct 18 19:44:40 2013 -0700
    58.3 @@ -2439,19 +2439,19 @@
    58.4               && !ref_class_type.equals(current_type())
    58.5               && !ref_class_type.equals(VerificationType::reference_type(
    58.6                    current_class()->super()->name()))) {
    58.7 -    bool subtype = ref_class_type.is_assignable_from(
    58.8 -      current_type(), this, CHECK_VERIFY(this));
    58.9 +    bool subtype = false;
   58.10 +    if (!current_class()->is_anonymous()) {
   58.11 +      subtype = ref_class_type.is_assignable_from(
   58.12 +                 current_type(), this, CHECK_VERIFY(this));
   58.13 +    } else {
   58.14 +      subtype = ref_class_type.is_assignable_from(VerificationType::reference_type(
   58.15 +                 current_class()->host_klass()->name()), this, CHECK_VERIFY(this));
   58.16 +    }
   58.17      if (!subtype) {
   58.18 -      if (current_class()->is_anonymous()) {
   58.19 -        subtype = ref_class_type.is_assignable_from(VerificationType::reference_type(
   58.20 -                   current_class()->host_klass()->name()), this, CHECK_VERIFY(this));
   58.21 -      }
   58.22 -      if (!subtype) {
   58.23 -        verify_error(ErrorContext::bad_code(bci),
   58.24 -            "Bad invokespecial instruction: "
   58.25 -            "current class isn't assignable to reference class.");
   58.26 -         return;
   58.27 -      }
   58.28 +      verify_error(ErrorContext::bad_code(bci),
   58.29 +          "Bad invokespecial instruction: "
   58.30 +          "current class isn't assignable to reference class.");
   58.31 +       return;
   58.32      }
   58.33    }
   58.34    // Match method descriptor with operand stack
   58.35 @@ -2470,17 +2470,13 @@
   58.36          if (!current_class()->is_anonymous()) {
   58.37            current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
   58.38          } else {
   58.39 -          // anonymous class invokespecial calls: either the
   58.40 -          // operand stack/objectref  is a subtype of the current class OR
   58.41 -          // the objectref is a subtype of the host_klass of the current class
   58.42 +          // anonymous class invokespecial calls: check if the
   58.43 +          // objectref is a subtype of the host_klass of the current class
   58.44            // to allow an anonymous class to reference methods in the host_klass
   58.45            VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
   58.46 -          bool subtype = current_type().is_assignable_from(top, this, CHECK_VERIFY(this));
   58.47 -          if (!subtype) {
   58.48 -            VerificationType hosttype =
   58.49 -              VerificationType::reference_type(current_class()->host_klass()->name());
   58.50 -            subtype = hosttype.is_assignable_from(top, this, CHECK_VERIFY(this));
   58.51 -          }
   58.52 +          VerificationType hosttype =
   58.53 +            VerificationType::reference_type(current_class()->host_klass()->name());
   58.54 +          bool subtype = hosttype.is_assignable_from(top, this, CHECK_VERIFY(this));
   58.55            if (!subtype) {
   58.56              verify_error( ErrorContext::bad_type(current_frame->offset(),
   58.57                current_frame->stack_top_ctx(),

    59.1 --- a/src/share/vm/code/codeBlob.cpp	Fri Oct 18 10:37:26 2013 +0000
    59.2 +++ b/src/share/vm/code/codeBlob.cpp	Fri Oct 18 19:44:40 2013 -0700
    59.3 @@ -245,8 +245,8 @@
    59.4  }
    59.5  
    59.6  
    59.7 -void* BufferBlob::operator new(size_t s, unsigned size) throw() {
    59.8 -  void* p = CodeCache::allocate(size);
    59.9 +void* BufferBlob::operator new(size_t s, unsigned size, bool is_critical) throw() {
   59.10 +  void* p = CodeCache::allocate(size, is_critical);
   59.11    return p;
   59.12  }
   59.13  
   59.14 @@ -277,7 +277,10 @@
   59.15    unsigned int size = allocation_size(cb, sizeof(AdapterBlob));
   59.16    {
   59.17      MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
   59.18 -    blob = new (size) AdapterBlob(size, cb);
   59.19 +    // The parameter 'true' indicates a critical memory allocation.
   59.20 +    // This means that CodeCacheMinimumFreeSpace is used, if necessary
   59.21 +    const bool is_critical = true;
   59.22 +    blob = new (size, is_critical) AdapterBlob(size, cb);
   59.23    }
   59.24    // Track memory usage statistic after releasing CodeCache_lock
   59.25    MemoryService::track_code_cache_memory_usage();
   59.26 @@ -299,7 +302,10 @@
   59.27    size += round_to(buffer_size, oopSize);
   59.28    {
   59.29      MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
   59.30 -    blob = new (size) MethodHandlesAdapterBlob(size);
   59.31 +    // The parameter 'true' indicates a critical memory allocation.
   59.32 +    // This means that CodeCacheMinimumFreeSpace is used, if necessary
   59.33 +    const bool is_critical = true;
   59.34 +    blob = new (size, is_critical) MethodHandlesAdapterBlob(size);
   59.35    }
   59.36    // Track memory usage statistic after releasing CodeCache_lock
   59.37    MemoryService::track_code_cache_memory_usage();

    60.1 --- a/src/share/vm/code/codeBlob.hpp	Fri Oct 18 10:37:26 2013 +0000
    60.2 +++ b/src/share/vm/code/codeBlob.hpp	Fri Oct 18 19:44:40 2013 -0700
    60.3 @@ -209,7 +209,7 @@
    60.4    BufferBlob(const char* name, int size);
    60.5    BufferBlob(const char* name, int size, CodeBuffer* cb);
    60.6  
    60.7 -  void* operator new(size_t s, unsigned size) throw();
    60.8 +  void* operator new(size_t s, unsigned size, bool is_critical = false) throw();
    60.9  
   60.10   public:
   60.11    // Creation
   60.12 @@ -253,7 +253,6 @@
   60.13  class MethodHandlesAdapterBlob: public BufferBlob {
   60.14  private:
   60.15    MethodHandlesAdapterBlob(int size)                 : BufferBlob("MethodHandles adapters", size) {}
   60.16 -  MethodHandlesAdapterBlob(int size, CodeBuffer* cb) : BufferBlob("MethodHandles adapters", size, cb) {}
   60.17  
   60.18  public:
   60.19    // Creation

    61.1 --- a/src/share/vm/compiler/abstractCompiler.cpp	Fri Oct 18 10:37:26 2013 +0000
    61.2 +++ b/src/share/vm/compiler/abstractCompiler.cpp	Fri Oct 18 19:44:40 2013 -0700
    61.3 @@ -24,41 +24,42 @@
    61.4  
    61.5  #include "precompiled.hpp"
    61.6  #include "compiler/abstractCompiler.hpp"
    61.7 +#include "compiler/compileBroker.hpp"
    61.8  #include "runtime/mutexLocker.hpp"
    61.9 -void AbstractCompiler::initialize_runtimes(initializer f, volatile int* state) {
   61.10 -  if (*state != initialized) {
   61.11  
   61.12 -    // We are thread in native here...
   61.13 -    CompilerThread* thread = CompilerThread::current();
   61.14 -    bool do_initialization = false;
   61.15 -    {
   61.16 -      ThreadInVMfromNative tv(thread);
   61.17 -      ResetNoHandleMark rnhm;
   61.18 -      MutexLocker only_one(CompileThread_lock, thread);
   61.19 -      if ( *state == uninitialized) {
   61.20 -        do_initialization = true;
   61.21 -        *state = initializing;
   61.22 -      } else {
   61.23 -        while (*state == initializing ) {
   61.24 -          CompileThread_lock->wait();
   61.25 -        }
   61.26 +bool AbstractCompiler::should_perform_init() {
   61.27 +  if (_compiler_state != initialized) {
   61.28 +    MutexLocker only_one(CompileThread_lock);
   61.29 +
   61.30 +    if (_compiler_state == uninitialized) {
   61.31 +      _compiler_state = initializing;
   61.32 +      return true;
   61.33 +    } else {
   61.34 +      while (_compiler_state == initializing) {
   61.35 +        CompileThread_lock->wait();
   61.36        }
   61.37      }
   61.38 -    if (do_initialization) {
   61.39 -      // We can not hold any locks here since JVMTI events may call agents
   61.40 +  }
   61.41 +  return false;
   61.42 +}
   61.43  
   61.44 -      // Compiler(s) run as native
   61.45 +bool AbstractCompiler::should_perform_shutdown() {
   61.46 +  // Since this method can be called by multiple threads, the lock ensures atomicity of
   61.47 +  // decrementing '_num_compiler_threads' and the following operations.
   61.48 +  MutexLocker only_one(CompileThread_lock);
   61.49 +  _num_compiler_threads--;
   61.50 +  assert (CompileBroker::is_compilation_disabled_forever(), "Must be set, otherwise thread waits forever");
   61.51  
   61.52 -      (*f)();
   61.53 +  // Only the last thread will perform shutdown operations
   61.54 +  if (_num_compiler_threads == 0) {
   61.55 +    return true;
   61.56 +  }
   61.57 +  return false;
   61.58 +}
   61.59  
   61.60 -      // To in_vm so we can use the lock
   61.61 -
   61.62 -      ThreadInVMfromNative tv(thread);
   61.63 -      ResetNoHandleMark rnhm;
   61.64 -      MutexLocker only_one(CompileThread_lock, thread);
   61.65 -      assert(*state == initializing, "wrong state");
   61.66 -      *state = initialized;
   61.67 -      CompileThread_lock->notify_all();
   61.68 -    }
   61.69 -  }
   61.70 +void AbstractCompiler::set_state(int state) {
   61.71 +  // Ensure that ste is only set by one thread at a time
   61.72 +  MutexLocker only_one(CompileThread_lock);
   61.73 +  _compiler_state =  state;
   61.74 +  CompileThread_lock->notify_all();
   61.75  }

    62.1 --- a/src/share/vm/compiler/abstractCompiler.hpp	Fri Oct 18 10:37:26 2013 +0000
    62.2 +++ b/src/share/vm/compiler/abstractCompiler.hpp	Fri Oct 18 19:44:40 2013 -0700
    62.3 @@ -27,22 +27,25 @@
    62.4  
    62.5  #include "ci/compilerInterface.hpp"
    62.6  
    62.7 -typedef void (*initializer)(void);
    62.8 -
    62.9  class AbstractCompiler : public CHeapObj<mtCompiler> {
   62.10   private:
   62.11 -  bool _is_initialized; // Mark whether compiler object is initialized
   62.12 +  volatile int _num_compiler_threads;
   62.13  
   62.14   protected:
   62.15 +  volatile int _compiler_state;
   62.16    // Used for tracking global state of compiler runtime initialization
   62.17 -  enum { uninitialized, initializing, initialized };
   62.18 +  enum { uninitialized, initializing, initialized, failed, shut_down };
   62.19  
   62.20 -  // This method will call the initialization method "f" once (per compiler class/subclass)
   62.21 -  // and do so without holding any locks
   62.22 -  void initialize_runtimes(initializer f, volatile int* state);
   62.23 +  // This method returns true for the first compiler thread that reaches that methods.
   62.24 +  // This thread will initialize the compiler runtime.
   62.25 +  bool should_perform_init();
   62.26  
   62.27   public:
   62.28 -  AbstractCompiler() : _is_initialized(false)    {}
   62.29 +  AbstractCompiler() : _compiler_state(uninitialized), _num_compiler_threads(0) {}
   62.30 +
   62.31 +  // This function determines the compiler thread that will perform the
   62.32 +  // shutdown of the corresponding compiler runtime.
   62.33 +  bool should_perform_shutdown();
   62.34  
   62.35    // Name of this compiler
   62.36    virtual const char* name() = 0;
   62.37 @@ -74,17 +77,18 @@
   62.38  #endif // TIERED
   62.39  
   62.40    // Customization
   62.41 -  virtual bool needs_stubs            ()         = 0;
   62.42 +  virtual void initialize () = 0;
   62.43  
   62.44 -  void mark_initialized()                        { _is_initialized = true; }
   62.45 -  bool is_initialized()                          { return _is_initialized; }
   62.46 +  void set_num_compiler_threads(int num) { _num_compiler_threads = num;  }
   62.47 +  int num_compiler_threads()             { return _num_compiler_threads; }
   62.48  
   62.49 -  virtual void initialize()                      = 0;
   62.50 -
   62.51 +  // Get/set state of compiler objects
   62.52 +  bool is_initialized()           { return _compiler_state == initialized; }
   62.53 +  bool is_failed     ()           { return _compiler_state == failed;}
   62.54 +  void set_state     (int state);
   62.55 +  void set_shut_down ()           { set_state(shut_down); }
   62.56    // Compilation entry point for methods
   62.57 -  virtual void compile_method(ciEnv* env,
   62.58 -                              ciMethod* target,
   62.59 -                              int entry_bci) {
   62.60 +  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci) {
   62.61      ShouldNotReachHere();
   62.62    }
   62.63  

    63.1 --- a/src/share/vm/compiler/compileBroker.cpp	Fri Oct 18 10:37:26 2013 +0000
    63.2 +++ b/src/share/vm/compiler/compileBroker.cpp	Fri Oct 18 19:44:40 2013 -0700
    63.3 @@ -186,7 +186,7 @@
    63.4  CompileQueue* CompileBroker::_c1_method_queue    = NULL;
    63.5  CompileTask*  CompileBroker::_task_free_list     = NULL;
    63.6  
    63.7 -GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;
    63.8 +GrowableArray<CompilerThread*>* CompileBroker::_compiler_threads = NULL;
    63.9  
   63.10  
   63.11  class CompilationLog : public StringEventLog {
   63.12 @@ -587,9 +587,6 @@
   63.13  
   63.14  
   63.15  
   63.16 -// ------------------------------------------------------------------
   63.17 -// CompileQueue::add
   63.18 -//
   63.19  // Add a CompileTask to a CompileQueue
   63.20  void CompileQueue::add(CompileTask* task) {
   63.21    assert(lock()->owned_by_self(), "must own lock");
   63.22 @@ -626,6 +623,16 @@
   63.23    lock()->notify_all();
   63.24  }
   63.25  
   63.26 +void CompileQueue::delete_all() {
   63.27 +  assert(lock()->owned_by_self(), "must own lock");
   63.28 +  if (_first != NULL) {
   63.29 +    for (CompileTask* task = _first; task != NULL; task = task->next()) {
   63.30 +      delete task;
   63.31 +    }
   63.32 +    _first = NULL;
   63.33 +  }
   63.34 +}
   63.35 +
   63.36  // ------------------------------------------------------------------
   63.37  // CompileQueue::get
   63.38  //
   63.39 @@ -640,6 +647,11 @@
   63.40    // case we perform code cache sweeps to free memory such that we can re-enable
   63.41    // compilation.
   63.42    while (_first == NULL) {
   63.43 +    // Exit loop if compilation is disabled forever
   63.44 +    if (CompileBroker::is_compilation_disabled_forever()) {
   63.45 +      return NULL;
   63.46 +    }
   63.47 +
   63.48      if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs()) {
   63.49        // Wait a certain amount of time to possibly do another sweep.
   63.50        // We must wait until stack scanning has happened so that we can
   63.51 @@ -664,9 +676,17 @@
   63.52        // remains unchanged. This behavior is desired, since we want to keep
   63.53        // the stable state, i.e., we do not want to evict methods from the
   63.54        // code cache if it is unnecessary.
   63.55 -      lock()->wait();
   63.56 +      // We need a timed wait here, since compiler threads can exit if compilation
   63.57 +      // is disabled forever. We use 5 seconds wait time; the exiting of compiler threads
   63.58 +      // is not critical and we do not want idle compiler threads to wake up too often.
   63.59 +      lock()->wait(!Mutex::_no_safepoint_check_flag, 5*1000);
   63.60      }
   63.61    }
   63.62 +
   63.63 +  if (CompileBroker::is_compilation_disabled_forever()) {
   63.64 +    return NULL;
   63.65 +  }
   63.66 +
   63.67    CompileTask* task = CompilationPolicy::policy()->select_task(this);
   63.68    remove(task);
   63.69    return task;
   63.70 @@ -891,10 +911,8 @@
   63.71  }
   63.72  
   63.73  
   63.74 -
   63.75 -// ------------------------------------------------------------------
   63.76 -// CompileBroker::make_compiler_thread
   63.77 -CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
   63.78 +CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters,
   63.79 +                                                    AbstractCompiler* comp, TRAPS) {
   63.80    CompilerThread* compiler_thread = NULL;
   63.81  
   63.82    Klass* k =
   63.83 @@ -961,6 +979,7 @@
   63.84      java_lang_Thread::set_daemon(thread_oop());
   63.85  
   63.86      compiler_thread->set_threadObj(thread_oop());
   63.87 +    compiler_thread->set_compiler(comp);
   63.88      Threads::add(compiler_thread);
   63.89      Thread::start(compiler_thread);
   63.90    }
   63.91 @@ -972,25 +991,24 @@
   63.92  }
   63.93  
   63.94  
   63.95 -// ------------------------------------------------------------------
   63.96 -// CompileBroker::init_compiler_threads
   63.97 -//
   63.98 -// Initialize the compilation queue
   63.99  void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {
  63.100    EXCEPTION_MARK;
  63.101  #if !defined(ZERO) && !defined(SHARK)
  63.102    assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
  63.103  #endif // !ZERO && !SHARK
  63.104 +  // Initialize the compilation queue
  63.105    if (c2_compiler_count > 0) {
  63.106      _c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
  63.107 +    _compilers[1]->set_num_compiler_threads(c2_compiler_count);
  63.108    }
  63.109    if (c1_compiler_count > 0) {
  63.110      _c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
  63.111 +    _compilers[0]->set_num_compiler_threads(c1_compiler_count);
  63.112    }
  63.113  
  63.114    int compiler_count = c1_compiler_count + c2_compiler_count;
  63.115  
  63.116 -  _method_threads =
  63.117 +  _compiler_threads =
  63.118      new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true);
  63.119  
  63.120    char name_buffer[256];
  63.121 @@ -998,21 +1016,22 @@
  63.122      // Create a name for our thread.
  63.123      sprintf(name_buffer, "C2 CompilerThread%d", i);
  63.124      CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
  63.125 -    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK);
  63.126 -    _method_threads->append(new_thread);
  63.127 +    // Shark and C2
  63.128 +    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, _compilers[1], CHECK);
  63.129 +    _compiler_threads->append(new_thread);
  63.130    }
  63.131  
  63.132    for (int i = c2_compiler_count; i < compiler_count; i++) {
  63.133      // Create a name for our thread.
  63.134      sprintf(name_buffer, "C1 CompilerThread%d", i);
  63.135      CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
  63.136 -    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK);
  63.137 -    _method_threads->append(new_thread);
  63.138 +    // C1
  63.139 +    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, _compilers[0], CHECK);
  63.140 +    _compiler_threads->append(new_thread);
  63.141    }
  63.142  
  63.143    if (UsePerfData) {
  63.144 -    PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
  63.145 -                                     compiler_count, CHECK);
  63.146 +    PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes, compiler_count, CHECK);
  63.147    }
  63.148  }
  63.149  
  63.150 @@ -1029,27 +1048,6 @@
  63.151  }
  63.152  
  63.153  // ------------------------------------------------------------------
  63.154 -// CompileBroker::is_idle
  63.155 -bool CompileBroker::is_idle() {
  63.156 -  if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) {
  63.157 -    return false;
  63.158 -  } else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) {
  63.159 -    return false;
  63.160 -  } else {
  63.161 -    int num_threads = _method_threads->length();
  63.162 -    for (int i=0; i<num_threads; i++) {
  63.163 -      if (_method_threads->at(i)->task() != NULL) {
  63.164 -        return false;
  63.165 -      }
  63.166 -    }
  63.167 -
  63.168 -    // No pending or active compilations.
  63.169 -    return true;
  63.170 -  }
  63.171 -}
  63.172 -
  63.173 -
  63.174 -// ------------------------------------------------------------------
  63.175  // CompileBroker::compile_method
  63.176  //
  63.177  // Request compilation of a method.
  63.178 @@ -1551,6 +1549,101 @@
  63.179    free_task(task);
  63.180  }
  63.181  
  63.182 +// Initialize compiler thread(s) + compiler object(s). The postcondition
  63.183 +// of this function is that the compiler runtimes are initialized and that
  63.184 +//compiler threads can start compiling.
  63.185 +bool CompileBroker::init_compiler_runtime() {
  63.186 +  CompilerThread* thread = CompilerThread::current();
  63.187 +  AbstractCompiler* comp = thread->compiler();
  63.188 +  // Final sanity check - the compiler object must exist
  63.189 +  guarantee(comp != NULL, "Compiler object must exist");
  63.190 +
  63.191 +  int system_dictionary_modification_counter;
  63.192 +  {
  63.193 +    MutexLocker locker(Compile_lock, thread);
  63.194 +    system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
  63.195 +  }
  63.196 +
  63.197 +  {
  63.198 +    // Must switch to native to allocate ci_env
  63.199 +    ThreadToNativeFromVM ttn(thread);
  63.200 +    ciEnv ci_env(NULL, system_dictionary_modification_counter);
  63.201 +    // Cache Jvmti state
  63.202 +    ci_env.cache_jvmti_state();
  63.203 +    // Cache DTrace flags
  63.204 +    ci_env.cache_dtrace_flags();
  63.205 +
  63.206 +    // Switch back to VM state to do compiler initialization
  63.207 +    ThreadInVMfromNative tv(thread);
  63.208 +    ResetNoHandleMark rnhm;
  63.209 +
  63.210 +
  63.211 +    if (!comp->is_shark()) {
  63.212 +      // Perform per-thread and global initializations
  63.213 +      comp->initialize();
  63.214 +    }
  63.215 +  }
  63.216 +
  63.217 +  if (comp->is_failed()) {
  63.218 +    disable_compilation_forever();
  63.219 +    // If compiler initialization failed, no compiler thread that is specific to a
  63.220 +    // particular compiler runtime will ever start to compile methods.
  63.221 +
  63.222 +    shutdown_compiler_runtime(comp, thread);
  63.223 +    return false;
  63.224 +  }
  63.225 +
  63.226 +  // C1 specific check
  63.227 +  if (comp->is_c1() && (thread->get_buffer_blob() == NULL)) {
  63.228 +    warning("Initialization of %s thread failed (no space to run compilers)", thread->name());
  63.229 +    return false;
  63.230 +  }
  63.231 +
  63.232 +  return true;
  63.233 +}
  63.234 +
  63.235 +// If C1 and/or C2 initialization failed, we shut down all compilation.
  63.236 +// We do this to keep things simple. This can be changed if it ever turns out to be
  63.237 +// a problem.
  63.238 +void CompileBroker::shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread) {
  63.239 +  // Free buffer blob, if allocated
  63.240 +  if (thread->get_buffer_blob() != NULL) {
  63.241 +    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  63.242 +    CodeCache::free(thread->get_buffer_blob());
  63.243 +  }
  63.244 +
  63.245 +  if (comp->should_perform_shutdown()) {
  63.246 +    // There are two reasons for shutting down the compiler
  63.247 +    // 1) compiler runtime initialization failed
  63.248 +    // 2) The code cache is full and the following flag is set: -XX:-UseCodeCacheFlushing
  63.249 +    warning("Shutting down compiler %s (no space to run compilers)", comp->name());
  63.250 +
  63.251 +    // Only one thread per compiler runtime object enters here
  63.252 +    // Set state to shut down
  63.253 +    comp->set_shut_down();
  63.254 +
  63.255 +    MutexLocker mu(MethodCompileQueue_lock, thread);
  63.256 +    CompileQueue* queue;
  63.257 +    if (_c1_method_queue != NULL) {
  63.258 +      _c1_method_queue->delete_all();
  63.259 +      queue = _c1_method_queue;
  63.260 +      _c1_method_queue = NULL;
  63.261 +      delete _c1_method_queue;
  63.262 +    }
  63.263 +
  63.264 +    if (_c2_method_queue != NULL) {
  63.265 +      _c2_method_queue->delete_all();
  63.266 +      queue = _c2_method_queue;
  63.267 +      _c2_method_queue = NULL;
  63.268 +      delete _c2_method_queue;
  63.269 +    }
  63.270 +
  63.271 +    // We could delete compiler runtimes also. However, there are references to
  63.272 +    // the compiler runtime(s) (e.g.,  nmethod::is_compiled_by_c1()) which then
  63.273 +    // fail. This can be done later if necessary.
  63.274 +  }
  63.275 +}
  63.276 +
  63.277  // ------------------------------------------------------------------
  63.278  // CompileBroker::compiler_thread_loop
  63.279  //
  63.280 @@ -1558,7 +1651,6 @@
  63.281  void CompileBroker::compiler_thread_loop() {
  63.282    CompilerThread* thread = CompilerThread::current();
  63.283    CompileQueue* queue = thread->queue();
  63.284 -
  63.285    // For the thread that initializes the ciObjectFactory
  63.286    // this resource mark holds all the shared objects
  63.287    ResourceMark rm;
  63.288 @@ -1587,65 +1679,78 @@
  63.289      log->end_elem();
  63.290    }
  63.291  
  63.292 -  while (true) {
  63.293 -    {
  63.294 -      // We need this HandleMark to avoid leaking VM handles.
  63.295 -      HandleMark hm(thread);
  63.296 +  // If compiler thread/runtime initialization fails, exit the compiler thread
  63.297 +  if (!init_compiler_runtime()) {
  63.298 +    return;
  63.299 +  }
  63.300  
  63.301 -      if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
  63.302 -        // the code cache is really full
  63.303 -        handle_full_code_cache();
  63.304 -      }
  63.305 +  // Poll for new compilation tasks as long as the JVM runs. Compilation
  63.306 +  // should only be disabled if something went wrong while initializing the
  63.307 +  // compiler runtimes. This, in turn, should not happen. The only known case
  63.308 +  // when compiler runtime initialization fails is if there is not enough free
  63.309 +  // space in the code cache to generate the necessary stubs, etc.
  63.310 +  while (!is_compilation_disabled_forever()) {
  63.311 +    // We need this HandleMark to avoid leaking VM handles.
  63.312 +    HandleMark hm(thread);
  63.313  
  63.314 -      CompileTask* task = queue->get();
  63.315 +    if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
  63.316 +      // the code cache is really full
  63.317 +      handle_full_code_cache();
  63.318 +    }
  63.319  
  63.320 -      // Give compiler threads an extra quanta.  They tend to be bursty and
  63.321 -      // this helps the compiler to finish up the job.
  63.322 -      if( CompilerThreadHintNoPreempt )
  63.323 -        os::hint_no_preempt();
  63.324 +    CompileTask* task = queue->get();
  63.325 +    if (task == NULL) {
  63.326 +      continue;
  63.327 +    }
  63.328  
  63.329 -      // trace per thread time and compile statistics
  63.330 -      CompilerCounters* counters = ((CompilerThread*)thread)->counters();
  63.331 -      PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());
  63.332 +    // Give compiler threads an extra quanta.  They tend to be bursty and
  63.333 +    // this helps the compiler to finish up the job.
  63.334 +    if( CompilerThreadHintNoPreempt )
  63.335 +      os::hint_no_preempt();
  63.336  
  63.337 -      // Assign the task to the current thread.  Mark this compilation
  63.338 -      // thread as active for the profiler.
  63.339 -      CompileTaskWrapper ctw(task);
  63.340 -      nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
  63.341 -      task->set_code_handle(&result_handle);
  63.342 -      methodHandle method(thread, task->method());
  63.343 +    // trace per thread time and compile statistics
  63.344 +    CompilerCounters* counters = ((CompilerThread*)thread)->counters();
  63.345 +    PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());
  63.346  
  63.347 -      // Never compile a method if breakpoints are present in it
  63.348 -      if (method()->number_of_breakpoints() == 0) {
  63.349 -        // Compile the method.
  63.350 -        if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
  63.351 +    // Assign the task to the current thread.  Mark this compilation
  63.352 +    // thread as active for the profiler.
  63.353 +    CompileTaskWrapper ctw(task);
  63.354 +    nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
  63.355 +    task->set_code_handle(&result_handle);
  63.356 +    methodHandle method(thread, task->method());
  63.357 +
  63.358 +    // Never compile a method if breakpoints are present in it
  63.359 +    if (method()->number_of_breakpoints() == 0) {
  63.360 +      // Compile the method.
  63.361 +      if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
  63.362  #ifdef COMPILER1
  63.363 -          // Allow repeating compilations for the purpose of benchmarking
  63.364 -          // compile speed. This is not useful for customers.
  63.365 -          if (CompilationRepeat != 0) {
  63.366 -            int compile_count = CompilationRepeat;
  63.367 -            while (compile_count > 0) {
  63.368 -              invoke_compiler_on_method(task);
  63.369 -              nmethod* nm = method->code();
  63.370 -              if (nm != NULL) {
  63.371 -                nm->make_zombie();
  63.372 -                method->clear_code();
  63.373 -              }
  63.374 -              compile_count--;
  63.375 +        // Allow repeating compilations for the purpose of benchmarking
  63.376 +        // compile speed. This is not useful for customers.
  63.377 +        if (CompilationRepeat != 0) {
  63.378 +          int compile_count = CompilationRepeat;
  63.379 +          while (compile_count > 0) {
  63.380 +            invoke_compiler_on_method(task);
  63.381 +            nmethod* nm = method->code();
  63.382 +            if (nm != NULL) {
  63.383 +              nm->make_zombie();
  63.384 +              method->clear_code();
  63.385              }
  63.386 +            compile_count--;
  63.387            }
  63.388 +        }
  63.389  #endif /* COMPILER1 */
  63.390 -          invoke_compiler_on_method(task);
  63.391 -        } else {
  63.392 -          // After compilation is disabled, remove remaining methods from queue
  63.393 -          method->clear_queued_for_compilation();
  63.394 -        }
  63.395 +        invoke_compiler_on_method(task);
  63.396 +      } else {
  63.397 +        // After compilation is disabled, remove remaining methods from queue
  63.398 +        method->clear_queued_for_compilation();
  63.399        }
  63.400      }
  63.401    }
  63.402 +
  63.403 +  // Shut down compiler runtime
  63.404 +  shutdown_compiler_runtime(thread->compiler(), thread);
  63.405  }
  63.406  
  63.407 -
  63.408  // ------------------------------------------------------------------
  63.409  // CompileBroker::init_compiler_thread_log
  63.410  //
  63.411 @@ -1953,11 +2058,14 @@
  63.412        // Since code cache is full, immediately stop new compiles
  63.413        if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) {
  63.414          NMethodSweeper::log_sweep("disable_compiler");
  63.415 +
  63.416 +        // Switch to 'vm_state'. This ensures that possibly_sweep() can be called
  63.417 +        // without having to consider the state in which the current thread is.
  63.418 +        ThreadInVMfromUnknown in_vm;
  63.419          NMethodSweeper::possibly_sweep();
  63.420        }
  63.421      } else {
  63.422 -      UseCompiler               = false;
  63.423 -      AlwaysCompileLoopMethods  = false;
  63.424 +      disable_compilation_forever();
  63.425      }
  63.426    }
  63.427    codecache_print(/* detailed= */ true);

    64.1 --- a/src/share/vm/compiler/compileBroker.hpp	Fri Oct 18 10:37:26 2013 +0000
    64.2 +++ b/src/share/vm/compiler/compileBroker.hpp	Fri Oct 18 19:44:40 2013 -0700
    64.3 @@ -213,8 +213,12 @@
    64.4  
    64.5    // Redefine Classes support
    64.6    void mark_on_stack();
    64.7 +  void delete_all();
    64.8 +  void         print();
    64.9  
   64.10 -  void         print();
   64.11 +  ~CompileQueue() {
   64.12 +    assert (is_empty(), " Compile Queue must be empty");
   64.13 +  }
   64.14  };
   64.15  
   64.16  // CompileTaskWrapper
   64.17 @@ -266,7 +270,7 @@
   64.18    static CompileQueue* _c1_method_queue;
   64.19    static CompileTask* _task_free_list;
   64.20  
   64.21 -  static GrowableArray<CompilerThread*>* _method_threads;
   64.22 +  static GrowableArray<CompilerThread*>* _compiler_threads;
   64.23  
   64.24    // performance counters
   64.25    static PerfCounter* _perf_total_compilation;
   64.26 @@ -311,7 +315,7 @@
   64.27    static int _sum_nmethod_code_size;
   64.28    static long _peak_compilation_time;
   64.29  
   64.30 -  static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS);
   64.31 +  static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, AbstractCompiler* comp, TRAPS);
   64.32    static void init_compiler_threads(int c1_compiler_count, int c2_compiler_count);
   64.33    static bool compilation_is_complete  (methodHandle method, int osr_bci, int comp_level);
   64.34    static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
   64.35 @@ -351,6 +355,9 @@
   64.36      if (is_c1_compile(comp_level)) return _c1_method_queue;
   64.37      return NULL;
   64.38    }
   64.39 +  static bool init_compiler_runtime();
   64.40 +  static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);
   64.41 +
   64.42   public:
   64.43    enum {
   64.44      // The entry bci used for non-OSR compilations.
   64.45 @@ -378,9 +385,7 @@
   64.46                                   const char* comment, Thread* thread);
   64.47  
   64.48    static void compiler_thread_loop();
   64.49 -
   64.50    static uint get_compilation_id() { return _compilation_id; }
   64.51 -  static bool is_idle();
   64.52  
   64.53    // Set _should_block.
   64.54    // Call this from the VM, with Threads_lock held and a safepoint requested.
   64.55 @@ -391,8 +396,9 @@
   64.56  
   64.57    enum {
   64.58      // Flags for toggling compiler activity
   64.59 -    stop_compilation = 0,
   64.60 -    run_compilation  = 1
   64.61 +    stop_compilation    = 0,
   64.62 +    run_compilation     = 1,
   64.63 +    shutdown_compilaton = 2
   64.64    };
   64.65  
   64.66    static bool should_compile_new_jobs() { return UseCompiler && (_should_compile_new_jobs == run_compilation); }
   64.67 @@ -401,6 +407,16 @@
   64.68      jint old = Atomic::cmpxchg(new_state, &_should_compile_new_jobs, 1-new_state);
   64.69      return (old == (1-new_state));
   64.70    }
   64.71 +
   64.72 +  static void disable_compilation_forever() {
   64.73 +    UseCompiler               = false;
   64.74 +    AlwaysCompileLoopMethods  = false;
   64.75 +    Atomic::xchg(shutdown_compilaton, &_should_compile_new_jobs);
   64.76 +  }
   64.77 +
   64.78 +  static bool is_compilation_disabled_forever() {
   64.79 +    return _should_compile_new_jobs == shutdown_compilaton;
   64.80 +  }
   64.81    static void handle_full_code_cache();
   64.82  
   64.83    // Return total compilation ticks

    65.1 --- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Fri Oct 18 10:37:26 2013 +0000
    65.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Fri Oct 18 19:44:40 2013 -0700
    65.3 @@ -344,6 +344,10 @@
    65.4      }
    65.5    }
    65.6  
    65.7 +  if (FLAG_IS_CMDLINE(NewSize) && FLAG_IS_CMDLINE(MaxNewSize) && NewSize > MaxNewSize) {
    65.8 +    vm_exit_during_initialization("Initial young gen size set larger than the maximum young gen size");
    65.9 +  }
   65.10 +
   65.11    if (FLAG_IS_CMDLINE(NewSize)) {
   65.12      _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
   65.13                                       1U);

    66.1 --- a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Fri Oct 18 10:37:26 2013 +0000
    66.2 +++ b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Fri Oct 18 19:44:40 2013 -0700
    66.3 @@ -211,7 +211,7 @@
    66.4    // a GC that freed space for the allocation.
    66.5    if (!MetadataAllocationFailALot) {
    66.6      _result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
    66.7 -    }
    66.8 +  }
    66.9  
   66.10    if (_result == NULL) {
   66.11      if (UseConcMarkSweepGC) {
   66.12 @@ -223,9 +223,7 @@
   66.13          _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
   66.14      }
   66.15      if (_result == NULL) {
   66.16 -      // Don't clear the soft refs.  This GC is for reclaiming metadata
   66.17 -      // and is unrelated to the fullness of the Java heap which should
   66.18 -      // be the criteria for clearing SoftReferences.
   66.19 +      // Don't clear the soft refs yet.
   66.20        if (Verbose && PrintGCDetails && UseConcMarkSweepGC) {
   66.21          gclog_or_tty->print_cr("\nCMS full GC for Metaspace");
   66.22        }
   66.23 @@ -235,7 +233,7 @@
   66.24        _result =
   66.25          _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
   66.26      }
   66.27 -    if (_result == NULL && !UseConcMarkSweepGC /* CMS already tried */) {
   66.28 +    if (_result == NULL) {
   66.29        // If still failing, allow the Metaspace to expand.
   66.30        // See delta_capacity_until_GC() for explanation of the
   66.31        // amount of the expansion.
   66.32 @@ -243,7 +241,16 @@
   66.33        // or a MaxMetaspaceSize has been specified on the command line.
   66.34        _result =
   66.35          _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
   66.36 -
   66.37 +      if (_result == NULL) {
   66.38 +        // If expansion failed, do a last-ditch collection and try allocating
   66.39 +        // again.  A last-ditch collection will clear softrefs.  This
   66.40 +        // behavior is similar to the last-ditch collection done for perm
   66.41 +        // gen when it was full and a collection for failed allocation
   66.42 +        // did not free perm gen space.
   66.43 +        heap->collect_as_vm_thread(GCCause::_last_ditch_collection);
   66.44 +        _result =
   66.45 +          _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
   66.46 +      }
   66.47      }
   66.48      if (Verbose && PrintGCDetails && _result == NULL) {
   66.49        gclog_or_tty->print_cr("\nAfter Metaspace GC failed to allocate size "

    67.1 --- a/src/share/vm/interpreter/linkResolver.cpp	Fri Oct 18 10:37:26 2013 +0000
    67.2 +++ b/src/share/vm/interpreter/linkResolver.cpp	Fri Oct 18 19:44:40 2013 -0700
    67.3 @@ -1,5 +1,6 @@
    67.4  /*
    67.5   * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
    67.6 + * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
    67.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    67.8   *
    67.9   * This code is free software; you can redistribute it and/or modify it
   67.10 @@ -158,6 +159,22 @@
   67.11      index = vt->index_of_miranda(resolved_method->name(),
   67.12                                   resolved_method->signature());
   67.13      kind = CallInfo::vtable_call;
   67.14 +  } else if (resolved_method->has_vtable_index()) {
   67.15 +    // Can occur if an interface redeclares a method of Object.
   67.16 +
   67.17 +#ifdef ASSERT
   67.18 +    // Ensure that this is really the case.
   67.19 +    KlassHandle object_klass = SystemDictionary::Object_klass();
   67.20 +    Method * object_resolved_method = object_klass()->vtable()->method_at(index);
   67.21 +    assert(object_resolved_method->name() == resolved_method->name(),
   67.22 +      err_msg("Object and interface method names should match at vtable index %d, %s != %s",
   67.23 +      index, object_resolved_method->name()->as_C_string(), resolved_method->name()->as_C_string()));
   67.24 +    assert(object_resolved_method->signature() == resolved_method->signature(),
   67.25 +      err_msg("Object and interface method signatures should match at vtable index %d, %s != %s",
   67.26 +      index, object_resolved_method->signature()->as_C_string(), resolved_method->signature()->as_C_string()));
   67.27 +#endif // ASSERT
   67.28 +
   67.29 +    kind = CallInfo::vtable_call;
   67.30    } else {
   67.31      // A regular interface call.
   67.32      kind = CallInfo::itable_call;

    68.1 --- a/src/share/vm/memory/binaryTreeDictionary.cpp	Fri Oct 18 10:37:26 2013 +0000
    68.2 +++ b/src/share/vm/memory/binaryTreeDictionary.cpp	Fri Oct 18 19:44:40 2013 -0700
    68.3 @@ -28,7 +28,6 @@
    68.4  #include "memory/binaryTreeDictionary.hpp"
    68.5  #include "memory/freeList.hpp"
    68.6  #include "memory/freeBlockDictionary.hpp"
    68.7 -#include "memory/metablock.hpp"
    68.8  #include "memory/metachunk.hpp"
    68.9  #include "runtime/globals.hpp"
   68.10  #include "utilities/ostream.hpp"

    69.1 --- a/src/share/vm/memory/freeBlockDictionary.cpp	Fri Oct 18 10:37:26 2013 +0000
    69.2 +++ b/src/share/vm/memory/freeBlockDictionary.cpp	Fri Oct 18 19:44:40 2013 -0700
    69.3 @@ -28,7 +28,6 @@
    69.4  #include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
    69.5  #endif // INCLUDE_ALL_GCS
    69.6  #include "memory/freeBlockDictionary.hpp"
    69.7 -#include "memory/metablock.hpp"
    69.8  #include "memory/metachunk.hpp"
    69.9  #include "runtime/thread.inline.hpp"
   69.10  #include "utilities/macros.hpp"

    70.1 --- a/src/share/vm/memory/freeList.cpp	Fri Oct 18 10:37:26 2013 +0000
    70.2 +++ b/src/share/vm/memory/freeList.cpp	Fri Oct 18 19:44:40 2013 -0700
    70.3 @@ -25,7 +25,6 @@
    70.4  #include "precompiled.hpp"
    70.5  #include "memory/freeBlockDictionary.hpp"
    70.6  #include "memory/freeList.hpp"
    70.7 -#include "memory/metablock.hpp"
    70.8  #include "memory/metachunk.hpp"
    70.9  #include "memory/sharedHeap.hpp"
   70.10  #include "runtime/globals.hpp"

    71.1 --- a/src/share/vm/memory/metablock.cpp	Fri Oct 18 10:37:26 2013 +0000
    71.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    71.3 @@ -1,68 +0,0 @@
    71.4 -/*
    71.5 - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
    71.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    71.7 - *
    71.8 - * This code is free software; you can redistribute it and/or modify it
    71.9 - * under the terms of the GNU General Public License version 2 only, as
   71.10 - * published by the Free Software Foundation.
   71.11 - *
   71.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   71.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   71.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   71.15 - * version 2 for more details (a copy is included in the LICENSE file that
   71.16 - * accompanied this code).
   71.17 - *
   71.18 - * You should have received a copy of the GNU General Public License version
   71.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   71.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   71.21 - *
   71.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   71.23 - * or visit www.oracle.com if you need additional information or have any
   71.24 - * questions.
   71.25 - *
   71.26 - */
   71.27 -
   71.28 -#include "precompiled.hpp"
   71.29 -#include "memory/allocation.hpp"
   71.30 -#include "memory/metablock.hpp"
   71.31 -#include "utilities/copy.hpp"
   71.32 -#include "utilities/debug.hpp"
   71.33 -
   71.34 -// Blocks of space for metadata are allocated out of Metachunks.
   71.35 -//
   71.36 -// Metachunk are allocated out of MetadataVirtualspaces and once
   71.37 -// allocated there is no explicit link between a Metachunk and
   71.38 -// the MetadataVirtualspaces from which it was allocated.
   71.39 -//
   71.40 -// Each SpaceManager maintains a
   71.41 -// list of the chunks it is using and the current chunk.  The current
   71.42 -// chunk is the chunk from which allocations are done.  Space freed in
   71.43 -// a chunk is placed on the free list of blocks (BlockFreelist) and
   71.44 -// reused from there.
   71.45 -//
   71.46 -// Future modification
   71.47 -//
   71.48 -// The Metachunk can conceivable be replaced by the Chunk in
   71.49 -// allocation.hpp.  Note that the latter Chunk is the space for
   71.50 -// allocation (allocations from the chunk are out of the space in
   71.51 -// the Chunk after the header for the Chunk) where as Metachunks
   71.52 -// point to space in a VirtualSpace.  To replace Metachunks with
   71.53 -// Chunks, change Chunks so that they can be allocated out of a VirtualSpace.
   71.54 -size_t Metablock::_min_block_byte_size = sizeof(Metablock);
   71.55 -
   71.56 -// New blocks returned by the Metaspace are zero initialized.
   71.57 -// We should fix the constructors to not assume this instead.
   71.58 -Metablock* Metablock::initialize(MetaWord* p, size_t word_size) {
   71.59 -  if (p == NULL) {
   71.60 -    return NULL;
   71.61 -  }
   71.62 -
   71.63 -  Metablock* result = (Metablock*) p;
   71.64 -
   71.65 -  // Clear the memory
   71.66 -  Copy::fill_to_aligned_words((HeapWord*)result, word_size);
   71.67 -#ifdef ASSERT
   71.68 -  result->set_word_size(word_size);
   71.69 -#endif
   71.70 -  return result;
   71.71 -}

    72.1 --- a/src/share/vm/memory/metablock.hpp	Fri Oct 18 10:37:26 2013 +0000
    72.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    72.3 @@ -1,101 +0,0 @@
    72.4 -/*
    72.5 - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    72.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    72.7 - *
    72.8 - * This code is free software; you can redistribute it and/or modify it
    72.9 - * under the terms of the GNU General Public License version 2 only, as
   72.10 - * published by the Free Software Foundation.
   72.11 - *
   72.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   72.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   72.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   72.15 - * version 2 for more details (a copy is included in the LICENSE file that
   72.16 - * accompanied this code).
   72.17 - *
   72.18 - * You should have received a copy of the GNU General Public License version
   72.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   72.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   72.21 - *
   72.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   72.23 - * or visit www.oracle.com if you need additional information or have any
   72.24 - * questions.
   72.25 - *
   72.26 - */
   72.27 -#ifndef SHARE_VM_MEMORY_METABLOCK_HPP
   72.28 -#define SHARE_VM_MEMORY_METABLOCK_HPP
   72.29 -
   72.30 -// Metablock are the unit of allocation from a Chunk.  It is initialized
   72.31 -// with the size of the requested allocation.  That size is overwritten
   72.32 -// once the allocation returns.
   72.33 -//
   72.34 -// A Metablock may be reused by its SpaceManager but are never moved between
   72.35 -// SpaceManagers.  There is no explicit link to the Metachunk
   72.36 -// from which it was allocated.  Metablock may be deallocated and
   72.37 -// put on a freelist but the space is never freed, rather
   72.38 -// the Metachunk it is a part of will be deallocated when it's
   72.39 -// associated class loader is collected.
   72.40 -
   72.41 -class Metablock VALUE_OBJ_CLASS_SPEC {
   72.42 -  friend class VMStructs;
   72.43 - private:
   72.44 -  // Used to align the allocation (see below).
   72.45 -  union block_t {
   72.46 -    void* _data[3];
   72.47 -    struct header_t {
   72.48 -      size_t _word_size;
   72.49 -      Metablock* _next;
   72.50 -      Metablock* _prev;
   72.51 -    } _header;
   72.52 -  } _block;
   72.53 -  static size_t _min_block_byte_size;
   72.54 -
   72.55 -  typedef union block_t Block;
   72.56 -  typedef struct header_t Header;
   72.57 -  const Block* block() const { return &_block; }
   72.58 -  const Block::header_t* header() const { return &(block()->_header); }
   72.59 - public:
   72.60 -
   72.61 -  static Metablock* initialize(MetaWord* p, size_t word_size);
   72.62 -
   72.63 -  // This places the body of the block at a 2 word boundary
   72.64 -  // because every block starts on a 2 word boundary.  Work out
   72.65 -  // how to make the body on a 2 word boundary if the block
   72.66 -  // starts on a arbitrary boundary.  JJJ
   72.67 -
   72.68 -  size_t word_size() const  { return header()->_word_size; }
   72.69 -  void set_word_size(size_t v) { _block._header._word_size = v; }
   72.70 -  size_t size() const volatile { return _block._header._word_size; }
   72.71 -  void set_size(size_t v) { _block._header._word_size = v; }
   72.72 -  Metablock* next() const { return header()->_next; }
   72.73 -  void set_next(Metablock* v) { _block._header._next = v; }
   72.74 -  Metablock* prev() const { return header()->_prev; }
   72.75 -  void set_prev(Metablock* v) { _block._header._prev = v; }
   72.76 -
   72.77 -  static size_t min_block_byte_size() { return _min_block_byte_size; }
   72.78 -
   72.79 -  bool is_free()                 { return header()->_word_size != 0; }
   72.80 -  void clear_next()              { set_next(NULL); }
   72.81 -  void link_prev(Metablock* ptr) { set_prev(ptr); }
   72.82 -  uintptr_t* end()              { return ((uintptr_t*) this) + size(); }
   72.83 -  bool cantCoalesce() const     { return false; }
   72.84 -  void link_next(Metablock* ptr) { set_next(ptr); }
   72.85 -  void link_after(Metablock* ptr){
   72.86 -    link_next(ptr);
   72.87 -    if (ptr != NULL) ptr->link_prev(this);
   72.88 -  }
   72.89 -
   72.90 -  // Should not be needed in a free list of Metablocks
   72.91 -  void markNotFree()            { ShouldNotReachHere(); }
   72.92 -
   72.93 -  // Debug support
   72.94 -#ifdef ASSERT
   72.95 -  void* prev_addr() const { return (void*)&_block._header._prev; }
   72.96 -  void* next_addr() const { return (void*)&_block._header._next; }
   72.97 -  void* size_addr() const { return (void*)&_block._header._word_size; }
   72.98 -#endif
   72.99 -  bool verify_chunk_in_free_list(Metablock* tc) const { return true; }
  72.100 -  bool verify_par_locked() { return true; }
  72.101 -
  72.102 -  void assert_is_mangled() const {/* Don't check "\*/}
  72.103 -};
  72.104 -#endif // SHARE_VM_MEMORY_METABLOCK_HPP