/*

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

 *

 */

#include "precompiled.hpp"

#include "code/codeCache.hpp"

#include "code/compiledIC.hpp"

#include "code/nmethod.hpp"

#include "code/relocInfo.hpp"

#include "memory/resourceArea.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "utilities/copy.hpp"

#include "oops/oop.inline.hpp"

const RelocationHolder RelocationHolder::none; // its type is relocInfo::none

// Implementation of relocInfo

#ifdef ASSERT

relocInfo::relocInfo(relocType t, int off, int f) {

  assert(t != data_prefix_tag, "cannot build a prefix this way");

  assert((t & type_mask) == t, "wrong type");

  assert((f & format_mask) == f, "wrong format");

  assert(off >= 0 && off < offset_limit(), "offset out off bounds");

  assert((off & (offset_unit-1)) == 0, "misaligned offset");

  (*this) = relocInfo(t, RAW_BITS, off, f);

}

#endif

void relocInfo::initialize(CodeSection* dest, Relocation* reloc) {

  relocInfo* data = this+1;  // here's where the data might go

  dest->set_locs_end(data);  // sync end: the next call may read dest.locs_end

  reloc->pack_data_to(dest); // maybe write data into locs, advancing locs_end

  relocInfo* data_limit = dest->locs_end();

  if (data_limit > data) {

    relocInfo suffix = (*this);

    data_limit = this->finish_prefix((short*) data_limit);

    // Finish up with the suffix.  (Hack note: pack_data_to might edit this.)

    *data_limit = suffix;

    dest->set_locs_end(data_limit+1);

  }

}

relocInfo* relocInfo::finish_prefix(short* prefix_limit) {

  assert(sizeof(relocInfo) == sizeof(short), "change this code");

  short* p = (short*)(this+1);

  assert(prefix_limit >= p, "must be a valid span of data");

  int plen = prefix_limit - p;

  if (plen == 0) {

    debug_only(_value = 0xFFFF);

    return this;                         // no data: remove self completely

  }

  if (plen == 1 && fits_into_immediate(p[0])) {

    (*this) = immediate_relocInfo(p[0]); // move data inside self

    return this+1;

  }

  // cannot compact, so just update the count and return the limit pointer

  (*this) = prefix_relocInfo(plen);   // write new datalen

  assert(data() + datalen() == prefix_limit, "pointers must line up");

  return (relocInfo*)prefix_limit;

}

void relocInfo::set_type(relocType t) {

  int old_offset = addr_offset();

  int old_format = format();

  (*this) = relocInfo(t, old_offset, old_format);

  assert(type()==(int)t, "sanity check");

  assert(addr_offset()==old_offset, "sanity check");

  assert(format()==old_format, "sanity check");

}

nmethod* RelocIterator::code_as_nmethod() const {

  return _code->as_nmethod();

}

void relocInfo::set_format(int f) {

  int old_offset = addr_offset();

  assert((f & format_mask) == f, "wrong format");

  _value = (_value & ~(format_mask << offset_width)) | (f << offset_width);

  assert(addr_offset()==old_offset, "sanity check");

}

void relocInfo::change_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type, relocType new_type) {

  bool found = false;

  while (itr->next() && !found) {

    if (itr->addr() == pc) {

      assert(itr->type()==old_type, "wrong relocInfo type found");

      itr->current()->set_type(new_type);

      found=true;

    }

  }

  assert(found, "no relocInfo found for pc");

}

void relocInfo::remove_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type) {

  change_reloc_info_for_address(itr, pc, old_type, none);

}

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

// Implementation of RelocIterator

