1 Remove unnecessary functions for memory.

     2 Do not plan to send upstream.

     3 

     4 diff --git a/js/src/gc/Memory.cpp b/js/src/gc/Memory.cpp

     5 --- a/js/src/gc/Memory.cpp

     6 +++ b/js/src/gc/Memory.cpp

     7 @@ -12,21 +12,16 @@

     8  #include "js/HeapAPI.h"

     9  #include "vm/Runtime.h"

    10  

    11  #if defined(XP_WIN)

    12  

    13  #include "jswin.h"

    14  #include <psapi.h>

    15  

    16 -#elif defined(SOLARIS)

    17 -

    18 -#include <sys/mman.h>

    19 -#include <unistd.h>

    20 -

    21  #elif defined(XP_UNIX)

    22  

    23  #include <algorithm>

    24  #include <errno.h>

    25  #include <sys/mman.h>

    26  #include <sys/resource.h>

    27  #include <sys/stat.h>

    28  #include <sys/types.h>

    29 @@ -346,85 +346,6 @@ DeallocateMappedContent(void* p, size_t

    30      // TODO: Bug 988813 - Support memory mapped array buffer for Windows platform.

    31  }

    32  

    33 -#elif defined(SOLARIS)

    34 -

    35 -#ifndef MAP_NOSYNC

    36 -# define MAP_NOSYNC 0

    37 -#endif

    38 -

    39 -void

    40 -InitMemorySubsystem()

    41 -{

    42 -    if (pageSize == 0)

    43 -        pageSize = allocGranularity = size_t(sysconf(_SC_PAGESIZE));

    44 -}

    45 -

    46 -void*

    47 -MapAlignedPages(size_t size, size_t alignment)

    48 -{

    49 -    MOZ_ASSERT(size >= alignment);

    50 -    MOZ_ASSERT(size % alignment == 0);

    51 -    MOZ_ASSERT(size % pageSize == 0);

    52 -    MOZ_ASSERT(alignment % allocGranularity == 0);

    53 -

    54 -    int prot = PROT_READ | PROT_WRITE;

    55 -    int flags = MAP_PRIVATE | MAP_ANON | MAP_ALIGN | MAP_NOSYNC;

    56 -

    57 -    void* p = mmap((caddr_t)alignment, size, prot, flags, -1, 0);

    58 -    if (p == MAP_FAILED)

    59 -        return nullptr;

    60 -    return p;

    61 -}

    62 -

    63 -static void*

    64 -MapAlignedPagesLastDitch(size_t size, size_t alignment)

    65 -{

    66 -    return nullptr;

    67 -}

    68 -

    69 -void

    70 -UnmapPages(void* p, size_t size)

    71 -{

    72 -    MOZ_ALWAYS_TRUE(0 == munmap((caddr_t)p, size));

    73 -}

    74 -

    75 -bool

    76 -MarkPagesUnused(void* p, size_t size)

    77 -{

    78 -    MOZ_ASSERT(OffsetFromAligned(p, pageSize) == 0);

    79 -    return true;

    80 -}

    81 -

    82 -bool

    83 -MarkPagesInUse(void* p, size_t size)

    84 -{

    85 -    if (!DecommitEnabled())

    86 -        return true;

    87 -

    88 -    MOZ_ASSERT(OffsetFromAligned(p, pageSize) == 0);

    89 -    return true;

    90 -}

    91 -

    92 -size_t

    93 -GetPageFaultCount()

    94 -{

    95 -    return 0;

    96 -}

    97 -

    98 -void*

    99 -AllocateMappedContent(int fd, size_t offset, size_t length, size_t alignment)

   100 -{

   101 -    // Not implemented.

   102 -    return nullptr;

   103 -}

   104 -

   105 -// Deallocate mapped memory for object.

   106 -void

   107 -DeallocateMappedContent(void* p, size_t length)

   108 -{

   109 -    // Not implemented.

   110 -}

   111 -

   112  #elif defined(XP_UNIX)

   113  

   114  void

   115 @@ -599,17 +521,17 @@ UnmapPages(void* p, size_t size)

   116  

   117  bool

   118  MarkPagesUnused(void* p, size_t size)

   119  {

   120      if (!DecommitEnabled())

   121          return false;

   122  

   123      MOZ_ASSERT(OffsetFromAligned(p, pageSize) == 0);

   124 -    int result = madvise(p, size, MADV_DONTNEED);

   125 +    int result = madvise((caddr_t)p, size, MADV_DONTNEED);

   126      return result != -1;

   127  }

   128  

   129  bool

   130  MarkPagesInUse(void* p, size_t size)

   131  {

   132      if (!DecommitEnabled())

   133          return true;