/*

 * Copyright (c) 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.

 *

 */

// These classes represent the stack-map substructures described in the JVMS

// (hence the non-conforming naming scheme).

// These classes work with the types in their compressed form in-place (as they

// would appear in the classfile).  No virtual methods or fields allowed.

class verification_type_info {

 private:

  // u1 tag

  // u2 cpool_index || u2 bci (for ITEM_Object & ITEM_Uninitailized only)

  address tag_addr() const { return (address)this; }

  address cpool_index_addr() const { return tag_addr() + sizeof(u1); }

  address bci_addr() const { return cpool_index_addr(); }

 protected:

  // No constructors  - should be 'private', but GCC issues a warning if it is

  verification_type_info() {}

  verification_type_info(const verification_type_info&) {}

 public:

  static verification_type_info* at(address addr) {

    return (verification_type_info*)addr;

  }

  static verification_type_info* create_at(address addr, u1 tag) {

    verification_type_info* vti = (verification_type_info*)addr;

    vti->set_tag(tag);

    return vti;

  }

  static verification_type_info* create_object_at(address addr, u2 cp_idx) {

    verification_type_info* vti = (verification_type_info*)addr;

    vti->set_tag(ITEM_Object);

    vti->set_cpool_index(cp_idx);

    return vti;

  }

  static verification_type_info* create_uninit_at(address addr, u2 bci) {

    verification_type_info* vti = (verification_type_info*)addr;

    vti->set_tag(ITEM_Uninitialized);

    vti->set_bci(bci);

    return vti;

  }

  static size_t calculate_size(u1 tag) {

    if (tag == ITEM_Object || tag == ITEM_Uninitialized) {

      return sizeof(u1) + sizeof(u2);

    } else {

      return sizeof(u1);

    }

  }

  static size_t max_size() { return sizeof(u1) + sizeof(u2); }

  u1 tag() const { return *(u1*)tag_addr(); }

  void set_tag(u1 tag) { *((u1*)tag_addr()) = tag; }

  bool is_object() const { return tag() == ITEM_Object; }

  bool is_uninitialized() const { return tag() == ITEM_Uninitialized; }

  u2 cpool_index() const {

    assert(is_object(), "This type has no cp_index");

    return Bytes::get_Java_u2(cpool_index_addr());

  }

  void set_cpool_index(u2 idx) {

    assert(is_object(), "This type has no cp_index");

    Bytes::put_Java_u2(cpool_index_addr(), idx);

  }

  u2 bci() const {

    assert(is_uninitialized(), "This type has no bci");

    return Bytes::get_Java_u2(bci_addr());

  }

  void set_bci(u2 bci) {

    assert(is_uninitialized(), "This type has no bci");

    Bytes::put_Java_u2(bci_addr(), bci);

  }

  void copy_from(verification_type_info* from) {

    set_tag(from->tag());

    if (from->is_object()) {

      set_cpool_index(from->cpool_index());

    } else if (from->is_uninitialized()) {

      set_bci(from->bci());

    }

  }

  size_t size() const {

    return calculate_size(tag());

  }

  verification_type_info* next() {

    return (verification_type_info*)((address)this + size());

  }

  // This method is used when reading unverified data in order to ensure

  // that we don't read past a particular memory limit.  It returns false

  // if any part of the data structure is outside the specified memory bounds.

  bool verify(address start, address end) {

    return ((address)this >= start &&

            (address)this < end &&

            (bci_addr() + sizeof(u2) <= end ||

                !is_object() && !is_uninitialized()));

  }

#ifdef ASSERT

