1 /*
2 * Copyright (c) 2000, 2021, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_OPTO_OUTPUT_HPP
26 #define SHARE_OPTO_OUTPUT_HPP
27
28 #include "code/debugInfo.hpp"
29 #include "code/exceptionHandlerTable.hpp"
30 #include "metaprogramming/enableIf.hpp"
31 #include "opto/ad.hpp"
32 #include "opto/constantTable.hpp"
33 #include "opto/phase.hpp"
34 #include "runtime/vm_version.hpp"
35 #include "utilities/globalDefinitions.hpp"
36 #include "utilities/macros.hpp"
37
38 class AbstractCompiler;
39 class Arena;
40 class Bundle;
41 class Block;
42 class Block_Array;
43 class C2_MacroAssembler;
44 class ciMethod;
45 class Compile;
46 class MachNode;
47 class MachSafePointNode;
48 class Node;
49 class PhaseCFG;
50 #ifndef PRODUCT
51 #define DEBUG_ARG(x) , x
52 #else
53 #define DEBUG_ARG(x)
54 #endif
55
56 // Define the initial sizes for allocation of the resizable code buffer
57 enum {
58 initial_const_capacity = 4 * 1024
59 };
60
61 class BufferSizingData {
62 public:
63 int _stub;
64 int _code;
65 int _const;
66 int _reloc;
67
68 BufferSizingData() :
69 _stub(0),
70 _code(0),
71 _const(0),
72 _reloc(0)
73 { };
74 };
75
76 class C2SafepointPollStubTable {
77 private:
78 struct C2SafepointPollStub: public ArenaObj {
79 uintptr_t _safepoint_offset;
80 Label _stub_label;
81 Label _trampoline_label;
82 C2SafepointPollStub(uintptr_t safepoint_offset) :
83 _safepoint_offset(safepoint_offset),
84 _stub_label(),
85 _trampoline_label() {}
86 };
87
88 GrowableArray<C2SafepointPollStub*> _safepoints;
89
90 static volatile int _stub_size;
91
92 void emit_stub_impl(MacroAssembler& masm, C2SafepointPollStub* entry) const;
93
94 // The selection logic below relieves the need to add dummy files to unsupported platforms.
95 template <bool enabled>
96 typename EnableIf<enabled>::type
97 select_emit_stub(MacroAssembler& masm, C2SafepointPollStub* entry) const {
98 emit_stub_impl(masm, entry);
99 }
100
101 template <bool enabled>
102 typename EnableIf<!enabled>::type
103 select_emit_stub(MacroAssembler& masm, C2SafepointPollStub* entry) const {}
104
105 void emit_stub(MacroAssembler& masm, C2SafepointPollStub* entry) const {
106 select_emit_stub<VM_Version::supports_stack_watermark_barrier()>(masm, entry);
107 }
108
109 int stub_size_lazy() const;
110
111 public:
112 Label& add_safepoint(uintptr_t safepoint_offset);
113 int estimate_stub_size() const;
114 void emit(CodeBuffer& cb);
115 };
116
117 // We move non-hot code of the nmethod entry barrier to an out-of-line stub
118 class C2EntryBarrierStub: public ArenaObj {
119 Label _slow_path;
120 Label _continuation;
121 Label _guard; // Used on AArch64 and RISCV
122
123 public:
124 C2EntryBarrierStub() :
125 _slow_path(),
126 _continuation(),
127 _guard() {}
128
129 Label& slow_path() { return _slow_path; }
130 Label& continuation() { return _continuation; }
131 Label& guard() { return _guard; }
132
133 };
134
135 class C2EntryBarrierStubTable {
136 C2EntryBarrierStub* _stub;
137
138 public:
139 C2EntryBarrierStubTable() : _stub(NULL) {}
140 C2EntryBarrierStub* add_entry_barrier();
141 int estimate_stub_size() const;
142 void emit(CodeBuffer& cb);
143 };
144
145 class PhaseOutput : public Phase {
146 private:
147 // Instruction bits passed off to the VM
148 int _method_size; // Size of nmethod code segment in bytes
149 CodeBuffer _code_buffer; // Where the code is assembled
150 int _first_block_size; // Size of unvalidated entry point code / OSR poison code
151 ExceptionHandlerTable _handler_table; // Table of native-code exception handlers
152 ImplicitExceptionTable _inc_table; // Table of implicit null checks in native code
153 C2SafepointPollStubTable _safepoint_poll_table;// Table for safepoint polls
154 C2EntryBarrierStubTable _entry_barrier_table; // Table for entry barrier stubs
155 OopMapSet* _oop_map_set; // Table of oop maps (one for each safepoint location)
156 BufferBlob* _scratch_buffer_blob; // For temporary code buffers.
157 relocInfo* _scratch_locs_memory; // For temporary code buffers.
158 int _scratch_const_size; // For temporary code buffers.
159 bool _in_scratch_emit_size; // true when in scratch_emit_size.
160
161 int _frame_slots; // Size of total frame in stack slots
162 CodeOffsets _code_offsets; // Offsets into the code for various interesting entries
163
164 uint _node_bundling_limit;
165 Bundle* _node_bundling_base; // Information for instruction bundling
166
167 // For deopt
168 int _orig_pc_slot;
169 int _orig_pc_slot_offset_in_bytes;
170
171 ConstantTable _constant_table; // The constant table for this compilation unit.
172
173 BufferSizingData _buf_sizes;
174 Block* _block;
175 uint _index;
176
177 void perform_mach_node_analysis();
178 void pd_perform_mach_node_analysis();
179
180 public:
181 PhaseOutput();
182 ~PhaseOutput();
183
184 // Convert Nodes to instruction bits and pass off to the VM
185 void Output();
186 bool need_stack_bang(int frame_size_in_bytes) const;
187 bool need_register_stack_bang() const;
188 void compute_loop_first_inst_sizes();
189
190 void install_code(ciMethod* target,
191 int entry_bci,
192 AbstractCompiler* compiler,
193 bool has_unsafe_access,
194 bool has_wide_vectors,
195 RTMState rtm_state);
196
197 void install_stub(const char* stub_name);
198
199 // Constant table
200 ConstantTable& constant_table() { return _constant_table; }
201
202 // Safepoint poll table
203 C2SafepointPollStubTable* safepoint_poll_table() { return &_safepoint_poll_table; }
204
205 // Entry barrier table
206 C2EntryBarrierStubTable* entry_barrier_table() { return &_entry_barrier_table; }
207
208 // Code emission iterator
209 Block* block() { return _block; }
210 int index() { return _index; }
211
212 // The architecture description provides short branch variants for some long
213 // branch instructions. Replace eligible long branches with short branches.
214 void shorten_branches(uint* blk_starts);
215 // If "objs" contains an ObjectValue whose id is "id", returns it, else NULL.
216 static ObjectValue* sv_for_node_id(GrowableArray<ScopeValue*> *objs, int id);
217 static void set_sv_for_object_node(GrowableArray<ScopeValue*> *objs, ObjectValue* sv);
218 void FillLocArray( int idx, MachSafePointNode* sfpt, Node *local,
219 GrowableArray<ScopeValue*> *array,
220 GrowableArray<ScopeValue*> *objs );
221
222 void Process_OopMap_Node(MachNode *mach, int current_offset);
223
224 // Initialize code buffer
225 void estimate_buffer_size(int& const_req);
226 CodeBuffer* init_buffer();
227
228 // Write out basic block data to code buffer
229 void fill_buffer(CodeBuffer* cb, uint* blk_starts);
230
231 // Compute the information for the exception tables
232 void FillExceptionTables(uint cnt, uint *call_returns, uint *inct_starts, Label *blk_labels);
233
234 // Perform instruction scheduling and bundling over the sequence of
235 // instructions in backwards order.
236 void ScheduleAndBundle();
237
238 void install();
239
240 // Instruction bits passed off to the VM
241 int code_size() { return _method_size; }
242 CodeBuffer* code_buffer() { return &_code_buffer; }
243 int first_block_size() { return _first_block_size; }
244 void set_frame_complete(int off) { if (!in_scratch_emit_size()) { _code_offsets.set_value(CodeOffsets::Frame_Complete, off); } }
245 ExceptionHandlerTable* handler_table() { return &_handler_table; }
246 ImplicitExceptionTable* inc_table() { return &_inc_table; }
247 OopMapSet* oop_map_set() { return _oop_map_set; }
248
249 // Scratch buffer
250 BufferBlob* scratch_buffer_blob() { return _scratch_buffer_blob; }
251 void init_scratch_buffer_blob(int const_size);
252 void clear_scratch_buffer_blob();
253 void set_scratch_buffer_blob(BufferBlob* b) { _scratch_buffer_blob = b; }
254 relocInfo* scratch_locs_memory() { return _scratch_locs_memory; }
255 void set_scratch_locs_memory(relocInfo* b) { _scratch_locs_memory = b; }
256 int scratch_buffer_code_size() { return (address)scratch_locs_memory() - _scratch_buffer_blob->content_begin(); }
257
258 // emit to scratch blob, report resulting size
259 uint scratch_emit_size(const Node* n);
260 void set_in_scratch_emit_size(bool x) { _in_scratch_emit_size = x; }
261 bool in_scratch_emit_size() const { return _in_scratch_emit_size; }
262
263 enum ScratchBufferBlob {
264 MAX_inst_size = 2048,
265 MAX_locs_size = 128, // number of relocInfo elements
266 MAX_const_size = 128,
267 MAX_stubs_size = 128
268 };
269
270 int frame_slots() const { return _frame_slots; }
271 int frame_size_in_words() const; // frame_slots in units of the polymorphic 'words'
272 int frame_size_in_bytes() const { return _frame_slots << LogBytesPerInt; }
273
274 int bang_size_in_bytes() const;
275
276 void set_node_bundling_limit(uint n) { _node_bundling_limit = n; }
277 void set_node_bundling_base(Bundle* b) { _node_bundling_base = b; }
278
279 Bundle* node_bundling(const Node *n);
280 bool valid_bundle_info(const Node *n);
281
282 bool starts_bundle(const Node *n) const;
283
284 // Dump formatted assembly
285 #if defined(SUPPORT_OPTO_ASSEMBLY)
286 void dump_asm_on(outputStream* ost, int* pcs, uint pc_limit);
287 #else
288 void dump_asm_on(outputStream* ost, int* pcs, uint pc_limit) { return; }
289 #endif
290
291 // Build OopMaps for each GC point
292 void BuildOopMaps();
293
294 #ifndef PRODUCT
295 void print_scheduling();
296 static void print_statistics();
297 #endif
298 };
299
300 #endif // SHARE_OPTO_OUTPUT_HPP