Lines Matching full:heap
59 // Check if the operand is a heap number.
64 __ LoadRoot(scratch2, Heap::kHeapNumberMapRootIndex);
116 __ LoadRoot(a1, Heap::kEmptyFixedArrayRootIndex);
117 __ LoadRoot(a2, Heap::kTheHoleValueRootIndex);
118 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
138 __ LoadRoot(t0, Heap::kFalseValueRootIndex);
161 __ LoadRoot(a1, Heap::kFunctionContextMapRootIndex);
175 __ LoadRoot(a1, Heap::kUndefinedValueRootIndex);
209 __ LoadRoot(a2, Heap::kBlockContextMapRootIndex);
237 __ LoadRoot(a1, Heap::kTheHoleValueRootIndex);
316 __ LoadRoot(t1, Heap::kUndefinedValueRootIndex);
324 __ LoadRoot(t1, Heap::kFixedCOWArrayMapRootIndex);
332 __ LoadRoot(t1, Heap::kFixedArrayMapRootIndex);
346 Heap::RootListIndex expected_map_index;
349 expected_map_index = Heap::kFixedArrayMapRootIndex;
352 expected_map_index = Heap::kFixedDoubleArrayMapRootIndex;
356 expected_map_index = Heap::kFixedCOWArrayMapRootIndex;
393 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
580 Heap::kHeapNumberMapRootIndex,
588 // Heap number check
591 // Handle loading a double from a heap number.
603 // Load the double from heap number to dst1 and dst2 in double format.
646 Heap::kHeapNumberMapRootIndex,
786 Heap::kHeapNumberMapRootIndex,
857 Heap::kHeapNumberMapRootIndex,
862 // Object is a heap number.
1012 // Store answer in the overwritable heap number.
1130 // Smis. If it's not a heap number, then return equal.
1145 __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
1177 // It is a heap number, so return non-equal if it's NaN and equal if it's
1228 // Check whether the non-smi is a heap number.
1236 // Smi compared non-strictly with a non-Smi non-heap-number. Call
1267 // Lhs is a Smi. Check whether the non-smi is a heap number.
1275 // Smi compared non-strictly with a non-Smi non-heap-number. Call
1503 // If first was a heap number & second wasn't, go to slow case.
1506 // Both are heap numbers. Load them up then jump to the code we have
1585 __ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
1597 // Heap::GetNumberStringCache.
1607 Heap::kHeapNumberMapRootIndex,
1793 // Check for heap-number-heap-number comparison. Can jump to slow case,
1874 CheckOddball(masm, UNDEFINED, Heap::kUndefinedValueRootIndex, false);
1877 CheckOddball(masm, BOOLEAN, Heap::kFalseValueRootIndex, false);
1878 CheckOddball(masm, BOOLEAN, Heap::kTrueValueRootIndex, true);
1881 CheckOddball(masm, NULL_TYPE, Heap::kNullValueRootIndex, false);
1923 // Heap number -> false iff +0, -0, or NaN.
1925 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
1947 Heap::RootListIndex value,
2149 // a0 is a heap number. Get a new heap number in a1.
2186 // Convert the heap number in a0 to an untagged integer in a1.
2199 // Try to store the result in a heap number.
2203 // Allocate a new heap number without zapping v0, which we need if it fails.
2210 __ push(v0); // Push the heap number, not the untagged int32.
2212 __ mov(a2, v0); // Move the new heap number into a2.
2213 // Get the heap number into v0, now that the new heap number is in a2.
2217 // Convert the heap number in v0 to an untagged integer in a1.
2225 __ mov(v0, a2); // Move newly allocated heap number to v0.
2229 // Convert the int32 in a1 to the heap number in v0. a2 is corrupted.
2548 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
2564 // Allocate new heap number for result.
2673 // The code below for writing into heap numbers isn't capable of
2696 // Allocate new heap number for result.
2708 // t1: Heap number to write answer into.
2710 // Nothing can go wrong now, so move the heap number to v0, which is the
2715 // Convert the int32 in a2 to the heap number in a0. As
2730 // Tail call that writes the int32 in a2 to the heap number in v0, using
2744 // generated. If the result is not a smi and heap number allocation is not
2746 // heap number cannot be allocated the code jumps to the lable gc_required.
2766 // If heap number results are possible generate the result in an allocated
2767 // heap number.
2783 // Allow heap number result and don't make a transition if a heap number
2791 // Code falls through if the result is not returned as either a smi or heap
2851 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
2927 // Otherwise return a heap number if allowed, or jump to type
2945 // If not try to return a heap number.
2947 // Check for minus zero. Return heap number for minus zero.
2959 // DIV just falls through to allocating a heap number.
2963 // Return a heap number, or fall through to type transition or runtime
2990 // Allocate a heap number to store the result.
3069 // to return a heap number if we can.
3098 // If not try to return a heap number. (We know the result is an int32.)
3131 // Tail call that writes the int32 in a2 to the heap number in v0, using
3170 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
3175 __ LoadRoot(a1, Heap::kNanValueRootIndex);
3179 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
3184 __ LoadRoot(a0, Heap::kNanValueRootIndex);
3307 // allocation of a heap number.
3309 // Allocate a heap number for the result.
3335 // tagged result (heap number) goes into v0.
3366 Heap::kHeapNumberMapRootIndex,
3471 // heap number, we return the result without updating.
3473 __ LoadRoot(t1, Heap::kHeapNumberMapRootIndex);
3487 __ LoadRoot(t1, Heap::kHeapNumberMapRootIndex);
3607 __ LoadRoot(heapnumbermap, Heap::kHeapNumberMapRootIndex);
3771 // as heap number in exponent.
3952 __ LoadRoot(a3, Heap::kTheHoleValueRootIndex);
3960 __ LoadRoot(t0, Heap::kTerminationExceptionRootIndex);
4161 __ LoadRoot(t1, Heap::kTheHoleValueRootIndex);
4274 __ LoadRoot(at, Heap::kInstanceofCacheFunctionRootIndex);
4276 __ LoadRoot(at, Heap::kInstanceofCacheMapRootIndex);
4278 __ LoadRoot(v0, Heap::kInstanceofCacheAnswerRootIndex);
4294 __ StoreRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
4295 __ StoreRoot(map, Heap::kInstanceofCacheMapRootIndex);
4318 __ LoadRoot(scratch2, Heap::kNullValueRootIndex);
4330 __ StoreRoot(v0, Heap::kInstanceofCacheAnswerRootIndex);
4333 __ LoadRoot(v0, Heap::kTrueValueRootIndex);
4348 __ StoreRoot(v0, Heap::kInstanceofCacheAnswerRootIndex);
4351 __ LoadRoot(v0, Heap::kFalseValueRootIndex);
4405 __ LoadRoot(v0, Heap::kTrueValueRootIndex);
4407 __ LoadRoot(v0, Heap::kFalseValueRootIndex);
4562 __ Addu(t5, t5, Operand(Heap::kArgumentsObjectSize));
4597 STATIC_ASSERT(Heap::kArgumentsCalleeIndex == 1);
4600 Heap::kArgumentsCalleeIndex * kPointerSize;
4604 STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);
4606 Heap
4612 __ Addu(t0, v0, Operand(Heap::kArgumentsObjectSize));
4630 __ LoadRoot(t2, Heap::kNonStrictArgumentsElementsMapRootIndex);
4653 __ LoadRoot(t3, Heap::kTheHoleValueRootIndex);
4684 __ LoadRoot(t1, Heap::kFixedArrayMapRootIndex);
4753 __ Addu(a1, a1, Operand(Heap::kArgumentsObjectSizeStrict / kPointerSize));
4774 STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);
4777 Heap::kArgumentsLengthIndex * kPointerSize));
4787 __ Addu(t0, v0, Operand(Heap::kArgumentsObjectSizeStrict));
4789 __ LoadRoot(a3, Heap::kFixedArrayMapRootIndex);
4997 __ LoadRoot(a1, Heap::kEmptyStringRootIndex);
5146 __ LoadRoot(a0, Heap::kTerminationExceptionRootIndex);
5353 masm->isolate()->heap()->undefined_value());
5355 masm->isolate()->heap()->the_hole_value());
5363 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5368 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
5379 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5400 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
5422 __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
5596 // If index is a heap number, try converting it to an integer.
5599 Heap::kHeapNumberMapRootIndex,
5649 // Fast case of Heap::LookupSingleCharacterStringFromCode.
5663 __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
5669 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
5906 __ LoadRoot(symbol_table, Heap::kSymbolTableRootIndex);
5909 __ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);
5960 __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
5998 __ LoadRoot(hash, Heap::kHashSeedRootIndex);
6145 __ LoadRoot(t0, Heap::kEmptyStringRootIndex);
6837 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
6846 __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
6865 // Check that both operands are heap objects.
6908 // Check that both operands are heap objects.
7130 __ LoadRoot(tmp, Heap::kUndefinedValueRootIndex);
7135 __ LoadRoot(tmp, Heap::kTheHoleValueRootIndex);
7285 __ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);
7448 // incremental heap marking.