  void print_on(outputStream* st) {

    switch (tag()) {

      case ITEM_Top: st->print("Top"); break;

      case ITEM_Integer: st->print("Integer"); break;

      case ITEM_Float: st->print("Float"); break;

      case ITEM_Double: st->print("Double"); break;

      case ITEM_Long: st->print("Long"); break;

      case ITEM_Null: st->print("Null"); break;

      case ITEM_UninitializedThis:

        st->print("UninitializedThis"); break;

      case ITEM_Uninitialized:

        st->print("Uninitialized[#%d]", bci()); break;

      case ITEM_Object:

        st->print("Object[#%d]", cpool_index()); break;

      default:

        assert(false, "Bad verification_type_info");

    }

  }

#endif

};

#define FOR_EACH_STACKMAP_FRAME_TYPE(macro, arg1, arg2) \

  macro(same_frame, arg1, arg2) \

  macro(same_frame_extended, arg1, arg2) \

  macro(same_frame_1_stack_item_frame, arg1, arg2) \

  macro(same_frame_1_stack_item_extended, arg1, arg2) \

  macro(chop_frame, arg1, arg2) \

  macro(append_frame, arg1, arg2) \

  macro(full_frame, arg1, arg2)

#define SM_FORWARD_DECL(type, arg1, arg2) class type;

FOR_EACH_STACKMAP_FRAME_TYPE(SM_FORWARD_DECL, x, x)

#undef SM_FORWARD_DECL

class stack_map_frame {

 protected:

  address frame_type_addr() const { return (address)this; }

  // No constructors  - should be 'private', but GCC issues a warning if it is

  stack_map_frame() {}

  stack_map_frame(const stack_map_frame&) {}

 public:

  static stack_map_frame* at(address addr) {

    return (stack_map_frame*)addr;

  }

  stack_map_frame* next() const {

    return at((address)this + size());

  }

  u1 frame_type() const { return *(u1*)frame_type_addr(); }

  void set_frame_type(u1 type) { *((u1*)frame_type_addr()) = type; }

  // pseudo-virtual methods

  inline size_t size() const;

  inline int offset_delta() const;

  inline void set_offset_delta(int offset_delta);

  inline int number_of_types() const; // number of types contained in the frame

  inline verification_type_info* types() const; // pointer to first type

  inline bool is_valid_offset(int offset_delta) const;

  // This method must be used when reading unverified data in order to ensure

  // that we don't read past a particular memory limit.  It returns false

  // if any part of the data structure is outside the specified memory bounds.

  inline bool verify(address start, address end) const;

#ifdef ASSERT

  inline void print_on(outputStream* st) const;

#endif

  // Create as_xxx and is_xxx methods for the subtypes

#define FRAME_TYPE_DECL(stackmap_frame_type, arg1, arg2) \

  inline stackmap_frame_type* as_##stackmap_frame_type() const; \

  bool is_##stackmap_frame_type() { \

    return as_##stackmap_frame_type() != NULL; \

  }

  FOR_EACH_STACKMAP_FRAME_TYPE(FRAME_TYPE_DECL, x, x)

#undef FRAME_TYPE_DECL

};

class same_frame : public stack_map_frame {

 private:

  static int frame_type_to_offset_delta(u1 frame_type) {

      return frame_type + 1; }

  static u1 offset_delta_to_frame_type(int offset_delta) {

      return (u1)(offset_delta - 1); }

 public:

  static bool is_frame_type(u1 tag) {

    return tag < 64;

  }

  static same_frame* at(address addr) {

    assert(is_frame_type(*addr), "Wrong frame id");

    return (same_frame*)addr;

  }

  static same_frame* create_at(address addr, int offset_delta) {

    same_frame* sm = (same_frame*)addr;

    sm->set_offset_delta(offset_delta);

    return sm;

  }

  static size_t calculate_size() { return sizeof(u1); }

  size_t size() const { return calculate_size(); }

  int offset_delta() const { return frame_type_to_offset_delta(frame_type()); }

  void set_offset_delta(int offset_delta) {

    assert(offset_delta <= 64, "Offset too large for same_frame");

    set_frame_type(offset_delta_to_frame_type(offset_delta));

  }

  int number_of_types() const { return 0; }

