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