Mercurial > hg > graal-compiler

comparison src/share/vm/classfile/loaderConstraints.hpp @ 2177:3582bf76420e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6990754: Use native memory and reference counting to implement SymbolTable Summary: move symbols from permgen into C heap and reference count them Reviewed-by: never, acorn, jmasa, stefank
author coleenp
date Thu, 27 Jan 2011 16:11:27 -0800
parents f95d63e2154a
children 1d1603768966
comparison
equal deleted inserted replaced
2176:27e4ea99855d 2177:3582bf76420e
29 #include "classfile/placeholders.hpp" 29 #include "classfile/placeholders.hpp"
30 #include "utilities/hashtable.hpp" 30 #include "utilities/hashtable.hpp"
31 31
32 class LoaderConstraintEntry; 32 class LoaderConstraintEntry;
33 33
34 class LoaderConstraintTable : public Hashtable { 34 class LoaderConstraintTable : public Hashtable<klassOop> {
35 friend class VMStructs; 35 friend class VMStructs;
36 private: 36 private:
37 37
38 enum Constants { 38 enum Constants {
39 _loader_constraint_size = 107, // number of entries in constraint table 39 _loader_constraint_size = 107, // number of entries in constraint table
40 _nof_buckets = 1009 // number of buckets in hash table 40 _nof_buckets = 1009 // number of buckets in hash table
41 }; 41 };
42 42
43 LoaderConstraintEntry** find_loader_constraint(symbolHandle name, 43 LoaderConstraintEntry** find_loader_constraint(Symbol* name,
44 Handle loader); 44 Handle loader);
45 45
46 public: 46 public:
47 47
48 LoaderConstraintTable(int nof_buckets); 48 LoaderConstraintTable(int nof_buckets);
49 49
50 LoaderConstraintEntry* new_entry(unsigned int hash, symbolOop name, 50 LoaderConstraintEntry* new_entry(unsigned int hash, Symbol* name,
51 klassOop klass, int num_loaders, 51 klassOop klass, int num_loaders,
52 int max_loaders); 52 int max_loaders);
53 void free_entry(LoaderConstraintEntry *entry);
53 54
54 LoaderConstraintEntry* bucket(int i) { 55 LoaderConstraintEntry* bucket(int i) {
55 return (LoaderConstraintEntry*)Hashtable::bucket(i); 56 return (LoaderConstraintEntry*)Hashtable<klassOop>::bucket(i);
56 } 57 }
57 58
58 LoaderConstraintEntry** bucket_addr(int i) { 59 LoaderConstraintEntry** bucket_addr(int i) {
59 return (LoaderConstraintEntry**)Hashtable::bucket_addr(i); 60 return (LoaderConstraintEntry**)Hashtable<klassOop>::bucket_addr(i);
60 } 61 }
61 62
62 // GC support 63 // GC support
63 void oops_do(OopClosure* f); 64 void oops_do(OopClosure* f);
64 void always_strong_classes_do(OopClosure* blk);
65 65
66 // Check class loader constraints 66 // Check class loader constraints
67 bool add_entry(symbolHandle name, klassOop klass1, Handle loader1, 67 bool add_entry(Symbol* name, klassOop klass1, Handle loader1,
68 klassOop klass2, Handle loader2); 68 klassOop klass2, Handle loader2);
69 69
70 // Note: The main entry point for this module is via SystemDictionary. 70 // Note: The main entry point for this module is via SystemDictionary.
71 // SystemDictionary::check_signature_loaders(symbolHandle signature, 71 // SystemDictionary::check_signature_loaders(Symbol* signature,
72 // Handle loader1, Handle loader2, 72 // Handle loader1, Handle loader2,
73 // bool is_method, TRAPS) 73 // bool is_method, TRAPS)
74 74
75 klassOop find_constrained_klass(symbolHandle name, Handle loader); 75 klassOop find_constrained_klass(Symbol* name, Handle loader);
76 76
77 // Class loader constraints 77 // Class loader constraints
78 78
79 void ensure_loader_constraint_capacity(LoaderConstraintEntry *p, int nfree); 79 void ensure_loader_constraint_capacity(LoaderConstraintEntry *p, int nfree);
80 void extend_loader_constraint(LoaderConstraintEntry* p, Handle loader, 80 void extend_loader_constraint(LoaderConstraintEntry* p, Handle loader,
81 klassOop klass); 81 klassOop klass);
82 void merge_loader_constraints(LoaderConstraintEntry** pp1, 82 void merge_loader_constraints(LoaderConstraintEntry** pp1,
83 LoaderConstraintEntry** pp2, klassOop klass); 83 LoaderConstraintEntry** pp2, klassOop klass);
84 84
85 bool check_or_update(instanceKlassHandle k, Handle loader, 85 bool check_or_update(instanceKlassHandle k, Handle loader,
86 symbolHandle name); 86 Symbol* name);
87 87
88 88
89 void purge_loader_constraints(BoolObjectClosure* is_alive); 89 void purge_loader_constraints(BoolObjectClosure* is_alive);
90 90
91 void verify(Dictionary* dictionary, PlaceholderTable* placeholders); 91 void verify(Dictionary* dictionary, PlaceholderTable* placeholders);
92 #ifndef PRODUCT 92 #ifndef PRODUCT
93 void print(); 93 void print();
94 #endif 94 #endif
95 }; 95 };
96 96
97 class LoaderConstraintEntry : public HashtableEntry { 97 class LoaderConstraintEntry : public HashtableEntry<klassOop> {
98 friend class VMStructs; 98 friend class VMStructs;
99 private: 99 private:
100 symbolOop _name; // class name 100 Symbol* _name; // class name
101 int _num_loaders; 101 int _num_loaders;
102 int _max_loaders; 102 int _max_loaders;
103 oop* _loaders; // initiating loaders 103 oop* _loaders; // initiating loaders
104 104
105 public: 105 public:
106 106
107 klassOop klass() { return (klassOop)literal(); } 107 klassOop klass() { return literal(); }
108 klassOop* klass_addr() { return (klassOop*)literal_addr(); } 108 klassOop* klass_addr() { return literal_addr(); }
109 void set_klass(klassOop k) { set_literal(k); } 109 void set_klass(klassOop k) { set_literal(k); }
110 110
111 LoaderConstraintEntry* next() { 111 LoaderConstraintEntry* next() {
112 return (LoaderConstraintEntry*)HashtableEntry::next(); 112 return (LoaderConstraintEntry*)HashtableEntry<klassOop>::next();
113 } 113 }
114 114
115 LoaderConstraintEntry** next_addr() { 115 LoaderConstraintEntry** next_addr() {
116 return (LoaderConstraintEntry**)HashtableEntry::next_addr(); 116 return (LoaderConstraintEntry**)HashtableEntry<klassOop>::next_addr();
117 } 117 }
118 void set_next(LoaderConstraintEntry* next) { 118 void set_next(LoaderConstraintEntry* next) {
119 HashtableEntry::set_next(next); 119 HashtableEntry<klassOop>::set_next(next);
120 } 120 }
121 121
122 symbolOop name() { return _name; } 122 Symbol* name() { return _name; }
123 symbolOop* name_addr() { return &_name; } 123 void set_name(Symbol* name) {
124 void set_name(symbolOop name) { _name = name; } 124 _name = name;
125 if (name != NULL) name->increment_refcount();
126 }
125 127
126 int num_loaders() { return _num_loaders; } 128 int num_loaders() { return _num_loaders; }
127 void set_num_loaders(int i) { _num_loaders = i; } 129 void set_num_loaders(int i) { _num_loaders = i; }
128 130
129 int max_loaders() { return _max_loaders; } 131 int max_loaders() { return _max_loaders; }