Mon, 25 Jun 2012 21:33:35 -0400
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
Summary: Cannot delete _buckets and HashtableEntries in shared space (CDS)
Reviewed-by: acorn, kvn, dlong, dcubed, kamg
1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
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
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 // FORMS.CPP - Definitions for ADL Parser Generic & Utility Forms Classes
26 #include "adlc.hpp"
28 //------------------------------Static Initializers----------------------------
29 // allocate arena used by forms
30 Arena *Form::arena = Form::generate_arena(); // = Form::generate_arena();
31 Arena *Form::generate_arena() {
32 return (new Arena);
33 }
35 //------------------------------NameList---------------------------------------
36 // reserved user-defined string
37 const char *NameList::_signal = "$$SIGNAL$$";
38 const char *NameList::_signal2 = "$$SIGNAL2$$";
39 const char *NameList::_signal3 = "$$SIGNAL3$$";
41 // Constructor and Destructor
42 NameList::NameList() : _cur(0), _max(4), _iter(0), _justReset(true) {
43 _names = (const char**)malloc(_max*sizeof(char*));
44 }
45 NameList::~NameList() {
46 // The following free is a double-free, and crashes the program:
47 //free(_names); // not owner of strings
48 }
50 void NameList::addName(const char *name) {
51 if (_cur == _max) _names =(const char**)realloc(_names,(_max *=2)*sizeof(char*));
52 _names[_cur++] = name;
53 }
55 void NameList::add_signal() {
56 addName( _signal );
57 }
58 void NameList::clear() {
59 _cur = 0;
60 _iter = 0;
61 _justReset = true;
62 // _max = 4; Already allocated
63 }
65 int NameList::count() const { return _cur; }
67 void NameList::reset() { _iter = 0; _justReset = true;}
68 const char *NameList::iter() {
69 if (_justReset) {_justReset=false; return (_iter < _cur ? _names[_iter] : NULL);}
70 else return (_iter <_cur-1 ? _names[++_iter] : NULL);
71 }
72 const char *NameList::current() { return (_iter < _cur ? _names[_iter] : NULL); }
73 const char *NameList::peek(int skip) { return (_iter + skip < _cur ? _names[_iter + skip] : NULL); }
75 // Return 'true' if current entry is signal
76 bool NameList::current_is_signal() {
77 const char *entry = current();
78 return is_signal(entry);
79 }
81 // Return true if entry is a signal
82 bool NameList::is_signal(const char *entry) {
83 return ( (strcmp(entry,NameList::_signal) == 0) ? true : false);
84 }
86 // Search for a name in the list
87 bool NameList::search(const char *name) {
88 const char *entry;
89 for(reset(); (entry = iter()) != NULL; ) {
90 if(!strcmp(entry,name)) return true;
91 }
92 return false;
93 }
95 // Return index of name in list
96 int NameList::index(const char *name) {
97 int cnt = 0;
98 const char *entry;
99 for(reset(); (entry = iter()) != NULL; ) {
100 if(!strcmp(entry,name)) return cnt;
101 cnt++;
102 }
103 return Not_in_list;
104 }
106 // Return name at index in list
107 const char *NameList::name(intptr_t index) {
108 return ( index < _cur ? _names[index] : NULL);
109 }
111 void NameList::dump() { output(stderr); }
113 void NameList::output(FILE *fp) {
114 fprintf(fp, "\n");
116 // Run iteration over all entries, independent of position of iterator.
117 const char *name = NULL;
118 int iter = 0;
119 bool justReset = true;
121 while( ( name = (justReset ?
122 (justReset=false, (iter < _cur ? _names[iter] : NULL)) :
123 (iter < _cur-1 ? _names[++iter] : NULL)) )
124 != NULL ) {
125 fprintf( fp, " %s,\n", name);
126 }
127 fprintf(fp, "\n");
128 }
130 //------------------------------NameAndList------------------------------------
131 // Storage for a name and an associated list of names
132 NameAndList::NameAndList(char *name) : _name(name) {
133 }
134 NameAndList::~NameAndList() {
135 }
137 // Add to entries in list
138 void NameAndList::add_entry(const char *entry) {
139 _list.addName(entry);
140 }
142 // Access the name and its associated list.
143 const char *NameAndList::name() const { return _name; }
144 void NameAndList::reset() { _list.reset(); }
145 const char *NameAndList::iter() { return _list.iter(); }
147 // Return the "index" entry in the list, zero-based
148 const char *NameAndList::operator[](int index) {
149 assert( index >= 0, "Internal Error(): index less than 0.");
151 _list.reset();
152 const char *entry = _list.iter();
153 // Iterate further if it isn't at index 0.
154 for ( int position = 0; position != index; ++position ) {
155 entry = _list.iter();
156 }
158 return entry;
159 }
162 void NameAndList::dump() { output(stderr); }
163 void NameAndList::output(FILE *fp) {
164 fprintf(fp, "\n");
166 // Output the Name
167 fprintf(fp, "Name == %s", (_name ? _name : "") );
169 // Output the associated list of names
170 const char *name;
171 fprintf(fp, " (");
172 for (reset(); (name = iter()) != NULL;) {
173 fprintf(fp, " %s,\n", name);
174 }
175 fprintf(fp, ")");
176 fprintf(fp, "\n");
177 }
179 //------------------------------Form-------------------------------------------
180 OpClassForm *Form::is_opclass() const {
181 return NULL;
182 }
184 OperandForm *Form::is_operand() const {
185 return NULL;
186 }
188 InstructForm *Form::is_instruction() const {
189 return NULL;
190 }
192 MachNodeForm *Form::is_machnode() const {
193 return NULL;
194 }
196 AttributeForm *Form::is_attribute() const {
197 return NULL;
198 }
200 Effect *Form::is_effect() const {
201 return NULL;
202 }
204 ResourceForm *Form::is_resource() const {
205 return NULL;
206 }
208 PipeClassForm *Form::is_pipeclass() const {
209 return NULL;
210 }
212 Form::DataType Form::ideal_to_const_type(const char *name) const {
213 if( name == NULL ) { return Form::none; }
215 if (strcmp(name,"ConI")==0) return Form::idealI;
216 if (strcmp(name,"ConP")==0) return Form::idealP;
217 if (strcmp(name,"ConN")==0) return Form::idealN;
218 if (strcmp(name,"ConL")==0) return Form::idealL;
219 if (strcmp(name,"ConF")==0) return Form::idealF;
220 if (strcmp(name,"ConD")==0) return Form::idealD;
221 if (strcmp(name,"Bool")==0) return Form::idealI;
223 return Form::none;
224 }
226 Form::DataType Form::ideal_to_sReg_type(const char *name) const {
227 if( name == NULL ) { return Form::none; }
229 if (strcmp(name,"sRegI")==0) return Form::idealI;
230 if (strcmp(name,"sRegP")==0) return Form::idealP;
231 if (strcmp(name,"sRegF")==0) return Form::idealF;
232 if (strcmp(name,"sRegD")==0) return Form::idealD;
233 if (strcmp(name,"sRegL")==0) return Form::idealL;
234 return Form::none;
235 }
237 Form::DataType Form::ideal_to_Reg_type(const char *name) const {
238 if( name == NULL ) { return Form::none; }
240 if (strcmp(name,"RegI")==0) return Form::idealI;
241 if (strcmp(name,"RegP")==0) return Form::idealP;
242 if (strcmp(name,"RegF")==0) return Form::idealF;
243 if (strcmp(name,"RegD")==0) return Form::idealD;
244 if (strcmp(name,"RegL")==0) return Form::idealL;
246 return Form::none;
247 }
249 // True if 'opType', an ideal name, loads or stores.
250 Form::DataType Form::is_load_from_memory(const char *opType) const {
251 if( strcmp(opType,"LoadB")==0 ) return Form::idealB;
252 if( strcmp(opType,"LoadUB")==0 ) return Form::idealB;
253 if( strcmp(opType,"LoadUS")==0 ) return Form::idealC;
254 if( strcmp(opType,"LoadD")==0 ) return Form::idealD;
255 if( strcmp(opType,"LoadD_unaligned")==0 ) return Form::idealD;
256 if( strcmp(opType,"LoadF")==0 ) return Form::idealF;
257 if( strcmp(opType,"LoadI")==0 ) return Form::idealI;
258 if( strcmp(opType,"LoadUI2L")==0 ) return Form::idealI;
259 if( strcmp(opType,"LoadKlass")==0 ) return Form::idealP;
260 if( strcmp(opType,"LoadNKlass")==0 ) return Form::idealN;
261 if( strcmp(opType,"LoadL")==0 ) return Form::idealL;
262 if( strcmp(opType,"LoadL_unaligned")==0 ) return Form::idealL;
263 if( strcmp(opType,"LoadPLocked")==0 ) return Form::idealP;
264 if( strcmp(opType,"LoadP")==0 ) return Form::idealP;
265 if( strcmp(opType,"LoadN")==0 ) return Form::idealN;
266 if( strcmp(opType,"LoadRange")==0 ) return Form::idealI;
267 if( strcmp(opType,"LoadS")==0 ) return Form::idealS;
268 if( strcmp(opType,"Load16B")==0 ) return Form::idealB;
269 if( strcmp(opType,"Load8B")==0 ) return Form::idealB;
270 if( strcmp(opType,"Load4B")==0 ) return Form::idealB;
271 if( strcmp(opType,"Load8C")==0 ) return Form::idealC;
272 if( strcmp(opType,"Load4C")==0 ) return Form::idealC;
273 if( strcmp(opType,"Load2C")==0 ) return Form::idealC;
274 if( strcmp(opType,"Load8S")==0 ) return Form::idealS;
275 if( strcmp(opType,"Load4S")==0 ) return Form::idealS;
276 if( strcmp(opType,"Load2S")==0 ) return Form::idealS;
277 if( strcmp(opType,"Load2D")==0 ) return Form::idealD;
278 if( strcmp(opType,"Load4F")==0 ) return Form::idealF;
279 if( strcmp(opType,"Load2F")==0 ) return Form::idealF;
280 if( strcmp(opType,"Load4I")==0 ) return Form::idealI;
281 if( strcmp(opType,"Load2I")==0 ) return Form::idealI;
282 if( strcmp(opType,"Load2L")==0 ) return Form::idealL;
283 assert( strcmp(opType,"Load") != 0, "Must type Loads" );
284 return Form::none;
285 }
287 Form::DataType Form::is_store_to_memory(const char *opType) const {
288 if( strcmp(opType,"StoreB")==0) return Form::idealB;
289 if( strcmp(opType,"StoreCM")==0) return Form::idealB;
290 if( strcmp(opType,"StoreC")==0) return Form::idealC;
291 if( strcmp(opType,"StoreD")==0) return Form::idealD;
292 if( strcmp(opType,"StoreF")==0) return Form::idealF;
293 if( strcmp(opType,"StoreI")==0) return Form::idealI;
294 if( strcmp(opType,"StoreL")==0) return Form::idealL;
295 if( strcmp(opType,"StoreP")==0) return Form::idealP;
296 if( strcmp(opType,"StoreN")==0) return Form::idealN;
297 if( strcmp(opType,"Store16B")==0) return Form::idealB;
298 if( strcmp(opType,"Store8B")==0) return Form::idealB;
299 if( strcmp(opType,"Store4B")==0) return Form::idealB;
300 if( strcmp(opType,"Store8C")==0) return Form::idealC;
301 if( strcmp(opType,"Store4C")==0) return Form::idealC;
302 if( strcmp(opType,"Store2C")==0) return Form::idealC;
303 if( strcmp(opType,"Store2D")==0) return Form::idealD;
304 if( strcmp(opType,"Store4F")==0) return Form::idealF;
305 if( strcmp(opType,"Store2F")==0) return Form::idealF;
306 if( strcmp(opType,"Store4I")==0) return Form::idealI;
307 if( strcmp(opType,"Store2I")==0) return Form::idealI;
308 if( strcmp(opType,"Store2L")==0) return Form::idealL;
309 assert( strcmp(opType,"Store") != 0, "Must type Stores" );
310 return Form::none;
311 }
313 Form::InterfaceType Form::interface_type(FormDict &globals) const {
314 return Form::no_interface;
315 }
317 //------------------------------FormList---------------------------------------
318 // Destructor
319 FormList::~FormList() {
320 // // This list may not own its elements
321 // Form *cur = _root;
322 // Form *next = NULL;
323 // for( ; (cur = next) != NULL; ) {
324 // next = (Form *)cur->_next;
325 // delete cur;
326 // }
327 };
329 //------------------------------FormDict---------------------------------------
330 // Constructor
331 FormDict::FormDict( CmpKey cmp, Hash hash, Arena *arena )
332 : _form(cmp, hash, arena) {
333 }
334 FormDict::~FormDict() {
335 }
337 // Return # of name-Form pairs in dict
338 int FormDict::Size(void) const {
339 return _form.Size();
340 }
342 // Insert inserts the given key-value pair into the dictionary. The prior
343 // value of the key is returned; NULL if the key was not previously defined.
344 const Form *FormDict::Insert(const char *name, Form *form) {
345 return (Form*)_form.Insert((void*)name, (void*)form);
346 }
348 // Finds the value of a given key; or NULL if not found.
349 // The dictionary is NOT changed.
350 const Form *FormDict::operator [](const char *name) const {
351 return (Form*)_form[name];
352 }
354 //------------------------------FormDict::private------------------------------
355 // Disable public use of constructor, copy-ctor, operator =, operator ==
356 FormDict::FormDict( ) : _form(cmpkey,hashkey) {
357 assert( false, "NotImplemented");
358 }
359 FormDict::FormDict( const FormDict & fd) : _form(fd._form) {
360 }
361 FormDict &FormDict::operator =( const FormDict &rhs) {
362 assert( false, "NotImplemented");
363 _form = rhs._form;
364 return *this;
365 }
366 // == compares two dictionaries; they must have the same keys (their keys
367 // must match using CmpKey) and they must have the same values (pointer
368 // comparison). If so 1 is returned, if not 0 is returned.
369 bool FormDict::operator ==(const FormDict &d) const {
370 assert( false, "NotImplemented");
371 return false;
372 }
374 // Print out the dictionary contents as key-value pairs
375 static void dumpkey (const void* key) { fprintf(stdout, "%s", (char*) key); }
376 static void dumpform(const void* form) { fflush(stdout); ((Form*)form)->dump(); }
378 void FormDict::dump() {
379 _form.print(dumpkey, dumpform);
380 }
382 //------------------------------SourceForm-------------------------------------
383 SourceForm::SourceForm(char* code) : _code(code) { }; // Constructor
384 SourceForm::~SourceForm() {
385 }
387 void SourceForm::dump() { // Debug printer
388 output(stderr);
389 }
391 void SourceForm::output(FILE *fp) {
392 fprintf(fp,"\n//%s\n%s\n",classname(),(_code?_code:""));
393 }