[LLVMSupport] Re-apply all post-import modifications on LLVMSupport that the Swift's fork has

Since the previous commits re-imported "vanilla" versions of LLVMSupport, we need to re-apply all modifications that the Swift's fork has made since the last import. More precisely:

1) git diff 7b70120..origin/main -- stdlib/include/llvm stdlib/public/LLVMSupport | git apply -3 --exclude "stdlib/include/llvm/Support/DataTypes.h" --exclude "stdlib/include/llvm/Config/llvm-config.h.cmake"
2) manually resolve conflict in STLExtras.h by applying the "__swift::__runtime" prefix to HEAD's version
3) manually resolve conflicts in StringSwitch.h by keeping HEAD's version (removing the Unicode BOM marker at the beginning of the file, keeping LLVM's version of the string functions)
4) manually resolve conflict in SwapByteOrder.h by adding the `defined(__wasi__)` part into the #if

Author: kubamracek

stdlib/include/llvm/ADT/Hashing.h

@@ -44,13 +44,13 @@
 #ifndef LLVM_ADT_HASHING_H
 #define LLVM_ADT_HASHING_H
 
-#include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Support/type_traits.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
+#include <cstdint>
 #include <string>
 #include <tuple>
 #include <utility>

stdlib/include/llvm/ADT/STLExtras.h

@@ -724,7 +724,8 @@ Iter next_or_end(const Iter &I, const Iter &End) {
 }
 
 template <typename Iter>
-auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
+auto deref_or_none(const Iter &I, const Iter &End)
+    -> __swift::__runtime::llvm::Optional<
     std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
     return None;

stdlib/include/llvm/Support/Atomic.h

@@ -17,7 +17,7 @@
 #ifndef LLVM_SUPPORT_ATOMIC_H
 #define LLVM_SUPPORT_ATOMIC_H
 
-#include "llvm/Support/DataTypes.h"
+#include <stdint.h>
 
 // Windows will at times define MemoryFence.
 #ifdef MemoryFence

stdlib/include/llvm/Support/Compiler.h

@@ -15,8 +15,6 @@
 #ifndef LLVM_SUPPORT_COMPILER_H
 #define LLVM_SUPPORT_COMPILER_H
 
-#include "llvm/Config/llvm-config.h"
-
 #ifdef __cplusplus
 #include <new>
 #endif

stdlib/include/llvm/Support/MathExtras.h

@@ -880,7 +880,7 @@ extern const float huge_valf;
 
 
 /// Add two signed integers, computing the two's complement truncated result,
-/// returning true if overflow occured.
+/// returning true if overflow occurred.
 template <typename T>
 std::enable_if_t<std::is_signed<T>::value, T> AddOverflow(T X, T Y, T &Result) {
 #if __has_builtin(__builtin_add_overflow)

stdlib/include/llvm/Support/PointerLikeTypeTraits.h

@@ -14,8 +14,8 @@
 #ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
 #define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
 
-#include "llvm/Support/DataTypes.h"
 #include <cassert>
+#include <cstdint>
 #include <type_traits>
 
 inline namespace __swift { inline namespace __runtime {

stdlib/include/llvm/Support/SwapByteOrder.h

@@ -21,7 +21,7 @@
 #include <stdlib.h>
 #endif
 
-#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
+#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) || defined(__wasi__) || \
     defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
 #include <endian.h>
 #elif defined(_AIX)

stdlib/public/LLVMSupport/ErrorHandling.cpp

@@ -15,28 +15,55 @@
 #include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <cstdlib>
+#include <cstdio>
 
 #if defined(_MSC_VER)
 # include <io.h>
 # include <fcntl.h>
+#endif
+
+#include <stdarg.h>
+
+#if SWIFT_STDLIB_HAS_ASL
+#include <asl.h>
+#elif defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+namespace {
+void error(const char *fmt, ...) {
+  char buffer[1024];
+  va_list argp;
+
+  va_start(argp, fmt);
+  vsnprintf(buffer, sizeof(buffer), fmt, argp);
+  va_end(argp);
+
+#if SWIFT_STDLIB_HAS_ASL
+  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", buffer);
+#elif defined(__ANDROID__)
+  __android_log_print(ANDROID_LOG_FATAL, "SwiftRuntime", "%s", buffer);
+#elif defined(_WIN32)
+#define STDERR_FILENO 2
+  _write(STDERR_FILENO, buffer, strlen(buffer));
 #else
-# include <stdio.h>
+  fputs(buffer, stderr);
+  fflush(stderr);
 #endif
+}
+}
 
 using namespace llvm;
 
 void __swift::__runtime::llvm::report_fatal_error(const char *Reason,
                                                   bool GenCrashDiag) {
-  report_fatal_error(std::string(Reason), GenCrashDiag);
+  error("LLVM ERROR: %s\n", Reason);
+  abort();
 }
 
 void __swift::__runtime::llvm::report_fatal_error(const std::string &Reason,
                                                   bool GenCrashDiag) {
-  // Blast the result out to stderr.  We don't try hard to make sure this
-  // succeeds (e.g. handling EINTR) and we can't use errs() here because
-  // raw ostreams can call report_fatal_error.
-  fprintf(stderr, "LLVM ERROR: %s\n", Reason.c_str());
-  abort();
+  report_fatal_error(Reason.c_str(), GenCrashDiag);
 }
 
 void __swift::__runtime::llvm::report_fatal_error(StringRef Reason,
@@ -48,7 +75,7 @@ void __swift::__runtime::llvm::report_bad_alloc_error(const char *Reason,
                                                       bool GenCrashDiag) {
   // Don't call the normal error handler. It may allocate memory. Directly write
   // an OOM to stderr and abort.
-  fprintf(stderr, "LLVM ERROR: out of memory\n");
+  error("LLVM ERROR: out of memory\n");
   abort();
 }
 
@@ -58,11 +85,11 @@ void __swift::__runtime::llvm::llvm_unreachable_internal(
   // llvm_unreachable is intended to be used to indicate "impossible"
   // situations, and not legitimate runtime errors.
   if (msg)
-    fprintf(stderr, "%s\n", msg);
-  fprintf(stderr, "UNREACHABLE executed");
+    error("%s\n", msg);
+  error("UNREACHABLE executed");
   if (file)
-    fprintf(stderr, " at %s:%u", file, line);
-  fprintf(stderr, "!\n");
+    error(" at %s:%u", file, line);
+  error("!\n");
   abort();
 #ifdef LLVM_BUILTIN_UNREACHABLE
   // Windows systems and possibly others don't declare abort() to be noreturn,