jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/classFileParser.cpp

-:51612f0c0a79
+:fc9d8850ab8b
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // Used for backward compatibility reasons:
 // - to check NameAndType_info signatures more aggressively
 #define JAVA_7_VERSION                    51
-void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) {
+void ClassFileParser::parse_constant_pool_entries(Handle class_loader, constantPoolHandle cp, int length, TRAPS) {
 // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
 // this function (_current can be allocated in a register, with scalar
 // replacement of aggregates). The _current pointer is copied back to
 // stream() when this function returns. DON'T call another method within
 // this method that uses stream().
 names[names_count] = (char*)utf8_buffer;
 lengths[names_count] = utf8_length;
 indices[names_count] = index;
 hashValues[names_count++] = hash;
 if (names_count == SymbolTable::symbol_alloc_batch_size) {
-SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(class_loader, cp, names_count, names, lengths, indices, hashValues, CHECK);
 names_count = 0;
 }
 } else {
 cp->symbol_at_put(index, result);
 }
 }
 }
 // Allocate the remaining symbols
 if (names_count > 0) {
-SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
+SymbolTable::new_symbols(class_loader, cp, names_count, names, lengths, indices, hashValues, CHECK);
 }
 // Copy _current pointer of local copy back to stream().
 #ifdef ASSERT
 assert(cfs0->current() == old_current, "non-exclusive use of stream()");
 void set_in_error(bool clean) { _in_error = clean; }
 };
 bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }
-constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
+constantPoolHandle ClassFileParser::parse_constant_pool(Handle class_loader, TRAPS) {
 ClassFileStream* cfs = stream();
 constantPoolHandle nullHandle;
 cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
 u2 length = cfs->get_u2_fast();
 cp->set_partially_loaded();    // Enables heap verify to work on partial constantPoolOops
 ConstantPoolCleaner cp_in_error(cp); // set constant pool to be cleaned up.
 // parsing constant pool entries
-parse_constant_pool_entries(cp, length, CHECK_(nullHandle));
+parse_constant_pool_entries(class_loader, cp, length, CHECK_(nullHandle));
 int index = 1;  // declared outside of loops for portability
 // first verification pass - validate cross references and fixup class and string constants
 for (index = 1; index < length; index++) {          // Index 0 is unused
 // Check if verification needs to be relaxed for this class file
 // Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
 _relax_verify = Verifier::relax_verify_for(class_loader());
 // Constant pool
-constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
+constantPoolHandle cp = parse_constant_pool(class_loader, CHECK_(nullHandle));
 ConstantPoolCleaner error_handler(cp); // set constant pool to be cleaned up.
 int cp_size = cp->length();
 cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/classfile/classFileParser.cpp

src/share/vm/classfile/classFileParser.cpp