  verification_type_info* types() const { return NULL; }

  bool is_valid_offset(int offset_delta) const {

    return is_frame_type(offset_delta_to_frame_type(offset_delta));

  }

  bool verify_subtype(address start, address end) const {

    return true;

  }

#ifdef ASSERT

  void print_on(outputStream* st) const {

    st->print("same_frame(%d)", offset_delta());

  }

#endif

};

class same_frame_extended : public stack_map_frame {

 private:

  enum { _frame_id = 251 };

  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }

 public:

  static bool is_frame_type(u1 tag) {

    return tag == _frame_id;

  }

  static same_frame_extended* at(address addr) {

    assert(is_frame_type(*addr), "Wrong frame type");

    return (same_frame_extended*)addr;

  }

  static same_frame_extended* create_at(address addr, u2 offset_delta) {

    same_frame_extended* sm = (same_frame_extended*)addr;

    sm->set_frame_type(_frame_id);

    sm->set_offset_delta(offset_delta);

    return sm;

  }

  static size_t calculate_size() { return sizeof(u1) + sizeof(u2); }

  size_t size() const { return calculate_size(); }

  int offset_delta() const {

    return Bytes::get_Java_u2(offset_delta_addr()) + 1;

  }

  void set_offset_delta(int offset_delta) {

    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);

  }

  int number_of_types() const { return 0; }

  verification_type_info* types() const { return NULL; }

  bool is_valid_offset(int offset) const { return true; }

  bool verify_subtype(address start, address end) const {

    return frame_type_addr() + size() <= end;

  }

#ifdef ASSERT

  void print_on(outputStream* st) const {

    st->print("same_frame_extended(%d)", offset_delta());

  }

#endif

};

class same_frame_1_stack_item_frame : public stack_map_frame {

 private:

  address type_addr() const { return frame_type_addr() + sizeof(u1); }

  static int frame_type_to_offset_delta(u1 frame_type) {

      return frame_type - 63; }

  static u1 offset_delta_to_frame_type(int offset_delta) {

      return (u1)(offset_delta + 63); }

 public:

  static bool is_frame_type(u1 tag) {

    return tag >= 64 && tag < 128;

  }

  static same_frame_1_stack_item_frame* at(address addr) {

    assert(is_frame_type(*addr), "Wrong frame id");

    return (same_frame_1_stack_item_frame*)addr;

  }

  static same_frame_1_stack_item_frame* create_at(

      address addr, int offset_delta, verification_type_info* vti) {

    same_frame_1_stack_item_frame* sm = (same_frame_1_stack_item_frame*)addr;

    sm->set_offset_delta(offset_delta);

    if (vti != NULL) {

      sm->set_type(vti);

    }

    return sm;

  }

  static size_t calculate_size(verification_type_info* vti) {

    return sizeof(u1) + vti->size();

  }

  static size_t max_size() {

    return sizeof(u1) + verification_type_info::max_size();

  }

  size_t size() const { return calculate_size(types()); }

  int offset_delta() const { return frame_type_to_offset_delta(frame_type()); }

  void set_offset_delta(int offset_delta) {

    assert(offset_delta > 0 && offset_delta <= 64,

           "Offset too large for this frame type");

    set_frame_type(offset_delta_to_frame_type(offset_delta));

  }

  void set_type(verification_type_info* vti) {

    verification_type_info* cur = types();

    cur->copy_from(vti);

  }

  int number_of_types() const { return 1; }

  verification_type_info* types() const {

    return verification_type_info::at(type_addr());

  }

  bool is_valid_offset(int offset_delta) const {

    return is_frame_type(offset_delta_to_frame_type(offset_delta));

  }

  bool verify_subtype(address start, address end) const {

    return types()->verify(start, end);

  }

#ifdef ASSERT

