Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/agent/src/os/linux/LinuxDebuggerLocal.c	Sat Oct 05 03:14:53 2013 +0200
     1.2 +++ b/agent/src/os/linux/LinuxDebuggerLocal.c	Fri Oct 04 21:00:43 2013 -0700
     1.3 @@ -29,6 +29,7 @@
     1.4  #include <sys/types.h>
     1.5  #include <sys/stat.h>
     1.6  #include <fcntl.h>
     1.7 +#include <stdlib.h>
     1.8  #include <string.h>
     1.9  #include <limits.h>
    1.10  
    1.11 @@ -80,7 +81,7 @@
    1.12    (JNIEnv *env, jclass cls) {
    1.13    jclass listClass;
    1.14  
    1.15 -  if (init_libproc(getenv("LIBSAPROC_DEBUG")) != true) {
    1.16 +  if (init_libproc(getenv("LIBSAPROC_DEBUG") != NULL) != true) {
    1.17       THROW_NEW_DEBUGGER_EXCEPTION("can't initialize libproc");
    1.18    }
    1.19  

     2.1 --- a/agent/src/os/linux/ps_proc.c	Sat Oct 05 03:14:53 2013 +0200
     2.2 +++ b/agent/src/os/linux/ps_proc.c	Fri Oct 04 21:00:43 2013 -0700
     2.3 @@ -27,6 +27,8 @@
     2.4  #include <string.h>
     2.5  #include <signal.h>
     2.6  #include <errno.h>
     2.7 +#include <sys/types.h>
     2.8 +#include <sys/wait.h>
     2.9  #include <sys/ptrace.h>
    2.10  #include "libproc_impl.h"
    2.11  

     3.1 --- a/agent/src/os/linux/salibelf.c	Sat Oct 05 03:14:53 2013 +0200
     3.2 +++ b/agent/src/os/linux/salibelf.c	Fri Oct 04 21:00:43 2013 -0700
     3.3 @@ -25,6 +25,7 @@
     3.4  #include "salibelf.h"
     3.5  #include <stdlib.h>
     3.6  #include <unistd.h>
     3.7 +#include <string.h>
     3.8  
     3.9  extern void print_debug(const char*,...);
    3.10  

     4.1 --- a/agent/src/os/linux/symtab.c	Sat Oct 05 03:14:53 2013 +0200
     4.2 +++ b/agent/src/os/linux/symtab.c	Fri Oct 04 21:00:43 2013 -0700
     4.3 @@ -305,7 +305,7 @@
     4.4  
     4.5    unsigned char *bytes
     4.6      = (unsigned char*)(note+1) + note->n_namesz;
     4.7 -  unsigned char *filename
     4.8 +  char *filename
     4.9      = (build_id_to_debug_filename (note->n_descsz, bytes));
    4.10  
    4.11    fd = pathmap_open(filename);

     5.1 --- a/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Sat Oct 05 03:14:53 2013 +0200
     5.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Fri Oct 04 21:00:43 2013 -0700
     5.3 @@ -134,15 +134,13 @@
     5.4       private String type;
     5.5       private String name;
     5.6       private Address addr;
     5.7 -     private String kind;
     5.8 -     private int origin;
     5.9 +     private int flags;
    5.10  
    5.11 -     private Flag(String type, String name, Address addr, String kind, int origin) {
    5.12 +     private Flag(String type, String name, Address addr, int flags) {
    5.13          this.type = type;
    5.14          this.name = name;
    5.15          this.addr = addr;
    5.16 -        this.kind = kind;
    5.17 -        this.origin = origin;
    5.18 +        this.flags = flags;
    5.19       }
    5.20  
    5.21       public String getType() {
    5.22 @@ -157,12 +155,8 @@
    5.23          return addr;
    5.24       }
    5.25  
    5.26 -     public String getKind() {
    5.27 -        return kind;
    5.28 -     }
    5.29 -
    5.30       public int getOrigin() {
    5.31 -        return origin;
    5.32 +        return flags & 0xF;  // XXX can we get the mask bits from somewhere?
    5.33       }
    5.34  
    5.35       public boolean isBool() {
    5.36 @@ -173,8 +167,7 @@
    5.37          if (Assert.ASSERTS_ENABLED) {
    5.38             Assert.that(isBool(), "not a bool flag!");
    5.39          }
    5.40 -        return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned())
    5.41 -               != 0;
    5.42 +        return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) != 0;
    5.43       }
    5.44  
    5.45       public boolean isIntx() {
    5.46 @@ -843,11 +836,10 @@
    5.47  
    5.48      Address flagAddr = flagType.getAddressField("flags").getValue();
    5.49  
    5.50 -    AddressField typeFld = flagType.getAddressField("type");
    5.51 -    AddressField nameFld = flagType.getAddressField("name");
    5.52 -    AddressField addrFld = flagType.getAddressField("addr");
    5.53 -    AddressField kindFld = flagType.getAddressField("kind");
    5.54 -    CIntField originFld = new CIntField(flagType.getCIntegerField("origin"), 0);
    5.55 +    AddressField typeFld = flagType.getAddressField("_type");
    5.56 +    AddressField nameFld = flagType.getAddressField("_name");
    5.57 +    AddressField addrFld = flagType.getAddressField("_addr");
    5.58 +    CIntField flagsFld = new CIntField(flagType.getCIntegerField("_flags"), 0);
    5.59  
    5.60      long flagSize = flagType.getSize(); // sizeof(Flag)
    5.61  
    5.62 @@ -856,9 +848,8 @@
    5.63        String type = CStringUtilities.getString(typeFld.getValue(flagAddr));
    5.64        String name = CStringUtilities.getString(nameFld.getValue(flagAddr));
    5.65        Address addr = addrFld.getValue(flagAddr);
    5.66 -      String kind = CStringUtilities.getString(kindFld.getValue(flagAddr));
    5.67 -      int origin = (int)originFld.getValue(flagAddr);
    5.68 -      commandLineFlags[f] = new Flag(type, name, addr, kind, origin);
    5.69 +      int flags = (int)flagsFld.getValue(flagAddr);
    5.70 +      commandLineFlags[f] = new Flag(type, name, addr, flags);
    5.71        flagAddr = flagAddr.addOffsetTo(flagSize);
    5.72      }
    5.73  

     6.1 --- a/make/bsd/makefiles/gcc.make	Sat Oct 05 03:14:53 2013 +0200
     6.2 +++ b/make/bsd/makefiles/gcc.make	Fri Oct 04 21:00:43 2013 -0700
     6.3 @@ -247,7 +247,7 @@
     6.4  
     6.5  ifeq ($(USE_CLANG), true)
     6.6    # However we need to clean the code up before we can unrestrictedly enable this option with Clang
     6.7 -  WARNINGS_ARE_ERRORS += -Wno-unused-value -Wno-logical-op-parentheses -Wno-parentheses-equality -Wno-parentheses
     6.8 +  WARNINGS_ARE_ERRORS += -Wno-logical-op-parentheses -Wno-parentheses-equality -Wno-parentheses
     6.9    WARNINGS_ARE_ERRORS += -Wno-switch -Wno-tautological-compare
    6.10  # Not yet supported by clang in Xcode 4.6.2
    6.11  #  WARNINGS_ARE_ERRORS += -Wno-tautological-constant-out-of-range-compare
    6.12 @@ -262,7 +262,7 @@
    6.13    # conversions which might affect the values. Only enable it in earlier versions.
    6.14    WARNING_FLAGS = -Wunused-function
    6.15    ifeq ($(USE_CLANG),)
    6.16 -    WARNINGS_FLAGS += -Wconversion
    6.17 +    WARNING_FLAGS += -Wconversion
    6.18    endif
    6.19  endif
    6.20  

     7.1 --- a/make/linux/makefiles/gcc.make	Sat Oct 05 03:14:53 2013 +0200
     7.2 +++ b/make/linux/makefiles/gcc.make	Fri Oct 04 21:00:43 2013 -0700
     7.3 @@ -208,7 +208,7 @@
     7.4  
     7.5  ifeq ($(USE_CLANG), true)
     7.6    # However we need to clean the code up before we can unrestrictedly enable this option with Clang
     7.7 -  WARNINGS_ARE_ERRORS += -Wno-unused-value -Wno-logical-op-parentheses -Wno-parentheses-equality -Wno-parentheses
     7.8 +  WARNINGS_ARE_ERRORS += -Wno-logical-op-parentheses -Wno-parentheses-equality -Wno-parentheses
     7.9    WARNINGS_ARE_ERRORS += -Wno-switch -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare
    7.10    WARNINGS_ARE_ERRORS += -Wno-delete-non-virtual-dtor -Wno-deprecated -Wno-format -Wno-dynamic-class-memaccess
    7.11    WARNINGS_ARE_ERRORS += -Wno-return-type -Wno-empty-body

     8.1 --- a/src/cpu/sparc/vm/methodHandles_sparc.cpp	Sat Oct 05 03:14:53 2013 +0200
     8.2 +++ b/src/cpu/sparc/vm/methodHandles_sparc.cpp	Fri Oct 04 21:00:43 2013 -0700
     8.3 @@ -1,5 +1,5 @@
     8.4  /*
     8.5 - * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
     8.6 + * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
     8.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.8   *
     8.9   * This code is free software; you can redistribute it and/or modify it
    8.10 @@ -121,6 +121,7 @@
    8.11  
    8.12  void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register method, Register target, Register temp,
    8.13                                              bool for_compiler_entry) {
    8.14 +  Label L_no_such_method;
    8.15    assert(method == G5_method, "interpreter calling convention");
    8.16    assert_different_registers(method, target, temp);
    8.17  
    8.18 @@ -133,6 +134,9 @@
    8.19      const Address interp_only(G2_thread, JavaThread::interp_only_mode_offset());
    8.20      __ ld(interp_only, temp);
    8.21      __ cmp_and_br_short(temp, 0, Assembler::zero, Assembler::pt, run_compiled_code);
    8.22 +    // Null method test is replicated below in compiled case,
    8.23 +    // it might be able to address across the verify_thread()
    8.24 +    __ br_null_short(G5_method, Assembler::pn, L_no_such_method);
    8.25      __ ld_ptr(G5_method, in_bytes(Method::interpreter_entry_offset()), target);
    8.26      __ jmp(target, 0);
    8.27      __ delayed()->nop();
    8.28 @@ -141,11 +145,19 @@
    8.29      // it doesn't matter, since this is interpreter code.
    8.30    }
    8.31  
    8.32 +  // Compiled case, either static or fall-through from runtime conditional
    8.33 +  __ br_null_short(G5_method, Assembler::pn, L_no_such_method);
    8.34 +
    8.35    const ByteSize entry_offset = for_compiler_entry ? Method::from_compiled_offset() :
    8.36                                                       Method::from_interpreted_offset();
    8.37    __ ld_ptr(G5_method, in_bytes(entry_offset), target);
    8.38    __ jmp(target, 0);
    8.39    __ delayed()->nop();
    8.40 +
    8.41 +  __ bind(L_no_such_method);
    8.42 +  AddressLiteral ame(StubRoutines::throw_AbstractMethodError_entry());
    8.43 +  __ jump_to(ame, temp);
    8.44 +  __ delayed()->nop();
    8.45  }
    8.46  
    8.47  void MethodHandles::jump_to_lambda_form(MacroAssembler* _masm,

     9.1 --- a/src/cpu/sparc/vm/sparc.ad	Sat Oct 05 03:14:53 2013 +0200
     9.2 +++ b/src/cpu/sparc/vm/sparc.ad	Fri Oct 04 21:00:43 2013 -0700
     9.3 @@ -2018,6 +2018,15 @@
     9.4    return L7_REGP_mask();
     9.5  }
     9.6  
     9.7 +const RegMask Matcher::mathExactI_result_proj_mask() {
     9.8 +  return G1_REGI_mask();
     9.9 +}
    9.10 +
    9.11 +const RegMask Matcher::mathExactI_flags_proj_mask() {
    9.12 +  return INT_FLAGS_mask();
    9.13 +}
    9.14 +
    9.15 +
    9.16  %}
    9.17  
    9.18  
    9.19 @@ -4245,12 +4254,16 @@
    9.20      greater_equal(0xB);
    9.21      less_equal(0x2);
    9.22      greater(0xA);
    9.23 +    overflow(0x7);
    9.24 +    no_overflow(0xF);
    9.25    %}
    9.26  %}
    9.27  
    9.28  // Comparison Op, unsigned
    9.29  operand cmpOpU() %{
    9.30    match(Bool);
    9.31 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
    9.32 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
    9.33  
    9.34    format %{ "u" %}
    9.35    interface(COND_INTER) %{
    9.36 @@ -4260,12 +4273,16 @@
    9.37      greater_equal(0xD);
    9.38      less_equal(0x4);
    9.39      greater(0xC);
    9.40 +    overflow(0x7);
    9.41 +    no_overflow(0xF);
    9.42    %}
    9.43  %}
    9.44  
    9.45  // Comparison Op, pointer (same as unsigned)
    9.46  operand cmpOpP() %{
    9.47    match(Bool);
    9.48 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
    9.49 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
    9.50  
    9.51    format %{ "p" %}
    9.52    interface(COND_INTER) %{
    9.53 @@ -4275,12 +4292,16 @@
    9.54      greater_equal(0xD);
    9.55      less_equal(0x4);
    9.56      greater(0xC);
    9.57 +    overflow(0x7);
    9.58 +    no_overflow(0xF);
    9.59    %}
    9.60  %}
    9.61  
    9.62  // Comparison Op, branch-register encoding
    9.63  operand cmpOp_reg() %{
    9.64    match(Bool);
    9.65 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
    9.66 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
    9.67  
    9.68    format %{ "" %}
    9.69    interface(COND_INTER) %{
    9.70 @@ -4290,12 +4311,16 @@
    9.71      greater_equal(0x7);
    9.72      less_equal   (0x2);
    9.73      greater      (0x6);
    9.74 +    overflow(0x7); // not supported
    9.75 +    no_overflow(0xF); // not supported
    9.76    %}
    9.77  %}
    9.78  
    9.79  // Comparison Code, floating, unordered same as less
    9.80  operand cmpOpF() %{
    9.81    match(Bool);
    9.82 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
    9.83 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
    9.84  
    9.85    format %{ "fl" %}
    9.86    interface(COND_INTER) %{
    9.87 @@ -4305,12 +4330,17 @@
    9.88      greater_equal(0xB);
    9.89      less_equal(0xE);
    9.90      greater(0x6);
    9.91 +
    9.92 +    overflow(0x7); // not supported
    9.93 +    no_overflow(0xF); // not supported
    9.94    %}
    9.95  %}
    9.96  
    9.97  // Used by long compare
    9.98  operand cmpOp_commute() %{
    9.99    match(Bool);
   9.100 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
   9.101 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
   9.102  
   9.103    format %{ "" %}
   9.104    interface(COND_INTER) %{
   9.105 @@ -4320,6 +4350,8 @@
   9.106      greater_equal(0x2);
   9.107      less_equal(0xB);
   9.108      greater(0x3);
   9.109 +    overflow(0x7);
   9.110 +    no_overflow(0xF);
   9.111    %}
   9.112  %}
   9.113  

    10.1 --- a/src/cpu/x86/vm/assembler_x86.cpp	Sat Oct 05 03:14:53 2013 +0200
    10.2 +++ b/src/cpu/x86/vm/assembler_x86.cpp	Fri Oct 04 21:00:43 2013 -0700
    10.3 @@ -4769,7 +4769,7 @@
    10.4  }
    10.5  
    10.6  void Assembler::adcq(Register dst, Register src) {
    10.7 -  (int) prefixq_and_encode(dst->encoding(), src->encoding());
    10.8 +  (void) prefixq_and_encode(dst->encoding(), src->encoding());
    10.9    emit_arith(0x13, 0xC0, dst, src);
   10.10  }
   10.11  
   10.12 @@ -4824,7 +4824,7 @@
   10.13  }
   10.14  
   10.15  void Assembler::andq(Register dst, Register src) {
   10.16 -  (int) prefixq_and_encode(dst->encoding(), src->encoding());
   10.17 +  (void) prefixq_and_encode(dst->encoding(), src->encoding());
   10.18    emit_arith(0x23, 0xC0, dst, src);
   10.19  }
   10.20  

    11.1 --- a/src/cpu/x86/vm/methodHandles_x86.cpp	Sat Oct 05 03:14:53 2013 +0200
    11.2 +++ b/src/cpu/x86/vm/methodHandles_x86.cpp	Fri Oct 04 21:00:43 2013 -0700
    11.3 @@ -114,6 +114,11 @@
    11.4  void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register method, Register temp,
    11.5                                              bool for_compiler_entry) {
    11.6    assert(method == rbx, "interpreter calling convention");
    11.7 +
    11.8 +   Label L_no_such_method;
    11.9 +   __ testptr(rbx, rbx);
   11.10 +   __ jcc(Assembler::zero, L_no_such_method);
   11.11 +
   11.12    __ verify_method_ptr(method);
   11.13  
   11.14    if (!for_compiler_entry && JvmtiExport::can_post_interpreter_events()) {
   11.15 @@ -138,6 +143,9 @@
   11.16    const ByteSize entry_offset = for_compiler_entry ? Method::from_compiled_offset() :
   11.17                                                       Method::from_interpreted_offset();
   11.18    __ jmp(Address(method, entry_offset));
   11.19 +
   11.20 +  __ bind(L_no_such_method);
   11.21 +  __ jump(RuntimeAddress(StubRoutines::throw_AbstractMethodError_entry()));
   11.22  }
   11.23  
   11.24  void MethodHandles::jump_to_lambda_form(MacroAssembler* _masm,

    12.1 --- a/src/cpu/x86/vm/x86_32.ad	Sat Oct 05 03:14:53 2013 +0200
    12.2 +++ b/src/cpu/x86/vm/x86_32.ad	Fri Oct 04 21:00:43 2013 -0700
    12.3 @@ -1534,6 +1534,14 @@
    12.4    return EBP_REG_mask();
    12.5  }
    12.6  
    12.7 +const RegMask Matcher::mathExactI_result_proj_mask() {
    12.8 +  return EAX_REG_mask();
    12.9 +}
   12.10 +
   12.11 +const RegMask Matcher::mathExactI_flags_proj_mask() {
   12.12 +  return INT_FLAGS_mask();
   12.13 +}
   12.14 +
   12.15  // Returns true if the high 32 bits of the value is known to be zero.
   12.16  bool is_operand_hi32_zero(Node* n) {
   12.17    int opc = n->Opcode();
   12.18 @@ -4922,6 +4930,8 @@
   12.19      greater_equal(0xD, "ge");
   12.20      less_equal(0xE, "le");
   12.21      greater(0xF, "g");
   12.22 +    overflow(0x0, "o");
   12.23 +    no_overflow(0x1, "no");
   12.24    %}
   12.25  %}
   12.26  
   12.27 @@ -4939,6 +4949,8 @@
   12.28      greater_equal(0x3, "nb");
   12.29      less_equal(0x6, "be");
   12.30      greater(0x7, "nbe");
   12.31 +    overflow(0x0, "o");
   12.32 +    no_overflow(0x1, "no");
   12.33    %}
   12.34  %}
   12.35  
   12.36 @@ -4957,6 +4969,8 @@
   12.37      greater_equal(0x3, "nb");
   12.38      less_equal(0x6, "be");
   12.39      greater(0x7, "nbe");
   12.40 +    overflow(0x0, "o");
   12.41 +    no_overflow(0x1, "no");
   12.42    %}
   12.43  %}
   12.44  
   12.45 @@ -4974,6 +4988,8 @@
   12.46      greater_equal(0x3, "nb");
   12.47      less_equal(0x6, "be");
   12.48      greater(0x7, "nbe");
   12.49 +    overflow(0x0, "o");
   12.50 +    no_overflow(0x1, "no");
   12.51    %}
   12.52  %}
   12.53  
   12.54 @@ -4981,6 +4997,8 @@
   12.55  operand cmpOp_fcmov() %{
   12.56    match(Bool);
   12.57  
   12.58 +  predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
   12.59 +            n->as_Bool()->_test._test != BoolTest::no_overflow);
   12.60    format %{ "" %}
   12.61    interface(COND_INTER) %{
   12.62      equal        (0x0C8);
   12.63 @@ -4989,6 +5007,8 @@
   12.64      greater_equal(0x1C0);
   12.65      less_equal   (0x0D0);
   12.66      greater      (0x1D0);
   12.67 +    overflow(0x0, "o"); // not really supported by the instruction
   12.68 +    no_overflow(0x1, "no"); // not really supported by the instruction
   12.69    %}
   12.70  %}
   12.71  
   12.72 @@ -5004,6 +5024,8 @@
   12.73      greater_equal(0xE, "le");
   12.74      less_equal(0xD, "ge");
   12.75      greater(0xC, "l");
   12.76 +    overflow(0x0, "o");
   12.77 +    no_overflow(0x1, "no");
   12.78    %}
   12.79  %}
   12.80  
   12.81 @@ -7496,6 +7518,31 @@
   12.82  
   12.83  //----------Arithmetic Instructions--------------------------------------------
   12.84  //----------Addition Instructions----------------------------------------------
   12.85 +
   12.86 +instruct addExactI_rReg(eAXRegI dst, rRegI src, eFlagsReg cr)
   12.87 +%{
   12.88 +  match(AddExactI dst src);
   12.89 +  effect(DEF cr);
   12.90 +
   12.91 +  format %{ "ADD    $dst, $src\t# addExact int" %}
   12.92 +  ins_encode %{
   12.93 +    __ addl($dst$$Register, $src$$Register);
   12.94 +  %}
   12.95 +  ins_pipe(ialu_reg_reg);
   12.96 +%}
   12.97 +
   12.98 +instruct addExactI_rReg_imm(eAXRegI dst, immI src, eFlagsReg cr)
   12.99 +%{
  12.100 +  match(AddExactI dst src);
  12.101 +  effect(DEF cr);
  12.102 +
  12.103 +  format %{ "ADD    $dst, $src\t# addExact int" %}
  12.104 +  ins_encode %{
  12.105 +    __ addl($dst$$Register, $src$$constant);
  12.106 +  %}
  12.107 +  ins_pipe(ialu_reg_reg);
  12.108 +%}
  12.109 +
  12.110  // Integer Addition Instructions
  12.111  instruct addI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{
  12.112    match(Set dst (AddI dst src));

    13.1 --- a/src/cpu/x86/vm/x86_64.ad	Sat Oct 05 03:14:53 2013 +0200
    13.2 +++ b/src/cpu/x86/vm/x86_64.ad	Fri Oct 04 21:00:43 2013 -0700
    13.3 @@ -1649,6 +1649,14 @@
    13.4    return PTR_RBP_REG_mask();
    13.5  }
    13.6  
    13.7 +const RegMask Matcher::mathExactI_result_proj_mask() {
    13.8 +  return INT_RAX_REG_mask();
    13.9 +}
   13.10 +
   13.11 +const RegMask Matcher::mathExactI_flags_proj_mask() {
   13.12 +  return INT_FLAGS_mask();
   13.13 +}
   13.14 +
   13.15  %}
   13.16  
   13.17  //----------ENCODING BLOCK-----------------------------------------------------
   13.18 @@ -4133,6 +4141,8 @@
   13.19      greater_equal(0xD, "ge");
   13.20      less_equal(0xE, "le");
   13.21      greater(0xF, "g");
   13.22 +    overflow(0x0, "o");
   13.23 +    no_overflow(0x1, "no");
   13.24    %}
   13.25  %}
   13.26  
   13.27 @@ -4151,6 +4161,8 @@
   13.28      greater_equal(0x3, "nb");
   13.29      less_equal(0x6, "be");
   13.30      greater(0x7, "nbe");
   13.31 +    overflow(0x0, "o");
   13.32 +    no_overflow(0x1, "no");
   13.33    %}
   13.34  %}
   13.35  
   13.36 @@ -4170,6 +4182,8 @@
   13.37      greater_equal(0x3, "nb");
   13.38      less_equal(0x6, "be");
   13.39      greater(0x7, "nbe");
   13.40 +    overflow(0x0, "o");
   13.41 +    no_overflow(0x1, "no");
   13.42    %}
   13.43  %}
   13.44  
   13.45 @@ -4187,6 +4201,8 @@
   13.46      greater_equal(0x3, "nb");
   13.47      less_equal(0x6, "be");
   13.48      greater(0x7, "nbe");
   13.49 +    overflow(0x0, "o");
   13.50 +    no_overflow(0x1, "no");
   13.51    %}
   13.52  %}
   13.53  
   13.54 @@ -6922,6 +6938,30 @@
   13.55  //----------Arithmetic Instructions--------------------------------------------
   13.56  //----------Addition Instructions----------------------------------------------
   13.57  
   13.58 +instruct addExactI_rReg(rax_RegI dst, rRegI src, rFlagsReg cr)
   13.59 +%{
   13.60 +  match(AddExactI dst src);
   13.61 +  effect(DEF cr);
   13.62 +
   13.63 +  format %{ "addl    $dst, $src\t# addExact int" %}
   13.64 +  ins_encode %{
   13.65 +    __ addl($dst$$Register, $src$$Register);
   13.66 +  %}
   13.67 +  ins_pipe(ialu_reg_reg);
   13.68 +%}
   13.69 +
   13.70 +instruct addExactI_rReg_imm(rax_RegI dst, immI src, rFlagsReg cr)
   13.71 +%{
   13.72 +  match(AddExactI dst src);
   13.73 +  effect(DEF cr);
   13.74 +
   13.75 +  format %{ "addl    $dst, $src\t# addExact int" %}
   13.76 +  ins_encode %{
   13.77 +    __ addl($dst$$Register, $src$$constant);
   13.78 +  %}
   13.79 +  ins_pipe(ialu_reg_reg);
   13.80 +%}
   13.81 +
   13.82  instruct addI_rReg(rRegI dst, rRegI src, rFlagsReg cr)
   13.83  %{
   13.84    match(Set dst (AddI dst src));

    14.1 --- a/src/share/vm/adlc/adlparse.cpp	Sat Oct 05 03:14:53 2013 +0200
    14.2 +++ b/src/share/vm/adlc/adlparse.cpp	Fri Oct 04 21:00:43 2013 -0700
    14.3 @@ -3395,12 +3395,16 @@
    14.4    char *greater_equal;
    14.5    char *less_equal;
    14.6    char *greater;
    14.7 +  char *overflow;
    14.8 +  char *no_overflow;
    14.9    const char *equal_format = "eq";
   14.10    const char *not_equal_format = "ne";
   14.11    const char *less_format = "lt";
   14.12    const char *greater_equal_format = "ge";
   14.13    const char *less_equal_format = "le";
   14.14    const char *greater_format = "gt";
   14.15 +  const char *overflow_format = "o";
   14.16 +  const char *no_overflow_format = "no";
   14.17  
   14.18    if (_curchar != '%') {
   14.19      parse_err(SYNERR, "Missing '%%{' for 'cond_interface' block.\n");
   14.20 @@ -3437,6 +3441,12 @@
   14.21      else if ( strcmp(field,"greater") == 0 ) {
   14.22        greater = interface_field_parse(&greater_format);
   14.23      }
   14.24 +    else if ( strcmp(field,"overflow") == 0 ) {
   14.25 +      overflow = interface_field_parse(&overflow_format);
   14.26 +    }
   14.27 +    else if ( strcmp(field,"no_overflow") == 0 ) {
   14.28 +      no_overflow = interface_field_parse(&no_overflow_format);
   14.29 +    }
   14.30      else {
   14.31        parse_err(SYNERR, "Expected keyword, base|index|scale|disp,  or '%%}' ending interface.\n");
   14.32        return NULL;
   14.33 @@ -3455,7 +3465,9 @@
   14.34                                         less,          less_format,
   14.35                                         greater_equal, greater_equal_format,
   14.36                                         less_equal,    less_equal_format,
   14.37 -                                       greater,       greater_format);
   14.38 +                                       greater,       greater_format,
   14.39 +                                       overflow,      overflow_format,
   14.40 +                                       no_overflow,   no_overflow_format);
   14.41    return inter;
   14.42  }
   14.43  

    15.1 --- a/src/share/vm/adlc/archDesc.cpp	Sat Oct 05 03:14:53 2013 +0200
    15.2 +++ b/src/share/vm/adlc/archDesc.cpp	Fri Oct 04 21:00:43 2013 -0700
    15.3 @@ -1192,6 +1192,8 @@
    15.4           || strcmp(idealName,"CmpF") == 0
    15.5           || strcmp(idealName,"FastLock") == 0
    15.6           || strcmp(idealName,"FastUnlock") == 0
    15.7 +         || strcmp(idealName,"AddExactI") == 0
    15.8 +         || strcmp(idealName,"FlagsProj") == 0
    15.9           || strcmp(idealName,"Bool") == 0
   15.10           || strcmp(idealName,"Binary") == 0 ) {
   15.11        // Removed ConI from the must_clone list.  CPUs that cannot use

    16.1 --- a/src/share/vm/adlc/formssel.cpp	Sat Oct 05 03:14:53 2013 +0200
    16.2 +++ b/src/share/vm/adlc/formssel.cpp	Fri Oct 04 21:00:43 2013 -0700
    16.3 @@ -2757,14 +2757,18 @@
    16.4                               const char* less,          const char* less_format,
    16.5                               const char* greater_equal, const char* greater_equal_format,
    16.6                               const char* less_equal,    const char* less_equal_format,
    16.7 -                             const char* greater,       const char* greater_format)
    16.8 +                             const char* greater,       const char* greater_format,
    16.9 +                             const char* overflow,      const char* overflow_format,
   16.10 +                             const char* no_overflow,   const char* no_overflow_format)
   16.11    : Interface("COND_INTER"),
   16.12      _equal(equal),                 _equal_format(equal_format),
   16.13      _not_equal(not_equal),         _not_equal_format(not_equal_format),
   16.14      _less(less),                   _less_format(less_format),
   16.15      _greater_equal(greater_equal), _greater_equal_format(greater_equal_format),
   16.16      _less_equal(less_equal),       _less_equal_format(less_equal_format),
   16.17 -    _greater(greater),             _greater_format(greater_format) {
   16.18 +    _greater(greater),             _greater_format(greater_format),
   16.19 +    _overflow(overflow),           _overflow_format(overflow_format),
   16.20 +    _no_overflow(no_overflow),     _no_overflow_format(no_overflow_format) {
   16.21  }
   16.22  CondInterface::~CondInterface() {
   16.23    // not owner of any character arrays
   16.24 @@ -2777,12 +2781,14 @@
   16.25  // Write info to output files
   16.26  void CondInterface::output(FILE *fp) {
   16.27    Interface::output(fp);
   16.28 -  if ( _equal  != NULL )     fprintf(fp," equal       == %s\n", _equal);
   16.29 -  if ( _not_equal  != NULL ) fprintf(fp," not_equal   == %s\n", _not_equal);
   16.30 -  if ( _less  != NULL )      fprintf(fp," less        == %s\n", _less);
   16.31 -  if ( _greater_equal  != NULL ) fprintf(fp," greater_equal   == %s\n", _greater_equal);
   16.32 -  if ( _less_equal  != NULL ) fprintf(fp," less_equal  == %s\n", _less_equal);
   16.33 -  if ( _greater  != NULL )    fprintf(fp," greater     == %s\n", _greater);
   16.34 +  if ( _equal  != NULL )     fprintf(fp," equal        == %s\n", _equal);
   16.35 +  if ( _not_equal  != NULL ) fprintf(fp," not_equal    == %s\n", _not_equal);
   16.36 +  if ( _less  != NULL )      fprintf(fp," less         == %s\n", _less);
   16.37 +  if ( _greater_equal  != NULL ) fprintf(fp," greater_equal    == %s\n", _greater_equal);
   16.38 +  if ( _less_equal  != NULL ) fprintf(fp," less_equal   == %s\n", _less_equal);
   16.39 +  if ( _greater  != NULL )    fprintf(fp," greater      == %s\n", _greater);
   16.40 +  if ( _overflow != NULL )    fprintf(fp," overflow     == %s\n", _overflow);
   16.41 +  if ( _no_overflow != NULL ) fprintf(fp," no_overflow  == %s\n", _no_overflow);
   16.42    // fprintf(fp,"\n");
   16.43  }
   16.44  

    17.1 --- a/src/share/vm/adlc/formssel.hpp	Sat Oct 05 03:14:53 2013 +0200
    17.2 +++ b/src/share/vm/adlc/formssel.hpp	Fri Oct 04 21:00:43 2013 -0700
    17.3 @@ -798,12 +798,16 @@
    17.4    const char *_greater_equal;
    17.5    const char *_less_equal;
    17.6    const char *_greater;
    17.7 +  const char *_overflow;
    17.8 +  const char *_no_overflow;
    17.9    const char *_equal_format;
   17.10    const char *_not_equal_format;
   17.11    const char *_less_format;
   17.12    const char *_greater_equal_format;
   17.13    const char *_less_equal_format;
   17.14    const char *_greater_format;
   17.15 +  const char *_overflow_format;
   17.16 +  const char *_no_overflow_format;
   17.17  
   17.18    // Public Methods
   17.19    CondInterface(const char* equal,         const char* equal_format,
   17.20 @@ -811,7 +815,9 @@
   17.21                  const char* less,          const char* less_format,
   17.22                  const char* greater_equal, const char* greater_equal_format,
   17.23                  const char* less_equal,    const char* less_equal_format,
   17.24 -                const char* greater,       const char* greater_format);
   17.25 +                const char* greater,       const char* greater_format,
   17.26 +                const char* overflow,      const char* overflow_format,
   17.27 +                const char* no_overflow,   const char* no_overflow_format);
   17.28    ~CondInterface();
   17.29  
   17.30    void dump();

    18.1 --- a/src/share/vm/adlc/output_h.cpp	Sat Oct 05 03:14:53 2013 +0200
    18.2 +++ b/src/share/vm/adlc/output_h.cpp	Fri Oct 04 21:00:43 2013 -0700
    18.3 @@ -388,6 +388,8 @@
    18.4    fprintf(fp, "  else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format);
    18.5    fprintf(fp, "  else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format);
    18.6    fprintf(fp, "  else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format);
    18.7 +  fprintf(fp, "  else if( _c%d == BoolTest::overflow ) st->print(\"%s\");\n",i,cond->_overflow_format);
    18.8 +  fprintf(fp, "  else if( _c%d == BoolTest::no_overflow ) st->print(\"%s\");\n",i,cond->_no_overflow_format);
    18.9  }
   18.10  
   18.11  // Output code that dumps constant values, increment "i" if type is constant
   18.12 @@ -1208,6 +1210,8 @@
   18.13        fprintf(fp,"    case  BoolTest::ne : return not_equal();\n");
   18.14        fprintf(fp,"    case  BoolTest::le : return less_equal();\n");
   18.15        fprintf(fp,"    case  BoolTest::ge : return greater_equal();\n");
   18.16 +      fprintf(fp,"    case  BoolTest::overflow : return overflow();\n");
   18.17 +      fprintf(fp,"    case  BoolTest::no_overflow: return no_overflow();\n");
   18.18        fprintf(fp,"    default : ShouldNotReachHere(); return 0;\n");
   18.19        fprintf(fp,"    }\n");
   18.20        fprintf(fp,"  };\n");
   18.21 @@ -1373,6 +1377,14 @@
   18.22          if( greater != NULL ) {
   18.23            define_oper_interface(fp, *oper, _globalNames, "greater", greater);
   18.24          }
   18.25 +        const char *overflow = cInterface->_overflow;
   18.26 +        if( overflow != NULL ) {
   18.27 +          define_oper_interface(fp, *oper, _globalNames, "overflow", overflow);
   18.28 +        }
   18.29 +        const char *no_overflow = cInterface->_no_overflow;
   18.30 +        if( no_overflow != NULL ) {
   18.31 +          define_oper_interface(fp, *oper, _globalNames, "no_overflow", no_overflow);
   18.32 +        }
   18.33        } // end Conditional Interface
   18.34        // Check if it is a Constant Interface
   18.35        else if (oper->_interface->is_ConstInterface() != NULL ) {

    19.1 --- a/src/share/vm/c1/c1_Runtime1.cpp	Sat Oct 05 03:14:53 2013 +0200
    19.2 +++ b/src/share/vm/c1/c1_Runtime1.cpp	Fri Oct 04 21:00:43 2013 -0700
    19.3 @@ -1078,14 +1078,17 @@
    19.4            // replace instructions
    19.5            // first replace the tail, then the call
    19.6  #ifdef ARM
    19.7 -          if(load_klass_or_mirror_patch_id && !VM_Version::supports_movw()) {
    19.8 +          if((load_klass_or_mirror_patch_id ||
    19.9 +              stub_id == Runtime1::load_appendix_patching_id) &&
   19.10 +             !VM_Version::supports_movw()) {
   19.11              nmethod* nm = CodeCache::find_nmethod(instr_pc);
   19.12              address addr = NULL;
   19.13              assert(nm != NULL, "invalid nmethod_pc");
   19.14              RelocIterator mds(nm, copy_buff, copy_buff + 1);
   19.15              while (mds.next()) {
   19.16                if (mds.type() == relocInfo::oop_type) {
   19.17 -                assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
   19.18 +                assert(stub_id == Runtime1::load_mirror_patching_id ||
   19.19 +                       stub_id == Runtime1::load_appendix_patching_id, "wrong stub id");
   19.20                  oop_Relocation* r = mds.oop_reloc();
   19.21                  addr = (address)r->oop_addr();
   19.22                  break;

    20.1 --- a/src/share/vm/classfile/classFileParser.cpp	Sat Oct 05 03:14:53 2013 +0200
    20.2 +++ b/src/share/vm/classfile/classFileParser.cpp	Fri Oct 04 21:00:43 2013 -0700
    20.3 @@ -1787,7 +1787,7 @@
    20.4      if (_location != _in_method)  break;  // only allow for methods
    20.5      if (!privileged)              break;  // only allow in privileged code
    20.6      return _method_LambdaForm_Hidden;
    20.7 -  case vmSymbols::VM_SYMBOL_ENUM_NAME(sun_invoke_Stable_signature):
    20.8 +  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_Stable_signature):
    20.9      if (_location != _in_field)   break;  // only allow for fields
   20.10      if (!privileged)              break;  // only allow in privileged code
   20.11      return _field_Stable;

    21.1 --- a/src/share/vm/classfile/defaultMethods.cpp	Sat Oct 05 03:14:53 2013 +0200
    21.2 +++ b/src/share/vm/classfile/defaultMethods.cpp	Fri Oct 04 21:00:43 2013 -0700
    21.3 @@ -793,7 +793,7 @@
    21.4  
    21.5  
    21.6  
    21.7 -#ifndef PRODUCT
    21.8 +#ifdef ASSERT
    21.9  // Return true is broad type is a covariant return of narrow type
   21.10  static bool covariant_return_type(BasicType narrow, BasicType broad) {
   21.11    if (narrow == broad) {
   21.12 @@ -804,7 +804,7 @@
   21.13    }
   21.14    return false;
   21.15  }
   21.16 -#endif // ndef PRODUCT
   21.17 +#endif
   21.18  
   21.19  static int assemble_redirect(
   21.20      BytecodeConstantPool* cp, BytecodeBuffer* buffer,
   21.21 @@ -1095,4 +1095,3 @@
   21.22      MetadataFactory::free_array(cld, original_ordering);
   21.23    }
   21.24  }
   21.25 -

    22.1 --- a/src/share/vm/classfile/vmSymbols.hpp	Sat Oct 05 03:14:53 2013 +0200
    22.2 +++ b/src/share/vm/classfile/vmSymbols.hpp	Fri Oct 04 21:00:43 2013 -0700
    22.3 @@ -270,7 +270,7 @@
    22.4    template(java_lang_invoke_LambdaForm,               "java/lang/invoke/LambdaForm")              \
    22.5    template(java_lang_invoke_ForceInline_signature,    "Ljava/lang/invoke/ForceInline;")           \
    22.6    template(java_lang_invoke_DontInline_signature,     "Ljava/lang/invoke/DontInline;")            \
    22.7 -  template(sun_invoke_Stable_signature,               "Lsun/invoke/Stable;")                      \
    22.8 +  template(java_lang_invoke_Stable_signature,         "Ljava/lang/invoke/Stable;")                \
    22.9    template(java_lang_invoke_LambdaForm_Compiled_signature, "Ljava/lang/invoke/LambdaForm$Compiled;") \
   22.10    template(java_lang_invoke_LambdaForm_Hidden_signature, "Ljava/lang/invoke/LambdaForm$Hidden;")  \
   22.11    template(java_lang_invoke_MagicLambdaImpl,          "java/lang/invoke/MagicLambdaImpl")         \
   22.12 @@ -631,6 +631,10 @@
   22.13    do_name(log_name,"log")       do_name(log10_name,"log10")     do_name(pow_name,"pow")                                 \
   22.14    do_name(exp_name,"exp")       do_name(min_name,"min")         do_name(max_name,"max")                                 \
   22.15                                                                                                                          \
   22.16 +  do_name(addExact_name,"addExact")                                                                                     \
   22.17 +  do_name(subtractExact_name,"subtractExact")                                                                           \
   22.18 +  do_name(multiplyExact_name,"multiplyExact")                                                                           \
   22.19 +                                                                                                                        \
   22.20    do_intrinsic(_dabs,                     java_lang_Math,         abs_name,   double_double_signature,           F_S)   \
   22.21    do_intrinsic(_dsin,                     java_lang_Math,         sin_name,   double_double_signature,           F_S)   \
   22.22    do_intrinsic(_dcos,                     java_lang_Math,         cos_name,   double_double_signature,           F_S)   \
   22.23 @@ -643,6 +647,7 @@
   22.24    do_intrinsic(_dexp,                     java_lang_Math,         exp_name,   double_double_signature,           F_S)   \
   22.25    do_intrinsic(_min,                      java_lang_Math,         min_name,   int2_int_signature,                F_S)   \
   22.26    do_intrinsic(_max,                      java_lang_Math,         max_name,   int2_int_signature,                F_S)   \
   22.27 +  do_intrinsic(_addExact,                 java_lang_Math,         addExact_name, int2_int_signature,             F_S)   \
   22.28                                                                                                                          \
   22.29    do_intrinsic(_floatToRawIntBits,        java_lang_Float,        floatToRawIntBits_name,   float_int_signature, F_S)   \
   22.30     do_name(     floatToRawIntBits_name,                          "floatToRawIntBits")                                   \

    23.1 --- a/src/share/vm/code/codeCache.cpp	Sat Oct 05 03:14:53 2013 +0200
    23.2 +++ b/src/share/vm/code/codeCache.cpp	Fri Oct 04 21:00:43 2013 -0700
    23.3 @@ -124,7 +124,6 @@
    23.4  int CodeCache::_number_of_nmethods_with_dependencies = 0;
    23.5  bool CodeCache::_needs_cache_clean = false;
    23.6  nmethod* CodeCache::_scavenge_root_nmethods = NULL;
    23.7 -nmethod* CodeCache::_saved_nmethods = NULL;
    23.8  
    23.9  int CodeCache::_codemem_full_count = 0;
   23.10  
   23.11 @@ -464,96 +463,11 @@
   23.12  }
   23.13  #endif //PRODUCT
   23.14  
   23.15 -/**
   23.16 - * Remove and return nmethod from the saved code list in order to reanimate it.
   23.17 - */
   23.18 -nmethod* CodeCache::reanimate_saved_code(Method* m) {
   23.19 -  MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
   23.20 -  nmethod* saved = _saved_nmethods;
   23.21 -  nmethod* prev = NULL;
   23.22 -  while (saved != NULL) {
   23.23 -    if (saved->is_in_use() && saved->method() == m) {
   23.24 -      if (prev != NULL) {
   23.25 -        prev->set_saved_nmethod_link(saved->saved_nmethod_link());
   23.26 -      } else {
   23.27 -        _saved_nmethods = saved->saved_nmethod_link();
   23.28 -      }
   23.29 -      assert(saved->is_speculatively_disconnected(), "shouldn't call for other nmethods");
   23.30 -      saved->set_speculatively_disconnected(false);
   23.31 -      saved->set_saved_nmethod_link(NULL);
   23.32 -      if (PrintMethodFlushing) {
   23.33 -        saved->print_on(tty, " ### nmethod is reconnected");
   23.34 -      }
   23.35 -      if (LogCompilation && (xtty != NULL)) {
   23.36 -        ttyLocker ttyl;
   23.37 -        xtty->begin_elem("nmethod_reconnected compile_id='%3d'", saved->compile_id());
   23.38 -        xtty->method(m);
   23.39 -        xtty->stamp();
   23.40 -        xtty->end_elem();
   23.41 -      }
   23.42 -      return saved;
   23.43 -    }
   23.44 -    prev = saved;
   23.45 -    saved = saved->saved_nmethod_link();
   23.46 -  }
   23.47 -  return NULL;
   23.48 -}
   23.49 -
   23.50 -/**
   23.51 - * Remove nmethod from the saved code list in order to discard it permanently
   23.52 - */
   23.53 -void CodeCache::remove_saved_code(nmethod* nm) {
   23.54 -  // For conc swpr this will be called with CodeCache_lock taken by caller
   23.55 -  assert_locked_or_safepoint(CodeCache_lock);
   23.56 -  assert(nm->is_speculatively_disconnected(), "shouldn't call for other nmethods");
   23.57 -  nmethod* saved = _saved_nmethods;
   23.58 -  nmethod* prev = NULL;
   23.59 -  while (saved != NULL) {
   23.60 -    if (saved == nm) {
   23.61 -      if (prev != NULL) {
   23.62 -        prev->set_saved_nmethod_link(saved->saved_nmethod_link());
   23.63 -      } else {
   23.64 -        _saved_nmethods = saved->saved_nmethod_link();
   23.65 -      }
   23.66 -      if (LogCompilation && (xtty != NULL)) {
   23.67 -        ttyLocker ttyl;
   23.68 -        xtty->begin_elem("nmethod_removed compile_id='%3d'", nm->compile_id());
   23.69 -        xtty->stamp();
   23.70 -        xtty->end_elem();
   23.71 -      }
   23.72 -      return;
   23.73 -    }
   23.74 -    prev = saved;
   23.75 -    saved = saved->saved_nmethod_link();
   23.76 -  }
   23.77 -  ShouldNotReachHere();
   23.78 -}
   23.79 -
   23.80 -void CodeCache::speculatively_disconnect(nmethod* nm) {
   23.81 -  assert_locked_or_safepoint(CodeCache_lock);
   23.82 -  assert(nm->is_in_use() && !nm->is_speculatively_disconnected(), "should only disconnect live nmethods");
   23.83 -  nm->set_saved_nmethod_link(_saved_nmethods);
   23.84 -  _saved_nmethods = nm;
   23.85 -  if (PrintMethodFlushing) {
   23.86 -    nm->print_on(tty, " ### nmethod is speculatively disconnected");
   23.87 -  }
   23.88 -  if (LogCompilation && (xtty != NULL)) {
   23.89 -    ttyLocker ttyl;
   23.90 -    xtty->begin_elem("nmethod_disconnected compile_id='%3d'", nm->compile_id());
   23.91 -    xtty->method(nm->method());
   23.92 -    xtty->stamp();
   23.93 -    xtty->end_elem();
   23.94 -  }
   23.95 -  nm->method()->clear_code();
   23.96 -  nm->set_speculatively_disconnected(true);
   23.97 -}
   23.98 -
   23.99  
  23.100  void CodeCache::gc_prologue() {
  23.101    assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_epilogue must be called");
  23.102  }
  23.103  
  23.104 -
  23.105  void CodeCache::gc_epilogue() {
  23.106    assert_locked_or_safepoint(CodeCache_lock);
  23.107    FOR_ALL_ALIVE_BLOBS(cb) {

    24.1 --- a/src/share/vm/code/codeCache.hpp	Sat Oct 05 03:14:53 2013 +0200
    24.2 +++ b/src/share/vm/code/codeCache.hpp	Fri Oct 04 21:00:43 2013 -0700
    24.3 @@ -57,7 +57,6 @@
    24.4    static int _number_of_nmethods_with_dependencies;
    24.5    static bool _needs_cache_clean;
    24.6    static nmethod* _scavenge_root_nmethods;  // linked via nm->scavenge_root_link()
    24.7 -  static nmethod* _saved_nmethods;          // Linked list of speculatively disconnected nmethods.
    24.8  
    24.9    static void verify_if_often() PRODUCT_RETURN;
   24.10  
   24.11 @@ -167,17 +166,12 @@
   24.12    static size_t  capacity()                      { return _heap->capacity(); }
   24.13    static size_t  max_capacity()                  { return _heap->max_capacity(); }
   24.14    static size_t  unallocated_capacity()          { return _heap->unallocated_capacity(); }
   24.15 -  static bool    needs_flushing()                { return unallocated_capacity() < CodeCacheFlushingMinimumFreeSpace; }
   24.16    static double  reverse_free_ratio();
   24.17  
   24.18    static bool needs_cache_clean()                { return _needs_cache_clean; }
   24.19    static void set_needs_cache_clean(bool v)      { _needs_cache_clean = v;    }
   24.20    static void clear_inline_caches();             // clear all inline caches
   24.21  
   24.22 -  static nmethod* reanimate_saved_code(Method* m);
   24.23 -  static void remove_saved_code(nmethod* nm);
   24.24 -  static void speculatively_disconnect(nmethod* nm);
   24.25 -
   24.26    // Deoptimization
   24.27    static int  mark_for_deoptimization(DepChange& changes);
   24.28  #ifdef HOTSWAP

    25.1 --- a/src/share/vm/code/nmethod.cpp	Sat Oct 05 03:14:53 2013 +0200
    25.2 +++ b/src/share/vm/code/nmethod.cpp	Fri Oct 04 21:00:43 2013 -0700
    25.3 @@ -462,7 +462,6 @@
    25.4    _state                      = alive;
    25.5    _marked_for_reclamation     = 0;
    25.6    _has_flushed_dependencies   = 0;
    25.7 -  _speculatively_disconnected = 0;
    25.8    _has_unsafe_access          = 0;
    25.9    _has_method_handle_invokes  = 0;
   25.10    _lazy_critical_native       = 0;
   25.11 @@ -481,7 +480,6 @@
   25.12    _osr_link                = NULL;
   25.13    _scavenge_root_link      = NULL;
   25.14    _scavenge_root_state     = 0;
   25.15 -  _saved_nmethod_link      = NULL;
   25.16    _compiler                = NULL;
   25.17  
   25.18  #ifdef HAVE_DTRACE_H
   25.19 @@ -686,6 +684,7 @@
   25.20      _osr_entry_point         = NULL;
   25.21      _exception_cache         = NULL;
   25.22      _pc_desc_cache.reset_to(NULL);
   25.23 +    _hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
   25.24  
   25.25      code_buffer->copy_values_to(this);
   25.26      if (ScavengeRootsInCode && detect_scavenge_root_oops()) {
   25.27 @@ -770,6 +769,7 @@
   25.28      _osr_entry_point         = NULL;
   25.29      _exception_cache         = NULL;
   25.30      _pc_desc_cache.reset_to(NULL);
   25.31 +    _hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
   25.32  
   25.33      code_buffer->copy_values_to(this);
   25.34      debug_only(verify_scavenge_root_oops());
   25.35 @@ -842,6 +842,7 @@
   25.36      _comp_level              = comp_level;
   25.37      _compiler                = compiler;
   25.38      _orig_pc_offset          = orig_pc_offset;
   25.39 +    _hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
   25.40  
   25.41      // Section offsets
   25.42      _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
   25.43 @@ -1176,7 +1177,7 @@
   25.44  
   25.45  // This is a private interface with the sweeper.
   25.46  void nmethod::mark_as_seen_on_stack() {
   25.47 -  assert(is_not_entrant(), "must be a non-entrant method");
   25.48 +  assert(is_alive(), "Must be an alive method");
   25.49    // Set the traversal mark to ensure that the sweeper does 2
   25.50    // cleaning passes before moving to zombie.
   25.51    set_stack_traversal_mark(NMethodSweeper::traversal_count());
   25.52 @@ -1261,7 +1262,7 @@
   25.53  
   25.54    set_osr_link(NULL);
   25.55    //set_scavenge_root_link(NULL); // done by prune_scavenge_root_nmethods
   25.56 -  NMethodSweeper::notify(this);
   25.57 +  NMethodSweeper::notify();
   25.58  }
   25.59  
   25.60  void nmethod::invalidate_osr_method() {
   25.61 @@ -1351,6 +1352,15 @@
   25.62        nmethod_needs_unregister = true;
   25.63      }
   25.64  
   25.65 +    // Must happen before state change. Otherwise we have a race condition in
   25.66 +    // nmethod::can_not_entrant_be_converted(). I.e., a method can immediately
   25.67 +    // transition its state from 'not_entrant' to 'zombie' without having to wait
   25.68 +    // for stack scanning.
   25.69 +    if (state == not_entrant) {
   25.70 +      mark_as_seen_on_stack();
   25.71 +      OrderAccess::storestore();
   25.72 +    }
   25.73 +
   25.74      // Change state
   25.75      _state = state;
   25.76  
   25.77 @@ -1369,11 +1379,6 @@
   25.78        HandleMark hm;
   25.79        method()->clear_code();
   25.80      }
   25.81 -
   25.82 -    if (state == not_entrant) {
   25.83 -      mark_as_seen_on_stack();
   25.84 -    }
   25.85 -
   25.86    } // leave critical region under Patching_lock
   25.87  
   25.88    // When the nmethod becomes zombie it is no longer alive so the
   25.89 @@ -1416,7 +1421,7 @@
   25.90    }
   25.91  
   25.92    // Make sweeper aware that there is a zombie method that needs to be removed
   25.93 -  NMethodSweeper::notify(this);
   25.94 +  NMethodSweeper::notify();
   25.95  
   25.96    return true;
   25.97  }
   25.98 @@ -1451,10 +1456,6 @@
   25.99      CodeCache::drop_scavenge_root_nmethod(this);
  25.100    }
  25.101  
  25.102 -  if (is_speculatively_disconnected()) {
  25.103 -    CodeCache::remove_saved_code(this);
  25.104 -  }
  25.105 -
  25.106  #ifdef SHARK
  25.107    ((SharkCompiler *) compiler())->free_compiled_method(insts_begin());
  25.108  #endif // SHARK

    26.1 --- a/src/share/vm/code/nmethod.hpp	Sat Oct 05 03:14:53 2013 +0200
    26.2 +++ b/src/share/vm/code/nmethod.hpp	Fri Oct 04 21:00:43 2013 -0700
    26.3 @@ -119,7 +119,6 @@
    26.4    // To support simple linked-list chaining of nmethods:
    26.5    nmethod*  _osr_link;         // from InstanceKlass::osr_nmethods_head
    26.6    nmethod*  _scavenge_root_link; // from CodeCache::scavenge_root_nmethods
    26.7 -  nmethod*  _saved_nmethod_link; // from CodeCache::speculatively_disconnect
    26.8  
    26.9    static nmethod* volatile _oops_do_mark_nmethods;
   26.10    nmethod*        volatile _oops_do_mark_link;
   26.11 @@ -165,7 +164,6 @@
   26.12  
   26.13    // protected by CodeCache_lock
   26.14    bool _has_flushed_dependencies;            // Used for maintenance of dependencies (CodeCache_lock)
   26.15 -  bool _speculatively_disconnected;          // Marked for potential unload
   26.16  
   26.17    bool _marked_for_reclamation;              // Used by NMethodSweeper (set only by sweeper)
   26.18    bool _marked_for_deoptimization;           // Used for stack deoptimization
   26.19 @@ -180,7 +178,7 @@
   26.20    unsigned int _has_wide_vectors:1;          // Preserve wide vectors at safepoints
   26.21  
   26.22    // Protected by Patching_lock
   26.23 -  unsigned char _state;                      // {alive, not_entrant, zombie, unloaded}
   26.24 +  volatile unsigned char _state;             // {alive, not_entrant, zombie, unloaded}
   26.25  
   26.26  #ifdef ASSERT
   26.27    bool _oops_are_stale;  // indicates that it's no longer safe to access oops section
   26.28 @@ -202,11 +200,18 @@
   26.29  
   26.30    // not_entrant method removal. Each mark_sweep pass will update
   26.31    // this mark to current sweep invocation count if it is seen on the
   26.32 -  // stack.  An not_entrant method can be removed when there is no
   26.33 +  // stack.  An not_entrant method can be removed when there are no
   26.34    // more activations, i.e., when the _stack_traversal_mark is less than
   26.35    // current sweep traversal index.
   26.36    long _stack_traversal_mark;
   26.37  
   26.38 +  // The _hotness_counter indicates the hotness of a method. The higher
   26.39 +  // the value the hotter the method. The hotness counter of a nmethod is
   26.40 +  // set to [(ReservedCodeCacheSize / (1024 * 1024)) * 2] each time the method
   26.41 +  // is active while stack scanning (mark_active_nmethods()). The hotness
   26.42 +  // counter is decreased (by 1) while sweeping.
   26.43 +  int _hotness_counter;
   26.44 +
   26.45    ExceptionCache *_exception_cache;
   26.46    PcDescCache     _pc_desc_cache;
   26.47  
   26.48 @@ -382,6 +387,10 @@
   26.49  
   26.50    int total_size        () const;
   26.51  
   26.52 +  void dec_hotness_counter()        { _hotness_counter--; }
   26.53 +  void set_hotness_counter(int val) { _hotness_counter = val; }
   26.54 +  int  hotness_counter() const      { return _hotness_counter; }
   26.55 +
   26.56    // Containment
   26.57    bool consts_contains       (address addr) const { return consts_begin       () <= addr && addr < consts_end       (); }
   26.58    bool insts_contains        (address addr) const { return insts_begin        () <= addr && addr < insts_end        (); }
   26.59 @@ -408,8 +417,8 @@
   26.60    // alive.  It is used when an uncommon trap happens.  Returns true
   26.61    // if this thread changed the state of the nmethod or false if
   26.62    // another thread performed the transition.
   26.63 -  bool  make_not_entrant()                        { return make_not_entrant_or_zombie(not_entrant); }
   26.64 -  bool  make_zombie()                             { return make_not_entrant_or_zombie(zombie); }
   26.65 +  bool  make_not_entrant() { return make_not_entrant_or_zombie(not_entrant); }
   26.66 +  bool  make_zombie()      { return make_not_entrant_or_zombie(zombie); }
   26.67  
   26.68    // used by jvmti to track if the unload event has been reported
   26.69    bool  unload_reported()                         { return _unload_reported; }
   26.70 @@ -437,9 +446,6 @@
   26.71    bool  has_method_handle_invokes() const         { return _has_method_handle_invokes; }
   26.72    void  set_has_method_handle_invokes(bool z)     { _has_method_handle_invokes = z; }
   26.73  
   26.74 -  bool  is_speculatively_disconnected() const     { return _speculatively_disconnected; }
   26.75 -  void  set_speculatively_disconnected(bool z)    { _speculatively_disconnected = z; }
   26.76 -
   26.77    bool  is_lazy_critical_native() const           { return _lazy_critical_native; }
   26.78    void  set_lazy_critical_native(bool z)          { _lazy_critical_native = z; }
   26.79  
   26.80 @@ -499,9 +505,6 @@
   26.81    nmethod* scavenge_root_link() const                  { return _scavenge_root_link; }
   26.82    void     set_scavenge_root_link(nmethod *n)          { _scavenge_root_link = n; }
   26.83  
   26.84 -  nmethod* saved_nmethod_link() const                  { return _saved_nmethod_link; }
   26.85 -  void     set_saved_nmethod_link(nmethod *n)          { _saved_nmethod_link = n; }
   26.86 -
   26.87   public:
   26.88  
   26.89    // Sweeper support

    27.1 --- a/src/share/vm/compiler/compileBroker.cpp	Sat Oct 05 03:14:53 2013 +0200
    27.2 +++ b/src/share/vm/compiler/compileBroker.cpp	Fri Oct 04 21:00:43 2013 -0700
    27.3 @@ -634,19 +634,36 @@
    27.4    NMethodSweeper::possibly_sweep();
    27.5  
    27.6    MutexLocker locker(lock());
    27.7 -  // Wait for an available CompileTask.
    27.8 +  // If _first is NULL we have no more compile jobs. There are two reasons for
    27.9 +  // having no compile jobs: First, we compiled everything we wanted. Second,
   27.10 +  // we ran out of code cache so compilation has been disabled. In the latter
   27.11 +  // case we perform code cache sweeps to free memory such that we can re-enable
   27.12 +  // compilation.
   27.13    while (_first == NULL) {
   27.14 -    // There is no work to be done right now.  Wait.
   27.15 -    if (UseCodeCacheFlushing && (!CompileBroker::should_compile_new_jobs() || CodeCache::needs_flushing())) {
   27.16 -      // During the emergency sweeping periods, wake up and sweep occasionally
   27.17 -      bool timedout = lock()->wait(!Mutex::_no_safepoint_check_flag, NmethodSweepCheckInterval*1000);
   27.18 -      if (timedout) {
   27.19 +    if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs()) {
   27.20 +      // Wait a certain amount of time to possibly do another sweep.
   27.21 +      // We must wait until stack scanning has happened so that we can
   27.22 +      // transition a method's state from 'not_entrant' to 'zombie'.
   27.23 +      long wait_time = NmethodSweepCheckInterval * 1000;
   27.24 +      if (FLAG_IS_DEFAULT(NmethodSweepCheckInterval)) {
   27.25 +        // Only one thread at a time can do sweeping. Scale the
   27.26 +        // wait time according to the number of compiler threads.
   27.27 +        // As a result, the next sweep is likely to happen every 100ms
   27.28 +        // with an arbitrary number of threads that do sweeping.
   27.29 +        wait_time = 100 * CICompilerCount;
   27.30 +      }
   27.31 +      bool timeout = lock()->wait(!Mutex::_no_safepoint_check_flag, wait_time);
   27.32 +      if (timeout) {
   27.33          MutexUnlocker ul(lock());
   27.34 -        // When otherwise not busy, run nmethod sweeping
   27.35          NMethodSweeper::possibly_sweep();
   27.36        }
   27.37      } else {
   27.38 -      // During normal operation no need to wake up on timer
   27.39 +      // If there are no compilation tasks and we can compile new jobs
   27.40 +      // (i.e., there is enough free space in the code cache) there is
   27.41 +      // no need to invoke the sweeper. As a result, the hotness of methods
   27.42 +      // remains unchanged. This behavior is desired, since we want to keep
   27.43 +      // the stable state, i.e., we do not want to evict methods from the
   27.44 +      // code cache if it is unnecessary.
   27.45        lock()->wait();
   27.46      }
   27.47    }
   27.48 @@ -1227,16 +1244,9 @@
   27.49          return method_code;
   27.50        }
   27.51      }
   27.52 -    if (method->is_not_compilable(comp_level)) return NULL;
   27.53 -
   27.54 -    if (UseCodeCacheFlushing) {
   27.55 -      nmethod* saved = CodeCache::reanimate_saved_code(method());
   27.56 -      if (saved != NULL) {
   27.57 -        method->set_code(method, saved);
   27.58 -        return saved;
   27.59 -      }
   27.60 +    if (method->is_not_compilable(comp_level)) {
   27.61 +      return NULL;
   27.62      }
   27.63 -
   27.64    } else {
   27.65      // osr compilation
   27.66  #ifndef TIERED
   27.67 @@ -1585,9 +1595,6 @@
   27.68        if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
   27.69          // the code cache is really full
   27.70          handle_full_code_cache();
   27.71 -      } else if (UseCodeCacheFlushing && CodeCache::needs_flushing()) {
   27.72 -        // Attempt to start cleaning the code cache while there is still a little headroom
   27.73 -        NMethodSweeper::handle_full_code_cache(false);
   27.74        }
   27.75  
   27.76        CompileTask* task = queue->get();
   27.77 @@ -1943,7 +1950,11 @@
   27.78      }
   27.79  #endif
   27.80      if (UseCodeCacheFlushing) {
   27.81 -      NMethodSweeper::handle_full_code_cache(true);
   27.82 +      // Since code cache is full, immediately stop new compiles
   27.83 +      if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) {
   27.84 +        NMethodSweeper::log_sweep("disable_compiler");
   27.85 +        NMethodSweeper::possibly_sweep();
   27.86 +      }
   27.87      } else {
   27.88        UseCompiler               = false;
   27.89        AlwaysCompileLoopMethods  = false;

    28.1 --- a/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp	Sat Oct 05 03:14:53 2013 +0200
    28.2 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp	Fri Oct 04 21:00:43 2013 -0700
    28.3 @@ -81,7 +81,7 @@
    28.4                                           size_t* marked_bytes_array,
    28.5                                           BitMap* task_card_bm) {
    28.6    G1CollectedHeap* g1h = _g1h;
    28.7 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*) (g1h->barrier_set());
    28.8 +  CardTableModRefBS* ct_bs = g1h->g1_barrier_set();
    28.9  
   28.10    HeapWord* start = mr.start();
   28.11    HeapWord* end = mr.end();

    29.1 --- a/src/share/vm/gc_implementation/g1/g1CardCounts.cpp	Sat Oct 05 03:14:53 2013 +0200
    29.2 +++ b/src/share/vm/gc_implementation/g1/g1CardCounts.cpp	Fri Oct 04 21:00:43 2013 -0700
    29.3 @@ -65,9 +65,7 @@
    29.4      // threshold limit is no more than this.
    29.5      guarantee(G1ConcRSHotCardLimit <= max_jubyte, "sanity");
    29.6  
    29.7 -    ModRefBarrierSet* bs = _g1h->mr_bs();
    29.8 -    guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition");
    29.9 -    _ct_bs = (CardTableModRefBS*)bs;
   29.10 +    _ct_bs = _g1h->g1_barrier_set();
   29.11      _ct_bot = _ct_bs->byte_for_const(_g1h->reserved_region().start());
   29.12  
   29.13      // Allocate/Reserve the counts table

    30.1 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Sat Oct 05 03:14:53 2013 +0200
    30.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Fri Oct 04 21:00:43 2013 -0700
    30.3 @@ -125,10 +125,8 @@
    30.4    int _histo[256];
    30.5  public:
    30.6    ClearLoggedCardTableEntryClosure() :
    30.7 -    _calls(0)
    30.8 +    _calls(0), _g1h(G1CollectedHeap::heap()), _ctbs(_g1h->g1_barrier_set())
    30.9    {
   30.10 -    _g1h = G1CollectedHeap::heap();
   30.11 -    _ctbs = (CardTableModRefBS*)_g1h->barrier_set();
   30.12      for (int i = 0; i < 256; i++) _histo[i] = 0;
   30.13    }
   30.14    bool do_card_ptr(jbyte* card_ptr, int worker_i) {
   30.15 @@ -158,11 +156,8 @@
   30.16    CardTableModRefBS* _ctbs;
   30.17  public:
   30.18    RedirtyLoggedCardTableEntryClosure() :
   30.19 -    _calls(0)
   30.20 -  {
   30.21 -    _g1h = G1CollectedHeap::heap();
   30.22 -    _ctbs = (CardTableModRefBS*)_g1h->barrier_set();
   30.23 -  }
   30.24 +    _calls(0), _g1h(G1CollectedHeap::heap()), _ctbs(_g1h->g1_barrier_set()) {}
   30.25 +
   30.26    bool do_card_ptr(jbyte* card_ptr, int worker_i) {
   30.27      if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) {
   30.28        _calls++;
   30.29 @@ -478,7 +473,7 @@
   30.30  
   30.31  void G1CollectedHeap::check_ct_logs_at_safepoint() {
   30.32    DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
   30.33 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set();
   30.34 +  CardTableModRefBS* ct_bs = g1_barrier_set();
   30.35  
   30.36    // Count the dirty cards at the start.
   30.37    CountNonCleanMemRegionClosure count1(this);
   30.38 @@ -1205,7 +1200,7 @@
   30.39  };
   30.40  
   30.41  void G1CollectedHeap::clear_rsets_post_compaction() {
   30.42 -  PostMCRemSetClearClosure rs_clear(this, mr_bs());
   30.43 +  PostMCRemSetClearClosure rs_clear(this, g1_barrier_set());
   30.44    heap_region_iterate(&rs_clear);
   30.45  }
   30.46  
   30.47 @@ -1777,7 +1772,6 @@
   30.48  }
   30.49  
   30.50  bool G1CollectedHeap::expand(size_t expand_bytes) {
   30.51 -  size_t old_mem_size = _g1_storage.committed_size();
   30.52    size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes);
   30.53    aligned_expand_bytes = align_size_up(aligned_expand_bytes,
   30.54                                         HeapRegion::GrainBytes);
   30.55 @@ -1787,6 +1781,13 @@
   30.56                  ergo_format_byte("attempted expansion amount"),
   30.57                  expand_bytes, aligned_expand_bytes);
   30.58  
   30.59 +  if (_g1_storage.uncommitted_size() == 0) {
   30.60 +    ergo_verbose0(ErgoHeapSizing,
   30.61 +                      "did not expand the heap",
   30.62 +                      ergo_format_reason("heap already fully expanded"));
   30.63 +    return false;
   30.64 +  }
   30.65 +
   30.66    // First commit the memory.
   30.67    HeapWord* old_end = (HeapWord*) _g1_storage.high();
   30.68    bool successful = _g1_storage.expand_by(aligned_expand_bytes);
   30.69 @@ -1845,7 +1846,6 @@
   30.70  }
   30.71  
   30.72  void G1CollectedHeap::shrink_helper(size_t shrink_bytes) {
   30.73 -  size_t old_mem_size = _g1_storage.committed_size();
   30.74    size_t aligned_shrink_bytes =
   30.75      ReservedSpace::page_align_size_down(shrink_bytes);
   30.76    aligned_shrink_bytes = align_size_down(aligned_shrink_bytes,
   30.77 @@ -2045,20 +2045,13 @@
   30.78    // Create the gen rem set (and barrier set) for the entire reserved region.
   30.79    _rem_set = collector_policy()->create_rem_set(_reserved, 2);
   30.80    set_barrier_set(rem_set()->bs());
   30.81 -  if (barrier_set()->is_a(BarrierSet::ModRef)) {
   30.82 -    _mr_bs = (ModRefBarrierSet*)_barrier_set;
   30.83 -  } else {
   30.84 -    vm_exit_during_initialization("G1 requires a mod ref bs.");
   30.85 +  if (!barrier_set()->is_a(BarrierSet::G1SATBCTLogging)) {
   30.86 +    vm_exit_during_initialization("G1 requires a G1SATBLoggingCardTableModRefBS");
   30.87      return JNI_ENOMEM;
   30.88    }
   30.89  
   30.90    // Also create a G1 rem set.
   30.91 -  if (mr_bs()->is_a(BarrierSet::CardTableModRef)) {
   30.92 -    _g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs());
   30.93 -  } else {
   30.94 -    vm_exit_during_initialization("G1 requires a cardtable mod ref bs.");
   30.95 -    return JNI_ENOMEM;
   30.96 -  }
   30.97 +  _g1_rem_set = new G1RemSet(this, g1_barrier_set());
   30.98  
   30.99    // Carve out the G1 part of the heap.
  30.100  
  30.101 @@ -3681,6 +3674,11 @@
  30.102    assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer");
  30.103    // Fill TLAB's and such
  30.104    ensure_parsability(true);
  30.105 +
  30.106 +  if (G1SummarizeRSetStats && (G1SummarizeRSetStatsPeriod > 0) &&
  30.107 +      (total_collections() % G1SummarizeRSetStatsPeriod == 0)) {
  30.108 +    g1_rem_set()->print_periodic_summary_info("Before GC RS summary");
  30.109 +  }
  30.110  }
  30.111  
  30.112  void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) {
  30.113 @@ -3689,7 +3687,7 @@
  30.114        (G1SummarizeRSetStatsPeriod > 0) &&
  30.115        // we are at the end of the GC. Total collections has already been increased.
  30.116        ((total_collections() - 1) % G1SummarizeRSetStatsPeriod == 0)) {
  30.117 -    g1_rem_set()->print_periodic_summary_info();
  30.118 +    g1_rem_set()->print_periodic_summary_info("After GC RS summary");
  30.119    }
  30.120  
  30.121    // FIXME: what is this about?
  30.122 @@ -4550,7 +4548,7 @@
  30.123    : _g1h(g1h),
  30.124      _refs(g1h->task_queue(queue_num)),
  30.125      _dcq(&g1h->dirty_card_queue_set()),
  30.126 -    _ct_bs((CardTableModRefBS*)_g1h->barrier_set()),
  30.127 +    _ct_bs(g1h->g1_barrier_set()),
  30.128      _g1_rem(g1h->g1_rem_set()),
  30.129      _hash_seed(17), _queue_num(queue_num),
  30.130      _term_attempts(0),
  30.131 @@ -5979,11 +5977,11 @@
  30.132  }
  30.133  
  30.134  class G1ParCleanupCTTask : public AbstractGangTask {
  30.135 -  CardTableModRefBS* _ct_bs;
  30.136 +  G1SATBCardTableModRefBS* _ct_bs;
  30.137    G1CollectedHeap* _g1h;
  30.138    HeapRegion* volatile _su_head;
  30.139  public:
  30.140 -  G1ParCleanupCTTask(CardTableModRefBS* ct_bs,
  30.141 +  G1ParCleanupCTTask(G1SATBCardTableModRefBS* ct_bs,
  30.142                       G1CollectedHeap* g1h) :
  30.143      AbstractGangTask("G1 Par Cleanup CT Task"),
  30.144      _ct_bs(ct_bs), _g1h(g1h) { }
  30.145 @@ -6006,9 +6004,9 @@
  30.146  #ifndef PRODUCT
  30.147  class G1VerifyCardTableCleanup: public HeapRegionClosure {
  30.148    G1CollectedHeap* _g1h;
  30.149 -  CardTableModRefBS* _ct_bs;
  30.150 +  G1SATBCardTableModRefBS* _ct_bs;
  30.151  public:
  30.152 -  G1VerifyCardTableCleanup(G1CollectedHeap* g1h, CardTableModRefBS* ct_bs)
  30.153 +  G1VerifyCardTableCleanup(G1CollectedHeap* g1h, G1SATBCardTableModRefBS* ct_bs)
  30.154      : _g1h(g1h), _ct_bs(ct_bs) { }
  30.155    virtual bool doHeapRegion(HeapRegion* r) {
  30.156      if (r->is_survivor()) {
  30.157 @@ -6022,7 +6020,7 @@
  30.158  
  30.159  void G1CollectedHeap::verify_not_dirty_region(HeapRegion* hr) {
  30.160    // All of the region should be clean.
  30.161 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set();
  30.162 +  G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
  30.163    MemRegion mr(hr->bottom(), hr->end());
  30.164    ct_bs->verify_not_dirty_region(mr);
  30.165  }
  30.166 @@ -6035,13 +6033,13 @@
  30.167    // not dirty that area (one less thing to have to do while holding
  30.168    // a lock). So we can only verify that [bottom(),pre_dummy_top()]
  30.169    // is dirty.
  30.170 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set();
  30.171 +  G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
  30.172    MemRegion mr(hr->bottom(), hr->pre_dummy_top());
  30.173    ct_bs->verify_dirty_region(mr);
  30.174  }
  30.175  
  30.176  void G1CollectedHeap::verify_dirty_young_list(HeapRegion* head) {
  30.177 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set();
  30.178 +  G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
  30.179    for (HeapRegion* hr = head; hr != NULL; hr = hr->get_next_young_region()) {
  30.180      verify_dirty_region(hr);
  30.181    }
  30.182 @@ -6053,7 +6051,7 @@
  30.183  #endif
  30.184  
  30.185  void G1CollectedHeap::cleanUpCardTable() {
  30.186 -  CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set());
  30.187 +  G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
  30.188    double start = os::elapsedTime();
  30.189  
  30.190    {

    31.1 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Sat Oct 05 03:14:53 2013 +0200
    31.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Fri Oct 04 21:00:43 2013 -0700
    31.3 @@ -31,6 +31,7 @@
    31.4  #include "gc_implementation/g1/g1HRPrinter.hpp"
    31.5  #include "gc_implementation/g1/g1MonitoringSupport.hpp"
    31.6  #include "gc_implementation/g1/g1RemSet.hpp"
    31.7 +#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
    31.8  #include "gc_implementation/g1/g1YCTypes.hpp"
    31.9  #include "gc_implementation/g1/heapRegionSeq.hpp"
   31.10  #include "gc_implementation/g1/heapRegionSets.hpp"
   31.11 @@ -791,8 +792,6 @@
   31.12  
   31.13    // The g1 remembered set of the heap.
   31.14    G1RemSet* _g1_rem_set;
   31.15 -  // And it's mod ref barrier set, used to track updates for the above.
   31.16 -  ModRefBarrierSet* _mr_bs;
   31.17  
   31.18    // A set of cards that cover the objects for which the Rsets should be updated
   31.19    // concurrently after the collection.
   31.20 @@ -1127,7 +1126,6 @@
   31.21  
   31.22    // The rem set and barrier set.
   31.23    G1RemSet* g1_rem_set() const { return _g1_rem_set; }
   31.24 -  ModRefBarrierSet* mr_bs() const { return _mr_bs; }
   31.25  
   31.26    unsigned get_gc_time_stamp() {
   31.27      return _gc_time_stamp;
   31.28 @@ -1346,6 +1344,10 @@
   31.29  
   31.30    virtual bool is_in_closed_subset(const void* p) const;
   31.31  
   31.32 +  G1SATBCardTableModRefBS* g1_barrier_set() {
   31.33 +    return (G1SATBCardTableModRefBS*) barrier_set();
   31.34 +  }
   31.35 +
   31.36    // This resets the card table to all zeros.  It is used after
   31.37    // a collection pause which used the card table to claim cards.
   31.38    void cleanUpCardTable();
   31.39 @@ -1875,7 +1877,7 @@
   31.40    G1CollectedHeap* _g1h;
   31.41    RefToScanQueue*  _refs;
   31.42    DirtyCardQueue   _dcq;
   31.43 -  CardTableModRefBS* _ct_bs;
   31.44 +  G1SATBCardTableModRefBS* _ct_bs;
   31.45    G1RemSet* _g1_rem;
   31.46  
   31.47    G1ParGCAllocBufferContainer  _surviving_alloc_buffer;
   31.48 @@ -1914,7 +1916,7 @@
   31.49    void   add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
   31.50  
   31.51    DirtyCardQueue& dirty_card_queue()             { return _dcq;  }
   31.52 -  CardTableModRefBS* ctbs()                      { return _ct_bs; }
   31.53 +  G1SATBCardTableModRefBS* ctbs()                { return _ct_bs; }
   31.54  
   31.55    template <class T> void immediate_rs_update(HeapRegion* from, T* p, int tid) {
   31.56      if (!from->is_survivor()) {

    32.1 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp	Sat Oct 05 03:14:53 2013 +0200
    32.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp	Fri Oct 04 21:00:43 2013 -0700
    32.3 @@ -134,7 +134,7 @@
    32.4    assert(containing_hr->is_in(end - 1), "it should also contain end - 1");
    32.5  
    32.6    MemRegion mr(start, end);
    32.7 -  ((CardTableModRefBS*)_g1h->barrier_set())->dirty(mr);
    32.8 +  g1_barrier_set()->dirty(mr);
    32.9  }
   32.10  
   32.11  inline RefToScanQueue* G1CollectedHeap::task_queue(int i) const {

    33.1 --- a/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp	Sat Oct 05 03:14:53 2013 +0200
    33.2 +++ b/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp	Fri Oct 04 21:00:43 2013 -0700
    33.3 @@ -41,11 +41,11 @@
    33.4  private:
    33.5    G1CollectedHeap* _g1;
    33.6    DirtyCardQueue *_dcq;
    33.7 -  CardTableModRefBS* _ct_bs;
    33.8 +  G1SATBCardTableModRefBS* _ct_bs;
    33.9  
   33.10  public:
   33.11    UpdateRSetDeferred(G1CollectedHeap* g1, DirtyCardQueue* dcq) :
   33.12 -    _g1(g1), _ct_bs((CardTableModRefBS*)_g1->barrier_set()), _dcq(dcq) {}
   33.13 +    _g1(g1), _ct_bs(_g1->g1_barrier_set()), _dcq(dcq) {}
   33.14  
   33.15    virtual void do_oop(narrowOop* p) { do_oop_work(p); }
   33.16    virtual void do_oop(      oop* p) { do_oop_work(p); }

    34.1 --- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Sat Oct 05 03:14:53 2013 +0200
    34.2 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Fri Oct 04 21:00:43 2013 -0700
    34.3 @@ -220,7 +220,7 @@
    34.4  public:
    34.5    G1PrepareCompactClosure(CompactibleSpace* cs)
    34.6    : _g1h(G1CollectedHeap::heap()),
    34.7 -    _mrbs(G1CollectedHeap::heap()->mr_bs()),
    34.8 +    _mrbs(_g1h->g1_barrier_set()),
    34.9      _cp(NULL, cs, cs->initialize_threshold()),
   34.10      _humongous_proxy_set("G1MarkSweep Humongous Proxy Set") { }
   34.11  

    35.1 --- a/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Sat Oct 05 03:14:53 2013 +0200
    35.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Fri Oct 04 21:00:43 2013 -0700
    35.3 @@ -83,7 +83,9 @@
    35.4    for (uint i = 0; i < n_workers(); i++) {
    35.5      _cset_rs_update_cl[i] = NULL;
    35.6    }
    35.7 -  _prev_period_summary.initialize(this, n_workers());
    35.8 +  if (G1SummarizeRSetStats) {
    35.9 +    _prev_period_summary.initialize(this);
   35.10 +  }
   35.11  }
   35.12  
   35.13  G1RemSet::~G1RemSet() {
   35.14 @@ -109,7 +111,7 @@
   35.15    CodeBlobToOopClosure* _code_root_cl;
   35.16  
   35.17    G1BlockOffsetSharedArray* _bot_shared;
   35.18 -  CardTableModRefBS *_ct_bs;
   35.19 +  G1SATBCardTableModRefBS *_ct_bs;
   35.20  
   35.21    double _strong_code_root_scan_time_sec;
   35.22    int    _worker_i;
   35.23 @@ -130,7 +132,7 @@
   35.24    {
   35.25      _g1h = G1CollectedHeap::heap();
   35.26      _bot_shared = _g1h->bot_shared();
   35.27 -    _ct_bs = (CardTableModRefBS*) (_g1h->barrier_set());
   35.28 +    _ct_bs = _g1h->g1_barrier_set();
   35.29      _block_size = MAX2<int>(G1RSetScanBlockSize, 1);
   35.30    }
   35.31  
   35.32 @@ -505,12 +507,7 @@
   35.33    ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) :
   35.34      _g1h(G1CollectedHeap::heap()),
   35.35      _region_bm(region_bm), _card_bm(card_bm),
   35.36 -    _ctbs(NULL)
   35.37 -  {
   35.38 -    ModRefBarrierSet* bs = _g1h->mr_bs();
   35.39 -    guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition");
   35.40 -    _ctbs = (CardTableModRefBS*)bs;
   35.41 -  }
   35.42 +    _ctbs(_g1h->g1_barrier_set()) {}
   35.43  
   35.44    bool doHeapRegion(HeapRegion* r) {
   35.45      if (!r->continuesHumongous()) {
   35.46 @@ -731,19 +728,19 @@
   35.47    return has_refs_into_cset;
   35.48  }
   35.49  
   35.50 -void G1RemSet::print_periodic_summary_info() {
   35.51 +void G1RemSet::print_periodic_summary_info(const char* header) {
   35.52    G1RemSetSummary current;
   35.53 -  current.initialize(this, n_workers());
   35.54 +  current.initialize(this);
   35.55  
   35.56    _prev_period_summary.subtract_from(&current);
   35.57 -  print_summary_info(&_prev_period_summary);
   35.58 +  print_summary_info(&_prev_period_summary, header);
   35.59  
   35.60    _prev_period_summary.set(&current);
   35.61  }
   35.62  
   35.63  void G1RemSet::print_summary_info() {
   35.64    G1RemSetSummary current;
   35.65 -  current.initialize(this, n_workers());
   35.66 +  current.initialize(this);
   35.67  
   35.68    print_summary_info(&current, " Cumulative RS summary");
   35.69  }

    36.1 --- a/src/share/vm/gc_implementation/g1/g1RemSet.hpp	Sat Oct 05 03:14:53 2013 +0200
    36.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.hpp	Fri Oct 04 21:00:43 2013 -0700
    36.3 @@ -145,7 +145,7 @@
    36.4    virtual void print_summary_info();
    36.5  
    36.6    // Print accumulated summary info from the last time called.
    36.7 -  virtual void print_periodic_summary_info();
    36.8 +  virtual void print_periodic_summary_info(const char* header);
    36.9  
   36.10    // Prepare remembered set for verification.
   36.11    virtual void prepare_for_verify();

    37.1 --- a/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp	Sat Oct 05 03:14:53 2013 +0200
    37.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp	Fri Oct 04 21:00:43 2013 -0700
    37.3 @@ -77,12 +77,12 @@
    37.4    return _rs_threads_vtimes[thread];
    37.5  }
    37.6  
    37.7 -void G1RemSetSummary::initialize(G1RemSet* remset, uint num_workers) {
    37.8 +void G1RemSetSummary::initialize(G1RemSet* remset) {
    37.9    assert(_rs_threads_vtimes == NULL, "just checking");
   37.10    assert(remset != NULL, "just checking");
   37.11  
   37.12    _remset = remset;
   37.13 -  _num_vtimes = num_workers;
   37.14 +  _num_vtimes = ConcurrentG1Refine::thread_num();
   37.15    _rs_threads_vtimes = NEW_C_HEAP_ARRAY(double, _num_vtimes, mtGC);
   37.16    memset(_rs_threads_vtimes, 0, sizeof(double) * _num_vtimes);
   37.17  
   37.18 @@ -125,25 +125,115 @@
   37.19    _sampling_thread_vtime = other->sampling_thread_vtime() - _sampling_thread_vtime;
   37.20  }
   37.21  
   37.22 +static double percent_of(size_t numerator, size_t denominator) {
   37.23 +  if (denominator != 0) {
   37.24 +    return (double)numerator / denominator * 100.0f;
   37.25 +  } else {
   37.26 +    return 0.0f;
   37.27 +  }
   37.28 +}
   37.29 +
   37.30 +static size_t round_to_K(size_t value) {
   37.31 +  return value / K;
   37.32 +}
   37.33 +
   37.34 +class RegionTypeCounter VALUE_OBJ_CLASS_SPEC {
   37.35 +private:
   37.36 +  const char* _name;
   37.37 +
   37.38 +  size_t _rs_mem_size;
   37.39 +  size_t _cards_occupied;
   37.40 +  size_t _amount;
   37.41 +
   37.42 +  size_t _code_root_mem_size;
   37.43 +  size_t _code_root_elems;
   37.44 +
   37.45 +  double rs_mem_size_percent_of(size_t total) {
   37.46 +    return percent_of(_rs_mem_size, total);
   37.47 +  }
   37.48 +
   37.49 +  double cards_occupied_percent_of(size_t total) {
   37.50 +    return percent_of(_cards_occupied, total);
   37.51 +  }
   37.52 +
   37.53 +  double code_root_mem_size_percent_of(size_t total) {
   37.54 +    return percent_of(_code_root_mem_size, total);
   37.55 +  }
   37.56 +
   37.57 +  double code_root_elems_percent_of(size_t total) {
   37.58 +    return percent_of(_code_root_elems, total);
   37.59 +  }
   37.60 +
   37.61 +  size_t amount() const { return _amount; }
   37.62 +
   37.63 +public:
   37.64 +
   37.65 +  RegionTypeCounter(const char* name) : _name(name), _rs_mem_size(0), _cards_occupied(0),
   37.66 +    _amount(0), _code_root_mem_size(0), _code_root_elems(0) { }
   37.67 +
   37.68 +  void add(size_t rs_mem_size, size_t cards_occupied, size_t code_root_mem_size,
   37.69 +    size_t code_root_elems) {
   37.70 +    _rs_mem_size += rs_mem_size;
   37.71 +    _cards_occupied += cards_occupied;
   37.72 +    _code_root_mem_size += code_root_mem_size;
   37.73 +    _code_root_elems += code_root_elems;
   37.74 +    _amount++;
   37.75 +  }
   37.76 +
   37.77 +  size_t rs_mem_size() const { return _rs_mem_size; }
   37.78 +  size_t cards_occupied() const { return _cards_occupied; }
   37.79 +
   37.80 +  size_t code_root_mem_size() const { return _code_root_mem_size; }
   37.81 +  size_t code_root_elems() const { return _code_root_elems; }
   37.82 +
   37.83 +  void print_rs_mem_info_on(outputStream * out, size_t total) {
   37.84 +    out->print_cr("    %8dK (%5.1f%%) by %zd %s regions", round_to_K(rs_mem_size()), rs_mem_size_percent_of(total), amount(), _name);
   37.85 +  }
   37.86 +
   37.87 +  void print_cards_occupied_info_on(outputStream * out, size_t total) {
   37.88 +    out->print_cr("     %8d (%5.1f%%) entries by %zd %s regions", cards_occupied(), cards_occupied_percent_of(total), amount(), _name);
   37.89 +  }
   37.90 +
   37.91 +  void print_code_root_mem_info_on(outputStream * out, size_t total) {
   37.92 +    out->print_cr("    %8dK (%5.1f%%) by %zd %s regions", round_to_K(code_root_mem_size()), code_root_mem_size_percent_of(total), amount(), _name);
   37.93 +  }
   37.94 +
   37.95 +  void print_code_root_elems_info_on(outputStream * out, size_t total) {
   37.96 +    out->print_cr("     %8d (%5.1f%%) elements by %zd %s regions", code_root_elems(), code_root_elems_percent_of(total), amount(), _name);
   37.97 +  }
   37.98 +};
   37.99 +
  37.100 +
  37.101  class HRRSStatsIter: public HeapRegionClosure {
  37.102 -  size_t _occupied;
  37.103 +private:
  37.104 +  RegionTypeCounter _young;
  37.105 +  RegionTypeCounter _humonguous;
  37.106 +  RegionTypeCounter _free;
  37.107 +  RegionTypeCounter _old;
  37.108 +  RegionTypeCounter _all;
  37.109  
  37.110 -  size_t _total_rs_mem_sz;
  37.111    size_t _max_rs_mem_sz;
  37.112    HeapRegion* _max_rs_mem_sz_region;
  37.113  
  37.114 -  size_t _total_code_root_mem_sz;
  37.115 +  size_t total_rs_mem_sz() const            { return _all.rs_mem_size(); }
  37.116 +  size_t total_cards_occupied() const       { return _all.cards_occupied(); }
  37.117 +
  37.118 +  size_t max_rs_mem_sz() const              { return _max_rs_mem_sz; }
  37.119 +  HeapRegion* max_rs_mem_sz_region() const  { return _max_rs_mem_sz_region; }
  37.120 +
  37.121    size_t _max_code_root_mem_sz;
  37.122    HeapRegion* _max_code_root_mem_sz_region;
  37.123 +
  37.124 +  size_t total_code_root_mem_sz() const     { return _all.code_root_mem_size(); }
  37.125 +  size_t total_code_root_elems() const      { return _all.code_root_elems(); }
  37.126 +
  37.127 +  size_t max_code_root_mem_sz() const       { return _max_code_root_mem_sz; }
  37.128 +  HeapRegion* max_code_root_mem_sz_region() const { return _max_code_root_mem_sz_region; }
  37.129 +
  37.130  public:
  37.131 -  HRRSStatsIter() :
  37.132 -    _occupied(0),
  37.133 -    _total_rs_mem_sz(0),
  37.134 -    _max_rs_mem_sz(0),
  37.135 -    _max_rs_mem_sz_region(NULL),
  37.136 -    _total_code_root_mem_sz(0),
  37.137 -    _max_code_root_mem_sz(0),
  37.138 -    _max_code_root_mem_sz_region(NULL)
  37.139 +  HRRSStatsIter() : _all("All"), _young("Young"), _humonguous("Humonguous"),
  37.140 +    _free("Free"), _old("Old"), _max_code_root_mem_sz_region(NULL), _max_rs_mem_sz_region(NULL),
  37.141 +    _max_rs_mem_sz(0), _max_code_root_mem_sz(0)
  37.142    {}
  37.143  
  37.144    bool doHeapRegion(HeapRegion* r) {
  37.145 @@ -156,46 +246,95 @@
  37.146        _max_rs_mem_sz = rs_mem_sz;
  37.147        _max_rs_mem_sz_region = r;
  37.148      }
  37.149 -    _total_rs_mem_sz += rs_mem_sz;
  37.150 -
  37.151 +    size_t occupied_cards = hrrs->occupied();
  37.152      size_t code_root_mem_sz = hrrs->strong_code_roots_mem_size();
  37.153 -    if (code_root_mem_sz > _max_code_root_mem_sz) {
  37.154 -      _max_code_root_mem_sz = code_root_mem_sz;
  37.155 +    if (code_root_mem_sz > max_code_root_mem_sz()) {
  37.156        _max_code_root_mem_sz_region = r;
  37.157      }
  37.158 -    _total_code_root_mem_sz += code_root_mem_sz;
  37.159 +    size_t code_root_elems = hrrs->strong_code_roots_list_length();
  37.160  
  37.161 -    size_t occ = hrrs->occupied();
  37.162 -    _occupied += occ;
  37.163 +    RegionTypeCounter* current = NULL;
  37.164 +    if (r->is_young()) {
  37.165 +      current = &_young;
  37.166 +    } else if (r->isHumongous()) {
  37.167 +      current = &_humonguous;
  37.168 +    } else if (r->is_empty()) {
  37.169 +      current = &_free;
  37.170 +    } else {
  37.171 +      current = &_old;
  37.172 +    }
  37.173 +    current->add(rs_mem_sz, occupied_cards, code_root_mem_sz, code_root_elems);
  37.174 +    _all.add(rs_mem_sz, occupied_cards, code_root_mem_sz, code_root_elems);
  37.175 +
  37.176      return false;
  37.177    }
  37.178 -  size_t total_rs_mem_sz() { return _total_rs_mem_sz; }
  37.179 -  size_t max_rs_mem_sz() { return _max_rs_mem_sz; }
  37.180 -  HeapRegion* max_rs_mem_sz_region() { return _max_rs_mem_sz_region; }
  37.181 -  size_t total_code_root_mem_sz() { return _total_code_root_mem_sz; }
  37.182 -  size_t max_code_root_mem_sz() { return _max_code_root_mem_sz; }
  37.183 -  HeapRegion* max_code_root_mem_sz_region() { return _max_code_root_mem_sz_region; }
  37.184 -  size_t occupied() { return _occupied; }
  37.185 +
  37.186 +  void print_summary_on(outputStream* out) {
  37.187 +    RegionTypeCounter* counters[] = { &_young, &_humonguous, &_free, &_old, NULL };
  37.188 +
  37.189 +    out->print_cr("\n Current rem set statistics");
  37.190 +    out->print_cr("  Total per region rem sets sizes = "SIZE_FORMAT"K."
  37.191 +                  " Max = "SIZE_FORMAT"K.",
  37.192 +                  round_to_K(total_rs_mem_sz()), round_to_K(max_rs_mem_sz()));
  37.193 +    for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
  37.194 +      (*current)->print_rs_mem_info_on(out, total_rs_mem_sz());
  37.195 +    }
  37.196 +
  37.197 +    out->print_cr("   Static structures = "SIZE_FORMAT"K,"
  37.198 +                  " free_lists = "SIZE_FORMAT"K.",
  37.199 +                  round_to_K(HeapRegionRemSet::static_mem_size()),
  37.200 +                  round_to_K(HeapRegionRemSet::fl_mem_size()));
  37.201 +
  37.202 +    out->print_cr("    "SIZE_FORMAT" occupied cards represented.",
  37.203 +                  total_cards_occupied());
  37.204 +    for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
  37.205 +      (*current)->print_cards_occupied_info_on(out, total_cards_occupied());
  37.206 +    }
  37.207 +
  37.208 +    // Largest sized rem set region statistics
  37.209 +    HeapRegionRemSet* rem_set = max_rs_mem_sz_region()->rem_set();
  37.210 +    out->print_cr("    Region with largest rem set = "HR_FORMAT", "
  37.211 +                  "size = "SIZE_FORMAT "K, occupied = "SIZE_FORMAT"K.",
  37.212 +                  HR_FORMAT_PARAMS(max_rs_mem_sz_region()),
  37.213 +                  round_to_K(rem_set->mem_size()),
  37.214 +                  round_to_K(rem_set->occupied()));
  37.215 +
  37.216 +    // Strong code root statistics
  37.217 +    HeapRegionRemSet* max_code_root_rem_set = max_code_root_mem_sz_region()->rem_set();
  37.218 +    out->print_cr("  Total heap region code root sets sizes = "SIZE_FORMAT"K."
  37.219 +                  "  Max = "SIZE_FORMAT"K.",
  37.220 +                  round_to_K(total_code_root_mem_sz()),
  37.221 +                  round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()));
  37.222 +    for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
  37.223 +      (*current)->print_code_root_mem_info_on(out, total_code_root_mem_sz());
  37.224 +    }
  37.225 +
  37.226 +    out->print_cr("    "SIZE_FORMAT" code roots represented.",
  37.227 +                  total_code_root_elems());
  37.228 +    for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
  37.229 +      (*current)->print_code_root_elems_info_on(out, total_code_root_elems());
  37.230 +    }
  37.231 +
  37.232 +    out->print_cr("    Region with largest amount of code roots = "HR_FORMAT", "
  37.233 +                  "size = "SIZE_FORMAT "K, num_elems = "SIZE_FORMAT".",
  37.234 +                  HR_FORMAT_PARAMS(max_code_root_mem_sz_region()),
  37.235 +                  round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()),
  37.236 +                  round_to_K(max_code_root_rem_set->strong_code_roots_list_length()));
  37.237 +  }
  37.238  };
  37.239  
  37.240 -double calc_percentage(size_t numerator, size_t denominator) {
  37.241 -  if (denominator != 0) {
  37.242 -    return (double)numerator / denominator * 100.0;
  37.243 -  } else {
  37.244 -    return 0.0f;
  37.245 -  }
  37.246 -}
  37.247 -
  37.248  void G1RemSetSummary::print_on(outputStream* out) {
  37.249 -  out->print_cr("\n Concurrent RS processed "SIZE_FORMAT" cards",
  37.250 +  out->print_cr("\n Recent concurrent refinement statistics");
  37.251 +  out->print_cr("  Processed "SIZE_FORMAT" cards",
  37.252                  num_concurrent_refined_cards());
  37.253    out->print_cr("  Of %d completed buffers:", num_processed_buf_total());
  37.254    out->print_cr("     %8d (%5.1f%%) by concurrent RS threads.",
  37.255                  num_processed_buf_total(),
  37.256 -                calc_percentage(num_processed_buf_rs_threads(), num_processed_buf_total()));
  37.257 +                percent_of(num_processed_buf_rs_threads(), num_processed_buf_total()));
  37.258    out->print_cr("     %8d (%5.1f%%) by mutator threads.",
  37.259                  num_processed_buf_mutator(),
  37.260 -                calc_percentage(num_processed_buf_mutator(), num_processed_buf_total()));
  37.261 +                percent_of(num_processed_buf_mutator(), num_processed_buf_total()));
  37.262 +  out->print_cr("  Did %d coarsenings.", num_coarsenings());
  37.263    out->print_cr("  Concurrent RS threads times (s)");
  37.264    out->print("     ");
  37.265    for (uint i = 0; i < _num_vtimes; i++) {
  37.266 @@ -207,33 +346,5 @@
  37.267  
  37.268    HRRSStatsIter blk;
  37.269    G1CollectedHeap::heap()->heap_region_iterate(&blk);
  37.270 -  // RemSet stats
  37.271 -  out->print_cr("  Total heap region rem set sizes = "SIZE_FORMAT"K."
  37.272 -                "  Max = "SIZE_FORMAT"K.",
  37.273 -                blk.total_rs_mem_sz()/K, blk.max_rs_mem_sz()/K);
  37.274 -  out->print_cr("  Static structures = "SIZE_FORMAT"K,"
  37.275 -                " free_lists = "SIZE_FORMAT"K.",
  37.276 -                HeapRegionRemSet::static_mem_size() / K,
  37.277 -                HeapRegionRemSet::fl_mem_size() / K);
  37.278 -  out->print_cr("    "SIZE_FORMAT" occupied cards represented.",
  37.279 -                blk.occupied());
  37.280 -  HeapRegion* max_rs_mem_sz_region = blk.max_rs_mem_sz_region();
  37.281 -  HeapRegionRemSet* max_rs_rem_set = max_rs_mem_sz_region->rem_set();
  37.282 -  out->print_cr("    Max size region = "HR_FORMAT", "
  37.283 -                "size = "SIZE_FORMAT "K, occupied = "SIZE_FORMAT"K.",
  37.284 -                HR_FORMAT_PARAMS(max_rs_mem_sz_region),
  37.285 -                (max_rs_rem_set->mem_size() + K - 1)/K,
  37.286 -                (max_rs_rem_set->occupied() + K - 1)/K);
  37.287 -  out->print_cr("    Did %d coarsenings.", num_coarsenings());
  37.288 -  // Strong code root stats
  37.289 -  out->print_cr("  Total heap region code-root set sizes = "SIZE_FORMAT"K."
  37.290 -                "  Max = "SIZE_FORMAT"K.",
  37.291 -                blk.total_code_root_mem_sz()/K, blk.max_code_root_mem_sz()/K);
  37.292 -  HeapRegion* max_code_root_mem_sz_region = blk.max_code_root_mem_sz_region();
  37.293 -  HeapRegionRemSet* max_code_root_rem_set = max_code_root_mem_sz_region->rem_set();
  37.294 -  out->print_cr("    Max size region = "HR_FORMAT", "
  37.295 -                "size = "SIZE_FORMAT "K, num_elems = "SIZE_FORMAT".",
  37.296 -                HR_FORMAT_PARAMS(max_code_root_mem_sz_region),
  37.297 -                (max_code_root_rem_set->strong_code_roots_mem_size() + K - 1)/K,
  37.298 -                (max_code_root_rem_set->strong_code_roots_list_length()));
  37.299 +  blk.print_summary_on(out);
  37.300  }

    38.1 --- a/src/share/vm/gc_implementation/g1/g1RemSetSummary.hpp	Sat Oct 05 03:14:53 2013 +0200
    38.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSetSummary.hpp	Fri Oct 04 21:00:43 2013 -0700
    38.3 @@ -84,7 +84,7 @@
    38.4    void subtract_from(G1RemSetSummary* other);
    38.5  
    38.6    // initialize and get the first sampling
    38.7 -  void initialize(G1RemSet* remset, uint num_workers);
    38.8 +  void initialize(G1RemSet* remset);
    38.9  
   38.10    void print_on(outputStream* out);
   38.11  

    39.1 --- a/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.cpp	Sat Oct 05 03:14:53 2013 +0200
    39.2 +++ b/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.cpp	Fri Oct 04 21:00:43 2013 -0700
    39.3 @@ -64,6 +64,27 @@
    39.4    }
    39.5  }
    39.6  
    39.7 +bool G1SATBCardTableModRefBS::mark_card_deferred(size_t card_index) {
    39.8 +  jbyte val = _byte_map[card_index];
    39.9 +  // It's already processed
   39.10 +  if ((val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val()) {
   39.11 +    return false;
   39.12 +  }
   39.13 +  // Cached bit can be installed either on a clean card or on a claimed card.
   39.14 +  jbyte new_val = val;
   39.15 +  if (val == clean_card_val()) {
   39.16 +    new_val = (jbyte)deferred_card_val();
   39.17 +  } else {
   39.18 +    if (val & claimed_card_val()) {
   39.19 +      new_val = val | (jbyte)deferred_card_val();
   39.20 +    }
   39.21 +  }
   39.22 +  if (new_val != val) {
   39.23 +    Atomic::cmpxchg(new_val, &_byte_map[card_index], val);
   39.24 +  }
   39.25 +  return true;
   39.26 +}
   39.27 +
   39.28  G1SATBCardTableLoggingModRefBS::
   39.29  G1SATBCardTableLoggingModRefBS(MemRegion whole_heap,
   39.30                                 int max_covered_regions) :

    40.1 --- a/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp	Sat Oct 05 03:14:53 2013 +0200
    40.2 +++ b/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp	Fri Oct 04 21:00:43 2013 -0700
    40.3 @@ -89,6 +89,42 @@
    40.4        write_ref_array_pre_work(dst, count);
    40.5      }
    40.6    }
    40.7 +
    40.8 +/*
    40.9 +   Claimed and deferred bits are used together in G1 during the evacuation
   40.10 +   pause. These bits can have the following state transitions:
   40.11 +   1. The claimed bit can be put over any other card state. Except that
   40.12 +      the "dirty -> dirty and claimed" transition is checked for in
   40.13 +      G1 code and is not used.
   40.14 +   2. Deferred bit can be set only if the previous state of the card
   40.15 +      was either clean or claimed. mark_card_deferred() is wait-free.
   40.16 +      We do not care if the operation is be successful because if
   40.17 +      it does not it will only result in duplicate entry in the update
   40.18 +      buffer because of the "cache-miss". So it's not worth spinning.
   40.19 + */
   40.20 +
   40.21 +  bool is_card_claimed(size_t card_index) {
   40.22 +    jbyte val = _byte_map[card_index];
   40.23 +    return (val & (clean_card_mask_val() | claimed_card_val())) == claimed_card_val();
   40.24 +  }
   40.25 +
   40.26 +  void set_card_claimed(size_t card_index) {
   40.27 +      jbyte val = _byte_map[card_index];
   40.28 +      if (val == clean_card_val()) {
   40.29 +        val = (jbyte)claimed_card_val();
   40.30 +      } else {
   40.31 +        val |= (jbyte)claimed_card_val();
   40.32 +      }
   40.33 +      _byte_map[card_index] = val;
   40.34 +  }
   40.35 +
   40.36 +  bool mark_card_deferred(size_t card_index);
   40.37 +
   40.38 +  bool is_card_deferred(size_t card_index) {
   40.39 +    jbyte val = _byte_map[card_index];
   40.40 +    return (val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val();
   40.41 +  }
   40.42 +
   40.43  };
   40.44  
   40.45  // Adds card-table logging to the post-barrier.

    41.1 --- a/src/share/vm/gc_implementation/parallelScavenge/generationSizer.hpp	Sat Oct 05 03:14:53 2013 +0200
    41.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/generationSizer.hpp	Fri Oct 04 21:00:43 2013 -0700
    41.3 @@ -40,10 +40,8 @@
    41.4  
    41.5    void initialize_flags() {
    41.6      // Do basic sizing work
    41.7 -    this->TwoGenerationCollectorPolicy::initialize_flags();
    41.8 +    TwoGenerationCollectorPolicy::initialize_flags();
    41.9  
   41.10 -    // If the user hasn't explicitly set the number of worker
   41.11 -    // threads, set the count.
   41.12      assert(UseSerialGC ||
   41.13             !FLAG_IS_DEFAULT(ParallelGCThreads) ||
   41.14             (ParallelGCThreads > 0),

    42.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp	Sat Oct 05 03:14:53 2013 +0200
    42.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp	Fri Oct 04 21:00:43 2013 -0700
    42.3 @@ -23,7 +23,6 @@
    42.4   */
    42.5  
    42.6  #include "precompiled.hpp"
    42.7 -#include "gc_implementation/parallelScavenge/generationSizer.hpp"
    42.8  #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
    42.9  #include "gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp"
   42.10  #include "gc_implementation/parallelScavenge/psScavenge.hpp"

    43.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp	Sat Oct 05 03:14:53 2013 +0200
    43.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp	Fri Oct 04 21:00:43 2013 -0700
    43.3 @@ -53,7 +53,6 @@
    43.4  
    43.5  // Forward decls
    43.6  class elapsedTimer;
    43.7 -class GenerationSizer;
    43.8  
    43.9  class PSAdaptiveSizePolicy : public AdaptiveSizePolicy {
   43.10   friend class PSGCAdaptivePolicyCounters;

    44.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp	Sat Oct 05 03:14:53 2013 +0200
    44.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp	Fri Oct 04 21:00:43 2013 -0700
    44.3 @@ -26,7 +26,6 @@
    44.4  #include "classfile/symbolTable.hpp"
    44.5  #include "classfile/systemDictionary.hpp"
    44.6  #include "code/codeCache.hpp"
    44.7 -#include "gc_implementation/parallelScavenge/generationSizer.hpp"
    44.8  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
    44.9  #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
   44.10  #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"

    45.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Sat Oct 05 03:14:53 2013 +0200
    45.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Fri Oct 04 21:00:43 2013 -0700
    45.3 @@ -27,7 +27,6 @@
    45.4  #include "classfile/systemDictionary.hpp"
    45.5  #include "code/codeCache.hpp"
    45.6  #include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
    45.7 -#include "gc_implementation/parallelScavenge/generationSizer.hpp"
    45.8  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
    45.9  #include "gc_implementation/parallelScavenge/pcTasks.hpp"
   45.10  #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"

    46.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp	Sat Oct 05 03:14:53 2013 +0200
    46.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp	Fri Oct 04 21:00:43 2013 -0700
    46.3 @@ -27,7 +27,6 @@
    46.4  #include "code/codeCache.hpp"
    46.5  #include "gc_implementation/parallelScavenge/cardTableExtension.hpp"
    46.6  #include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
    46.7 -#include "gc_implementation/parallelScavenge/generationSizer.hpp"
    46.8  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
    46.9  #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
   46.10  #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"

    47.1 --- a/src/share/vm/memory/cardTableModRefBS.cpp	Sat Oct 05 03:14:53 2013 +0200
    47.2 +++ b/src/share/vm/memory/cardTableModRefBS.cpp	Fri Oct 04 21:00:43 2013 -0700
    47.3 @@ -423,60 +423,6 @@
    47.4    inline_write_ref_field(field, newVal);
    47.5  }
    47.6  
    47.7 -/*
    47.8 -   Claimed and deferred bits are used together in G1 during the evacuation
    47.9 -   pause. These bits can have the following state transitions:
   47.10 -   1. The claimed bit can be put over any other card state. Except that
   47.11 -      the "dirty -> dirty and claimed" transition is checked for in
   47.12 -      G1 code and is not used.
   47.13 -   2. Deferred bit can be set only if the previous state of the card
   47.14 -      was either clean or claimed. mark_card_deferred() is wait-free.
   47.15 -      We do not care if the operation is be successful because if
   47.16 -      it does not it will only result in duplicate entry in the update
   47.17 -      buffer because of the "cache-miss". So it's not worth spinning.
   47.18 - */
   47.19 -
   47.20 -
   47.21 -bool CardTableModRefBS::claim_card(size_t card_index) {
   47.22 -  jbyte val = _byte_map[card_index];
   47.23 -  assert(val != dirty_card_val(), "Shouldn't claim a dirty card");
   47.24 -  while (val == clean_card_val() ||
   47.25 -         (val & (clean_card_mask_val() | claimed_card_val())) != claimed_card_val()) {
   47.26 -    jbyte new_val = val;
   47.27 -    if (val == clean_card_val()) {
   47.28 -      new_val = (jbyte)claimed_card_val();
   47.29 -    } else {
   47.30 -      new_val = val | (jbyte)claimed_card_val();
   47.31 -    }
   47.32 -    jbyte res = Atomic::cmpxchg(new_val, &_byte_map[card_index], val);
   47.33 -    if (res == val) {
   47.34 -      return true;
   47.35 -    }
   47.36 -    val = res;
   47.37 -  }
   47.38 -  return false;
   47.39 -}
   47.40 -
   47.41 -bool CardTableModRefBS::mark_card_deferred(size_t card_index) {
   47.42 -  jbyte val = _byte_map[card_index];
   47.43 -  // It's already processed
   47.44 -  if ((val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val()) {
   47.45 -    return false;
   47.46 -  }
   47.47 -  // Cached bit can be installed either on a clean card or on a claimed card.
   47.48 -  jbyte new_val = val;
   47.49 -  if (val == clean_card_val()) {
   47.50 -    new_val = (jbyte)deferred_card_val();
   47.51 -  } else {
   47.52 -    if (val & claimed_card_val()) {
   47.53 -      new_val = val | (jbyte)deferred_card_val();
   47.54 -    }
   47.55 -  }
   47.56 -  if (new_val != val) {
   47.57 -    Atomic::cmpxchg(new_val, &_byte_map[card_index], val);
   47.58 -  }
   47.59 -  return true;
   47.60 -}
   47.61  
   47.62  void CardTableModRefBS::non_clean_card_iterate_possibly_parallel(Space* sp,
   47.63                                                                   MemRegion mr,

    48.1 --- a/src/share/vm/memory/cardTableModRefBS.hpp	Sat Oct 05 03:14:53 2013 +0200
    48.2 +++ b/src/share/vm/memory/cardTableModRefBS.hpp	Fri Oct 04 21:00:43 2013 -0700
    48.3 @@ -339,34 +339,10 @@
    48.4      _byte_map[card_index] = dirty_card_val();
    48.5    }
    48.6  
    48.7 -  bool is_card_claimed(size_t card_index) {
    48.8 -    jbyte val = _byte_map[card_index];
    48.9 -    return (val & (clean_card_mask_val() | claimed_card_val())) == claimed_card_val();
   48.10 -  }
   48.11 -
   48.12 -  void set_card_claimed(size_t card_index) {
   48.13 -      jbyte val = _byte_map[card_index];
   48.14 -      if (val == clean_card_val()) {
   48.15 -        val = (jbyte)claimed_card_val();
   48.16 -      } else {
   48.17 -        val |= (jbyte)claimed_card_val();
   48.18 -      }
   48.19 -      _byte_map[card_index] = val;
   48.20 -  }
   48.21 -
   48.22 -  bool claim_card(size_t card_index);
   48.23 -
   48.24    bool is_card_clean(size_t card_index) {
   48.25      return _byte_map[card_index] == clean_card_val();
   48.26    }
   48.27  
   48.28 -  bool is_card_deferred(size_t card_index) {
   48.29 -    jbyte val = _byte_map[card_index];
   48.30 -    return (val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val();
   48.31 -  }
   48.32 -
   48.33 -  bool mark_card_deferred(size_t card_index);
   48.34 -
   48.35    // Card marking array base (adjusted for heap low boundary)
   48.36    // This would be the 0th element of _byte_map, if the heap started at 0x0.
   48.37    // But since the heap starts at some higher address, this points to somewhere

    49.1 --- a/src/share/vm/memory/collectorPolicy.cpp	Sat Oct 05 03:14:53 2013 +0200
    49.2 +++ b/src/share/vm/memory/collectorPolicy.cpp	Fri Oct 04 21:00:43 2013 -0700
    49.3 @@ -64,19 +64,21 @@
    49.4      vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
    49.5    }
    49.6  
    49.7 -  if (!is_size_aligned(MaxMetaspaceSize, max_alignment())) {
    49.8 -    FLAG_SET_ERGO(uintx, MaxMetaspaceSize,
    49.9 -        restricted_align_down(MaxMetaspaceSize, max_alignment()));
   49.10 +  // Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
   49.11 +  // override if MaxMetaspaceSize was set on the command line or not.
   49.12 +  // This information is needed later to conform to the specification of the
   49.13 +  // java.lang.management.MemoryUsage API.
   49.14 +  //
   49.15 +  // Ideally, we would be able to set the default value of MaxMetaspaceSize in
   49.16 +  // globals.hpp to the aligned value, but this is not possible, since the
   49.17 +  // alignment depends on other flags being parsed.
   49.18 +  MaxMetaspaceSize = restricted_align_down(MaxMetaspaceSize, max_alignment());
   49.19 +
   49.20 +  if (MetaspaceSize > MaxMetaspaceSize) {
   49.21 +    MetaspaceSize = MaxMetaspaceSize;
   49.22    }
   49.23  
   49.24 -  if (MetaspaceSize > MaxMetaspaceSize) {
   49.25 -    FLAG_SET_ERGO(uintx, MetaspaceSize, MaxMetaspaceSize);
   49.26 -  }
   49.27 -
   49.28 -  if (!is_size_aligned(MetaspaceSize, min_alignment())) {
   49.29 -    FLAG_SET_ERGO(uintx, MetaspaceSize,
   49.30 -        restricted_align_down(MetaspaceSize, min_alignment()));
   49.31 -  }
   49.32 +  MetaspaceSize = restricted_align_down(MetaspaceSize, min_alignment());
   49.33  
   49.34    assert(MetaspaceSize <= MaxMetaspaceSize, "Must be");
   49.35  
   49.36 @@ -135,15 +137,8 @@
   49.37  
   49.38  GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
   49.39                                             int max_covered_regions) {
   49.40 -  switch (rem_set_name()) {
   49.41 -  case GenRemSet::CardTable: {
   49.42 -    CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions);
   49.43 -    return res;
   49.44 -  }
   49.45 -  default:
   49.46 -    guarantee(false, "unrecognized GenRemSet::Name");
   49.47 -    return NULL;
   49.48 -  }
   49.49 +  assert(rem_set_name() == GenRemSet::CardTable, "unrecognized GenRemSet::Name");
   49.50 +  return new CardTableRS(whole_heap, max_covered_regions);
   49.51  }
   49.52  
   49.53  void CollectorPolicy::cleared_all_soft_refs() {

    50.1 --- a/src/share/vm/memory/genRemSet.cpp	Sat Oct 05 03:14:53 2013 +0200
    50.2 +++ b/src/share/vm/memory/genRemSet.cpp	Fri Oct 04 21:00:43 2013 -0700
    50.3 @@ -32,13 +32,8 @@
    50.4  // enumeration.)
    50.5  
    50.6  uintx GenRemSet::max_alignment_constraint(Name nm) {
    50.7 -  switch (nm) {
    50.8 -  case GenRemSet::CardTable:
    50.9 -    return CardTableRS::ct_max_alignment_constraint();
   50.10 -  default:
   50.11 -    guarantee(false, "Unrecognized GenRemSet type.");
   50.12 -    return (0); // Make Windows compiler happy
   50.13 -  }
   50.14 +  assert(nm == GenRemSet::CardTable, "Unrecognized GenRemSet type.");
   50.15 +  return CardTableRS::ct_max_alignment_constraint();
   50.16  }
   50.17  
   50.18  class HasAccumulatedModifiedOopsClosure : public KlassClosure {

    51.1 --- a/src/share/vm/memory/metaspace.cpp	Sat Oct 05 03:14:53 2013 +0200
    51.2 +++ b/src/share/vm/memory/metaspace.cpp	Fri Oct 04 21:00:43 2013 -0700
    51.3 @@ -3104,7 +3104,7 @@
    51.4  MetaWord* Metaspace::allocate(size_t word_size, MetadataType mdtype) {
    51.5    // DumpSharedSpaces doesn't use class metadata area (yet)
    51.6    // Also, don't use class_vsm() unless UseCompressedClassPointers is true.
    51.7 -  if (mdtype == ClassType && using_class_space()) {
    51.8 +  if (is_class_space_allocation(mdtype)) {
    51.9      return  class_vsm()->allocate(word_size);
   51.10    } else {
   51.11      return  vsm()->allocate(word_size);
   51.12 @@ -3252,8 +3252,8 @@
   51.13          MetaspaceAux::dump(gclog_or_tty);
   51.14        }
   51.15        // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
   51.16 -      const char* space_string = (mdtype == ClassType) ? "Compressed class space" :
   51.17 -                                                         "Metadata space";
   51.18 +      const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
   51.19 +                                                                     "Metadata space";
   51.20        report_java_out_of_memory(space_string);
   51.21  
   51.22        if (JvmtiExport::should_post_resource_exhausted()) {
   51.23 @@ -3261,7 +3261,7 @@
   51.24              JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
   51.25              space_string);
   51.26        }
   51.27 -      if (mdtype == ClassType) {
   51.28 +      if (is_class_space_allocation(mdtype)) {
   51.29          THROW_OOP_0(Universe::out_of_memory_error_class_metaspace());
   51.30        } else {
   51.31          THROW_OOP_0(Universe::out_of_memory_error_metaspace());

    52.1 --- a/src/share/vm/memory/metaspace.hpp	Sat Oct 05 03:14:53 2013 +0200
    52.2 +++ b/src/share/vm/memory/metaspace.hpp	Fri Oct 04 21:00:43 2013 -0700
    52.3 @@ -235,6 +235,9 @@
    52.4      return NOT_LP64(false) LP64_ONLY(UseCompressedClassPointers && !DumpSharedSpaces);
    52.5    }
    52.6  
    52.7 +  static bool is_class_space_allocation(MetadataType mdType) {
    52.8 +    return mdType == ClassType && using_class_space();
    52.9 +  }
   52.10  };
   52.11  
   52.12  class MetaspaceAux : AllStatic {

    53.1 --- a/src/share/vm/oops/method.cpp	Sat Oct 05 03:14:53 2013 +0200
    53.2 +++ b/src/share/vm/oops/method.cpp	Fri Oct 04 21:00:43 2013 -0700
    53.3 @@ -901,16 +901,6 @@
    53.4  // This function must not hit a safepoint!
    53.5  address Method::verified_code_entry() {
    53.6    debug_only(No_Safepoint_Verifier nsv;)
    53.7 -  nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);
    53.8 -  if (code == NULL && UseCodeCacheFlushing) {
    53.9 -    nmethod *saved_code = CodeCache::reanimate_saved_code(this);
   53.10 -    if (saved_code != NULL) {
   53.11 -      methodHandle method(this);
   53.12 -      assert( ! saved_code->is_osr_method(), "should not get here for osr" );
   53.13 -      set_code( method, saved_code );
   53.14 -    }
   53.15 -  }
   53.16 -
   53.17    assert(_from_compiled_entry != NULL, "must be set");
   53.18    return _from_compiled_entry;
   53.19  }

    54.1 --- a/src/share/vm/opto/c2_globals.hpp	Sat Oct 05 03:14:53 2013 +0200
    54.2 +++ b/src/share/vm/opto/c2_globals.hpp	Fri Oct 04 21:00:43 2013 -0700
    54.3 @@ -636,7 +636,9 @@
    54.4                                                                              \
    54.5    diagnostic(bool, OptimizeExpensiveOps, true,                              \
    54.6            "Find best control for expensive operations")                     \
    54.7 -
    54.8 +                                                                            \
    54.9 +  product(bool, UseMathExactIntrinsics, true,                               \
   54.10 +          "Enables intrinsification of various java.lang.Math funcitons")
   54.11  
   54.12  C2_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG)
   54.13  

    55.1 --- a/src/share/vm/opto/callGenerator.hpp	Sat Oct 05 03:14:53 2013 +0200
    55.2 +++ b/src/share/vm/opto/callGenerator.hpp	Fri Oct 04 21:00:43 2013 -0700
    55.3 @@ -65,6 +65,8 @@
    55.4    virtual bool      is_predicted() const        { return false; }
    55.5    // is_trap: Does not return to the caller.  (E.g., uncommon trap.)
    55.6    virtual bool      is_trap() const             { return false; }
    55.7 +  // does_virtual_dispatch: Should try inlining as normal method first.
    55.8 +  virtual bool      does_virtual_dispatch() const     { return false; }
    55.9  
   55.10    // is_late_inline: supports conversion of call into an inline
   55.11    virtual bool      is_late_inline() const      { return false; }

    56.1 --- a/src/share/vm/opto/classes.cpp	Sat Oct 05 03:14:53 2013 +0200
    56.2 +++ b/src/share/vm/opto/classes.cpp	Fri Oct 04 21:00:43 2013 -0700
    56.3 @@ -32,6 +32,7 @@
    56.4  #include "opto/loopnode.hpp"
    56.5  #include "opto/machnode.hpp"
    56.6  #include "opto/memnode.hpp"
    56.7 +#include "opto/mathexactnode.hpp"
    56.8  #include "opto/mulnode.hpp"
    56.9  #include "opto/multnode.hpp"
   56.10  #include "opto/node.hpp"

    57.1 --- a/src/share/vm/opto/classes.hpp	Sat Oct 05 03:14:53 2013 +0200
    57.2 +++ b/src/share/vm/opto/classes.hpp	Fri Oct 04 21:00:43 2013 -0700
    57.3 @@ -29,6 +29,7 @@
    57.4  macro(AbsF)
    57.5  macro(AbsI)
    57.6  macro(AddD)
    57.7 +macro(AddExactI)
    57.8  macro(AddF)
    57.9  macro(AddI)
   57.10  macro(AddL)
   57.11 @@ -133,6 +134,7 @@
   57.12  macro(ExpD)
   57.13  macro(FastLock)
   57.14  macro(FastUnlock)
   57.15 +macro(FlagsProj)
   57.16  macro(Goto)
   57.17  macro(Halt)
   57.18  macro(If)
   57.19 @@ -167,6 +169,7 @@
   57.20  macro(LoopLimit)
   57.21  macro(Mach)
   57.22  macro(MachProj)
   57.23 +macro(MathExact)
   57.24  macro(MaxI)
   57.25  macro(MemBarAcquire)
   57.26  macro(MemBarAcquireLock)

    58.1 --- a/src/share/vm/opto/doCall.cpp	Sat Oct 05 03:14:53 2013 +0200
    58.2 +++ b/src/share/vm/opto/doCall.cpp	Fri Oct 04 21:00:43 2013 -0700
    58.3 @@ -110,6 +110,7 @@
    58.4    // then we return it as the inlined version of the call.
    58.5    // We do this before the strict f.p. check below because the
    58.6    // intrinsics handle strict f.p. correctly.
    58.7 +  CallGenerator* cg_intrinsic = NULL;
    58.8    if (allow_inline && allow_intrinsics) {
    58.9      CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
   58.10      if (cg != NULL) {
   58.11 @@ -121,7 +122,16 @@
   58.12            cg = CallGenerator::for_predicted_intrinsic(cg, inline_cg);
   58.13          }
   58.14        }
   58.15 -      return cg;
   58.16 +
   58.17 +      // If intrinsic does the virtual dispatch, we try to use the type profile
   58.18 +      // first, and hopefully inline it as the regular virtual call below.
   58.19 +      // We will retry the intrinsic if nothing had claimed it afterwards.
   58.20 +      if (cg->does_virtual_dispatch()) {
   58.21 +        cg_intrinsic = cg;
   58.22 +        cg = NULL;
   58.23 +      } else {
   58.24 +        return cg;
   58.25 +      }
   58.26      }
   58.27    }
   58.28  
   58.29 @@ -266,6 +276,13 @@
   58.30      }
   58.31    }
   58.32  
   58.33 +  // Nothing claimed the intrinsic, we go with straight-forward inlining
   58.34 +  // for already discovered intrinsic.
   58.35 +  if (allow_inline && allow_intrinsics && cg_intrinsic != NULL) {
   58.36 +    assert(cg_intrinsic->does_virtual_dispatch(), "sanity");
   58.37 +    return cg_intrinsic;
   58.38 +  }
   58.39 +
   58.40    // There was no special inlining tactic, or it bailed out.
   58.41    // Use a more generic tactic, like a simple call.
   58.42    if (call_does_dispatch) {

    59.1 --- a/src/share/vm/opto/graphKit.cpp	Sat Oct 05 03:14:53 2013 +0200
    59.2 +++ b/src/share/vm/opto/graphKit.cpp	Fri Oct 04 21:00:43 2013 -0700
    59.3 @@ -3849,9 +3849,9 @@
    59.4    const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
    59.5                                                       false, NULL, 0);
    59.6    const TypePtr* value_field_type = string_type->add_offset(value_offset);
    59.7 -  int value_field_idx = C->get_alias_index(value_field_type);
    59.8 -  store_to_memory(ctrl, basic_plus_adr(str, value_offset),
    59.9 -                  value, T_OBJECT, value_field_idx);
   59.10 +
   59.11 +  store_oop_to_object(ctrl, str,  basic_plus_adr(str, value_offset), value_field_type,
   59.12 +      value, TypeAryPtr::CHARS, T_OBJECT);
   59.13  }
   59.14  
   59.15  void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) {

    60.1 --- a/src/share/vm/opto/ifnode.cpp	Sat Oct 05 03:14:53 2013 +0200
    60.2 +++ b/src/share/vm/opto/ifnode.cpp	Fri Oct 04 21:00:43 2013 -0700
    60.3 @@ -76,6 +76,7 @@
    60.4    if( !i1->is_Bool() ) return NULL;
    60.5    BoolNode *b = i1->as_Bool();
    60.6    Node *cmp = b->in(1);
    60.7 +  if( cmp->is_FlagsProj() ) return NULL;
    60.8    if( !cmp->is_Cmp() ) return NULL;
    60.9    i1 = cmp->in(1);
   60.10    if( i1 == NULL || !i1->is_Phi() ) return NULL;

    61.1 --- a/src/share/vm/opto/lcm.cpp	Sat Oct 05 03:14:53 2013 +0200
    61.2 +++ b/src/share/vm/opto/lcm.cpp	Fri Oct 04 21:00:43 2013 -0700
    61.3 @@ -472,6 +472,13 @@
    61.4            break;
    61.5          }
    61.6  
    61.7 +        // For nodes that produce a FlagsProj, make the node adjacent to the
    61.8 +        // use of the FlagsProj
    61.9 +        if (use->is_FlagsProj() && get_block_for_node(use) == block) {
   61.10 +          found_machif = true;
   61.11 +          break;
   61.12 +        }
   61.13 +
   61.14          // More than this instruction pending for successor to be ready,
   61.15          // don't choose this if other opportunities are ready
   61.16          if (ready_cnt.at(use->_idx) > 1)

    62.1 --- a/src/share/vm/opto/library_call.cpp	Sat Oct 05 03:14:53 2013 +0200
    62.2 +++ b/src/share/vm/opto/library_call.cpp	Fri Oct 04 21:00:43 2013 -0700
    62.3 @@ -32,6 +32,7 @@
    62.4  #include "opto/callGenerator.hpp"
    62.5  #include "opto/cfgnode.hpp"
    62.6  #include "opto/idealKit.hpp"
    62.7 +#include "opto/mathexactnode.hpp"
    62.8  #include "opto/mulnode.hpp"
    62.9  #include "opto/parse.hpp"
   62.10  #include "opto/runtime.hpp"
   62.11 @@ -46,19 +47,22 @@
   62.12   private:
   62.13    bool             _is_virtual;
   62.14    bool             _is_predicted;
   62.15 +  bool             _does_virtual_dispatch;
   62.16    vmIntrinsics::ID _intrinsic_id;
   62.17  
   62.18   public:
   62.19 -  LibraryIntrinsic(ciMethod* m, bool is_virtual, bool is_predicted, vmIntrinsics::ID id)
   62.20 +  LibraryIntrinsic(ciMethod* m, bool is_virtual, bool is_predicted, bool does_virtual_dispatch, vmIntrinsics::ID id)
   62.21      : InlineCallGenerator(m),
   62.22        _is_virtual(is_virtual),
   62.23        _is_predicted(is_predicted),
   62.24 +      _does_virtual_dispatch(does_virtual_dispatch),
   62.25        _intrinsic_id(id)
   62.26    {
   62.27    }
   62.28    virtual bool is_intrinsic() const { return true; }
   62.29    virtual bool is_virtual()   const { return _is_virtual; }
   62.30    virtual bool is_predicted()   const { return _is_predicted; }
   62.31 +  virtual bool does_virtual_dispatch()   const { return _does_virtual_dispatch; }
   62.32    virtual JVMState* generate(JVMState* jvms);
   62.33    virtual Node* generate_predicate(JVMState* jvms);
   62.34    vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }
   62.35 @@ -199,6 +203,8 @@
   62.36    bool inline_math_native(vmIntrinsics::ID id);
   62.37    bool inline_trig(vmIntrinsics::ID id);
   62.38    bool inline_math(vmIntrinsics::ID id);
   62.39 +  bool inline_math_mathExact(Node* math);
   62.40 +  bool inline_math_addExact();
   62.41    bool inline_exp();
   62.42    bool inline_pow();
   62.43    void finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
   62.44 @@ -352,6 +358,7 @@
   62.45    }
   62.46  
   62.47    bool is_predicted = false;
   62.48 +  bool does_virtual_dispatch = false;
   62.49  
   62.50    switch (id) {
   62.51    case vmIntrinsics::_compareTo:
   62.52 @@ -378,8 +385,10 @@
   62.53      break;
   62.54    case vmIntrinsics::_hashCode:
   62.55      if (!InlineObjectHash)  return NULL;
   62.56 +    does_virtual_dispatch = true;
   62.57      break;
   62.58    case vmIntrinsics::_clone:
   62.59 +    does_virtual_dispatch = true;
   62.60    case vmIntrinsics::_copyOf:
   62.61    case vmIntrinsics::_copyOfRange:
   62.62      if (!InlineObjectCopy)  return NULL;
   62.63 @@ -498,6 +507,15 @@
   62.64      if (!UseCRC32Intrinsics) return NULL;
   62.65      break;
   62.66  
   62.67 +  case vmIntrinsics::_addExact:
   62.68 +    if (!Matcher::match_rule_supported(Op_AddExactI)) {
   62.69 +      return NULL;
   62.70 +    }
   62.71 +    if (!UseMathExactIntrinsics) {
   62.72 +      return NULL;
   62.73 +    }
   62.74 +    break;
   62.75 +
   62.76   default:
   62.77      assert(id <= vmIntrinsics::LAST_COMPILER_INLINE, "caller responsibility");
   62.78      assert(id != vmIntrinsics::_Object_init && id != vmIntrinsics::_invoke, "enum out of order?");
   62.79 @@ -529,7 +547,7 @@
   62.80      if (!InlineUnsafeOps)  return NULL;
   62.81    }
   62.82  
   62.83 -  return new LibraryIntrinsic(m, is_virtual, is_predicted, (vmIntrinsics::ID) id);
   62.84 +  return new LibraryIntrinsic(m, is_virtual, is_predicted, does_virtual_dispatch, (vmIntrinsics::ID) id);
   62.85  }
   62.86  
   62.87  //----------------------register_library_intrinsics-----------------------
   62.88 @@ -668,6 +686,8 @@
   62.89    case vmIntrinsics::_min:
   62.90    case vmIntrinsics::_max:                      return inline_min_max(intrinsic_id());
   62.91  
   62.92 +  case vmIntrinsics::_addExact:                 return inline_math_addExact();
   62.93 +
   62.94    case vmIntrinsics::_arraycopy:                return inline_arraycopy();
   62.95  
   62.96    case vmIntrinsics::_compareTo:                return inline_string_compareTo();
   62.97 @@ -1911,6 +1931,45 @@
   62.98    return true;
   62.99  }
  62.100  
  62.101 +bool LibraryCallKit::inline_math_mathExact(Node* math) {
  62.102 +  Node* result = _gvn.transform( new(C) ProjNode(math, MathExactNode::result_proj_node));
  62.103 +  Node* flags = _gvn.transform( new(C) FlagsProjNode(math, MathExactNode::flags_proj_node));
  62.104 +
  62.105 +  Node* bol = _gvn.transform( new (C) BoolNode(flags, BoolTest::overflow) );
  62.106 +  IfNode* check = create_and_map_if(control(), bol, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
  62.107 +  Node* fast_path = _gvn.transform( new (C) IfFalseNode(check));
  62.108 +  Node* slow_path = _gvn.transform( new (C) IfTrueNode(check) );
  62.109 +
  62.110 +  {
  62.111 +    PreserveJVMState pjvms(this);
  62.112 +    PreserveReexecuteState preexecs(this);
  62.113 +    jvms()->set_should_reexecute(true);
  62.114 +
  62.115 +    set_control(slow_path);
  62.116 +    set_i_o(i_o());
  62.117 +
  62.118 +    uncommon_trap(Deoptimization::Reason_intrinsic,
  62.119 +                  Deoptimization::Action_none);
  62.120 +  }
  62.121 +
  62.122 +  set_control(fast_path);
  62.123 +  set_result(result);
  62.124 +  return true;
  62.125 +}
  62.126 +
  62.127 +bool LibraryCallKit::inline_math_addExact() {
  62.128 +  Node* arg1 = argument(0);
  62.129 +  Node* arg2 = argument(1);
  62.130 +
  62.131 +  Node* add = _gvn.transform( new(C) AddExactINode(NULL, arg1, arg2) );
  62.132 +  if (add->Opcode() == Op_AddExactI) {
  62.133 +    return inline_math_mathExact(add);
  62.134 +  } else {
  62.135 +    set_result(add);
  62.136 +  }
  62.137 +  return true;
  62.138 +}
  62.139 +
  62.140  Node*
  62.141  LibraryCallKit::generate_min_max(vmIntrinsics::ID id, Node* x0, Node* y0) {
  62.142    // These are the candidate return value:

    63.1 --- a/src/share/vm/opto/loopTransform.cpp	Sat Oct 05 03:14:53 2013 +0200
    63.2 +++ b/src/share/vm/opto/loopTransform.cpp	Fri Oct 04 21:00:43 2013 -0700
    63.3 @@ -776,6 +776,9 @@
    63.4          continue; // not RC
    63.5  
    63.6        Node *cmp = bol->in(1);
    63.7 +      if (cmp->is_FlagsProj()) {
    63.8 +        continue;
    63.9 +      }
   63.10  
   63.11        Node *rc_exp = cmp->in(1);
   63.12        Node *limit = cmp->in(2);

    64.1 --- a/src/share/vm/opto/loopopts.cpp	Sat Oct 05 03:14:53 2013 +0200
    64.2 +++ b/src/share/vm/opto/loopopts.cpp	Fri Oct 04 21:00:43 2013 -0700
    64.3 @@ -2355,7 +2355,8 @@
    64.4          opc == Op_Catch     ||
    64.5          opc == Op_CatchProj ||
    64.6          opc == Op_Jump      ||
    64.7 -        opc == Op_JumpProj) {
    64.8 +        opc == Op_JumpProj  ||
    64.9 +        opc == Op_FlagsProj) {
   64.10  #if !defined(PRODUCT)
   64.11        if (TracePartialPeeling) {
   64.12          tty->print_cr("\nExit control too complex: lp: %d", head->_idx);

    65.1 --- a/src/share/vm/opto/matcher.cpp	Sat Oct 05 03:14:53 2013 +0200
    65.2 +++ b/src/share/vm/opto/matcher.cpp	Fri Oct 04 21:00:43 2013 -0700
    65.3 @@ -1964,6 +1964,7 @@
    65.4        case Op_Catch:
    65.5        case Op_CatchProj:
    65.6        case Op_CProj:
    65.7 +      case Op_FlagsProj:
    65.8        case Op_JumpProj:
    65.9        case Op_JProj:
   65.10        case Op_NeverBranch:

    66.1 --- a/src/share/vm/opto/matcher.hpp	Sat Oct 05 03:14:53 2013 +0200
    66.2 +++ b/src/share/vm/opto/matcher.hpp	Fri Oct 04 21:00:43 2013 -0700
    66.3 @@ -337,6 +337,9 @@
    66.4    // Register for MODL projection of divmodL
    66.5    static RegMask modL_proj_mask();
    66.6  
    66.7 +  static const RegMask mathExactI_result_proj_mask();
    66.8 +  static const RegMask mathExactI_flags_proj_mask();
    66.9 +
   66.10    // Use hardware DIV instruction when it is faster than
   66.11    // a code which use multiply for division by constant.
   66.12    static bool use_asm_for_ldiv_by_con( jlong divisor );

    67.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    67.2 +++ b/src/share/vm/opto/mathexactnode.cpp	Fri Oct 04 21:00:43 2013 -0700
    67.3 @@ -0,0 +1,143 @@
    67.4 +/*
    67.5 + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
    67.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    67.7 + *
    67.8 + * This code is free software; you can redistribute it and/or modify it
    67.9 + * under the terms of the GNU General Public License version 2 only, as
   67.10 + * published by the Free Software Foundation.
   67.11 + *
   67.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
   67.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   67.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   67.15 + * version 2 for more details (a copy is included in the LICENSE file that
   67.16 + * accompanied this code).
   67.17 + *
   67.18 + * You should have received a copy of the GNU General Public License version
   67.19 + * 2 along with this work; if not, write to the Free Software Foundation,
   67.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   67.21 + *
   67.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   67.23 + * or visit www.oracle.com if you need additional information or have any
   67.24 + * questions.
   67.25 + *
   67.26 + */
   67.27 +
   67.28 +#include "precompiled.hpp"
   67.29 +#include "memory/allocation.inline.hpp"
   67.30 +#include "opto/addnode.hpp"
   67.31 +#include "opto/machnode.hpp"
   67.32 +#include "opto/mathexactnode.hpp"
   67.33 +#include "opto/matcher.hpp"
   67.34 +#include "opto/subnode.hpp"
   67.35 +
   67.36 +MathExactNode::MathExactNode(Node* ctrl, Node* n1, Node* n2) : MultiNode(3) {
   67.37 +  init_req(0, ctrl);
   67.38 +  init_req(1, n1);
   67.39 +  init_req(2, n2);
   67.40 +}
   67.41 +
   67.42 +Node* AddExactINode::match(const ProjNode* proj, const Matcher* m) {
   67.43 +  uint ideal_reg = proj->ideal_reg();
   67.44 +  RegMask rm;
   67.45 +  if (proj->_con == result_proj_node) {
   67.46 +    rm = m->mathExactI_result_proj_mask();
   67.47 +  } else {
   67.48 +    assert(proj->_con == flags_proj_node, "must be result or flags");
   67.49 +    assert(ideal_reg == Op_RegFlags, "sanity");
   67.50 +    rm = m->mathExactI_flags_proj_mask();
   67.51 +  }
   67.52 +  return new (m->C) MachProjNode(this, proj->_con, rm, ideal_reg);
   67.53 +}
   67.54 +
   67.55 +// If the MathExactNode won't overflow we have to replace the
   67.56 +// FlagsProjNode and ProjNode that is generated by the MathExactNode
   67.57 +Node* MathExactNode::no_overflow(PhaseGVN *phase, Node* new_result) {
   67.58 +  PhaseIterGVN *igvn = phase->is_IterGVN();
   67.59 +  if (igvn) {
   67.60 +    ProjNode* result = result_node();
   67.61 +    ProjNode* flags = flags_node();
   67.62 +
   67.63 +    if (result != NULL) {
   67.64 +      igvn->replace_node(result, new_result);
   67.65 +    }
   67.66 +
   67.67 +    if (flags != NULL) {
   67.68 +      BoolNode* bolnode = (BoolNode *) flags->unique_out();
   67.69 +      switch (bolnode->_test._test) {
   67.70 +        case BoolTest::overflow:
   67.71 +          // if the check is for overflow - never taken
   67.72 +          igvn->replace_node(bolnode, phase->intcon(0));
   67.73 +          break;
   67.74 +        case BoolTest::no_overflow:
   67.75 +          // if the check is for no overflow - always taken
   67.76 +          igvn->replace_node(bolnode, phase->intcon(1));
   67.77 +          break;
   67.78 +        default:
   67.79 +          fatal("Unexpected value of BoolTest");
   67.80 +          break;
   67.81 +      }
   67.82 +      flags->del_req(0);
   67.83 +    }
   67.84 +  }
   67.85 +  return new_result;
   67.86 +}
   67.87 +
   67.88 +Node *AddExactINode::Ideal(PhaseGVN *phase, bool can_reshape) {
   67.89 +  Node *arg1 = in(1);
   67.90 +  Node *arg2 = in(2);
   67.91 +
   67.92 +  const Type* type1 = phase->type(arg1);
   67.93 +  const Type* type2 = phase->type(arg2);
   67.94 +
   67.95 +  if (type1 != Type::TOP && type1->singleton() &&
   67.96 +      type2 != Type::TOP && type2->singleton()) {
   67.97 +    jint val1 = arg1->get_int();
   67.98 +    jint val2 = arg2->get_int();
   67.99 +    jint result = val1 + val2;
  67.100 +    // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result
  67.101 +    if ( (((val1 ^ result) & (val2 ^ result)) >= 0)) {
  67.102 +      Node* con_result = ConINode::make(phase->C, result);
  67.103 +      return no_overflow(phase, con_result);
  67.104 +    }
  67.105 +    return NULL;
  67.106 +  }
  67.107 +
  67.108 +  if (type1 == TypeInt::ZERO) { // (Add 0 x) == x
  67.109 +    Node* add_result = new (phase->C) AddINode(arg1, arg2);
  67.110 +    return no_overflow(phase, add_result);
  67.111 +  }
  67.112 +
  67.113 +  if (type2 == TypeInt::ZERO) { // (Add x 0) == x
  67.114 +    Node* add_result = new (phase->C) AddINode(arg1, arg2);
  67.115 +    return no_overflow(phase, add_result);
  67.116 +  }
  67.117 +
  67.118 +  if (type2->singleton()) {
  67.119 +    return NULL; // no change - keep constant on the right
  67.120 +  }
  67.121 +
  67.122 +  if (type1->singleton()) {
  67.123 +    // Make it x + Constant - move constant to the right
  67.124 +    swap_edges(1, 2);
  67.125 +    return this;
  67.126 +  }
  67.127 +
  67.128 +  if (arg2->is_Load()) {
  67.129 +    return NULL; // no change - keep load on the right
  67.130 +  }
  67.131 +
  67.132 +  if (arg1->is_Load()) {
  67.133 +    // Make it x + Load - move load to the right
  67.134 +    swap_edges(1, 2);
  67.135 +    return this;
  67.136 +  }
  67.137 +
  67.138 +  if (arg1->_idx > arg2->_idx) {
  67.139 +    // Sort the edges
  67.140 +    swap_edges(1, 2);
  67.141 +    return this;
  67.142 +  }
  67.143 +
  67.144 +  return NULL;
  67.145 +}
  67.146 +

    68.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    68.2 +++ b/src/share/vm/opto/mathexactnode.hpp	Fri Oct 04 21:00:43 2013 -0700
    68.3 @@ -0,0 +1,81 @@
    68.4 +/*
    68.5 + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
    68.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    68.7 + *
    68.8 + * This code is free software; you can redistribute it and/or modify it
    68.9 + * under the terms of the GNU General Public License version 2 only, as
   68.10 + * published by the Free Software Foundation.
   68.11 + *
   68.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
   68.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   68.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   68.15 + * version 2 for more details (a copy is included in the LICENSE file that
   68.16 + * accompanied this code).
   68.17 + *
   68.18 + * You should have received a copy of the GNU General Public License version
   68.19 + * 2 along with this work; if not, write to the Free Software Foundation,
   68.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   68.21 + *
   68.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   68.23 + * or visit www.oracle.com if you need additional information or have any
   68.24 + * questions.
   68.25 + *
   68.26 + */
   68.27 +
   68.28 +#ifndef SHARE_VM_OPTO_MATHEXACTNODE_HPP
   68.29 +#define SHARE_VM_OPTO_MATHEXACTNODE_HPP
   68.30 +
   68.31 +#include "opto/multnode.hpp"
   68.32 +#include "opto/node.hpp"
   68.33 +#include "opto/type.hpp"
   68.34 +
   68.35 +class Node;
   68.36 +
   68.37 +class PhaseGVN;
   68.38 +class PhaseTransform;
   68.39 +
   68.40 +class MathExactNode : public MultiNode {
   68.41 +public:
   68.42 +  MathExactNode(Node* ctrl, Node* in1, Node* in2);
   68.43 +  enum {
   68.44 +    result_proj_node = 0,
   68.45 +    flags_proj_node = 1
   68.46 +  };
   68.47 +  virtual int Opcode() const;
   68.48 +  virtual Node* Identity(PhaseTransform* phase) { return this; }
   68.49 +  virtual Node* Ideal(PhaseGVN* phase, bool can_reshape) { return NULL; }
   68.50 +  virtual const Type* Value(PhaseTransform* phase) const { return bottom_type(); }
   68.51 +  virtual uint hash() const { return Node::hash(); }
   68.52 +  virtual bool is_CFG() const { return false; }
   68.53 +  virtual uint ideal_reg() const { return NotAMachineReg; }
   68.54 +
   68.55 +  ProjNode* result_node() { return proj_out(result_proj_node); }
   68.56 +  ProjNode* flags_node() { return proj_out(flags_proj_node); }
   68.57 +protected:
   68.58 +  Node* no_overflow(PhaseGVN *phase, Node* new_result);
   68.59 +};
   68.60 +
   68.61 +class AddExactINode : public MathExactNode {
   68.62 +public:
   68.63 +  AddExactINode(Node* ctrl, Node* in1, Node* in2) : MathExactNode(ctrl, in1, in2) {}
   68.64 +  virtual int Opcode() const;
   68.65 +  virtual const Type* bottom_type() const { return TypeTuple::INT_CC_PAIR; }
   68.66 +  virtual Node* match(const ProjNode* proj, const Matcher* m);
   68.67 +  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   68.68 +};
   68.69 +
   68.70 +class FlagsProjNode : public ProjNode {
   68.71 +public:
   68.72 +  FlagsProjNode(Node* src, uint con) : ProjNode(src, con) {
   68.73 +    init_class_id(Class_FlagsProj);
   68.74 +  }
   68.75 +
   68.76 +  virtual int Opcode() const;
   68.77 +  virtual bool is_CFG() const { return false; }
   68.78 +  virtual const Type* bottom_type() const { return TypeInt::CC; }
   68.79 +  virtual uint ideal_reg() const { return Op_RegFlags; }
   68.80 +};
   68.81 +
   68.82 +
   68.83 +#endif
   68.84 +

    69.1 --- a/src/share/vm/opto/multnode.cpp	Sat Oct 05 03:14:53 2013 +0200
    69.2 +++ b/src/share/vm/opto/multnode.cpp	Fri Oct 04 21:00:43 2013 -0700
    69.3 @@ -25,6 +25,7 @@
    69.4  #include "precompiled.hpp"
    69.5  #include "opto/callnode.hpp"
    69.6  #include "opto/matcher.hpp"
    69.7 +#include "opto/mathexactnode.hpp"
    69.8  #include "opto/multnode.hpp"
    69.9  #include "opto/opcodes.hpp"
   69.10  #include "opto/phaseX.hpp"
   69.11 @@ -46,15 +47,21 @@
   69.12    assert(Opcode() != Op_If || outcnt() == 2, "bad if #1");
   69.13    for( DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++ ) {
   69.14      Node *p = fast_out(i);
   69.15 -    if( !p->is_Proj() ) {
   69.16 +    if (p->is_Proj()) {
   69.17 +      ProjNode *proj = p->as_Proj();
   69.18 +      if (proj->_con == which_proj) {
   69.19 +        assert(Opcode() != Op_If || proj->Opcode() == (which_proj?Op_IfTrue:Op_IfFalse), "bad if #2");
   69.20 +        return proj;
   69.21 +      }
   69.22 +    } else if (p->is_FlagsProj()) {
   69.23 +      FlagsProjNode *proj = p->as_FlagsProj();
   69.24 +      if (proj->_con == which_proj) {
   69.25 +        return proj;
   69.26 +      }
   69.27 +    } else {
   69.28        assert(p == this && this->is_Start(), "else must be proj");
   69.29        continue;
   69.30      }
   69.31 -    ProjNode *proj = p->as_Proj();
   69.32 -    if( proj->_con == which_proj ) {
   69.33 -      assert(Opcode() != Op_If || proj->Opcode() == (which_proj?Op_IfTrue:Op_IfFalse), "bad if #2");
   69.34 -      return proj;
   69.35 -    }
   69.36    }
   69.37    return NULL;
   69.38  }

    70.1 --- a/src/share/vm/opto/node.hpp	Sat Oct 05 03:14:53 2013 +0200
    70.2 +++ b/src/share/vm/opto/node.hpp	Fri Oct 04 21:00:43 2013 -0700
    70.3 @@ -69,6 +69,7 @@
    70.4  class EncodePKlassNode;
    70.5  class FastLockNode;
    70.6  class FastUnlockNode;
    70.7 +class FlagsProjNode;
    70.8  class IfNode;
    70.9  class IfFalseNode;
   70.10  class IfTrueNode;
   70.11 @@ -623,6 +624,7 @@
   70.12        DEFINE_CLASS_ID(Cmp,   Sub, 0)
   70.13          DEFINE_CLASS_ID(FastLock,   Cmp, 0)
   70.14          DEFINE_CLASS_ID(FastUnlock, Cmp, 1)
   70.15 +        DEFINE_CLASS_ID(FlagsProj, Cmp, 2)
   70.16  
   70.17      DEFINE_CLASS_ID(MergeMem, Node, 7)
   70.18      DEFINE_CLASS_ID(Bool,     Node, 8)
   70.19 @@ -726,6 +728,7 @@
   70.20    DEFINE_CLASS_QUERY(EncodePKlass)
   70.21    DEFINE_CLASS_QUERY(FastLock)
   70.22    DEFINE_CLASS_QUERY(FastUnlock)
   70.23 +  DEFINE_CLASS_QUERY(FlagsProj)
   70.24    DEFINE_CLASS_QUERY(If)
   70.25    DEFINE_CLASS_QUERY(IfFalse)
   70.26    DEFINE_CLASS_QUERY(IfTrue)

    71.1 --- a/src/share/vm/opto/subnode.cpp	Sat Oct 05 03:14:53 2013 +0200
    71.2 +++ b/src/share/vm/opto/subnode.cpp	Fri Oct 04 21:00:43 2013 -0700
    71.3 @@ -1064,7 +1064,7 @@
    71.4  // Print special per-node info
    71.5  #ifndef PRODUCT
    71.6  void BoolTest::dump_on(outputStream *st) const {
    71.7 -  const char *msg[] = {"eq","gt","??","lt","ne","le","??","ge"};
    71.8 +  const char *msg[] = {"eq","gt","of","lt","ne","le","nof","ge"};
    71.9    st->print(msg[_test]);
   71.10  }
   71.11  #endif
   71.12 @@ -1126,7 +1126,7 @@
   71.13    Node *cmp = in(1);
   71.14    if( !cmp->is_Sub() ) return NULL;
   71.15    int cop = cmp->Opcode();
   71.16 -  if( cop == Op_FastLock || cop == Op_FastUnlock ) return NULL;
   71.17 +  if( cop == Op_FastLock || cop == Op_FastUnlock || cop == Op_FlagsProj) return NULL;
   71.18    Node *cmp1 = cmp->in(1);
   71.19    Node *cmp2 = cmp->in(2);
   71.20    if( !cmp1 ) return NULL;

    72.1 --- a/src/share/vm/opto/subnode.hpp	Sat Oct 05 03:14:53 2013 +0200
    72.2 +++ b/src/share/vm/opto/subnode.hpp	Fri Oct 04 21:00:43 2013 -0700
    72.3 @@ -263,16 +263,16 @@
    72.4  // We pick the values as 3 bits; the low order 2 bits we compare against the
    72.5  // condition codes, the high bit flips the sense of the result.
    72.6  struct BoolTest VALUE_OBJ_CLASS_SPEC {
    72.7 -  enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, illegal = 8 };
    72.8 +  enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, illegal = 8 };
    72.9    mask _test;
   72.10    BoolTest( mask btm ) : _test(btm) {}
   72.11    const Type *cc2logical( const Type *CC ) const;
   72.12    // Commute the test.  I use a small table lookup.  The table is created as
   72.13    // a simple char array where each element is the ASCII version of a 'mask'
   72.14    // enum from above.
   72.15 -  mask commute( ) const { return mask("038147858"[_test]-'0'); }
   72.16 +  mask commute( ) const { return mask("032147658"[_test]-'0'); }
   72.17    mask negate( ) const { return mask(_test^4); }
   72.18 -  bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le); }
   72.19 +  bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); }
   72.20  #ifndef PRODUCT
   72.21    void dump_on(outputStream *st) const;
   72.22  #endif

    73.1 --- a/src/share/vm/opto/type.cpp	Sat Oct 05 03:14:53 2013 +0200
    73.2 +++ b/src/share/vm/opto/type.cpp	Fri Oct 04 21:00:43 2013 -0700
    73.3 @@ -430,6 +430,11 @@
    73.4    longpair[1] = TypeLong::LONG;
    73.5    TypeTuple::LONG_PAIR = TypeTuple::make(2, longpair);
    73.6  
    73.7 +  const Type **intccpair = TypeTuple::fields(2);
    73.8 +  intccpair[0] = TypeInt::INT;
    73.9 +  intccpair[1] = TypeInt::CC;
   73.10 +  TypeTuple::INT_CC_PAIR = TypeTuple::make(2, intccpair);
   73.11 +
   73.12    _const_basic_type[T_NARROWOOP]   = TypeNarrowOop::BOTTOM;
   73.13    _const_basic_type[T_NARROWKLASS] = Type::BOTTOM;
   73.14    _const_basic_type[T_BOOLEAN]     = TypeInt::BOOL;
   73.15 @@ -1646,6 +1651,7 @@
   73.16  const TypeTuple *TypeTuple::START_I2C;
   73.17  const TypeTuple *TypeTuple::INT_PAIR;
   73.18  const TypeTuple *TypeTuple::LONG_PAIR;
   73.19 +const TypeTuple *TypeTuple::INT_CC_PAIR;
   73.20  
   73.21  
   73.22  //------------------------------make-------------------------------------------

    74.1 --- a/src/share/vm/opto/type.hpp	Sat Oct 05 03:14:53 2013 +0200
    74.2 +++ b/src/share/vm/opto/type.hpp	Fri Oct 04 21:00:43 2013 -0700
    74.3 @@ -584,6 +584,7 @@
    74.4    static const TypeTuple *START_I2C;
    74.5    static const TypeTuple *INT_PAIR;
    74.6    static const TypeTuple *LONG_PAIR;
    74.7 +  static const TypeTuple *INT_CC_PAIR;
    74.8  #ifndef PRODUCT
    74.9    virtual void dump2( Dict &d, uint, outputStream *st  ) const; // Specialized per-Type dumping
   74.10  #endif

    75.1 --- a/src/share/vm/prims/jvm.cpp	Sat Oct 05 03:14:53 2013 +0200
    75.2 +++ b/src/share/vm/prims/jvm.cpp	Fri Oct 04 21:00:43 2013 -0700
    75.3 @@ -3984,13 +3984,13 @@
    75.4  
    75.5  JVM_LEAF(jboolean, JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get))
    75.6    JVMWrapper("JVM_AccessBoolVMFlag");
    75.7 -  return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, INTERNAL);
    75.8 +  return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, Flag::INTERNAL);
    75.9  JVM_END
   75.10  
   75.11  JVM_LEAF(jboolean, JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get))
   75.12    JVMWrapper("JVM_AccessVMIntFlag");
   75.13    intx v;
   75.14 -  jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, INTERNAL);
   75.15 +  jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, Flag::INTERNAL);
   75.16    *value = (jint)v;
   75.17    return result;
   75.18  JVM_END

    76.1 --- a/src/share/vm/runtime/arguments.cpp	Sat Oct 05 03:14:53 2013 +0200
    76.2 +++ b/src/share/vm/runtime/arguments.cpp	Fri Oct 04 21:00:43 2013 -0700
    76.3 @@ -625,11 +625,11 @@
    76.4    }
    76.5  }
    76.6  
    76.7 -static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) {
    76.8 +static bool set_bool_flag(char* name, bool value, Flag::Flags origin) {
    76.9    return CommandLineFlags::boolAtPut(name, &value, origin);
   76.10  }
   76.11  
   76.12 -static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
   76.13 +static bool set_fp_numeric_flag(char* name, char* value, Flag::Flags origin) {
   76.14    double v;
   76.15    if (sscanf(value, "%lf", &v) != 1) {
   76.16      return false;
   76.17 @@ -641,7 +641,7 @@
   76.18    return false;
   76.19  }
   76.20  
   76.21 -static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
   76.22 +static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) {
   76.23    julong v;
   76.24    intx intx_v;
   76.25    bool is_neg = false;
   76.26 @@ -674,14 +674,14 @@
   76.27    return false;
   76.28  }
   76.29  
   76.30 -static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
   76.31 +static bool set_string_flag(char* name, const char* value, Flag::Flags origin) {
   76.32    if (!CommandLineFlags::ccstrAtPut(name, &value, origin))  return false;
   76.33    // Contract:  CommandLineFlags always returns a pointer that needs freeing.
   76.34    FREE_C_HEAP_ARRAY(char, value, mtInternal);
   76.35    return true;
   76.36  }
   76.37  
   76.38 -static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) {
   76.39 +static bool append_to_string_flag(char* name, const char* new_value, Flag::Flags origin) {
   76.40    const char* old_value = "";
   76.41    if (!CommandLineFlags::ccstrAt(name, &old_value))  return false;
   76.42    size_t old_len = old_value != NULL ? strlen(old_value) : 0;
   76.43 @@ -709,7 +709,7 @@
   76.44    return true;
   76.45  }
   76.46  
   76.47 -bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) {
   76.48 +bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
   76.49  
   76.50    // range of acceptable characters spelled out for portability reasons
   76.51  #define NAME_RANGE  "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
   76.52 @@ -850,7 +850,7 @@
   76.53  }
   76.54  
   76.55  bool Arguments::process_argument(const char* arg,
   76.56 -    jboolean ignore_unrecognized, FlagValueOrigin origin) {
   76.57 +    jboolean ignore_unrecognized, Flag::Flags origin) {
   76.58  
   76.59    JDK_Version since = JDK_Version();
   76.60  
   76.61 @@ -904,7 +904,7 @@
   76.62        jio_fprintf(defaultStream::error_stream(),
   76.63                    "Did you mean '%s%s%s'?\n",
   76.64                    (fuzzy_matched->is_bool()) ? "(+/-)" : "",
   76.65 -                  fuzzy_matched->name,
   76.66 +                  fuzzy_matched->_name,
   76.67                    (fuzzy_matched->is_bool()) ? "" : "=<value>");
   76.68      }
   76.69    }
   76.70 @@ -952,7 +952,7 @@
   76.71          // this allows a way to include spaces in string-valued options
   76.72          token[pos] = '\0';
   76.73          logOption(token);
   76.74 -        result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
   76.75 +        result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE);
   76.76          build_jvm_flags(token);
   76.77          pos = 0;
   76.78          in_white_space = true;
   76.79 @@ -970,7 +970,7 @@
   76.80    }
   76.81    if (pos > 0) {
   76.82      token[pos] = '\0';
   76.83 -    result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
   76.84 +    result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE);
   76.85      build_jvm_flags(token);
   76.86    }
   76.87    fclose(stream);
   76.88 @@ -1132,6 +1132,9 @@
   76.89      Tier3InvokeNotifyFreqLog = 0;
   76.90      Tier4InvocationThreshold = 0;
   76.91    }
   76.92 +  if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
   76.93 +    FLAG_SET_DEFAULT(NmethodSweepFraction, 1 + ReservedCodeCacheSize / (16 * M));
   76.94 +  }
   76.95  }
   76.96  
   76.97  #if INCLUDE_ALL_GCS
   76.98 @@ -2337,6 +2340,10 @@
   76.99                  (2*G)/M);
  76.100      status = false;
  76.101    }
  76.102 +
  76.103 +  status &= verify_interval(NmethodSweepFraction, 1, ReservedCodeCacheSize/K, "NmethodSweepFraction");
  76.104 +  status &= verify_interval(NmethodSweepActivity, 0, 2000, "NmethodSweepActivity");
  76.105 +
  76.106    return status;
  76.107  }
  76.108  
  76.109 @@ -2438,7 +2445,7 @@
  76.110    }
  76.111  
  76.112    // Parse JavaVMInitArgs structure passed in
  76.113 -  result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE);
  76.114 +  result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, Flag::COMMAND_LINE);
  76.115    if (result != JNI_OK) {
  76.116      return result;
  76.117    }
  76.118 @@ -2510,7 +2517,7 @@
  76.119  jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args,
  76.120                                         SysClassPath* scp_p,
  76.121                                         bool* scp_assembly_required_p,
  76.122 -                                       FlagValueOrigin origin) {
  76.123 +                                       Flag::Flags origin) {
  76.124    // Remaining part of option string
  76.125    const char* tail;
  76.126  
  76.127 @@ -3333,7 +3340,7 @@
  76.128        }
  76.129      }
  76.130  
  76.131 -    return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR));
  76.132 +    return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, Flag::ENVIRON_VAR));
  76.133    }
  76.134    return JNI_OK;
  76.135  }

    77.1 --- a/src/share/vm/runtime/arguments.hpp	Sat Oct 05 03:14:53 2013 +0200
    77.2 +++ b/src/share/vm/runtime/arguments.hpp	Fri Oct 04 21:00:43 2013 -0700
    77.3 @@ -360,15 +360,15 @@
    77.4  
    77.5    // Argument parsing
    77.6    static void do_pd_flag_adjustments();
    77.7 -  static bool parse_argument(const char* arg, FlagValueOrigin origin);
    77.8 -  static bool process_argument(const char* arg, jboolean ignore_unrecognized, FlagValueOrigin origin);
    77.9 +  static bool parse_argument(const char* arg, Flag::Flags origin);
   77.10 +  static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin);
   77.11    static void process_java_launcher_argument(const char*, void*);
   77.12    static void process_java_compiler_argument(char* arg);
   77.13    static jint parse_options_environment_variable(const char* name, SysClassPath* scp_p, bool* scp_assembly_required_p);
   77.14    static jint parse_java_tool_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p);
   77.15    static jint parse_java_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p);
   77.16    static jint parse_vm_init_args(const JavaVMInitArgs* args);
   77.17 -  static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, SysClassPath* scp_p, bool* scp_assembly_required_p, FlagValueOrigin origin);
   77.18 +  static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, SysClassPath* scp_p, bool* scp_assembly_required_p, Flag::Flags origin);
   77.19    static jint finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required);
   77.20    static bool is_bad_option(const JavaVMOption* option, jboolean ignore,
   77.21      const char* option_type);

    78.1 --- a/src/share/vm/runtime/globals.cpp	Sat Oct 05 03:14:53 2013 +0200
    78.2 +++ b/src/share/vm/runtime/globals.cpp	Fri Oct 04 21:00:43 2013 -0700
    78.3 @@ -62,26 +62,174 @@
    78.4  MATERIALIZE_FLAGS_EXT
    78.5  
    78.6  
    78.7 +void Flag::check_writable() {
    78.8 +  if (is_constant_in_binary()) {
    78.9 +    fatal(err_msg("flag is constant: %s", _name));
   78.10 +  }
   78.11 +}
   78.12 +
   78.13 +bool Flag::is_bool() const {
   78.14 +  return strcmp(_type, "bool") == 0;
   78.15 +}
   78.16 +
   78.17 +bool Flag::get_bool() const {
   78.18 +  return *((bool*) _addr);
   78.19 +}
   78.20 +
   78.21 +void Flag::set_bool(bool value) {
   78.22 +  check_writable();
   78.23 +  *((bool*) _addr) = value;
   78.24 +}
   78.25 +
   78.26 +bool Flag::is_intx() const {
   78.27 +  return strcmp(_type, "intx")  == 0;
   78.28 +}
   78.29 +
   78.30 +intx Flag::get_intx() const {
   78.31 +  return *((intx*) _addr);
   78.32 +}
   78.33 +
   78.34 +void Flag::set_intx(intx value) {
   78.35 +  check_writable();
   78.36 +  *((intx*) _addr) = value;
   78.37 +}
   78.38 +
   78.39 +bool Flag::is_uintx() const {
   78.40 +  return strcmp(_type, "uintx") == 0;
   78.41 +}
   78.42 +
   78.43 +uintx Flag::get_uintx() const {
   78.44 +  return *((uintx*) _addr);
   78.45 +}
   78.46 +
   78.47 +void Flag::set_uintx(uintx value) {
   78.48 +  check_writable();
   78.49 +  *((uintx*) _addr) = value;
   78.50 +}
   78.51 +
   78.52 +bool Flag::is_uint64_t() const {
   78.53 +  return strcmp(_type, "uint64_t") == 0;
   78.54 +}
   78.55 +
   78.56 +uint64_t Flag::get_uint64_t() const {
   78.57 +  return *((uint64_t*) _addr);
   78.58 +}
   78.59 +
   78.60 +void Flag::set_uint64_t(uint64_t value) {
   78.61 +  check_writable();
   78.62 +  *((uint64_t*) _addr) = value;
   78.63 +}
   78.64 +
   78.65 +bool Flag::is_double() const {
   78.66 +  return strcmp(_type, "double") == 0;
   78.67 +}
   78.68 +
   78.69 +double Flag::get_double() const {
   78.70 +  return *((double*) _addr);
   78.71 +}
   78.72 +
   78.73 +void Flag::set_double(double value) {
   78.74 +  check_writable();
   78.75 +  *((double*) _addr) = value;
   78.76 +}
   78.77 +
   78.78 +bool Flag::is_ccstr() const {
   78.79 +  return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0;
   78.80 +}
   78.81 +
   78.82 +bool Flag::ccstr_accumulates() const {
   78.83 +  return strcmp(_type, "ccstrlist") == 0;
   78.84 +}
   78.85 +
   78.86 +ccstr Flag::get_ccstr() const {
   78.87 +  return *((ccstr*) _addr);
   78.88 +}
   78.89 +
   78.90 +void Flag::set_ccstr(ccstr value) {
   78.91 +  check_writable();
   78.92 +  *((ccstr*) _addr) = value;
   78.93 +}
   78.94 +
   78.95 +
   78.96 +Flag::Flags Flag::get_origin() {
   78.97 +  return Flags(_flags & VALUE_ORIGIN_MASK);
   78.98 +}
   78.99 +
  78.100 +void Flag::set_origin(Flags origin) {
  78.101 +  assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity");
  78.102 +  _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin);
  78.103 +}
  78.104 +
  78.105 +bool Flag::is_default() {
  78.106 +  return (get_origin() == DEFAULT);
  78.107 +}
  78.108 +
  78.109 +bool Flag::is_ergonomic() {
  78.110 +  return (get_origin() == ERGONOMIC);
  78.111 +}
  78.112 +
  78.113 +bool Flag::is_command_line() {
  78.114 +  return (get_origin() == COMMAND_LINE);
  78.115 +}
  78.116 +
  78.117 +bool Flag::is_product() const {
  78.118 +  return (_flags & KIND_PRODUCT) != 0;
  78.119 +}
  78.120 +
  78.121 +bool Flag::is_manageable() const {
  78.122 +  return (_flags & KIND_MANAGEABLE) != 0;
  78.123 +}
  78.124 +
  78.125 +bool Flag::is_diagnostic() const {
  78.126 +  return (_flags & KIND_DIAGNOSTIC) != 0;
  78.127 +}
  78.128 +
  78.129 +bool Flag::is_experimental() const {
  78.130 +  return (_flags & KIND_EXPERIMENTAL) != 0;
  78.131 +}
  78.132 +
  78.133 +bool Flag::is_notproduct() const {
  78.134 +  return (_flags & KIND_NOT_PRODUCT) != 0;
  78.135 +}
  78.136 +
  78.137 +bool Flag::is_develop() const {
  78.138 +  return (_flags & KIND_DEVELOP) != 0;
  78.139 +}
  78.140 +
  78.141 +bool Flag::is_read_write() const {
  78.142 +  return (_flags & KIND_READ_WRITE) != 0;
  78.143 +}
  78.144 +
  78.145 +bool Flag::is_commercial() const {
  78.146 +  return (_flags & KIND_COMMERCIAL) != 0;
  78.147 +}
  78.148 +
  78.149 +/**
  78.150 + * Returns if this flag is a constant in the binary.  Right now this is
  78.151 + * true for notproduct and develop flags in product builds.
  78.152 + */
  78.153 +bool Flag::is_constant_in_binary() const {
  78.154 +#ifdef PRODUCT
  78.155 +    return is_notproduct() || is_develop();
  78.156 +#else
  78.157 +    return false;
  78.158 +#endif
  78.159 +}
  78.160 +
  78.161  bool Flag::is_unlocker() const {
  78.162 -  return strcmp(name, "UnlockDiagnosticVMOptions") == 0     ||
  78.163 -         strcmp(name, "UnlockExperimentalVMOptions") == 0   ||
  78.164 +  return strcmp(_name, "UnlockDiagnosticVMOptions") == 0     ||
  78.165 +         strcmp(_name, "UnlockExperimentalVMOptions") == 0   ||
  78.166           is_unlocker_ext();
  78.167  }
  78.168  
  78.169  bool Flag::is_unlocked() const {
  78.170 -  if (strcmp(kind, "{diagnostic}") == 0 ||
  78.171 -      strcmp(kind, "{C2 diagnostic}") == 0 ||
  78.172 -      strcmp(kind, "{ARCH diagnostic}") == 0 ||
  78.173 -      strcmp(kind, "{Shark diagnostic}") == 0) {
  78.174 +  if (is_diagnostic()) {
  78.175      return UnlockDiagnosticVMOptions;
  78.176 -  } else if (strcmp(kind, "{experimental}") == 0 ||
  78.177 -             strcmp(kind, "{C2 experimental}") == 0 ||
  78.178 -             strcmp(kind, "{ARCH experimental}") == 0 ||
  78.179 -             strcmp(kind, "{Shark experimental}") == 0) {
  78.180 +  }
  78.181 +  if (is_experimental()) {
  78.182      return UnlockExperimentalVMOptions;
  78.183 -  } else {
  78.184 -    return is_unlocked_ext();
  78.185    }
  78.186 +  return is_unlocked_ext();
  78.187  }
  78.188  
  78.189  // Get custom message for this locked flag, or return NULL if
  78.190 @@ -91,16 +239,14 @@
  78.191  }
  78.192  
  78.193  bool Flag::is_writeable() const {
  78.194 -  return strcmp(kind, "{manageable}") == 0 ||
  78.195 -         strcmp(kind, "{product rw}") == 0 ||
  78.196 -         is_writeable_ext();
  78.197 +  return is_manageable() || (is_product() && is_read_write()) || is_writeable_ext();
  78.198  }
  78.199  
  78.200  // All flags except "manageable" are assumed to be internal flags.
  78.201  // Long term, we need to define a mechanism to specify which flags
  78.202  // are external/stable and change this function accordingly.
  78.203  bool Flag::is_external() const {
  78.204 -  return strcmp(kind, "{manageable}") == 0 || is_external_ext();
  78.205 +  return is_manageable() || is_external_ext();
  78.206  }
  78.207  
  78.208  
  78.209 @@ -108,53 +254,113 @@
  78.210  #define FORMAT_BUFFER_LEN 16
  78.211  
  78.212  void Flag::print_on(outputStream* st, bool withComments) {
  78.213 -  st->print("%9s %-40s %c= ", type, name, (origin != DEFAULT ? ':' : ' '));
  78.214 -  if (is_bool())     st->print("%-16s", get_bool() ? "true" : "false");
  78.215 -  if (is_intx())     st->print("%-16ld", get_intx());
  78.216 -  if (is_uintx())    st->print("%-16lu", get_uintx());
  78.217 -  if (is_uint64_t()) st->print("%-16lu", get_uint64_t());
  78.218 -  if (is_double())   st->print("%-16f", get_double());
  78.219 +  // Don't print notproduct and develop flags in a product build.
  78.220 +  if (is_constant_in_binary()) {
  78.221 +    return;
  78.222 +  }
  78.223  
  78.224 +  st->print("%9s %-40s %c= ", _type, _name, (!is_default() ? ':' : ' '));
  78.225 +
  78.226 +  if (is_bool()) {
  78.227 +    st->print("%-16s", get_bool() ? "true" : "false");
  78.228 +  }
  78.229 +  if (is_intx()) {
  78.230 +    st->print("%-16ld", get_intx());
  78.231 +  }
  78.232 +  if (is_uintx()) {
  78.233 +    st->print("%-16lu", get_uintx());
  78.234 +  }
  78.235 +  if (is_uint64_t()) {
  78.236 +    st->print("%-16lu", get_uint64_t());
  78.237 +  }
  78.238 +  if (is_double()) {
  78.239 +    st->print("%-16f", get_double());
  78.240 +  }
  78.241    if (is_ccstr()) {
  78.242 -     const char* cp = get_ccstr();
  78.243 -     if (cp != NULL) {
  78.244 -       const char* eol;
  78.245 -       while ((eol = strchr(cp, '\n')) != NULL) {
  78.246 -         char format_buffer[FORMAT_BUFFER_LEN];
  78.247 -         size_t llen = pointer_delta(eol, cp, sizeof(char));
  78.248 -         jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
  78.249 -                     "%%." SIZE_FORMAT "s", llen);
  78.250 -         st->print(format_buffer, cp);
  78.251 -         st->cr();
  78.252 -         cp = eol+1;
  78.253 -         st->print("%5s %-35s += ", "", name);
  78.254 -       }
  78.255 -       st->print("%-16s", cp);
  78.256 -     }
  78.257 -     else st->print("%-16s", "");
  78.258 +    const char* cp = get_ccstr();
  78.259 +    if (cp != NULL) {
  78.260 +      const char* eol;
  78.261 +      while ((eol = strchr(cp, '\n')) != NULL) {
  78.262 +        char format_buffer[FORMAT_BUFFER_LEN];
  78.263 +        size_t llen = pointer_delta(eol, cp, sizeof(char));
  78.264 +        jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
  78.265 +            "%%." SIZE_FORMAT "s", llen);
  78.266 +        st->print(format_buffer, cp);
  78.267 +        st->cr();
  78.268 +        cp = eol+1;
  78.269 +        st->print("%5s %-35s += ", "", _name);
  78.270 +      }
  78.271 +      st->print("%-16s", cp);
  78.272 +    }
  78.273 +    else st->print("%-16s", "");
  78.274    }
  78.275 -  st->print("%-20s", kind);
  78.276 +
  78.277 +  st->print("%-20");
  78.278 +  print_kind(st);
  78.279 +
  78.280    if (withComments) {
  78.281  #ifndef PRODUCT
  78.282 -    st->print("%s", doc );
  78.283 +    st->print("%s", _doc);
  78.284  #endif
  78.285    }
  78.286    st->cr();
  78.287  }
  78.288  
  78.289 +void Flag::print_kind(outputStream* st) {
  78.290 +  struct Data {
  78.291 +    int flag;
  78.292 +    const char* name;
  78.293 +  };
  78.294 +
  78.295 +  Data data[] = {
  78.296 +      { KIND_C1, "C1" },
  78.297 +      { KIND_C2, "C2" },
  78.298 +      { KIND_ARCH, "ARCH" },
  78.299 +      { KIND_SHARK, "SHARK" },
  78.300 +      { KIND_PLATFORM_DEPENDENT, "pd" },
  78.301 +      { KIND_PRODUCT, "product" },
  78.302 +      { KIND_MANAGEABLE, "manageable" },
  78.303 +      { KIND_DIAGNOSTIC, "diagnostic" },
  78.304 +      { KIND_NOT_PRODUCT, "notproduct" },
  78.305 +      { KIND_DEVELOP, "develop" },
  78.306 +      { KIND_LP64_PRODUCT, "lp64_product" },
  78.307 +      { KIND_READ_WRITE, "rw" },
  78.308 +      { -1, "" }
  78.309 +  };
  78.310 +
  78.311 +  if ((_flags & KIND_MASK) != 0) {
  78.312 +    st->print("{");
  78.313 +    bool is_first = true;
  78.314 +
  78.315 +    for (int i = 0; data[i].flag != -1; i++) {
  78.316 +      Data d = data[i];
  78.317 +      if ((_flags & d.flag) != 0) {
  78.318 +        if (is_first) {
  78.319 +          is_first = false;
  78.320 +        } else {
  78.321 +          st->print(" ");
  78.322 +        }
  78.323 +        st->print(d.name);
  78.324 +      }
  78.325 +    }
  78.326 +
  78.327 +    st->print("}");
  78.328 +  }
  78.329 +}
  78.330 +
  78.331  void Flag::print_as_flag(outputStream* st) {
  78.332    if (is_bool()) {
  78.333 -    st->print("-XX:%s%s", get_bool() ? "+" : "-", name);
  78.334 +    st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
  78.335    } else if (is_intx()) {
  78.336 -    st->print("-XX:%s=" INTX_FORMAT, name, get_intx());
  78.337 +    st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
  78.338    } else if (is_uintx()) {
  78.339 -    st->print("-XX:%s=" UINTX_FORMAT, name, get_uintx());
  78.340 +    st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx());
  78.341    } else if (is_uint64_t()) {
  78.342 -    st->print("-XX:%s=" UINT64_FORMAT, name, get_uint64_t());
  78.343 +    st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t());
  78.344    } else if (is_double()) {
  78.345 -    st->print("-XX:%s=%f", name, get_double());
  78.346 +    st->print("-XX:%s=%f", _name, get_double());
  78.347    } else if (is_ccstr()) {
  78.348 -    st->print("-XX:%s=", name);
  78.349 +    st->print("-XX:%s=", _name);
  78.350      const char* cp = get_ccstr();
  78.351      if (cp != NULL) {
  78.352        // Need to turn embedded '\n's back into separate arguments
  78.353 @@ -167,7 +373,7 @@
  78.354              st->print("%c", *cp);
  78.355              break;
  78.356            case '\n':
  78.357 -            st->print(" -XX:%s=", name);
  78.358 +            st->print(" -XX:%s=", _name);
  78.359              break;
  78.360          }
  78.361        }
  78.362 @@ -180,79 +386,51 @@
  78.363  // 4991491 do not "optimize out" the was_set false values: omitting them
  78.364  // tickles a Microsoft compiler bug causing flagTable to be malformed
  78.365  
  78.366 -#define RUNTIME_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product}", DEFAULT },
  78.367 -#define RUNTIME_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{pd product}", DEFAULT },
  78.368 -#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{diagnostic}", DEFAULT },
  78.369 -#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{experimental}", DEFAULT },
  78.370 -#define RUNTIME_MANAGEABLE_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{manageable}", DEFAULT },
  78.371 -#define RUNTIME_PRODUCT_RW_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product rw}", DEFAULT },
  78.372 +#define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
  78.373  
  78.374 -#ifdef PRODUCT
  78.375 -  #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.376 -  #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
  78.377 -  #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
  78.378 -#else
  78.379 -  #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "", DEFAULT },
  78.380 -  #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{pd}", DEFAULT },
  78.381 -  #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{notproduct}", DEFAULT },
  78.382 -#endif
  78.383 +#define RUNTIME_PRODUCT_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
  78.384 +#define RUNTIME_PD_PRODUCT_FLAG_STRUCT(  type, name,        doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
  78.385 +#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
  78.386 +#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
  78.387 +#define RUNTIME_MANAGEABLE_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
  78.388 +#define RUNTIME_PRODUCT_RW_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_READ_WRITE) },
  78.389 +#define RUNTIME_DEVELOP_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP) },
  78.390 +#define RUNTIME_PD_DEVELOP_FLAG_STRUCT(  type, name,        doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
  78.391 +#define RUNTIME_NOTPRODUCT_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_NOT_PRODUCT) },
  78.392  
  78.393  #ifdef _LP64
  78.394 -  #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{lp64_product}", DEFAULT },
  78.395 +#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_LP64_PRODUCT) },
  78.396  #else
  78.397 -  #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.398 +#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.399  #endif // _LP64
  78.400  
  78.401 -#define C1_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 product}", DEFAULT },
  78.402 -#define C1_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 pd product}", DEFAULT },
  78.403 -#define C1_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 diagnostic}", DEFAULT },
  78.404 -#ifdef PRODUCT
  78.405 -  #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.406 -  #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
  78.407 -  #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
  78.408 -#else
  78.409 -  #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1}", DEFAULT },
  78.410 -  #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{C1 pd}", DEFAULT },
  78.411 -  #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1 notproduct}", DEFAULT },
  78.412 -#endif
  78.413 +#define C1_PRODUCT_FLAG_STRUCT(          type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT) },
  78.414 +#define C1_PD_PRODUCT_FLAG_STRUCT(       type, name,        doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
  78.415 +#define C1_DIAGNOSTIC_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DIAGNOSTIC) },
  78.416 +#define C1_DEVELOP_FLAG_STRUCT(          type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP) },
  78.417 +#define C1_PD_DEVELOP_FLAG_STRUCT(       type, name,        doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
  78.418 +#define C1_NOTPRODUCT_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_NOT_PRODUCT) },
  78.419  
  78.420 -#define C2_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 product}", DEFAULT },
  78.421 -#define C2_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 pd product}", DEFAULT },
  78.422 -#define C2_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 diagnostic}", DEFAULT },
  78.423 -#define C2_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 experimental}", DEFAULT },
  78.424 -#ifdef PRODUCT
  78.425 -  #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.426 -  #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
  78.427 -  #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
  78.428 -#else
  78.429 -  #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2}", DEFAULT },
  78.430 -  #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{C2 pd}", DEFAULT },
  78.431 -  #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2 notproduct}", DEFAULT },
  78.432 -#endif
  78.433 +#define C2_PRODUCT_FLAG_STRUCT(          type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT) },
  78.434 +#define C2_PD_PRODUCT_FLAG_STRUCT(       type, name,        doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
  78.435 +#define C2_DIAGNOSTIC_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DIAGNOSTIC) },
  78.436 +#define C2_EXPERIMENTAL_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_EXPERIMENTAL) },
  78.437 +#define C2_DEVELOP_FLAG_STRUCT(          type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP) },
  78.438 +#define C2_PD_DEVELOP_FLAG_STRUCT(       type, name,        doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
  78.439 +#define C2_NOTPRODUCT_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_NOT_PRODUCT) },
  78.440  
  78.441 -#define ARCH_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH product}", DEFAULT },
  78.442 -#define ARCH_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH diagnostic}", DEFAULT },
  78.443 -#define ARCH_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH experimental}", DEFAULT },
  78.444 -#ifdef PRODUCT
  78.445 -  #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.446 -  #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
  78.447 -#else
  78.448 -  #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH}", DEFAULT },
  78.449 -  #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH notproduct}", DEFAULT },
  78.450 -#endif
  78.451 +#define ARCH_PRODUCT_FLAG_STRUCT(        type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_PRODUCT) },
  78.452 +#define ARCH_DIAGNOSTIC_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DIAGNOSTIC) },
  78.453 +#define ARCH_EXPERIMENTAL_FLAG_STRUCT(   type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_EXPERIMENTAL) },
  78.454 +#define ARCH_DEVELOP_FLAG_STRUCT(        type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DEVELOP) },
  78.455 +#define ARCH_NOTPRODUCT_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_NOT_PRODUCT) },
  78.456  
  78.457 -#define SHARK_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark product}", DEFAULT },
  78.458 -#define SHARK_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark pd product}", DEFAULT },
  78.459 -#define SHARK_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark diagnostic}", DEFAULT },
  78.460 -#ifdef PRODUCT
  78.461 -  #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
  78.462 -  #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
  78.463 -  #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
  78.464 -#else
  78.465 -  #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark}", DEFAULT },
  78.466 -  #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{Shark pd}", DEFAULT },
  78.467 -  #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark notproduct}", DEFAULT },
  78.468 -#endif
  78.469 +#define SHARK_PRODUCT_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_PRODUCT) },
  78.470 +#define SHARK_PD_PRODUCT_FLAG_STRUCT(    type, name,        doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
  78.471 +#define SHARK_DIAGNOSTIC_FLAG_STRUCT(    type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DIAGNOSTIC) },
  78.472 +#define SHARK_DEVELOP_FLAG_STRUCT(       type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DEVELOP) },
  78.473 +#define SHARK_PD_DEVELOP_FLAG_STRUCT(    type, name,        doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
  78.474 +#define SHARK_NOTPRODUCT_FLAG_STRUCT(    type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_NOT_PRODUCT) },
  78.475  
  78.476  static Flag flagTable[] = {
  78.477   RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_EXPERIMENTAL_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT, RUNTIME_MANAGEABLE_FLAG_STRUCT, RUNTIME_PRODUCT_RW_FLAG_STRUCT, RUNTIME_LP64_PRODUCT_FLAG_STRUCT)
  78.478 @@ -285,9 +463,14 @@
  78.479  
  78.480  // Search the flag table for a named flag
  78.481  Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) {
  78.482 -  for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
  78.483 -    if (str_equal(current->name, name, length)) {
  78.484 -      // Found a matching entry.  Report locked flags only if allowed.
  78.485 +  for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
  78.486 +    if (str_equal(current->_name, name, length)) {
  78.487 +      // Found a matching entry.
  78.488 +      // Don't report notproduct and develop flags in product builds.
  78.489 +      if (current->is_constant_in_binary()) {
  78.490 +        return NULL;
  78.491 +      }
  78.492 +      // Report locked flags only if allowed.
  78.493        if (!(current->is_unlocked() || current->is_unlocker())) {
  78.494          if (!allow_locked) {
  78.495            // disable use of locked flags, e.g. diagnostic, experimental,
  78.496 @@ -327,8 +510,8 @@
  78.497    float score;
  78.498    float max_score = -1;
  78.499  
  78.500 -  for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
  78.501 -    score = str_similar(current->name, name, length);
  78.502 +  for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
  78.503 +    score = str_similar(current->_name, name, length);
  78.504      if (score > max_score) {
  78.505        max_score = score;
  78.506        match = current;
  78.507 @@ -357,25 +540,25 @@
  78.508  bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
  78.509    assert((size_t)flag < Flag::numFlags, "bad command line flag index");
  78.510    Flag* f = &Flag::flags[flag];
  78.511 -  return (f->origin == DEFAULT);
  78.512 +  return f->is_default();
  78.513  }
  78.514  
  78.515  bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
  78.516    assert((size_t)flag < Flag::numFlags, "bad command line flag index");
  78.517    Flag* f = &Flag::flags[flag];
  78.518 -  return (f->origin == ERGONOMIC);
  78.519 +  return f->is_ergonomic();
  78.520  }
  78.521  
  78.522  bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
  78.523    assert((size_t)flag < Flag::numFlags, "bad command line flag index");
  78.524    Flag* f = &Flag::flags[flag];
  78.525 -  return (f->origin == COMMAND_LINE);
  78.526 +  return f->is_command_line();
  78.527  }
  78.528  
  78.529  bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
  78.530    Flag* result = Flag::find_flag((char*)name, strlen(name));
  78.531    if (result == NULL) return false;
  78.532 -  *value = (result->origin == COMMAND_LINE);
  78.533 +  *value = result->is_command_line();
  78.534    return true;
  78.535  }
  78.536  
  78.537 @@ -387,22 +570,22 @@
  78.538    return true;
  78.539  }
  78.540  
  78.541 -bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin) {
  78.542 +bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) {
  78.543    Flag* result = Flag::find_flag(name, len);
  78.544    if (result == NULL) return false;
  78.545    if (!result->is_bool()) return false;
  78.546    bool old_value = result->get_bool();
  78.547    result->set_bool(*value);
  78.548    *value = old_value;
  78.549 -  result->origin = origin;
  78.550 +  result->set_origin(origin);
  78.551    return true;
  78.552  }
  78.553  
  78.554 -void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin) {
  78.555 +void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
  78.556    Flag* faddr = address_of_flag(flag);
  78.557    guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
  78.558    faddr->set_bool(value);
  78.559 -  faddr->origin = origin;
  78.560 +  faddr->set_origin(origin);
  78.561  }
  78.562  
  78.563  bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
  78.564 @@ -413,22 +596,22 @@
  78.565    return true;
  78.566  }
  78.567  
  78.568 -bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin) {
  78.569 +bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) {
  78.570    Flag* result = Flag::find_flag(name, len);
  78.571    if (result == NULL) return false;
  78.572    if (!result->is_intx()) return false;
  78.573    intx old_value = result->get_intx();
  78.574    result->set_intx(*value);
  78.575    *value = old_value;
  78.576 -  result->origin = origin;
  78.577 +  result->set_origin(origin);
  78.578    return true;
  78.579  }
  78.580  
  78.581 -void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin) {
  78.582 +void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
  78.583    Flag* faddr = address_of_flag(flag);
  78.584    guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
  78.585    faddr->set_intx(value);
  78.586 -  faddr->origin = origin;
  78.587 +  faddr->set_origin(origin);
  78.588  }
  78.589  
  78.590  bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
  78.591 @@ -439,22 +622,22 @@
  78.592    return true;
  78.593  }
  78.594  
  78.595 -bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin) {
  78.596 +bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) {
  78.597    Flag* result = Flag::find_flag(name, len);
  78.598    if (result == NULL) return false;
  78.599    if (!result->is_uintx()) return false;
  78.600    uintx old_value = result->get_uintx();
  78.601    result->set_uintx(*value);
  78.602    *value = old_value;
  78.603 -  result->origin = origin;
  78.604 +  result->set_origin(origin);
  78.605    return true;
  78.606  }
  78.607  
  78.608 -void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin) {
  78.609 +void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
  78.610    Flag* faddr = address_of_flag(flag);
  78.611    guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
  78.612    faddr->set_uintx(value);
  78.613 -  faddr->origin = origin;
  78.614 +  faddr->set_origin(origin);
  78.615  }
  78.616  
  78.617  bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
  78.618 @@ -465,22 +648,22 @@
  78.619    return true;
  78.620  }
  78.621  
  78.622 -bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) {
  78.623 +bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) {
  78.624    Flag* result = Flag::find_flag(name, len);
  78.625    if (result == NULL) return false;
  78.626    if (!result->is_uint64_t()) return false;
  78.627    uint64_t old_value = result->get_uint64_t();
  78.628    result->set_uint64_t(*value);
  78.629    *value = old_value;
  78.630 -  result->origin = origin;
  78.631 +  result->set_origin(origin);
  78.632    return true;
  78.633  }
  78.634  
  78.635 -void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin) {
  78.636 +void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
  78.637    Flag* faddr = address_of_flag(flag);
  78.638    guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
  78.639    faddr->set_uint64_t(value);
  78.640 -  faddr->origin = origin;
  78.641 +  faddr->set_origin(origin);
  78.642  }
  78.643  
  78.644  bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
  78.645 @@ -491,22 +674,22 @@
  78.646    return true;
  78.647  }
  78.648  
  78.649 -bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) {
  78.650 +bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) {
  78.651    Flag* result = Flag::find_flag(name, len);
  78.652    if (result == NULL) return false;
  78.653    if (!result->is_double()) return false;
  78.654    double old_value = result->get_double();
  78.655    result->set_double(*value);
  78.656    *value = old_value;
  78.657 -  result->origin = origin;
  78.658 +  result->set_origin(origin);
  78.659    return true;
  78.660  }
  78.661  
  78.662 -void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin) {
  78.663 +void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
  78.664    Flag* faddr = address_of_flag(flag);
  78.665    guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
  78.666    faddr->set_double(value);
  78.667 -  faddr->origin = origin;
  78.668 +  faddr->set_origin(origin);
  78.669  }
  78.670  
  78.671  bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
  78.672 @@ -519,7 +702,7 @@
  78.673  
  78.674  // Contract:  Flag will make private copy of the incoming value.
  78.675  // Outgoing value is always malloc-ed, and caller MUST call free.
  78.676 -bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) {
  78.677 +bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
  78.678    Flag* result = Flag::find_flag(name, len);
  78.679    if (result == NULL) return false;
  78.680    if (!result->is_ccstr()) return false;
  78.681 @@ -530,35 +713,35 @@
  78.682      strcpy(new_value, *value);
  78.683    }
  78.684    result->set_ccstr(new_value);
  78.685 -  if (result->origin == DEFAULT && old_value != NULL) {
  78.686 +  if (result->is_default() && old_value != NULL) {
  78.687      // Prior value is NOT heap allocated, but was a literal constant.
  78.688      char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
  78.689      strcpy(old_value_to_free, old_value);
  78.690      old_value = old_value_to_free;
  78.691    }
  78.692    *value = old_value;
  78.693 -  result->origin = origin;
  78.694 +  result->set_origin(origin);
  78.695    return true;
  78.696  }
  78.697  
  78.698  // Contract:  Flag will make private copy of the incoming value.
  78.699 -void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin) {
  78.700 +void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
  78.701    Flag* faddr = address_of_flag(flag);
  78.702    guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
  78.703    ccstr old_value = faddr->get_ccstr();
  78.704    char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
  78.705    strcpy(new_value, value);
  78.706    faddr->set_ccstr(new_value);
  78.707 -  if (faddr->origin != DEFAULT && old_value != NULL) {
  78.708 +  if (!faddr->is_default() && old_value != NULL) {
  78.709      // Prior value is heap allocated so free it.
  78.710      FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
  78.711    }
  78.712 -  faddr->origin = origin;
  78.713 +  faddr->set_origin(origin);
  78.714  }
  78.715  
  78.716  extern "C" {
  78.717    static int compare_flags(const void* void_a, const void* void_b) {
  78.718 -    return strcmp((*((Flag**) void_a))->name, (*((Flag**) void_b))->name);
  78.719 +    return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name);
  78.720    }
  78.721  }
  78.722  
  78.723 @@ -567,20 +750,19 @@
  78.724    // note: this method is called before the thread structure is in place
  78.725    //       which means resource allocation cannot be used.
  78.726  
  78.727 -  // Compute size
  78.728 -  int length= 0;
  78.729 -  while (flagTable[length].name != NULL) length++;
  78.730 +  // The last entry is the null entry.
  78.731 +  const size_t length = Flag::numFlags - 1;
  78.732  
  78.733    // Sort
  78.734    Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
  78.735 -  for (int index = 0; index < length; index++) {
  78.736 -    array[index] = &flagTable[index];
  78.737 +  for (size_t i = 0; i < length; i++) {
  78.738 +    array[i] = &flagTable[i];
  78.739    }
  78.740    qsort(array, length, sizeof(Flag*), compare_flags);
  78.741  
  78.742    // Print
  78.743 -  for (int i = 0; i < length; i++) {
  78.744 -    if (array[i]->origin /* naked field! */) {
  78.745 +  for (size_t i = 0; i < length; i++) {
  78.746 +    if (array[i]->get_origin() /* naked field! */) {
  78.747        array[i]->print_as_flag(out);
  78.748        out->print(" ");
  78.749      }
  78.750 @@ -603,20 +785,19 @@
  78.751    // note: this method is called before the thread structure is in place
  78.752    //       which means resource allocation cannot be used.
  78.753  
  78.754 -  // Compute size
  78.755 -  int length= 0;
  78.756 -  while (flagTable[length].name != NULL) length++;
  78.757 +  // The last entry is the null entry.
  78.758 +  const size_t length = Flag::numFlags - 1;
  78.759  
  78.760    // Sort
  78.761    Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
  78.762 -  for (int index = 0; index < length; index++) {
  78.763 -    array[index] = &flagTable[index];
  78.764 +  for (size_t i = 0; i < length; i++) {
  78.765 +    array[i] = &flagTable[i];
  78.766    }
  78.767    qsort(array, length, sizeof(Flag*), compare_flags);
  78.768  
  78.769    // Print
  78.770    out->print_cr("[Global flags]");
  78.771 -  for (int i = 0; i < length; i++) {
  78.772 +  for (size_t i = 0; i < length; i++) {
  78.773      if (array[i]->is_unlocked()) {
  78.774        array[i]->print_on(out, withComments);
  78.775      }