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 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 29 void Malloced::Delete(void* p) { 30 free(p); 31 } 32 33 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 43 void* Embedded::operator new(size_t size) { 44 UNREACHABLE(); 45 return invalid; 46 } 47 48 49 void Embedded::operator delete(void* p) { 50 UNREACHABLE(); 51 } 52 53 54 void* AllStatic::operator new(size_t size) { 55 UNREACHABLE(); 56 return invalid; 57 } 58 59 60 void AllStatic::operator delete(void* p) { 61 UNREACHABLE(); 62 } 63 64 #endif 65 66 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 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 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 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