  void print_on(outputStream* st) const {

    st->print("same_frame_1_stack_item_frame(%d,", offset_delta());

    types()->print_on(st);

    st->print(")");

  }

#endif

};

class same_frame_1_stack_item_extended : public stack_map_frame {

 private:

  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }

  address type_addr() const { return offset_delta_addr() + sizeof(u2); }

  enum { _frame_id = 247 };

 public:

  static bool is_frame_type(u1 tag) {

    return tag == _frame_id;

  }

  static same_frame_1_stack_item_extended* at(address addr) {

    assert(is_frame_type(*addr), "Wrong frame id");

    return (same_frame_1_stack_item_extended*)addr;

  }

  static same_frame_1_stack_item_extended* create_at(

      address addr, int offset_delta, verification_type_info* vti) {

    same_frame_1_stack_item_extended* sm =

       (same_frame_1_stack_item_extended*)addr;

    sm->set_frame_type(_frame_id);

    sm->set_offset_delta(offset_delta);

    if (vti != NULL) {

      sm->set_type(vti);

    }

    return sm;

  }

  static size_t calculate_size(verification_type_info* vti) {

    return sizeof(u1) + sizeof(u2) + vti->size();

  }

  size_t size() const { return calculate_size(types()); }

  int offset_delta() const {

    return Bytes::get_Java_u2(offset_delta_addr()) + 1;

  }

  void set_offset_delta(int offset_delta) {

    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);

  }

  void set_type(verification_type_info* vti) {

    verification_type_info* cur = types();

    cur->copy_from(vti);

  }

  int number_of_types() const { return 1; }

  verification_type_info* types() const {

    return verification_type_info::at(type_addr());

  }

  bool is_valid_offset(int offset) { return true; }

  bool verify_subtype(address start, address end) const {

    return type_addr() < end && types()->verify(start, end);

  }

#ifdef ASSERT

  void print_on(outputStream* st) const {

    st->print("same_frame_1_stack_item_extended(%d,", offset_delta());

    types()->print_on(st);

    st->print(")");

  }

#endif

};

class chop_frame : public stack_map_frame {

 private:

  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }

  static int frame_type_to_chops(u1 frame_type) {

    int chop = 251 - frame_type;

    return chop;

  }

  static u1 chops_to_frame_type(int chop) {

    return 251 - chop;

  }

 public:

  static bool is_frame_type(u1 tag) {

    return frame_type_to_chops(tag) > 0 && frame_type_to_chops(tag) < 4;

  }

  static chop_frame* at(address addr) {

    assert(is_frame_type(*addr), "Wrong frame id");

    return (chop_frame*)addr;

  }

  static chop_frame* create_at(address addr, int offset_delta, int chops) {

    chop_frame* sm = (chop_frame*)addr;

    sm->set_chops(chops);

    sm->set_offset_delta(offset_delta);

    return sm;

  }

  static size_t calculate_size() {

    return sizeof(u1) + sizeof(u2);

  }

  size_t size() const { return calculate_size(); }

  int offset_delta() const {

    return Bytes::get_Java_u2(offset_delta_addr()) + 1;

  }

  void set_offset_delta(int offset_delta) {

    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);

  }

  int chops() const {

    int chops = frame_type_to_chops(frame_type());

    assert(chops > 0 && chops < 4, "Invalid number of chops in frame");

    return chops;

  }

  void set_chops(int chops) {

    assert(chops > 0 && chops <= 3, "Bad number of chops");

    set_frame_type(chops_to_frame_type(chops));

  }

  int number_of_types() const { return 0; }

  verification_type_info* types() const { return NULL; }

  bool is_valid_offset(int offset) { return true; }

  bool verify_subtype(address start, address end) const {

    return frame_type_addr() + size() <= end;

  }

#ifdef ASSERT

  void print_on(outputStream* st) const {

    st->print("chop_frame(%d,%d)", offset_delta(), chops());

  }

#endif

};

class append_frame : public stack_map_frame {

 private: