jdk8-mips64-public/hotspot: comparison src/share/vm/asm/codeBuffer.cpp

-:53dbe853fb3a
+:3e8fbc61cee8
 /*
-* Copyright (c) 1997, 2009, Oracle and/or its affiliates. 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.
 // 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));
 }
 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;
 /// 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...
 int alignSize = MAX2((intx) sizeof(jdouble), CodeEntryAlignment);
 assert( (dest->_total_start - _insts.start()) % alignSize == 0, "copy must preserve alignment");
 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 code_size_so_far = 0;
 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 {
 *(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 relocs to repair embedded addresses.
 void CodeBuffer::relocate_code_to(CodeBuffer* dest) const {
 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
 for (int n = 0; n < (int)SECT_LIMIT; n++) {
 CodeSection* sect = code_section(n);
 if (!sect->is_allocated())  continue;
 }
 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 > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/asm/codeBuffer.cpp

src/share/vm/asm/codeBuffer.cpp