void RelocIterator::initialize(CompiledMethod* nm, address begin, address limit) {

  initialize_misc();

  if (nm == NULL && begin != NULL) {

    // allow nmethod to be deduced from beginning address

    CodeBlob* cb = CodeCache::find_blob(begin);

    nm = (cb != NULL) ? cb->as_compiled_method_or_null() : NULL;

  }

  guarantee(nm != NULL, "must be able to deduce nmethod from other arguments");

  _code    = nm;

  _current = nm->relocation_begin() - 1;

  _end     = nm->relocation_end();

  _addr    = nm->content_begin();

  // Initialize code sections.

  _section_start[CodeBuffer::SECT_CONSTS] = nm->consts_begin();

  _section_start[CodeBuffer::SECT_INSTS ] = nm->insts_begin() ;

  _section_start[CodeBuffer::SECT_STUBS ] = nm->stub_begin()  ;

  _section_end  [CodeBuffer::SECT_CONSTS] = nm->consts_end()  ;

  _section_end  [CodeBuffer::SECT_INSTS ] = nm->insts_end()   ;

  _section_end  [CodeBuffer::SECT_STUBS ] = nm->stub_end()    ;

  assert(!has_current(), "just checking");

  assert(begin == NULL || begin >= nm->code_begin(), "in bounds");

  assert(limit == NULL || limit <= nm->code_end(),   "in bounds");

  set_limits(begin, limit);

}

RelocIterator::RelocIterator(CodeSection* cs, address begin, address limit) {

  initialize_misc();

  _current = cs->locs_start()-1;

  _end     = cs->locs_end();

  _addr    = cs->start();

  _code    = NULL; // Not cb->blob();

  CodeBuffer* cb = cs->outer();

  assert((int) SECT_LIMIT == CodeBuffer::SECT_LIMIT, "my copy must be equal");

  for (int n = (int) CodeBuffer::SECT_FIRST; n < (int) CodeBuffer::SECT_LIMIT; n++) {

    CodeSection* cs = cb->code_section(n);

    _section_start[n] = cs->start();

    _section_end  [n] = cs->end();

  }

  assert(!has_current(), "just checking");

  assert(begin == NULL || begin >= cs->start(), "in bounds");

  assert(limit == NULL || limit <= cs->end(),   "in bounds");

  set_limits(begin, limit);

}

enum { indexCardSize = 128 };

struct RelocIndexEntry {

  jint addr_offset;          // offset from header_end of an addr()

  jint reloc_offset;         // offset from header_end of a relocInfo (prefix)

};

bool RelocIterator::addr_in_const() const {

  const int n = CodeBuffer::SECT_CONSTS;

  return section_start(n) <= addr() && addr() < section_end(n);

}

void RelocIterator::set_limits(address begin, address limit) {

  _limit = limit;

  // the limit affects this next stuff:

  if (begin != NULL) {

    relocInfo* backup;

    address    backup_addr;

    while (true) {

      backup      = _current;

      backup_addr = _addr;

      if (!next() || addr() >= begin) break;

    }

    // At this point, either we are at the first matching record,

    // or else there is no such record, and !has_current().

    // In either case, revert to the immediatly preceding state.

    _current = backup;

    _addr    = backup_addr;

    set_has_current(false);

  }

}

void RelocIterator::set_limit(address limit) {

  address code_end = (address)code() + code()->size();

  assert(limit == NULL || limit <= code_end, "in bounds");

  _limit = limit;

}

// All the strange bit-encodings are in here.

// The idea is to encode relocation data which are small integers

// very efficiently (a single extra halfword).  Larger chunks of

// relocation data need a halfword header to hold their size.

void RelocIterator::advance_over_prefix() {

  if (_current->is_datalen()) {

    _data    = (short*) _current->data();

    _datalen =          _current->datalen();

    _current += _datalen + 1;   // skip the embedded data & header

  } else {

    _databuf = _current->immediate();

    _data = &_databuf;

    _datalen = 1;

    _current++;                 // skip the header

  }

  // The client will see the following relocInfo, whatever that is.

  // It is the reloc to which the preceding data applies.

}

void RelocIterator::initialize_misc() {

  set_has_current(false);

  for (int i = (int) CodeBuffer::SECT_FIRST; i < (int) CodeBuffer::SECT_LIMIT; i++) {

    _section_start[i] = NULL;  // these will be lazily computed, if needed

    _section_end  [i] = NULL;

  }

}

Relocation* RelocIterator::reloc() {

  // (take the "switch" out-of-line)

  relocInfo::relocType t = type();

  if (false) {}

  #define EACH_TYPE(name)                             \

  else if (t == relocInfo::name##_type) {             \

    return name##_reloc();                            \

  }

  APPLY_TO_RELOCATIONS(EACH_TYPE);

  #undef EACH_TYPE

  assert(t == relocInfo::none, "must be padding");

  return new(_rh) Relocation();

}

//////// Methods for flyweight Relocation types

