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
3 // found in the LICENSE file.
4
5 #include "src/allocation.h"
6
7 #include <stdlib.h> // For free, malloc.
8 #include "src/base/bits.h"
9 #include "src/base/logging.h"
10 #include "src/base/platform/platform.h"
11 #include "src/utils.h"
12
13 #if V8_LIBC_BIONIC
14 #include <malloc.h> // NOLINT
15 #endif
16
17 namespace v8 {
18 namespace internal {
19
New(size_t size)20 void* Malloced::New(size_t size) {
21 void* result = malloc(size);
22 if (result == NULL) {
23 v8::internal::FatalProcessOutOfMemory("Malloced operator new");
24 }
25 return result;
26 }
27
28
Delete(void * p)29 void Malloced::Delete(void* p) {
30 free(p);
31 }
32
33
FatalProcessOutOfMemory()34 void Malloced::FatalProcessOutOfMemory() {
35 v8::internal::FatalProcessOutOfMemory("Out of memory");
36 }
37
38
39 #ifdef DEBUG
40
41 static void* invalid = static_cast<void*>(NULL);
42
operator new(size_t size)43 void* Embedded::operator new(size_t size) {
44 UNREACHABLE();
45 return invalid;
46 }
47
48
operator delete(void * p)49 void Embedded::operator delete(void* p) {
50 UNREACHABLE();
51 }
52
53
operator new(size_t size)54 void* AllStatic::operator new(size_t size) {
55 UNREACHABLE();
56 return invalid;
57 }
58
59
operator delete(void * p)60 void AllStatic::operator delete(void* p) {
61 UNREACHABLE();
62 }
63
64 #endif
65
66
StrDup(const char * str)67 char* StrDup(const char* str) {
68 int length = StrLength(str);
69 char* result = NewArray<char>(length + 1);
70 MemCopy(result, str, length);
71 result[length] = '\0';
72 return result;
73 }
74
75
StrNDup(const char * str,int n)76 char* StrNDup(const char* str, int n) {
77 int length = StrLength(str);
78 if (n < length) length = n;
79 char* result = NewArray<char>(length + 1);
80 MemCopy(result, str, length);
81 result[length] = '\0';
82 return result;
83 }
84
85
AlignedAlloc(size_t size,size_t alignment)86 void* AlignedAlloc(size_t size, size_t alignment) {
87 DCHECK_LE(V8_ALIGNOF(void*), alignment);
88 DCHECK(base::bits::IsPowerOfTwo32(alignment));
89 void* ptr;
90 #if V8_OS_WIN
91 ptr = _aligned_malloc(size, alignment);
92 #elif V8_LIBC_BIONIC
93 // posix_memalign is not exposed in some Android versions, so we fall back to
94 // memalign. See http://code.google.com/p/android/issues/detail?id=35391.
95 ptr = memalign(alignment, size);
96 #else
97 if (posix_memalign(&ptr, alignment, size)) ptr = NULL;
98 #endif
99 if (ptr == NULL) FatalProcessOutOfMemory("AlignedAlloc");
100 return ptr;
101 }
102
103
AlignedFree(void * ptr)104 void AlignedFree(void *ptr) {
105 #if V8_OS_WIN
106 _aligned_free(ptr);
107 #elif V8_LIBC_BIONIC
108 // Using free is not correct in general, but for V8_LIBC_BIONIC it is.
109 free(ptr);
110 #else
111 free(ptr);
112 #endif
113 }
114
115 } } // namespace v8::internal
116