add diff patch

remove RODataMem.FreeMem.clear(); and replace return true to RELEASE_ASSERT(0, "finalizeMemory failed")

llvm_patches/0014-PATCH-SectionMemoryManger-Make-better-use-of-virtual.patch

+From b7035692e3abd5d5b6781d59d17f8a5cf98297f9 Mon Sep 17 00:00:00 2001
+From: Dong-hee Na <corona10@gmail.com>
+Date: Tue, 20 Sep 2016 23:11:35 +0900
+Subject: [PATCH] [PATCH] SectionMemoryManger: Make better use of virtual
+ memory
+
+---
+ lib/Support/Unix/Memory.inc | 19 ++++++++-----------
+ 1 file changed, 8 insertions(+), 11 deletions(-)
+
+diff --git a/lib/Support/Unix/Memory.inc b/lib/Support/Unix/Memory.inc
+index c421ee8..f3463e5 100644
+--- a/lib/Support/Unix/Memory.inc
++++ b/lib/Support/Unix/Memory.inc
+@@ -50,9 +50,8 @@ int getPosixProtectionFlags(unsigned Flags) {
+     return PROT_READ | PROT_WRITE;
+   case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
+     return PROT_READ | PROT_EXEC;
+-  case llvm::sys::Memory::MF_READ |
+-	 llvm::sys::Memory::MF_WRITE |
+-	 llvm::sys::Memory::MF_EXEC:
++  case llvm::sys::Memory::MF_READ | llvm::sys::Memory::MF_WRITE |
++      llvm::sys::Memory::MF_EXEC:
+     return PROT_READ | PROT_WRITE | PROT_EXEC;
+   case llvm::sys::Memory::MF_EXEC:
+ #if defined(__FreeBSD__)
+@@ -74,7 +73,7 @@ int getPosixProtectionFlags(unsigned Flags) {
+   return PROT_NONE;
+ }
+ 
+-} // namespace
++} // anonymous namespace
+ 
+ namespace llvm {
+ namespace sys {
+@@ -153,6 +152,7 @@ Memory::releaseMappedMemory(MemoryBlock &M) {
+ 
+ std::error_code
+ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
++  static const size_t PageSize = Process::getPageSize();
+   if (M.Address == nullptr || M.Size == 0)
+     return std::error_code();
+ 
+@@ -161,7 +161,7 @@ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
+ 
+   int Protect = getPosixProtectionFlags(Flags);
+ 
+-  int Result = ::mprotect(M.Address, M.Size, Protect);
++  int Result = ::mprotect((void*)((uintptr_t)M.Address & ~(PageSize-1)), PageSize*((M.Size+PageSize-1)/PageSize), Protect);
+   if (Result != 0)
+     return std::error_code(errno, std::generic_category());
+ 
+@@ -181,7 +181,7 @@ Memory::AllocateRWX(size_t NumBytes, const MemoryBlock* NearBlock,
+                     std::string *ErrMsg) {
+   if (NumBytes == 0) return MemoryBlock();
+ 
+-  size_t PageSize = Process::getPageSize();
++  static const size_t PageSize = Process::getPageSize();
+   size_t NumPages = (NumBytes+PageSize-1)/PageSize;
+ 
+   int fd = -1;
+@@ -265,15 +265,12 @@ bool Memory::setWritable (MemoryBlock &M, std::string *ErrMsg) {
+ }
+ 
+ bool Memory::setExecutable (MemoryBlock &M, std::string *ErrMsg) {
+-#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
+-  if (M.Address == 0 || M.Size == 0) return false;
++  if (M.Address == nullptr || M.Size == 0) return false;
+   Memory::InvalidateInstructionCache(M.Address, M.Size);
++#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
+   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)M.Address,
+     (vm_size_t)M.Size, 0, VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
+   return KERN_SUCCESS == kr;
+-#elif defined(__arm__) || defined(__aarch64__)
+-  Memory::InvalidateInstructionCache(M.Address, M.Size);
+-  return true;
+ #else
+   return true;
+ #endif
+-- 
+2.7.4
+

llvm_patches/0015-Update-STLExtra-to-support-STL-operation.patch

+From d6df8d7e08ef91811fea5a16f1aa10bbf22a43d9 Mon Sep 17 00:00:00 2001
+From: Dong-hee Na <corona10@gmail.com>
+Date: Tue, 20 Sep 2016 23:38:39 +0900
+Subject: [PATCH 8/8] Update STLExtra to support STL operation
+
+---
+ include/llvm/ADT/STLExtras.h | 300 ++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 271 insertions(+), 29 deletions(-)
+
+diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h
+index 57af18e..e6215e4 100644
+--- a/include/llvm/ADT/STLExtras.h
++++ b/include/llvm/ADT/STLExtras.h
+@@ -17,7 +17,7 @@
+ #ifndef LLVM_ADT_STLEXTRAS_H
+ #define LLVM_ADT_STLEXTRAS_H
+ 
+-#include "llvm/Support/Compiler.h"
++#include <algorithm> // for std::all_of
+ #include <cassert>
+ #include <cstddef> // for std::size_t
+ #include <cstdlib> // for qsort
+@@ -26,7 +26,18 @@
+ #include <memory>
+ #include <utility> // for std::pair
+ 
++#include "llvm/ADT/Optional.h"
++#include "llvm/ADT/iterator.h"
++#include "llvm/ADT/iterator_range.h"
++#include "llvm/Support/Compiler.h"
++
+ namespace llvm {
++namespace detail {
++
++template <typename RangeT>
++using IterOfRange = decltype(std::begin(std::declval<RangeT>()));
++
++} // End detail namespace
+ 
+ //===----------------------------------------------------------------------===//
+ //     Extra additions to <functional>
+@@ -116,14 +127,15 @@ public:
+           iterator_category;
+   typedef typename std::iterator_traits<RootIt>::difference_type
+           difference_type;
+-  typedef typename UnaryFunc::result_type value_type;
++  typedef typename std::result_of<
++            UnaryFunc(decltype(*std::declval<RootIt>()))>
++          ::type value_type;
+ 
+   typedef void pointer;
+   //typedef typename UnaryFunc::result_type *pointer;
+   typedef void reference;        // Can't modify value returned by fn
+ 
+   typedef RootIt iterator_type;
+-  typedef mapped_iterator<RootIt, UnaryFunc> _Self;
+ 
+   inline const RootIt &getCurrent() const { return current; }
+   inline const UnaryFunc &getFunc() const { return Fn; }
+@@ -135,34 +147,56 @@ public:
+     return Fn(*current);         // little change
+   }
+ 
+-  _Self& operator++() { ++current; return *this; }
+-  _Self& operator--() { --current; return *this; }
+-  _Self  operator++(int) { _Self __tmp = *this; ++current; return __tmp; }
+-  _Self  operator--(int) { _Self __tmp = *this; --current; return __tmp; }
+-  _Self  operator+    (difference_type n) const {
+-    return _Self(current + n, Fn);
++  mapped_iterator &operator++() {
++    ++current;
++    return *this;
++  }
++  mapped_iterator &operator--() {
++    --current;
++    return *this;
++  }
++  mapped_iterator operator++(int) {
++    mapped_iterator __tmp = *this;
++    ++current;
++    return __tmp;
++  }
++  mapped_iterator operator--(int) {
++    mapped_iterator __tmp = *this;
++    --current;
++    return __tmp;
+   }
+-  _Self& operator+=   (difference_type n) { current += n; return *this; }
+-  _Self  operator-    (difference_type n) const {
+-    return _Self(current - n, Fn);
++  mapped_iterator operator+(difference_type n) const {
++    return mapped_iterator(current + n, Fn);
++  }
++  mapped_iterator &operator+=(difference_type n) {
++    current += n;
++    return *this;
++  }
++  mapped_iterator operator-(difference_type n) const {
++    return mapped_iterator(current - n, Fn);
++  }
++  mapped_iterator &operator-=(difference_type n) {
++    current -= n;
++    return *this;
+   }
+-  _Self& operator-=   (difference_type n) { current -= n; return *this; }
+   reference operator[](difference_type n) const { return *(*this + n); }
+ 
+-  inline bool operator!=(const _Self &X) const { return !operator==(X); }
+-  inline bool operator==(const _Self &X) const { return current == X.current; }
+-  inline bool operator< (const _Self &X) const { return current <  X.current; }
++  bool operator!=(const mapped_iterator &X) const { return !operator==(X); }
++  bool operator==(const mapped_iterator &X) const {
++    return current == X.current;
++  }
++  bool operator<(const mapped_iterator &X) const { return current < X.current; }
+ 
+-  inline difference_type operator-(const _Self &X) const {
++  difference_type operator-(const mapped_iterator &X) const {
+     return current - X.current;
+   }
+ };
+ 
+-template <class _Iterator, class Func>
+-inline mapped_iterator<_Iterator, Func>
+-operator+(typename mapped_iterator<_Iterator, Func>::difference_type N,
+-          const mapped_iterator<_Iterator, Func>& X) {
+-  return mapped_iterator<_Iterator, Func>(X.getCurrent() - N, X.getFunc());
++template <class Iterator, class Func>
++inline mapped_iterator<Iterator, Func>
++operator+(typename mapped_iterator<Iterator, Func>::difference_type N,
++          const mapped_iterator<Iterator, Func> &X) {
++  return mapped_iterator<Iterator, Func>(X.getCurrent() - N, X.getFunc());
+ }
+ 
+ 
+@@ -174,6 +208,138 @@ inline mapped_iterator<ItTy, FuncTy> map_iterator(const ItTy &I, FuncTy F) {
+   return mapped_iterator<ItTy, FuncTy>(I, F);
+ }
+ 
++/// Helper to determine if type T has a member called rbegin().
++template <typename Ty> class has_rbegin_impl {
++  typedef char yes[1];
++  typedef char no[2];
++
++  template <typename Inner>
++  static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
++
++  template <typename>
++  static no& test(...);
++
++public:
++  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
++};
++
++/// Metafunction to determine if T& or T has a member called rbegin().
++template <typename Ty>
++struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
++};
++
++// Returns an iterator_range over the given container which iterates in reverse.
++// Note that the container must have rbegin()/rend() methods for this to work.
++template <typename ContainerTy>
++auto reverse(ContainerTy &&C,
++             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
++                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
++  return make_range(C.rbegin(), C.rend());
++}
++
++// Returns a std::reverse_iterator wrapped around the given iterator.
++template <typename IteratorTy>
++std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
++  return std::reverse_iterator<IteratorTy>(It);
++}
++
++// Returns an iterator_range over the given container which iterates in reverse.
++// Note that the container must have begin()/end() methods which return
++// bidirectional iterators for this to work.
++template <typename ContainerTy>
++auto reverse(
++    ContainerTy &&C,
++    typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
++    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
++                           llvm::make_reverse_iterator(std::begin(C)))) {
++  return make_range(llvm::make_reverse_iterator(std::end(C)),
++                    llvm::make_reverse_iterator(std::begin(C)));
++}
++
++/// An iterator adaptor that filters the elements of given inner iterators.
++///
++/// The predicate parameter should be a callable object that accepts the wrapped
++/// iterator's reference type and returns a bool. When incrementing or
++/// decrementing the iterator, it will call the predicate on each element and
++/// skip any where it returns false.
++///
++/// \code
++///   int A[] = { 1, 2, 3, 4 };
++///   auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
++///   // R contains { 1, 3 }.
++/// \endcode
++template <typename WrappedIteratorT, typename PredicateT>
++class filter_iterator
++    : public iterator_adaptor_base<
++          filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
++          typename std::common_type<
++              std::forward_iterator_tag,
++              typename std::iterator_traits<
++                  WrappedIteratorT>::iterator_category>::type> {
++  using BaseT = iterator_adaptor_base<
++      filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
++      typename std::common_type<
++          std::forward_iterator_tag,
++          typename std::iterator_traits<WrappedIteratorT>::iterator_category>::
++          type>;
++
++  struct PayloadType {
++    WrappedIteratorT End;
++    PredicateT Pred;
++  };
++
++  Optional<PayloadType> Payload;
++
++  void findNextValid() {
++    assert(Payload && "Payload should be engaged when findNextValid is called");
++    while (this->I != Payload->End && !Payload->Pred(*this->I))
++      BaseT::operator++();
++  }
++
++  // Construct the begin iterator. The begin iterator requires to know where end
++  // is, so that it can properly stop when it hits end.
++  filter_iterator(WrappedIteratorT Begin, WrappedIteratorT End, PredicateT Pred)
++      : BaseT(std::move(Begin)),
++        Payload(PayloadType{std::move(End), std::move(Pred)}) {
++    findNextValid();
++  }
++
++  // Construct the end iterator. It's not incrementable, so Payload doesn't
++  // have to be engaged.
++  filter_iterator(WrappedIteratorT End) : BaseT(End) {}
++
++public:
++  using BaseT::operator++;
++
++  filter_iterator &operator++() {
++    BaseT::operator++();
++    findNextValid();
++    return *this;
++  }
++
++  template <typename RT, typename PT>
++  friend iterator_range<filter_iterator<detail::IterOfRange<RT>, PT>>
++  make_filter_range(RT &&, PT);
++};
++
++/// Convenience function that takes a range of elements and a predicate,
++/// and return a new filter_iterator range.
++///
++/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
++/// lifetime of that temporary is not kept by the returned range object, and the
++/// temporary is going to be dropped on the floor after the make_iterator_range
++/// full expression that contains this function call.
++template <typename RangeT, typename PredicateT>
++iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
++make_filter_range(RangeT &&Range, PredicateT Pred) {
++  using FilterIteratorT =
++      filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
++  return make_range(FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
++                                    std::end(std::forward<RangeT>(Range)),
++                                    std::move(Pred)),
++                    FilterIteratorT(std::end(std::forward<RangeT>(Range))));
++}
++
+ //===----------------------------------------------------------------------===//
+ //     Extra additions to <utility>
+ //===----------------------------------------------------------------------===//
+@@ -216,6 +382,11 @@ struct build_index_impl<0, I...> : index_sequence<I...> {};
+ template <class... Ts>
+ struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
+ 
++/// Utility type to build an inheritance chain that makes it easy to rank
++/// overload candidates.
++template <int N> struct rank : rank<N - 1> {};
++template <> struct rank<0> {};
++
+ //===----------------------------------------------------------------------===//
+ //     Extra additions for arrays
+ //===----------------------------------------------------------------------===//
+@@ -263,10 +434,11 @@ inline int (*get_array_pod_sort_comparator(const T &))
+ /// default to std::less.
+ template<class IteratorTy>
+ inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
+-  // Don't dereference start iterator of empty sequence.
+-  if (Start == End) return;
+-  qsort(&*Start, End-Start, sizeof(*Start),
+-        get_array_pod_sort_comparator(*Start));
++  // Don't inefficiently call qsort with one element or trigger undefined
++  // behavior with an empty sequence.
++  auto NElts = End - Start;
++  if (NElts <= 1) return;
++  qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
+ }
+ 
+ template <class IteratorTy>
+@@ -275,9 +447,11 @@ inline void array_pod_sort(
+     int (*Compare)(
+         const typename std::iterator_traits<IteratorTy>::value_type *,
+         const typename std::iterator_traits<IteratorTy>::value_type *)) {
+-  // Don't dereference start iterator of empty sequence.
+-  if (Start == End) return;
+-  qsort(&*Start, End - Start, sizeof(*Start),
++  // Don't inefficiently call qsort with one element or trigger undefined
++  // behavior with an empty sequence.
++  auto NElts = End - Start;
++  if (NElts <= 1) return;
++  qsort(&*Start, NElts, sizeof(*Start),
+         reinterpret_cast<int (*)(const void *, const void *)>(Compare));
+ }
+ 
+@@ -303,6 +477,74 @@ void DeleteContainerSeconds(Container &C) {
+   C.clear();
+ }
+ 
++/// Provide wrappers to std::all_of which take ranges instead of having to pass
++/// begin/end explicitly.
++template<typename R, class UnaryPredicate>
++bool all_of(R &&Range, UnaryPredicate &&P) {
++  return std::all_of(Range.begin(), Range.end(),
++                     std::forward<UnaryPredicate>(P));
++}
++
++/// Provide wrappers to std::any_of which take ranges instead of having to pass
++/// begin/end explicitly.
++template <typename R, class UnaryPredicate>
++bool any_of(R &&Range, UnaryPredicate &&P) {
++  return std::any_of(Range.begin(), Range.end(),
++                     std::forward<UnaryPredicate>(P));
++}
++
++/// Provide wrappers to std::none_of which take ranges instead of having to pass
++/// begin/end explicitly.
++template <typename R, class UnaryPredicate>
++bool none_of(R &&Range, UnaryPredicate &&P) {
++  return std::none_of(Range.begin(), Range.end(),
++                      std::forward<UnaryPredicate>(P));
++}
++
++/// Provide wrappers to std::find which take ranges instead of having to pass
++/// begin/end explicitly.
++template<typename R, class T>
++auto find(R &&Range, const T &val) -> decltype(Range.begin()) {
++  return std::find(Range.begin(), Range.end(), val);
++}
++
++/// Provide wrappers to std::find_if which take ranges instead of having to pass
++/// begin/end explicitly.
++template <typename R, class T>
++auto find_if(R &&Range, const T &Pred) -> decltype(Range.begin()) {
++  return std::find_if(Range.begin(), Range.end(), Pred);
++}
++
++/// Provide wrappers to std::remove_if which take ranges instead of having to
++/// pass begin/end explicitly.
++template<typename R, class UnaryPredicate>
++auto remove_if(R &&Range, UnaryPredicate &&P) -> decltype(Range.begin()) {
++  return std::remove_if(Range.begin(), Range.end(), P);
++}
++
++/// Wrapper function around std::find to detect if an element exists
++/// in a container.
++template <typename R, typename E>
++bool is_contained(R &&Range, const E &Element) {
++  return std::find(Range.begin(), Range.end(), Element) != Range.end();
++}
++
++/// Wrapper function around std::count_if to count the number of times an
++/// element satisfying a given predicate occurs in a range.
++template <typename R, typename UnaryPredicate>
++auto count_if(R &&Range, UnaryPredicate &&P)
++    -> typename std::iterator_traits<decltype(Range.begin())>::difference_type {
++  return std::count_if(Range.begin(), Range.end(), P);
++}
++
++/// Wrapper function around std::transform to apply a function to a range and
++/// store the result elsewhere.
++template <typename R, class OutputIt, typename UnaryPredicate>
++OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate &&P) {
++  return std::transform(Range.begin(), Range.end(), d_first,
++                        std::forward<UnaryPredicate>(P));
++}
++
+ //===----------------------------------------------------------------------===//
+ //     Extra additions to <memory>
+ //===----------------------------------------------------------------------===//
+-- 
+2.7.4
+

src/codegen/memmgr.cpp

@@ -182,20 +182,16 @@ bool PystonMemoryManager::finalizeMemory(std::string* ErrMsg) {
         if (ErrMsg) {
             *ErrMsg = ec.message();
         }
-        return true;
+        RELEASE_ASSERT(0, "finalizeMemory failed");
     }
 
-    // This code was removed in latest LLVM's repo.
-    // Don't allow free memory blocks to be used after setting protection flags.
-    RODataMem.FreeMem.clear();
-
     // Make read-only data memory read-only.
     ec = applyMemoryGroupPermissions(RODataMem, sys::Memory::MF_READ | sys::Memory::MF_EXEC);
     if (ec) {
         if (ErrMsg) {
             *ErrMsg = ec.message();
         }
-        return true;
+        RELEASE_ASSERT(0, "finalizeMemory failed");
     }
 
     // Read-write data memory already has the correct permissions
@@ -226,11 +222,6 @@ static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
     return Trimmed;
 }
 
-// Copy from LLVM 3.9 repo's /include/llvm/ADT/STLExtras.h
-template <typename R, class UnaryPredicate> auto remove_if(R&& Range, UnaryPredicate&& P) -> decltype(Range.begin()) {
-    return std::remove_if(Range.begin(), Range.end(), P);
-}
-
 llvm_error_code PystonMemoryManager::applyMemoryGroupPermissions(MemoryGroup& MemGroup, unsigned Permissions) {
 
     for (sys::MemoryBlock& MB : MemGroup.PendingMem) {