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

comparison src/share/vm/asm/codeBuffer.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	e1a275dbc8cd 0878d7bae69f
children	06f017f7daa7

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1997, 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.
 *
 * 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,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 # include "incls/_precompiled.incl"
 # include "incls/_codeBuffer.cpp.incl"
 // 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 or other buffer area
+// External buffer, in a predefined CodeBlob.
 // Important: The code_start must be taken exactly, and not realigned.
-CodeBuffer::CodeBuffer(address code_start, csize_t code_size) {
+CodeBuffer::CodeBuffer(CodeBlob* blob) {
-assert(code_start != NULL, "sanity");
 initialize_misc("static buffer");
-initialize(code_start, code_size);
+initialize(blob->content_begin(), blob->content_size());
 assert(verify_section_allocation(), "initial use of buffer OK");
 }
 void CodeBuffer::initialize(csize_t code_size, csize_t locs_size) {
 // Compute maximal alignment.
 }
 // Set up various pointers into the blob.
 initialize(_total_start, _total_size);
-assert((uintptr_t)code_begin() % CodeEntryAlignment == 0, "instruction start not code entry aligned");
+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));
 // free any overflow storage
 delete _overflow_arena;
 #ifdef ASSERT
+// Save allocation type to execute assert in ~ResourceObj()
+// which is called after this destructor.
+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");
 _oop_recorder = r;
 }
 void CodeBuffer::initialize_section_size(CodeSection* cs, csize_t size) {
 assert(cs != &_insts, "insts is the memory provider, not the consumer");
-#ifdef ASSERT
-for (int n = (int)SECT_INSTS+1; n < (int)SECT_LIMIT; n++) {
-CodeSection* prevCS = code_section(n);
-if (prevCS == cs)  break;
-assert(!prevCS->is_allocated(), "section allocation must be in reverse order");
-}
-#endif
 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;
 }
 void CodeBuffer::set_blob(BufferBlob* blob) {
 _blob = blob;
 if (blob != NULL) {
-address start = blob->instructions_begin();
+address start = blob->content_begin();
-address end   = blob->instructions_end();
+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;
-_consts._start  = _consts._end  = badAddress;
+#endif //ASSERT
-#endif //ASSERT
 }
 }
 void CodeBuffer::free_blob() {
 if (_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";
-case SECT_CONSTS:            return "consts";
 default:                     return NULL;
 }
 #endif //PRODUCT
 }
 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_bytes(_locs_start, locs_start, old_capacity * sizeof(relocInfo));
+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_code_size() const {
+csize_t CodeBuffer::total_content_size() const {
-csize_t code_size_so_far = 0;
+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
-code_size_so_far = cs->align_at_start(code_size_so_far);
+size_so_far = cs->align_at_start(size_so_far);
-code_size_so_far += cs->size();
+size_so_far += cs->size();
 }
-return code_size_so_far;
+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_code_size(), "must be big enough");
+assert(dest->_total_size >= total_content_size(), "must be big enough");
 {
 // not sure why this is here, but why not...
 // (tw) disabled assert
 // 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 = 0; n < (int)SECT_LIMIT; n++) {
+for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
 // figure compact layout of each section
 const CodeSection* cs = code_section(n);
-address cstart = cs->start();
+csize_t csize = cs->size();
-address cend   = cs->end();
-csize_t csize  = cend - cstart;
 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.
 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_CONSTS) {
+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;
 buf_offset += csize;
 }
 // Done calculating sections; did it come out to the right end?
-assert(buf_offset == total_code_size(), "sanity");
+assert(buf_offset == total_content_size(), "sanity");
 assert(dest->verify_section_allocation(), "final configuration works");
 }
