v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
macro-assembler-s390.h
Go to the documentation of this file.
1// Copyright 2014 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_CODEGEN_S390_MACRO_ASSEMBLER_S390_H_
6#define V8_CODEGEN_S390_MACRO_ASSEMBLER_S390_H_
7
8#ifndef INCLUDED_FROM_MACRO_ASSEMBLER_H
9#error This header must be included via macro-assembler.h
10#endif
11
12#include "src/base/platform/platform.h"
13#include "src/codegen/bailout-reason.h"
14#include "src/codegen/s390/assembler-s390.h"
15#include "src/common/globals.h"
16#include "src/execution/frame-constants.h"
17#include "src/execution/isolate-data.h"
18#include "src/objects/contexts.h"
19
20namespace v8 {
21namespace internal {
22
23enum class StackLimitKind { kInterruptStackLimit, kRealStackLimit };
24
25// ----------------------------------------------------------------------------
26// Static helper functions
27
28// Generate a MemOperand for loading a field from an object.
29inline MemOperand FieldMemOperand(Register object, int offset) {
30 return MemOperand(object, offset - kHeapObjectTag);
31}
32
33// Generate a MemOperand for loading a field from an object.
34inline MemOperand FieldMemOperand(Register object, Register index, int offset) {
35 return MemOperand(object, index, offset - kHeapObjectTag);
36}
37
38enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved };
39
40Register GetRegisterThatIsNotOneOf(Register reg1, Register reg2 = no_reg,
41 Register reg3 = no_reg,
42 Register reg4 = no_reg,
43 Register reg5 = no_reg,
44 Register reg6 = no_reg);
45
46class V8_EXPORT_PRIVATE MacroAssembler : public MacroAssemblerBase {
47 public:
48 using MacroAssemblerBase::MacroAssemblerBase;
49
50 void CallBuiltin(Builtin builtin, Condition cond = al);
51 void TailCallBuiltin(Builtin builtin, Condition cond = al);
52 void AtomicCmpExchangeHelper(Register addr, Register output,
53 Register old_value, Register new_value,
54 int start, int end, int shift_amount, int offset,
55 Register temp0, Register temp1);
56 void AtomicCmpExchangeU8(Register addr, Register output, Register old_value,
57 Register new_value, Register temp0, Register temp1);
58 void AtomicCmpExchangeU16(Register addr, Register output, Register old_value,
59 Register new_value, Register temp0, Register temp1);
60 void AtomicExchangeHelper(Register addr, Register value, Register output,
61 int start, int end, int shift_amount, int offset,
62 Register scratch);
63 void AtomicExchangeU8(Register addr, Register value, Register output,
64 Register scratch);
65 void AtomicExchangeU16(Register addr, Register value, Register output,
66 Register scratch);
67
68 void DoubleMax(DoubleRegister result_reg, DoubleRegister left_reg,
69 DoubleRegister right_reg);
70 void DoubleMin(DoubleRegister result_reg, DoubleRegister left_reg,
71 DoubleRegister right_reg);
72 void FloatMax(DoubleRegister result_reg, DoubleRegister left_reg,
73 DoubleRegister right_reg);
74 void FloatMin(DoubleRegister result_reg, DoubleRegister left_reg,
75 DoubleRegister right_reg);
76 void CeilF32(DoubleRegister dst, DoubleRegister src);
77 void CeilF64(DoubleRegister dst, DoubleRegister src);
78 void FloorF32(DoubleRegister dst, DoubleRegister src);
79 void FloorF64(DoubleRegister dst, DoubleRegister src);
80 void TruncF32(DoubleRegister dst, DoubleRegister src);
81 void TruncF64(DoubleRegister dst, DoubleRegister src);
82 void NearestIntF32(DoubleRegister dst, DoubleRegister src);
83 void NearestIntF64(DoubleRegister dst, DoubleRegister src);
84
85 void LoadFromConstantsTable(Register destination, int constant_index) final;
86 void LoadRootRegisterOffset(Register destination, intptr_t offset) final;
87 void LoadRootRelative(Register destination, int32_t offset) final;
88 void StoreRootRelative(int32_t offset, Register value) final;
89
90 // Operand pointing to an external reference.
91 // May emit code to set up the scratch register. The operand is
92 // only guaranteed to be correct as long as the scratch register
93 // isn't changed.
94 // If the operand is used more than once, use a scratch register
95 // that is guaranteed not to be clobbered.
96 MemOperand ExternalReferenceAsOperand(ExternalReference reference,
97 Register scratch);
98 MemOperand ExternalReferenceAsOperand(IsolateFieldId id) {
99 return ExternalReferenceAsOperand(ExternalReference::Create(id), no_reg);
100 }
101
102 // Jump, Call, and Ret pseudo instructions implementing inter-working.
103 void Jump(Register target, Condition cond = al);
104 void Jump(Address target, RelocInfo::Mode rmode, Condition cond = al);
105 void Jump(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al);
106 void Jump(const ExternalReference& reference);
107 // Jump the register contains a smi.
108 inline void JumpIfSmi(Register value, Label* smi_label) {
109 TestIfSmi(value);
110 beq(smi_label /*, cr0*/); // branch if SMI
111 }
112 Condition CheckSmi(Register src) {
113 TestIfSmi(src);
114 return eq;
115 }
116
117 void JumpIfEqual(Register x, int32_t y, Label* dest);
118 void JumpIfLessThan(Register x, int32_t y, Label* dest);
119
120 // Caution: if {reg} is a 32-bit negative int, it should be sign-extended to
121 // 64-bit before calling this function.
122 void Switch(Register scrach, Register reg, int case_base_value,
123 Label** labels, int num_labels);
124
125 void JumpIfCodeIsMarkedForDeoptimization(Register code, Register scratch,
126 Label* if_marked_for_deoptimization);
127
128 void JumpIfCodeIsTurbofanned(Register code, Register scratch,
129 Label* if_turbofanned);
130 void LoadMap(Register destination, Register object);
131 void LoadCompressedMap(Register destination, Register object);
132
133 void LoadFeedbackVector(Register dst, Register closure, Register scratch,
134 Label* fbv_undef);
135
136 void Call(Register target);
137 void Call(Address target, RelocInfo::Mode rmode, Condition cond = al);
138 void Call(Handle<Code> code, RelocInfo::Mode rmode = RelocInfo::CODE_TARGET,
139 Condition cond = al);
140 void Ret() { b(r14); }
141 void Ret(Condition cond) { b(cond, r14); }
142
143 // TODO(olivf, 42204201) Rename this to AssertNotDeoptimized once
144 // non-leaptiering is removed from the codebase.
145 void BailoutIfDeoptimized(Register scratch);
146 void CallForDeoptimization(Builtin target, int deopt_id, Label* exit,
147 DeoptimizeKind kind, Label* ret,
148 Label* jump_deoptimization_entry_label);
149
150 // Emit code to discard a non-negative number of pointer-sized elements
151 // from the stack, clobbering only the sp register.
152 void Drop(int count);
153 void Drop(Register count, Register scratch = r0);
154
155 void Ret(int drop) {
156 Drop(drop);
157 Ret();
158 }
159
160 void Call(Label* target);
161
162 void GetLabelAddress(Register dst, Label* target);
163
164 // Load the builtin given by the Smi in |builtin_index| into |target|.
165 void LoadEntryFromBuiltinIndex(Register builtin_index, Register target);
166 void LoadEntryFromBuiltin(Builtin builtin, Register destination);
167 MemOperand EntryFromBuiltinAsOperand(Builtin builtin);
168
169#ifdef V8_ENABLE_LEAPTIERING
170 void LoadEntrypointFromJSDispatchTable(Register destination,
171 Register dispatch_handle,
172 Register scratch);
173#endif // V8_ENABLE_LEAPTIERING
174
175 // Load the code entry point from the Code object.
176 void LoadCodeInstructionStart(
177 Register destination, Register code_object,
178 CodeEntrypointTag tag = kDefaultCodeEntrypointTag);
179 void CallCodeObject(Register code_object);
180 void JumpCodeObject(Register code_object,
181 JumpMode jump_mode = JumpMode::kJump);
182
183 void CallBuiltinByIndex(Register builtin_index, Register target);
184
185 // Register move. May do nothing if the registers are identical.
186 void Move(Register dst, Tagged<Smi> smi) { LoadSmiLiteral(dst, smi); }
187 void Move(Register dst, Handle<HeapObject> source,
188 RelocInfo::Mode rmode = RelocInfo::FULL_EMBEDDED_OBJECT);
189 void Move(Register dst, ExternalReference reference);
190 void LoadIsolateField(Register dst, IsolateFieldId id);
191 void Move(Register dst, const MemOperand& src);
192 void Move(Register dst, Register src, Condition cond = al);
193 void Move(DoubleRegister dst, DoubleRegister src);
194
195 void MoveChar(const MemOperand& opnd1, const MemOperand& opnd2,
196 const Operand& length);
197
198 void CompareLogicalChar(const MemOperand& opnd1, const MemOperand& opnd2,
199 const Operand& length);
200
201 void ExclusiveOrChar(const MemOperand& opnd1, const MemOperand& opnd2,
202 const Operand& length);
203
204 void RotateInsertSelectBits(Register dst, Register src,
205 const Operand& startBit, const Operand& endBit,
206 const Operand& shiftAmt, bool zeroBits);
207
208 void BranchRelativeOnIdxHighP(Register dst, Register inc, Label* L);
209
210 void MaybeSaveRegisters(RegList registers);
211 void MaybeRestoreRegisters(RegList registers);
212
213 void CallEphemeronKeyBarrier(Register object, Register slot_address,
214 SaveFPRegsMode fp_mode);
215
216 void CallRecordWriteStubSaveRegisters(
217 Register object, Register slot_address, SaveFPRegsMode fp_mode,
218 StubCallMode mode = StubCallMode::kCallBuiltinPointer);
219 void CallRecordWriteStub(
220 Register object, Register slot_address, SaveFPRegsMode fp_mode,
221 StubCallMode mode = StubCallMode::kCallBuiltinPointer);
222
223 void MultiPush(RegList regs, Register location = sp);
224 void MultiPop(RegList regs, Register location = sp);
225
226 void MultiPushDoubles(DoubleRegList dregs, Register location = sp);
227 void MultiPopDoubles(DoubleRegList dregs, Register location = sp);
228
229 void MultiPushV128(DoubleRegList dregs, Register scratch,
230 Register location = sp);
231 void MultiPopV128(DoubleRegList dregs, Register scratch,
232 Register location = sp);
233
234 void MultiPushF64OrV128(DoubleRegList dregs, Register scratch,
235 Register location = sp);
236 void MultiPopF64OrV128(DoubleRegList dregs, Register scratch,
237 Register location = sp);
238 void PushAll(RegList registers);
239 void PopAll(RegList registers);
240 void PushAll(DoubleRegList registers, int stack_slot_size = kDoubleSize);
241 void PopAll(DoubleRegList registers, int stack_slot_size = kDoubleSize);
242
243 // Calculate how much stack space (in bytes) are required to store caller
244 // registers excluding those specified in the arguments.
245 int RequiredStackSizeForCallerSaved(SaveFPRegsMode fp_mode,
246 Register exclusion1 = no_reg,
247 Register exclusion2 = no_reg,
248 Register exclusion3 = no_reg) const;
249
250 // Push caller saved registers on the stack, and return the number of bytes
251 // stack pointer is adjusted.
252 int PushCallerSaved(SaveFPRegsMode fp_mode, Register scratch,
253 Register exclusion1 = no_reg,
254 Register exclusion2 = no_reg,
255 Register exclusion3 = no_reg);
256 // Restore caller saved registers from the stack, and return the number of
257 // bytes stack pointer is adjusted.
258 int PopCallerSaved(SaveFPRegsMode fp_mode, Register scratch,
259 Register exclusion1 = no_reg, Register exclusion2 = no_reg,
260 Register exclusion3 = no_reg);
261
262 // Load an object from the root table.
263 void LoadRoot(Register destination, RootIndex index) override {
264 LoadRoot(destination, index, al);
265 }
266 void LoadRoot(Register destination, RootIndex index, Condition cond);
267 void LoadTaggedRoot(Register destination, RootIndex index);
268 //--------------------------------------------------------------------------
269 // S390 Macro Assemblers for Instructions
270 //--------------------------------------------------------------------------
271
272 // Arithmetic Operations
273
274 // Add (Register - Immediate)
275 void AddS32(Register dst, const Operand& imm);
276 void AddS64(Register dst, const Operand& imm);
277 void AddS32(Register dst, Register src, const Operand& imm);
278 void AddS64(Register dst, Register src, const Operand& imm);
279 void AddS32(Register dst, Register src, int32_t imm);
280 void AddS64(Register dst, Register src, int32_t imm);
281
282 // Add (Register - Register)
283 void AddS32(Register dst, Register src);
284 void AddS64(Register dst, Register src);
285 void AddS32(Register dst, Register src1, Register src2);
286 void AddS64(Register dst, Register src1, Register src2);
287
288 // Add (Register - Mem)
289 void AddS32(Register dst, const MemOperand& opnd);
290 void AddS64(Register dst, const MemOperand& opnd);
291
292 // Add (Mem - Immediate)
293 void AddS32(const MemOperand& opnd, const Operand& imm);
294 void AddS64(const MemOperand& opnd, const Operand& imm);
295
296 // Add Logical (Register - Register)
297 void AddU32(Register dst, Register src1, Register src2);
298
299 // Add Logical (Register - Immediate)
300 void AddU32(Register dst, const Operand& imm);
301 void AddU64(Register dst, const Operand& imm);
302 void AddU64(Register dst, int imm) { AddU64(dst, Operand(imm)); }
303 void AddU64(Register dst, Register src1, Register src2);
304 void AddU64(Register dst, Register src) { algr(dst, src); }
305
306 // Add Logical (Register - Mem)
307 void AddU32(Register dst, const MemOperand& opnd);
308 void AddU64(Register dst, const MemOperand& opnd);
309
310 // Subtract (Register - Immediate)
311 void SubS32(Register dst, const Operand& imm);
312 void SubS64(Register dst, const Operand& imm);
313 void SubS32(Register dst, Register src, const Operand& imm);
314 void SubS64(Register dst, Register src, const Operand& imm);
315 void SubS32(Register dst, Register src, int32_t imm);
316 void SubS64(Register dst, Register src, int32_t imm);
317
318 // Subtract (Register - Register)
319 void SubS32(Register dst, Register src);
320 void SubS64(Register dst, Register src);
321 void SubS32(Register dst, Register src1, Register src2);
322 void SubS64(Register dst, Register src1, Register src2);
323
324 // Subtract (Register - Mem)
325 void SubS32(Register dst, const MemOperand& opnd);
326 void SubS64(Register dst, const MemOperand& opnd);
327 void LoadAndSub32(Register dst, Register src, const MemOperand& opnd);
328 void LoadAndSub64(Register dst, Register src, const MemOperand& opnd);
329
330 // Subtract Logical (Register - Mem)
331 void SubU32(Register dst, const MemOperand& opnd);
332 void SubU64(Register dst, const MemOperand& opnd);
333 // Subtract Logical 32-bit
334 void SubU32(Register dst, Register src1, Register src2);
335
336 // Multiply
337 void MulS64(Register dst, const Operand& opnd);
338 void MulS64(Register dst, Register src);
339 void MulS64(Register dst, const MemOperand& opnd);
340 void MulS64(Register dst, Register src1, Register src2) {
341 if (CpuFeatures::IsSupported(MISC_INSTR_EXT2)) {
342 msgrkc(dst, src1, src2);
343 } else {
344 if (dst == src2) {
345 MulS64(dst, src1);
346 } else if (dst == src1) {
347 MulS64(dst, src2);
348 } else {
349 mov(dst, src1);
350 MulS64(dst, src2);
351 }
352 }
353 }
354
355 void MulS32(Register dst, const MemOperand& src1);
356 void MulS32(Register dst, Register src1);
357 void MulS32(Register dst, const Operand& src1);
358 void MulS32(Register dst, Register src1, Register src2) {
359 if (CpuFeatures::IsSupported(MISC_INSTR_EXT2)) {
360 msrkc(dst, src1, src2);
361 } else {
362 if (dst == src2) {
363 MulS32(dst, src1);
364 } else if (dst == src1) {
365 MulS32(dst, src2);
366 } else {
367 mov(dst, src1);
368 MulS32(dst, src2);
369 }
370 }
371 }
372 void MulHighS64(Register dst, Register src1, Register src2);
373 void MulHighS64(Register dst, Register src1, const MemOperand& src2);
374 void MulHighU64(Register dst, Register src1, Register src2);
375 void MulHighU64(Register dst, Register src1, const MemOperand& src2);
376
377 void MulHighS32(Register dst, Register src1, const MemOperand& src2);
378 void MulHighS32(Register dst, Register src1, Register src2);
379 void MulHighS32(Register dst, Register src1, const Operand& src2);
380 void MulHighU32(Register dst, Register src1, const MemOperand& src2);
381 void MulHighU32(Register dst, Register src1, Register src2);
382 void MulHighU32(Register dst, Register src1, const Operand& src2);
383 void Mul32WithOverflowIfCCUnequal(Register dst, Register src1,
384 const MemOperand& src2);
385 void Mul32WithOverflowIfCCUnequal(Register dst, Register src1, Register src2);
386 void Mul32WithOverflowIfCCUnequal(Register dst, Register src1,
387 const Operand& src2);
388 // Divide
389 void DivS32(Register dst, Register src1, const MemOperand& src2);
390 void DivS32(Register dst, Register src1, Register src2);
391 void DivU32(Register dst, Register src1, const MemOperand& src2);
392 void DivU32(Register dst, Register src1, Register src2);
393 void DivS64(Register dst, Register src1, const MemOperand& src2);
394 void DivS64(Register dst, Register src1, Register src2);
395 void DivU64(Register dst, Register src1, const MemOperand& src2);
396 void DivU64(Register dst, Register src1, Register src2);
397
398 // Mod
399 void ModS32(Register dst, Register src1, const MemOperand& src2);
400 void ModS32(Register dst, Register src1, Register src2);
401 void ModU32(Register dst, Register src1, const MemOperand& src2);
402 void ModU32(Register dst, Register src1, Register src2);
403 void ModS64(Register dst, Register src1, const MemOperand& src2);
404 void ModS64(Register dst, Register src1, Register src2);
405 void ModU64(Register dst, Register src1, const MemOperand& src2);
406 void ModU64(Register dst, Register src1, Register src2);
407
408 // Square root
409 void Sqrt(DoubleRegister result, DoubleRegister input);
410 void Sqrt(DoubleRegister result, const MemOperand& input);
411
412 // Compare
413 void CmpS32(Register src1, Register src2);
414 void CmpS64(Register src1, Register src2);
415 void CmpS32(Register dst, const Operand& opnd);
416 void CmpS64(Register dst, const Operand& opnd);
417 void CmpS32(Register dst, const MemOperand& opnd);
418 void CmpS64(Register dst, const MemOperand& opnd);
419 void CmpAndSwap(Register old_val, Register new_val, const MemOperand& opnd);
420 void CmpAndSwap64(Register old_val, Register new_val, const MemOperand& opnd);
421 // TODO(john.yan): remove this
422 template <class T>
423 void CmpP(Register src1, T src2) {
424 CmpS64(src1, src2);
425 }
426
427 // Compare Logical
428 void CmpU32(Register src1, Register src2);
429 void CmpU64(Register src1, Register src2);
430 void CmpU32(Register src1, const Operand& opnd);
431 void CmpU64(Register src1, const Operand& opnd);
432 void CmpU32(Register dst, const MemOperand& opnd);
433 void CmpU64(Register dst, const MemOperand& opnd);
434
435 // Compare Floats
436 void CmpF32(DoubleRegister src1, DoubleRegister src2);
437 void CmpF64(DoubleRegister src1, DoubleRegister src2);
438 void CmpF32(DoubleRegister src1, const MemOperand& src2);
439 void CmpF64(DoubleRegister src1, const MemOperand& src2);
440
441 // Load
442 void LoadU64(Register dst, const MemOperand& mem, Register scratch = no_reg);
443 void LoadS32(Register dst, const MemOperand& opnd, Register scratch = no_reg);
444 void LoadS32(Register dst, Register src);
445 void LoadU32(Register dst, const MemOperand& opnd, Register scratch = no_reg);
446 void LoadU32(Register dst, Register src);
447 void LoadU16(Register dst, const MemOperand& opnd);
448 void LoadU16(Register dst, Register src);
449 void LoadS16(Register dst, Register src);
450 void LoadS16(Register dst, const MemOperand& mem, Register scratch = no_reg);
451 void LoadS8(Register dst, const MemOperand& opnd);
452 void LoadS8(Register dst, Register src);
453 void LoadU8(Register dst, const MemOperand& opnd);
454 void LoadU8(Register dst, Register src);
455 void LoadV128(Simd128Register dst, const MemOperand& mem, Register scratch);
456 void LoadF64(DoubleRegister dst, const MemOperand& opnd);
457 void LoadF32(DoubleRegister dst, const MemOperand& opnd);
458 // LE Load
459 void LoadU64LE(Register dst, const MemOperand& mem,
460 Register scratch = no_reg);
461 void LoadS32LE(Register dst, const MemOperand& opnd,
462 Register scratch = no_reg);
463 void LoadU32LE(Register dst, const MemOperand& opnd,
464 Register scratch = no_reg);
465 void LoadU16LE(Register dst, const MemOperand& opnd);
466 void LoadS16LE(Register dst, const MemOperand& opnd);
467 void LoadV128LE(DoubleRegister dst, const MemOperand& mem, Register scratch0,
468 Register scratch1);
469 void LoadF64LE(DoubleRegister dst, const MemOperand& opnd, Register scratch);
470 void LoadF32LE(DoubleRegister dst, const MemOperand& opnd, Register scratch);
471 // Vector LE Load and Transform instructions.
472 void LoadAndSplat64x2LE(Simd128Register dst, const MemOperand& mem,
473 Register scratch);
474 void LoadAndSplat32x4LE(Simd128Register dst, const MemOperand& mem,
475 Register scratch);
476 void LoadAndSplat16x8LE(Simd128Register dst, const MemOperand& me,
477 Register scratch);
478 void LoadAndSplat8x16LE(Simd128Register dst, const MemOperand& mem,
479 Register scratch);
480 void LoadAndExtend8x8ULE(Simd128Register dst, const MemOperand& mem,
481 Register scratch);
482 void LoadAndExtend8x8SLE(Simd128Register dst, const MemOperand& mem,
483 Register scratch);
484 void LoadAndExtend16x4ULE(Simd128Register dst, const MemOperand& mem,
485 Register scratch);
486 void LoadAndExtend16x4SLE(Simd128Register dst, const MemOperand& mem,
487 Register scratch);
488 void LoadAndExtend32x2ULE(Simd128Register dst, const MemOperand& mem,
489 Register scratch);
490 void LoadAndExtend32x2SLE(Simd128Register dst, const MemOperand& mem,
491 Register scratch);
492 void LoadV32ZeroLE(Simd128Register dst, const MemOperand& mem,
493 Register scratch);
494 void LoadV64ZeroLE(Simd128Register dst, const MemOperand& mem,
495 Register scratch);
496 void LoadLane8LE(Simd128Register dst, const MemOperand& mem, int lane,
497 Register scratch);
498 void LoadLane16LE(Simd128Register dst, const MemOperand& mem, int lane,
499 Register scratch);
500 void LoadLane32LE(Simd128Register dst, const MemOperand& mem, int lane,
501 Register scratch);
502 void LoadLane64LE(Simd128Register dst, const MemOperand& mem, int lane,
503 Register scratch);
504 void StoreLane8LE(Simd128Register src, const MemOperand& mem, int lane,
505 Register scratch);
506 void StoreLane16LE(Simd128Register src, const MemOperand& mem, int lane,
507 Register scratch);
508 void StoreLane32LE(Simd128Register src, const MemOperand& mem, int lane,
509 Register scratch);
510 void StoreLane64LE(Simd128Register src, const MemOperand& mem, int lane,
511 Register scratch);
512
513 // Load And Test
514 void LoadAndTest32(Register dst, Register src);
515 void LoadAndTestP(Register dst, Register src);
516
517 void LoadAndTest32(Register dst, const MemOperand& opnd);
518 void LoadAndTestP(Register dst, const MemOperand& opnd);
519
520 // Store
521 void StoreU64(const MemOperand& mem, const Operand& opnd,
522 Register scratch = no_reg);
523 void StoreU64(Register src, const MemOperand& mem, Register scratch = no_reg);
524 void StoreU32(Register src, const MemOperand& mem, Register scratch = no_reg);
525
526 void StoreU16(Register src, const MemOperand& mem, Register scratch = r0);
527 void StoreU8(Register src, const MemOperand& mem, Register scratch = r0);
528 void StoreF64(DoubleRegister dst, const MemOperand& opnd);
529 void StoreF32(DoubleRegister dst, const MemOperand& opnd);
530 void StoreV128(Simd128Register src, const MemOperand& mem, Register scratch);
531
532 // Store LE
533 void StoreU64LE(Register src, const MemOperand& mem,
534 Register scratch = no_reg);
535 void StoreU32LE(Register src, const MemOperand& mem,
536 Register scratch = no_reg);
537
538 void StoreU16LE(Register src, const MemOperand& mem, Register scratch = r0);
539 void StoreF64LE(DoubleRegister src, const MemOperand& opnd, Register scratch);
540 void StoreF32LE(DoubleRegister src, const MemOperand& opnd, Register scratch);
541 void StoreV128LE(Simd128Register src, const MemOperand& mem,
542 Register scratch1, Register scratch2);
543
544 void AddF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
545 void SubF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
546 void MulF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
547 void DivF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
548
549 void AddF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
550 void SubF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
551 void MulF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
552 void DivF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs);
553
554 void AddFloat32(DoubleRegister dst, const MemOperand& opnd,
555 DoubleRegister scratch);
556 void AddFloat64(DoubleRegister dst, const MemOperand& opnd,
557 DoubleRegister scratch);
558 void SubFloat32(DoubleRegister dst, const MemOperand& opnd,
559 DoubleRegister scratch);
560 void SubFloat64(DoubleRegister dst, const MemOperand& opnd,
561 DoubleRegister scratch);
562 void MulFloat32(DoubleRegister dst, const MemOperand& opnd,
563 DoubleRegister scratch);
564 void MulFloat64(DoubleRegister dst, const MemOperand& opnd,
565 DoubleRegister scratch);
566 void DivFloat32(DoubleRegister dst, const MemOperand& opnd,
567 DoubleRegister scratch);
568 void DivFloat64(DoubleRegister dst, const MemOperand& opnd,
569 DoubleRegister scratch);
570 void LoadF32AsF64(DoubleRegister dst, const MemOperand& opnd);
571
572 // Load On Condition
573 void LoadOnConditionP(Condition cond, Register dst, Register src);
574
575 void LoadPositiveP(Register result, Register input);
576 void LoadPositive32(Register result, Register input);
577
578 void Branch(Condition c, const Operand& opnd);
579 void BranchOnCount(Register r1, Label* l);
580
581 // Shifts
582 void ShiftLeftU32(Register dst, Register src, Register val,
583 const Operand& val2 = Operand::Zero());
584 void ShiftLeftU32(Register dst, Register src, const Operand& val);
585 void ShiftLeftU64(Register dst, Register src, Register val,
586 const Operand& val2 = Operand::Zero());
587 void ShiftLeftU64(Register dst, Register src, const Operand& val);
588 void ShiftRightU32(Register dst, Register src, Register val,
589 const Operand& val2 = Operand::Zero());
590 void ShiftRightU32(Register dst, Register src, const Operand& val);
591 void ShiftRightU64(Register dst, Register src, Register val,
592 const Operand& val2 = Operand::Zero());
593 void ShiftRightU64(Register dst, Register src, const Operand& val);
594 void ShiftRightS32(Register dst, Register src, Register shift,
595 const Operand& val2 = Operand::Zero());
596 void ShiftRightS32(Register dst, Register src, const Operand& val);
597 void ShiftRightS64(Register dst, Register src, Register shift,
598 const Operand& val2 = Operand::Zero());
599 void ShiftRightS64(Register dst, Register src, const Operand& val);
600
601 void ClearRightImm(Register dst, Register src, const Operand& val);
602
603 // Bitwise operations
604 void And(Register dst, Register src);
605 void AndP(Register dst, Register src);
606 void And(Register dst, Register src1, Register src2);
607 void AndP(Register dst, Register src1, Register src2);
608 void And(Register dst, const MemOperand& opnd);
609 void AndP(Register dst, const MemOperand& opnd);
610 void And(Register dst, const Operand& opnd);
611 void AndP(Register dst, const Operand& opnd);
612 void And(Register dst, Register src, const Operand& opnd);
613 void AndP(Register dst, Register src, const Operand& opnd);
614 void Or(Register dst, Register src);
615 void OrP(Register dst, Register src);
616 void Or(Register dst, Register src1, Register src2);
617 void OrP(Register dst, Register src1, Register src2);
618 void Or(Register dst, const MemOperand& opnd);
619 void OrP(Register dst, const MemOperand& opnd);
620 void Or(Register dst, const Operand& opnd);
621 void OrP(Register dst, const Operand& opnd);
622 void Or(Register dst, Register src, const Operand& opnd);
623 void OrP(Register dst, Register src, const Operand& opnd);
624 void Xor(Register dst, Register src);
625 void XorP(Register dst, Register src);
626 void Xor(Register dst, Register src1, Register src2);
627 void XorP(Register dst, Register src1, Register src2);
628 void Xor(Register dst, const MemOperand& opnd);
629 void XorP(Register dst, const MemOperand& opnd);
630 void Xor(Register dst, const Operand& opnd);
631 void XorP(Register dst, const Operand& opnd);
632 void Xor(Register dst, Register src, const Operand& opnd);
633 void XorP(Register dst, Register src, const Operand& opnd);
634 void Popcnt32(Register dst, Register src);
635 void Not32(Register dst, Register src = no_reg);
636 void Not64(Register dst, Register src = no_reg);
637 void NotP(Register dst, Register src = no_reg);
638
639 void Popcnt64(Register dst, Register src);
640
641 void mov(Register dst, const Operand& src);
642 void mov(Register dst, Register src);
643
644 void push(DoubleRegister src) {
645 lay(sp, MemOperand(sp, -kSystemPointerSize));
646 StoreF64(src, MemOperand(sp));
647 }
648
649 void push(Register src) {
650 lay(sp, MemOperand(sp, -kSystemPointerSize));
651 StoreU64(src, MemOperand(sp));
652 }
653
654 void pop(DoubleRegister dst) {
655 LoadF64(dst, MemOperand(sp));
656 la(sp, MemOperand(sp, kSystemPointerSize));
657 }
658
659 void pop(Register dst) {
660 LoadU64(dst, MemOperand(sp));
661 la(sp, MemOperand(sp, kSystemPointerSize));
662 }
663
664 void pop() { la(sp, MemOperand(sp, kSystemPointerSize)); }
665
666 void Push(Register src) { push(src); }
667
668 // Push a handle.
669 void Push(Handle<HeapObject> handle);
670 void Push(Tagged<Smi> smi);
671 void Push(Tagged<TaggedIndex> index);
672
673 // Push two registers. Pushes leftmost register first (to highest address).
674 void Push(Register src1, Register src2) {
675 lay(sp, MemOperand(sp, -kSystemPointerSize * 2));
676 StoreU64(src1, MemOperand(sp, kSystemPointerSize));
677 StoreU64(src2, MemOperand(sp, 0));
678 }
679
680 // Push three registers. Pushes leftmost register first (to highest address).
681 void Push(Register src1, Register src2, Register src3) {
682 lay(sp, MemOperand(sp, -kSystemPointerSize * 3));
683 StoreU64(src1, MemOperand(sp, kSystemPointerSize * 2));
684 StoreU64(src2, MemOperand(sp, kSystemPointerSize));
685 StoreU64(src3, MemOperand(sp, 0));
686 }
687
688 // Push four registers. Pushes leftmost register first (to highest address).
689 void Push(Register src1, Register src2, Register src3, Register src4) {
690 lay(sp, MemOperand(sp, -kSystemPointerSize * 4));
691 StoreU64(src1, MemOperand(sp, kSystemPointerSize * 3));
692 StoreU64(src2, MemOperand(sp, kSystemPointerSize * 2));
693 StoreU64(src3, MemOperand(sp, kSystemPointerSize));
694 StoreU64(src4, MemOperand(sp, 0));
695 }
696
697 // Push five registers. Pushes leftmost register first (to highest address).
698 void Push(Register src1, Register src2, Register src3, Register src4,
699 Register src5) {
700 DCHECK(src1 != src2);
701 DCHECK(src1 != src3);
702 DCHECK(src2 != src3);
703 DCHECK(src1 != src4);
704 DCHECK(src2 != src4);
705 DCHECK(src3 != src4);
706 DCHECK(src1 != src5);
707 DCHECK(src2 != src5);
708 DCHECK(src3 != src5);
709 DCHECK(src4 != src5);
710
711 lay(sp, MemOperand(sp, -kSystemPointerSize * 5));
712 StoreU64(src1, MemOperand(sp, kSystemPointerSize * 4));
713 StoreU64(src2, MemOperand(sp, kSystemPointerSize * 3));
714 StoreU64(src3, MemOperand(sp, kSystemPointerSize * 2));
715 StoreU64(src4, MemOperand(sp, kSystemPointerSize));
716 StoreU64(src5, MemOperand(sp, 0));
717 }
718
719 enum PushArrayOrder { kNormal, kReverse };
720 void PushArray(Register array, Register size, Register scratch,
721 Register scratch2, PushArrayOrder order = kNormal);
722
723 void Pop(Register dst) { pop(dst); }
724
725 // Pop two registers. Pops rightmost register first (from lower address).
726 void Pop(Register src1, Register src2) {
727 LoadU64(src2, MemOperand(sp, 0));
728 LoadU64(src1, MemOperand(sp, kSystemPointerSize));
729 la(sp, MemOperand(sp, 2 * kSystemPointerSize));
730 }
731
732 // Pop three registers. Pops rightmost register first (from lower address).
733 void Pop(Register src1, Register src2, Register src3) {
734 LoadU64(src3, MemOperand(sp, 0));
735 LoadU64(src2, MemOperand(sp, kSystemPointerSize));
736 LoadU64(src1, MemOperand(sp, 2 * kSystemPointerSize));
737 la(sp, MemOperand(sp, 3 * kSystemPointerSize));
738 }
739
740 // Pop four registers. Pops rightmost register first (from lower address).
741 void Pop(Register src1, Register src2, Register src3, Register src4) {
742 LoadU64(src4, MemOperand(sp, 0));
743 LoadU64(src3, MemOperand(sp, kSystemPointerSize));
744 LoadU64(src2, MemOperand(sp, 2 * kSystemPointerSize));
745 LoadU64(src1, MemOperand(sp, 3 * kSystemPointerSize));
746 la(sp, MemOperand(sp, 4 * kSystemPointerSize));
747 }
748
749 // Pop five registers. Pops rightmost register first (from lower address).
750 void Pop(Register src1, Register src2, Register src3, Register src4,
751 Register src5) {
752 LoadU64(src5, MemOperand(sp, 0));
753 LoadU64(src4, MemOperand(sp, kSystemPointerSize));
754 LoadU64(src3, MemOperand(sp, 2 * kSystemPointerSize));
755 LoadU64(src2, MemOperand(sp, 3 * kSystemPointerSize));
756 LoadU64(src1, MemOperand(sp, 4 * kSystemPointerSize));
757 la(sp, MemOperand(sp, 5 * kSystemPointerSize));
758 }
759
760 // Push a fixed frame, consisting of lr, fp, constant pool.
761 void PushCommonFrame(Register marker_reg = no_reg);
762
763 // Push a standard frame, consisting of lr, fp, constant pool,
764 // context and JS function
765 void PushStandardFrame(Register function_reg);
766
767 void PopCommonFrame(Register marker_reg = no_reg);
768
769 // Restore caller's frame pointer and return address prior to being
770 // overwritten by tail call stack preparation.
771 void RestoreFrameStateForTailCall();
772
773 void InitializeRootRegister() {
774 ExternalReference isolate_root = ExternalReference::isolate_root(isolate());
775 mov(kRootRegister, Operand(isolate_root));
776#ifdef V8_COMPRESS_POINTERS_IN_SHARED_CAGE
777 LoadRootRelative(kPtrComprCageBaseRegister,
778 IsolateData::cage_base_offset());
779#endif
780 }
781
782 // If the value is a NaN, canonicalize the value else, do nothing.
783 void CanonicalizeNaN(const DoubleRegister dst, const DoubleRegister src);
784 void CanonicalizeNaN(const DoubleRegister value) {
785 CanonicalizeNaN(value, value);
786 }
787
788 // Converts the integer (untagged smi) in |src| to a double, storing
789 // the result to |dst|
790 void ConvertIntToDouble(DoubleRegister dst, Register src);
791
792 // Converts the unsigned integer (untagged smi) in |src| to
793 // a double, storing the result to |dst|
794 void ConvertUnsignedIntToDouble(DoubleRegister dst, Register src);
795
796 // Converts the integer (untagged smi) in |src| to
797 // a float, storing the result in |dst|
798 void ConvertIntToFloat(DoubleRegister dst, Register src);
799
800 // Converts the unsigned integer (untagged smi) in |src| to
801 // a float, storing the result in |dst|
802 void ConvertUnsignedIntToFloat(DoubleRegister dst, Register src);
803
804 void ConvertInt64ToFloat(DoubleRegister double_dst, Register src);
805 void ConvertInt64ToDouble(DoubleRegister double_dst, Register src);
806 void ConvertUnsignedInt64ToFloat(DoubleRegister double_dst, Register src);
807 void ConvertUnsignedInt64ToDouble(DoubleRegister double_dst, Register src);
808
809 void MovIntToFloat(DoubleRegister dst, Register src);
810 void MovFloatToInt(Register dst, DoubleRegister src);
811 void MovDoubleToInt64(Register dst, DoubleRegister src);
812 void MovInt64ToDouble(DoubleRegister dst, Register src);
813 // Converts the double_input to an integer. Note that, upon return,
814 // the contents of double_dst will also hold the fixed point representation.
815 void ConvertFloat32ToInt64(const Register dst,
816 const DoubleRegister double_input,
817 FPRoundingMode rounding_mode = kRoundToZero);
818
819 // Converts the double_input to an integer. Note that, upon return,
820 // the contents of double_dst will also hold the fixed point representation.
821 void ConvertDoubleToInt64(const Register dst,
822 const DoubleRegister double_input,
823 FPRoundingMode rounding_mode = kRoundToZero);
824 void ConvertDoubleToInt32(const Register dst,
825 const DoubleRegister double_input,
826 FPRoundingMode rounding_mode = kRoundToZero);
827
828 void ConvertFloat32ToInt32(const Register result,
829 const DoubleRegister double_input,
830 FPRoundingMode rounding_mode);
831 void ConvertFloat32ToUnsignedInt32(
832 const Register result, const DoubleRegister double_input,
833 FPRoundingMode rounding_mode = kRoundToZero);
834 // Converts the double_input to an unsigned integer. Note that, upon return,
835 // the contents of double_dst will also hold the fixed point representation.
836 void ConvertDoubleToUnsignedInt64(
837 const Register dst, const DoubleRegister double_input,
838 FPRoundingMode rounding_mode = kRoundToZero);
839 void ConvertDoubleToUnsignedInt32(
840 const Register dst, const DoubleRegister double_input,
841 FPRoundingMode rounding_mode = kRoundToZero);
842 void ConvertFloat32ToUnsignedInt64(
843 const Register result, const DoubleRegister double_input,
844 FPRoundingMode rounding_mode = kRoundToZero);
845
846 // Generates function and stub prologue code.
847 void StubPrologue(StackFrame::Type type, Register base = no_reg,
848 int prologue_offset = 0);
849 void Prologue(Register base, int prologue_offset = 0);
850
851 void DropArguments(Register count);
852 void DropArgumentsAndPushNewReceiver(Register argc, Register receiver);
853
854 // Get the actual activation frame alignment for target environment.
855 static int ActivationFrameAlignment();
856 // ----------------------------------------------------------------
857 // new S390 macro-assembler interfaces that are slightly higher level
858 // than assembler-s390 and may generate variable length sequences
859
860 // load an SMI value <value> to GPR <dst>
861 void LoadSmiLiteral(Register dst, Tagged<Smi> smi);
862
863 // load a literal double value <value> to FPR <result>
864 template <class T>
865 void LoadF64(DoubleRegister result, T value, Register scratch) {
866 static_assert(sizeof(T) == kDoubleSize, "Expect input size to be 8");
867 uint64_t int_val = base::bit_cast<uint64_t, T>(value);
868 // Load the 64-bit value into a GPR, then transfer it to FPR via LDGR
869 uint32_t hi_32 = int_val >> 32;
870 uint32_t lo_32 = static_cast<uint32_t>(int_val);
871
872 if (int_val == 0) {
873 lzdr(result);
874 } else if (lo_32 == 0) {
875 llihf(scratch, Operand(hi_32));
876 ldgr(result, scratch);
877 } else {
878 iihf(scratch, Operand(hi_32));
879 iilf(scratch, Operand(lo_32));
880 ldgr(result, scratch);
881 }
882 }
883
884 template <class T>
885 void LoadF32(DoubleRegister result, T value, Register scratch) {
886 static_assert(sizeof(T) == kFloatSize, "Expect input size to be 4");
887 uint32_t int_val = base::bit_cast<uint32_t, T>(value);
888 LoadF64(result, static_cast<uint64_t>(int_val) << 32, scratch);
889 }
890
891 void CmpSmiLiteral(Register src1, Tagged<Smi> smi, Register scratch);
892
893 // Set new rounding mode RN to FPSCR
894 void SetRoundingMode(FPRoundingMode RN);
895
896 // reset rounding mode to default (kRoundToNearest)
897 void ResetRoundingMode();
898
899 // These exist to provide portability between 32 and 64bit
900 void LoadMultipleP(Register dst1, Register dst2, const MemOperand& mem);
901 void StoreMultipleP(Register dst1, Register dst2, const MemOperand& mem);
902 void LoadMultipleW(Register dst1, Register dst2, const MemOperand& mem);
903 void StoreMultipleW(Register dst1, Register dst2, const MemOperand& mem);
904
905 void SwapP(Register src, Register dst, Register scratch);
906 void SwapP(Register src, MemOperand dst, Register scratch);
907 void SwapP(MemOperand src, MemOperand dst, Register scratch_0,
908 Register scratch_1);
909 void SwapFloat32(DoubleRegister src, DoubleRegister dst,
910 DoubleRegister scratch);
911 void SwapFloat32(DoubleRegister src, MemOperand dst, DoubleRegister scratch);
912 void SwapFloat32(MemOperand src, MemOperand dst, DoubleRegister scratch);
913 void SwapDouble(DoubleRegister src, DoubleRegister dst,
914 DoubleRegister scratch);
915 void SwapDouble(DoubleRegister src, MemOperand dst, DoubleRegister scratch);
916 void SwapDouble(MemOperand src, MemOperand dst, DoubleRegister scratch);
917 void SwapSimd128(Simd128Register src, Simd128Register dst,
918 Simd128Register scratch);
919 void SwapSimd128(Simd128Register src, MemOperand dst,
920 Simd128Register scratch);
921 void SwapSimd128(MemOperand src, MemOperand dst, Simd128Register scratch);
922
923 // ---------------------------------------------------------------------------
924 // Runtime calls
925
926 // Before calling a C-function from generated code, align arguments on stack.
927 // After aligning the frame, non-register arguments must be stored in
928 // sp[0], sp[4], etc., not pushed. The argument count assumes all arguments
929 // are word sized. If double arguments are used, this function assumes that
930 // all double arguments are stored before core registers; otherwise the
931 // correct alignment of the double values is not guaranteed.
932 // Some compilers/platforms require the stack to be aligned when calling
933 // C++ code.
934 // Needs a scratch register to do some arithmetic. This register will be
935 // trashed.
936 void PrepareCallCFunction(int num_reg_arguments, int num_double_registers,
937 Register scratch);
938 void PrepareCallCFunction(int num_reg_arguments, Register scratch);
939
940 // There are two ways of passing double arguments on ARM, depending on
941 // whether soft or hard floating point ABI is used. These functions
942 // abstract parameter passing for the three different ways we call
943 // C functions from generated code.
944 void MovToFloatParameter(DoubleRegister src);
945 void MovToFloatParameters(DoubleRegister src1, DoubleRegister src2);
946 void MovToFloatResult(DoubleRegister src);
947
948 // Calls a C function and cleans up the space for arguments allocated
949 // by PrepareCallCFunction. The called function is not allowed to trigger a
950 // garbage collection, since that might move the code and invalidate the
951 // return address (unless this is somehow accounted for by the called
952 // function).
953 int CallCFunction(
954 ExternalReference function, int num_arguments,
955 SetIsolateDataSlots set_isolate_data_slots = SetIsolateDataSlots::kYes,
956 bool has_function_descriptor = ABI_USES_FUNCTION_DESCRIPTORS,
957 Label* return_label = nullptr);
958 int CallCFunction(
959 Register function, int num_arguments,
960 SetIsolateDataSlots set_isolate_data_slots = SetIsolateDataSlots::kYes,
961 bool has_function_descriptor = ABI_USES_FUNCTION_DESCRIPTORS,
962 Label* return_label = nullptr);
963 int CallCFunction(
964 ExternalReference function, int num_reg_arguments,
965 int num_double_arguments,
966 SetIsolateDataSlots set_isolate_data_slots = SetIsolateDataSlots::kYes,
967 bool has_function_descriptor = ABI_USES_FUNCTION_DESCRIPTORS,
968 Label* return_label = nullptr);
969 int CallCFunction(
970 Register function, int num_reg_arguments, int num_double_arguments,
971 SetIsolateDataSlots set_isolate_data_slots = SetIsolateDataSlots::kYes,
972 bool has_function_descriptor = ABI_USES_FUNCTION_DESCRIPTORS,
973 Label* return_label = nullptr);
974
975 void MovFromFloatParameter(DoubleRegister dst);
976 void MovFromFloatResult(DoubleRegister dst);
977
978 void Trap();
979 void DebugBreak();
980
981 // Emit code for a truncating division by a constant. The dividend register is
982 // unchanged and ip gets clobbered. Dividend and result must be different.
983 void TruncateDoubleToI(Isolate* isolate, Zone* zone, Register result,
984 DoubleRegister double_input, StubCallMode stub_mode);
985 void TryInlineTruncateDoubleToI(Register result, DoubleRegister double_input,
986 Label* done);
987
988 // ---------------------------------------------------------------------------
989 // Debugging
990
991 // Calls Abort(msg) if the condition cond is not satisfied.
992 // Use --debug_code to enable.
993 void Assert(Condition cond, AbortReason reason,
994 CRegister cr = cr7) NOOP_UNLESS_DEBUG_CODE;
995
996 // Like Assert(), but without condition.
997 // Use --debug-code to enable.
998 void AssertUnreachable(AbortReason reason) NOOP_UNLESS_DEBUG_CODE;
999 void AssertZeroExtended(Register reg) NOOP_UNLESS_DEBUG_CODE;
1000
1001 // Like Assert(), but always enabled.
1002 void Check(Condition cond, AbortReason reason, CRegister cr = cr7);
1003
1004 // Print a message to stdout and abort execution.
1005 void Abort(AbortReason reason);
1006
1007 // ---------------------------------------------------------------------------
1008 // Bit testing/extraction
1009 //
1010 // Bit numbering is such that the least significant bit is bit 0
1011 // (for consistency between 32/64-bit).
1012
1013 // Extract consecutive bits (defined by rangeStart - rangeEnd) from src
1014 // and place them into the least significant bits of dst.
1015 inline void ExtractBitRange(Register dst, Register src, int rangeStart,
1016 int rangeEnd) {
1017 DCHECK(rangeStart >= rangeEnd && rangeStart < kBitsPerSystemPointer);
1018
1019 // Try to use RISBG if possible.
1020 if (CpuFeatures::IsSupported(GENERAL_INSTR_EXT)) {
1021 int shiftAmount = (64 - rangeEnd) % 64; // Convert to shift left.
1022 int endBit = 63; // End is always LSB after shifting.
1023 int startBit = 63 - rangeStart + rangeEnd;
1024 RotateInsertSelectBits(dst, src, Operand(startBit), Operand(endBit),
1025 Operand(shiftAmount), true);
1026 } else {
1027 if (rangeEnd > 0) // Don't need to shift if rangeEnd is zero.
1028 ShiftRightU64(dst, src, Operand(rangeEnd));
1029 else if (dst != src) // If we didn't shift, we might need to copy
1030 mov(dst, src);
1031 int width = rangeStart - rangeEnd + 1;
1032 uint64_t mask = (static_cast<uint64_t>(1) << width) - 1;
1033 nihf(dst, Operand(mask >> 32));
1034 nilf(dst, Operand(mask & 0xFFFFFFFF));
1035 ltgr(dst, dst);
1036 }
1037 }
1038
1039 inline void ExtractBit(Register dst, Register src, uint32_t bitNumber) {
1040 ExtractBitRange(dst, src, bitNumber, bitNumber);
1041 }
1042
1043 // Extract consecutive bits (defined by mask) from src and place them
1044 // into the least significant bits of dst.
1045 inline void ExtractBitMask(Register dst, Register src, uintptr_t mask,
1046 RCBit rc = LeaveRC) {
1047 int start = kBitsPerSystemPointer - 1;
1048 int end;
1049 uintptr_t bit = (1L << start);
1050
1051 while (bit && (mask & bit) == 0) {
1052 start--;
1053 bit >>= 1;
1054 }
1055 end = start;
1056 bit >>= 1;
1057
1058 while (bit && (mask & bit)) {
1059 end--;
1060 bit >>= 1;
1061 }
1062
1063 // 1-bits in mask must be contiguous
1064 DCHECK(bit == 0 || (mask & ((bit << 1) - 1)) == 0);
1065
1066 ExtractBitRange(dst, src, start, end);
1067 }
1068
1069 // Test single bit in value.
1070 inline void TestBit(Register value, int bitNumber, Register scratch = r0) {
1071 ExtractBitRange(scratch, value, bitNumber, bitNumber);
1072 }
1073
1074 // Test consecutive bit range in value. Range is defined by
1075 // rangeStart - rangeEnd.
1076 inline void TestBitRange(Register value, int rangeStart, int rangeEnd,
1077 Register scratch = r0) {
1078 ExtractBitRange(scratch, value, rangeStart, rangeEnd);
1079 }
1080
1081 // Test consecutive bit range in value. Range is defined by mask.
1082 inline void TestBitMask(Register value, uintptr_t mask,
1083 Register scratch = r0) {
1084 ExtractBitMask(scratch, value, mask, SetRC);
1085 }
1086 inline void TestIfSmi(Register value) { tmll(value, Operand(1)); }
1087
1088 inline void TestIfSmi(MemOperand value) {
1089 if (is_uint12(value.offset())) {
1090 tm(value, Operand(1));
1091 } else if (is_int20(value.offset())) {
1092 tmy(value, Operand(1));
1093 } else {
1094 LoadS8(r0, value);
1095 tmll(r0, Operand(1));
1096 }
1097 }
1098
1099 inline void TestIfInt32(Register value) {
1100 // High bits must be identical to fit into an 32-bit integer
1101 cgfr(value, value);
1102 }
1103 void SmiUntag(Register reg) { SmiUntag(reg, reg); }
1104
1105 void SmiUntag(Register dst, const MemOperand& src);
1106 void SmiUntag(Register dst, Register src) {
1107 if (SmiValuesAre31Bits()) {
1108 ShiftRightS32(dst, src, Operand(kSmiShift));
1109 } else {
1110 ShiftRightS64(dst, src, Operand(kSmiShift));
1111 }
1112 lgfr(dst, dst);
1113 }
1114 void SmiToInt32(Register smi) {
1115 if (v8_flags.enable_slow_asserts) {
1116 AssertSmi(smi);
1117 }
1118 DCHECK(SmiValuesAre32Bits() || SmiValuesAre31Bits());
1119 SmiUntag(smi);
1120 }
1121 void SmiToInt32(Register dst, Register src) {
1122 DCHECK(SmiValuesAre32Bits() || SmiValuesAre31Bits());
1123 mov(dst, src);
1124 SmiUntag(dst);
1125 }
1126
1127 // Shift left by kSmiShift
1128 void SmiTag(Register reg) { SmiTag(reg, reg); }
1129 void SmiTag(Register dst, Register src) {
1130 ShiftLeftU64(dst, src, Operand(kSmiShift));
1131 }
1132
1133 // Abort execution if argument is a smi, enabled via --debug-code.
1134 void AssertNotSmi(Register object) NOOP_UNLESS_DEBUG_CODE;
1135 void AssertSmi(Register object) NOOP_UNLESS_DEBUG_CODE;
1136
1137 // Abort execution if argument is not a Map, enabled via
1138 // --debug-code.
1139 void AssertMap(Register object) NOOP_UNLESS_DEBUG_CODE;
1140
1141 // Activation support.
1142 void EnterFrame(StackFrame::Type type,
1143 bool load_constant_pool_pointer_reg = false);
1144 // Returns the pc offset at which the frame ends.
1145 int LeaveFrame(StackFrame::Type type, int stack_adjustment = 0);
1146
1147 void AllocateStackSpace(int bytes) {
1148 DCHECK_GE(bytes, 0);
1149 if (bytes == 0) return;
1150 lay(sp, MemOperand(sp, -bytes));
1151 }
1152
1153 void AllocateStackSpace(Register bytes) { SubS64(sp, sp, bytes); }
1154
1155 void CheckPageFlag(Register object, Register scratch, int mask, Condition cc,
1156 Label* condition_met);
1157
1158 void ComputeCodeStartAddress(Register dst);
1159 void LoadPC(Register dst);
1160
1161 // Enforce platform specific stack alignment.
1162 void EnforceStackAlignment();
1163
1164 // Control-flow integrity:
1165
1166 // Define a function entrypoint. This doesn't emit any code for this
1167 // architecture, as control-flow integrity is not supported for it.
1168 void CodeEntry() {}
1169 // Define an exception handler.
1170 void ExceptionHandler() {}
1171 // Define an exception handler and bind a label.
1172 void BindExceptionHandler(Label* label) { bind(label); }
1173
1174 // Convenience functions to call/jmp to the code of a JSFunction object.
1175 void CallJSFunction(Register function_object, uint16_t argument_count);
1176 void JumpJSFunction(Register function_object,
1177 JumpMode jump_mode = JumpMode::kJump);
1178#ifdef V8_ENABLE_LEAPTIERING
1179 void CallJSDispatchEntry(JSDispatchHandle dispatch_handle,
1180 uint16_t argument_count);
1181#endif
1182#ifdef V8_ENABLE_WEBASSEMBLY
1183 void ResolveWasmCodePointer(Register target);
1184 void CallWasmCodePointer(Register target,
1185 CallJumpMode call_jump_mode = CallJumpMode::kCall);
1186 void LoadWasmCodePointer(Register dst, MemOperand src);
1187#endif
1188
1189 // Generates an instruction sequence s.t. the return address points to the
1190 // instruction following the call.
1191 // The return address on the stack is used by frame iteration.
1192 void StoreReturnAddressAndCall(Register target);
1193#if V8_OS_ZOS
1194 void zosStoreReturnAddressAndCall(Register target, Register scratch);
1195#endif
1196
1197 // ---------------------------------------------------------------------------
1198 // Simd Support.
1199 void F64x2Splat(Simd128Register dst, Simd128Register src);
1200 void F32x4Splat(Simd128Register dst, Simd128Register src);
1201 void I64x2Splat(Simd128Register dst, Register src);
1202 void I32x4Splat(Simd128Register dst, Register src);
1203 void I16x8Splat(Simd128Register dst, Register src);
1204 void I8x16Splat(Simd128Register dst, Register src);
1205 void F64x2ExtractLane(DoubleRegister dst, Simd128Register src,
1206 uint8_t imm_lane_idx, Register = r0);
1207 void F32x4ExtractLane(DoubleRegister dst, Simd128Register src,
1208 uint8_t imm_lane_idx, Register = r0);
1209 void I64x2ExtractLane(Register dst, Simd128Register src, uint8_t imm_lane_idx,
1210 Register = r0);
1211 void I32x4ExtractLane(Register dst, Simd128Register src, uint8_t imm_lane_idx,
1212 Register = r0);
1213 void I16x8ExtractLaneU(Register dst, Simd128Register src,
1214 uint8_t imm_lane_idx, Register = r0);
1215 void I16x8ExtractLaneS(Register dst, Simd128Register src,
1216 uint8_t imm_lane_idx, Register scratch);
1217 void I8x16ExtractLaneU(Register dst, Simd128Register src,
1218 uint8_t imm_lane_idx, Register = r0);
1219 void I8x16ExtractLaneS(Register dst, Simd128Register src,
1220 uint8_t imm_lane_idx, Register scratch);
1221 void F64x2ReplaceLane(Simd128Register dst, Simd128Register src1,
1222 DoubleRegister src2, uint8_t imm_lane_idx,
1223 Register scratch);
1224 void F32x4ReplaceLane(Simd128Register dst, Simd128Register src1,
1225 DoubleRegister src2, uint8_t imm_lane_idx,
1226 Register scratch);
1227 void I64x2ReplaceLane(Simd128Register dst, Simd128Register src1,
1228 Register src2, uint8_t imm_lane_idx, Register = r0);
1229 void I32x4ReplaceLane(Simd128Register dst, Simd128Register src1,
1230 Register src2, uint8_t imm_lane_idx, Register = r0);
1231 void I16x8ReplaceLane(Simd128Register dst, Simd128Register src1,
1232 Register src2, uint8_t imm_lane_idx, Register = r0);
1233 void I8x16ReplaceLane(Simd128Register dst, Simd128Register src1,
1234 Register src2, uint8_t imm_lane_idx, Register = r0);
1235 void I64x2Mul(Simd128Register dst, Simd128Register src1, Simd128Register src2,
1236 Register scratch1, Register scratch2, Register scratch3);
1237 void I32x4GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2,
1238 Simd128Register scratch);
1239 void I16x8GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2,
1240 Simd128Register scratch);
1241 void I8x16GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2,
1242 Simd128Register scratch);
1243 void I64x2BitMask(Register dst, Simd128Register src, Register scratch1,
1244 Simd128Register scratch2);
1245 void I32x4BitMask(Register dst, Simd128Register src, Register scratch1,
1246 Simd128Register scratch2);
1247 void I16x8BitMask(Register dst, Simd128Register src, Register scratch1,
1248 Simd128Register scratch2);
1249 void I8x16BitMask(Register dst, Simd128Register src, Register scratch1,
1250 Register scratch2, Simd128Register scratch3);
1251 void V128AnyTrue(Register dst, Simd128Register src, Register scratch);
1252 void I32x4SConvertF32x4(Simd128Register dst, Simd128Register src,
1253 Simd128Register scratch1, Register scratch2);
1254 void I32x4UConvertF32x4(Simd128Register dst, Simd128Register src,
1255 Simd128Register scratch1, Register scratch2);
1256 void F32x4SConvertI32x4(Simd128Register dst, Simd128Register src,
1257 Simd128Register scratch1, Register scratch2);
1258 void F32x4UConvertI32x4(Simd128Register dst, Simd128Register src,
1259 Simd128Register scratch1, Register scratch2);
1260 void I16x8SConvertI32x4(Simd128Register dst, Simd128Register src1,
1261 Simd128Register src2);
1262 void I8x16SConvertI16x8(Simd128Register dst, Simd128Register src1,
1263 Simd128Register src2);
1264 void I16x8UConvertI32x4(Simd128Register dst, Simd128Register src1,
1265 Simd128Register src2, Simd128Register scratch);
1266 void I8x16UConvertI16x8(Simd128Register dst, Simd128Register src1,
1267 Simd128Register src2, Simd128Register scratch);
1268 void F64x2PromoteLowF32x4(Simd128Register dst, Simd128Register src,
1269 Simd128Register scratch1, Register scratch2,
1270 Register scratch3, Register scratch4);
1271 void F32x4DemoteF64x2Zero(Simd128Register dst, Simd128Register src,
1272 Simd128Register scratch1, Register scratch2,
1273 Register scratch3, Register scratch4);
1274 void I32x4TruncSatF64x2SZero(Simd128Register dst, Simd128Register src,
1275 Simd128Register scratch);
1276 void I32x4TruncSatF64x2UZero(Simd128Register dst, Simd128Register src,
1277 Simd128Register scratch);
1278 void I8x16Swizzle(Simd128Register dst, Simd128Register src1,
1279 Simd128Register src2, Register scratch1, Register scratch2,
1280 Simd128Register scratch3);
1281 void S128Const(Simd128Register dst, uint64_t high, uint64_t low,
1282 Register scratch1, Register scratch2);
1283 void I8x16Shuffle(Simd128Register dst, Simd128Register src1,
1284 Simd128Register src2, uint64_t high, uint64_t low,
1285 Register scratch1, Register scratch2,
1286 Simd128Register scratch3);
1287 void I32x4DotI16x8S(Simd128Register dst, Simd128Register src1,
1288 Simd128Register src2, Simd128Register scratch);
1289 void I16x8DotI8x16S(Simd128Register dst, Simd128Register src1,
1290 Simd128Register src2, Simd128Register scratch);
1291 void I32x4DotI8x16AddS(Simd128Register dst, Simd128Register src1,
1292 Simd128Register src2, Simd128Register src3,
1293 Simd128Register scratch1, Simd128Register scratch2);
1294 void I16x8Q15MulRSatS(Simd128Register dst, Simd128Register src1,
1295 Simd128Register src2, Simd128Register scratch1,
1296 Simd128Register scratch2, Simd128Register scratch3);
1297 void S128Select(Simd128Register dst, Simd128Register src1,
1298 Simd128Register src2, Simd128Register mask);
1299
1300#define SIMD_SHIFT_LIST(V) \
1301 V(I64x2Shl) \
1302 V(I64x2ShrS) \
1303 V(I64x2ShrU) \
1304 V(I32x4Shl) \
1305 V(I32x4ShrS) \
1306 V(I32x4ShrU) \
1307 V(I16x8Shl) \
1308 V(I16x8ShrS) \
1309 V(I16x8ShrU) \
1310 V(I8x16Shl) \
1311 V(I8x16ShrS) \
1312 V(I8x16ShrU)
1313
1314#define PROTOTYPE_SIMD_SHIFT(name) \
1315 void name(Simd128Register dst, Simd128Register src1, Register src2, \
1316 Simd128Register scratch); \
1317 void name(Simd128Register dst, Simd128Register src1, const Operand& src2, \
1318 Register scratch1, Simd128Register scratch2);
1319 SIMD_SHIFT_LIST(PROTOTYPE_SIMD_SHIFT)
1320#undef PROTOTYPE_SIMD_SHIFT
1321#undef SIMD_SHIFT_LIST
1322
1323#define SIMD_UNOP_LIST(V) \
1324 V(F64x2Abs) \
1325 V(F64x2Neg) \
1326 V(F64x2Sqrt) \
1327 V(F64x2Ceil) \
1328 V(F64x2Floor) \
1329 V(F64x2Trunc) \
1330 V(F64x2NearestInt) \
1331 V(F64x2ConvertLowI32x4S) \
1332 V(F64x2ConvertLowI32x4U) \
1333 V(F32x4Abs) \
1334 V(F32x4Neg) \
1335 V(F32x4Sqrt) \
1336 V(F32x4Ceil) \
1337 V(F32x4Floor) \
1338 V(F32x4Trunc) \
1339 V(F32x4NearestInt) \
1340 V(I64x2Abs) \
1341 V(I64x2SConvertI32x4Low) \
1342 V(I64x2SConvertI32x4High) \
1343 V(I64x2UConvertI32x4Low) \
1344 V(I64x2UConvertI32x4High) \
1345 V(I64x2Neg) \
1346 V(I32x4Abs) \
1347 V(I32x4Neg) \
1348 V(I32x4SConvertI16x8Low) \
1349 V(I32x4SConvertI16x8High) \
1350 V(I32x4UConvertI16x8Low) \
1351 V(I32x4UConvertI16x8High) \
1352 V(I16x8Abs) \
1353 V(I16x8Neg) \
1354 V(I16x8SConvertI8x16Low) \
1355 V(I16x8SConvertI8x16High) \
1356 V(I16x8UConvertI8x16Low) \
1357 V(I16x8UConvertI8x16High) \
1358 V(I8x16Abs) \
1359 V(I8x16Neg) \
1360 V(I8x16Popcnt) \
1361 V(S128Not) \
1362 V(S128Zero) \
1363 V(S128AllOnes)
1364
1365#define PROTOTYPE_SIMD_UNOP(name) \
1366 void name(Simd128Register dst, Simd128Register src);
1367 SIMD_UNOP_LIST(PROTOTYPE_SIMD_UNOP)
1368#undef PROTOTYPE_SIMD_UNOP
1369#undef SIMD_UNOP_LIST
1370
1371#define SIMD_BINOP_LIST(V) \
1372 V(F64x2Add) \
1373 V(F64x2Sub) \
1374 V(F64x2Mul) \
1375 V(F64x2Div) \
1376 V(F64x2Min) \
1377 V(F64x2Max) \
1378 V(F64x2Eq) \
1379 V(F64x2Ne) \
1380 V(F64x2Lt) \
1381 V(F64x2Le) \
1382 V(F64x2Pmin) \
1383 V(F64x2Pmax) \
1384 V(F32x4Add) \
1385 V(F32x4Sub) \
1386 V(F32x4Mul) \
1387 V(F32x4Div) \
1388 V(F32x4Min) \
1389 V(F32x4Max) \
1390 V(F32x4Eq) \
1391 V(F32x4Ne) \
1392 V(F32x4Lt) \
1393 V(F32x4Le) \
1394 V(F32x4Pmin) \
1395 V(F32x4Pmax) \
1396 V(I64x2Add) \
1397 V(I64x2Sub) \
1398 V(I64x2Eq) \
1399 V(I64x2Ne) \
1400 V(I64x2GtS) \
1401 V(I64x2GeS) \
1402 V(I32x4Add) \
1403 V(I32x4Sub) \
1404 V(I32x4Mul) \
1405 V(I32x4Eq) \
1406 V(I32x4Ne) \
1407 V(I32x4GtS) \
1408 V(I32x4GeS) \
1409 V(I32x4GtU) \
1410 V(I32x4MinS) \
1411 V(I32x4MinU) \
1412 V(I32x4MaxS) \
1413 V(I32x4MaxU) \
1414 V(I16x8Add) \
1415 V(I16x8Sub) \
1416 V(I16x8Mul) \
1417 V(I16x8Eq) \
1418 V(I16x8Ne) \
1419 V(I16x8GtS) \
1420 V(I16x8GeS) \
1421 V(I16x8GtU) \
1422 V(I16x8MinS) \
1423 V(I16x8MinU) \
1424 V(I16x8MaxS) \
1425 V(I16x8MaxU) \
1426 V(I16x8RoundingAverageU) \
1427 V(I8x16Add) \
1428 V(I8x16Sub) \
1429 V(I8x16Eq) \
1430 V(I8x16Ne) \
1431 V(I8x16GtS) \
1432 V(I8x16GeS) \
1433 V(I8x16GtU) \
1434 V(I8x16MinS) \
1435 V(I8x16MinU) \
1436 V(I8x16MaxS) \
1437 V(I8x16MaxU) \
1438 V(I8x16RoundingAverageU) \
1439 V(S128And) \
1440 V(S128Or) \
1441 V(S128Xor) \
1442 V(S128AndNot)
1443
1444#define PROTOTYPE_SIMD_BINOP(name) \
1445 void name(Simd128Register dst, Simd128Register src1, Simd128Register src2);
1446 SIMD_BINOP_LIST(PROTOTYPE_SIMD_BINOP)
1447#undef PROTOTYPE_SIMD_BINOP
1448#undef SIMD_BINOP_LIST
1449
1450#define SIMD_EXT_MUL_LIST(V) \
1451 V(I64x2ExtMulLowI32x4S) \
1452 V(I64x2ExtMulHighI32x4S) \
1453 V(I64x2ExtMulLowI32x4U) \
1454 V(I64x2ExtMulHighI32x4U) \
1455 V(I32x4ExtMulLowI16x8S) \
1456 V(I32x4ExtMulHighI16x8S) \
1457 V(I32x4ExtMulLowI16x8U) \
1458 V(I32x4ExtMulHighI16x8U) \
1459 V(I16x8ExtMulLowI8x16S) \
1460 V(I16x8ExtMulHighI8x16S) \
1461 V(I16x8ExtMulLowI8x16U) \
1462 V(I16x8ExtMulHighI8x16U)
1463
1464#define PROTOTYPE_SIMD_EXT_MUL(name) \
1465 void name(Simd128Register dst, Simd128Register src1, Simd128Register src2, \
1466 Simd128Register scratch);
1467 SIMD_EXT_MUL_LIST(PROTOTYPE_SIMD_EXT_MUL)
1468#undef PROTOTYPE_SIMD_EXT_MUL
1469#undef SIMD_EXT_MUL_LIST
1470
1471#define SIMD_ALL_TRUE_LIST(V) \
1472 V(I64x2AllTrue) \
1473 V(I32x4AllTrue) \
1474 V(I16x8AllTrue) \
1475 V(I8x16AllTrue)
1476
1477#define PROTOTYPE_SIMD_ALL_TRUE(name) \
1478 void name(Register dst, Simd128Register src, Register scratch1, \
1479 Simd128Register scratch2);
1480 SIMD_ALL_TRUE_LIST(PROTOTYPE_SIMD_ALL_TRUE)
1481#undef PROTOTYPE_SIMD_ALL_TRUE
1482#undef SIMD_ALL_TRUE_LIST
1483
1484#define SIMD_QFM_LIST(V) \
1485 V(F64x2Qfma) \
1486 V(F64x2Qfms) \
1487 V(F32x4Qfma) \
1488 V(F32x4Qfms)
1489
1490#define PROTOTYPE_SIMD_QFM(name) \
1491 void name(Simd128Register dst, Simd128Register src1, Simd128Register src2, \
1492 Simd128Register src3);
1493 SIMD_QFM_LIST(PROTOTYPE_SIMD_QFM)
1494#undef PROTOTYPE_SIMD_QFM
1495#undef SIMD_QFM_LIST
1496
1497#define SIMD_ADD_SUB_SAT_LIST(V) \
1498 V(I16x8AddSatS) \
1499 V(I16x8SubSatS) \
1500 V(I16x8AddSatU) \
1501 V(I16x8SubSatU) \
1502 V(I8x16AddSatS) \
1503 V(I8x16SubSatS) \
1504 V(I8x16AddSatU) \
1505 V(I8x16SubSatU)
1506
1507#define PROTOTYPE_SIMD_ADD_SUB_SAT(name) \
1508 void name(Simd128Register dst, Simd128Register src1, Simd128Register src2, \
1509 Simd128Register scratch1, Simd128Register scratch2);
1510 SIMD_ADD_SUB_SAT_LIST(PROTOTYPE_SIMD_ADD_SUB_SAT)
1511#undef PROTOTYPE_SIMD_ADD_SUB_SAT
1512#undef SIMD_ADD_SUB_SAT_LIST
1513
1514#define SIMD_EXT_ADD_PAIRWISE_LIST(V) \
1515 V(I32x4ExtAddPairwiseI16x8S) \
1516 V(I32x4ExtAddPairwiseI16x8U) \
1517 V(I16x8ExtAddPairwiseI8x16S) \
1518 V(I16x8ExtAddPairwiseI8x16U)
1519
1520#define PROTOTYPE_SIMD_EXT_ADD_PAIRWISE(name) \
1521 void name(Simd128Register dst, Simd128Register src, \
1522 Simd128Register scratch1, Simd128Register scratch2);
1523 SIMD_EXT_ADD_PAIRWISE_LIST(PROTOTYPE_SIMD_EXT_ADD_PAIRWISE)
1524#undef PROTOTYPE_SIMD_EXT_ADD_PAIRWISE
1525#undef SIMD_EXT_ADD_PAIRWISE_LIST
1526
1527 // ---------------------------------------------------------------------------
1528 // Pointer compression Support
1529
1530 void SmiToPtrArrayOffset(Register dst, Register src) {
1531#if defined(V8_COMPRESS_POINTERS) || defined(V8_31BIT_SMIS_ON_64BIT_ARCH)
1532 static_assert(kSmiTag == 0 && kSmiShift < kSystemPointerSizeLog2);
1533 ShiftLeftU64(dst, src, Operand(kSystemPointerSizeLog2 - kSmiShift));
1534#else
1535 static_assert(kSmiTag == 0 && kSmiShift > kSystemPointerSizeLog2);
1536 ShiftRightS64(dst, src, Operand(kSmiShift - kSystemPointerSizeLog2));
1537#endif
1538 }
1539
1540 // Loads a field containing any tagged value and decompresses it if necessary.
1541 void LoadTaggedField(const Register& destination,
1542 const MemOperand& field_operand,
1543 const Register& scratch = no_reg);
1544 void LoadTaggedSignedField(Register destination, MemOperand field_operand);
1545 void LoadTaggedFieldWithoutDecompressing(const Register& destination,
1546 const MemOperand& field_operand,
1547 const Register& scratch = no_reg);
1548
1549 // Loads a field containing smi value and untags it.
1550 void SmiUntagField(Register dst, const MemOperand& src);
1551
1552 // Compresses and stores tagged value to given on-heap location.
1553 void StoreTaggedField(const Register& value,
1554 const MemOperand& dst_field_operand,
1555 const Register& scratch = no_reg);
1556
1557 void Zero(const MemOperand& dest);
1558 void Zero(const MemOperand& dest1, const MemOperand& dest2);
1559
1560 void DecompressTaggedSigned(Register destination, MemOperand field_operand);
1561 void DecompressTaggedSigned(Register destination, Register src);
1562 void DecompressTagged(Register destination, MemOperand field_operand);
1563 void DecompressTagged(Register destination, Register source);
1564 void DecompressTagged(const Register& destination, Tagged_t immediate);
1565
1566 // CountLeadingZeros will corrupt the scratch register pair (eg. r0:r1)
1567 void CountLeadingZerosU32(Register dst, Register src,
1568 Register scratch_pair = r0);
1569 void CountLeadingZerosU64(Register dst, Register src,
1570 Register scratch_pair = r0);
1571 void CountTrailingZerosU32(Register dst, Register src,
1572 Register scratch_pair = r0);
1573 void CountTrailingZerosU64(Register dst, Register src,
1574 Register scratch_pair = r0);
1575
1576 void LoadStackLimit(Register destination, StackLimitKind kind);
1577
1578 // It assumes that the arguments are located below the stack pointer.
1579 void LoadReceiver(Register dest) { LoadU64(dest, MemOperand(sp, 0)); }
1580 void StoreReceiver(Register rec) { StoreU64(rec, MemOperand(sp, 0)); }
1581
1582 void CallRuntime(const Runtime::Function* f, int num_arguments);
1583
1584 // Convenience function: Same as above, but takes the fid instead.
1585 void CallRuntime(Runtime::FunctionId fid) {
1586 const Runtime::Function* function = Runtime::FunctionForId(fid);
1587 CallRuntime(function, function->nargs);
1588 }
1589
1590 // Convenience function: Same as above, but takes the fid instead.
1591 void CallRuntime(Runtime::FunctionId fid, int num_arguments) {
1592 CallRuntime(Runtime::FunctionForId(fid), num_arguments);
1593 }
1594
1595 // Convenience function: tail call a runtime routine (jump).
1596 void TailCallRuntime(Runtime::FunctionId fid);
1597
1598 // ---------------------------------------------------------------------------
1599 // Support functions.
1600
1601 void IsObjectType(Register object, Register scratch1, Register scratch2,
1602 InstanceType type);
1603
1604 // Compare object type for heap object. heap_object contains a non-Smi
1605 // whose object type should be compared with the given type. This both
1606 // sets the flags and leaves the object type in the type_reg register.
1607 // It leaves the map in the map register (unless the type_reg and map register
1608 // are the same register). It leaves the heap object in the heap_object
1609 // register unless the heap_object register is the same register as one of the
1610 // other registers.
1611 // Type_reg can be no_reg. In that case ip is used.
1612 template <bool use_unsigned_cmp = false>
1613 void CompareObjectType(Register heap_object, Register map, Register type_reg,
1614 InstanceType type) {
1615 const Register temp = type_reg == no_reg ? r0 : type_reg;
1616
1617 LoadMap(map, heap_object);
1618 CompareInstanceType<use_unsigned_cmp>(map, temp, type);
1619 }
1620 // Variant of the above, which compares against a type range rather than a
1621 // single type (lower_limit and higher_limit are inclusive).
1622 //
1623 // Always use unsigned comparisons: ls for a positive result.
1624 void CompareObjectTypeRange(Register heap_object, Register map,
1625 Register type_reg, Register scratch,
1626 InstanceType lower_limit,
1627 InstanceType higher_limit);
1628
1629 // Compare instance type in a map. map contains a valid map object whose
1630 // object type should be compared with the given type. This both
1631 // sets the flags and leaves the object type in the type_reg register.
1632 template <bool use_unsigned_cmp = false>
1633 void CompareInstanceType(Register map, Register type_reg, InstanceType type) {
1634 static_assert(Map::kInstanceTypeOffset < 4096);
1635 static_assert(LAST_TYPE <= 0xFFFF);
1636 if (use_unsigned_cmp) {
1637 LoadU16(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
1638 CmpU64(type_reg, Operand(type));
1639 } else {
1640 LoadS16(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
1641 CmpS64(type_reg, Operand(type));
1642 }
1643 }
1644
1645 // Compare instance type ranges for a map (lower_limit and higher_limit
1646 // inclusive).
1647 //
1648 // Always use unsigned comparisons: ls for a positive result.
1649 void CompareInstanceTypeRange(Register map, Register type_reg,
1650 Register scratch, InstanceType lower_limit,
1651 InstanceType higher_limit);
1652
1653 // Compare the object in a register to a value from the root list.
1654 // Uses the ip register as scratch.
1655 void CompareRoot(Register obj, RootIndex index);
1656 void CompareTaggedRoot(Register obj, RootIndex index);
1657 void PushRoot(RootIndex index) {
1658 LoadRoot(r0, index);
1659 Push(r0);
1660 }
1661
1662 template <class T>
1663 void CompareTagged(Register src1, T src2) {
1664 if (COMPRESS_POINTERS_BOOL) {
1665 CmpS32(src1, src2);
1666 } else {
1667 CmpS64(src1, src2);
1668 }
1669 }
1670
1671 void Cmp(Register dst, int32_t src) { CmpS32(dst, Operand(src)); }
1672
1673 void CmpTagged(const Register& src1, const Register& src2) {
1674 CompareTagged(src1, src2);
1675 }
1676
1677 // Jump to a runtime routine.
1678 void JumpToExternalReference(const ExternalReference& builtin,
1679 bool builtin_exit_frame = false);
1680
1681 // Compare the object in a register to a value and jump if they are equal.
1682 void JumpIfRoot(Register with, RootIndex index, Label* if_equal) {
1683 CompareRoot(with, index);
1684 beq(if_equal);
1685 }
1686
1687 // Compare the object in a register to a value and jump if they are not equal.
1688 void JumpIfNotRoot(Register with, RootIndex index, Label* if_not_equal) {
1689 CompareRoot(with, index);
1690 bne(if_not_equal);
1691 }
1692
1693 // Checks if value is in range [lower_limit, higher_limit] using a single
1694 // comparison.
1695 void CompareRange(Register value, Register scratch, unsigned lower_limit,
1696 unsigned higher_limit);
1697 void JumpIfIsInRange(Register value, Register scratch, unsigned lower_limit,
1698 unsigned higher_limit, Label* on_in_range);
1699
1700 // ---------------------------------------------------------------------------
1701 // In-place weak references.
1702 void LoadWeakValue(Register out, Register in, Label* target_if_cleared);
1703
1704 // ---------------------------------------------------------------------------
1705 // StatsCounter support
1706
1707 void IncrementCounter(StatsCounter* counter, int value, Register scratch1,
1708 Register scratch2) {
1709 if (!v8_flags.native_code_counters) return;
1710 EmitIncrementCounter(counter, value, scratch1, scratch2);
1711 }
1712 void EmitIncrementCounter(StatsCounter* counter, int value, Register scratch1,
1713 Register scratch2);
1714 void DecrementCounter(StatsCounter* counter, int value, Register scratch1,
1715 Register scratch2) {
1716 if (!v8_flags.native_code_counters) return;
1717 EmitDecrementCounter(counter, value, scratch1, scratch2);
1718 }
1719 void EmitDecrementCounter(StatsCounter* counter, int value, Register scratch1,
1720 Register scratch2);
1721
1722 // ---------------------------------------------------------------------------
1723 // Stack limit utilities
1724
1725 MemOperand StackLimitAsMemOperand(StackLimitKind kind);
1726 void StackOverflowCheck(Register num_args, Register scratch,
1727 Label* stack_overflow);
1728
1729 // ---------------------------------------------------------------------------
1730 // JavaScript invokes
1731
1732 // Set up call kind marking in ecx. The method takes ecx as an
1733 // explicit first parameter to make the code more readable at the
1734 // call sites.
1735 // void SetCallKind(Register dst, CallKind kind);
1736
1737 // Removes current frame and its arguments from the stack preserving
1738 // the arguments and a return address pushed to the stack for the next call.
1739 // Both |callee_args_count| and |caller_args_count| do not include
1740 // receiver. |callee_args_count| is not modified. |caller_args_count|
1741 // is trashed.
1742
1743 // Invoke the JavaScript function code by either calling or jumping.
1744 void InvokeFunctionCode(Register function, Register new_target,
1745 Register expected_parameter_count,
1746 Register actual_parameter_count, InvokeType type);
1747
1748 // On function call, call into the debugger if necessary.
1749 void CheckDebugHook(Register fun, Register new_target,
1750 Register expected_parameter_count,
1751 Register actual_parameter_count);
1752
1753 // Invoke the JavaScript function in the given register. Changes the
1754 // current context to the context in the function before invoking.
1755 void InvokeFunctionWithNewTarget(Register function, Register new_target,
1756 Register actual_parameter_count,
1757 InvokeType type);
1758 void InvokeFunction(Register function, Register expected_parameter_count,
1759 Register actual_parameter_count, InvokeType type);
1760
1761 // Exception handling
1762
1763 // Push a new stack handler and link into stack handler chain.
1764 void PushStackHandler();
1765
1766 // Unlink the stack handler on top of the stack from the stack handler chain.
1767 // Must preserve the result register.
1768 void PopStackHandler();
1769
1770 // Enter exit frame.
1771 // stack_space - extra stack space, used for parameters before call to C.
1772 void EnterExitFrame(Register scratch, int stack_space,
1773 StackFrame::Type frame_type);
1774
1775 // Leave the current exit frame.
1776 void LeaveExitFrame(Register scratch);
1777
1778 // Load the global proxy from the current context.
1779 void LoadGlobalProxy(Register dst) {
1780 LoadNativeContextSlot(dst, Context::GLOBAL_PROXY_INDEX);
1781 }
1782
1783 void LoadNativeContextSlot(Register dst, int index);
1784
1785 // Falls through and sets scratch_and_result to 0 on failure, jumps to
1786 // on_result on success.
1787 void TryLoadOptimizedOsrCode(Register scratch_and_result,
1788 CodeKind min_opt_level, Register feedback_vector,
1789 FeedbackSlot slot, Label* on_result,
1790 Label::Distance distance);
1791 // ---------------------------------------------------------------------------
1792 // Smi utilities
1793
1794 // Jump if either of the registers contain a non-smi.
1795 inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
1796 TestIfSmi(value);
1797 bne(not_smi_label /*, cr0*/);
1798 }
1799
1800#if !defined(V8_COMPRESS_POINTERS) && !defined(V8_31BIT_SMIS_ON_64BIT_ARCH)
1801 // Ensure it is permissible to read/write int value directly from
1802 // upper half of the smi.
1803 static_assert(kSmiTag == 0);
1804 static_assert(kSmiTagSize + kSmiShiftSize == 32);
1805#endif
1806#if V8_TARGET_LITTLE_ENDIAN
1807#define SmiWordOffset(offset) (offset + kSystemPointerSize / 2)
1808#else
1809#define SmiWordOffset(offset) offset
1810#endif
1811
1812 // Abort execution if argument is not a Constructor, enabled via --debug-code.
1813 void AssertConstructor(Register object,
1814 Register scratch) NOOP_UNLESS_DEBUG_CODE;
1815
1816 // Abort execution if argument is not a JSFunction, enabled via --debug-code.
1817 void AssertFunction(Register object) NOOP_UNLESS_DEBUG_CODE;
1818
1819 // Abort execution if argument is not a callable JSFunction, enabled via
1820 // --debug-code.
1821 void AssertCallableFunction(Register object) NOOP_UNLESS_DEBUG_CODE;
1822
1823 // Abort execution if argument is not a JSBoundFunction,
1824 // enabled via --debug-code.
1825 void AssertBoundFunction(Register object) NOOP_UNLESS_DEBUG_CODE;
1826
1827 // Abort execution if argument is not a JSGeneratorObject (or subclass),
1828 // enabled via --debug-code.
1829 void AssertGeneratorObject(Register object) NOOP_UNLESS_DEBUG_CODE;
1830
1831 // Abort execution if argument is not undefined or an AllocationSite, enabled
1832 // via --debug-code.
1833 void AssertUndefinedOrAllocationSite(Register object,
1834 Register scratch) NOOP_UNLESS_DEBUG_CODE;
1835
1836 void AssertJSAny(Register object, Register map_tmp, Register tmp,
1837 AbortReason abort_reason) NOOP_UNLESS_DEBUG_CODE;
1838
1839 template <typename Field>
1840 void DecodeField(Register dst, Register src) {
1841 int shift = Field::kShift;
1842 int mask = Field::kMask >> Field::kShift;
1843 if (base::bits::IsPowerOfTwo(mask + 1)) {
1844 ExtractBitRange(dst, src, Field::kShift + Field::kSize - 1,
1845 Field::kShift);
1846 } else if (shift != 0) {
1847 ShiftLeftU64(dst, src, Operand(shift));
1848 AndP(dst, Operand(mask));
1849 } else {
1850 AndP(dst, src, Operand(mask));
1851 }
1852 }
1853
1854 template <typename Field>
1855 void DecodeField(Register reg) {
1856 DecodeField<Field>(reg, reg);
1857 }
1858
1859 // Tiering support.
1860 void AssertFeedbackCell(Register object,
1861 Register scratch) NOOP_UNLESS_DEBUG_CODE;
1862 void AssertFeedbackVector(Register object,
1863 Register scratch) NOOP_UNLESS_DEBUG_CODE;
1864 void AssertFeedbackVector(Register object) NOOP_UNLESS_DEBUG_CODE;
1865 void ReplaceClosureCodeWithOptimizedCode(Register optimized_code,
1866 Register closure, Register scratch1,
1867 Register slot_address);
1868 void GenerateTailCallToReturnedCode(Runtime::FunctionId function_id);
1869 Condition LoadFeedbackVectorFlagsAndCheckIfNeedsProcessing(
1870 Register flags, Register feedback_vector, CodeKind current_code_kind);
1871 void LoadFeedbackVectorFlagsAndJumpIfNeedsProcessing(
1872 Register flags, Register feedback_vector, CodeKind current_code_kind,
1873 Label* flags_need_processing);
1874 void OptimizeCodeOrTailCallOptimizedCodeSlot(Register flags,
1875 Register feedback_vector);
1876
1877 // ---------------------------------------------------------------------------
1878 // GC Support
1879
1880 void IncrementalMarkingRecordWriteHelper(Register object, Register value,
1881 Register address);
1882
1883 void CallJSEntry(Register target);
1884 static int CallSizeNotPredictableCodeSize(Address target,
1885 RelocInfo::Mode rmode,
1886 Condition cond = al);
1887 // Notify the garbage collector that we wrote a pointer into an object.
1888 // |object| is the object being stored into, |value| is the object being
1889 // stored. value and scratch registers are clobbered by the operation.
1890 // The offset is the offset from the start of the object, not the offset from
1891 // the tagged HeapObject pointer. For use with FieldMemOperand(reg, off).
1892 void RecordWriteField(Register object, int offset, Register value,
1893 Register slot_address, LinkRegisterStatus lr_status,
1894 SaveFPRegsMode save_fp,
1895 SmiCheck smi_check = SmiCheck::kInline);
1896
1897 // For a given |object| notify the garbage collector that the slot |address|
1898 // has been written. |value| is the object being stored. The value and
1899 // address registers are clobbered by the operation.
1900 void RecordWrite(Register object, Register slot_address, Register value,
1901 LinkRegisterStatus lr_status, SaveFPRegsMode save_fp,
1902 SmiCheck smi_check = SmiCheck::kInline);
1903
1904 void TestCodeIsMarkedForDeoptimization(Register code, Register scratch);
1905 Operand ClearedValue() const;
1906
1907 private:
1908 static const int kSmiShift = kSmiTagSize + kSmiShiftSize;
1909
1910 void Jump(intptr_t target, RelocInfo::Mode rmode, Condition cond = al);
1911 int CalculateStackPassedWords(int num_reg_arguments,
1912 int num_double_arguments);
1913
1914 // Helper functions for generating invokes.
1915 void InvokePrologue(Register expected_parameter_count,
1916 Register actual_parameter_count, InvokeType type);
1917
1918 DISALLOW_IMPLICIT_CONSTRUCTORS(MacroAssembler);
1919};
1920
1921struct MoveCycleState {
1922 // Whether a move in the cycle needs a double scratch register.
1923 bool pending_double_scratch_register_use = false;
1924};
1925
1926// Provides access to exit frame parameters (GC-ed).
1927inline MemOperand ExitFrameStackSlotOperand(int offset) {
1928 // The slot at [sp] is reserved in all ExitFrames for storing the return
1929 // address before doing the actual call, it's necessary for frame iteration
1930 // (see StoreReturnAddressAndCall for details).
1931 static constexpr int kSPOffset = 1 * kSystemPointerSize;
1932 return MemOperand(sp, (kStackFrameExtraParamSlot * kSystemPointerSize) +
1933 offset + kSPOffset);
1934}
1935
1936// Provides access to exit frame stack space (not GC-ed).
1937inline MemOperand ExitFrameCallerStackSlotOperand(int index) {
1938 return MemOperand(
1939 fp, (BuiltinExitFrameConstants::kFixedSlotCountAboveFp + index) *
1940 kSystemPointerSize);
1941}
1942
1943// Calls an API function. Allocates HandleScope, extracts returned value
1944// from handle and propagates exceptions. Clobbers C argument registers
1945// and C caller-saved registers. Restores context. On return removes
1946// (*argc_operand + slots_to_drop_on_return) * kSystemPointerSize
1947// (GCed, includes the call JS arguments space and the additional space
1948// allocated for the fast call).
1949void CallApiFunctionAndReturn(MacroAssembler* masm, bool with_profiling,
1950 Register function_address,
1951 ExternalReference thunk_ref, Register thunk_arg,
1952 int slots_to_drop_on_return,
1953 MemOperand* argc_operand,
1954 MemOperand return_value_operand);
1955
1956#define ACCESS_MASM(masm) masm->
1957
1958} // namespace internal
1959} // namespace v8
1960
1961#endif // V8_CODEGEN_S390_MACRO_ASSEMBLER_S390_H_
T
#define T
kind
Builtins::Kind kind
Definition builtins.cc:40
v8::internal::CommonFrameConstants::kFixedSlotCountAboveFp
static constexpr int kFixedSlotCountAboveFp
Definition frame-constants.h:62
v8::internal::MacroAssembler::LoadAndExtend32x2ULE
void LoadAndExtend32x2ULE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::I16x8DotI8x16S
void I16x8DotI8x16S(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::DivFloat32
void DivFloat32(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::F32x4UConvertI32x4
void F32x4UConvertI32x4(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2)
v8::internal::MacroAssembler::LoadS32
void LoadS32(Register dst, Register src)
v8::internal::MacroAssembler::JumpIfRoot
void JumpIfRoot(Register with, RootIndex index, Label *if_equal)
Definition macro-assembler-s390.h:1682
v8::internal::MacroAssembler::AssertFeedbackVector
void AssertFeedbackVector(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::Prologue
void Prologue(Register base, int prologue_offset=0)
v8::internal::MacroAssembler::Abort
void Abort(AbortReason reason)
v8::internal::MacroAssembler::Push
void Push(Register src1, Register src2, Register src3, Register src4, Register src5)
Definition macro-assembler-s390.h:698
v8::internal::MacroAssembler::I32x4TruncSatF64x2SZero
void I32x4TruncSatF64x2SZero(Simd128Register dst, Simd128Register src, Simd128Register scratch)
v8::internal::MacroAssembler::PushAll
void PushAll(RegList registers)
v8::internal::MacroAssembler::MovToFloatParameters
void MovToFloatParameters(DoubleRegister src1, DoubleRegister src2)
v8::internal::MacroAssembler::MulHighS32
void MulHighS32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::ModS32
void ModS32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::F32x4ReplaceLane
void F32x4ReplaceLane(Simd128Register dst, Simd128Register src1, DoubleRegister src2, uint8_t imm_lane_idx, Register scratch)
v8::internal::MacroAssembler::NearestIntF32
void NearestIntF32(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::StoreLane8LE
void StoreLane8LE(Simd128Register src, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::LoadStackLimit
void LoadStackLimit(Register destination, StackLimitKind kind)
v8::internal::MacroAssembler::ShiftRightU64
void ShiftRightU64(Register dst, Register src, Register val, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::SubU64
void SubU64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::StoreV128
void StoreV128(Simd128Register src, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::And
void And(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::MulHighU64
void MulHighU64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::Pop
void Pop(Register src1, Register src2, Register src3)
Definition macro-assembler-s390.h:733
v8::internal::MacroAssembler::LoadTaggedField
void LoadTaggedField(const Register &destination, const MemOperand &field_operand, const Register &scratch=no_reg)
v8::internal::MacroAssembler::Push
void Push(Tagged< TaggedIndex > index)
v8::internal::MacroAssembler::SwapFloat32
void SwapFloat32(MemOperand src, MemOperand dst, DoubleRegister scratch)
v8::internal::MacroAssembler::CallJSFunction
void CallJSFunction(Register function_object, uint16_t argument_count)
v8::internal::MacroAssembler::AndP
void AndP(Register dst, Register src, const Operand &opnd)
v8::internal::MacroAssembler::S128Select
void S128Select(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register mask)
v8::internal::MacroAssembler::ShiftRightU32
void ShiftRightU32(Register dst, Register src, Register val, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::I32x4BitMask
void I32x4BitMask(Register dst, Simd128Register src, Register scratch1, Simd128Register scratch2)
v8::internal::MacroAssembler::MulS32
void MulS32(Register dst, Register src1)
v8::internal::MacroAssembler::AddU64
void AddU64(Register dst, int imm)
Definition macro-assembler-s390.h:302
v8::internal::MacroAssembler::StoreU8
void StoreU8(Register src, const MemOperand &mem, Register scratch=r0)
v8::internal::MacroAssembler::LoadF32AsF64
void LoadF32AsF64(DoubleRegister dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, Register src, const Operand &imm)
v8::internal::MacroAssembler::LoadAndSplat64x2LE
void LoadAndSplat64x2LE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::RecordWrite
void RecordWrite(Register object, Register slot_address, Register value, LinkRegisterStatus lr_status, SaveFPRegsMode save_fp, SmiCheck smi_check=SmiCheck::kInline)
v8::internal::MacroAssembler::LoadV32ZeroLE
void LoadV32ZeroLE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::ConvertDoubleToInt64
void ConvertDoubleToInt64(const Register dst, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::TestCodeIsMarkedForDeoptimization
void TestCodeIsMarkedForDeoptimization(Register code, Register scratch)
v8::internal::MacroAssembler::AtomicExchangeU8
void AtomicExchangeU8(Register addr, Register value, Register output, Register scratch)
v8::internal::MacroAssembler::AssertMap
void AssertMap(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::JumpIfIsInRange
void JumpIfIsInRange(Register value, Register scratch, unsigned lower_limit, unsigned higher_limit, Label *on_in_range)
v8::internal::MacroAssembler::MulHighU32
void MulHighU32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::I16x8ReplaceLane
void I16x8ReplaceLane(Simd128Register dst, Simd128Register src1, Register src2, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::LeaveFrame
int LeaveFrame(StackFrame::Type type, int stack_adjustment=0)
v8::internal::MacroAssembler::ShiftLeftU32
void ShiftLeftU32(Register dst, Register src, Register val, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::I16x8Q15MulRSatS
void I16x8Q15MulRSatS(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch1, Simd128Register scratch2, Simd128Register scratch3)
v8::internal::MacroAssembler::SubFloat32
void SubFloat32(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::CallRuntime
void CallRuntime(Runtime::FunctionId fid)
Definition macro-assembler-s390.h:1585
v8::internal::MacroAssembler::XorP
void XorP(Register dst, Register src)
v8::internal::MacroAssembler::LoadF64LE
void LoadF64LE(DoubleRegister dst, const MemOperand &opnd, Register scratch)
v8::internal::MacroAssembler::LoadAndSplat16x8LE
void LoadAndSplat16x8LE(Simd128Register dst, const MemOperand &me, Register scratch)
v8::internal::MacroAssembler::CalculateStackPassedWords
int CalculateStackPassedWords(int num_reg_arguments, int num_double_arguments)
v8::internal::MacroAssembler::PushCallerSaved
int PushCallerSaved(SaveFPRegsMode fp_mode, Register scratch, Register exclusion1=no_reg, Register exclusion2=no_reg, Register exclusion3=no_reg)
v8::internal::MacroAssembler::StoreTaggedField
void StoreTaggedField(const Register &value, const MemOperand &dst_field_operand, const Register &scratch=no_reg)
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, const Operand &imm)
v8::internal::MacroAssembler::Call
void Call(Address target, RelocInfo::Mode rmode, Condition cond=al)
v8::internal::MacroAssembler::mov
void mov(Register dst, Register src)
v8::internal::MacroAssembler::PopCommonFrame
void PopCommonFrame(Register marker_reg=no_reg)
v8::internal::MacroAssembler::AddU32
void AddU32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::RotateInsertSelectBits
void RotateInsertSelectBits(Register dst, Register src, const Operand &startBit, const Operand &endBit, const Operand &shiftAmt, bool zeroBits)
v8::internal::MacroAssembler::ConvertUnsignedIntToDouble
void ConvertUnsignedIntToDouble(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::ConvertInt64ToFloat
void ConvertInt64ToFloat(DoubleRegister double_dst, Register src)
v8::internal::MacroAssembler::MultiPopV128
void MultiPopV128(DoubleRegList dregs, Register scratch, Register location=sp)
v8::internal::MacroAssembler::Move
void Move(Register dst, Register src, Condition cond=al)
v8::internal::MacroAssembler::StackLimitAsMemOperand
MemOperand StackLimitAsMemOperand(StackLimitKind kind)
v8::internal::MacroAssembler::CallCFunction
int CallCFunction(Register function, int num_reg_arguments, int num_double_arguments, SetIsolateDataSlots set_isolate_data_slots=SetIsolateDataSlots::kYes, bool has_function_descriptor=ABI_USES_FUNCTION_DESCRIPTORS, Label *return_label=nullptr)
v8::internal::MacroAssembler::I8x16UConvertI16x8
void I8x16UConvertI16x8(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::StoreU16LE
void StoreU16LE(Register src, const MemOperand &mem, Register scratch=r0)
v8::internal::MacroAssembler::MulS64
void MulS64(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::DecodeField
void DecodeField(Register dst, Register src)
Definition macro-assembler-s390.h:1840
v8::internal::MacroAssembler::I16x8BitMask
void I16x8BitMask(Register dst, Simd128Register src, Register scratch1, Simd128Register scratch2)
v8::internal::MacroAssembler::AssertFunction
void AssertFunction(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::CmpF32
void CmpF32(DoubleRegister src1, const MemOperand &src2)
v8::internal::MacroAssembler::I8x16GeU
void I8x16GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::MulHighU32
void MulHighU32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::LoadU32
void LoadU32(Register dst, Register src)
v8::internal::MacroAssembler::CmpU32
void CmpU32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::F32x4Splat
void F32x4Splat(Simd128Register dst, Simd128Register src)
v8::internal::MacroAssembler::AssertGeneratorObject
void AssertGeneratorObject(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::CallSizeNotPredictableCodeSize
static int CallSizeNotPredictableCodeSize(Address target, RelocInfo::Mode rmode, Condition cond=al)
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::ConvertFloat32ToUnsignedInt32
void ConvertFloat32ToUnsignedInt32(const Register result, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::JumpIfNotRoot
void JumpIfNotRoot(Register with, RootIndex index, Label *if_not_equal)
Definition macro-assembler-s390.h:1688
v8::internal::MacroAssembler::MulS64
void MulS64(Register dst, Register src)
v8::internal::MacroAssembler::Pop
void Pop(Register src1, Register src2, Register src3, Register src4)
Definition macro-assembler-s390.h:741
v8::internal::MacroAssembler::MovFloatToInt
void MovFloatToInt(Register dst, DoubleRegister src)
v8::internal::MacroAssembler::SwapSimd128
void SwapSimd128(MemOperand src, MemOperand dst, Simd128Register scratch)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, Register src)
v8::internal::MacroAssembler::CompareLogicalChar
void CompareLogicalChar(const MemOperand &opnd1, const MemOperand &opnd2, const Operand &length)
v8::internal::MacroAssembler::ModS32
void ModS32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::V128AnyTrue
void V128AnyTrue(Register dst, Simd128Register src, Register scratch)
v8::internal::MacroAssembler::LoadEntryFromBuiltin
void LoadEntryFromBuiltin(Builtin builtin, Register destination)
v8::internal::MacroAssembler::OrP
void OrP(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::LoadU32LE
void LoadU32LE(Register dst, const MemOperand &opnd, Register scratch=no_reg)
v8::internal::MacroAssembler::DivFloat64
void DivFloat64(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::F32x4SConvertI32x4
void F32x4SConvertI32x4(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2)
v8::internal::MacroAssembler::Or
void Or(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::PushStandardFrame
void PushStandardFrame(Register function_reg)
v8::internal::MacroAssembler::CountTrailingZerosU32
void CountTrailingZerosU32(Register dst, Register src, Register scratch_pair=r0)
v8::internal::MacroAssembler::LoadAndSub32
void LoadAndSub32(Register dst, Register src, const MemOperand &opnd)
v8::internal::MacroAssembler::AtomicCmpExchangeHelper
void AtomicCmpExchangeHelper(Register addr, Register output, Register old_value, Register new_value, int start, int end, int shift_amount, int offset, Register temp0, Register temp1)
v8::internal::MacroAssembler::AddS64
void AddS64(const MemOperand &opnd, const Operand &imm)
v8::internal::MacroAssembler::SubF32
void SubF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::CmpF64
void CmpF64(DoubleRegister src1, const MemOperand &src2)
v8::internal::MacroAssembler::Or
void Or(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::LoadLane16LE
void LoadLane16LE(Simd128Register dst, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::ExtractBitRange
void ExtractBitRange(Register dst, Register src, int rangeStart, int rangeEnd)
Definition macro-assembler-s390.h:1015
v8::internal::MacroAssembler::CompareRoot
void CompareRoot(Register obj, RootIndex index)
v8::internal::MacroAssembler::MulHighS32
void MulHighS32(Register dst, Register src1, const Operand &src2)
v8::internal::MacroAssembler::MovIntToFloat
void MovIntToFloat(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::CmpS64
void CmpS64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, const Operand &imm)
v8::internal::MacroAssembler::LoadU64LE
void LoadU64LE(Register dst, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::StoreU32LE
void StoreU32LE(Register src, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::ShiftRightS32
void ShiftRightS32(Register dst, Register src, Register shift, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::I64x2ReplaceLane
void I64x2ReplaceLane(Simd128Register dst, Simd128Register src1, Register src2, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::StoreU32
void StoreU32(Register src, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::Move
void Move(Register dst, Tagged< Smi > smi)
Definition macro-assembler-s390.h:186
v8::internal::MacroAssembler::LoadAndExtend32x2SLE
void LoadAndExtend32x2SLE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::mov
void mov(Register dst, const Operand &src)
v8::internal::MacroAssembler::Move
void Move(Register dst, const MemOperand &src)
v8::internal::MacroAssembler::RecordWriteField
void RecordWriteField(Register object, int offset, Register value, Register slot_address, LinkRegisterStatus lr_status, SaveFPRegsMode save_fp, SmiCheck smi_check=SmiCheck::kInline)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, const Operand &imm)
v8::internal::MacroAssembler::CallCFunction
int CallCFunction(ExternalReference function, int num_reg_arguments, int num_double_arguments, SetIsolateDataSlots set_isolate_data_slots=SetIsolateDataSlots::kYes, bool has_function_descriptor=ABI_USES_FUNCTION_DESCRIPTORS, Label *return_label=nullptr)
v8::internal::MacroAssembler::I32x4GeU
void I32x4GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::Call
void Call(Handle< Code > code, RelocInfo::Mode rmode=RelocInfo::CODE_TARGET, Condition cond=al)
v8::internal::MacroAssembler::ExtractBit
void ExtractBit(Register dst, Register src, uint32_t bitNumber)
Definition macro-assembler-s390.h:1039
v8::internal::MacroAssembler::StoreReturnAddressAndCall
void StoreReturnAddressAndCall(Register target)
v8::internal::MacroAssembler::CompareObjectType
void CompareObjectType(Register heap_object, Register map, Register type_reg, InstanceType type)
Definition macro-assembler-s390.h:1613
v8::internal::MacroAssembler::LeaveExitFrame
void LeaveExitFrame(Register scratch)
v8::internal::MacroAssembler::StackOverflowCheck
void StackOverflowCheck(Register num_args, Register scratch, Label *stack_overflow)
v8::internal::MacroAssembler::DivU32
void DivU32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::AssertFeedbackVector
void AssertFeedbackVector(Register object, Register scratch) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::CallBuiltinByIndex
void CallBuiltinByIndex(Register builtin_index, Register target)
v8::internal::MacroAssembler::I16x8Splat
void I16x8Splat(Simd128Register dst, Register src)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::LoadRootRelative
void LoadRootRelative(Register destination, int32_t offset) final
v8::internal::MacroAssembler::AtomicCmpExchangeU16
void AtomicCmpExchangeU16(Register addr, Register output, Register old_value, Register new_value, Register temp0, Register temp1)
v8::internal::MacroAssembler::JumpIfSmi
void JumpIfSmi(Register value, Label *smi_label)
Definition macro-assembler-s390.h:108
v8::internal::MacroAssembler::TruncF64
void TruncF64(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::LoadRoot
void LoadRoot(Register destination, RootIndex index, Condition cond)
v8::internal::MacroAssembler::LoadPC
void LoadPC(Register dst)
v8::internal::MacroAssembler::ActivationFrameAlignment
static int ActivationFrameAlignment()
v8::internal::MacroAssembler::BranchRelativeOnIdxHighP
void BranchRelativeOnIdxHighP(Register dst, Register inc, Label *L)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, Register src, const Operand &imm)
v8::internal::MacroAssembler::Push
void Push(Handle< HeapObject > handle)
v8::internal::MacroAssembler::PrepareCallCFunction
void PrepareCallCFunction(int num_reg_arguments, Register scratch)
v8::internal::MacroAssembler::CallCodeObject
void CallCodeObject(Register code_object)
v8::internal::MacroAssembler::CallEphemeronKeyBarrier
void CallEphemeronKeyBarrier(Register object, Register slot_address, SaveFPRegsMode fp_mode)
v8::internal::MacroAssembler::LoadLane64LE
void LoadLane64LE(Simd128Register dst, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::LoadTaggedSignedField
void LoadTaggedSignedField(Register destination, MemOperand field_operand)
v8::internal::MacroAssembler::CmpTagged
void CmpTagged(const Register &src1, const Register &src2)
Definition macro-assembler-s390.h:1673
v8::internal::MacroAssembler::CmpS32
void CmpS32(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::ModU64
void ModU64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::LoadS8
void LoadS8(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::AssertUnreachable
void AssertUnreachable(AbortReason reason) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::AddU32
void AddU32(Register dst, const Operand &imm)
v8::internal::MacroAssembler::I32x4UConvertF32x4
void I32x4UConvertF32x4(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2)
v8::internal::MacroAssembler::ConvertFloat32ToUnsignedInt64
void ConvertFloat32ToUnsignedInt64(const Register result, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::AndP
void AndP(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::ShiftLeftU64
void ShiftLeftU64(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::I32x4ExtractLane
void I32x4ExtractLane(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::LoadCompressedMap
void LoadCompressedMap(Register destination, Register object)
v8::internal::MacroAssembler::SwapDouble
void SwapDouble(DoubleRegister src, DoubleRegister dst, DoubleRegister scratch)
v8::internal::MacroAssembler::LoadRootRegisterOffset
void LoadRootRegisterOffset(Register destination, intptr_t offset) final
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, Register src)
v8::internal::MacroAssembler::CanonicalizeNaN
void CanonicalizeNaN(const DoubleRegister value)
Definition macro-assembler-s390.h:784
v8::internal::MacroAssembler::Branch
void Branch(Condition c, const Operand &opnd)
v8::internal::MacroAssembler::PopAll
void PopAll(DoubleRegList registers, int stack_slot_size=kDoubleSize)
v8::internal::MacroAssembler::SubU32
void SubU32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::AssertSmi
void AssertSmi(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::LoadCodeInstructionStart
void LoadCodeInstructionStart(Register destination, Register code_object, CodeEntrypointTag tag=kDefaultCodeEntrypointTag)
v8::internal::MacroAssembler::TryInlineTruncateDoubleToI
void TryInlineTruncateDoubleToI(Register result, DoubleRegister double_input, Label *done)
v8::internal::MacroAssembler::Xor
void Xor(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SmiUntag
void SmiUntag(Register dst, Register src)
Definition macro-assembler-s390.h:1106
v8::internal::MacroAssembler::LoadAndExtend8x8SLE
void LoadAndExtend8x8SLE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::AddU64
void AddU64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::Xor
void Xor(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::I32x4SConvertF32x4
void I32x4SConvertF32x4(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2)
v8::internal::MacroAssembler::LoadFeedbackVectorFlagsAndJumpIfNeedsProcessing
void LoadFeedbackVectorFlagsAndJumpIfNeedsProcessing(Register flags, Register feedback_vector, CodeKind current_code_kind, Label *flags_need_processing)
v8::internal::MacroAssembler::MulS64
void MulS64(Register dst, Register src1, Register src2)
Definition macro-assembler-s390.h:340
v8::internal::MacroAssembler::LoadFeedbackVector
void LoadFeedbackVector(Register dst, Register closure, Register scratch, Label *fbv_undef)
v8::internal::MacroAssembler::DivF64
void DivF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::AddU64
void AddU64(Register dst, Register src)
Definition macro-assembler-s390.h:304
v8::internal::MacroAssembler::CmpS32
void CmpS32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::EmitIncrementCounter
void EmitIncrementCounter(StatsCounter *counter, int value, Register scratch1, Register scratch2)
v8::internal::MacroAssembler::I32x4DotI16x8S
void I32x4DotI16x8S(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::ModU32
void ModU32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::AndP
void AndP(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::StoreV128LE
void StoreV128LE(Simd128Register src, const MemOperand &mem, Register scratch1, Register scratch2)
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::SwapDouble
void SwapDouble(MemOperand src, MemOperand dst, DoubleRegister scratch)
v8::internal::MacroAssembler::SwapFloat32
void SwapFloat32(DoubleRegister src, DoubleRegister dst, DoubleRegister scratch)
v8::internal::MacroAssembler::InvokeFunctionCode
void InvokeFunctionCode(Register function, Register new_target, Register expected_parameter_count, Register actual_parameter_count, InvokeType type)
v8::internal::MacroAssembler::Mul32WithOverflowIfCCUnequal
void Mul32WithOverflowIfCCUnequal(Register dst, Register src1, const Operand &src2)
v8::internal::MacroAssembler::CmpAndSwap64
void CmpAndSwap64(Register old_val, Register new_val, const MemOperand &opnd)
v8::internal::MacroAssembler::ExtractBitMask
void ExtractBitMask(Register dst, Register src, uintptr_t mask, RCBit rc=LeaveRC)
Definition macro-assembler-s390.h:1045
v8::internal::MacroAssembler::ConvertUnsignedIntToFloat
void ConvertUnsignedIntToFloat(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::StoreLane16LE
void StoreLane16LE(Simd128Register src, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::RequiredStackSizeForCallerSaved
int RequiredStackSizeForCallerSaved(SaveFPRegsMode fp_mode, Register exclusion1=no_reg, Register exclusion2=no_reg, Register exclusion3=no_reg) const
v8::internal::MacroAssembler::DoubleMax
void DoubleMax(DoubleRegister result_reg, DoubleRegister left_reg, DoubleRegister right_reg)
v8::internal::MacroAssembler::I64x2ExtractLane
void I64x2ExtractLane(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::MultiPopDoubles
void MultiPopDoubles(DoubleRegList dregs, Register location=sp)
v8::internal::MacroAssembler::Jump
void Jump(const ExternalReference &reference)
v8::internal::MacroAssembler::LoadF32
void LoadF32(DoubleRegister result, T value, Register scratch)
Definition macro-assembler-s390.h:885
v8::internal::MacroAssembler::ShiftLeftU64
void ShiftLeftU64(Register dst, Register src, Register val, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::StoreF64LE
void StoreF64LE(DoubleRegister src, const MemOperand &opnd, Register scratch)
v8::internal::MacroAssembler::ExternalReferenceAsOperand
MemOperand ExternalReferenceAsOperand(IsolateFieldId id)
Definition macro-assembler-s390.h:98
v8::internal::MacroAssembler::IsObjectType
void IsObjectType(Register object, Register scratch1, Register scratch2, InstanceType type)
v8::internal::MacroAssembler::InvokePrologue
void InvokePrologue(Register expected_parameter_count, Register actual_parameter_count, InvokeType type)
v8::internal::MacroAssembler::DivS32
void DivS32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::LoadS32LE
void LoadS32LE(Register dst, const MemOperand &opnd, Register scratch=no_reg)
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, Register src)
v8::internal::MacroAssembler::Push
void Push(Register src1, Register src2, Register src3)
Definition macro-assembler-s390.h:681
v8::internal::MacroAssembler::AssertConstructor
void AssertConstructor(Register object, Register scratch) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::AddF64
void AddF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::I16x8ExtractLaneS
void I16x8ExtractLaneS(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register scratch)
v8::internal::MacroAssembler::ModS64
void ModS64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::StoreF32LE
void StoreF32LE(DoubleRegister src, const MemOperand &opnd, Register scratch)
v8::internal::MacroAssembler::LoadOnConditionP
void LoadOnConditionP(Condition cond, Register dst, Register src)
v8::internal::MacroAssembler::MovDoubleToInt64
void MovDoubleToInt64(Register dst, DoubleRegister src)
v8::internal::MacroAssembler::PushAll
void PushAll(DoubleRegList registers, int stack_slot_size=kDoubleSize)
v8::internal::MacroAssembler::ConvertFloat32ToInt32
void ConvertFloat32ToInt32(const Register result, const DoubleRegister double_input, FPRoundingMode rounding_mode)
v8::internal::MacroAssembler::ReplaceClosureCodeWithOptimizedCode
void ReplaceClosureCodeWithOptimizedCode(Register optimized_code, Register closure, Register scratch1, Register slot_address)
v8::internal::MacroAssembler::I8x16Shuffle
void I8x16Shuffle(Simd128Register dst, Simd128Register src1, Simd128Register src2, uint64_t high, uint64_t low, Register scratch1, Register scratch2, Simd128Register scratch3)
v8::internal::MacroAssembler::Sqrt
void Sqrt(DoubleRegister result, DoubleRegister input)
v8::internal::MacroAssembler::AssertZeroExtended
void AssertZeroExtended(Register reg) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, Register src, int32_t imm)
v8::internal::MacroAssembler::EnterExitFrame
void EnterExitFrame(Register scratch, int stack_space, StackFrame::Type frame_type)
v8::internal::MacroAssembler::ConvertDoubleToUnsignedInt32
void ConvertDoubleToUnsignedInt32(const Register dst, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::And
void And(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::Zero
void Zero(const MemOperand &dest1, const MemOperand &dest2)
v8::internal::MacroAssembler::LoadAndTest32
void LoadAndTest32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SwapP
void SwapP(MemOperand src, MemOperand dst, Register scratch_0, Register scratch_1)
v8::internal::MacroAssembler::SetRoundingMode
void SetRoundingMode(FPRoundingMode RN)
v8::internal::MacroAssembler::BailoutIfDeoptimized
void BailoutIfDeoptimized(Register scratch)
v8::internal::MacroAssembler::Check
void Check(Condition cond, AbortReason reason, CRegister cr=cr7)
v8::internal::MacroAssembler::I32x4DotI8x16AddS
void I32x4DotI8x16AddS(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register src3, Simd128Register scratch1, Simd128Register scratch2)
v8::internal::MacroAssembler::LoadU8
void LoadU8(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::And
void And(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::SmiTag
void SmiTag(Register dst, Register src)
Definition macro-assembler-s390.h:1129
v8::internal::MacroAssembler::CallJSEntry
void CallJSEntry(Register target)
v8::internal::MacroAssembler::DivU64
void DivU64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SwapSimd128
void SwapSimd128(Simd128Register src, MemOperand dst, Simd128Register scratch)
v8::internal::MacroAssembler::ExternalReferenceAsOperand
MemOperand ExternalReferenceAsOperand(ExternalReference reference, Register scratch)
v8::internal::MacroAssembler::And
void And(Register dst, Register src)
v8::internal::MacroAssembler::Zero
void Zero(const MemOperand &dest)
v8::internal::MacroAssembler::IncrementCounter
void IncrementCounter(StatsCounter *counter, int value, Register scratch1, Register scratch2)
Definition macro-assembler-s390.h:1707
v8::internal::MacroAssembler::AddU64
void AddU64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::I16x8ExtractLaneU
void I16x8ExtractLaneU(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::SwapP
void SwapP(Register src, MemOperand dst, Register scratch)
v8::internal::MacroAssembler::PushCommonFrame
void PushCommonFrame(Register marker_reg=no_reg)
v8::internal::MacroAssembler::MovFromFloatParameter
void MovFromFloatParameter(DoubleRegister dst)
v8::internal::MacroAssembler::LoadAndSub64
void LoadAndSub64(Register dst, Register src, const MemOperand &opnd)
v8::internal::MacroAssembler::JumpIfEqual
void JumpIfEqual(Register x, int32_t y, Label *dest)
v8::internal::MacroAssembler::Not32
void Not32(Register dst, Register src=no_reg)
v8::internal::MacroAssembler::SwapDouble
void SwapDouble(DoubleRegister src, MemOperand dst, DoubleRegister scratch)
v8::internal::MacroAssembler::GetLabelAddress
void GetLabelAddress(Register dst, Label *target)
v8::internal::MacroAssembler::LoadU16
void LoadU16(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::MulHighS64
void MulHighS64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::Assert
void Assert(Condition cond, AbortReason reason, CRegister cr=cr7) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::DecompressTaggedSigned
void DecompressTaggedSigned(Register destination, MemOperand field_operand)
v8::internal::MacroAssembler::MulHighS64
void MulHighS64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::StoreLane32LE
void StoreLane32LE(Simd128Register src, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::Move
void Move(Register dst, Handle< HeapObject > source, RelocInfo::Mode rmode=RelocInfo::FULL_EMBEDDED_OBJECT)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::JumpToExternalReference
void JumpToExternalReference(const ExternalReference &builtin, bool builtin_exit_frame=false)
v8::internal::MacroAssembler::ConvertInt64ToDouble
void ConvertInt64ToDouble(DoubleRegister double_dst, Register src)
v8::internal::MacroAssembler::ClearedValue
Operand ClearedValue() const
v8::internal::MacroAssembler::MulF32
void MulF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::LoadS16
void LoadS16(Register dst, Register src)
v8::internal::MacroAssembler::LoadF64
void LoadF64(DoubleRegister dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SwapSimd128
void SwapSimd128(Simd128Register src, Simd128Register dst, Simd128Register scratch)
v8::internal::MacroAssembler::DivU32
void DivU32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::DivS64
void DivS64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::I32x4Splat
void I32x4Splat(Simd128Register dst, Register src)
v8::internal::MacroAssembler::InvokeFunctionWithNewTarget
void InvokeFunctionWithNewTarget(Register function, Register new_target, Register actual_parameter_count, InvokeType type)
v8::internal::MacroAssembler::MulF64
void MulF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::MovToFloatParameter
void MovToFloatParameter(DoubleRegister src)
v8::internal::MacroAssembler::Jump
void Jump(Register target, Condition cond=al)
v8::internal::MacroAssembler::CmpS64
void CmpS64(Register src1, Register src2)
v8::internal::MacroAssembler::LoadAndSplat8x16LE
void LoadAndSplat8x16LE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::FloatMin
void FloatMin(DoubleRegister result_reg, DoubleRegister left_reg, DoubleRegister right_reg)
v8::internal::MacroAssembler::MultiPushF64OrV128
void MultiPushF64OrV128(DoubleRegList dregs, Register scratch, Register location=sp)
v8::internal::MacroAssembler::ConvertUnsignedInt64ToDouble
void ConvertUnsignedInt64ToDouble(DoubleRegister double_dst, Register src)
v8::internal::MacroAssembler::ClearRightImm
void ClearRightImm(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::MovToFloatResult
void MovToFloatResult(DoubleRegister src)
v8::internal::MacroAssembler::LoadAndTest32
void LoadAndTest32(Register dst, Register src)
v8::internal::MacroAssembler::CountTrailingZerosU64
void CountTrailingZerosU64(Register dst, Register src, Register scratch_pair=r0)
v8::internal::MacroAssembler::MovInt64ToDouble
void MovInt64ToDouble(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::Pop
void Pop(Register src1, Register src2)
Definition macro-assembler-s390.h:726
v8::internal::MacroAssembler::Switch
void Switch(Register scrach, Register reg, int case_base_value, Label **labels, int num_labels)
v8::internal::MacroAssembler::EnterFrame
void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg=false)
v8::internal::MacroAssembler::InvokeFunction
void InvokeFunction(Register function, Register expected_parameter_count, Register actual_parameter_count, InvokeType type)
v8::internal::MacroAssembler::StubPrologue
void StubPrologue(StackFrame::Type type, Register base=no_reg, int prologue_offset=0)
v8::internal::MacroAssembler::TruncateDoubleToI
void TruncateDoubleToI(Isolate *isolate, Zone *zone, Register result, DoubleRegister double_input, StubCallMode stub_mode)
v8::internal::MacroAssembler::Popcnt32
void Popcnt32(Register dst, Register src)
v8::internal::MacroAssembler::CmpS64
void CmpS64(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::SwapP
void SwapP(Register src, Register dst, Register scratch)
v8::internal::MacroAssembler::ShiftRightU32
void ShiftRightU32(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::CompareRange
void CompareRange(Register value, Register scratch, unsigned lower_limit, unsigned higher_limit)
v8::internal::MacroAssembler::S128Const
void S128Const(Simd128Register dst, uint64_t high, uint64_t low, Register scratch1, Register scratch2)
v8::internal::MacroAssembler::JumpCodeObject
void JumpCodeObject(Register code_object, JumpMode jump_mode=JumpMode::kJump)
v8::internal::MacroAssembler::CmpU32
void CmpU32(Register src1, Register src2)
v8::internal::MacroAssembler::PushArray
void PushArray(Register array, Register size, Register scratch, Register scratch2, PushArrayOrder order=kNormal)
v8::internal::MacroAssembler::DecrementCounter
void DecrementCounter(StatsCounter *counter, int value, Register scratch1, Register scratch2)
Definition macro-assembler-s390.h:1714
v8::internal::MacroAssembler::OrP
void OrP(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::I64x2Splat
void I64x2Splat(Simd128Register dst, Register src)
v8::internal::MacroAssembler::LoadLane32LE
void LoadLane32LE(Simd128Register dst, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::I8x16ExtractLaneU
void I8x16ExtractLaneU(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::SwapFloat32
void SwapFloat32(DoubleRegister src, MemOperand dst, DoubleRegister scratch)
v8::internal::MacroAssembler::StoreLane64LE
void StoreLane64LE(Simd128Register src, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::MulHighS32
void MulHighS32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::BranchOnCount
void BranchOnCount(Register r1, Label *l)
v8::internal::MacroAssembler::JumpIfCodeIsTurbofanned
void JumpIfCodeIsTurbofanned(Register code, Register scratch, Label *if_turbofanned)
v8::internal::MacroAssembler::EmitDecrementCounter
void EmitDecrementCounter(StatsCounter *counter, int value, Register scratch1, Register scratch2)
v8::internal::MacroAssembler::LoadU8
void LoadU8(Register dst, Register src)
v8::internal::MacroAssembler::ModU64
void ModU64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::MulS64
void MulS64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::DivU64
void DivU64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::LoadFromConstantsTable
void LoadFromConstantsTable(Register destination, int constant_index) final
v8::internal::MacroAssembler::AddU32
void AddU32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::EntryFromBuiltinAsOperand
MemOperand EntryFromBuiltinAsOperand(Builtin builtin)
v8::internal::MacroAssembler::SubU32
void SubU32(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::StoreU16
void StoreU16(Register src, const MemOperand &mem, Register scratch=r0)
v8::internal::MacroAssembler::F64x2ReplaceLane
void F64x2ReplaceLane(Simd128Register dst, Simd128Register src1, DoubleRegister src2, uint8_t imm_lane_idx, Register scratch)
v8::internal::MacroAssembler::CompareObjectTypeRange
void CompareObjectTypeRange(Register heap_object, Register map, Register type_reg, Register scratch, InstanceType lower_limit, InstanceType higher_limit)
v8::internal::MacroAssembler::ConvertDoubleToInt32
void ConvertDoubleToInt32(const Register dst, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::AssertNotSmi
void AssertNotSmi(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::CeilF32
void CeilF32(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::ConvertIntToDouble
void ConvertIntToDouble(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::ComputeCodeStartAddress
void ComputeCodeStartAddress(Register dst)
v8::internal::MacroAssembler::MaybeSaveRegisters
void MaybeSaveRegisters(RegList registers)
v8::internal::MacroAssembler::LoadV128LE
void LoadV128LE(DoubleRegister dst, const MemOperand &mem, Register scratch0, Register scratch1)
v8::internal::MacroAssembler::DivS32
void DivS32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::LoadTaggedRoot
void LoadTaggedRoot(Register destination, RootIndex index)
v8::internal::MacroAssembler::SubF64
void SubF64(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::DISALLOW_IMPLICIT_CONSTRUCTORS
DISALLOW_IMPLICIT_CONSTRUCTORS(MacroAssembler)
v8::internal::MacroAssembler::FloorF64
void FloorF64(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::LoadPositive32
void LoadPositive32(Register result, Register input)
v8::internal::MacroAssembler::LoadPositiveP
void LoadPositiveP(Register result, Register input)
v8::internal::MacroAssembler::CompareInstanceType
void CompareInstanceType(Register map, Register type_reg, InstanceType type)
Definition macro-assembler-s390.h:1633
v8::internal::MacroAssembler::JumpIfNotSmi
void JumpIfNotSmi(Register value, Label *not_smi_label)
Definition macro-assembler-s390.h:1795
v8::internal::MacroAssembler::MultiPush
void MultiPush(RegList regs, Register location=sp)
v8::internal::MacroAssembler::AddF32
void AddF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::ModU32
void ModU32(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::I32x4ReplaceLane
void I32x4ReplaceLane(Simd128Register dst, Simd128Register src1, Register src2, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::JumpJSFunction
void JumpJSFunction(Register function_object, JumpMode jump_mode=JumpMode::kJump)
v8::internal::MacroAssembler::LoadU16LE
void LoadU16LE(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::CountLeadingZerosU32
void CountLeadingZerosU32(Register dst, Register src, Register scratch_pair=r0)
v8::internal::MacroAssembler::ShiftRightS32
void ShiftRightS32(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::CheckDebugHook
void CheckDebugHook(Register fun, Register new_target, Register expected_parameter_count, Register actual_parameter_count)
v8::internal::MacroAssembler::LoadAndExtend8x8ULE
void LoadAndExtend8x8ULE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::Jump
void Jump(intptr_t target, RelocInfo::Mode rmode, Condition cond=al)
v8::internal::MacroAssembler::AtomicExchangeHelper
void AtomicExchangeHelper(Register addr, Register value, Register output, int start, int end, int shift_amount, int offset, Register scratch)
v8::internal::MacroAssembler::F64x2PromoteLowF32x4
void F64x2PromoteLowF32x4(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2, Register scratch3, Register scratch4)
v8::internal::MacroAssembler::Sqrt
void Sqrt(DoubleRegister result, const MemOperand &input)
v8::internal::MacroAssembler::TestBitRange
void TestBitRange(Register value, int rangeStart, int rangeEnd, Register scratch=r0)
Definition macro-assembler-s390.h:1076
v8::internal::MacroAssembler::LoadAndExtend16x4ULE
void LoadAndExtend16x4ULE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::push
void push(DoubleRegister src)
Definition macro-assembler-s390.h:644
v8::internal::MacroAssembler::ShiftLeftU32
void ShiftLeftU32(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::LoadFeedbackVectorFlagsAndCheckIfNeedsProcessing
Condition LoadFeedbackVectorFlagsAndCheckIfNeedsProcessing(Register flags, Register feedback_vector, CodeKind current_code_kind)
v8::internal::MacroAssembler::LoadAndTestP
void LoadAndTestP(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::CallCFunction
int CallCFunction(ExternalReference function, int num_arguments, SetIsolateDataSlots set_isolate_data_slots=SetIsolateDataSlots::kYes, bool has_function_descriptor=ABI_USES_FUNCTION_DESCRIPTORS, Label *return_label=nullptr)
v8::internal::MacroAssembler::LoadF32LE
void LoadF32LE(DoubleRegister dst, const MemOperand &opnd, Register scratch)
v8::internal::MacroAssembler::CallRuntime
void CallRuntime(const Runtime::Function *f, int num_arguments)
v8::internal::MacroAssembler::LoadWeakValue
void LoadWeakValue(Register out, Register in, Label *target_if_cleared)
v8::internal::MacroAssembler::CallBuiltin
void CallBuiltin(Builtin builtin, Condition cond=al)
v8::internal::MacroAssembler::Popcnt64
void Popcnt64(Register dst, Register src)
v8::internal::MacroAssembler::SubFloat64
void SubFloat64(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, Register src, int32_t imm)
v8::internal::MacroAssembler::ConvertUnsignedInt64ToFloat
void ConvertUnsignedInt64ToFloat(DoubleRegister double_dst, Register src)
v8::internal::MacroAssembler::Pop
void Pop(Register src1, Register src2, Register src3, Register src4, Register src5)
Definition macro-assembler-s390.h:750
v8::internal::MacroAssembler::F32x4ExtractLane
void F32x4ExtractLane(DoubleRegister dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::CanonicalizeNaN
void CanonicalizeNaN(const DoubleRegister dst, const DoubleRegister src)
v8::internal::MacroAssembler::I16x8UConvertI32x4
void I16x8UConvertI32x4(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::I16x8SConvertI32x4
void I16x8SConvertI32x4(Simd128Register dst, Simd128Register src1, Simd128Register src2)
v8::internal::MacroAssembler::I8x16BitMask
void I8x16BitMask(Register dst, Simd128Register src, Register scratch1, Register scratch2, Simd128Register scratch3)
v8::internal::MacroAssembler::GenerateTailCallToReturnedCode
void GenerateTailCallToReturnedCode(Runtime::FunctionId function_id)
v8::internal::MacroAssembler::LoadAndSplat32x4LE
void LoadAndSplat32x4LE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::StoreF64
void StoreF64(DoubleRegister dst, const MemOperand &opnd)
v8::internal::MacroAssembler::I64x2BitMask
void I64x2BitMask(Register dst, Simd128Register src, Register scratch1, Simd128Register scratch2)
v8::internal::MacroAssembler::StoreMultipleP
void StoreMultipleP(Register dst1, Register dst2, const MemOperand &mem)
v8::internal::MacroAssembler::StoreU64LE
void StoreU64LE(Register src, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::AssertJSAny
void AssertJSAny(Register object, Register map_tmp, Register tmp, AbortReason abort_reason) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::Push
void Push(Tagged< Smi > smi)
v8::internal::MacroAssembler::FloorF32
void FloorF32(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::LoadSmiLiteral
void LoadSmiLiteral(Register dst, Tagged< Smi > smi)
v8::internal::MacroAssembler::Xor
void Xor(Register dst, Register src)
v8::internal::MacroAssembler::Cmp
void Cmp(Register dst, int32_t src)
Definition macro-assembler-s390.h:1671
v8::internal::MacroAssembler::DivS64
void DivS64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::IncrementalMarkingRecordWriteHelper
void IncrementalMarkingRecordWriteHelper(Register object, Register value, Register address)
v8::internal::MacroAssembler::DivF32
void DivF32(DoubleRegister dst, DoubleRegister lhs, DoubleRegister rhs)
v8::internal::MacroAssembler::F32x4DemoteF64x2Zero
void F32x4DemoteF64x2Zero(Simd128Register dst, Simd128Register src, Simd128Register scratch1, Register scratch2, Register scratch3, Register scratch4)
v8::internal::MacroAssembler::AssertFeedbackCell
void AssertFeedbackCell(Register object, Register scratch) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::OrP
void OrP(Register dst, Register src)
v8::internal::MacroAssembler::Or
void Or(Register dst, Register src)
v8::internal::MacroAssembler::CallForDeoptimization
void CallForDeoptimization(Builtin target, int deopt_id, Label *exit, DeoptimizeKind kind, Label *ret, Label *jump_deoptimization_entry_label)
v8::internal::MacroAssembler::Xor
void Xor(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::CountLeadingZerosU64
void CountLeadingZerosU64(Register dst, Register src, Register scratch_pair=r0)
v8::internal::MacroAssembler::Call
void Call(Label *target)
v8::internal::MacroAssembler::CmpSmiLiteral
void CmpSmiLiteral(Register src1, Tagged< Smi > smi, Register scratch)
v8::internal::MacroAssembler::DropArgumentsAndPushNewReceiver
void DropArgumentsAndPushNewReceiver(Register argc, Register receiver)
v8::internal::MacroAssembler::CompareTagged
void CompareTagged(Register src1, T src2)
Definition macro-assembler-s390.h:1663
v8::internal::MacroAssembler::JumpIfCodeIsMarkedForDeoptimization
void JumpIfCodeIsMarkedForDeoptimization(Register code, Register scratch, Label *if_marked_for_deoptimization)
v8::internal::MacroAssembler::LoadF32
void LoadF32(DoubleRegister dst, const MemOperand &opnd)
v8::internal::MacroAssembler::LoadMultipleW
void LoadMultipleW(Register dst1, Register dst2, const MemOperand &mem)
v8::internal::MacroAssembler::Or
void Or(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::NotP
void NotP(Register dst, Register src=no_reg)
v8::internal::MacroAssembler::AllocateStackSpace
void AllocateStackSpace(Register bytes)
Definition macro-assembler-s390.h:1153
v8::internal::MacroAssembler::LoadEntryFromBuiltinIndex
void LoadEntryFromBuiltinIndex(Register builtin_index, Register target)
v8::internal::MacroAssembler::ConvertDoubleToUnsignedInt64
void ConvertDoubleToUnsignedInt64(const Register dst, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::MoveChar
void MoveChar(const MemOperand &opnd1, const MemOperand &opnd2, const Operand &length)
v8::internal::MacroAssembler::AddFloat32
void AddFloat32(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::LoadAndExtend16x4SLE
void LoadAndExtend16x4SLE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::MulHighU32
void MulHighU32(Register dst, Register src1, const Operand &src2)
v8::internal::MacroAssembler::SmiToInt32
void SmiToInt32(Register dst, Register src)
Definition macro-assembler-s390.h:1121
v8::internal::MacroAssembler::XorP
void XorP(Register dst, Register src, const Operand &opnd)
v8::internal::MacroAssembler::StoreU64
void StoreU64(Register src, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::MulFloat64
void MulFloat64(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::MultiPop
void MultiPop(RegList regs, Register location=sp)
v8::internal::MacroAssembler::SubS64
void SubS64(Register dst, Register src, int32_t imm)
v8::internal::MacroAssembler::OrP
void OrP(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::LoadS16LE
void LoadS16LE(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::Move
void Move(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::AddFloat64
void AddFloat64(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::LoadMultipleP
void LoadMultipleP(Register dst1, Register dst2, const MemOperand &mem)
v8::internal::MacroAssembler::ExclusiveOrChar
void ExclusiveOrChar(const MemOperand &opnd1, const MemOperand &opnd2, const Operand &length)
v8::internal::MacroAssembler::JumpIfLessThan
void JumpIfLessThan(Register x, int32_t y, Label *dest)
v8::internal::MacroAssembler::Push
void Push(Register src1, Register src2, Register src3, Register src4)
Definition macro-assembler-s390.h:689
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, Register src, const Operand &imm)
v8::internal::MacroAssembler::AssertBoundFunction
void AssertBoundFunction(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::CeilF64
void CeilF64(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::MulS32
void MulS32(Register dst, const Operand &src1)
v8::internal::MacroAssembler::CmpU32
void CmpU32(Register src1, const Operand &opnd)
v8::internal::MacroAssembler::TestBitMask
void TestBitMask(Register value, uintptr_t mask, Register scratch=r0)
Definition macro-assembler-s390.h:1082
v8::internal::MacroAssembler::PopCallerSaved
int PopCallerSaved(SaveFPRegsMode fp_mode, Register scratch, Register exclusion1=no_reg, Register exclusion2=no_reg, Register exclusion3=no_reg)
v8::internal::MacroAssembler::XorP
void XorP(Register dst, const Operand &opnd)
v8::internal::MacroAssembler::Not64
void Not64(Register dst, Register src=no_reg)
v8::internal::MacroAssembler::AddU64
void AddU64(Register dst, const Operand &imm)
v8::internal::MacroAssembler::SubS32
void SubS32(Register dst, Register src)
v8::internal::MacroAssembler::LoadS32
void LoadS32(Register dst, const MemOperand &opnd, Register scratch=no_reg)
v8::internal::MacroAssembler::CmpU64
void CmpU64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::LoadS8
void LoadS8(Register dst, Register src)
v8::internal::MacroAssembler::CmpU64
void CmpU64(Register src1, Register src2)
v8::internal::MacroAssembler::I16x8GeU
void I16x8GeU(Simd128Register dst, Simd128Register src1, Simd128Register src2, Simd128Register scratch)
v8::internal::MacroAssembler::CompareInstanceTypeRange
void CompareInstanceTypeRange(Register map, Register type_reg, Register scratch, InstanceType lower_limit, InstanceType higher_limit)
v8::internal::MacroAssembler::F64x2ExtractLane
void F64x2ExtractLane(DoubleRegister dst, Simd128Register src, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::OptimizeCodeOrTailCallOptimizedCodeSlot
void OptimizeCodeOrTailCallOptimizedCodeSlot(Register flags, Register feedback_vector)
v8::internal::MacroAssembler::LoadIsolateField
void LoadIsolateField(Register dst, IsolateFieldId id)
v8::internal::MacroAssembler::LoadU64
void LoadU64(Register dst, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::Mul32WithOverflowIfCCUnequal
void Mul32WithOverflowIfCCUnequal(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::ShiftRightU64
void ShiftRightU64(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::MaybeRestoreRegisters
void MaybeRestoreRegisters(RegList registers)
v8::internal::MacroAssembler::CallRecordWriteStub
void CallRecordWriteStub(Register object, Register slot_address, SaveFPRegsMode fp_mode, StubCallMode mode=StubCallMode::kCallBuiltinPointer)
v8::internal::MacroAssembler::StoreF32
void StoreF32(DoubleRegister dst, const MemOperand &opnd)
v8::internal::MacroAssembler::ConvertFloat32ToInt64
void ConvertFloat32ToInt64(const Register dst, const DoubleRegister double_input, FPRoundingMode rounding_mode=kRoundToZero)
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, const Operand &imm)
v8::internal::MacroAssembler::Call
void Call(Register target)
v8::internal::MacroAssembler::MulS32
void MulS32(Register dst, const MemOperand &src1)
v8::internal::MacroAssembler::CmpF64
void CmpF64(DoubleRegister src1, DoubleRegister src2)
v8::internal::MacroAssembler::PrepareCallCFunction
void PrepareCallCFunction(int num_reg_arguments, int num_double_registers, Register scratch)
v8::internal::MacroAssembler::LoadF64
void LoadF64(DoubleRegister result, T value, Register scratch)
Definition macro-assembler-s390.h:865
v8::internal::MacroAssembler::TryLoadOptimizedOsrCode
void TryLoadOptimizedOsrCode(Register scratch_and_result, CodeKind min_opt_level, Register feedback_vector, FeedbackSlot slot, Label *on_result, Label::Distance distance)
v8::internal::MacroAssembler::Jump
void Jump(Address target, RelocInfo::Mode rmode, Condition cond=al)
v8::internal::MacroAssembler::ShiftRightS64
void ShiftRightS64(Register dst, Register src, const Operand &val)
v8::internal::MacroAssembler::I8x16Splat
void I8x16Splat(Simd128Register dst, Register src)
v8::internal::MacroAssembler::Drop
void Drop(Register count, Register scratch=r0)
v8::internal::MacroAssembler::I8x16ReplaceLane
void I8x16ReplaceLane(Simd128Register dst, Simd128Register src1, Register src2, uint8_t imm_lane_idx, Register=r0)
v8::internal::MacroAssembler::AssertUndefinedOrAllocationSite
void AssertUndefinedOrAllocationSite(Register object, Register scratch) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::Jump
void Jump(Handle< Code > code, RelocInfo::Mode rmode, Condition cond=al)
v8::internal::MacroAssembler::Move
void Move(Register dst, ExternalReference reference)
v8::internal::MacroAssembler::CompareTaggedRoot
void CompareTaggedRoot(Register obj, RootIndex index)
v8::internal::MacroAssembler::LoadAndTestP
void LoadAndTestP(Register dst, Register src)
v8::internal::MacroAssembler::FloatMax
void FloatMax(DoubleRegister result_reg, DoubleRegister left_reg, DoubleRegister right_reg)
v8::internal::MacroAssembler::F64x2Splat
void F64x2Splat(Simd128Register dst, Simd128Register src)
v8::internal::MacroAssembler::ShiftRightS64
void ShiftRightS64(Register dst, Register src, Register shift, const Operand &val2=Operand::Zero())
v8::internal::MacroAssembler::StoreMultipleW
void StoreMultipleW(Register dst1, Register dst2, const MemOperand &mem)
v8::internal::MacroAssembler::ConvertIntToFloat
void ConvertIntToFloat(DoubleRegister dst, Register src)
v8::internal::MacroAssembler::MultiPushV128
void MultiPushV128(DoubleRegList dregs, Register scratch, Register location=sp)
v8::internal::MacroAssembler::OrP
void OrP(Register dst, Register src, const Operand &opnd)
v8::internal::MacroAssembler::NearestIntF64
void NearestIntF64(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::LoadU16
void LoadU16(Register dst, Register src)
v8::internal::MacroAssembler::SmiUntagField
void SmiUntagField(Register dst, const MemOperand &src)
v8::internal::MacroAssembler::PopAll
void PopAll(RegList registers)
v8::internal::MacroAssembler::TruncF32
void TruncF32(DoubleRegister dst, DoubleRegister src)
v8::internal::MacroAssembler::DecompressTagged
void DecompressTagged(const Register &destination, Tagged_t immediate)
v8::internal::MacroAssembler::MulHighU64
void MulHighU64(Register dst, Register src1, const MemOperand &src2)
v8::internal::MacroAssembler::DecompressTagged
void DecompressTagged(Register destination, Register source)
v8::internal::MacroAssembler::DecompressTagged
void DecompressTagged(Register destination, MemOperand field_operand)
v8::internal::MacroAssembler::CheckSmi
Condition CheckSmi(Register src)
Definition macro-assembler-s390.h:112
v8::internal::MacroAssembler::DecompressTaggedSigned
void DecompressTaggedSigned(Register destination, Register src)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, Register src, int32_t imm)
v8::internal::MacroAssembler::StoreRootRelative
void StoreRootRelative(int32_t offset, Register value) final
v8::internal::MacroAssembler::DoubleMin
void DoubleMin(DoubleRegister result_reg, DoubleRegister left_reg, DoubleRegister right_reg)
v8::internal::MacroAssembler::Push
void Push(Register src1, Register src2)
Definition macro-assembler-s390.h:674
v8::internal::MacroAssembler::CmpF32
void CmpF32(DoubleRegister src1, DoubleRegister src2)
v8::internal::MacroAssembler::StoreU64
void StoreU64(const MemOperand &mem, const Operand &opnd, Register scratch=no_reg)
v8::internal::MacroAssembler::CmpU64
void CmpU64(Register src1, const Operand &opnd)
v8::internal::MacroAssembler::I64x2Mul
void I64x2Mul(Simd128Register dst, Simd128Register src1, Simd128Register src2, Register scratch1, Register scratch2, Register scratch3)
v8::internal::MacroAssembler::LoadMap
void LoadMap(Register destination, Register object)
v8::internal::MacroAssembler::MovFromFloatResult
void MovFromFloatResult(DoubleRegister dst)
v8::internal::MacroAssembler::CmpP
void CmpP(Register src1, T src2)
Definition macro-assembler-s390.h:423
v8::internal::MacroAssembler::SmiUntag
void SmiUntag(Register dst, const MemOperand &src)
v8::internal::MacroAssembler::CmpAndSwap
void CmpAndSwap(Register old_val, Register new_val, const MemOperand &opnd)
v8::internal::MacroAssembler::TailCallRuntime
void TailCallRuntime(Runtime::FunctionId fid)
v8::internal::MacroAssembler::MultiPopF64OrV128
void MultiPopF64OrV128(DoubleRegList dregs, Register scratch, Register location=sp)
v8::internal::MacroAssembler::XorP
void XorP(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::SmiToPtrArrayOffset
void SmiToPtrArrayOffset(Register dst, Register src)
Definition macro-assembler-s390.h:1530
v8::internal::MacroAssembler::CallRuntime
void CallRuntime(Runtime::FunctionId fid, int num_arguments)
Definition macro-assembler-s390.h:1591
v8::internal::MacroAssembler::TestBit
void TestBit(Register value, int bitNumber, Register scratch=r0)
Definition macro-assembler-s390.h:1070
v8::internal::MacroAssembler::LoadNativeContextSlot
void LoadNativeContextSlot(Register dst, int index)
v8::internal::MacroAssembler::I8x16SConvertI16x8
void I8x16SConvertI16x8(Simd128Register dst, Simd128Register src1, Simd128Register src2)
v8::internal::MacroAssembler::CallRecordWriteStubSaveRegisters
void CallRecordWriteStubSaveRegisters(Register object, Register slot_address, SaveFPRegsMode fp_mode, StubCallMode mode=StubCallMode::kCallBuiltinPointer)
v8::internal::MacroAssembler::AtomicCmpExchangeU8
void AtomicCmpExchangeU8(Register addr, Register output, Register old_value, Register new_value, Register temp0, Register temp1)
v8::internal::MacroAssembler::AddS32
void AddS32(const MemOperand &opnd, const Operand &imm)
v8::internal::MacroAssembler::CallCFunction
int CallCFunction(Register function, int num_arguments, SetIsolateDataSlots set_isolate_data_slots=SetIsolateDataSlots::kYes, bool has_function_descriptor=ABI_USES_FUNCTION_DESCRIPTORS, Label *return_label=nullptr)
v8::internal::MacroAssembler::MulS32
void MulS32(Register dst, Register src1, Register src2)
Definition macro-assembler-s390.h:358
v8::internal::MacroAssembler::TailCallBuiltin
void TailCallBuiltin(Builtin builtin, Condition cond=al)
v8::internal::MacroAssembler::XorP
void XorP(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::AddS64
void AddS64(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::MulFloat32
void MulFloat32(DoubleRegister dst, const MemOperand &opnd, DoubleRegister scratch)
v8::internal::MacroAssembler::Mul32WithOverflowIfCCUnequal
void Mul32WithOverflowIfCCUnequal(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::AtomicExchangeU16
void AtomicExchangeU16(Register addr, Register value, Register output, Register scratch)
v8::internal::MacroAssembler::I32x4TruncSatF64x2UZero
void I32x4TruncSatF64x2UZero(Simd128Register dst, Simd128Register src, Simd128Register scratch)
v8::internal::MacroAssembler::LoadS16
void LoadS16(Register dst, const MemOperand &mem, Register scratch=no_reg)
v8::internal::MacroAssembler::LoadLane8LE
void LoadLane8LE(Simd128Register dst, const MemOperand &mem, int lane, Register scratch)
v8::internal::MacroAssembler::LoadRoot
void LoadRoot(Register destination, RootIndex index) override
Definition macro-assembler-s390.h:263
v8::internal::MacroAssembler::I8x16ExtractLaneS
void I8x16ExtractLaneS(Register dst, Simd128Register src, uint8_t imm_lane_idx, Register scratch)
v8::internal::MacroAssembler::CheckPageFlag
void CheckPageFlag(Register object, Register scratch, int mask, Condition cc, Label *condition_met)
v8::internal::MacroAssembler::LoadV128
void LoadV128(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::CmpS32
void CmpS32(Register src1, Register src2)
v8::internal::MacroAssembler::LoadU32
void LoadU32(Register dst, const MemOperand &opnd, Register scratch=no_reg)
v8::internal::MacroAssembler::ModS64
void ModS64(Register dst, Register src1, Register src2)
v8::internal::MacroAssembler::AndP
void AndP(Register dst, const MemOperand &opnd)
v8::internal::MacroAssembler::I8x16Swizzle
void I8x16Swizzle(Simd128Register dst, Simd128Register src1, Simd128Register src2, Register scratch1, Register scratch2, Simd128Register scratch3)
v8::internal::MacroAssembler::AndP
void AndP(Register dst, Register src)
v8::internal::MacroAssembler::DropArguments
void DropArguments(Register count)
v8::internal::MacroAssembler::LoadTaggedFieldWithoutDecompressing
void LoadTaggedFieldWithoutDecompressing(const Register &destination, const MemOperand &field_operand, const Register &scratch=no_reg)
v8::internal::MacroAssembler::AssertCallableFunction
void AssertCallableFunction(Register object) NOOP_UNLESS_DEBUG_CODE
v8::internal::MacroAssembler::MultiPushDoubles
void MultiPushDoubles(DoubleRegList dregs, Register location=sp)
v8::internal::MacroAssembler::LoadV64ZeroLE
void LoadV64ZeroLE(Simd128Register dst, const MemOperand &mem, Register scratch)
v8::internal::MacroAssembler::AddS32
void AddS32(Register dst, Register src, const Operand &imm)
NOOP_UNLESS_DEBUG_CODE
#define NOOP_UNLESS_DEBUG_CODE
Definition assembler.h:628
COMPRESS_POINTERS_BOOL
#define COMPRESS_POINTERS_BOOL
Definition globals.h:99
ABI_USES_FUNCTION_DESCRIPTORS
#define ABI_USES_FUNCTION_DESCRIPTORS
Definition constants-ppc.h:29
start
int start
Definition debug-coverage.cc:595
end
int end
Definition debug-coverage.cc:596
new_target
DirectHandle< Object > new_target
Definition execution.cc:75
label
Label label
Definition experimental-compiler.cc:532
isolate
Isolate * isolate
Definition graph-builder.cc:67
offset
int32_t offset
Definition instruction-selector-ia32.cc:67
receiver
TNode< Object > receiver
Definition js-call-reducer.cc:1498
rounding_mode
RoundingMode rounding_mode
Definition js-temporal-objects.cc:206
result
ZoneVector< RpoNumber > & result
Definition jump-threading.cc:21
reg
LiftoffRegister reg
Definition liftoff-compiler.cc:512
y
int y
Definition liveedit-diff.cc:60
x
int x
Definition liveedit-diff.cc:60
mask
uint32_t const mask
Definition machine-operator-reducer.cc:2278
PROTOTYPE_SIMD_ALL_TRUE
#define PROTOTYPE_SIMD_ALL_TRUE(name)
Definition macro-assembler-ppc.h:1384
SIMD_UNOP_LIST
#define SIMD_UNOP_LIST(V)
Definition macro-assembler-ppc.h:1325
SIMD_ALL_TRUE_LIST
#define SIMD_ALL_TRUE_LIST(V)
Definition macro-assembler-ppc.h:1378
PROTOTYPE_SIMD_QFM
#define PROTOTYPE_SIMD_QFM(name)
Definition macro-assembler-ppc.h:1396
PROTOTYPE_SIMD_BINOP
#define PROTOTYPE_SIMD_BINOP(name)
Definition macro-assembler-ppc.h:1244
PROTOTYPE_SIMD_SHIFT
#define PROTOTYPE_SIMD_SHIFT(name)
Definition macro-assembler-ppc.h:1304
SIMD_BINOP_LIST
#define SIMD_BINOP_LIST(V)
Definition macro-assembler-ppc.h:1173
SIMD_QFM_LIST
#define SIMD_QFM_LIST(V)
Definition macro-assembler-ppc.h:1391
SIMD_SHIFT_LIST
#define SIMD_SHIFT_LIST(V)
Definition macro-assembler-ppc.h:1290
SIMD_EXT_ADD_PAIRWISE_LIST
#define SIMD_EXT_ADD_PAIRWISE_LIST(V)
Definition macro-assembler-ppc.h:1403
PROTOTYPE_SIMD_EXT_ADD_PAIRWISE
#define PROTOTYPE_SIMD_EXT_ADD_PAIRWISE(name)
Definition macro-assembler-ppc.h:1408
PROTOTYPE_SIMD_UNOP
#define PROTOTYPE_SIMD_UNOP(name)
Definition macro-assembler-ppc.h:1354
SIMD_EXT_MUL_LIST
#define SIMD_EXT_MUL_LIST(V)
Definition macro-assembler-s390.h:1450
PROTOTYPE_SIMD_ADD_SUB_SAT
#define PROTOTYPE_SIMD_ADD_SUB_SAT(name)
Definition macro-assembler-s390.h:1507
PROTOTYPE_SIMD_EXT_MUL
#define PROTOTYPE_SIMD_EXT_MUL(name)
Definition macro-assembler-s390.h:1464
SIMD_ADD_SUB_SAT_LIST
#define SIMD_ADD_SUB_SAT_LIST(V)
Definition macro-assembler-s390.h:1497
SmiCheck
SmiCheck
Definition macro-assembler.h:37
InvokeType
InvokeType
Definition macro-assembler.h:13
SetIsolateDataSlots
SetIsolateDataSlots
Definition macro-assembler.h:49
JumpMode
JumpMode
Definition macro-assembler.h:31
registers
RegListBase< RegisterT > registers
Definition maglev-code-generator.cc:168
destination
InstructionOperand destination
Definition move-optimizer.cc:17
v8::internal::no_reg
constexpr Register no_reg
Definition register-arm.h:87
v8::internal::kRootRegister
constexpr Register kRootRegister
Definition register-arm.h:332
v8::internal::ExitFrameCallerStackSlotOperand
MemOperand ExitFrameCallerStackSlotOperand(int index)
Definition macro-assembler-arm.h:1090
v8::internal::kSmiTagSize
const int kSmiTagSize
Definition v8-internal.h:87
v8::internal::kStackFrameExtraParamSlot
const int kStackFrameExtraParamSlot
Definition register-ppc.h:110
v8::internal::kFloatSize
constexpr int kFloatSize
Definition globals.h:406
v8::internal::Tagged_t
Address Tagged_t
Definition globals.h:547
v8::internal::kSystemPointerSizeLog2
constexpr int kSystemPointerSizeLog2
Definition globals.h:494
v8::internal::kSmiShift
constexpr int kSmiShift
Definition assembler-arm64.h:64
v8::internal::FieldMemOperand
MemOperand FieldMemOperand(Register object, int offset)
Definition macro-assembler-arm.h:32
v8::internal::kSystemPointerSize
constexpr int kSystemPointerSize
Definition globals.h:410
v8::internal::SmiValuesAre31Bits
constexpr bool SmiValuesAre31Bits()
Definition v8-internal.h:208
v8::internal::kHeapObjectTag
const int kHeapObjectTag
Definition v8-internal.h:72
v8::internal::kSmiShiftSize
const int kSmiShiftSize
Definition v8-internal.h:204
v8::internal::v8_flags
V8_EXPORT_PRIVATE FlagValues v8_flags
v8::internal::SmiValuesAre32Bits
constexpr bool SmiValuesAre32Bits()
Definition v8-internal.h:209
v8::internal::kBitsPerSystemPointer
constexpr int kBitsPerSystemPointer
Definition globals.h:684
v8::internal::kPtrComprCageBaseRegister
constexpr Register kPtrComprCageBaseRegister
Definition register-loong64.h:239
v8::internal::CallApiFunctionAndReturn
void CallApiFunctionAndReturn(MacroAssembler *masm, bool with_profiling, Register function_address, ExternalReference thunk_ref, Register thunk_arg, int slots_to_drop_on_return, MemOperand *argc_operand, MemOperand return_value_operand)
Definition macro-assembler-riscv.cc:7850
v8::internal::kSmiTag
const int kSmiTag
Definition v8-internal.h:86
v8::internal::GetRegisterThatIsNotOneOf
Register GetRegisterThatIsNotOneOf(Register reg1, Register reg2=no_reg, Register reg3=no_reg, Register reg4=no_reg, Register reg5=no_reg, Register reg6=no_reg)
Definition macro-assembler-riscv.cc:7372
v8::internal::kDoubleSize
constexpr int kDoubleSize
Definition globals.h:407
v8::internal::ExitFrameStackSlotOperand
MemOperand ExitFrameStackSlotOperand(int offset)
Definition macro-assembler-arm.h:1081
DCHECK_GE
#define DCHECK_GE(v1, v2)
Definition logging.h:488
DCHECK
#define DCHECK(condition)
Definition logging.h:482
V8_EXPORT_PRIVATE
#define V8_EXPORT_PRIVATE
Definition macros.h:460