jdk-sandbox: comparison hotspot/src/share/vm/runtime/sharedRuntime.cpp

equal deleted inserted replaced

-:64752e56d721
+:be27e1b6a4b9
 #endif
 // A simple wrapper class around the calling convention information
 // that allows sharing of adapters for the same calling convention.
-class AdapterFingerPrint : public CHeapObj {
+class AdapterFingerPrint : public CHeapObj<mtCode> {
 private:
 union {
 int  _compact[3];
 int* _fingerprint;
 } _value;
 // of the time.
 _length = -len;
 ptr = _value._compact;
 } else {
 _length = len;
-_value._fingerprint = NEW_C_HEAP_ARRAY(int, _length);
+_value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode);
 ptr = _value._fingerprint;
 }
 // Now pack the BasicTypes with 8 per int
 int sig_index = 0;
 }
 }
 ~AdapterFingerPrint() {
 if (_length > 0) {
-FREE_C_HEAP_ARRAY(int, _value._fingerprint);
+FREE_C_HEAP_ARRAY(int, _value._fingerprint, mtCode);
 }
 }
 int value(int index) {
 if (_length < 0) {
 }
 };
 // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries
-class AdapterHandlerTable : public BasicHashtable {
+class AdapterHandlerTable : public BasicHashtable<mtCode> {
 friend class AdapterHandlerTableIterator;
 private:
 #ifndef PRODUCT
 static int _hits;    // number of successful lookups
 static int _compact; // number of equals calls with compact signature
 #endif
 AdapterHandlerEntry* bucket(int i) {
-return (AdapterHandlerEntry*)BasicHashtable::bucket(i);
+return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
 }
 public:
 AdapterHandlerTable()
-: BasicHashtable(293, sizeof(AdapterHandlerEntry)) { }
+: BasicHashtable<mtCode>(293, sizeof(AdapterHandlerEntry)) { }
 // Create a new entry suitable for insertion in the table
 AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
-AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable::new_entry(fingerprint->compute_hash());
+AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
 entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
 return entry;
 }
 // Insert an entry into the table
 add_entry(index, entry);
 }
 void free_entry(AdapterHandlerEntry* entry) {
 entry->deallocate();
-BasicHashtable::free_entry(entry);
+BasicHashtable<mtCode>::free_entry(entry);
 }
 // Find a entry with the same fingerprint if it exists
 AdapterHandlerEntry* lookup(int total_args_passed, BasicType* sig_bt) {
 NOT_PRODUCT(_lookups++);
 void AdapterHandlerEntry::deallocate() {
 delete _fingerprint;
 #ifdef ASSERT
-if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code);
+if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode);
-if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig);
+if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode);
 #endif
 }
 #ifdef ASSERT
 // Capture the code before relocation so that it can be compared
 // against other versions.  If the code is captured after relocation
 // then relative instructions won't be equivalent.
 void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
-_saved_code = NEW_C_HEAP_ARRAY(unsigned char, length);
+_saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
 _code_length = length;
 memcpy(_saved_code, buffer, length);
 _total_args_passed = total_args_passed;
-_saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed);
+_saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode);
 memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType));
 }
 bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
 methodOop moop = fr.interpreter_frame_method();
 int max_locals = moop->max_locals();
 // Allocate temp buffer, 1 word per local & 2 per active monitor
 int buf_size_words = max_locals + active_monitor_count*2;
-intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words);
+intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode);
 // Copy the locals.  Order is preserved so that loading of longs works.
 // Since there's no GC I can copy the oops blindly.
 assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
 Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
 return buf;
 JRT_END
 JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) )
-FREE_C_HEAP_ARRAY(intptr_t,buf);
+FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode);
 JRT_END
 bool AdapterHandlerLibrary::contains(CodeBlob* b) {
 AdapterHandlerTableIterator iter(_adapters);
 while (iter.has_next()) {

changeset 13195	be27e1b6a4b9
parent 11788	bef6166c683c
child 13391	30245956af37