--- a/hotspot/src/share/vm/ci/ciMethod.cpp	Fri Aug 29 19:45:49 2014 -0400
+++ b/hotspot/src/share/vm/ci/ciMethod.cpp	Tue Sep 02 10:26:48 2014 -0700
@@ -1102,6 +1102,22 @@
 }
 
 // ------------------------------------------------------------------
+// ciMethod::has_option_value
+//
+template<typename T>
+bool ciMethod::has_option_value(const char* option, T& value) {
+  check_is_loaded();
+  VM_ENTRY_MARK;
+  methodHandle mh(THREAD, get_Method());
+  return CompilerOracle::has_option_value(mh, option, value);
+}
+// Explicit instantiation for all OptionTypes supported.
+template bool ciMethod::has_option_value<intx>(const char* option, intx& value);
+template bool ciMethod::has_option_value<uintx>(const char* option, uintx& value);
+template bool ciMethod::has_option_value<bool>(const char* option, bool& value);
+template bool ciMethod::has_option_value<ccstr>(const char* option, ccstr& value);
+
+// ------------------------------------------------------------------
 // ciMethod::can_be_compiled
 //
 // Have previous compilations of this method succeeded?

--- a/hotspot/src/share/vm/ci/ciMethod.hpp	Fri Aug 29 19:45:49 2014 -0400
+++ b/hotspot/src/share/vm/ci/ciMethod.hpp	Tue Sep 02 10:26:48 2014 -0700
@@ -269,6 +269,8 @@
   bool should_print_assembly();
   bool break_at_execute();
   bool has_option(const char *option);
+  template<typename T>
+  bool has_option_value(const char* option, T& value);
   bool can_be_compiled();
   bool can_be_osr_compiled(int entry_bci);
   void set_not_compilable(const char* reason = NULL);

--- a/hotspot/src/share/vm/compiler/compilerOracle.cpp	Fri Aug 29 19:45:49 2014 -0400
+++ b/hotspot/src/share/vm/compiler/compilerOracle.cpp	Tue Sep 02 10:26:48 2014 -0700
@@ -173,7 +173,6 @@
   UintxType,
   BoolType,
   CcstrType,
-  CcstrListType,
   UnknownType
 };
 
@@ -195,6 +194,19 @@
   return BoolType;
 }
 
+template<> OptionType get_type_for<ccstr>() {
+  return CcstrType;
+}
+
+template<typename T>
+static const T copy_value(const T value) {
+  return value;
+}
+
+template<> const ccstr copy_value<ccstr>(const ccstr value) {
+  return (const ccstr)os::strdup_check_oom(value);
+}
+
 template <typename T>
 class TypedMethodOptionMatcher : public MethodMatcher {
   const char* _option;
@@ -207,7 +219,7 @@
                            Symbol* signature, const char* opt,
                            const T value,  MethodMatcher* next) :
     MethodMatcher(class_name, class_mode, method_name, method_mode, signature, next),
