jdk-sandbox: comparison src/hotspot/share/classfile/classFileParser.cpp

equal deleted inserted replaced

-:2178d300d6b3
+:675dbad7a9b0
 // This method is also called from the modular system APIs in modules.cpp
 // to verify the validity of module and package names.
 bool ClassFileParser::verify_unqualified_name(const char* name,
 unsigned int length,
 int type) {
-for (const char* p = name; p != name + length;) {
+for (const char* p = name; p != name + length; p++) {
-jchar ch = *p;
+switch(*p) {
-if (ch < 128) {
+case '.':
-if (ch == '.' || ch == ';' || ch == '[' ) {
+case ';':
-return false;   // do not permit '.', ';', or '['
+case '[':
-}
+// do not permit '.', ';', or '['
-if (ch == '/') {
+return false;
+case '/':
 // check for '//' or leading or trailing '/' which are not legal
 // unqualified name must not be empty
 if (type == ClassFileParser::LegalClass) {
 if (p == name || p+1 >= name+length || *(p+1) == '/') {
 return false;
 }
 } else {
 return false;   // do not permit '/' unless it's class name
 }
-}
+break;
-if (type == ClassFileParser::LegalMethod && (ch == '<' || ch == '>')) {
+case '<':
-return false;   // do not permit '<' or '>' in method names
+case '>':
-}
+// do not permit '<' or '>' in method names
-p++;
+if (type == ClassFileParser::LegalMethod) {
-} else {
+return false;
-char* tmp_p = UTF8::next(p, &ch);
+}
-p = tmp_p;
 }
 }
 return true;
 }
 // be taken as a fieldname. Allow '/' if slash_ok is true.
 // Return a pointer to just past the fieldname.
 // Return NULL if no fieldname at all was found, or in the case of slash_ok
 // being true, we saw consecutive slashes (meaning we were looking for a
 // qualified path but found something that was badly-formed).
-static const char* skip_over_field_name(const char* name,
+static const char* skip_over_field_name(const char* const name,
 bool slash_ok,
 unsigned int length) {
 const char* p;
 jboolean last_is_slash = false;
 jboolean not_first_ch = false;
 p = tmp_p;
 last_is_slash = false;
 // Check if ch is Java identifier start or is Java identifier part
 // 4672820: call java.lang.Character methods directly without generating separate tables.
 EXCEPTION_MARK;
 // return value
 JavaValue result(T_BOOLEAN);
-// Set up the arguments to isJavaIdentifierStart and isJavaIdentifierPart
+// Set up the arguments to isJavaIdentifierStart or isJavaIdentifierPart
 JavaCallArguments args;
 args.push_int(unicode_ch);
-// public static boolean isJavaIdentifierStart(char ch);
-JavaCalls::call_static(&result,
-SystemDictionary::Character_klass(),
-vmSymbols::isJavaIdentifierStart_name(),
-vmSymbols::int_bool_signature(),
-&args,
-THREAD);
-if (HAS_PENDING_EXCEPTION) {
-CLEAR_PENDING_EXCEPTION;
-return 0;
-}
-if (result.get_jboolean()) {
-continue;
-}
 if (not_first_ch) {
 // public static boolean isJavaIdentifierPart(char ch);
 JavaCalls::call_static(&result,
 SystemDictionary::Character_klass(),
 vmSymbols::isJavaIdentifierPart_name(),
 vmSymbols::int_bool_signature(),
 &args,
 THREAD);
+} else {
-if (HAS_PENDING_EXCEPTION) {
+// public static boolean isJavaIdentifierStart(char ch);
-CLEAR_PENDING_EXCEPTION;
+JavaCalls::call_static(&result,
-return 0;
+SystemDictionary::Character_klass(),
-}
+vmSymbols::isJavaIdentifierStart_name(),
+vmSymbols::int_bool_signature(),
-if (result.get_jboolean()) {
+&args,
-continue;
+THREAD);
 }
+if (HAS_PENDING_EXCEPTION) {
+CLEAR_PENDING_EXCEPTION;
+return NULL;
+}
+if(result.get_jboolean()) {
+continue;
 }
 }
 return (not_first_ch) ? old_p : NULL;
 }
 return (not_first_ch) ? p : NULL;
 return p + 1;
 }
 }
 else {
 // Skip leading 'L' and ignore first appearance of ';'
-length--;
 signature++;
 char* c = strchr((char*) signature, ';');
 // Format check signature
 if (c != NULL) {
-ResourceMark rm(THREAD);
 int newlen = c - (char*) signature;
-char* sig = NEW_RESOURCE_ARRAY(char, newlen + 1);
+bool legal = verify_unqualified_name(signature, newlen, LegalClass);
-strncpy(sig, signature, newlen);
-sig[newlen] = '\0';
-bool legal = verify_unqualified_name(sig, newlen, LegalClass);
 if (!legal) {
 classfile_parse_error("Class name contains illegal character "
 "in descriptor in class file %s",
 CHECK_0);
 return NULL;
 // Checks if name is a legal class name.
 void ClassFileParser::verify_legal_class_name(const Symbol* name, TRAPS) const {
 if (!_need_verify || _relax_verify) { return; }
-char buf[fixed_buffer_size];
+assert(name->refcount() > 0, "symbol must be kept alive");
-char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
+char* bytes = (char*)name->bytes();
 unsigned int length = name->utf8_length();
 bool legal = false;
 if (length > 0) {
 const char* p;
 // Checks if name is a legal field name.
 void ClassFileParser::verify_legal_field_name(const Symbol* name, TRAPS) const {
 if (!_need_verify || _relax_verify) { return; }
-char buf[fixed_buffer_size];
+char* bytes = (char*)name->bytes();
-char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = name->utf8_length();
 bool legal = false;
 if (length > 0) {
 if (_major_version < JAVA_1_5_VERSION) {
 // Checks if name is a legal method name.
 void ClassFileParser::verify_legal_method_name(const Symbol* name, TRAPS) const {
 if (!_need_verify || _relax_verify) { return; }
 assert(name != NULL, "method name is null");
-char buf[fixed_buffer_size];
+char* bytes = (char*)name->bytes();
-char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = name->utf8_length();
 bool legal = false;
 if (length > 0) {
 if (bytes[0] == '<') {
 void ClassFileParser::verify_legal_field_signature(const Symbol* name,
 const Symbol* signature,
 TRAPS) const {
 if (!_need_verify) { return; }
-char buf[fixed_buffer_size];
+const char* const bytes = (const char* const)signature->bytes();
-const char* const bytes = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 const unsigned int length = signature->utf8_length();
 const char* const p = skip_over_field_signature(bytes, false, length, CHECK);
 if (p == NULL || (p - bytes) != (int)length) {
 throwIllegalSignature("Field", name, signature, CHECK);
 throwIllegalSignature("Method", name, signature, CHECK_0);
 return 0;
 }
 unsigned int args_size = 0;
-char buf[fixed_buffer_size];
+const char* p = (const char*)signature->bytes();
-const char* p = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
 unsigned int length = signature->utf8_length();
 const char* nextp;
 // The first character must be a '('
 if ((length > 0) && (*p++ == JVM_SIGNATURE_FUNC)) {

changeset 53728	675dbad7a9b0
parent 53705	757e9407bafc
child 53739	4dab92cc7aed