/*

 * Copyright (c) 1998, 2012, 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 Forms Classes

#include "adlc.hpp"

//==============================Instructions===================================

//------------------------------InstructForm-----------------------------------

InstructForm::InstructForm(const char *id, bool ideal_only)

  : _ident(id), _ideal_only(ideal_only),

    _localNames(cmpstr, hashstr, Form::arena),

    _effects(cmpstr, hashstr, Form::arena),

    _is_mach_constant(false),

    _has_call(false)

{

      _ftype = Form::INS;

      _matrule              = NULL;

      _insencode            = NULL;

      _constant             = NULL;

      _is_postalloc_expand  = false;

      _opcode               = NULL;

      _size                 = NULL;

      _attribs              = NULL;

      _predicate            = NULL;

      _exprule              = NULL;

      _rewrule              = NULL;

      _format               = NULL;

      _peephole             = NULL;

      _ins_pipe             = NULL;

      _uniq_idx             = NULL;

      _num_uniq             = 0;

      _cisc_spill_operand   = Not_cisc_spillable;// Which operand may cisc-spill

      _cisc_spill_alternate = NULL;            // possible cisc replacement

      _cisc_reg_mask_name   = NULL;

      _is_cisc_alternate    = false;

      _is_short_branch      = false;

      _short_branch_form    = NULL;

      _alignment            = 1;

}

InstructForm::InstructForm(const char *id, InstructForm *instr, MatchRule *rule)

  : _ident(id), _ideal_only(false),

    _localNames(instr->_localNames),

    _effects(instr->_effects),

    _is_mach_constant(false),

    _has_call(false)

{

      _ftype = Form::INS;

      _matrule               = rule;

      _insencode             = instr->_insencode;

      _constant              = instr->_constant;

      _is_postalloc_expand   = instr->_is_postalloc_expand;

      _opcode                = instr->_opcode;

      _size                  = instr->_size;

      _attribs               = instr->_attribs;

      _predicate             = instr->_predicate;

      _exprule               = instr->_exprule;

      _rewrule               = instr->_rewrule;

      _format                = instr->_format;

      _peephole              = instr->_peephole;

      _ins_pipe              = instr->_ins_pipe;

      _uniq_idx              = instr->_uniq_idx;

      _num_uniq              = instr->_num_uniq;

      _cisc_spill_operand    = Not_cisc_spillable; // Which operand may cisc-spill

      _cisc_spill_alternate  = NULL;               // possible cisc replacement

      _cisc_reg_mask_name    = NULL;

      _is_cisc_alternate     = false;

      _is_short_branch       = false;

      _short_branch_form     = NULL;

      _alignment             = 1;

     // Copy parameters

     const char *name;

     instr->_parameters.reset();

     for (; (name = instr->_parameters.iter()) != NULL;)

       _parameters.addName(name);

}

InstructForm::~InstructForm() {

}

InstructForm *InstructForm::is_instruction() const {

  return (InstructForm*)this;

}

bool InstructForm::ideal_only() const {

  return _ideal_only;

}

bool InstructForm::sets_result() const {

  return (_matrule != NULL && _matrule->sets_result());

}

bool InstructForm::needs_projections() {

  _components.reset();

  for( Component *comp; (comp = _components.iter()) != NULL; ) {

    if (comp->isa(Component::KILL)) {

      return true;

    }

  }

  return false;

}

bool InstructForm::has_temps() {

  if (_matrule) {

    // Examine each component to see if it is a TEMP

    _components.reset();

    // Skip the first component, if already handled as (SET dst (...))

    Component *comp = NULL;

    if (sets_result())  comp = _components.iter();

    while ((comp = _components.iter()) != NULL) {

      if (comp->isa(Component::TEMP)) {

        return true;

      }

    }

  }

  return false;

}

uint InstructForm::num_defs_or_kills() {

  uint   defs_or_kills = 0;

  _components.reset();

  for( Component *comp; (comp = _components.iter()) != NULL; ) {

    if( comp->isa(Component::DEF) || comp->isa(Component::KILL) ) {

      ++defs_or_kills;

    }

  }

  return  defs_or_kills;

}

// This instruction has an expand rule?

bool InstructForm::expands() const {

  return ( _exprule != NULL );

}

// This instruction has a late expand rule?

bool InstructForm::postalloc_expands() const {

  return _is_postalloc_expand;

}

// This instruction has a peephole rule?

Peephole *InstructForm::peepholes() const {

  return _peephole;

}

// This instruction has a peephole rule?

void InstructForm::append_peephole(Peephole *peephole) {

  if( _peephole == NULL ) {

    _peephole = peephole;

  } else {

    _peephole->append_peephole(peephole);

  }

}

// ideal opcode enumeration

const char *InstructForm::ideal_Opcode( FormDict &globalNames )  const {

  if( !_matrule ) return "Node"; // Something weird

  // Chain rules do not really have ideal Opcodes; use their source

  // operand ideal Opcode instead.

  if( is_simple_chain_rule(globalNames) ) {

    const char *src = _matrule->_rChild->_opType;

    OperandForm *src_op = globalNames[src]->is_operand();

    assert( src_op, "Not operand class of chain rule" );

    if( !src_op->_matrule ) return "Node";

    return src_op->_matrule->_opType;

  }

  // Operand chain rules do not really have ideal Opcodes

  if( _matrule->is_chain_rule(globalNames) )

    return "Node";

  return strcmp(_matrule->_opType,"Set")

    ? _matrule->_opType

    : _matrule->_rChild->_opType;

}

// Recursive check on all operands' match rules in my match rule

bool InstructForm::is_pinned(FormDict &globals) {

  if ( ! _matrule)  return false;

  int  index   = 0;

  if (_matrule->find_type("Goto",          index)) return true;

  if (_matrule->find_type("If",            index)) return true;

  if (_matrule->find_type("CountedLoopEnd",index)) return true;

  if (_matrule->find_type("Return",        index)) return true;

  if (_matrule->find_type("Rethrow",       index)) return true;

  if (_matrule->find_type("TailCall",      index)) return true;

  if (_matrule->find_type("TailJump",      index)) return true;

  if (_matrule->find_type("Halt",          index)) return true;

  if (_matrule->find_type("Jump",          index)) return true;

  return is_parm(globals);

}

// Recursive check on all operands' match rules in my match rule

bool InstructForm::is_projection(FormDict &globals) {

  if ( ! _matrule)  return false;

  int  index   = 0;

  if (_matrule->find_type("Goto",    index)) return true;

  if (_matrule->find_type("Return",  index)) return true;

  if (_matrule->find_type("Rethrow", index)) return true;

  if (_matrule->find_type("TailCall",index)) return true;

  if (_matrule->find_type("TailJump",index)) return true;

  if (_matrule->find_type("Halt",    index)) return true;

  return false;

}

// Recursive check on all operands' match rules in my match rule

bool InstructForm::is_parm(FormDict &globals) {

  if ( ! _matrule)  return false;

  int  index   = 0;

  if (_matrule->find_type("Parm",index)) return true;

  return false;

}

bool InstructForm::is_ideal_negD() const {

  return (_matrule && _matrule->_rChild && strcmp(_matrule->_rChild->_opType, "NegD") == 0);

}

// Return 'true' if this instruction matches an ideal 'Copy*' node

int InstructForm::is_ideal_copy() const {

  return _matrule ? _matrule->is_ideal_copy() : 0;

}

// Return 'true' if this instruction is too complex to rematerialize.

int InstructForm::is_expensive() const {

  // We can prove it is cheap if it has an empty encoding.

  // This helps with platform-specific nops like ThreadLocal and RoundFloat.

  if (is_empty_encoding())

    return 0;

  if (is_tls_instruction())

    return 1;

  if (_matrule == NULL)  return 0;

  return _matrule->is_expensive();

}

// Has an empty encoding if _size is a constant zero or there

// are no ins_encode tokens.

int InstructForm::is_empty_encoding() const {

  if (_insencode != NULL) {

    _insencode->reset();

    if (_insencode->encode_class_iter() == NULL) {

      return 1;

    }

  }

  if (_size != NULL && strcmp(_size, "0") == 0) {

    return 1;

  }

  return 0;

}

int InstructForm::is_tls_instruction() const {

  if (_ident != NULL &&

      ( ! strcmp( _ident,"tlsLoadP") ||

        ! strncmp(_ident,"tlsLoadP_",9)) ) {

    return 1;

  }

  if (_matrule != NULL && _insencode != NULL) {

    const char* opType = _matrule->_opType;

    if (strcmp(opType, "Set")==0)

      opType = _matrule->_rChild->_opType;

    if (strcmp(opType,"ThreadLocal")==0) {

      fprintf(stderr, "Warning: ThreadLocal instruction %s should be named 'tlsLoadP_*'\n",

              (_ident == NULL ? "NULL" : _ident));

      return 1;

    }

  }

  return 0;

}

// Return 'true' if this instruction matches an ideal 'If' node

bool InstructForm::is_ideal_if() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_if();

}

// Return 'true' if this instruction matches an ideal 'FastLock' node

bool InstructForm::is_ideal_fastlock() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_fastlock();

}

// Return 'true' if this instruction matches an ideal 'MemBarXXX' node

bool InstructForm::is_ideal_membar() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_membar();

}

// Return 'true' if this instruction matches an ideal 'LoadPC' node

bool InstructForm::is_ideal_loadPC() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_loadPC();

}

// Return 'true' if this instruction matches an ideal 'Box' node

bool InstructForm::is_ideal_box() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_box();

}

// Return 'true' if this instruction matches an ideal 'Goto' node

bool InstructForm::is_ideal_goto() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_goto();

}

// Return 'true' if this instruction matches an ideal 'Jump' node

bool InstructForm::is_ideal_jump() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_jump();

}

// Return 'true' if instruction matches ideal 'If' | 'Goto' | 'CountedLoopEnd'

bool InstructForm::is_ideal_branch() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_ideal_if() || _matrule->is_ideal_goto();

}

// Return 'true' if this instruction matches an ideal 'Return' node

bool InstructForm::is_ideal_return() const {

  if( _matrule == NULL ) return false;

  // Check MatchRule to see if the first entry is the ideal "Return" node

  int  index   = 0;

  if (_matrule->find_type("Return",index)) return true;

  if (_matrule->find_type("Rethrow",index)) return true;

  if (_matrule->find_type("TailCall",index)) return true;

  if (_matrule->find_type("TailJump",index)) return true;

  return false;

}

// Return 'true' if this instruction matches an ideal 'Halt' node

bool InstructForm::is_ideal_halt() const {

  int  index   = 0;

  return _matrule && _matrule->find_type("Halt",index);

}

// Return 'true' if this instruction matches an ideal 'SafePoint' node

bool InstructForm::is_ideal_safepoint() const {

  int  index   = 0;

  return _matrule && _matrule->find_type("SafePoint",index);

}

// Return 'true' if this instruction matches an ideal 'Nop' node

bool InstructForm::is_ideal_nop() const {

  return _ident && _ident[0] == 'N' && _ident[1] == 'o' && _ident[2] == 'p' && _ident[3] == '_';

}

bool InstructForm::is_ideal_control() const {

  if ( ! _matrule)  return false;

  return is_ideal_return() || is_ideal_branch() || _matrule->is_ideal_jump() || is_ideal_halt();

}

// Return 'true' if this instruction matches an ideal 'Call' node

Form::CallType InstructForm::is_ideal_call() const {

  if( _matrule == NULL ) return Form::invalid_type;

  // Check MatchRule to see if the first entry is the ideal "Call" node

  int  idx   = 0;

  if(_matrule->find_type("CallStaticJava",idx))   return Form::JAVA_STATIC;

  idx = 0;

  if(_matrule->find_type("Lock",idx))             return Form::JAVA_STATIC;

  idx = 0;

  if(_matrule->find_type("Unlock",idx))           return Form::JAVA_STATIC;

  idx = 0;

  if(_matrule->find_type("CallDynamicJava",idx))  return Form::JAVA_DYNAMIC;

  idx = 0;

  if(_matrule->find_type("CallRuntime",idx))      return Form::JAVA_RUNTIME;

  idx = 0;

  if(_matrule->find_type("CallLeaf",idx))         return Form::JAVA_LEAF;

  idx = 0;

  if(_matrule->find_type("CallLeafNoFP",idx))     return Form::JAVA_LEAF;

  idx = 0;

  return Form::invalid_type;

}

// Return 'true' if this instruction matches an ideal 'Load?' node

Form::DataType InstructForm::is_ideal_load() const {

  if( _matrule == NULL ) return Form::none;

  return  _matrule->is_ideal_load();

}

// Return 'true' if this instruction matches an ideal 'LoadKlass' node

bool InstructForm::skip_antidep_check() const {

  if( _matrule == NULL ) return false;

  return  _matrule->skip_antidep_check();

}

// Return 'true' if this instruction matches an ideal 'Load?' node

Form::DataType InstructForm::is_ideal_store() const {

  if( _matrule == NULL ) return Form::none;

  return  _matrule->is_ideal_store();

}

// Return 'true' if this instruction matches an ideal vector node

bool InstructForm::is_vector() const {

  if( _matrule == NULL ) return false;

  return _matrule->is_vector();

}

// Return the input register that must match the output register

// If this is not required, return 0

uint InstructForm::two_address(FormDict &globals) {

  uint  matching_input = 0;

  if(_components.count() == 0) return 0;

  _components.reset();

  Component *comp = _components.iter();

  // Check if there is a DEF

  if( comp->isa(Component::DEF) ) {

    // Check that this is a register

    const char  *def_type = comp->_type;

    const Form  *form     = globals[def_type];

    OperandForm *op       = form->is_operand();

    if( op ) {

      if( op->constrained_reg_class() != NULL &&

          op->interface_type(globals) == Form::register_interface ) {

        // Remember the local name for equality test later

        const char *def_name = comp->_name;

        // Check if a component has the same name and is a USE

        do {

          if( comp->isa(Component::USE) && strcmp(comp->_name,def_name)==0 ) {

            return operand_position_format(def_name);

          }

        } while( (comp = _components.iter()) != NULL);

      }

    }

  }

  return 0;

}

// when chaining a constant to an instruction, returns 'true' and sets opType

Form::DataType InstructForm::is_chain_of_constant(FormDict &globals) {

  const char *dummy  = NULL;

  const char *dummy2 = NULL;

  return is_chain_of_constant(globals, dummy, dummy2);

}

Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,

                const char * &opTypeParam) {

  const char *result = NULL;

  return is_chain_of_constant(globals, opTypeParam, result);

}

Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,

                const char * &opTypeParam, const char * &resultParam) {

  Form::DataType  data_type = Form::none;

  if ( ! _matrule)  return data_type;

  // !!!!!

  // The source of the chain rule is 'position = 1'

  uint         position = 1;

  const char  *result   = NULL;

  const char  *name     = NULL;

  const char  *opType   = NULL;

  // Here base_operand is looking for an ideal type to be returned (opType).

  if ( _matrule->is_chain_rule(globals)

       && _matrule->base_operand(position, globals, result, name, opType) ) {

    data_type = ideal_to_const_type(opType);

    // if it isn't an ideal constant type, just return

    if ( data_type == Form::none ) return data_type;

    // Ideal constant types also adjust the opType parameter.

    resultParam = result;

    opTypeParam = opType;

    return data_type;