jdk8-mips64-public/hotspot: src/share/vm/adlc/forms.cpp@4d9884b01ba6 (annotated)

src/share/vm/adlc/forms.cpp@4d9884b01ba6 (annotated)

src/share/vm/adlc/forms.cpp

Tue, 28 Oct 2008 09:31:30 -0700

author: never
date: Tue, 28 Oct 2008 09:31:30 -0700
changeset 850: 4d9884b01ba6
parent 631: d1605aabd0a1
child 993: 3b5ac9e7e6ea
permissions: -rw-r--r--

6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
Reviewed-by: kvn, rasbold

 /*
  * Copyright 1997-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.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); }
 // 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,"LoadC")==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,"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", 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:""));
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/adlc/forms.cpp@4d9884b01ba6 (annotated)

src/share/vm/adlc/forms.cpp