--- a/hotspot/make/aix/makefiles/trace.make Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/make/aix/makefiles/trace.make Thu Nov 05 15:28:24 2015 +0000
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -82,8 +82,7 @@
GENERATE_CODE= \
$(QUIETLY) echo $(LOG_INFO) Generating $@; \
- $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@; \
- test -f $@
+ $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@
$(TraceOutDir)/traceEventIds.hpp: $(TraceSrcDir)/trace.xml $(TraceSrcDir)/traceEventIds.xsl $(XML_DEPS)
$(GENERATE_CODE)
--- a/hotspot/make/bsd/makefiles/trace.make Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/make/bsd/makefiles/trace.make Thu Nov 05 15:28:24 2015 +0000
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -83,8 +83,7 @@
GENERATE_CODE= \
$(QUIETLY) echo $(LOG_INFO) Generating $@; \
- $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@; \
- test -f $@
+ $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@
$(TraceOutDir)/traceEventIds.hpp: $(TraceSrcDir)/trace.xml $(TraceSrcDir)/traceEventIds.xsl $(XML_DEPS)
$(GENERATE_CODE)
--- a/hotspot/make/linux/makefiles/trace.make Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/make/linux/makefiles/trace.make Thu Nov 05 15:28:24 2015 +0000
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -82,8 +82,7 @@
GENERATE_CODE= \
$(QUIETLY) echo $(LOG_INFO) Generating $@; \
- $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@; \
- test -f $@
+ $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@
$(TraceOutDir)/traceEventIds.hpp: $(TraceSrcDir)/trace.xml $(TraceSrcDir)/traceEventIds.xsl $(XML_DEPS)
$(GENERATE_CODE)
--- a/hotspot/make/solaris/makefiles/trace.make Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/make/solaris/makefiles/trace.make Thu Nov 05 15:28:24 2015 +0000
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -78,8 +78,7 @@
GENERATE_CODE= \
$(QUIETLY) echo $(LOG_INFO) Generating $@; \
- $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@; \
- test -f $@
+ $(XSLT) -IN $(word 1,$^) -XSL $(word 2,$^) -OUT $@
$(TraceOutDir)/traceEventIds.hpp: $(TraceSrcDir)/trace.xml $(TraceSrcDir)/traceEventIds.xsl $(XML_DEPS)
$(GENERATE_CODE)
--- a/hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp Thu Nov 05 15:28:24 2015 +0000
@@ -1037,19 +1037,6 @@
_recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms;
if (recent_avg_pause_time_ratio() < 0.0 ||
(recent_avg_pause_time_ratio() - 1.0 > 0.0)) {
-#ifndef PRODUCT
- // Dump info to allow post-facto debugging
- gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds");
- gclog_or_tty->print_cr("-------------------------------------------");
- gclog_or_tty->print_cr("Recent GC Times (ms):");
- _recent_gc_times_ms->dump();
- gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec);
- _recent_prev_end_times_for_all_gcs_sec->dump();
- gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f",
- _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio());
- // In debug mode, terminate the JVM if the user wants to debug at this point.
- assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above");
-#endif // !PRODUCT
// Clip ratio between 0.0 and 1.0, and continue. This will be fixed in
// CR 6902692 by redoing the manner in which the ratio is incrementally computed.
if (_recent_avg_pause_time_ratio < 0.0) {
--- a/hotspot/src/share/vm/gc/g1/g1_globals.hpp Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/gc/g1/g1_globals.hpp Thu Nov 05 15:28:24 2015 +0000
@@ -228,10 +228,6 @@
develop(bool, G1HRRSFlushLogBuffersOnVerify, false, \
"Forces flushing of log buffers before verification.") \
\
- develop(bool, G1FailOnFPError, false, \
- "When set, G1 will fail when it encounters an FP 'error', " \
- "so as to allow debugging") \
- \
product(size_t, G1HeapRegionSize, 0, \
"Size of the G1 regions.") \
range(0, 32*M) \
--- a/hotspot/src/share/vm/prims/jvmtiGen.java Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/prims/jvmtiGen.java Thu Nov 05 15:28:24 2015 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -22,52 +22,60 @@
*
*/
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.transform.stream.StreamResult;
+import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.w3c.dom.Document;
import org.w3c.dom.DOMException;
-// For write operation
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.TransformerConfigurationException;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamSource;
-import javax.xml.transform.stream.StreamResult;
-
-import java.io.*;
public class jvmtiGen
{
+ private static final int EXIT_FAILURE_ERROR = 1;
+ private static final int EXIT_FAILURE_BADARGUMENTS = 2;
+
+ private static boolean verbose = false;
+
/**
* Write out usage and exit.
*/
private static void showUsage() {
System.err.println("usage:");
System.err.println(" java jvmtiGen " +
+ "[-verbose] " +
"-IN <input XML file name> " +
"-XSL <XSL file> " +
"-OUT <output file name> " +
"[-PARAM <name> <expression> ...]");
- System.exit(0); // There is no returning from showUsage()
+ System.exit(EXIT_FAILURE_BADARGUMENTS); // There is no returning from showUsage()
}
- // Global value so it can be ref'd by the tree-adapter
- static Document document;
-
- public static void main (String argv [])
- {
- String inFileName=null;
- String xslFileName=null;
- String outFileName=null;
- java.util.Vector<String> params=new java.util.Vector<String>();
+ public static void main (String argv []) {
+ String inFileName = null;
+ String xslFileName = null;
+ String outFileName = null;
+ final List<String> params = new ArrayList<String>();
for (int ii = 0; ii < argv.length; ii++) {
- if (argv[ii].equals("-IN")) {
+ if (argv[ii].equals("-verbose")) {
+ verbose = true;
+ } else if (argv[ii].equals("-IN")) {
inFileName = argv[++ii];
} else if (argv[ii].equals("-XSL")) {
xslFileName = argv[++ii];
@@ -75,10 +83,10 @@
outFileName = argv[++ii];
} else if (argv[ii].equals("-PARAM")) {
if (ii + 2 < argv.length) {
- String name = argv[++ii];
- params.addElement(name);
- String expression = argv[++ii];
- params.addElement(expression);
+ final String name = argv[++ii];
+ params.add(name);
+ final String expression = argv[++ii];
+ params.add(expression);
} else {
showUsage();
}
@@ -86,109 +94,54 @@
showUsage();
}
}
- if (inFileName==null || xslFileName==null || outFileName==null){
+ if (inFileName == null || xslFileName == null || outFileName == null) {
showUsage();
}
- /*
- * Due to JAXP breakage in some intermediate Tiger builds, the
- * com.sun.org.apache..... parser may throw an exception:
- * com.sun.org.apache.xml.internal.utils.WrappedRuntimeException:
- * org.apache.xalan.serialize.SerializerToText
- *
- * To work around the problem, this program uses the
- * org.apache.xalan.... version if it is available. It is
- * available in J2SE 1.4.x and early builds of 1.5 (Tiger).
- * It was removed at the same time the thrown exception issue
- * above was fixed, so if the class is not found we can proceed
- * and use the default parser.
- */
- final String parserProperty =
- "javax.xml.transform.TransformerFactory";
- final String workaroundParser =
- "org.apache.xalan.processor.TransformerFactoryImpl";
-
- try {
- java.lang.Class cls = java.lang.Class.forName(workaroundParser);
- /*
- * If we get here, we found the class. Use it.
- */
- System.setProperty(parserProperty, workaroundParser);
- System.out.println("Info: jvmtiGen using " + parserProperty +
- " = " + workaroundParser);
- } catch (ClassNotFoundException cnfex) {
- /*
- * We didn't find workaroundParser. Ignore the
- * exception and proceed with default settings.
- */
- }
-
- DocumentBuilderFactory factory =
- DocumentBuilderFactory.newInstance();
+ final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
factory.setValidating(true);
factory.setXIncludeAware(true);
- try {
- File datafile = new File(inFileName);
- File stylesheet = new File(xslFileName);
-
- DocumentBuilder builder = factory.newDocumentBuilder();
- document = builder.parse(datafile);
-
- // Use a Transformer for output
- TransformerFactory tFactory =
- TransformerFactory.newInstance();
- StreamSource stylesource = new StreamSource(stylesheet);
- Transformer transformer = tFactory.newTransformer(stylesource);
- for (int ii = 0; ii < params.size(); ii += 2){
- transformer.setParameter((String) params.elementAt(ii),
- (String) params.elementAt(ii + 1));
- }
- DOMSource source = new DOMSource(document);
-
- PrintStream ps = new PrintStream( new FileOutputStream(outFileName));
- StreamResult result = new StreamResult(ps);
- transformer.transform(source, result);
-
- } catch (TransformerConfigurationException tce) {
- // Error generated by the parser
- System.out.println ("\n** Transformer Factory error");
- System.out.println(" " + tce.getMessage() );
+ final File datafile = new File(inFileName);
+ final File stylesheet = new File(xslFileName);
- // Use the contained exception, if any
- Throwable x = tce;
- if (tce.getException() != null)
- x = tce.getException();
- x.printStackTrace();
-
- } catch (TransformerException te) {
- // Error generated by the parser
- System.out.println ("\n** Transformation error");
- System.out.println(" " + te.getMessage() );
-
- // Use the contained exception, if any
- Throwable x = te;
- if (te.getException() != null)
- x = te.getException();
- x.printStackTrace();
-
- } catch (SAXException sxe) {
- // Error generated by this application
- // (or a parser-initialization error)
- Exception x = sxe;
- if (sxe.getException() != null)
- x = sxe.getException();
- x.printStackTrace();
-
- } catch (ParserConfigurationException pce) {
- // Parser with specified options can't be built
- pce.printStackTrace();
-
- } catch (IOException ioe) {
- // I/O error
- ioe.printStackTrace();
+ try (
+ final OutputStream os = new BufferedOutputStream(new FileOutputStream(outFileName));
+ ) {
+ final StreamSource stylesource = new StreamSource(stylesheet);
+ // Use a Transformer for output
+ final Transformer transformer =
+ TransformerFactory.newInstance().newTransformer(stylesource);
+ for (int ii = 0; ii < params.size(); ii += 2) {
+ transformer.setParameter(params.get(ii), params.get(ii + 1));
+ }
+ final DocumentBuilder builder = factory.newDocumentBuilder();
+ builder.setErrorHandler(new ErrorHandler() {
+ public void fatalError(SAXParseException exn) throws SAXException {
+ throw new SAXException(exn);
+ }
+ public void error(SAXParseException exn) throws SAXException {
+ fatalError(exn);
+ }
+ public void warning(SAXParseException exn) throws SAXException {
+ if (verbose) {
+ System.err.println("jvmtiGen warning: " + exn.getMessage());
+ }
+ }
+ });
+ final Document document = builder.parse(datafile);
+ final DOMSource source = new DOMSource(document);
+ final StreamResult result = new StreamResult(os);
+ transformer.transform(source, result);
+ } catch (IOException
+ | ParserConfigurationException
+ | SAXException
+ | TransformerException exn) {
+ System.err.print("jvmtiGen error: " + exn.getMessage());
+ exn.printStackTrace(System.err);
+ System.exit(EXIT_FAILURE_ERROR);
}
} // main
}
--- a/hotspot/src/share/vm/runtime/arguments.cpp Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Thu Nov 05 15:28:24 2015 +0000
@@ -818,9 +818,15 @@
int int_v;
intx intx_v;
bool is_neg = false;
+ Flag* result = Flag::find_flag(name, strlen(name));
+
+ if (result == NULL) {
+ return false;
+ }
+
// Check the sign first since atomull() parses only unsigned values.
if (*value == '-') {
- if ((CommandLineFlags::intxAt(name, &intx_v) != Flag::SUCCESS) && (CommandLineFlags::intAt(name, &int_v) != Flag::SUCCESS)) {
+ if (!result->is_intx() && !result->is_int()) {
return false;
}
value++;
@@ -829,37 +835,33 @@
if (!atomull(value, &v)) {
return false;
}
- int_v = (int) v;
- if (is_neg) {
- int_v = -int_v;
- }
- if (CommandLineFlags::intAtPut(name, &int_v, origin) == Flag::SUCCESS) {
- return true;
- }
- uint uint_v = (uint) v;
- if (!is_neg && CommandLineFlags::uintAtPut(name, &uint_v, origin) == Flag::SUCCESS) {
- return true;
- }
- intx_v = (intx) v;
- if (is_neg) {
- intx_v = -intx_v;
- }
- if (CommandLineFlags::intxAtPut(name, &intx_v, origin) == Flag::SUCCESS) {
- return true;
- }
- uintx uintx_v = (uintx) v;
- if (!is_neg && (CommandLineFlags::uintxAtPut(name, &uintx_v, origin) == Flag::SUCCESS)) {
- return true;
- }
- uint64_t uint64_t_v = (uint64_t) v;
- if (!is_neg && (CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin) == Flag::SUCCESS)) {
- return true;
- }
- size_t size_t_v = (size_t) v;
- if (!is_neg && (CommandLineFlags::size_tAtPut(name, &size_t_v, origin) == Flag::SUCCESS)) {
- return true;
- }
- return false;
+ if (result->is_int()) {
+ int_v = (int) v;
+ if (is_neg) {
+ int_v = -int_v;
+ }
+ return CommandLineFlags::intAtPut(result, &int_v, origin) == Flag::SUCCESS;
+ } else if (result->is_uint()) {
+ uint uint_v = (uint) v;
+ return CommandLineFlags::uintAtPut(result, &uint_v, origin) == Flag::SUCCESS;
+ } else if (result->is_intx()) {
+ intx_v = (intx) v;
+ if (is_neg) {
+ intx_v = -intx_v;
+ }
+ return CommandLineFlags::intxAtPut(result, &intx_v, origin) == Flag::SUCCESS;
+ } else if (result->is_uintx()) {
+ uintx uintx_v = (uintx) v;
+ return CommandLineFlags::uintxAtPut(result, &uintx_v, origin) == Flag::SUCCESS;
+ } else if (result->is_uint64_t()) {
+ uint64_t uint64_t_v = (uint64_t) v;
+ return CommandLineFlags::uint64_tAtPut(result, &uint64_t_v, origin) == Flag::SUCCESS;
+ } else if (result->is_size_t()) {
+ size_t size_t_v = (size_t) v;
+ return CommandLineFlags::size_tAtPut(result, &size_t_v, origin) == Flag::SUCCESS;
+ } else {
+ return false;
+ }
}
static bool set_string_flag(const char* name, const char* value, Flag::Flags origin) {
--- a/hotspot/src/share/vm/runtime/globals.cpp Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/runtime/globals.cpp Thu Nov 05 15:28:24 2015 +0000
@@ -787,7 +787,7 @@
e.commit();
}
-static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
if (constraint != NULL) {
@@ -804,32 +804,33 @@
return Flag::SUCCESS;
}
-Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_bool()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::boolAtPut(Flag* flag, bool* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_bool()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- bool old_value = result->get_bool();
+ bool old_value = flag->get_bool();
trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
- result->set_bool(*value);
+ flag->set_bool(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return boolAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
- faddr->set_bool(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::boolAtPut(faddr, &value, origin);
}
-static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -852,32 +853,33 @@
return Flag::SUCCESS;
}
-Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_int()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::intAtPut(Flag* flag, int* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_int()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- int old_value = result->get_int();
+ int old_value = flag->get_int();
trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
- result->set_int(*value);
+ flag->set_int(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return intAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_int(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
- faddr->set_int(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::intAtPut(faddr, &value, origin);
}
-static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -900,29 +902,30 @@
return Flag::SUCCESS;
}
-Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_uint()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::uintAtPut(Flag* flag, uint* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_uint()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- uint old_value = result->get_uint();
+ uint old_value = flag->get_uint();
trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
- result->set_uint(*value);
+ flag->set_uint(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return uintAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_uint(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
- faddr->set_uint(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::uintAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
@@ -933,7 +936,7 @@
return Flag::SUCCESS;
}
-static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -948,29 +951,30 @@
return status;
}
-Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_intx()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::intxAtPut(Flag* flag, intx* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_intx()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- intx old_value = result->get_intx();
+ intx old_value = flag->get_intx();
trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
- result->set_intx(*value);
+ flag->set_intx(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return intxAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
- faddr->set_intx(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::intxAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
@@ -981,7 +985,7 @@
return Flag::SUCCESS;
}
-static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -996,29 +1000,30 @@
return status;
}
-Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_uintx()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_uintx()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- uintx old_value = result->get_uintx();
+ uintx old_value = flag->get_uintx();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
- result->set_uintx(*value);
+ flag->set_uintx(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return uintxAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
- faddr->set_uintx(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::uintxAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
@@ -1029,7 +1034,7 @@
return Flag::SUCCESS;
}
-static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -1044,29 +1049,30 @@
return status;
}
-Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_uint64_t()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- uint64_t old_value = result->get_uint64_t();
+ uint64_t old_value = flag->get_uint64_t();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
- result->set_uint64_t(*value);
+ flag->set_uint64_t(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return uint64_tAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
- faddr->set_uint64_t(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::uint64_tAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
@@ -1077,7 +1083,7 @@
return Flag::SUCCESS;
}
-static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -1092,29 +1098,31 @@
return status;
}
-Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_size_t()) return Flag::WRONG_FORMAT;
+
+Flag::Error CommandLineFlags::size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_size_t()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- size_t old_value = result->get_size_t();
+ size_t old_value = flag->get_size_t();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
- result->set_size_t(*value);
+ flag->set_size_t(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return size_tAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
- faddr->set_size_t(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::size_tAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
@@ -1125,7 +1133,7 @@
return Flag::SUCCESS;
}
-static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose = true) {
+static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@@ -1140,29 +1148,30 @@
return status;
}
-Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
- Flag* result = Flag::find_flag(name, len);
- if (result == NULL) return Flag::INVALID_FLAG;
- if (!result->is_double()) return Flag::WRONG_FORMAT;
+Flag::Error CommandLineFlags::doubleAtPut(Flag* flag, double* value, Flag::Flags origin) {
+ const char* name;
+ if (flag == NULL) return Flag::INVALID_FLAG;
+ if (!flag->is_double()) return Flag::WRONG_FORMAT;
+ name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
- double old_value = result->get_double();
+ double old_value = flag->get_double();
trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
- result->set_double(*value);
+ flag->set_double(*value);
*value = old_value;
- result->set_origin(origin);
+ flag->set_origin(origin);
return Flag::SUCCESS;
}
+Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ return doubleAtPut(result, value, origin);
+}
+
Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
- Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, value);
- if (check != Flag::SUCCESS) return check;
- trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
- faddr->set_double(value);
- faddr->set_origin(origin);
- return Flag::SUCCESS;
+ return CommandLineFlags::doubleAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
--- a/hotspot/src/share/vm/runtime/globals.hpp Thu Nov 05 11:42:42 2015 +0100
+++ b/hotspot/src/share/vm/runtime/globals.hpp Thu Nov 05 15:28:24 2015 +0000
@@ -452,41 +452,49 @@
public:
static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false) { return boolAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error boolAtPut(Flag* flag, bool* value, Flag::Flags origin);
static Flag::Error boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
static Flag::Error boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error intAtPut(Flag* flag, int* value, Flag::Flags origin);
static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); }
static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error uintAtPut(Flag* flag, uint* value, Flag::Flags origin);
static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); }
static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error intxAtPut(Flag* flag, intx* value, Flag::Flags origin);
static Flag::Error intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
static Flag::Error intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); }
static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false) { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin);
static Flag::Error uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin);
static Flag::Error uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false) { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin);
static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin);
static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin);
static Flag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin);
static Flag::Error uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false) { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }
+ static Flag::Error doubleAtPut(Flag* flag, double* value, Flag::Flags origin);
static Flag::Error doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin);
static Flag::Error doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }