graal-jvmci-8: src/share/vm/asm/codeBuffer.cpp comparison

comparison src/share/vm/asm/codeBuffer.cpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	e88293edf07c 44ce519bc3d1
children	957c266d8bc5

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 #include "precompiled.hpp"
 #include "asm/codeBuffer.hpp"
 #include "compiler/disassembler.hpp"
 #include "utilities/copy.hpp"
+#include "utilities/xmlstream.hpp"
 // The structure of a CodeSection:
 //
 //    _start ->           +----------------+
 //                        | machine code...|
 // 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());
-assert(verify_section_allocation(), "initial use of buffer OK");
+verify_section_allocation();
 }
 void CodeBuffer::initialize(csize_t code_size, csize_t locs_size) {
 // Compute maximal alignment.
 int align = _insts.alignment();
 if (locs_size != 0) {
 _insts.initialize_locs(locs_size / sizeof(relocInfo));
 }
-assert(verify_section_allocation(), "initial use of blob is OK");
+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.
-assert(verify_section_allocation(), "final storage configuration still OK");
 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();
 }
 buf_offset += csize;
 }
 // Done calculating sections; did it come out to the right end?
 assert(buf_offset == total_content_size(), "sanity");
-assert(dest->verify_section_allocation(), "final configuration works");
+dest->verify_section_allocation();
 }
 csize_t CodeBuffer::total_offset_of(CodeSection* cs) const {
 csize_t size_so_far = 0;
 for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
 // relocs to repair embedded addresses.  The layout in the destination
 // CodeBuffer is different to the source CodeBuffer: the destination
 // CodeBuffer gets the final layout (consts, insts, stubs in order of
 // ascending address).
 void CodeBuffer::relocate_code_to(CodeBuffer* dest) const {
-DEBUG_ONLY(address dest_end = dest->_total_start + dest->_total_size);
+address dest_end = dest->_total_start + dest->_total_size;
+address dest_filled = NULL;
 for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
 // pull code out of each section
 const CodeSection* cs = code_section(n);
 if (cs->is_empty())  continue;  // skip trivial section
 CodeSection* dest_cs = dest->code_section(n);
 // Destination is a final resting place, not just another buffer.
 // Normalize uninitialized bytes in the final padding.
 Copy::fill_to_bytes(dest_cs->end(), dest_cs->remaining(),
 Assembler::code_fill_byte());
 }
+// Keep track of the highest filled address
+dest_filled = MAX2(dest_filled, dest_cs->end() + dest_cs->remaining());
 assert(cs->locs_start() != (relocInfo*)badAddress,
 "this section carries no reloc storage, but reloc was attempted");
 // Make the new code copy use the old copy's relocations:
 RelocIterator iter(dest_cs);
 while (iter.next()) {
 iter.reloc()->fix_relocation_after_move(this, dest);
 }
 }
+}
+if (dest->blob() == NULL) {
+// Destination is a final resting place, not just another buffer.
+// Normalize uninitialized bytes in the final padding.
+Copy::fill_to_bytes(dest_filled, dest_end - dest_filled,
+Assembler::code_fill_byte());
 }
 }
 csize_t CodeBuffer::figure_expanded_capacities(CodeSection* which_cs,
 csize_t amount,
 badCodeHeapFreeVal));
 _decode_begin = NULL;  // sanity
 // Make certain that the new sections are all snugly inside the new blob.
-assert(verify_section_allocation(), "expanded allocation is ship-shape");
+verify_section_allocation();
 #ifndef PRODUCT
 if (PrintNMethods && (WizardMode || Verbose)) {
 tty->print("expanded CodeBuffer:");
 this->print();
 _overflow_arena = cb->_overflow_arena;
 // Make sure the old cb won't try to use it or free it.
 DEBUG_ONLY(cb->_blob = (BufferBlob*)badAddress);
 }
-#ifdef ASSERT
+void CodeBuffer::verify_section_allocation() {
-bool CodeBuffer::verify_section_allocation() {
 address tstart = _total_start;
-if (tstart == badAddress)  return true;  // smashed by set_blob(NULL)
+if (tstart == badAddress)  return;  // smashed by set_blob(NULL)
 address tend   = tstart + _total_size;
 if (_blob != NULL) {
-assert(tstart >= _blob->content_begin(), "sanity");
-assert(tend   <= _blob->content_end(),   "sanity");
+guarantee(tstart >= _blob->content_begin(), "sanity");
+guarantee(tend   <= _blob->content_end(),   "sanity");
 }
 // Verify disjointness.
 for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
 CodeSection* sect = code_section(n);
 if (!sect->is_allocated() || sect->is_empty())  continue;
-assert((intptr_t)sect->start() % sect->alignment() == 0
+guarantee((intptr_t)sect->start() % sect->alignment() == 0
 || sect->is_empty() || _blob == NULL,
 "start is aligned");
 for (int m = (int) SECT_FIRST; m < (int) SECT_LIMIT; m++) {
 CodeSection* other = code_section(m);
 if (!other->is_allocated() || other == sect)  continue;
-assert(!other->contains(sect->start()    ), "sanity");
+guarantee(!other->contains(sect->start()    ), "sanity");
 // limit is an exclusive address and can be the start of another
 // section.
-assert(!other->contains(sect->limit() - 1), "sanity");
+guarantee(!other->contains(sect->limit() - 1), "sanity");
 }
-assert(sect->end() <= tend, "sanity");
+guarantee(sect->end() <= tend, "sanity");
-}
+guarantee(sect->end() <= sect->limit(), "sanity");
-return true;
+}
 }
-#endif //ASSERT
+void CodeBuffer::log_section_sizes(const char* name) {
+if (xtty != NULL) {
+// log info about buffer usage
+xtty->print_cr("<blob name='%s' size='%d'>", name, _total_size);
+for (int n = (int) CodeBuffer::SECT_FIRST; n < (int) CodeBuffer::SECT_LIMIT; n++) {
+CodeSection* sect = code_section(n);
+if (!sect->is_allocated() || sect->is_empty())  continue;
+xtty->print_cr("<sect index='%d' size='" SIZE_FORMAT "' free='" SIZE_FORMAT "'/>",
+n, sect->limit() - sect->start(), sect->limit() - sect->end());
+}
+xtty->print_cr("</blob>");
+}
+}
 #ifndef PRODUCT
 void CodeSection::dump() {
 address ptr = start();
 void CodeBuffer::block_comment(intptr_t offset, const char * comment) {
 _comments.add_comment(offset, comment);
 }
 class CodeComment: public CHeapObj {
 private:
 friend class CodeComments;
 intptr_t     _offset;

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/asm/codeBuffer.cpp @ 4137:04b9a2566eec