Mercurial > hg > graal-compiler
comparison src/share/vm/classfile/loaderConstraints.hpp @ 2177:3582bf76420e
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; } |