-csize_t CodeBuffer::total_offset_of(address addr) const {
+csize_t CodeBuffer::total_offset_of(CodeSection* cs) const {
-csize_t code_size_so_far = 0;
+csize_t size_so_far = 0;
-for (int n = 0; n < (int)SECT_LIMIT; n++) {
+for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
-const CodeSection* cs = code_section(n);
+const CodeSection* cur_cs = code_section(n);
-if (!cs->is_empty()) {
+if (!cur_cs->is_empty()) {
-code_size_so_far = cs->align_at_start(code_size_so_far);
+size_so_far = cur_cs->align_at_start(size_so_far);
 }
-if (cs->contains2(addr)) {
+if (cur_cs->index() == cs->index()) {
-return code_size_so_far + (addr - cs->start());
+return size_so_far;
 }
-code_size_so_far += cs->size();
+size_so_far += cur_cs->size();
 }
-#ifndef PRODUCT
-tty->print_cr("Dangling address " PTR_FORMAT " in:", addr);
-((CodeBuffer*)this)->print();
-#endif
 ShouldNotReachHere();
 return -1;
 }
 csize_t CodeBuffer::total_relocation_size() const {
 csize_t lsize = copy_relocations_to(NULL);  // dry run only
-csize_t csize = total_code_size();
+csize_t csize = total_content_size();
 csize_t total = RelocIterator::locs_and_index_size(csize, lsize);
 return (csize_t) align_size_up(total, HeapWordSize);
 }
 csize_t CodeBuffer::copy_relocations_to(CodeBlob* dest) const {
 }
 // if dest == NULL, this is just the sizing pass
 csize_t code_end_so_far = 0;
 csize_t code_point_so_far = 0;
-for (int n = 0; n < (int)SECT_LIMIT; n++) {
+for (int n = (int) SECT_FIRST; n < (int)SECT_LIMIT; n++) {
 // pull relocs out of each section
 const CodeSection* cs = code_section(n);
 assert(!(cs->is_empty() && cs->locs_count() > 0), "sanity");
 if (cs->is_empty())  continue;  // skip trivial section
 relocInfo* lstart = cs->locs_start();
 // Use wordwise copies if possible:
 Copy::disjoint_words((HeapWord*)lstart,
 (HeapWord*)(buf+buf_offset),
 (lsize + HeapWordSize-1) / HeapWordSize);
 } else {
-Copy::conjoint_bytes(lstart, buf+buf_offset, lsize);
+Copy::conjoint_jbytes(lstart, buf+buf_offset, lsize);
 }
 }
 buf_offset += lsize;
 }
 *(relocInfo*)(buf+buf_offset) = padding;
 }
 buf_offset += sizeof(relocInfo);
 }
