• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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