author | coleenp |
Thu, 10 Jan 2019 15:13:51 -0500 | |
changeset 53244 | 9807daeb47c4 |
parent 51633 | 21154cb84d2a |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
51633
diff
changeset
|
2 |
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2332
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2332
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2332
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
51633
diff
changeset
|
25 |
#ifndef SHARE_ASM_ASSEMBLER_HPP |
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
51633
diff
changeset
|
26 |
#define SHARE_ASM_ASSEMBLER_HPP |
7397 | 27 |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
28 |
#include "asm/codeBuffer.hpp" |
25715
d5a8dbdc5150
8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents:
22872
diff
changeset
|
29 |
#include "asm/register.hpp" |
7397 | 30 |
#include "code/oopRecorder.hpp" |
31 |
#include "code/relocInfo.hpp" |
|
32 |
#include "memory/allocation.hpp" |
|
25715
d5a8dbdc5150
8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents:
22872
diff
changeset
|
33 |
#include "runtime/vm_version.hpp" |
7397 | 34 |
#include "utilities/debug.hpp" |
35 |
#include "utilities/growableArray.hpp" |
|
40010 | 36 |
#include "utilities/macros.hpp" |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
37 |
|
2131 | 38 |
// This file contains platform-independent assembler declarations. |
1 | 39 |
|
40 |
class MacroAssembler; |
|
41 |
class AbstractAssembler; |
|
42 |
class Label; |
|
43 |
||
44 |
/** |
|
45 |
* Labels represent destinations for control transfer instructions. Such |
|
46 |
* instructions can accept a Label as their target argument. A Label is |
|
47 |
* bound to the current location in the code stream by calling the |
|
48 |
* MacroAssembler's 'bind' method, which in turn calls the Label's 'bind' |
|
49 |
* method. A Label may be referenced by an instruction before it's bound |
|
50 |
* (i.e., 'forward referenced'). 'bind' stores the current code offset |
|
51 |
* in the Label object. |
|
52 |
* |
|
53 |
* If an instruction references a bound Label, the offset field(s) within |
|
54 |
* the instruction are immediately filled in based on the Label's code |
|
55 |
* offset. If an instruction references an unbound label, that |
|
56 |
* instruction is put on a list of instructions that must be patched |
|
57 |
* (i.e., 'resolved') when the Label is bound. |
|
58 |
* |
|
59 |
* 'bind' will call the platform-specific 'patch_instruction' method to |
|
60 |
* fill in the offset field(s) for each unresolved instruction (if there |
|
61 |
* are any). 'patch_instruction' lives in one of the |
|
62 |
* cpu/<arch>/vm/assembler_<arch>* files. |
|
63 |
* |
|
64 |
* Instead of using a linked list of unresolved instructions, a Label has |
|
65 |
* an array of unresolved instruction code offsets. _patch_index |
|
66 |
* contains the total number of forward references. If the Label's array |
|
67 |
* overflows (i.e., _patch_index grows larger than the array size), a |
|
68 |
* GrowableArray is allocated to hold the remaining offsets. (The cache |
|
69 |
* size is 4 for now, which handles over 99.5% of the cases) |
|
70 |
* |
|
71 |
* Labels may only be used within a single CodeSection. If you need |
|
72 |
* to create references between code sections, use explicit relocations. |
|
73 |
*/ |
|
49373
47b5652f2928
8199283: Remove ValueObj class for allocation subclassing for compiler code
coleenp
parents:
47216
diff
changeset
|
74 |
class Label { |
1 | 75 |
private: |
51633
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
76 |
enum { PatchCacheSize = 4 debug_only( +4 ) }; |
1 | 77 |
|
78 |
// _loc encodes both the binding state (via its sign) |
|
79 |
// and the binding locator (via its value) of a label. |
|
80 |
// |
|
81 |
// _loc >= 0 bound label, loc() encodes the target (jump) position |
|
82 |
// _loc == -1 unbound label |
|
83 |
int _loc; |
|
84 |
||
85 |
// References to instructions that jump to this unresolved label. |
|
86 |
// These instructions need to be patched when the label is bound |
|
87 |
// using the platform-specific patchInstruction() method. |
|
88 |
// |
|
89 |
// To avoid having to allocate from the C-heap each time, we provide |
|
90 |
// a local cache and use the overflow only if we exceed the local cache |
|
91 |
int _patches[PatchCacheSize]; |
|
92 |
int _patch_index; |
|
93 |
GrowableArray<int>* _patch_overflow; |
|
94 |
||
95 |
Label(const Label&) { ShouldNotReachHere(); } |
|
46272
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
96 |
protected: |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
97 |
|
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
98 |
// The label will be bound to a location near its users. |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
99 |
bool _is_near; |
1 | 100 |
|
51633
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
101 |
#ifdef ASSERT |
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
102 |
// Sourcre file and line location of jump instruction |
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
103 |
int _lines[PatchCacheSize]; |
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
104 |
const char* _files[PatchCacheSize]; |
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
105 |
#endif |
1 | 106 |
public: |
107 |
||
108 |
/** |
|
109 |
* After binding, be sure 'patch_instructions' is called later to link |
|
110 |
*/ |
|
111 |
void bind_loc(int loc) { |
|
112 |
assert(loc >= 0, "illegal locator"); |
|
113 |
assert(_loc == -1, "already bound"); |
|
114 |
_loc = loc; |
|
115 |
} |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
116 |
void bind_loc(int pos, int sect) { bind_loc(CodeBuffer::locator(pos, sect)); } |
1 | 117 |
|
118 |
#ifndef PRODUCT |
|
119 |
// Iterates over all unresolved instructions for printing |
|
120 |
void print_instructions(MacroAssembler* masm) const; |
|
121 |
#endif // PRODUCT |
|
122 |
||
123 |
/** |
|
124 |
* Returns the position of the the Label in the code buffer |
|
125 |
* The position is a 'locator', which encodes both offset and section. |
|
126 |
*/ |
|
127 |
int loc() const { |
|
128 |
assert(_loc >= 0, "unbound label"); |
|
129 |
return _loc; |
|
130 |
} |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
131 |
int loc_pos() const { return CodeBuffer::locator_pos(loc()); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
132 |
int loc_sect() const { return CodeBuffer::locator_sect(loc()); } |
1 | 133 |
|
134 |
bool is_bound() const { return _loc >= 0; } |
|
135 |
bool is_unbound() const { return _loc == -1 && _patch_index > 0; } |
|
136 |
bool is_unused() const { return _loc == -1 && _patch_index == 0; } |
|
137 |
||
46272
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
138 |
// The label will be bound to a location near its users. Users can |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
139 |
// optimize on this information, e.g. generate short branches. |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
140 |
bool is_near() { return _is_near; } |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
141 |
|
1 | 142 |
/** |
143 |
* Adds a reference to an unresolved displacement instruction to |
|
144 |
* this unbound label |
|
145 |
* |
|
146 |
* @param cb the code buffer being patched |
|
147 |
* @param branch_loc the locator of the branch instruction in the code buffer |
|
148 |
*/ |
|
51633
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
149 |
void add_patch_at(CodeBuffer* cb, int branch_loc, const char* file = NULL, int line = 0); |
1 | 150 |
|
151 |
/** |
|
152 |
* Iterate over the list of patches, resolving the instructions |
|
153 |
* Call patch_instruction on each 'branch_loc' value |
|
154 |
*/ |
|
155 |
void patch_instructions(MacroAssembler* masm); |
|
156 |
||
157 |
void init() { |
|
158 |
_loc = -1; |
|
159 |
_patch_index = 0; |
|
160 |
_patch_overflow = NULL; |
|
46272
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
161 |
_is_near = false; |
1 | 162 |
} |
163 |
||
164 |
Label() { |
|
165 |
init(); |
|
166 |
} |
|
51178
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
167 |
|
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
168 |
~Label() { |
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
169 |
assert(is_bound() || is_unused(), "Label was never bound to a location, but it was used as a jmp target"); |
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
170 |
} |
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
171 |
|
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
172 |
void reset() { |
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
173 |
init(); //leave _patch_overflow because it points to CodeBuffer. |
416a76fe8067
8206075: On x86, assert on unbound assembler Labels used as branch targets
kvn
parents:
49373
diff
changeset
|
174 |
} |
1 | 175 |
}; |
176 |
||
46272
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
177 |
// A NearLabel must be bound to a location near its users. Users can |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
178 |
// optimize on this information, e.g. generate short branches. |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
179 |
class NearLabel : public Label { |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
180 |
public: |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
181 |
NearLabel() : Label() { _is_near = true; } |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
182 |
}; |
3cee5c1f3459
8173465: Introduce NearLabel for branches known to be short.
goetz
parents:
40093
diff
changeset
|
183 |
|
2148
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
184 |
// A union type for code which has to assemble both constant and |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
185 |
// non-constant operands, when the distinction cannot be made |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
186 |
// statically. |
49373
47b5652f2928
8199283: Remove ValueObj class for allocation subclassing for compiler code
coleenp
parents:
47216
diff
changeset
|
187 |
class RegisterOrConstant { |
2148
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
188 |
private: |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
189 |
Register _r; |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
190 |
intptr_t _c; |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
191 |
|
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
192 |
public: |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2148
diff
changeset
|
193 |
RegisterOrConstant(): _r(noreg), _c(0) {} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2148
diff
changeset
|
194 |
RegisterOrConstant(Register r): _r(r), _c(0) {} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2148
diff
changeset
|
195 |
RegisterOrConstant(intptr_t c): _r(noreg), _c(c) {} |
2148
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
196 |
|
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
197 |
Register as_register() const { assert(is_register(),""); return _r; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
198 |
intptr_t as_constant() const { assert(is_constant(),""); return _c; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
199 |
|
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
200 |
Register register_or_noreg() const { return _r; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
201 |
intptr_t constant_or_zero() const { return _c; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
202 |
|
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
203 |
bool is_register() const { return _r != noreg; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
204 |
bool is_constant() const { return _r == noreg; } |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
205 |
}; |
1 | 206 |
|
207 |
// The Abstract Assembler: Pure assembler doing NO optimizations on the |
|
208 |
// instruction level; i.e., what you write is what you get. |
|
209 |
// The Assembler is generating code into a CodeBuffer. |
|
210 |
class AbstractAssembler : public ResourceObj { |
|
211 |
friend class Label; |
|
212 |
||
213 |
protected: |
|
214 |
CodeSection* _code_section; // section within the code buffer |
|
215 |
OopRecorder* _oop_recorder; // support for relocInfo::oop_type |
|
216 |
||
22853
308672304981
8028767: PPC64: (part 121): smaller shared changes needed to build C2
goetz
parents:
16368
diff
changeset
|
217 |
public: |
1 | 218 |
// Code emission & accessing |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
219 |
address addr_at(int pos) const { return code_section()->start() + pos; } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
220 |
|
22853
308672304981
8028767: PPC64: (part 121): smaller shared changes needed to build C2
goetz
parents:
16368
diff
changeset
|
221 |
protected: |
1 | 222 |
// This routine is called with a label is used for an address. |
223 |
// Labels and displacements truck in offsets, but target must return a PC. |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
224 |
address target(Label& L) { return code_section()->target(L, pc()); } |
1 | 225 |
|
226 |
bool is8bit(int x) const { return -0x80 <= x && x < 0x80; } |
|
227 |
bool isByte(int x) const { return 0 <= x && x < 0x100; } |
|
228 |
bool isShiftCount(int x) const { return 0 <= x && x < 32; } |
|
229 |
||
230 |
// Instruction boundaries (required when emitting relocatable values). |
|
231 |
class InstructionMark: public StackObj { |
|
232 |
private: |
|
233 |
AbstractAssembler* _assm; |
|
234 |
||
235 |
public: |
|
236 |
InstructionMark(AbstractAssembler* assm) : _assm(assm) { |
|
237 |
assert(assm->inst_mark() == NULL, "overlapping instructions"); |
|
238 |
_assm->set_inst_mark(); |
|
239 |
} |
|
240 |
~InstructionMark() { |
|
241 |
_assm->clear_inst_mark(); |
|
242 |
} |
|
243 |
}; |
|
244 |
friend class InstructionMark; |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
245 |
#ifdef ASSERT |
1 | 246 |
// Make it return true on platforms which need to verify |
247 |
// instruction boundaries for some operations. |
|
14631
526804361522
8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
14626
diff
changeset
|
248 |
static bool pd_check_instruction_mark(); |
11434
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
249 |
|
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
250 |
// Add delta to short branch distance to verify that it still fit into imm8. |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
251 |
int _short_branch_delta; |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
252 |
|
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
253 |
int short_branch_delta() const { return _short_branch_delta; } |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
254 |
void set_short_branch_delta() { _short_branch_delta = 32; } |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
255 |
void clear_short_branch_delta() { _short_branch_delta = 0; } |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
256 |
|
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
257 |
class ShortBranchVerifier: public StackObj { |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
258 |
private: |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
259 |
AbstractAssembler* _assm; |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
260 |
|
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
261 |
public: |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
262 |
ShortBranchVerifier(AbstractAssembler* assm) : _assm(assm) { |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
263 |
assert(assm->short_branch_delta() == 0, "overlapping instructions"); |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
264 |
_assm->set_short_branch_delta(); |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
265 |
} |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
266 |
~ShortBranchVerifier() { |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
267 |
_assm->clear_short_branch_delta(); |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
268 |
} |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
269 |
}; |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
270 |
#else |
11434
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
271 |
// Dummy in product. |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
272 |
class ShortBranchVerifier: public StackObj { |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
273 |
public: |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
274 |
ShortBranchVerifier(AbstractAssembler* assm) {} |
c50976508b6b
7110832: ctw/.../org_apache_avalon_composition_util_StringHelper crashes the VM
kvn
parents:
11190
diff
changeset
|
275 |
}; |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
276 |
#endif |
1 | 277 |
|
278 |
public: |
|
279 |
||
280 |
// Creation |
|
281 |
AbstractAssembler(CodeBuffer* code); |
|
282 |
||
283 |
// ensure buf contains all code (call this before using/copying the code) |
|
284 |
void flush(); |
|
285 |
||
14837
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
286 |
void emit_int8( int8_t x) { code_section()->emit_int8( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
287 |
void emit_int16( int16_t x) { code_section()->emit_int16( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
288 |
void emit_int32( int32_t x) { code_section()->emit_int32( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
289 |
void emit_int64( int64_t x) { code_section()->emit_int64( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
290 |
|
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
291 |
void emit_float( jfloat x) { code_section()->emit_float( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
292 |
void emit_double( jdouble x) { code_section()->emit_double( x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
293 |
void emit_address(address x) { code_section()->emit_address(x); } |
a75c3082d106
8004250: replace AbstractAssembler a_byte/a_long with emit_int8/emit_int32
twisti
parents:
14831
diff
changeset
|
294 |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
295 |
// min and max values for signed immediate ranges |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
296 |
static int min_simm(int nbits) { return -(intptr_t(1) << (nbits - 1)) ; } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
297 |
static int max_simm(int nbits) { return (intptr_t(1) << (nbits - 1)) - 1; } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
298 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
299 |
// Define some: |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
300 |
static int min_simm10() { return min_simm(10); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
301 |
static int min_simm13() { return min_simm(13); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
302 |
static int min_simm16() { return min_simm(16); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
303 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
304 |
// Test if x is within signed immediate range for nbits |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
305 |
static bool is_simm(intptr_t x, int nbits) { return min_simm(nbits) <= x && x <= max_simm(nbits); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
306 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
307 |
// Define some: |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
308 |
static bool is_simm5( intptr_t x) { return is_simm(x, 5 ); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
309 |
static bool is_simm8( intptr_t x) { return is_simm(x, 8 ); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
310 |
static bool is_simm10(intptr_t x) { return is_simm(x, 10); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
311 |
static bool is_simm11(intptr_t x) { return is_simm(x, 11); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
312 |
static bool is_simm12(intptr_t x) { return is_simm(x, 12); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
313 |
static bool is_simm13(intptr_t x) { return is_simm(x, 13); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
314 |
static bool is_simm16(intptr_t x) { return is_simm(x, 16); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
315 |
static bool is_simm26(intptr_t x) { return is_simm(x, 26); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
316 |
static bool is_simm32(intptr_t x) { return is_simm(x, 32); } |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
8921
diff
changeset
|
317 |
|
1 | 318 |
// Accessors |
319 |
CodeSection* code_section() const { return _code_section; } |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
320 |
CodeBuffer* code() const { return code_section()->outer(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
321 |
int sect() const { return code_section()->index(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
322 |
address pc() const { return code_section()->end(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
323 |
int offset() const { return code_section()->size(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
324 |
int locator() const { return CodeBuffer::locator(offset(), sect()); } |
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
325 |
|
1 | 326 |
OopRecorder* oop_recorder() const { return _oop_recorder; } |
327 |
void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; } |
|
328 |
||
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
329 |
address inst_mark() const { return code_section()->mark(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
330 |
void set_inst_mark() { code_section()->set_mark(); } |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
331 |
void clear_inst_mark() { code_section()->clear_mark(); } |
1 | 332 |
|
333 |
// Constants in code |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
334 |
void relocate(RelocationHolder const& rspec, int format = 0) { |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
335 |
assert(!pd_check_instruction_mark() |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
336 |
|| inst_mark() == NULL || inst_mark() == code_section()->end(), |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
337 |
"call relocate() between instructions"); |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
338 |
code_section()->relocate(code_section()->end(), rspec, format); |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
339 |
} |
1 | 340 |
void relocate( relocInfo::relocType rtype, int format = 0) { |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14625
diff
changeset
|
341 |
code_section()->relocate(code_section()->end(), rtype, format); |
1 | 342 |
} |
343 |
||
344 |
static int code_fill_byte(); // used to pad out odd-sized code buffers |
|
345 |
||
346 |
// Associate a comment with the current offset. It will be printed |
|
347 |
// along with the disassembly when printing nmethods. Currently |
|
348 |
// only supported in the instruction section of the code buffer. |
|
349 |
void block_comment(const char* comment); |
|
16368
713209c45a82
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
15116
diff
changeset
|
350 |
// Copy str to a buffer that has the same lifetime as the CodeBuffer |
713209c45a82
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
15116
diff
changeset
|
351 |
const char* code_string(const char* str); |
1 | 352 |
|
353 |
// Label functions |
|
354 |
void bind(Label& L); // binds an unbound label L to the current code position |
|
355 |
||
356 |
// Move to a different section in the same code buffer. |
|
357 |
void set_code_section(CodeSection* cs); |
|
358 |
||
359 |
// Inform assembler when generating stub code and relocation info |
|
360 |
address start_a_stub(int required_space); |
|
361 |
void end_a_stub(); |
|
362 |
// Ditto for constants. |
|
363 |
address start_a_const(int required_space, int required_align = sizeof(double)); |
|
14624 | 364 |
void end_a_const(CodeSection* cs); // Pass the codesection to continue in (insts or stubs?). |
1 | 365 |
|
7433 | 366 |
// constants support |
14624 | 367 |
// |
368 |
// We must remember the code section (insts or stubs) in c1 |
|
369 |
// so we can reset to the proper section in end_a_const(). |
|
40040
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
370 |
address int_constant(jint c) { |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
371 |
CodeSection* c1 = _code_section; |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
372 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
373 |
if (ptr != NULL) { |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
374 |
emit_int32(c); |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
375 |
end_a_const(c1); |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
376 |
} |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
377 |
return ptr; |
7644f470d923
8160425: Vectorization with signalling NaN returns wrong result
thartmann
parents:
37466
diff
changeset
|
378 |
} |
7433 | 379 |
address long_constant(jlong c) { |
14624 | 380 |
CodeSection* c1 = _code_section; |
7433 | 381 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
382 |
if (ptr != NULL) { |
|
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
383 |
emit_int64(c); |
14624 | 384 |
end_a_const(c1); |
7433 | 385 |
} |
386 |
return ptr; |
|
387 |
} |
|
1 | 388 |
address double_constant(jdouble c) { |
14624 | 389 |
CodeSection* c1 = _code_section; |
1 | 390 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
391 |
if (ptr != NULL) { |
|
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
392 |
emit_double(c); |
14624 | 393 |
end_a_const(c1); |
1 | 394 |
} |
395 |
return ptr; |
|
396 |
} |
|
397 |
address float_constant(jfloat c) { |
|
14624 | 398 |
CodeSection* c1 = _code_section; |
1 | 399 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
400 |
if (ptr != NULL) { |
|
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
401 |
emit_float(c); |
14624 | 402 |
end_a_const(c1); |
1 | 403 |
} |
404 |
return ptr; |
|
405 |
} |
|
7433 | 406 |
address address_constant(address c) { |
14624 | 407 |
CodeSection* c1 = _code_section; |
7433 | 408 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
409 |
if (ptr != NULL) { |
|
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
410 |
emit_address(c); |
14624 | 411 |
end_a_const(c1); |
7433 | 412 |
} |
413 |
return ptr; |
|
414 |
} |
|
1 | 415 |
address address_constant(address c, RelocationHolder const& rspec) { |
14624 | 416 |
CodeSection* c1 = _code_section; |
1 | 417 |
address ptr = start_a_const(sizeof(c), sizeof(c)); |
418 |
if (ptr != NULL) { |
|
419 |
relocate(rspec); |
|
14625
b02f361c324e
8003195: AbstractAssembler should not store code pointers but use the CodeSection directly
twisti
parents:
14624
diff
changeset
|
420 |
emit_address(c); |
14624 | 421 |
end_a_const(c1); |
1 | 422 |
} |
423 |
return ptr; |
|
424 |
} |
|
425 |
||
2148
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
426 |
// Bootstrapping aid to cope with delayed determination of constants. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
427 |
// Returns a static address which will eventually contain the constant. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
428 |
// The value zero (NULL) stands instead of a constant which is still uncomputed. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
429 |
// Thus, the eventual value of the constant must not be zero. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
430 |
// This is fine, since this is designed for embedding object field |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
431 |
// offsets in code which must be generated before the object class is loaded. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
432 |
// Field offsets are never zero, since an object's header (mark word) |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
433 |
// is located at offset zero. |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
11434
diff
changeset
|
434 |
RegisterOrConstant delayed_value(int(*value_fn)(), Register tmp, int offset = 0); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
11434
diff
changeset
|
435 |
RegisterOrConstant delayed_value(address(*value_fn)(), Register tmp, int offset = 0); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2148
diff
changeset
|
436 |
virtual RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr, Register tmp, int offset) = 0; |
2148
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
437 |
// Last overloading is platform-dependent; look in assembler_<arch>.cpp. |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
438 |
static intptr_t* delayed_value_addr(int(*constant_fn)()); |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
439 |
static intptr_t* delayed_value_addr(address(*constant_fn)()); |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
440 |
static void update_delayed_values(); |
09c7f703773b
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
2131
diff
changeset
|
441 |
|
1 | 442 |
// Bang stack to trigger StackOverflowError at a safe location |
443 |
// implementation delegates to machine-specific bang_stack_with_offset |
|
444 |
void generate_stack_overflow_check( int frame_size_in_bytes ); |
|
445 |
virtual void bang_stack_with_offset(int offset) = 0; |
|
446 |
||
447 |
||
448 |
/** |
|
449 |
* A platform-dependent method to patch a jump instruction that refers |
|
450 |
* to this label. |
|
451 |
* |
|
452 |
* @param branch the location of the instruction to patch |
|
453 |
* @param masm the assembler which generated the branch |
|
454 |
*/ |
|
51633
21154cb84d2a
8209594: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset
kvn
parents:
51178
diff
changeset
|
455 |
void pd_patch_instruction(address branch, address target, const char* file, int line); |
1 | 456 |
|
457 |
}; |
|
458 |
||
40010 | 459 |
#include CPU_HEADER(assembler) |
7397 | 460 |
|
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
51633
diff
changeset
|
461 |
#endif // SHARE_ASM_ASSEMBLER_HPP |