RelocationHolder RelocationHolder::plus(int offset) const {

  if (offset != 0) {

    switch (type()) {

    case relocInfo::none:

      break;

    case relocInfo::oop_type:

      {

        oop_Relocation* r = (oop_Relocation*)reloc();

        return oop_Relocation::spec(r->oop_index(), r->offset() + offset);

      }

    case relocInfo::metadata_type:

      {

        metadata_Relocation* r = (metadata_Relocation*)reloc();

        return metadata_Relocation::spec(r->metadata_index(), r->offset() + offset);

      }

    default:

      ShouldNotReachHere();

    }

  }

  return (*this);

}

void Relocation::guarantee_size() {

  guarantee(false, "Make _relocbuf bigger!");

}

    // some relocations can compute their own values

address Relocation::value() {

  ShouldNotReachHere();

  return NULL;

}

void Relocation::set_value(address x) {

  ShouldNotReachHere();

}

void Relocation::const_set_data_value(address x) {

#ifdef _LP64

  if (format() == relocInfo::narrow_oop_in_const) {

    *(narrowOop*)addr() = oopDesc::encode_heap_oop((oop) x);

  } else {

#endif

    *(address*)addr() = x;

#ifdef _LP64

  }

#endif

}

void Relocation::const_verify_data_value(address x) {

#ifdef _LP64

  if (format() == relocInfo::narrow_oop_in_const) {

    guarantee(*(narrowOop*)addr() == oopDesc::encode_heap_oop((oop) x), "must agree");

  } else {

#endif

    guarantee(*(address*)addr() == x, "must agree");

#ifdef _LP64

  }

#endif

}

RelocationHolder Relocation::spec_simple(relocInfo::relocType rtype) {

  if (rtype == relocInfo::none)  return RelocationHolder::none;

  relocInfo ri = relocInfo(rtype, 0);

  RelocIterator itr;

  itr.set_current(ri);

  itr.reloc();

  return itr._rh;

}

address Relocation::old_addr_for(address newa,

                                 const CodeBuffer* src, CodeBuffer* dest) {

  int sect = dest->section_index_of(newa);

  guarantee(sect != CodeBuffer::SECT_NONE, "lost track of this address");

  address ostart = src->code_section(sect)->start();

  address nstart = dest->code_section(sect)->start();

  return ostart + (newa - nstart);

}

address Relocation::new_addr_for(address olda,

                                 const CodeBuffer* src, CodeBuffer* dest) {

  debug_only(const CodeBuffer* src0 = src);

  int sect = CodeBuffer::SECT_NONE;

  // Look for olda in the source buffer, and all previous incarnations

  // if the source buffer has been expanded.

  for (; src != NULL; src = src->before_expand()) {

    sect = src->section_index_of(olda);

    if (sect != CodeBuffer::SECT_NONE)  break;

  }

  guarantee(sect != CodeBuffer::SECT_NONE, "lost track of this address");

  address ostart = src->code_section(sect)->start();

  address nstart = dest->code_section(sect)->start();

  return nstart + (olda - ostart);

}

void Relocation::normalize_address(address& addr, const CodeSection* dest, bool allow_other_sections) {

  address addr0 = addr;

  if (addr0 == NULL || dest->allocates2(addr0))  return;

  CodeBuffer* cb = dest->outer();

  addr = new_addr_for(addr0, cb, cb);

  assert(allow_other_sections || dest->contains2(addr),

         "addr must be in required section");

}

void CallRelocation::set_destination(address x) {

  pd_set_call_destination(x);

}

void CallRelocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {

  // Usually a self-relative reference to an external routine.

  // On some platforms, the reference is absolute (not self-relative).

  // The enhanced use of pd_call_destination sorts this all out.

  address orig_addr = old_addr_for(addr(), src, dest);

  address callee    = pd_call_destination(orig_addr);

  // Reassert the callee address, this time in the new copy of the code.

  pd_set_call_destination(callee);

}

//// pack/unpack methods

void oop_Relocation::pack_data_to(CodeSection* dest) {

  short* p = (short*) dest->locs_end();

  p = pack_2_ints_to(p, _oop_index, _offset);

  dest->set_locs_end((relocInfo*) p);

}

void oop_Relocation::unpack_data() {

  unpack_2_ints(_oop_index, _offset);

}

