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

annotate src/share/vm/asm/assembler.hpp @ 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	a9becfeecd1b
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: 8767 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: 665 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 665 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: 665 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 #ifndef SHARE_VM_ASM_ASSEMBLER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_ASM_ASSEMBLER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	28 #include "asm/codeBuffer.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "code/oopRecorder.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "code/relocInfo.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "utilities/debug.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "utilities/top.hpp"
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	35
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 # include "register_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	38 # include "vm_version_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	40 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	41 # include "register_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	42 # include "vm_version_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	43 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	44 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	45 # include "register_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	46 # include "vm_version_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	47 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	48 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	49 # include "register_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	50 # include "vm_version_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	51 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	52 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	53 # include "register_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	54 # include "vm_version_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	55 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	56
605 98cb887364d3 6810672: Comment typos twisti parents: 0 diff changeset	57 // This file contains platform-independent assembler declarations.
0 a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 class MacroAssembler;
a61af66fc99e Initial load duke parents: diff changeset	60 class AbstractAssembler;
a61af66fc99e Initial load duke parents: diff changeset	61 class Label;
a61af66fc99e Initial load duke parents: diff changeset	62
a61af66fc99e Initial load duke parents: diff changeset	63 /**
a61af66fc99e Initial load duke parents: diff changeset	64 * Labels represent destinations for control transfer instructions. Such
a61af66fc99e Initial load duke parents: diff changeset	65 * instructions can accept a Label as their target argument. A Label is
a61af66fc99e Initial load duke parents: diff changeset	66 * bound to the current location in the code stream by calling the
a61af66fc99e Initial load duke parents: diff changeset	67 * MacroAssembler's 'bind' method, which in turn calls the Label's 'bind'
a61af66fc99e Initial load duke parents: diff changeset	68 * method. A Label may be referenced by an instruction before it's bound
a61af66fc99e Initial load duke parents: diff changeset	69 * (i.e., 'forward referenced'). 'bind' stores the current code offset
a61af66fc99e Initial load duke parents: diff changeset	70 * in the Label object.
a61af66fc99e Initial load duke parents: diff changeset	71 *
a61af66fc99e Initial load duke parents: diff changeset	72 * If an instruction references a bound Label, the offset field(s) within
a61af66fc99e Initial load duke parents: diff changeset	73 * the instruction are immediately filled in based on the Label's code
a61af66fc99e Initial load duke parents: diff changeset	74 * offset. If an instruction references an unbound label, that
a61af66fc99e Initial load duke parents: diff changeset	75 * instruction is put on a list of instructions that must be patched
a61af66fc99e Initial load duke parents: diff changeset	76 * (i.e., 'resolved') when the Label is bound.
a61af66fc99e Initial load duke parents: diff changeset	77 *
a61af66fc99e Initial load duke parents: diff changeset	78 * 'bind' will call the platform-specific 'patch_instruction' method to
a61af66fc99e Initial load duke parents: diff changeset	79 * fill in the offset field(s) for each unresolved instruction (if there
a61af66fc99e Initial load duke parents: diff changeset	80 * are any). 'patch_instruction' lives in one of the
a61af66fc99e Initial load duke parents: diff changeset	81 * cpu/<arch>/vm/assembler_<arch>* files.
a61af66fc99e Initial load duke parents: diff changeset	82 *
a61af66fc99e Initial load duke parents: diff changeset	83 * Instead of using a linked list of unresolved instructions, a Label has
a61af66fc99e Initial load duke parents: diff changeset	84 * an array of unresolved instruction code offsets. _patch_index
a61af66fc99e Initial load duke parents: diff changeset	85 * contains the total number of forward references. If the Label's array
a61af66fc99e Initial load duke parents: diff changeset	86 * overflows (i.e., _patch_index grows larger than the array size), a
a61af66fc99e Initial load duke parents: diff changeset	87 * GrowableArray is allocated to hold the remaining offsets. (The cache
a61af66fc99e Initial load duke parents: diff changeset	88 * size is 4 for now, which handles over 99.5% of the cases)
a61af66fc99e Initial load duke parents: diff changeset	89 *
a61af66fc99e Initial load duke parents: diff changeset	90 * Labels may only be used within a single CodeSection. If you need
a61af66fc99e Initial load duke parents: diff changeset	91 * to create references between code sections, use explicit relocations.
a61af66fc99e Initial load duke parents: diff changeset	92 */
a61af66fc99e Initial load duke parents: diff changeset	93 class Label VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	94 private:
a61af66fc99e Initial load duke parents: diff changeset	95 enum { PatchCacheSize = 4 };
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 // _loc encodes both the binding state (via its sign)
a61af66fc99e Initial load duke parents: diff changeset	98 // and the binding locator (via its value) of a label.
a61af66fc99e Initial load duke parents: diff changeset	99 //
a61af66fc99e Initial load duke parents: diff changeset	100 // _loc >= 0 bound label, loc() encodes the target (jump) position
a61af66fc99e Initial load duke parents: diff changeset	101 // _loc == -1 unbound label
a61af66fc99e Initial load duke parents: diff changeset	102 int _loc;
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 // References to instructions that jump to this unresolved label.
a61af66fc99e Initial load duke parents: diff changeset	105 // These instructions need to be patched when the label is bound
a61af66fc99e Initial load duke parents: diff changeset	106 // using the platform-specific patchInstruction() method.
a61af66fc99e Initial load duke parents: diff changeset	107 //
a61af66fc99e Initial load duke parents: diff changeset	108 // To avoid having to allocate from the C-heap each time, we provide
a61af66fc99e Initial load duke parents: diff changeset	109 // a local cache and use the overflow only if we exceed the local cache
a61af66fc99e Initial load duke parents: diff changeset	110 int _patches[PatchCacheSize];
a61af66fc99e Initial load duke parents: diff changeset	111 int _patch_index;
a61af66fc99e Initial load duke parents: diff changeset	112 GrowableArray<int>* _patch_overflow;
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 Label(const Label&) { ShouldNotReachHere(); }
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 public:
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 /**
a61af66fc99e Initial load duke parents: diff changeset	119 * After binding, be sure 'patch_instructions' is called later to link
a61af66fc99e Initial load duke parents: diff changeset	120 */
a61af66fc99e Initial load duke parents: diff changeset	121 void bind_loc(int loc) {
a61af66fc99e Initial load duke parents: diff changeset	122 assert(loc >= 0, "illegal locator");
a61af66fc99e Initial load duke parents: diff changeset	123 assert(_loc == -1, "already bound");
a61af66fc99e Initial load duke parents: diff changeset	124 _loc = loc;
a61af66fc99e Initial load duke parents: diff changeset	125 }
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	126 void bind_loc(int pos, int sect) { bind_loc(CodeBuffer::locator(pos, sect)); }
0 a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	129 // Iterates over all unresolved instructions for printing
a61af66fc99e Initial load duke parents: diff changeset	130 void print_instructions(MacroAssembler* masm) const;
a61af66fc99e Initial load duke parents: diff changeset	131 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 /**
a61af66fc99e Initial load duke parents: diff changeset	134 * Returns the position of the the Label in the code buffer
a61af66fc99e Initial load duke parents: diff changeset	135 * The position is a 'locator', which encodes both offset and section.
a61af66fc99e Initial load duke parents: diff changeset	136 */
a61af66fc99e Initial load duke parents: diff changeset	137 int loc() const {
a61af66fc99e Initial load duke parents: diff changeset	138 assert(_loc >= 0, "unbound label");
a61af66fc99e Initial load duke parents: diff changeset	139 return _loc;
a61af66fc99e Initial load duke parents: diff changeset	140 }
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	141 int loc_pos() const { return CodeBuffer::locator_pos(loc()); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	142 int loc_sect() const { return CodeBuffer::locator_sect(loc()); }
0 a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 bool is_bound() const { return _loc >= 0; }
a61af66fc99e Initial load duke parents: diff changeset	145 bool is_unbound() const { return _loc == -1 && _patch_index > 0; }
a61af66fc99e Initial load duke parents: diff changeset	146 bool is_unused() const { return _loc == -1 && _patch_index == 0; }
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 /**
a61af66fc99e Initial load duke parents: diff changeset	149 * Adds a reference to an unresolved displacement instruction to
a61af66fc99e Initial load duke parents: diff changeset	150 * this unbound label
a61af66fc99e Initial load duke parents: diff changeset	151 *
a61af66fc99e Initial load duke parents: diff changeset	152 * @param cb the code buffer being patched
a61af66fc99e Initial load duke parents: diff changeset	153 * @param branch_loc the locator of the branch instruction in the code buffer
a61af66fc99e Initial load duke parents: diff changeset	154 */
a61af66fc99e Initial load duke parents: diff changeset	155 void add_patch_at(CodeBuffer* cb, int branch_loc);
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 /**
a61af66fc99e Initial load duke parents: diff changeset	158 * Iterate over the list of patches, resolving the instructions
a61af66fc99e Initial load duke parents: diff changeset	159 * Call patch_instruction on each 'branch_loc' value
a61af66fc99e Initial load duke parents: diff changeset	160 */
a61af66fc99e Initial load duke parents: diff changeset	161 void patch_instructions(MacroAssembler* masm);
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 void init() {
a61af66fc99e Initial load duke parents: diff changeset	164 _loc = -1;
a61af66fc99e Initial load duke parents: diff changeset	165 _patch_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	166 _patch_overflow = NULL;
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 Label() {
a61af66fc99e Initial load duke parents: diff changeset	170 init();
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172 };
a61af66fc99e Initial load duke parents: diff changeset	173
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	174 // A union type for code which has to assemble both constant and
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	175 // non-constant operands, when the distinction cannot be made
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	176 // statically.
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 622 diff changeset	177 class RegisterOrConstant VALUE_OBJ_CLASS_SPEC {
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	178 private:
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	179 Register _r;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	180 intptr_t _c;
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	181
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	182 public:
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 622 diff changeset	183 RegisterOrConstant(): _r(noreg), _c(0) {}
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 622 diff changeset	184 RegisterOrConstant(Register r): _r(r), _c(0) {}
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 622 diff changeset	185 RegisterOrConstant(intptr_t c): _r(noreg), _c(c) {}
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	186
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	187 Register as_register() const { assert(is_register(),""); return _r; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	188 intptr_t as_constant() const { assert(is_constant(),""); return _c; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	189
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	190 Register register_or_noreg() const { return _r; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	191 intptr_t constant_or_zero() const { return _c; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	192
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	193 bool is_register() const { return _r != noreg; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	194 bool is_constant() const { return _r == noreg; }
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	195 };
0 a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 // The Abstract Assembler: Pure assembler doing NO optimizations on the
a61af66fc99e Initial load duke parents: diff changeset	198 // instruction level; i.e., what you write is what you get.
a61af66fc99e Initial load duke parents: diff changeset	199 // The Assembler is generating code into a CodeBuffer.
a61af66fc99e Initial load duke parents: diff changeset	200 class AbstractAssembler : public ResourceObj {
a61af66fc99e Initial load duke parents: diff changeset	201 friend class Label;
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 protected:
a61af66fc99e Initial load duke parents: diff changeset	204 CodeSection* _code_section; // section within the code buffer
a61af66fc99e Initial load duke parents: diff changeset	205 OopRecorder* _oop_recorder; // support for relocInfo::oop_type
a61af66fc99e Initial load duke parents: diff changeset	206
14437 15120a36272d 8028767: PPC64: (part 121): smaller shared changes needed to build C2 goetz parents: 8767 diff changeset	207 public:
0 a61af66fc99e Initial load duke parents: diff changeset	208 // Code emission & accessing
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	209 address addr_at(int pos) const { return code_section()->start() + pos; }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	210
14437 15120a36272d 8028767: PPC64: (part 121): smaller shared changes needed to build C2 goetz parents: 8767 diff changeset	211 protected:
0 a61af66fc99e Initial load duke parents: diff changeset	212 // This routine is called with a label is used for an address.
a61af66fc99e Initial load duke parents: diff changeset	213 // Labels and displacements truck in offsets, but target must return a PC.
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	214 address target(Label& L) { return code_section()->target(L, pc()); }
0 a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216 bool is8bit(int x) const { return -0x80 <= x && x < 0x80; }
a61af66fc99e Initial load duke parents: diff changeset	217 bool isByte(int x) const { return 0 <= x && x < 0x100; }
a61af66fc99e Initial load duke parents: diff changeset	218 bool isShiftCount(int x) const { return 0 <= x && x < 32; }
a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 // Instruction boundaries (required when emitting relocatable values).
a61af66fc99e Initial load duke parents: diff changeset	221 class InstructionMark: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	222 private:
a61af66fc99e Initial load duke parents: diff changeset	223 AbstractAssembler* _assm;
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 public:
a61af66fc99e Initial load duke parents: diff changeset	226 InstructionMark(AbstractAssembler* assm) : _assm(assm) {
a61af66fc99e Initial load duke parents: diff changeset	227 assert(assm->inst_mark() == NULL, "overlapping instructions");
a61af66fc99e Initial load duke parents: diff changeset	228 _assm->set_inst_mark();
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 ~InstructionMark() {
a61af66fc99e Initial load duke parents: diff changeset	231 _assm->clear_inst_mark();
a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233 };
a61af66fc99e Initial load duke parents: diff changeset	234 friend class InstructionMark;
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	235 #ifdef ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	236 // Make it return true on platforms which need to verify
a61af66fc99e Initial load duke parents: diff changeset	237 // instruction boundaries for some operations.
7204 f0c2369fda5a 8003250: SPARC: move MacroAssembler into separate file twisti parents: 7199 diff changeset	238 static bool pd_check_instruction_mark();
4766 40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	239
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	240 // Add delta to short branch distance to verify that it still fit into imm8.
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	241 int _short_branch_delta;
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	242
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	243 int short_branch_delta() const { return _short_branch_delta; }
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	244 void set_short_branch_delta() { _short_branch_delta = 32; }
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	245 void clear_short_branch_delta() { _short_branch_delta = 0; }
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	246
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	247 class ShortBranchVerifier: public StackObj {
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	248 private:
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	249 AbstractAssembler* _assm;
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	250
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	251 public:
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	252 ShortBranchVerifier(AbstractAssembler* assm) : _assm(assm) {
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	253 assert(assm->short_branch_delta() == 0, "overlapping instructions");
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	254 _assm->set_short_branch_delta();
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	255 }
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	256 ~ShortBranchVerifier() {
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	257 _assm->clear_short_branch_delta();
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	258 }
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	259 };
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	260 #else
4766 40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	261 // Dummy in product.
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	262 class ShortBranchVerifier: public StackObj {
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	263 public:
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	264 ShortBranchVerifier(AbstractAssembler* assm) {}
40c2484c09e1 7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM kvn parents: 4114 diff changeset	265 };
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	266 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 public:
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 // Creation
a61af66fc99e Initial load duke parents: diff changeset	271 AbstractAssembler(CodeBuffer* code);
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273 // ensure buf contains all code (call this before using/copying the code)
a61af66fc99e Initial load duke parents: diff changeset	274 void flush();
a61af66fc99e Initial load duke parents: diff changeset	275
7430 d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	276 void emit_int8( int8_t x) { code_section()->emit_int8( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	277 void emit_int16( int16_t x) { code_section()->emit_int16( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	278 void emit_int32( int32_t x) { code_section()->emit_int32( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	279 void emit_int64( int64_t x) { code_section()->emit_int64( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	280
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	281 void emit_float( jfloat x) { code_section()->emit_float( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	282 void emit_double( jdouble x) { code_section()->emit_double( x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	283 void emit_address(address x) { code_section()->emit_address(x); }
d02120b7a34f 8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32 twisti parents: 7424 diff changeset	284
4114 6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	285 // min and max values for signed immediate ranges
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	286 static int min_simm(int nbits) { return -(intptr_t(1) << (nbits - 1)) ; }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	287 static int max_simm(int nbits) { return (intptr_t(1) << (nbits - 1)) - 1; }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	288
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	289 // Define some:
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	290 static int min_simm10() { return min_simm(10); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	291 static int min_simm13() { return min_simm(13); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	292 static int min_simm16() { return min_simm(16); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	293
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	294 // Test if x is within signed immediate range for nbits
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	295 static bool is_simm(intptr_t x, int nbits) { return min_simm(nbits) <= x && x <= max_simm(nbits); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	296
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	297 // Define some:
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	298 static bool is_simm5( intptr_t x) { return is_simm(x, 5 ); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	299 static bool is_simm8( intptr_t x) { return is_simm(x, 8 ); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	300 static bool is_simm10(intptr_t x) { return is_simm(x, 10); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	301 static bool is_simm11(intptr_t x) { return is_simm(x, 11); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	302 static bool is_simm12(intptr_t x) { return is_simm(x, 12); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	303 static bool is_simm13(intptr_t x) { return is_simm(x, 13); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	304 static bool is_simm16(intptr_t x) { return is_simm(x, 16); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	305 static bool is_simm26(intptr_t x) { return is_simm(x, 26); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	306 static bool is_simm32(intptr_t x) { return is_simm(x, 32); }
6729bbc1fcd6 7003454: order constants in constant table by number of references in code twisti parents: 2426 diff changeset	307
0 a61af66fc99e Initial load duke parents: diff changeset	308 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	309 CodeSection* code_section() const { return _code_section; }
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	310 CodeBuffer* code() const { return code_section()->outer(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	311 int sect() const { return code_section()->index(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	312 address pc() const { return code_section()->end(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	313 int offset() const { return code_section()->size(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	314 int locator() const { return CodeBuffer::locator(offset(), sect()); }
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	315
0 a61af66fc99e Initial load duke parents: diff changeset	316 OopRecorder* oop_recorder() const { return _oop_recorder; }
a61af66fc99e Initial load duke parents: diff changeset	317 void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; }
a61af66fc99e Initial load duke parents: diff changeset	318
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	319 address inst_mark() const { return code_section()->mark(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	320 void set_inst_mark() { code_section()->set_mark(); }
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	321 void clear_inst_mark() { code_section()->clear_mark(); }
0 a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 // Constants in code
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	324 void relocate(RelocationHolder const& rspec, int format = 0) {
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	325 assert(!pd_check_instruction_mark()
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	326 \|\| inst_mark() == NULL \|\| inst_mark() == code_section()->end(),
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	327 "call relocate() between instructions");
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	328 code_section()->relocate(code_section()->end(), rspec, format);
cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	329 }
0 a61af66fc99e Initial load duke parents: diff changeset	330 void relocate( relocInfo::relocType rtype, int format = 0) {
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 7198 diff changeset	331 code_section()->relocate(code_section()->end(), rtype, format);
0 a61af66fc99e Initial load duke parents: diff changeset	332 }
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 static int code_fill_byte(); // used to pad out odd-sized code buffers
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 // Associate a comment with the current offset. It will be printed
a61af66fc99e Initial load duke parents: diff changeset	337 // along with the disassembly when printing nmethods. Currently
a61af66fc99e Initial load duke parents: diff changeset	338 // only supported in the instruction section of the code buffer.
a61af66fc99e Initial load duke parents: diff changeset	339 void block_comment(const char* comment);
8767 a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7476 diff changeset	340 // Copy str to a buffer that has the same lifetime as the CodeBuffer
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory roland parents: 7476 diff changeset	341 const char* code_string(const char* str);
0 a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 // Label functions
a61af66fc99e Initial load duke parents: diff changeset	344 void bind(Label& L); // binds an unbound label L to the current code position
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 // Move to a different section in the same code buffer.
a61af66fc99e Initial load duke parents: diff changeset	347 void set_code_section(CodeSection* cs);
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 // Inform assembler when generating stub code and relocation info
a61af66fc99e Initial load duke parents: diff changeset	350 address start_a_stub(int required_space);
a61af66fc99e Initial load duke parents: diff changeset	351 void end_a_stub();
a61af66fc99e Initial load duke parents: diff changeset	352 // Ditto for constants.
a61af66fc99e Initial load duke parents: diff changeset	353 address start_a_const(int required_space, int required_align = sizeof(double));
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	354 void end_a_const(CodeSection* cs); // Pass the codesection to continue in (insts or stubs?).
0 a61af66fc99e Initial load duke parents: diff changeset	355
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	356 // constants support
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	357 //
1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	358 // We must remember the code section (insts or stubs) in c1
1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	359 // so we can reset to the proper section in end_a_const().
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	360 address long_constant(jlong c) {
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	361 CodeSection* c1 = _code_section;
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	362 address ptr = start_a_const(sizeof(c), sizeof(c));
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	363 if (ptr != NULL) {
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	364 emit_int64(c);
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	365 end_a_const(c1);
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	366 }
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	367 return ptr;
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	368 }
0 a61af66fc99e Initial load duke parents: diff changeset	369 address double_constant(jdouble c) {
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	370 CodeSection* c1 = _code_section;
0 a61af66fc99e Initial load duke parents: diff changeset	371 address ptr = start_a_const(sizeof(c), sizeof(c));
a61af66fc99e Initial load duke parents: diff changeset	372 if (ptr != NULL) {
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	373 emit_double(c);
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	374 end_a_const(c1);
0 a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376 return ptr;
a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378 address float_constant(jfloat c) {
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	379 CodeSection* c1 = _code_section;
0 a61af66fc99e Initial load duke parents: diff changeset	380 address ptr = start_a_const(sizeof(c), sizeof(c));
a61af66fc99e Initial load duke parents: diff changeset	381 if (ptr != NULL) {
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	382 emit_float(c);
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	383 end_a_const(c1);
0 a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385 return ptr;
a61af66fc99e Initial load duke parents: diff changeset	386 }
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	387 address address_constant(address c) {
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	388 CodeSection* c1 = _code_section;
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	389 address ptr = start_a_const(sizeof(c), sizeof(c));
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	390 if (ptr != NULL) {
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	391 emit_address(c);
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	392 end_a_const(c1);
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	393 }
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	394 return ptr;
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	395 }
0 a61af66fc99e Initial load duke parents: diff changeset	396 address address_constant(address c, RelocationHolder const& rspec) {
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	397 CodeSection* c1 = _code_section;
0 a61af66fc99e Initial load duke parents: diff changeset	398 address ptr = start_a_const(sizeof(c), sizeof(c));
a61af66fc99e Initial load duke parents: diff changeset	399 if (ptr != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	400 relocate(rspec);
7198 6ab62ad83507 8003195: AbstractAssembler should not store code pointers but use the CodeSection directly twisti parents: 7197 diff changeset	401 emit_address(c);
7197 1acccb7c0b01 8003850: add support for constants in stub code kvn parents: 6842 diff changeset	402 end_a_const(c1);
0 a61af66fc99e Initial load duke parents: diff changeset	403 }
a61af66fc99e Initial load duke parents: diff changeset	404 return ptr;
a61af66fc99e Initial load duke parents: diff changeset	405 }
a61af66fc99e Initial load duke parents: diff changeset	406
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	407 // Bootstrapping aid to cope with delayed determination of constants.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	408 // Returns a static address which will eventually contain the constant.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	409 // The value zero (NULL) stands instead of a constant which is still uncomputed.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	410 // Thus, the eventual value of the constant must not be zero.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	411 // This is fine, since this is designed for embedding object field
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	412 // offsets in code which must be generated before the object class is loaded.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	413 // Field offsets are never zero, since an object's header (mark word)
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	414 // is located at offset zero.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	415 RegisterOrConstant delayed_value(int(*value_fn)(), Register tmp, int offset = 0);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4766 diff changeset	416 RegisterOrConstant delayed_value(address(*value_fn)(), Register tmp, int offset = 0);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 622 diff changeset	417 virtual RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr, Register tmp, int offset) = 0;
622 56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	418 // Last overloading is platform-dependent; look in assembler_<arch>.cpp.
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	419 static intptr_t* delayed_value_addr(int(*constant_fn)());
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	420 static intptr_t* delayed_value_addr(address(*constant_fn)());
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	421 static void update_delayed_values();
56aae7be60d4 6812678: macro assembler needs delayed binding of a few constants (for 6655638) jrose parents: 605 diff changeset	422
0 a61af66fc99e Initial load duke parents: diff changeset	423 // Bang stack to trigger StackOverflowError at a safe location
a61af66fc99e Initial load duke parents: diff changeset	424 // implementation delegates to machine-specific bang_stack_with_offset
a61af66fc99e Initial load duke parents: diff changeset	425 void generate_stack_overflow_check( int frame_size_in_bytes );
a61af66fc99e Initial load duke parents: diff changeset	426 virtual void bang_stack_with_offset(int offset) = 0;
a61af66fc99e Initial load duke parents: diff changeset	427
a61af66fc99e Initial load duke parents: diff changeset	428
a61af66fc99e Initial load duke parents: diff changeset	429 /**
a61af66fc99e Initial load duke parents: diff changeset	430 * A platform-dependent method to patch a jump instruction that refers
a61af66fc99e Initial load duke parents: diff changeset	431 * to this label.
a61af66fc99e Initial load duke parents: diff changeset	432 *
a61af66fc99e Initial load duke parents: diff changeset	433 * @param branch the location of the instruction to patch
a61af66fc99e Initial load duke parents: diff changeset	434 * @param masm the assembler which generated the branch
a61af66fc99e Initial load duke parents: diff changeset	435 */
a61af66fc99e Initial load duke parents: diff changeset	436 void pd_patch_instruction(address branch, address target);
a61af66fc99e Initial load duke parents: diff changeset	437
a61af66fc99e Initial load duke parents: diff changeset	438 };
a61af66fc99e Initial load duke parents: diff changeset	439
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	440 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	441 # include "assembler_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	442 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	443 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	444 # include "assembler_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	445 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	446 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	447 # include "assembler_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	448 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	449 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	450 # include "assembler_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	451 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	452 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	453 # include "assembler_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	454 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	455
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	456
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	457 #endif // SHARE_VM_ASM_ASSEMBLER_HPP

Mercurial > hg > truffle

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