Mercurial > hg > graal-jvmci-8
view src/share/vm/adlc/forms.cpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
author | johnc |
---|---|
date | Thu, 22 Sep 2011 10:57:37 -0700 |
parents | f95d63e2154a |
children | 8b0a4867acf0 |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ // FORMS.CPP - Definitions for ADL Parser Generic & Utility Forms Classes #include "adlc.hpp" //------------------------------Static Initializers---------------------------- // allocate arena used by forms Arena *Form::arena = Form::generate_arena(); // = Form::generate_arena(); Arena *Form::generate_arena() { return (new Arena); } //------------------------------NameList--------------------------------------- // reserved user-defined string const char *NameList::_signal = "$$SIGNAL$$"; const char *NameList::_signal2 = "$$SIGNAL2$$"; const char *NameList::_signal3 = "$$SIGNAL3$$"; // Constructor and Destructor NameList::NameList() : _cur(0), _max(4), _iter(0), _justReset(true) { _names = (const char**)malloc(_max*sizeof(char*)); } NameList::~NameList() { // The following free is a double-free, and crashes the program: //free(_names); // not owner of strings } void NameList::addName(const char *name) { if (_cur == _max) _names =(const char**)realloc(_names,(_max *=2)*sizeof(char*)); _names[_cur++] = name; } void NameList::add_signal() { addName( _signal ); } void NameList::clear() { _cur = 0; _iter = 0; _justReset = true; // _max = 4; Already allocated } int NameList::count() const { return _cur; } void NameList::reset() { _iter = 0; _justReset = true;} const char *NameList::iter() { if (_justReset) {_justReset=false; return (_iter < _cur ? _names[_iter] : NULL);} else return (_iter <_cur-1 ? _names[++_iter] : NULL); } const char *NameList::current() { return (_iter < _cur ? _names[_iter] : NULL); } const char *NameList::peek(int skip) { return (_iter + skip < _cur ? _names[_iter + skip] : NULL); } // Return 'true' if current entry is signal bool NameList::current_is_signal() { const char *entry = current(); return is_signal(entry); } // Return true if entry is a signal bool NameList::is_signal(const char *entry) { return ( (strcmp(entry,NameList::_signal) == 0) ? true : false); } // Search for a name in the list bool NameList::search(const char *name) { const char *entry; for(reset(); (entry = iter()) != NULL; ) { if(!strcmp(entry,name)) return true; } return false; } // Return index of name in list int NameList::index(const char *name) { int cnt = 0; const char *entry; for(reset(); (entry = iter()) != NULL; ) { if(!strcmp(entry,name)) return cnt; cnt++; } return Not_in_list; } // Return name at index in list const char *NameList::name(intptr_t index) { return ( index < _cur ? _names[index] : NULL); } void NameList::dump() { output(stderr); } void NameList::output(FILE *fp) { fprintf(fp, "\n"); // Run iteration over all entries, independent of position of iterator. const char *name = NULL; int iter = 0; bool justReset = true; while( ( name = (justReset ? (justReset=false, (iter < _cur ? _names[iter] : NULL)) : (iter < _cur-1 ? _names[++iter] : NULL)) ) != NULL ) { fprintf( fp, " %s,\n", name); } fprintf(fp, "\n"); } //------------------------------NameAndList------------------------------------ // Storage for a name and an associated list of names NameAndList::NameAndList(char *name) : _name(name) { } NameAndList::~NameAndList() { } // Add to entries in list void NameAndList::add_entry(const char *entry) { _list.addName(entry); } // Access the name and its associated list. const char *NameAndList::name() const { return _name; } void NameAndList::reset() { _list.reset(); } const char *NameAndList::iter() { return _list.iter(); } // Return the "index" entry in the list, zero-based const char *NameAndList::operator[](int index) { assert( index >= 0, "Internal Error(): index less than 0."); _list.reset(); const char *entry = _list.iter(); // Iterate further if it isn't at index 0. for ( int position = 0; position != index; ++position ) { entry = _list.iter(); } return entry; } void NameAndList::dump() { output(stderr); } void NameAndList::output(FILE *fp) { fprintf(fp, "\n"); // Output the Name fprintf(fp, "Name == %s", (_name ? _name : "") ); // Output the associated list of names const char *name; fprintf(fp, " ("); for (reset(); (name = iter()) != NULL;) { fprintf(fp, " %s,\n", name); } fprintf(fp, ")"); fprintf(fp, "\n"); } //------------------------------Form------------------------------------------- OpClassForm *Form::is_opclass() const { return NULL; } OperandForm *Form::is_operand() const { return NULL; } InstructForm *Form::is_instruction() const { return NULL; } MachNodeForm *Form::is_machnode() const { return NULL; } AttributeForm *Form::is_attribute() const { return NULL; } Effect *Form::is_effect() const { return NULL; } ResourceForm *Form::is_resource() const { return NULL; } PipeClassForm *Form::is_pipeclass() const { return NULL; } Form::DataType Form::ideal_to_const_type(const char *name) const { if( name == NULL ) { return Form::none; } if (strcmp(name,"ConI")==0) return Form::idealI; if (strcmp(name,"ConP")==0) return Form::idealP; if (strcmp(name,"ConN")==0) return Form::idealN; if (strcmp(name,"ConL")==0) return Form::idealL; if (strcmp(name,"ConF")==0) return Form::idealF; if (strcmp(name,"ConD")==0) return Form::idealD; if (strcmp(name,"Bool")==0) return Form::idealI; return Form::none; } Form::DataType Form::ideal_to_sReg_type(const char *name) const { if( name == NULL ) { return Form::none; } if (strcmp(name,"sRegI")==0) return Form::idealI; if (strcmp(name,"sRegP")==0) return Form::idealP; if (strcmp(name,"sRegF")==0) return Form::idealF; if (strcmp(name,"sRegD")==0) return Form::idealD; if (strcmp(name,"sRegL")==0) return Form::idealL; return Form::none; } Form::DataType Form::ideal_to_Reg_type(const char *name) const { if( name == NULL ) { return Form::none; } if (strcmp(name,"RegI")==0) return Form::idealI; if (strcmp(name,"RegP")==0) return Form::idealP; if (strcmp(name,"RegF")==0) return Form::idealF; if (strcmp(name,"RegD")==0) return Form::idealD; if (strcmp(name,"RegL")==0) return Form::idealL; return Form::none; } // True if 'opType', an ideal name, loads or stores. Form::DataType Form::is_load_from_memory(const char *opType) const { if( strcmp(opType,"LoadB")==0 ) return Form::idealB; if( strcmp(opType,"LoadUB")==0 ) return Form::idealB; if( strcmp(opType,"LoadUS")==0 ) return Form::idealC; if( strcmp(opType,"LoadD")==0 ) return Form::idealD; if( strcmp(opType,"LoadD_unaligned")==0 ) return Form::idealD; if( strcmp(opType,"LoadF")==0 ) return Form::idealF; if( strcmp(opType,"LoadI")==0 ) return Form::idealI; if( strcmp(opType,"LoadUI2L")==0 ) return Form::idealI; if( strcmp(opType,"LoadKlass")==0 ) return Form::idealP; if( strcmp(opType,"LoadNKlass")==0 ) return Form::idealN; if( strcmp(opType,"LoadL")==0 ) return Form::idealL; if( strcmp(opType,"LoadL_unaligned")==0 ) return Form::idealL; if( strcmp(opType,"LoadPLocked")==0 ) return Form::idealP; if( strcmp(opType,"LoadLLocked")==0 ) return Form::idealL; if( strcmp(opType,"LoadP")==0 ) return Form::idealP; if( strcmp(opType,"LoadN")==0 ) return Form::idealN; if( strcmp(opType,"LoadRange")==0 ) return Form::idealI; if( strcmp(opType,"LoadS")==0 ) return Form::idealS; if( strcmp(opType,"Load16B")==0 ) return Form::idealB; if( strcmp(opType,"Load8B")==0 ) return Form::idealB; if( strcmp(opType,"Load4B")==0 ) return Form::idealB; if( strcmp(opType,"Load8C")==0 ) return Form::idealC; if( strcmp(opType,"Load4C")==0 ) return Form::idealC; if( strcmp(opType,"Load2C")==0 ) return Form::idealC; if( strcmp(opType,"Load8S")==0 ) return Form::idealS; if( strcmp(opType,"Load4S")==0 ) return Form::idealS; if( strcmp(opType,"Load2S")==0 ) return Form::idealS; if( strcmp(opType,"Load2D")==0 ) return Form::idealD; if( strcmp(opType,"Load4F")==0 ) return Form::idealF; if( strcmp(opType,"Load2F")==0 ) return Form::idealF; if( strcmp(opType,"Load4I")==0 ) return Form::idealI; if( strcmp(opType,"Load2I")==0 ) return Form::idealI; if( strcmp(opType,"Load2L")==0 ) return Form::idealL; assert( strcmp(opType,"Load") != 0, "Must type Loads" ); return Form::none; } Form::DataType Form::is_store_to_memory(const char *opType) const { if( strcmp(opType,"StoreB")==0) return Form::idealB; if( strcmp(opType,"StoreCM")==0) return Form::idealB; if( strcmp(opType,"StoreC")==0) return Form::idealC; if( strcmp(opType,"StoreD")==0) return Form::idealD; if( strcmp(opType,"StoreF")==0) return Form::idealF; if( strcmp(opType,"StoreI")==0) return Form::idealI; if( strcmp(opType,"StoreL")==0) return Form::idealL; if( strcmp(opType,"StoreP")==0) return Form::idealP; if( strcmp(opType,"StoreN")==0) return Form::idealN; if( strcmp(opType,"Store16B")==0) return Form::idealB; if( strcmp(opType,"Store8B")==0) return Form::idealB; if( strcmp(opType,"Store4B")==0) return Form::idealB; if( strcmp(opType,"Store8C")==0) return Form::idealC; if( strcmp(opType,"Store4C")==0) return Form::idealC; if( strcmp(opType,"Store2C")==0) return Form::idealC; if( strcmp(opType,"Store2D")==0) return Form::idealD; if( strcmp(opType,"Store4F")==0) return Form::idealF; if( strcmp(opType,"Store2F")==0) return Form::idealF; if( strcmp(opType,"Store4I")==0) return Form::idealI; if( strcmp(opType,"Store2I")==0) return Form::idealI; if( strcmp(opType,"Store2L")==0) return Form::idealL; assert( strcmp(opType,"Store") != 0, "Must type Stores" ); return Form::none; } Form::InterfaceType Form::interface_type(FormDict &globals) const { return Form::no_interface; } //------------------------------FormList--------------------------------------- // Destructor FormList::~FormList() { // // This list may not own its elements // Form *cur = _root; // Form *next = NULL; // for( ; (cur = next) != NULL; ) { // next = (Form *)cur->_next; // delete cur; // } }; //------------------------------FormDict--------------------------------------- // Constructor FormDict::FormDict( CmpKey cmp, Hash hash, Arena *arena ) : _form(cmp, hash, arena) { } FormDict::~FormDict() { } // Return # of name-Form pairs in dict int FormDict::Size(void) const { return _form.Size(); } // Insert inserts the given key-value pair into the dictionary. The prior // value of the key is returned; NULL if the key was not previously defined. const Form *FormDict::Insert(const char *name, Form *form) { return (Form*)_form.Insert((void*)name, (void*)form); } // Finds the value of a given key; or NULL if not found. // The dictionary is NOT changed. const Form *FormDict::operator [](const char *name) const { return (Form*)_form[name]; } //------------------------------FormDict::private------------------------------ // Disable public use of constructor, copy-ctor, operator =, operator == FormDict::FormDict( ) : _form(cmpkey,hashkey) { assert( false, "NotImplemented"); } FormDict::FormDict( const FormDict & fd) : _form(fd._form) { } FormDict &FormDict::operator =( const FormDict &rhs) { assert( false, "NotImplemented"); _form = rhs._form; return *this; } // == compares two dictionaries; they must have the same keys (their keys // must match using CmpKey) and they must have the same values (pointer // comparison). If so 1 is returned, if not 0 is returned. bool FormDict::operator ==(const FormDict &d) const { assert( false, "NotImplemented"); return false; } // Print out the dictionary contents as key-value pairs static void dumpkey (const void* key) { fprintf(stdout, "%s", (char*) key); } static void dumpform(const void* form) { fflush(stdout); ((Form*)form)->dump(); } void FormDict::dump() { _form.print(dumpkey, dumpform); } //------------------------------SourceForm------------------------------------- SourceForm::SourceForm(char* code) : _code(code) { }; // Constructor SourceForm::~SourceForm() { } void SourceForm::dump() { // Debug printer output(stderr); } void SourceForm::output(FILE *fp) { fprintf(fp,"\n//%s\n%s\n",classname(),(_code?_code:"")); }