void metadata_Relocation::pack_data_to(CodeSection* dest) {

  short* p = (short*) dest->locs_end();

  p = pack_2_ints_to(p, _metadata_index, _offset);

  dest->set_locs_end((relocInfo*) p);

}

void metadata_Relocation::unpack_data() {

  unpack_2_ints(_metadata_index, _offset);

}

void virtual_call_Relocation::pack_data_to(CodeSection* dest) {

  short*  p     = (short*) dest->locs_end();

  address point =          dest->locs_point();

  normalize_address(_cached_value, dest);

  jint x0 = scaled_offset_null_special(_cached_value, point);

  p = pack_2_ints_to(p, x0, _method_index);

  dest->set_locs_end((relocInfo*) p);

}

void virtual_call_Relocation::unpack_data() {

  jint x0 = 0;

  unpack_2_ints(x0, _method_index);

  address point = addr();

  _cached_value = x0==0? NULL: address_from_scaled_offset(x0, point);

}

void runtime_call_w_cp_Relocation::pack_data_to(CodeSection * dest) {

  short* p = pack_1_int_to((short *)dest->locs_end(), (jint)(_offset >> 2));

  dest->set_locs_end((relocInfo*) p);

}

void runtime_call_w_cp_Relocation::unpack_data() {

  _offset = unpack_1_int() << 2;

}

void static_stub_Relocation::pack_data_to(CodeSection* dest) {

  short* p = (short*) dest->locs_end();

  CodeSection* insts = dest->outer()->insts();

  normalize_address(_static_call, insts);

  jint is_aot = _is_aot ? 1 : 0;

  p = pack_2_ints_to(p, scaled_offset(_static_call, insts->start()), is_aot);

  dest->set_locs_end((relocInfo*) p);

}

void static_stub_Relocation::unpack_data() {

  address base = binding()->section_start(CodeBuffer::SECT_INSTS);

  jint offset;

  jint is_aot;

  unpack_2_ints(offset, is_aot);

  _static_call = address_from_scaled_offset(offset, base);

  _is_aot = (is_aot == 1);

}

void trampoline_stub_Relocation::pack_data_to(CodeSection* dest ) {

  short* p = (short*) dest->locs_end();

  CodeSection* insts = dest->outer()->insts();

  normalize_address(_owner, insts);

  p = pack_1_int_to(p, scaled_offset(_owner, insts->start()));

  dest->set_locs_end((relocInfo*) p);

}

void trampoline_stub_Relocation::unpack_data() {

  address base = binding()->section_start(CodeBuffer::SECT_INSTS);

  _owner = address_from_scaled_offset(unpack_1_int(), base);

}

void external_word_Relocation::pack_data_to(CodeSection* dest) {

  short* p = (short*) dest->locs_end();

#ifndef _LP64

  p = pack_1_int_to(p, (int32_t) (intptr_t)_target);

#else

  jlong t = (jlong) _target;

  int32_t lo = low(t);

  int32_t hi = high(t);

  p = pack_2_ints_to(p, lo, hi);

#endif /* _LP64 */

  dest->set_locs_end((relocInfo*) p);

}

void external_word_Relocation::unpack_data() {

#ifndef _LP64

  _target = (address) (intptr_t)unpack_1_int();

#else

  int32_t lo, hi;

  unpack_2_ints(lo, hi);

  jlong t = jlong_from(hi, lo);;

  _target = (address) t;

#endif /* _LP64 */

}

void internal_word_Relocation::pack_data_to(CodeSection* dest) {

  short* p = (short*) dest->locs_end();

  normalize_address(_target, dest, true);

  // Check whether my target address is valid within this section.

  // If not, strengthen the relocation type to point to another section.

  int sindex = _section;

  if (sindex == CodeBuffer::SECT_NONE && _target != NULL

      && (!dest->allocates(_target) || _target == dest->locs_point())) {

    sindex = dest->outer()->section_index_of(_target);

    guarantee(sindex != CodeBuffer::SECT_NONE, "must belong somewhere");

    relocInfo* base = dest->locs_end() - 1;

    assert(base->type() == this->type(), "sanity");

    // Change the written type, to be section_word_type instead.

    base->set_type(relocInfo::section_word_type);

  }