-assert(code_end_so_far == total_code_size(), "sanity");
+assert(code_end_so_far == total_content_size(), "sanity");
 // Account for index:
 if (buf != NULL) {
 RelocIterator::create_index(dest->relocation_begin(),
 buf_offset / sizeof(relocInfo),
 tty->print("done with CodeBuffer:");
 ((CodeBuffer*)this)->print();
 }
 #endif //PRODUCT
-CodeBuffer dest(dest_blob->instructions_begin(),
+CodeBuffer dest(dest_blob);
-dest_blob->instructions_size());
+assert(dest_blob->content_size() >= total_content_size(), "good sizing");
-assert(dest_blob->instructions_size() >= total_code_size(), "good sizing");
 this->compute_final_layout(&dest);
 relocate_code_to(&dest);
 // transfer comments from buffer to blob
 dest_blob->set_comments(_comments);
 // Done moving code bytes; were they the right size?
-assert(round_to(dest.total_code_size(), oopSize) == dest_blob->instructions_size(), "sanity");
+assert(round_to(dest.total_content_size(), oopSize) == dest_blob->content_size(), "sanity");
 // Flush generated code
-ICache::invalidate_range(dest_blob->instructions_begin(),
+ICache::invalidate_range(dest_blob->code_begin(), dest_blob->code_size());
-dest_blob->instructions_size());
+}
-}
+// Move all my code into another code buffer.  Consult applicable
-// Move all my code into another code buffer.
+// relocs to repair embedded addresses.  The layout in the destination
-// Consult applicable relocs to repair embedded addresses.
+// 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);
-for (int n = 0; n < (int)SECT_LIMIT; n++) {
+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);
 assert(cs->size() == dest_cs->size(), "sanity");
 csize_t CodeBuffer::figure_expanded_capacities(CodeSection* which_cs,
 csize_t amount,
 csize_t* new_capacity) {
 csize_t new_total_cap = 0;
-int prev_n = -1;
+for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
-for (int n = 0; n < (int)SECT_LIMIT; n++) {
 const CodeSection* sect = code_section(n);
 if (!sect->is_empty()) {
-// Compute initial padding; assign it to the previous non-empty guy.
+// Compute initial padding; assign it to the previous section,
-// Cf. compute_final_layout.
+// even if it's empty (e.g. consts section can be empty).
+// Cf. compute_final_layout
 csize_t padding = sect->align_at_start(new_total_cap) - new_total_cap;
 if (padding != 0) {
 new_total_cap += padding;
-assert(prev_n >= 0, "sanity");
+assert(n - 1 >= SECT_FIRST, "sanity");
-new_capacity[prev_n] += padding;
+new_capacity[n - 1] += padding;
 }
-prev_n = n;
 }
 csize_t exp = sect->size();  // 100% increase
 if ((uint)exp < 4*K)  exp = 4*K;       // minimum initial increase
 if (sect == which_cs) {
 DEBUG_ONLY(this->_blob = NULL);  // silence a later assert
 bxp->_before_expand = this->_before_expand;
 this->_before_expand = bxp;
 // Give each section its required (expanded) capacity.
-for (int n = (int)SECT_LIMIT-1; n >= SECT_INSTS; n--) {
+for (int n = (int)SECT_LIMIT-1; n >= SECT_FIRST; n--) {
 CodeSection* cb_sect   = cb.code_section(n);
 CodeSection* this_sect = code_section(n);
 if (new_capacity[n] == 0)  continue;  // already nulled out
-if (n > SECT_INSTS) {
+if (n != SECT_INSTS) {
 cb.initialize_section_size(cb_sect, new_capacity[n]);
 }
 assert(cb_sect->capacity() >= new_capacity[n], "big enough");
 address cb_start = cb_sect->start();
 cb_sect->set_end(cb_start + this_sect->size());
 bool CodeBuffer::verify_section_allocation() {
 address tstart = _total_start;
 if (tstart == badAddress)  return true;  // smashed by set_blob(NULL)
 address tend   = tstart + _total_size;
 if (_blob != NULL) {
-assert(tstart >= _blob->instructions_begin(), "sanity");
+assert(tstart >= _blob->content_begin(), "sanity");
-assert(tend   <= _blob->instructions_end(),   "sanity");
+assert(tend   <= _blob->content_end(),   "sanity");
 }
-address tcheck = tstart;  // advancing pointer to verify disjointness
+// Verify disjointness.
-for (int n = 0; n < (int)SECT_LIMIT; n++) {
+for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) {
 CodeSection* sect = code_section(n);
-if (!sect->is_allocated())  continue;
+if (!sect->is_allocated() || sect->is_empty())  continue;
-assert(sect->start() >= tcheck, "sanity");
+assert((intptr_t)sect->start() % sect->alignment() == 0
-tcheck = sect->start();
-assert((intptr_t)tcheck % sect->alignment() == 0
 || sect->is_empty() || _blob == NULL,
 "start is aligned");
-assert(sect->end()   >= tcheck, "sanity");
+for (int m = (int) SECT_FIRST; m < (int) SECT_LIMIT; m++) {
-assert(sect->end()   <= tend,   "sanity");
+CodeSection* other = code_section(m);
+if (!other->is_allocated() || other == sect)  continue;
+assert(!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");
+}
+assert(sect->end() <= tend, "sanity");
 }
 return true;
 }
 #endif //ASSERT
 }
 void CodeBuffer::decode() {
-Disassembler::decode(decode_begin(), code_end());
+Disassembler::decode(decode_begin(), insts_end());
-_decode_begin = code_end();
+_decode_begin = insts_end();
 }
 void CodeBuffer::skip_decode() {
-_decode_begin = code_end();
+_decode_begin = insts_end();
 }
 void CodeBuffer::decode_all() {
 for (int n = 0; n < (int)SECT_LIMIT; n++) {

Mercurial > hg > graal-compiler

comparison src/share/vm/asm/codeBuffer.cpp @ 1930:2d26b0046e0d