| OLD | NEW |
| 1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #include <limits.h> // For LONG_MIN, LONG_MAX. | 5 #include <limits.h> // For LONG_MIN, LONG_MAX. |
| 6 | 6 |
| 7 #include "src/v8.h" | 7 #include "src/v8.h" |
| 8 | 8 |
| 9 #if V8_TARGET_ARCH_ARM | 9 #if V8_TARGET_ARCH_ARM |
| 10 | 10 |
| (...skipping 1694 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1705 cmp(result, ip); | 1705 cmp(result, ip); |
| 1706 Check(eq, kUnexpectedAllocationTop); | 1706 Check(eq, kUnexpectedAllocationTop); |
| 1707 } | 1707 } |
| 1708 // Load allocation limit into ip. Result already contains allocation top. | 1708 // Load allocation limit into ip. Result already contains allocation top. |
| 1709 ldr(ip, MemOperand(topaddr, limit - top)); | 1709 ldr(ip, MemOperand(topaddr, limit - top)); |
| 1710 } | 1710 } |
| 1711 | 1711 |
| 1712 if ((flags & DOUBLE_ALIGNMENT) != 0) { | 1712 if ((flags & DOUBLE_ALIGNMENT) != 0) { |
| 1713 // Align the next allocation. Storing the filler map without checking top is | 1713 // Align the next allocation. Storing the filler map without checking top is |
| 1714 // safe in new-space because the limit of the heap is aligned there. | 1714 // safe in new-space because the limit of the heap is aligned there. |
| 1715 DCHECK((flags & PRETENURE_OLD_POINTER_SPACE) == 0); | |
| 1716 STATIC_ASSERT(kPointerAlignment * 2 == kDoubleAlignment); | 1715 STATIC_ASSERT(kPointerAlignment * 2 == kDoubleAlignment); |
| 1717 and_(scratch2, result, Operand(kDoubleAlignmentMask), SetCC); | 1716 and_(scratch2, result, Operand(kDoubleAlignmentMask), SetCC); |
| 1718 Label aligned; | 1717 Label aligned; |
| 1719 b(eq, &aligned); | 1718 b(eq, &aligned); |
| 1720 if ((flags & PRETENURE_OLD_DATA_SPACE) != 0) { | 1719 if ((flags & PRETENURE) != 0) { |
| 1721 cmp(result, Operand(ip)); | 1720 cmp(result, Operand(ip)); |
| 1722 b(hs, gc_required); | 1721 b(hs, gc_required); |
| 1723 } | 1722 } |
| 1724 mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map())); | 1723 mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map())); |
| 1725 str(scratch2, MemOperand(result, kDoubleSize / 2, PostIndex)); | 1724 str(scratch2, MemOperand(result, kDoubleSize / 2, PostIndex)); |
| 1726 bind(&aligned); | 1725 bind(&aligned); |
| 1727 } | 1726 } |
| 1728 | 1727 |
| 1729 // Calculate new top and bail out if new space is exhausted. Use result | 1728 // Calculate new top and bail out if new space is exhausted. Use result |
| 1730 // to calculate the new top. We must preserve the ip register at this | 1729 // to calculate the new top. We must preserve the ip register at this |
| (...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1819 cmp(result, ip); | 1818 cmp(result, ip); |
| 1820 Check(eq, kUnexpectedAllocationTop); | 1819 Check(eq, kUnexpectedAllocationTop); |
| 1821 } | 1820 } |
| 1822 // Load allocation limit into ip. Result already contains allocation top. | 1821 // Load allocation limit into ip. Result already contains allocation top. |
| 1823 ldr(ip, MemOperand(topaddr, limit - top)); | 1822 ldr(ip, MemOperand(topaddr, limit - top)); |
| 1824 } | 1823 } |
| 1825 | 1824 |
| 1826 if ((flags & DOUBLE_ALIGNMENT) != 0) { | 1825 if ((flags & DOUBLE_ALIGNMENT) != 0) { |
| 1827 // Align the next allocation. Storing the filler map without checking top is | 1826 // Align the next allocation. Storing the filler map without checking top is |
| 1828 // safe in new-space because the limit of the heap is aligned there. | 1827 // safe in new-space because the limit of the heap is aligned there. |
| 1829 DCHECK((flags & PRETENURE_OLD_POINTER_SPACE) == 0); | |
| 1830 DCHECK(kPointerAlignment * 2 == kDoubleAlignment); | 1828 DCHECK(kPointerAlignment * 2 == kDoubleAlignment); |
| 1831 and_(scratch2, result, Operand(kDoubleAlignmentMask), SetCC); | 1829 and_(scratch2, result, Operand(kDoubleAlignmentMask), SetCC); |
| 1832 Label aligned; | 1830 Label aligned; |
| 1833 b(eq, &aligned); | 1831 b(eq, &aligned); |
| 1834 if ((flags & PRETENURE_OLD_DATA_SPACE) != 0) { | 1832 if ((flags & PRETENURE) != 0) { |
| 1835 cmp(result, Operand(ip)); | 1833 cmp(result, Operand(ip)); |
| 1836 b(hs, gc_required); | 1834 b(hs, gc_required); |
| 1837 } | 1835 } |
| 1838 mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map())); | 1836 mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map())); |
| 1839 str(scratch2, MemOperand(result, kDoubleSize / 2, PostIndex)); | 1837 str(scratch2, MemOperand(result, kDoubleSize / 2, PostIndex)); |
| 1840 bind(&aligned); | 1838 bind(&aligned); |
| 1841 } | 1839 } |
| 1842 | 1840 |
| 1843 // Calculate new top and bail out if new space is exhausted. Use result | 1841 // Calculate new top and bail out if new space is exhausted. Use result |
| 1844 // to calculate the new top. Object size may be in words so a shift is | 1842 // to calculate the new top. Object size may be in words so a shift is |
| (...skipping 2066 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 3911 } | 3909 } |
| 3912 } | 3910 } |
| 3913 if (mag.shift > 0) mov(result, Operand(result, ASR, mag.shift)); | 3911 if (mag.shift > 0) mov(result, Operand(result, ASR, mag.shift)); |
| 3914 add(result, result, Operand(dividend, LSR, 31)); | 3912 add(result, result, Operand(dividend, LSR, 31)); |
| 3915 } | 3913 } |
| 3916 | 3914 |
| 3917 } // namespace internal | 3915 } // namespace internal |
| 3918 } // namespace v8 | 3916 } // namespace v8 |
| 3919 | 3917 |
| 3920 #endif // V8_TARGET_ARCH_ARM | 3918 #endif // V8_TARGET_ARCH_ARM |
| OLD | NEW |