1 // Copyright 2018 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_TURBO_ASSEMBLER_H_
6 #define V8_TURBO_ASSEMBLER_H_
7
8 #include "src/assembler-arch.h"
9 #include "src/base/template-utils.h"
10 #include "src/heap/heap.h"
11
12 namespace v8 {
13 namespace internal {
14
15 // Common base class for platform-specific TurboAssemblers containing
16 // platform-independent bits.
17 class V8_EXPORT_PRIVATE TurboAssemblerBase : public Assembler {
18 public:
isolate()19 Isolate* isolate() const { return isolate_; }
20
CodeObject()21 Handle<HeapObject> CodeObject() const {
22 DCHECK(!code_object_.is_null());
23 return code_object_;
24 }
25
root_array_available()26 bool root_array_available() const { return root_array_available_; }
set_root_array_available(bool v)27 void set_root_array_available(bool v) { root_array_available_ = v; }
28
trap_on_abort()29 bool trap_on_abort() const { return trap_on_abort_; }
30
should_abort_hard()31 bool should_abort_hard() const { return hard_abort_; }
set_abort_hard(bool v)32 void set_abort_hard(bool v) { hard_abort_ = v; }
33
set_builtin_index(int i)34 void set_builtin_index(int i) { maybe_builtin_index_ = i; }
35
set_has_frame(bool v)36 void set_has_frame(bool v) { has_frame_ = v; }
has_frame()37 bool has_frame() const { return has_frame_; }
38
39 // Loads the given constant or external reference without embedding its direct
40 // pointer. The produced code is isolate-independent.
41 void IndirectLoadConstant(Register destination, Handle<HeapObject> object);
42 void IndirectLoadExternalReference(Register destination,
43 ExternalReference reference);
44
45 virtual void LoadFromConstantsTable(Register destination,
46 int constant_index) = 0;
47
48 virtual void LoadRootRegisterOffset(Register destination,
49 intptr_t offset) = 0;
50 virtual void LoadRootRelative(Register destination, int32_t offset) = 0;
51
52 virtual void LoadRoot(Register destination, Heap::RootListIndex index) = 0;
53
54 static int32_t RootRegisterOffset(Heap::RootListIndex root_index);
55 static int32_t RootRegisterOffsetForExternalReferenceIndex(
56 int reference_index);
57
58 static int32_t RootRegisterOffsetForBuiltinIndex(int builtin_index);
59
60 static intptr_t RootRegisterOffsetForExternalReference(
61 Isolate* isolate, const ExternalReference& reference);
62
63 // An address is addressable through kRootRegister if it is located within
64 // [isolate, roots_ + root_register_addressable_end_offset[.
65 static bool IsAddressableThroughRootRegister(
66 Isolate* isolate, const ExternalReference& reference);
67
68 protected:
69 TurboAssemblerBase(Isolate* isolate, const AssemblerOptions& options,
70 void* buffer, int buffer_size,
71 CodeObjectRequired create_code_object);
72
73 void RecordCommentForOffHeapTrampoline(int builtin_index);
74
75 Isolate* const isolate_ = nullptr;
76
77 // This handle will be patched with the code object on installation.
78 Handle<HeapObject> code_object_;
79
80 // Whether kRootRegister has been initialized.
81 bool root_array_available_ = true;
82
83 // Immediately trap instead of calling {Abort} when debug code fails.
84 bool trap_on_abort_ = FLAG_trap_on_abort;
85
86 // Emit a C call to abort instead of a runtime call.
87 bool hard_abort_ = false;
88
89 // May be set while generating builtins.
90 int maybe_builtin_index_ = Builtins::kNoBuiltinId;
91
92 bool has_frame_ = false;
93
94 DISALLOW_IMPLICIT_CONSTRUCTORS(TurboAssemblerBase);
95 };
96
97 // Avoids emitting calls to the {Builtins::kAbort} builtin when emitting debug
98 // code during the lifetime of this scope object. For disabling debug code
99 // entirely use the {DontEmitDebugCodeScope} instead.
100 class HardAbortScope BASE_EMBEDDED {
101 public:
HardAbortScope(TurboAssemblerBase * assembler)102 explicit HardAbortScope(TurboAssemblerBase* assembler)
103 : assembler_(assembler), old_value_(assembler->should_abort_hard()) {
104 assembler_->set_abort_hard(true);
105 }
~HardAbortScope()106 ~HardAbortScope() { assembler_->set_abort_hard(old_value_); }
107
108 private:
109 TurboAssemblerBase* assembler_;
110 bool old_value_;
111 };
112
113 // Helper stubs can be called in different ways depending on where the target
114 // code is located and how the call sequence is expected to look like:
115 // - JavaScript: Call on-heap {Code} object via {RelocInfo::CODE_TARGET}.
116 // - WebAssembly: Call native {WasmCode} stub via {RelocInfo::WASM_STUB_CALL}.
117 enum class StubCallMode { kCallOnHeapBuiltin, kCallWasmRuntimeStub };
118
119 #ifdef DEBUG
120 template <typename RegType, typename... RegTypes,
121 // All arguments must be either Register or DoubleRegister.
122 typename = typename std::enable_if<
123 base::is_same<Register, RegType, RegTypes...>::value ||
124 base::is_same<DoubleRegister, RegType, RegTypes...>::value>::type>
AreAliased(RegType first_reg,RegTypes...regs)125 inline bool AreAliased(RegType first_reg, RegTypes... regs) {
126 int num_different_regs = NumRegs(RegType::ListOf(first_reg, regs...));
127 int num_given_regs = sizeof...(regs) + 1;
128 return num_different_regs < num_given_regs;
129 }
130 #endif
131
132 } // namespace internal
133 } // namespace v8
134
135 #endif // V8_TURBO_ASSEMBLER_H_
136