-                  _type(get_type_for<T>()), _value(value) {
+                  _type(get_type_for<T>()), _value(copy_value<T>(value)) {
     _option = os::strdup_check_oom(opt);
   }
 
@@ -253,8 +265,8 @@
 void TypedMethodOptionMatcher<intx>::print() {
   ttyLocker ttyl;
   print_base();
-  tty->print(" %s", _option);
-  tty->print(" " INTX_FORMAT, _value);
+  tty->print(" intx %s", _option);
+  tty->print(" = " INTX_FORMAT, _value);
   tty->cr();
 };
 
@@ -262,8 +274,8 @@
 void TypedMethodOptionMatcher<uintx>::print() {
   ttyLocker ttyl;
   print_base();
-  tty->print(" %s", _option);
-  tty->print(" " UINTX_FORMAT, _value);
+  tty->print(" uintx %s", _option);
+  tty->print(" = " UINTX_FORMAT, _value);
   tty->cr();
 };
 
@@ -271,8 +283,17 @@
 void TypedMethodOptionMatcher<bool>::print() {
   ttyLocker ttyl;
   print_base();
-  tty->print(" %s", _option);
-  tty->print(" %s", _value ? "true" : "false");
+  tty->print(" bool %s", _option);
+  tty->print(" = %s", _value ? "true" : "false");
+  tty->cr();
+};
+
+template<>
+void TypedMethodOptionMatcher<ccstr>::print() {
+  ttyLocker ttyl;
+  print_base();
+  tty->print(" const char* %s", _option);
+  tty->print(" = '%s'", _value);
   tty->cr();
 };
 
@@ -368,6 +389,7 @@
 template bool CompilerOracle::has_option_value<intx>(methodHandle method, const char* option, intx& value);
 template bool CompilerOracle::has_option_value<uintx>(methodHandle method, const char* option, uintx& value);
 template bool CompilerOracle::has_option_value<bool>(methodHandle method, const char* option, bool& value);
+template bool CompilerOracle::has_option_value<ccstr>(methodHandle method, const char* option, ccstr& value);
 
 bool CompilerOracle::should_exclude(methodHandle method, bool& quietly) {
   quietly = true;
@@ -543,12 +565,45 @@
       } else {
         jio_snprintf(errorbuf, buf_size, "  Value cannot be read for flag %s of type %s", flag, type);
       }
+    } else if (strcmp(type, "ccstr") == 0) {
+      ResourceMark rm;
+      char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
+      if (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", value, &bytes_read) == 1) {
+        total_bytes_read += bytes_read;
+        return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
+      } else {
+        jio_snprintf(errorbuf, buf_size, "  Value cannot be read for flag %s of type %s", flag, type);
+      }
+    } else if (strcmp(type, "ccstrlist") == 0) {
+      // Accumulates several strings into one. The internal type is ccstr.
+      ResourceMark rm;
+      char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
+      char* next_value = value;
+      if (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", next_value, &bytes_read) == 1) {
+        total_bytes_read += bytes_read;
+        line += bytes_read;
+        next_value += bytes_read;
+        char* end_value = next_value-1;
+        while (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", next_value, &bytes_read) == 1) {
+          total_bytes_read += bytes_read;
+          line += bytes_read;
+          *end_value = ' '; // override '\0'
+          next_value += bytes_read;
+          end_value = next_value-1;
+        }
+        return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
+      } else {
+        jio_snprintf(errorbuf, buf_size, "  Value cannot be read for flag %s of type %s", flag, type);
+      }
     } else if (strcmp(type, "bool") == 0) {
       char value[256];
       if (sscanf(line, "%*[ \t]%255[a-zA-Z]%n", value, &bytes_read) == 1) {
         if (strcmp(value, "true") == 0) {
           total_bytes_read += bytes_read;
           return add_option_string(c_name, c_match, m_name, m_match, signature, flag, true);
+        } else if (strcmp(value, "false") == 0) {
+          total_bytes_read += bytes_read;
+          return add_option_string(c_name, c_match, m_name, m_match, signature, flag, false);
         } else {
           jio_snprintf(errorbuf, buf_size, "  Value cannot be read for flag %s of type %s", flag, type);
         }
@@ -649,8 +704,7 @@
       // (i.e., to check if a flag "someflag" is enabled for a method).
       //
       // Type (2) is used to support options with a value. Values can have the
-      // the following types: intx, uintx, bool, ccstr, and ccstrlist. Currently,
-      // values of type intx, uintx, and bool are supported.
+      // the following types: intx, uintx, bool, ccstr, and ccstrlist.
       //
       // For future extensions: extend scan_flag_and_value()
       char option[256]; // stores flag for Type (1) and type of Type (2)

--- a/hotspot/src/share/vm/opto/compile.hpp	Fri Aug 29 19:45:49 2014 -0400
+++ b/hotspot/src/share/vm/opto/compile.hpp	Tue Sep 02 10:26:48 2014 -0700
@@ -601,6 +601,10 @@
   bool          method_has_option(const char * option) {
     return method() != NULL && method()->has_option(option);
   }
+  template<typename T>
+  bool          method_has_option_value(const char * option, T& value) {
+    return method() != NULL && method()->has_option_value(option, value);
+  }
 #ifndef PRODUCT
   bool          trace_opto_output() const       { return _trace_opto_output; }
   bool              parsed_irreducible_loop() const { return _parsed_irreducible_loop; }