1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ART_COMPILER_UTILS_JNI_MACRO_ASSEMBLER_H_
18 #define ART_COMPILER_UTILS_JNI_MACRO_ASSEMBLER_H_
19
20 #include <vector>
21
22 #include <android-base/logging.h>
23
24 #include "arch/instruction_set.h"
25 #include "base/arena_allocator.h"
26 #include "base/arena_object.h"
27 #include "base/array_ref.h"
28 #include "base/enums.h"
29 #include "base/macros.h"
30 #include "managed_register.h"
31 #include "offsets.h"
32
33 namespace art {
34
35 class ArenaAllocator;
36 class DebugFrameOpCodeWriterForAssembler;
37 class InstructionSetFeatures;
38 class MemoryRegion;
39 class JNIMacroLabel;
40
41 enum class JNIMacroUnaryCondition {
42 kZero,
43 kNotZero
44 };
45
46 class ArgumentLocation {
47 public:
ArgumentLocation(ManagedRegister reg,size_t size)48 ArgumentLocation(ManagedRegister reg, size_t size)
49 : reg_(reg), frame_offset_(0u), size_(size) {
50 DCHECK(reg.IsRegister());
51 }
52
ArgumentLocation(FrameOffset frame_offset,size_t size)53 ArgumentLocation(FrameOffset frame_offset, size_t size)
54 : reg_(ManagedRegister::NoRegister()), frame_offset_(frame_offset), size_(size) {}
55
IsRegister()56 bool IsRegister() const {
57 return reg_.IsRegister();
58 }
59
GetRegister()60 ManagedRegister GetRegister() const {
61 DCHECK(IsRegister());
62 return reg_;
63 }
64
GetFrameOffset()65 FrameOffset GetFrameOffset() const {
66 DCHECK(!IsRegister());
67 return frame_offset_;
68 }
69
GetSize()70 size_t GetSize() const {
71 return size_;
72 }
73
74 private:
75 ManagedRegister reg_;
76 FrameOffset frame_offset_;
77 size_t size_;
78 };
79
80 template <PointerSize kPointerSize>
81 class JNIMacroAssembler : public DeletableArenaObject<kArenaAllocAssembler> {
82 public:
83 static std::unique_ptr<JNIMacroAssembler<kPointerSize>> Create(
84 ArenaAllocator* allocator,
85 InstructionSet instruction_set,
86 const InstructionSetFeatures* instruction_set_features = nullptr);
87
88 // Finalize the code; emit slow paths, fixup branches, add literal pool, etc.
89 virtual void FinalizeCode() = 0;
90
91 // Size of generated code
92 virtual size_t CodeSize() const = 0;
93
94 // Copy instructions out of assembly buffer into the given region of memory
95 virtual void FinalizeInstructions(const MemoryRegion& region) = 0;
96
97 // Emit code that will create an activation on the stack
98 virtual void BuildFrame(size_t frame_size,
99 ManagedRegister method_reg,
100 ArrayRef<const ManagedRegister> callee_save_regs) = 0;
101
102 // Emit code that will remove an activation from the stack
103 //
104 // Argument `may_suspend` must be `true` if the compiled method may be
105 // suspended during its execution (otherwise `false`, if it is impossible
106 // to suspend during its execution).
107 virtual void RemoveFrame(size_t frame_size,
108 ArrayRef<const ManagedRegister> callee_save_regs,
109 bool may_suspend) = 0;
110
111 virtual void IncreaseFrameSize(size_t adjust) = 0;
112 virtual void DecreaseFrameSize(size_t adjust) = 0;
113
114 // Store routines
115 virtual void Store(FrameOffset offs, ManagedRegister src, size_t size) = 0;
116 virtual void StoreRef(FrameOffset dest, ManagedRegister src) = 0;
117 virtual void StoreRawPtr(FrameOffset dest, ManagedRegister src) = 0;
118
119 virtual void StoreImmediateToFrame(FrameOffset dest, uint32_t imm) = 0;
120
121 virtual void StoreStackOffsetToThread(ThreadOffset<kPointerSize> thr_offs,
122 FrameOffset fr_offs) = 0;
123
124 virtual void StoreStackPointerToThread(ThreadOffset<kPointerSize> thr_offs) = 0;
125
126 virtual void StoreSpanning(FrameOffset dest,
127 ManagedRegister src,
128 FrameOffset in_off) = 0;
129
130 // Load routines
131 virtual void Load(ManagedRegister dest, FrameOffset src, size_t size) = 0;
132
133 virtual void LoadFromThread(ManagedRegister dest,
134 ThreadOffset<kPointerSize> src,
135 size_t size) = 0;
136
137 virtual void LoadRef(ManagedRegister dest, FrameOffset src) = 0;
138 // If unpoison_reference is true and kPoisonReference is true, then we negate the read reference.
139 virtual void LoadRef(ManagedRegister dest,
140 ManagedRegister base,
141 MemberOffset offs,
142 bool unpoison_reference) = 0;
143
144 virtual void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) = 0;
145
146 virtual void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset<kPointerSize> offs) = 0;
147
148 // Copying routines
149 virtual void MoveArguments(ArrayRef<ArgumentLocation> dests, ArrayRef<ArgumentLocation> srcs) = 0;
150
151 virtual void Move(ManagedRegister dest, ManagedRegister src, size_t size) = 0;
152
153 virtual void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset<kPointerSize> thr_offs) = 0;
154
155 virtual void CopyRawPtrToThread(ThreadOffset<kPointerSize> thr_offs,
156 FrameOffset fr_offs,
157 ManagedRegister scratch) = 0;
158
159 virtual void CopyRef(FrameOffset dest, FrameOffset src) = 0;
160 virtual void CopyRef(FrameOffset dest,
161 ManagedRegister base,
162 MemberOffset offs,
163 bool unpoison_reference) = 0;
164
165 virtual void Copy(FrameOffset dest, FrameOffset src, size_t size) = 0;
166
167 virtual void Copy(FrameOffset dest,
168 ManagedRegister src_base,
169 Offset src_offset,
170 ManagedRegister scratch,
171 size_t size) = 0;
172
173 virtual void Copy(ManagedRegister dest_base,
174 Offset dest_offset,
175 FrameOffset src,
176 ManagedRegister scratch,
177 size_t size) = 0;
178
179 virtual void Copy(FrameOffset dest,
180 FrameOffset src_base,
181 Offset src_offset,
182 ManagedRegister scratch,
183 size_t size) = 0;
184
185 virtual void Copy(ManagedRegister dest,
186 Offset dest_offset,
187 ManagedRegister src,
188 Offset src_offset,
189 ManagedRegister scratch,
190 size_t size) = 0;
191
192 virtual void Copy(FrameOffset dest,
193 Offset dest_offset,
194 FrameOffset src,
195 Offset src_offset,
196 ManagedRegister scratch,
197 size_t size) = 0;
198
199 virtual void MemoryBarrier(ManagedRegister scratch) = 0;
200
201 // Sign extension
202 virtual void SignExtend(ManagedRegister mreg, size_t size) = 0;
203
204 // Zero extension
205 virtual void ZeroExtend(ManagedRegister mreg, size_t size) = 0;
206
207 // Exploit fast access in managed code to Thread::Current()
208 virtual void GetCurrentThread(ManagedRegister dest) = 0;
209 virtual void GetCurrentThread(FrameOffset dest_offset) = 0;
210
211 // Set up out_reg to hold a Object** into the handle scope, or to be null if the
212 // value is null and null_allowed. in_reg holds a possibly stale reference
213 // that can be used to avoid loading the handle scope entry to see if the value is
214 // null.
215 virtual void CreateHandleScopeEntry(ManagedRegister out_reg,
216 FrameOffset handlescope_offset,
217 ManagedRegister in_reg,
218 bool null_allowed) = 0;
219
220 // Set up out_off to hold a Object** into the handle scope, or to be null if the
221 // value is null and null_allowed.
222 virtual void CreateHandleScopeEntry(FrameOffset out_off,
223 FrameOffset handlescope_offset,
224 bool null_allowed) = 0;
225
226 // src holds a handle scope entry (Object**) load this into dst
227 virtual void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) = 0;
228
229 // Heap::VerifyObject on src. In some cases (such as a reference to this) we
230 // know that src may not be null.
231 virtual void VerifyObject(ManagedRegister src, bool could_be_null) = 0;
232 virtual void VerifyObject(FrameOffset src, bool could_be_null) = 0;
233
234 // Jump to address held at [base+offset] (used for tail calls).
235 virtual void Jump(ManagedRegister base, Offset offset) = 0;
236
237 // Call to address held at [base+offset]
238 virtual void Call(ManagedRegister base, Offset offset) = 0;
239 virtual void Call(FrameOffset base, Offset offset) = 0;
240 virtual void CallFromThread(ThreadOffset<kPointerSize> offset) = 0;
241
242 // Generate code to check if Thread::Current()->exception_ is non-null
243 // and branch to a ExceptionSlowPath if it is.
244 virtual void ExceptionPoll(size_t stack_adjust) = 0;
245
246 // Create a new label that can be used with Jump/Bind calls.
247 virtual std::unique_ptr<JNIMacroLabel> CreateLabel() = 0;
248 // Emit an unconditional jump to the label.
249 virtual void Jump(JNIMacroLabel* label) = 0;
250 // Emit a conditional jump to the label by applying a unary condition test to the GC marking flag.
251 virtual void TestGcMarking(JNIMacroLabel* label, JNIMacroUnaryCondition cond) = 0;
252 // Code at this offset will serve as the target for the Jump call.
253 virtual void Bind(JNIMacroLabel* label) = 0;
254
~JNIMacroAssembler()255 virtual ~JNIMacroAssembler() {}
256
257 /**
258 * @brief Buffer of DWARF's Call Frame Information opcodes.
259 * @details It is used by debuggers and other tools to unwind the call stack.
260 */
261 virtual DebugFrameOpCodeWriterForAssembler& cfi() = 0;
262
SetEmitRunTimeChecksInDebugMode(bool value)263 void SetEmitRunTimeChecksInDebugMode(bool value) {
264 emit_run_time_checks_in_debug_mode_ = value;
265 }
266
267 protected:
JNIMacroAssembler()268 JNIMacroAssembler() {}
269
270 // Should run-time checks be emitted in debug mode?
271 bool emit_run_time_checks_in_debug_mode_ = false;
272 };
273
274 // A "Label" class used with the JNIMacroAssembler
275 // allowing one to use branches (jumping from one place to another).
276 //
277 // This is just an interface, so every platform must provide
278 // its own implementation of it.
279 //
280 // It is only safe to use a label created
281 // via JNIMacroAssembler::CreateLabel with that same macro assembler.
282 class JNIMacroLabel {
283 public:
284 virtual ~JNIMacroLabel() = 0;
285
286 const InstructionSet isa_;
287 protected:
JNIMacroLabel(InstructionSet isa)288 explicit JNIMacroLabel(InstructionSet isa) : isa_(isa) {}
289 };
290
~JNIMacroLabel()291 inline JNIMacroLabel::~JNIMacroLabel() {
292 // Compulsory definition for a pure virtual destructor
293 // to avoid linking errors.
294 }
295
296 template <typename T, PointerSize kPointerSize>
297 class JNIMacroAssemblerFwd : public JNIMacroAssembler<kPointerSize> {
298 public:
FinalizeCode()299 void FinalizeCode() override {
300 asm_.FinalizeCode();
301 }
302
CodeSize()303 size_t CodeSize() const override {
304 return asm_.CodeSize();
305 }
306
FinalizeInstructions(const MemoryRegion & region)307 void FinalizeInstructions(const MemoryRegion& region) override {
308 asm_.FinalizeInstructions(region);
309 }
310
cfi()311 DebugFrameOpCodeWriterForAssembler& cfi() override {
312 return asm_.cfi();
313 }
314
315 protected:
JNIMacroAssemblerFwd(ArenaAllocator * allocator)316 explicit JNIMacroAssemblerFwd(ArenaAllocator* allocator) : asm_(allocator) {}
317
318 T asm_;
319 };
320
321 template <typename Self, typename PlatformLabel, InstructionSet kIsa>
322 class JNIMacroLabelCommon : public JNIMacroLabel {
323 public:
Cast(JNIMacroLabel * label)324 static Self* Cast(JNIMacroLabel* label) {
325 CHECK(label != nullptr);
326 CHECK_EQ(kIsa, label->isa_);
327
328 return reinterpret_cast<Self*>(label);
329 }
330
331 protected:
AsPlatformLabel()332 PlatformLabel* AsPlatformLabel() {
333 return &label_;
334 }
335
JNIMacroLabelCommon()336 JNIMacroLabelCommon() : JNIMacroLabel(kIsa) {
337 }
338
~JNIMacroLabelCommon()339 ~JNIMacroLabelCommon() override {}
340
341 private:
342 PlatformLabel label_;
343 };
344
345 } // namespace art
346
347 #endif // ART_COMPILER_UTILS_JNI_MACRO_ASSEMBLER_H_
348