/*

 * 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.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_ciTypeFlow.cpp.incl"

// ciTypeFlow::JsrSet

//

// A JsrSet represents some set of JsrRecords.  This class

// is used to record a set of all jsr routines which we permit

// execution to return (ret) from.

//

// During abstract interpretation, JsrSets are used to determine

// whether two paths which reach a given block are unique, and

// should be cloned apart, or are compatible, and should merge

// together.

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::JsrSet

ciTypeFlow::JsrSet::JsrSet(Arena* arena, int default_len) {

  if (arena != NULL) {

    // Allocate growable array in Arena.

    _set = new (arena) GrowableArray<JsrRecord*>(arena, default_len, 0, NULL);

  } else {

    // Allocate growable array in current ResourceArea.

    _set = new GrowableArray<JsrRecord*>(4, 0, NULL, false);

  }

}

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::copy_into

void ciTypeFlow::JsrSet::copy_into(JsrSet* jsrs) {

  int len = size();

  jsrs->_set->clear();

  for (int i = 0; i < len; i++) {

    jsrs->_set->append(_set->at(i));

  }

}

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::is_compatible_with

//

// !!!! MISGIVINGS ABOUT THIS... disregard

//

// Is this JsrSet compatible with some other JsrSet?

//

// In set-theoretic terms, a JsrSet can be viewed as a partial function

// from entry addresses to return addresses.  Two JsrSets A and B are

// compatible iff

//

//   For any x,

//   A(x) defined and B(x) defined implies A(x) == B(x)

//

// Less formally, two JsrSets are compatible when they have identical

// return addresses for any entry addresses they share in common.

bool ciTypeFlow::JsrSet::is_compatible_with(JsrSet* other) {

  // Walk through both sets in parallel.  If the same entry address

  // appears in both sets, then the return address must match for

  // the sets to be compatible.

  int size1 = size();

  int size2 = other->size();

  // Special case.  If nothing is on the jsr stack, then there can

  // be no ret.

  if (size2 == 0) {

    return true;

  } else if (size1 != size2) {

    return false;

  } else {

    for (int i = 0; i < size1; i++) {

      JsrRecord* record1 = record_at(i);

      JsrRecord* record2 = other->record_at(i);

      if (record1->entry_address() != record2->entry_address() ||

          record1->return_address() != record2->return_address()) {

        return false;

      }

    }

    return true;

  }

#if 0

  int pos1 = 0;

  int pos2 = 0;

  int size1 = size();

  int size2 = other->size();

  while (pos1 < size1 && pos2 < size2) {

    JsrRecord* record1 = record_at(pos1);

    JsrRecord* record2 = other->record_at(pos2);

    int entry1 = record1->entry_address();

    int entry2 = record2->entry_address();

    if (entry1 < entry2) {

      pos1++;

    } else if (entry1 > entry2) {

      pos2++;

    } else {

      if (record1->return_address() == record2->return_address()) {

        pos1++;

        pos2++;

      } else {

        // These two JsrSets are incompatible.

        return false;

      }

    }

  }

  // The two JsrSets agree.

  return true;

#endif

}

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::insert_jsr_record

//

// Insert the given JsrRecord into the JsrSet, maintaining the order

// of the set and replacing any element with the same entry address.

void ciTypeFlow::JsrSet::insert_jsr_record(JsrRecord* record) {

  int len = size();

  int entry = record->entry_address();

  int pos = 0;

  for ( ; pos < len; pos++) {

    JsrRecord* current = record_at(pos);

    if (entry == current->entry_address()) {

      // Stomp over this entry.

      _set->at_put(pos, record);

      assert(size() == len, "must be same size");

      return;

    } else if (entry < current->entry_address()) {

      break;

    }

  }

  // Insert the record into the list.

  JsrRecord* swap = record;

  JsrRecord* temp = NULL;

  for ( ; pos < len; pos++) {

    temp = _set->at(pos);

    _set->at_put(pos, swap);

    swap = temp;

  }

  _set->append(swap);

  assert(size() == len+1, "must be larger");

}

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::remove_jsr_record

//

// Remove the JsrRecord with the given return address from the JsrSet.

void ciTypeFlow::JsrSet::remove_jsr_record(int return_address) {

  int len = size();

  for (int i = 0; i < len; i++) {

    if (record_at(i)->return_address() == return_address) {

      // We have found the proper entry.  Remove it from the

      // JsrSet and exit.

      for (int j = i+1; j < len ; j++) {

        _set->at_put(j-1, _set->at(j));

      }

      _set->trunc_to(len-1);

      assert(size() == len-1, "must be smaller");

      return;

    }

  }

  assert(false, "verify: returning from invalid subroutine");

}

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::apply_control

//

// Apply the effect of a control-flow bytecode on the JsrSet.  The

// only bytecodes that modify the JsrSet are jsr and ret.

void ciTypeFlow::JsrSet::apply_control(ciTypeFlow* analyzer,

                                       ciBytecodeStream* str,

                                       ciTypeFlow::StateVector* state) {

  Bytecodes::Code code = str->cur_bc();

  if (code == Bytecodes::_jsr) {

    JsrRecord* record =

      analyzer->make_jsr_record(str->get_dest(), str->next_bci());

    insert_jsr_record(record);

  } else if (code == Bytecodes::_jsr_w) {

    JsrRecord* record =

      analyzer->make_jsr_record(str->get_far_dest(), str->next_bci());

    insert_jsr_record(record);

  } else if (code == Bytecodes::_ret) {

    Cell local = state->local(str->get_index());

    ciType* return_address = state->type_at(local);

    assert(return_address->is_return_address(), "verify: wrong type");

    if (size() == 0) {

      // Ret-state underflow:  Hit a ret w/o any previous jsrs.  Bail out.

      // This can happen when a loop is inside a finally clause (4614060).

      analyzer->record_failure("OSR in finally clause");

      return;

    }

    remove_jsr_record(return_address->as_return_address()->bci());

  }

}

#ifndef PRODUCT

// ------------------------------------------------------------------

// ciTypeFlow::JsrSet::print_on

void ciTypeFlow::JsrSet::print_on(outputStream* st) const {

  st->print("{ ");

  int num_elements = size();

  if (num_elements > 0) {

    int i = 0;

    for( ; i < num_elements - 1; i++) {

      _set->at(i)->print_on(st);

      st->print(", ");

    }

    _set->at(i)->print_on(st);

    st->print(" ");

  }

  st->print("}");

}

#endif

// ciTypeFlow::StateVector

//

// A StateVector summarizes the type information at some point in

// the program.

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::type_meet

//

// Meet two types.

//

// The semi-lattice of types use by this analysis are modeled on those

// of the verifier.  The lattice is as follows:

//

//        top_type() >= all non-extremal types >= bottom_type

//                             and

//   Every primitive type is comparable only with itself.  The meet of

//   reference types is determined by their kind: instance class,

//   interface, or array class.  The meet of two types of the same

//   kind is their least common ancestor.  The meet of two types of

//   different kinds is always java.lang.Object.

ciType* ciTypeFlow::StateVector::type_meet_internal(ciType* t1, ciType* t2, ciTypeFlow* analyzer) {

  assert(t1 != t2, "checked in caller");

  if (t1->equals(top_type())) {

    return t2;

  } else if (t2->equals(top_type())) {

    return t1;

  } else if (t1->is_primitive_type() || t2->is_primitive_type()) {

    // Special case null_type.  null_type meet any reference type T

    // is T.  null_type meet null_type is null_type.

    if (t1->equals(null_type())) {

      if (!t2->is_primitive_type() || t2->equals(null_type())) {

        return t2;

      }

    } else if (t2->equals(null_type())) {

      if (!t1->is_primitive_type()) {

        return t1;

      }

    }

    // At least one of the two types is a non-top primitive type.

    // The other type is not equal to it.  Fall to bottom.

    return bottom_type();

  } else {

    // Both types are non-top non-primitive types.  That is,

    // both types are either instanceKlasses or arrayKlasses.

    ciKlass* object_klass = analyzer->env()->Object_klass();

    ciKlass* k1 = t1->as_klass();

    ciKlass* k2 = t2->as_klass();

    if (k1->equals(object_klass) || k2->equals(object_klass)) {

      return object_klass;

    } else if (!k1->is_loaded() || !k2->is_loaded()) {

      // Unloaded classes fall to java.lang.Object at a merge.

      return object_klass;

    } else if (k1->is_interface() != k2->is_interface()) {

      // When an interface meets a non-interface, we get Object;

      // This is what the verifier does.

      return object_klass;

    } else if (k1->is_array_klass() || k2->is_array_klass()) {

      // When an array meets a non-array, we get Object.

      // When objArray meets typeArray, we also get Object.

      // And when typeArray meets different typeArray, we again get Object.

      // But when objArray meets objArray, we look carefully at element types.

      if (k1->is_obj_array_klass() && k2->is_obj_array_klass()) {

        // Meet the element types, then construct the corresponding array type.

        ciKlass* elem1 = k1->as_obj_array_klass()->element_klass();

        ciKlass* elem2 = k2->as_obj_array_klass()->element_klass();

        ciKlass* elem  = type_meet_internal(elem1, elem2, analyzer)->as_klass();

        // Do an easy shortcut if one type is a super of the other.

        if (elem == elem1) {

          assert(k1 == ciObjArrayKlass::make(elem), "shortcut is OK");

          return k1;

        } else if (elem == elem2) {

          assert(k2 == ciObjArrayKlass::make(elem), "shortcut is OK");

          return k2;

        } else {

          return ciObjArrayKlass::make(elem);

        }

      } else {

        return object_klass;

      }

    } else {

      // Must be two plain old instance klasses.

      assert(k1->is_instance_klass(), "previous cases handle non-instances");

      assert(k2->is_instance_klass(), "previous cases handle non-instances");

      return k1->least_common_ancestor(k2);

    }

  }

}

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::StateVector

//

// Build a new state vector

ciTypeFlow::StateVector::StateVector(ciTypeFlow* analyzer) {

  _outer = analyzer;

  _stack_size = -1;

  _monitor_count = -1;

  // Allocate the _types array

  int max_cells = analyzer->max_cells();

  _types = (ciType**)analyzer->arena()->Amalloc(sizeof(ciType*) * max_cells);

  for (int i=0; i<max_cells; i++) {

    _types[i] = top_type();

  }

  _trap_bci = -1;

  _trap_index = 0;

  _def_locals.clear();

}

// ------------------------------------------------------------------

// ciTypeFlow::get_start_state

//

// Set this vector to the method entry state.

const ciTypeFlow::StateVector* ciTypeFlow::get_start_state() {

  StateVector* state = new StateVector(this);

  if (is_osr_flow()) {

    ciTypeFlow* non_osr_flow = method()->get_flow_analysis();

    if (non_osr_flow->failing()) {

      record_failure(non_osr_flow->failure_reason());

      return NULL;

    }

    JsrSet* jsrs = new JsrSet(NULL, 16);

    Block* non_osr_block = non_osr_flow->existing_block_at(start_bci(), jsrs);

    if (non_osr_block == NULL) {

      record_failure("cannot reach OSR point");

      return NULL;

    }

    // load up the non-OSR state at this point

    non_osr_block->copy_state_into(state);

    int non_osr_start = non_osr_block->start();

    if (non_osr_start != start_bci()) {

      // must flow forward from it

      if (CITraceTypeFlow) {

        tty->print_cr(">> Interpreting pre-OSR block %d:", non_osr_start);

      }

      Block* block = block_at(non_osr_start, jsrs);

      assert(block->limit() == start_bci(), "must flow forward to start");

      flow_block(block, state, jsrs);

    }

    return state;

    // Note:  The code below would be an incorrect for an OSR flow,

    // even if it were possible for an OSR entry point to be at bci zero.

  }

  // "Push" the method signature into the first few locals.

  state->set_stack_size(-max_locals());

  if (!method()->is_static()) {

    state->push(method()->holder());

    assert(state->tos() == state->local(0), "");

  }

  for (ciSignatureStream str(method()->signature());

       !str.at_return_type();

       str.next()) {

    state->push_translate(str.type());

  }

  // Set the rest of the locals to bottom.

  Cell cell = state->next_cell(state->tos());

  state->set_stack_size(0);

  int limit = state->limit_cell();

  for (; cell < limit; cell = state->next_cell(cell)) {

    state->set_type_at(cell, state->bottom_type());

  }

  // Lock an object, if necessary.

  state->set_monitor_count(method()->is_synchronized() ? 1 : 0);

  return state;

}

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::copy_into

//

// Copy our value into some other StateVector

void ciTypeFlow::StateVector::copy_into(ciTypeFlow::StateVector* copy)

const {

  copy->set_stack_size(stack_size());

  copy->set_monitor_count(monitor_count());

  Cell limit = limit_cell();

  for (Cell c = start_cell(); c < limit; c = next_cell(c)) {

    copy->set_type_at(c, type_at(c));

  }

}

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::meet

//

// Meets this StateVector with another, destructively modifying this

// one.  Returns true if any modification takes place.

bool ciTypeFlow::StateVector::meet(const ciTypeFlow::StateVector* incoming) {

  if (monitor_count() == -1) {

    set_monitor_count(incoming->monitor_count());

  }

  assert(monitor_count() == incoming->monitor_count(), "monitors must match");

  if (stack_size() == -1) {

    set_stack_size(incoming->stack_size());

    Cell limit = limit_cell();

    #ifdef ASSERT

    { for (Cell c = start_cell(); c < limit; c = next_cell(c)) {

        assert(type_at(c) == top_type(), "");

    } }

    #endif

    // Make a simple copy of the incoming state.

    for (Cell c = start_cell(); c < limit; c = next_cell(c)) {

      set_type_at(c, incoming->type_at(c));

    }

    return true;  // it is always different the first time

  }

#ifdef ASSERT

  if (stack_size() != incoming->stack_size()) {

    _outer->method()->print_codes();

    tty->print_cr("!!!! Stack size conflict");

    tty->print_cr("Current state:");

    print_on(tty);

    tty->print_cr("Incoming state:");

    ((StateVector*)incoming)->print_on(tty);

  }

#endif

  assert(stack_size() == incoming->stack_size(), "sanity");

  bool different = false;

  Cell limit = limit_cell();

  for (Cell c = start_cell(); c < limit; c = next_cell(c)) {

    ciType* t1 = type_at(c);

    ciType* t2 = incoming->type_at(c);

    if (!t1->equals(t2)) {

      ciType* new_type = type_meet(t1, t2);

      if (!t1->equals(new_type)) {

        set_type_at(c, new_type);

        different = true;

      }

    }

  }

  return different;

}

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::meet_exception

//

// Meets this StateVector with another, destructively modifying this

// one.  The incoming state is coming via an exception.  Returns true

// if any modification takes place.

bool ciTypeFlow::StateVector::meet_exception(ciInstanceKlass* exc,

                                     const ciTypeFlow::StateVector* incoming) {

  if (monitor_count() == -1) {

    set_monitor_count(incoming->monitor_count());

  }

  assert(monitor_count() == incoming->monitor_count(), "monitors must match");

  if (stack_size() == -1) {

    set_stack_size(1);

  }

  assert(stack_size() ==  1, "must have one-element stack");

  bool different = false;

  // Meet locals from incoming array.

  Cell limit = local(_outer->max_locals()-1);

  for (Cell c = start_cell(); c <= limit; c = next_cell(c)) {

    ciType* t1 = type_at(c);

    ciType* t2 = incoming->type_at(c);

    if (!t1->equals(t2)) {

      ciType* new_type = type_meet(t1, t2);

      if (!t1->equals(new_type)) {

        set_type_at(c, new_type);

        different = true;

      }

    }

  }

  // Handle stack separately.  When an exception occurs, the

  // only stack entry is the exception instance.

  ciType* tos_type = type_at_tos();

  if (!tos_type->equals(exc)) {

    ciType* new_type = type_meet(tos_type, exc);

    if (!tos_type->equals(new_type)) {

      set_type_at_tos(new_type);

      different = true;

    }

  }

  return different;

}

// ------------------------------------------------------------------

// ciTypeFlow::StateVector::push_translate

void ciTypeFlow::StateVector::push_translate(ciType* type) {

  BasicType basic_type = type->basic_type();

  if (basic_type == T_BOOLEAN || basic_type == T_CHAR ||

      basic_type == T_BYTE    || basic_type == T_SHORT) {

    push_int();

  } else {

    push(type);

    if (type->is_two_word()) {

      push(half_type(type));