[libcxxabi][SystemZ][z/OS] Update libcxxabi/src/fallback_malloc.cpp to support POSIX(OFF)

[DanielMcIntosh-IBM]

Summary

Modify mutexor so we don't perform syncronization in fallback_malloc() or
fallback_free() when we're in a single-threaded application in order to
prevent calls to mutex functions when the threading API is disabled.

Depends on D110349

[DanielMcIntosh-IBM]

Update comment a bit to increase clarity

[DanielMcIntosh-IBM]

Update function names as a result of changes to D110349

libcxxabi/src/fallback_malloc.cpp

 _LIBCPP_SAFE_STATIC
 static std::__libcpp_mutex_t heap_mutex = _LIBCPP_MUTEX_INITIALIZER;
 #else
 static void* heap_mutex = 0;
 #endif
 
 class mutexor {
 public:
-#ifndef _LIBCXXABI_HAS_NO_THREADS
-  mutexor(std::__libcpp_mutex_t* m) : mtx_(m) {
-    std::__libcpp_mutex_lock(mtx_);
-  }
-  ~mutexor() { std::__libcpp_mutex_unlock(mtx_); }
-#else
+#ifdef _LIBCXXABI_HAS_NO_THREADS
   mutexor(void*) {}
   ~mutexor() {}
+#else
+  mutexor(std::__libcpp_mutex_t* m) {
+    // Neither fallback_malloc nor fallback_free spawn new threads. Thus, there
+    // is no danger of one thread entering them without aquiring the mutex,
+    // followed by another thread entering (and aquiring the mutex) before the
+    // first thread leaves.
+    // We can't acquire the mutex with threads disabled, but since we don't
+    // need to unless there is more than one thread anyways, we only bother to
+    // aquire the mutex when multi-threaded.
+    if (std::__libcpp_has_spawned_other_threads()) {
+      mtx_ = m;
+      std::__libcpp_mutex_lock(mtx_);
+    } else
+      mtx_ = nullptr;
+  }
+  ~mutexor() {
+    if (mtx_ != nullptr)
+      std::__libcpp_mutex_unlock(mtx_);
+  }
 #endif
 private:
   mutexor(const mutexor& rhs);
   mutexor& operator=(const mutexor& rhs);
 #ifndef _LIBCXXABI_HAS_NO_THREADS
   std::__libcpp_mutex_t* mtx_;
 #endif
 };