/*

 * 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 "asm/codeBuffer.hpp"

#include "compiler/disassembler.hpp"

#include "memory/gcLocker.hpp"

#include "oops/methodData.hpp"

#include "oops/oop.inline.hpp"

#include "utilities/copy.hpp"

#include "utilities/xmlstream.hpp"

// The structure of a CodeSection:

//

//    _start ->           +----------------+

//                        | machine code...|

//    _end ->             |----------------|

//                        |                |

//                        |    (empty)     |

//                        |                |

//                        |                |

//                        +----------------+

//    _limit ->           |                |

//

//    _locs_start ->      +----------------+

//                        |reloc records...|

//                        |----------------|

//    _locs_end ->        |                |

//                        |                |

//                        |    (empty)     |

//                        |                |

//                        |                |

//                        +----------------+

//    _locs_limit ->      |                |

// The _end (resp. _limit) pointer refers to the first

// unused (resp. unallocated) byte.

// The structure of the CodeBuffer while code is being accumulated:

//

//    _total_start ->    \

//    _insts._start ->              +----------------+

//                                  |                |

//                                  |     Code       |

//                                  |                |

//    _stubs._start ->              |----------------|

//                                  |                |

//                                  |    Stubs       | (also handlers for deopt/exception)

//                                  |                |

//    _consts._start ->             |----------------|

//                                  |                |

//                                  |   Constants    |

//                                  |                |

//                                  +----------------+

//    + _total_size ->              |                |

//

// When the code and relocations are copied to the code cache,

// the empty parts of each section are removed, and everything

// is copied into contiguous locations.

typedef CodeBuffer::csize_t csize_t;  // file-local definition

// External buffer, in a predefined CodeBlob.

// Important: The code_start must be taken exactly, and not realigned.

CodeBuffer::CodeBuffer(CodeBlob* blob) {

  initialize_misc("static buffer");

  initialize(blob->content_begin(), blob->content_size());

  verify_section_allocation();

}

void CodeBuffer::initialize(csize_t code_size, csize_t locs_size) {

  // Compute maximal alignment.

  int align = _insts.alignment();

  // Always allow for empty slop around each section.

  int slop = (int) CodeSection::end_slop();

  assert(blob() == NULL, "only once");

  set_blob(BufferBlob::create(_name, code_size + (align+slop) * (SECT_LIMIT+1)));

  if (blob() == NULL) {

    // The assembler constructor will throw a fatal on an empty CodeBuffer.

    return;  // caller must test this

  }

  // Set up various pointers into the blob.

  initialize(_total_start, _total_size);

  assert((uintptr_t)insts_begin() % CodeEntryAlignment == 0, "instruction start not code entry aligned");

  pd_initialize();

  if (locs_size != 0) {

    _insts.initialize_locs(locs_size / sizeof(relocInfo));

  }

  verify_section_allocation();

}

CodeBuffer::~CodeBuffer() {

  verify_section_allocation();

  // If we allocate our code buffer from the CodeCache

  // via a BufferBlob, and it's not permanent, then

  // free the BufferBlob.

  // The rest of the memory will be freed when the ResourceObj

  // is released.

  for (CodeBuffer* cb = this; cb != NULL; cb = cb->before_expand()) {

    // Previous incarnations of this buffer are held live, so that internal

    // addresses constructed before expansions will not be confused.

    cb->free_blob();

  }

  // free any overflow storage

  delete _overflow_arena;

#ifdef ASSERT

  // Save allocation type to execute assert in ~ResourceObj()

  // which is called after this destructor.

  assert(_default_oop_recorder.allocated_on_stack(), "should be embedded object");

  ResourceObj::allocation_type at = _default_oop_recorder.get_allocation_type();

  Copy::fill_to_bytes(this, sizeof(*this), badResourceValue);

  ResourceObj::set_allocation_type((address)(&_default_oop_recorder), at);

#endif

}

void CodeBuffer::initialize_oop_recorder(OopRecorder* r) {

  assert(_oop_recorder == &_default_oop_recorder && _default_oop_recorder.is_unused(), "do this once");

  DEBUG_ONLY(_default_oop_recorder.freeze());  // force unused OR to be frozen

  _oop_recorder = r;

}

void CodeBuffer::initialize_section_size(CodeSection* cs, csize_t size) {

  assert(cs != &_insts, "insts is the memory provider, not the consumer");

  csize_t slop = CodeSection::end_slop();  // margin between sections

  int align = cs->alignment();

  assert(is_power_of_2(align), "sanity");

  address start  = _insts._start;

  address limit  = _insts._limit;

  address middle = limit - size;

  middle -= (intptr_t)middle & (align-1);  // align the division point downward

  guarantee(middle - slop > start, "need enough space to divide up");

  _insts._limit = middle - slop;  // subtract desired space, plus slop

  cs->initialize(middle, limit - middle);

  assert(cs->start() == middle, "sanity");

  assert(cs->limit() == limit,  "sanity");

  // give it some relocations to start with, if the main section has them

  if (_insts.has_locs())  cs->initialize_locs(1);

}

void CodeBuffer::freeze_section(CodeSection* cs) {

  CodeSection* next_cs = (cs == consts())? NULL: code_section(cs->index()+1);

  csize_t frozen_size = cs->size();

  if (next_cs != NULL) {

    frozen_size = next_cs->align_at_start(frozen_size);

  }

  address old_limit = cs->limit();

  address new_limit = cs->start() + frozen_size;

  relocInfo* old_locs_limit = cs->locs_limit();

  relocInfo* new_locs_limit = cs->locs_end();

  // Patch the limits.

  cs->_limit = new_limit;

  cs->_locs_limit = new_locs_limit;

  cs->_frozen = true;

  if (!next_cs->is_allocated() && !next_cs->is_frozen()) {

    // Give remaining buffer space to the following section.

    next_cs->initialize(new_limit, old_limit - new_limit);

    next_cs->initialize_shared_locs(new_locs_limit,

                                    old_locs_limit - new_locs_limit);

  }

}

void CodeBuffer::set_blob(BufferBlob* blob) {

  _blob = blob;

  if (blob != NULL) {

    address start = blob->content_begin();

    address end   = blob->content_end();

    // Round up the starting address.

    int align = _insts.alignment();

    start += (-(intptr_t)start) & (align-1);

    _total_start = start;

    _total_size  = end - start;

  } else {

#ifdef ASSERT

    // Clean out dangling pointers.

    _total_start    = badAddress;

    _consts._start  = _consts._end  = badAddress;

    _insts._start   = _insts._end   = badAddress;

    _stubs._start   = _stubs._end   = badAddress;

#endif //ASSERT

  }

}

void CodeBuffer::free_blob() {

  if (_blob != NULL) {

    BufferBlob::free(_blob);

    set_blob(NULL);

  }

}

const char* CodeBuffer::code_section_name(int n) {

#ifdef PRODUCT

  return NULL;

#else //PRODUCT

  switch (n) {

  case SECT_CONSTS:            return "consts";

  case SECT_INSTS:             return "insts";

  case SECT_STUBS:             return "stubs";

  default:                     return NULL;

  }

#endif //PRODUCT

}

int CodeBuffer::section_index_of(address addr) const {

  for (int n = 0; n < (int)SECT_LIMIT; n++) {

    const CodeSection* cs = code_section(n);

    if (cs->allocates(addr))  return n;

  }

  return SECT_NONE;

}

int CodeBuffer::locator(address addr) const {

  for (int n = 0; n < (int)SECT_LIMIT; n++) {

    const CodeSection* cs = code_section(n);

    if (cs->allocates(addr)) {

      return locator(addr - cs->start(), n);

    }

  }

  return -1;

}

address CodeBuffer::locator_address(int locator) const {

  if (locator < 0)  return NULL;

  address start = code_section(locator_sect(locator))->start();

  return start + locator_pos(locator);

}

bool CodeBuffer::is_backward_branch(Label& L) {

  return L.is_bound() && insts_end() <= locator_address(L.loc());

}

address CodeBuffer::decode_begin() {

  address begin = _insts.start();

  if (_decode_begin != NULL && _decode_begin > begin)

    begin = _decode_begin;

  return begin;

}

GrowableArray<int>* CodeBuffer::create_patch_overflow() {

  if (_overflow_arena == NULL) {

    _overflow_arena = new (mtCode) Arena();

  }

  return new (_overflow_arena) GrowableArray<int>(_overflow_arena, 8, 0, 0);

}

// Helper function for managing labels and their target addresses.

// Returns a sensible address, and if it is not the label's final

// address, notes the dependency (at 'branch_pc') on the label.

address CodeSection::target(Label& L, address branch_pc) {

  if (L.is_bound()) {

    int loc = L.loc();

    if (index() == CodeBuffer::locator_sect(loc)) {

      return start() + CodeBuffer::locator_pos(loc);

    } else {

      return outer()->locator_address(loc);

    }

  } else {

    assert(allocates2(branch_pc), "sanity");

    address base = start();

    int patch_loc = CodeBuffer::locator(branch_pc - base, index());

    L.add_patch_at(outer(), patch_loc);

    // Need to return a pc, doesn't matter what it is since it will be

    // replaced during resolution later.

    // Don't return NULL or badAddress, since branches shouldn't overflow.

    // Don't return base either because that could overflow displacements

    // for shorter branches.  It will get checked when bound.

    return branch_pc;

  }

}

void CodeSection::relocate(address at, RelocationHolder const& spec, int format) {

  Relocation* reloc = spec.reloc();

  relocInfo::relocType rtype = (relocInfo::relocType) reloc->type();

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

  // The assertion below has been adjusted, to also work for

  // relocation for fixup.  Sometimes we want to put relocation

  // information for the next instruction, since it will be patched

  // with a call.

  assert(start() <= at && at <= end()+1,

         "cannot relocate data outside code boundaries");

  if (!has_locs()) {

    // no space for relocation information provided => code cannot be

    // relocated.  Make sure that relocate is only called with rtypes

    // that can be ignored for this kind of code.

    assert(rtype == relocInfo::none              ||

           rtype == relocInfo::runtime_call_type ||

           rtype == relocInfo::internal_word_type||

           rtype == relocInfo::section_word_type ||

           rtype == relocInfo::external_word_type,

           "code needs relocation information");

    // leave behind an indication that we attempted a relocation

    DEBUG_ONLY(_locs_start = _locs_limit = (relocInfo*)badAddress);

    return;

  }

  // Advance the point, noting the offset we'll have to record.

  csize_t offset = at - locs_point();

  set_locs_point(at);

  // Test for a couple of overflow conditions; maybe expand the buffer.

  relocInfo* end = locs_end();

  relocInfo* req = end + relocInfo::length_limit;

  // Check for (potential) overflow

  if (req >= locs_limit() || offset >= relocInfo::offset_limit()) {

    req += (uint)offset / (uint)relocInfo::offset_limit();

    if (req >= locs_limit()) {

      // Allocate or reallocate.

      expand_locs(locs_count() + (req - end));

      // reload pointer

      end = locs_end();

    }

  }

  // If the offset is giant, emit filler relocs, of type 'none', but

  // each carrying the largest possible offset, to advance the locs_point.

  while (offset >= relocInfo::offset_limit()) {

    assert(end < locs_limit(), "adjust previous paragraph of code");

    *end++ = filler_relocInfo();

    offset -= filler_relocInfo().addr_offset();

  }

  // If it's a simple reloc with no data, we'll just write (rtype | offset).

  (*end) = relocInfo(rtype, offset, format);

  // If it has data, insert the prefix, as (data_prefix_tag | data1), data2.

  end->initialize(this, reloc);

}

void CodeSection::initialize_locs(int locs_capacity) {

  assert(_locs_start == NULL, "only one locs init step, please");

  // Apply a priori lower limits to relocation size:

  csize_t min_locs = MAX2(size() / 16, (csize_t)4);

  if (locs_capacity < min_locs)  locs_capacity = min_locs;

  relocInfo* locs_start = NEW_RESOURCE_ARRAY(relocInfo, locs_capacity);

  _locs_start    = locs_start;

  _locs_end      = locs_start;

  _locs_limit    = locs_start + locs_capacity;

  _locs_own      = true;

}

void CodeSection::initialize_shared_locs(relocInfo* buf, int length) {

  assert(_locs_start == NULL, "do this before locs are allocated");

  // Internal invariant:  locs buf must be fully aligned.

  // See copy_relocations_to() below.

  while ((uintptr_t)buf % HeapWordSize != 0 && length > 0) {

    ++buf; --length;

  }

  if (length > 0) {

    _locs_start = buf;

    _locs_end   = buf;

    _locs_limit = buf + length;

    _locs_own   = false;

  }

}

void CodeSection::initialize_locs_from(const CodeSection* source_cs) {

  int lcount = source_cs->locs_count();

  if (lcount != 0) {

    initialize_shared_locs(source_cs->locs_start(), lcount);

    _locs_end = _locs_limit = _locs_start + lcount;

    assert(is_allocated(), "must have copied code already");

    set_locs_point(start() + source_cs->locs_point_off());

  }

  assert(this->locs_count() == source_cs->locs_count(), "sanity");

}

void CodeSection::expand_locs(int new_capacity) {

  if (_locs_start == NULL) {

    initialize_locs(new_capacity);

    return;

  } else {

    int old_count    = locs_count();

    int old_capacity = locs_capacity();

    if (new_capacity < old_capacity * 2)

      new_capacity = old_capacity * 2;

    relocInfo* locs_start;

    if (_locs_own) {

      locs_start = REALLOC_RESOURCE_ARRAY(relocInfo, _locs_start, old_capacity, new_capacity);

    } else {

      locs_start = NEW_RESOURCE_ARRAY(relocInfo, new_capacity);

      Copy::conjoint_jbytes(_locs_start, locs_start, old_capacity * sizeof(relocInfo));

      _locs_own = true;

    }

    _locs_start    = locs_start;

    _locs_end      = locs_start + old_count;

    _locs_limit    = locs_start + new_capacity;

  }

}

/// Support for emitting the code to its final location.

/// The pattern is the same for all functions.

/// We iterate over all the sections, padding each to alignment.

csize_t CodeBuffer::total_content_size() const {

  csize_t size_so_far = 0;

  for (int n = 0; n < (int)SECT_LIMIT; n++) {

    const CodeSection* cs = code_section(n);

    if (cs->is_empty())  continue;  // skip trivial section

    size_so_far = cs->align_at_start(size_so_far);

    size_so_far += cs->size();

  }

  return size_so_far;

}

void CodeBuffer::compute_final_layout(CodeBuffer* dest) const {

  address buf = dest->_total_start;

  csize_t buf_offset = 0;

  assert(dest->_total_size >= total_content_size(), "must be big enough");

  {

    // not sure why this is here, but why not...

    int alignSize = MAX2((intx) sizeof(jdouble), CodeEntryAlignment);

    assert( (dest->_total_start - _insts.start()) % alignSize == 0, "copy must preserve alignment");

  }

  const CodeSection* prev_cs      = NULL;

  CodeSection*       prev_dest_cs = NULL;

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

    // figure compact layout of each section

    const CodeSection* cs = code_section(n);

    csize_t csize = cs->size();

    CodeSection* dest_cs = dest->code_section(n);

    if (!cs->is_empty()) {

      // Compute initial padding; assign it to the previous non-empty guy.

      // Cf. figure_expanded_capacities.

      csize_t padding = cs->align_at_start(buf_offset) - buf_offset;

      if (padding != 0) {

        buf_offset += padding;

        assert(prev_dest_cs != NULL, "sanity");

        prev_dest_cs->_limit += padding;

      }

      #ifdef ASSERT

      if (prev_cs != NULL && prev_cs->is_frozen() && n < (SECT_LIMIT - 1)) {

        // Make sure the ends still match up.

        // This is important because a branch in a frozen section

        // might target code in a following section, via a Label,

        // and without a relocation record.  See Label::patch_instructions.

        address dest_start = buf+buf_offset;

        csize_t start2start = cs->start() - prev_cs->start();

        csize_t dest_start2start = dest_start - prev_dest_cs->start();

        assert(start2start == dest_start2start, "cannot stretch frozen sect");

      }

      #endif //ASSERT

      prev_dest_cs = dest_cs;

      prev_cs      = cs;

    }

    debug_only(dest_cs->_start = NULL);  // defeat double-initialization assert

    dest_cs->initialize(buf+buf_offset, csize);

    dest_cs->set_end(buf+buf_offset+csize);

    assert(dest_cs->is_allocated(), "must always be allocated");

    assert(cs->is_empty() == dest_cs->is_empty(), "sanity");

    buf_offset += csize;

  }

  // Done calculating sections; did it come out to the right end?

  assert(buf_offset == total_content_size(), "sanity");

  dest->verify_section_allocation();

}

// Append an oop reference that keeps the class alive.

static void append_oop_references(GrowableArray<oop>* oops, Klass* k) {

  oop cl = k->klass_holder();

  if (cl != NULL && !oops->contains(cl)) {

    oops->append(cl);

  }

}

void CodeBuffer::finalize_oop_references(methodHandle mh) {

  No_Safepoint_Verifier nsv;

  GrowableArray<oop> oops;

  // Make sure that immediate metadata records something in the OopRecorder

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

    // pull code out of each section

    CodeSection* cs = code_section(n);

    if (cs->is_empty())  continue;  // skip trivial section

    RelocIterator iter(cs);

    while (iter.next()) {