Disable RWX mapping tests in unittests/Support/MemoryTest

[krytarowski]

Summary

RWX mapping is not allowed on all operating
systems (W^X restrictions).

This fixes all unexpected failures on NetBSD 8.0(beta).

RWX allocations require different interface,
AllocateRWX.

Sponsored by <The NetBSD Foundation>

[krytarowski]

CC: @lhames

Closing this. This interface should be refactored.

unittests/Support/MemoryTest.cpp

protected:
   // Adds RW flags to permit testing of the resulting memory
   unsigned getTestableEquivalent(unsigned RequestedFlags) {
     switch (RequestedFlags) {
     case Memory::MF_READ:
     case Memory::MF_WRITE:
     case Memory::MF_READ|Memory::MF_WRITE:
       return Memory::MF_READ|Memory::MF_WRITE;
     case Memory::MF_READ|Memory::MF_EXEC:
-    case Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC:
     case Memory::MF_EXEC:
-      return Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC;
+      return Memory::MF_READ|Memory::MF_EXEC;
     }
     // Default in case values are added to the enum, as required by some compilers
     return Memory::MF_READ|Memory::MF_WRITE;
   }
 
   // Returns true if the memory blocks overlap
   bool doesOverlap(MemoryBlock M1, MemoryBlock M2) {
     if (M1.base() == M2.base())
TEST_P(MappedMemoryTest, MultipleWrite) {
   // Verify that M2 remains unaffected by other activity
   for (int i = 0; i < 8; i++) {
     EXPECT_EQ(i, y[i]);
   }
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, EnabledWrite) {
+  if (Flags & Memory::MF_EXEC)
+    return;
+
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(2 * sizeof(int), nullptr, Flags,
                                                 EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
                                                 EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
TEST_P(MappedMemoryTest, UnalignedNear) {
   EXPECT_NE((void*)nullptr, M1.base());
   EXPECT_LE(sizeof(int), M1.size());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
 
 // Note that Memory::MF_WRITE is not supported exclusively across
 // operating systems and architectures and can imply MF_READ|MF_WRITE
+// RWX mapping is not allowed on all operating systems (W^X restrictions)
 unsigned MemoryFlags[] = {
          Memory::MF_READ,
          Memory::MF_WRITE,
          Memory::MF_READ|Memory::MF_WRITE,
          Memory::MF_EXEC,
-         Memory::MF_READ|Memory::MF_EXEC,
-         Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC
+         Memory::MF_READ|Memory::MF_EXEC
        };
 
 INSTANTIATE_TEST_CASE_P(AllocationTests,
       MappedMemoryTest,
       ::testing::ValuesIn(MemoryFlags),);
 
 }  // anonymous namespace