truffle: src/share/vm/asm/assembler.cpp annotate

annotate src/share/vm/asm/assembler.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	55fb97c4c58d
children	4ca6dc0799b6

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17467 55fb97c4c58d 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 13047 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	26 #include "asm/macroAssembler.hpp"
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	27 #include "asm/macroAssembler.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "asm/codeBuffer.hpp"
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	29 #include "runtime/atomic.hpp"
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	30 #include "runtime/atomic.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "runtime/icache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "runtime/os.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	33
a61af66fc99e Initial load duke parents: diff changeset	34
a61af66fc99e Initial load duke parents: diff changeset	35 // Implementation of AbstractAssembler
a61af66fc99e Initial load duke parents: diff changeset	36 //
a61af66fc99e Initial load duke parents: diff changeset	37 // The AbstractAssembler is generating code into a CodeBuffer. To make code generation faster,
a61af66fc99e Initial load duke parents: diff changeset	38 // the assembler keeps a copy of the code buffers boundaries & modifies them when
a61af66fc99e Initial load duke parents: diff changeset	39 // emitting bytes rather than using the code buffers accessor functions all the time.
605 98cb887364d3 6810672: Comment typos twisti parents: 380 diff changeset	40 // The code buffer is updated via set_code_end(...) after emitting a whole instruction.
0 a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 AbstractAssembler::AbstractAssembler(CodeBuffer* code) {
a61af66fc99e Initial load duke parents: diff changeset	43 if (code == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	44 CodeSection* cs = code->insts();
a61af66fc99e Initial load duke parents: diff changeset	45 cs->clear_mark(); // new assembler kills old mark
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	46 if (cs->start() == NULL) {
10161 746b070f5022 8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap" ccheung parents: 8767 diff changeset	47 vm_exit_out_of_memory(0, OOM_MMAP_ERROR, err_msg("CodeCache: no room for %s",
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 844 diff changeset	48 code->name()));
0 a61af66fc99e Initial load duke parents: diff changeset	49 }
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	50 _code_section = cs;
6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	51 _oop_recorder= code->oop_recorder();
6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	52 DEBUG_ONLY( _short_branch_delta = 0; )
0 a61af66fc99e Initial load duke parents: diff changeset	53 }
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 void AbstractAssembler::set_code_section(CodeSection* cs) {
a61af66fc99e Initial load duke parents: diff changeset	56 assert(cs->outer() == code_section()->outer(), "sanity");
a61af66fc99e Initial load duke parents: diff changeset	57 assert(cs->is_allocated(), "need to pre-allocate this section");
a61af66fc99e Initial load duke parents: diff changeset	58 cs->clear_mark(); // new assembly into this section kills old mark
a61af66fc99e Initial load duke parents: diff changeset	59 _code_section = cs;
a61af66fc99e Initial load duke parents: diff changeset	60 }
a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 // Inform CodeBuffer that incoming code and relocation will be for stubs
a61af66fc99e Initial load duke parents: diff changeset	63 address AbstractAssembler::start_a_stub(int required_space) {
a61af66fc99e Initial load duke parents: diff changeset	64 CodeBuffer* cb = code();
a61af66fc99e Initial load duke parents: diff changeset	65 CodeSection* cs = cb->stubs();
a61af66fc99e Initial load duke parents: diff changeset	66 assert(_code_section == cb->insts(), "not in insts?");
a61af66fc99e Initial load duke parents: diff changeset	67 if (cs->maybe_expand_to_ensure_remaining(required_space)
a61af66fc99e Initial load duke parents: diff changeset	68 && cb->blob() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	69 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	70 }
a61af66fc99e Initial load duke parents: diff changeset	71 set_code_section(cs);
a61af66fc99e Initial load duke parents: diff changeset	72 return pc();
a61af66fc99e Initial load duke parents: diff changeset	73 }
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 // Inform CodeBuffer that incoming code and relocation will be code
a61af66fc99e Initial load duke parents: diff changeset	76 // Should not be called if start_a_stub() returned NULL
a61af66fc99e Initial load duke parents: diff changeset	77 void AbstractAssembler::end_a_stub() {
a61af66fc99e Initial load duke parents: diff changeset	78 assert(_code_section == code()->stubs(), "not in stubs?");
a61af66fc99e Initial load duke parents: diff changeset	79 set_code_section(code()->insts());
a61af66fc99e Initial load duke parents: diff changeset	80 }
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 // Inform CodeBuffer that incoming code and relocation will be for stubs
a61af66fc99e Initial load duke parents: diff changeset	83 address AbstractAssembler::start_a_const(int required_space, int required_align) {
a61af66fc99e Initial load duke parents: diff changeset	84 CodeBuffer* cb = code();
a61af66fc99e Initial load duke parents: diff changeset	85 CodeSection* cs = cb->consts();
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	86 assert(_code_section == cb->insts() \|\| _code_section == cb->stubs(), "not in insts/stubs?");
0 a61af66fc99e Initial load duke parents: diff changeset	87 address end = cs->end();
a61af66fc99e Initial load duke parents: diff changeset	88 int pad = -(intptr_t)end & (required_align-1);
a61af66fc99e Initial load duke parents: diff changeset	89 if (cs->maybe_expand_to_ensure_remaining(pad + required_space)) {
a61af66fc99e Initial load duke parents: diff changeset	90 if (cb->blob() == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	91 end = cs->end(); // refresh pointer
a61af66fc99e Initial load duke parents: diff changeset	92 }
a61af66fc99e Initial load duke parents: diff changeset	93 if (pad > 0) {
a61af66fc99e Initial load duke parents: diff changeset	94 while (--pad >= 0) { *end++ = 0; }
a61af66fc99e Initial load duke parents: diff changeset	95 cs->set_end(end);
a61af66fc99e Initial load duke parents: diff changeset	96 }
a61af66fc99e Initial load duke parents: diff changeset	97 set_code_section(cs);
a61af66fc99e Initial load duke parents: diff changeset	98 return end;
a61af66fc99e Initial load duke parents: diff changeset	99 }
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 // Inform CodeBuffer that incoming code and relocation will be code
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	102 // in section cs (insts or stubs).
1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	103 void AbstractAssembler::end_a_const(CodeSection* cs) {
0 a61af66fc99e Initial load duke parents: diff changeset	104 assert(_code_section == code()->consts(), "not in consts?");
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	105 set_code_section(cs);
0 a61af66fc99e Initial load duke parents: diff changeset	106 }
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108 void AbstractAssembler::flush() {
a61af66fc99e Initial load duke parents: diff changeset	109 ICache::invalidate_range(addr_at(0), offset());
a61af66fc99e Initial load duke parents: diff changeset	110 }
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 void AbstractAssembler::bind(Label& L) {
a61af66fc99e Initial load duke parents: diff changeset	113 if (L.is_bound()) {
a61af66fc99e Initial load duke parents: diff changeset	114 // Assembler can bind a label more than once to the same place.
a61af66fc99e Initial load duke parents: diff changeset	115 guarantee(L.loc() == locator(), "attempt to redefine label");
a61af66fc99e Initial load duke parents: diff changeset	116 return;
a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118 L.bind_loc(locator());
a61af66fc99e Initial load duke parents: diff changeset	119 L.patch_instructions((MacroAssembler*)this);
a61af66fc99e Initial load duke parents: diff changeset	120 }
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 void AbstractAssembler::generate_stack_overflow_check( int frame_size_in_bytes) {
a61af66fc99e Initial load duke parents: diff changeset	123 if (UseStackBanging) {
a61af66fc99e Initial load duke parents: diff changeset	124 // Each code entry causes one stack bang n pages down the stack where n
13047 be525e91f65b 8026775: nsk/jvmti/RedefineClasses/StressRedefine crashes due to EXCEPTION_ACCESS_VIOLATION mikael parents: 10161 diff changeset	125 // is configurable by StackShadowPages. The setting depends on the maximum
0 a61af66fc99e Initial load duke parents: diff changeset	126 // depth of VM call stack or native before going back into java code,
a61af66fc99e Initial load duke parents: diff changeset	127 // since only java code can raise a stack overflow exception using the
a61af66fc99e Initial load duke parents: diff changeset	128 // stack banging mechanism. The VM and native code does not detect stack
a61af66fc99e Initial load duke parents: diff changeset	129 // overflow.
a61af66fc99e Initial load duke parents: diff changeset	130 // The code in JavaCalls::call() checks that there is at least n pages
a61af66fc99e Initial load duke parents: diff changeset	131 // available, so all entry code needs to do is bang once for the end of
a61af66fc99e Initial load duke parents: diff changeset	132 // this shadow zone.
a61af66fc99e Initial load duke parents: diff changeset	133 // The entry code may need to bang additional pages if the framesize
a61af66fc99e Initial load duke parents: diff changeset	134 // is greater than a page.
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 const int page_size = os::vm_page_size();
a61af66fc99e Initial load duke parents: diff changeset	137 int bang_end = StackShadowPages*page_size;
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 // This is how far the previous frame's stack banging extended.
a61af66fc99e Initial load duke parents: diff changeset	140 const int bang_end_safe = bang_end;
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 if (frame_size_in_bytes > page_size) {
a61af66fc99e Initial load duke parents: diff changeset	143 bang_end += frame_size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 int bang_offset = bang_end_safe;
a61af66fc99e Initial load duke parents: diff changeset	147 while (bang_offset <= bang_end) {
a61af66fc99e Initial load duke parents: diff changeset	148 // Need at least one stack bang at end of shadow zone.
a61af66fc99e Initial load duke parents: diff changeset	149 bang_stack_with_offset(bang_offset);
a61af66fc99e Initial load duke parents: diff changeset	150 bang_offset += page_size;
a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152 } // end (UseStackBanging)
a61af66fc99e Initial load duke parents: diff changeset	153 }
a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 void Label::add_patch_at(CodeBuffer* cb, int branch_loc) {
a61af66fc99e Initial load duke parents: diff changeset	156 assert(_loc == -1, "Label is unbound");
a61af66fc99e Initial load duke parents: diff changeset	157 if (_patch_index < PatchCacheSize) {
a61af66fc99e Initial load duke parents: diff changeset	158 _patches[_patch_index] = branch_loc;
a61af66fc99e Initial load duke parents: diff changeset	159 } else {
a61af66fc99e Initial load duke parents: diff changeset	160 if (_patch_overflow == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	161 _patch_overflow = cb->create_patch_overflow();
a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163 _patch_overflow->push(branch_loc);
a61af66fc99e Initial load duke parents: diff changeset	164 }
a61af66fc99e Initial load duke parents: diff changeset	165 ++_patch_index;
a61af66fc99e Initial load duke parents: diff changeset	166 }
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 void Label::patch_instructions(MacroAssembler* masm) {
a61af66fc99e Initial load duke parents: diff changeset	169 assert(is_bound(), "Label is bound");
a61af66fc99e Initial load duke parents: diff changeset	170 CodeBuffer* cb = masm->code();
a61af66fc99e Initial load duke parents: diff changeset	171 int target_sect = CodeBuffer::locator_sect(loc());
a61af66fc99e Initial load duke parents: diff changeset	172 address target = cb->locator_address(loc());
a61af66fc99e Initial load duke parents: diff changeset	173 while (_patch_index > 0) {
a61af66fc99e Initial load duke parents: diff changeset	174 --_patch_index;
a61af66fc99e Initial load duke parents: diff changeset	175 int branch_loc;
a61af66fc99e Initial load duke parents: diff changeset	176 if (_patch_index >= PatchCacheSize) {
a61af66fc99e Initial load duke parents: diff changeset	177 branch_loc = _patch_overflow->pop();
a61af66fc99e Initial load duke parents: diff changeset	178 } else {
a61af66fc99e Initial load duke parents: diff changeset	179 branch_loc = _patches[_patch_index];
a61af66fc99e Initial load duke parents: diff changeset	180 }
a61af66fc99e Initial load duke parents: diff changeset	181 int branch_sect = CodeBuffer::locator_sect(branch_loc);
a61af66fc99e Initial load duke parents: diff changeset	182 address branch = cb->locator_address(branch_loc);
a61af66fc99e Initial load duke parents: diff changeset	183 if (branch_sect == CodeBuffer::SECT_CONSTS) {
a61af66fc99e Initial load duke parents: diff changeset	184 // The thing to patch is a constant word.
a61af66fc99e Initial load duke parents: diff changeset	185 (address)branch = target;
a61af66fc99e Initial load duke parents: diff changeset	186 continue;
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	190 // Cross-section branches only work if the
a61af66fc99e Initial load duke parents: diff changeset	191 // intermediate section boundaries are frozen.
a61af66fc99e Initial load duke parents: diff changeset	192 if (target_sect != branch_sect) {
a61af66fc99e Initial load duke parents: diff changeset	193 for (int n = MIN2(target_sect, branch_sect),
a61af66fc99e Initial load duke parents: diff changeset	194 nlimit = (target_sect + branch_sect) - n;
a61af66fc99e Initial load duke parents: diff changeset	195 n < nlimit; n++) {
a61af66fc99e Initial load duke parents: diff changeset	196 CodeSection* cs = cb->code_section(n);
a61af66fc99e Initial load duke parents: diff changeset	197 assert(cs->is_frozen(), "cross-section branch needs stable offsets");
a61af66fc99e Initial load duke parents: diff changeset	198 }
a61af66fc99e Initial load duke parents: diff changeset	199 }
a61af66fc99e Initial load duke parents: diff changeset	200 #endif //ASSERT
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 // Push the target offset into the branch instruction.
a61af66fc99e Initial load duke parents: diff changeset	203 masm->pd_patch_instruction(branch, target);
a61af66fc99e Initial load duke parents: diff changeset	204 }
a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	206
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	207 struct DelayedConstant {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	208 typedef void (*value_fn_t)();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	209 BasicType type;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	210 intptr_t value;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	211 value_fn_t value_fn;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	212 // This limit of 20 is generous for initial uses.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	213 // The limit needs to be large enough to store the field offsets
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	214 // into classes which do not have statically fixed layouts.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	215 // (Initial use is for method handle object offsets.)
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	216 // Look for uses of "delayed_value" in the source code
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	217 // and make sure this number is generous enough to handle all of them.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	218 enum { DC_LIMIT = 20 };
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	219 static DelayedConstant delayed_constants[DC_LIMIT];
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	220 static DelayedConstant* add(BasicType type, value_fn_t value_fn);
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	221 bool match(BasicType t, value_fn_t cfn) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	222 return type == t && value_fn == cfn;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	223 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	224 static void update_all();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	225 };
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	226
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	227 DelayedConstant DelayedConstant::delayed_constants[DC_LIMIT];
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	228 // Default C structure initialization rules have the following effect here:
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	229 // = { { (BasicType)0, (intptr_t)NULL }, ... };
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	230
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	231 DelayedConstant* DelayedConstant::add(BasicType type,
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	232 DelayedConstant::value_fn_t cfn) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	233 for (int i = 0; i < DC_LIMIT; i++) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	234 DelayedConstant* dcon = &delayed_constants[i];
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	235 if (dcon->match(type, cfn))
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	236 return dcon;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	237 if (dcon->value_fn == NULL) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	238 // (cmpxchg not because this is multi-threaded but because I'm paranoid)
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	239 if (Atomic::cmpxchg_ptr(CAST_FROM_FN_PTR(void*, cfn), &dcon->value_fn, NULL) == NULL) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	240 dcon->type = type;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	241 return dcon;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	242 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	243 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	244 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	245 // If this assert is hit (in pre-integration testing!) then re-evaluate
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	246 // the comment on the definition of DC_LIMIT.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	247 guarantee(false, "too many delayed constants");
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	248 return NULL;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	249 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	250
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	251 void DelayedConstant::update_all() {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	252 for (int i = 0; i < DC_LIMIT; i++) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	253 DelayedConstant* dcon = &delayed_constants[i];
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	254 if (dcon->value_fn != NULL && dcon->value == 0) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	255 typedef int (*int_fn_t)();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	256 typedef address (*address_fn_t)();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	257 switch (dcon->type) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	258 case T_INT: dcon->value = (intptr_t) ((int_fn_t) dcon->value_fn)(); break;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	259 case T_ADDRESS: dcon->value = (intptr_t) ((address_fn_t)dcon->value_fn)(); break;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	260 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	261 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	262 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	263 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	264
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	265 RegisterOrConstant AbstractAssembler::delayed_value(int(*value_fn)(), Register tmp, int offset) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	266 intptr_t val = (intptr_t) (*value_fn)();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	267 if (val != 0) return val + offset;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	268 return delayed_value_impl(delayed_value_addr(value_fn), tmp, offset);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	269 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	270 RegisterOrConstant AbstractAssembler::delayed_value(address(*value_fn)(), Register tmp, int offset) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	271 intptr_t val = (intptr_t) (*value_fn)();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	272 if (val != 0) return val + offset;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	273 return delayed_value_impl(delayed_value_addr(value_fn), tmp, offset);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	274 }
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	275 intptr_t* AbstractAssembler::delayed_value_addr(int(*value_fn)()) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	276 DelayedConstant* dcon = DelayedConstant::add(T_INT, (DelayedConstant::value_fn_t) value_fn);
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	277 return &dcon->value;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	278 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	279 intptr_t* AbstractAssembler::delayed_value_addr(address(*value_fn)()) {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	280 DelayedConstant* dcon = DelayedConstant::add(T_ADDRESS, (DelayedConstant::value_fn_t) value_fn);
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	281 return &dcon->value;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	282 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	283 void AbstractAssembler::update_delayed_values() {
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	284 DelayedConstant::update_all();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	285 }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	286
0 a61af66fc99e Initial load duke parents: diff changeset	287 void AbstractAssembler::block_comment(const char* comment) {
a61af66fc99e Initial load duke parents: diff changeset	288 if (sect() == CodeBuffer::SECT_INSTS) {
a61af66fc99e Initial load duke parents: diff changeset	289 code_section()->outer()->block_comment(offset(), comment);
a61af66fc99e Initial load duke parents: diff changeset	290 }
a61af66fc99e Initial load duke parents: diff changeset	291 }
a61af66fc99e Initial load duke parents: diff changeset	292
8767 a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	293 const char* AbstractAssembler::code_string(const char* str) {
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	294 if (sect() == CodeBuffer::SECT_INSTS \|\| sect() == CodeBuffer::SECT_STUBS) {
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	295 return code_section()->outer()->code_string(str);
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	296 }
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	297 return NULL;
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	298 }
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7430 diff changeset	299
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	300 bool MacroAssembler::needs_explicit_null_check(intptr_t offset) {
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	301 // Exception handler checks the nmethod's implicit null checks table
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	302 // only when this method returns false.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	303 #ifdef _LP64
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	304 if (UseCompressedOops && Universe::narrow_oop_base() != NULL) {
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	305 assert (Universe::heap() != NULL, "java heap should be initialized");
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	306 // The first page after heap_base is unmapped and
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	307 // the 'offset' is equal to [heap_base + offset] for
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	308 // narrow oop implicit null checks.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	309 uintptr_t base = (uintptr_t)Universe::narrow_oop_base();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	310 if ((uintptr_t)offset >= base) {
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	311 // Normalize offset for the next check.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	312 offset = (intptr_t)(pointer_delta((void)offset, (void)base, 1));
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	313 }
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	314 }
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 622 diff changeset	315 #endif
237 1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	316 return offset < 0 \|\| os::vm_page_size() <= offset;
1fdb98a17101 6716785: implicit null checks not triggering with CompressedOops coleenp parents: 0 diff changeset	317 }

Mercurial > hg > truffle

annotate src/share/vm/asm/assembler.cpp @ 20543:e7d0505c8a30