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