Mercurial > hg > truffle

comparison src/share/vm/classfile/loaderConstraints.hpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author coleenp
date Sat, 01 Sep 2012 13:25:18 -0400
parents d2a62e0f25eb
children
comparison
equal deleted inserted replaced
6724:36d1d483d5d6 6725:da91efe96a93
1 /* 1 /*
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
28 #include "classfile/dictionary.hpp" 28 #include "classfile/dictionary.hpp"
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 class Symbol;
33 34
34 class LoaderConstraintTable : public Hashtable<klassOop, mtClass> { 35 class LoaderConstraintTable : public Hashtable<Klass*, mtClass> {
35 friend class VMStructs; 36 friend class VMStructs;
36 private: 37 private:
37 38
38 enum Constants { 39 enum Constants {
39 _loader_constraint_size = 107, // number of entries in constraint table 40 _loader_constraint_size = 107, // number of entries in constraint table
46 public: 47 public:
47 48
48 LoaderConstraintTable(int nof_buckets); 49 LoaderConstraintTable(int nof_buckets);
49 50
50 LoaderConstraintEntry* new_entry(unsigned int hash, Symbol* name, 51 LoaderConstraintEntry* new_entry(unsigned int hash, Symbol* name,
51 klassOop klass, int num_loaders, 52 Klass* klass, int num_loaders,
52 int max_loaders); 53 int max_loaders);
53 void free_entry(LoaderConstraintEntry *entry); 54 void free_entry(LoaderConstraintEntry *entry);
54 55
55 LoaderConstraintEntry* bucket(int i) { 56 LoaderConstraintEntry* bucket(int i) {
56 return (LoaderConstraintEntry*)Hashtable<klassOop, mtClass>::bucket(i); 57 return (LoaderConstraintEntry*)Hashtable<Klass*, mtClass>::bucket(i);
57 } 58 }
58 59
59 LoaderConstraintEntry** bucket_addr(int i) { 60 LoaderConstraintEntry** bucket_addr(int i) {
60 return (LoaderConstraintEntry**)Hashtable<klassOop, mtClass>::bucket_addr(i); 61 return (LoaderConstraintEntry**)Hashtable<Klass*, mtClass>::bucket_addr(i);
61 } 62 }
62 63
63 // GC support 64 // Enhanced Class Redefinition support
64 void oops_do(OopClosure* f); 65 void classes_do(KlassClosure* f);
65 66
66 // Check class loader constraints 67 // Check class loader constraints
67 bool add_entry(Symbol* name, klassOop klass1, Handle loader1, 68 bool add_entry(Symbol* name, Klass* klass1, Handle loader1,
68 klassOop klass2, Handle loader2); 69 Klass* klass2, Handle loader2);
69 70
70 // Note: The main entry point for this module is via SystemDictionary. 71 // Note: The main entry point for this module is via SystemDictionary.
71 // SystemDictionary::check_signature_loaders(Symbol* signature, 72 // SystemDictionary::check_signature_loaders(Symbol* signature,
72 // Handle loader1, Handle loader2, 73 // Handle loader1, Handle loader2,
73 // bool is_method, TRAPS) 74 // bool is_method, TRAPS)
74 75
75 klassOop find_constrained_klass(Symbol* name, Handle loader); 76 Klass* find_constrained_klass(Symbol* name, Handle loader);
76 77
77 // Class loader constraints 78 // Class loader constraints
78 79
79 void ensure_loader_constraint_capacity(LoaderConstraintEntry *p, int nfree); 80 void ensure_loader_constraint_capacity(LoaderConstraintEntry *p, int nfree);
80 void extend_loader_constraint(LoaderConstraintEntry* p, Handle loader, 81 void extend_loader_constraint(LoaderConstraintEntry* p, Handle loader,
81 klassOop klass); 82 Klass* klass);
82 void merge_loader_constraints(LoaderConstraintEntry** pp1, 83 void merge_loader_constraints(LoaderConstraintEntry** pp1,
83 LoaderConstraintEntry** pp2, klassOop klass); 84 LoaderConstraintEntry** pp2, Klass* klass);
84 85
85 bool check_or_update(instanceKlassHandle k, Handle loader, 86 bool check_or_update(instanceKlassHandle k, Handle loader,
86 Symbol* name); 87 Symbol* name);
87 88
88 89
89 void purge_loader_constraints(BoolObjectClosure* is_alive); 90 void purge_loader_constraints();
90 91
91 void verify(Dictionary* dictionary, PlaceholderTable* placeholders); 92 void verify(Dictionary* dictionary, PlaceholderTable* placeholders);
92 #ifndef PRODUCT 93 #ifndef PRODUCT
93 void print(); 94 void print();
94 #endif 95 #endif
95 }; 96 };
96 97
97 class LoaderConstraintEntry : public HashtableEntry<klassOop, mtClass> { 98 class LoaderConstraintEntry : public HashtableEntry<Klass*, mtClass> {
98 friend class VMStructs; 99 friend class VMStructs;
99 private: 100 private:
100 Symbol* _name; // class name 101 Symbol* _name; // class name
101 int _num_loaders; 102 int _num_loaders;
102 int _max_loaders; 103 int _max_loaders;
103 oop* _loaders; // initiating loaders 104 // Loader constraints enforce correct linking behavior.
105 // Thus, it really operates on ClassLoaderData which represents linking domain,
106 // not class loaders.
107 ClassLoaderData** _loaders; // initiating loaders
104 108
105 public: 109 public:
106 110
107 klassOop klass() { return literal(); } 111 Klass* klass() { return literal(); }
108 klassOop* klass_addr() { return literal_addr(); } 112 Klass** klass_addr() { return literal_addr(); }
109 void set_klass(klassOop k) { set_literal(k); } 113 void set_klass(Klass* k) { set_literal(k); }
110 114
111 LoaderConstraintEntry* next() { 115 LoaderConstraintEntry* next() {
112 return (LoaderConstraintEntry*)HashtableEntry<klassOop, mtClass>::next(); 116 return (LoaderConstraintEntry*)HashtableEntry<Klass*, mtClass>::next();
113 } 117 }
114 118
115 LoaderConstraintEntry** next_addr() { 119 LoaderConstraintEntry** next_addr() {
116 return (LoaderConstraintEntry**)HashtableEntry<klassOop, mtClass>::next_addr(); 120 return (LoaderConstraintEntry**)HashtableEntry<Klass*, mtClass>::next_addr();
117 } 121 }
118 void set_next(LoaderConstraintEntry* next) { 122 void set_next(LoaderConstraintEntry* next) {
119 HashtableEntry<klassOop, mtClass>::set_next(next); 123 HashtableEntry<Klass*, mtClass>::set_next(next);
120 } 124 }
121 125
122 Symbol* name() { return _name; } 126 Symbol* name() { return _name; }
123 void set_name(Symbol* name) { 127 void set_name(Symbol* name) {
124 _name = name; 128 _name = name;
129 void set_num_loaders(int i) { _num_loaders = i; } 133 void set_num_loaders(int i) { _num_loaders = i; }
130 134
131 int max_loaders() { return _max_loaders; } 135 int max_loaders() { return _max_loaders; }
132 void set_max_loaders(int i) { _max_loaders = i; } 136 void set_max_loaders(int i) { _max_loaders = i; }
133 137
134 oop* loaders() { return _loaders; } 138 ClassLoaderData** loaders() { return _loaders; }
135 void set_loaders(oop* loaders) { _loaders = loaders; } 139 void set_loaders(ClassLoaderData** loaders) { _loaders = loaders; }
136 140
137 oop loader(int i) { return _loaders[i]; } 141 ClassLoaderData* loader_data(int i) { return _loaders[i]; }
138 oop* loader_addr(int i) { return &_loaders[i]; } 142 void set_loader_data(int i, ClassLoaderData* p) { _loaders[i] = p; }
139 void set_loader(int i, oop p) { _loaders[i] = p; } 143 // convenience
140 144 void set_loader(int i, oop p);
141 }; 145 };
142 146
143 #endif // SHARE_VM_CLASSFILE_LOADERCONSTRAINTS_HPP 147 #endif // SHARE_VM_CLASSFILE_LOADERCONSTRAINTS_HPP