diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
index 241f9ce..f8efc39 100644
--- a/lib/ClangImporter/ClangImporter.cpp
+++ b/lib/ClangImporter/ClangImporter.cpp
@@ -43,6 +43,7 @@
 #include "clang/Basic/Module.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
+#include "clang/Basic/VirtualFileSystem.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/Utils.h"
@@ -63,6 +64,7 @@
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <memory>
+#include <regex>
 
 using namespace swift;
 using namespace importer;
@@ -405,6 +407,84 @@
 
 #define SHIMS_INCLUDE_FLAG "-isystem"
 
+
+void generateGlibcMap(StringRef glibcModuleMapPathIn,
+                      StringRef sysroot,
+                      const llvm::Triple &triple,
+                      clang::vfs::InMemoryFileSystem *imf) {
+
+  auto glibcBuffer = llvm::MemoryBuffer::getFile(glibcModuleMapPathIn);
+  if (!glibcBuffer){
+    llvm::errs() << "unable to read glibc.modulemap '"
+      << glibcModuleMapPathIn << "'";
+    return;
+  }
+
+  SmallString<128> includePath = sysroot;
+  if (triple.isOSHaiku()) {
+    llvm::sys::path::append(includePath,
+                            "system", "develop", "headers", "posix");
+  } else if (triple.isOSFuchsia()){
+    llvm::sys::path::append(includePath, "include");
+  } else {
+    llvm::sys::path::append(includePath, "usr", "include");
+  }
+
+  // Attempt to detect if the target sysroot is storing headers in a multiarch
+  // fashion like Debian or Ubuntu
+  SmallString<128> archIncludePath = includePath;
+  if (triple.isOSLinux() && !triple.isAndroid()) {
+    // The multiarch folder *should* match the triple passed in.
+    SmallString<128> triplePath = includePath;
+    llvm::sys::path::append(triplePath, triple.getTriple());
+    if (llvm::sys::fs::exists(triplePath)){
+      llvm::sys::path::append(archIncludePath, triple.getTriple());
+    } else {
+      // Attempt to match to folder manually. Scan the lib folder looking for
+      // a directory that parses as triple, parses as Linux and and has a
+      // matching arch as our target.
+      std::error_code EC;
+      llvm::sys::fs::directory_iterator DI(includePath, EC);
+      llvm::sys::fs::directory_iterator DE;
+      for (; !EC && DI != DE; DI = DI.increment(EC)) {
+        StringRef path = DI->path();
+        if (llvm::sys::fs::is_directory(path)) {
+          StringRef filename = llvm::sys::path::filename(path);
+          if (filename.count('-') > 2) {
+            // This folder smells like a triple. Parse it as one.
+            llvm::Triple folderTriple(filename);
+            if (folderTriple.isOSLinux() &&
+                folderTriple.getArch() == triple.getArch()) {
+              // This folder matches both as Linux and matches our arch so it's
+              // a likely canidate.
+              llvm::sys::path::append(archIncludePath, filename);
+              break;
+            }
+          }
+        }
+      }
+      if (EC) {
+        llvm::errs() << "Failed to enumerate include path '" << includePath <<
+          "' - " << EC.message();
+      }
+    }
+  }
+
+  std::string contents = glibcBuffer.get()->getBuffer();
+  contents = std::regex_replace(contents,
+                                std::regex("\\<system-include\\>"),
+                                std::string(includePath.str()));
+  contents = std::regex_replace(contents,
+                                std::regex("\\<system-arch-include\\>"),
+                                std::string(archIncludePath.str()));
+
+  // Replace the original glibc.modulemap with a modified one in the VFS overlay
+  // using the same path.
+  imf->addFile(glibcModuleMapPathIn, 0,
+               llvm::MemoryBuffer::getMemBuffer(StringRef(contents)));
+}
+
+
 static StringRef
 getMinVersionOptNameForDarwinTriple(const llvm::Triple &triple) {
   switch(getDarwinPlatformKind(triple)) {
@@ -429,7 +509,8 @@
 static void
 getNormalInvocationArguments(std::vector<std::string> &invocationArgStrs,
                              ASTContext &ctx,
-                             const ClangImporterOptions &importerOpts) {
+                             const ClangImporterOptions &importerOpts,
+                             clang::vfs::InMemoryFileSystem *imf) {
   const auto &LangOpts = ctx.LangOpts;
   const llvm::Triple &triple = LangOpts.Target;
   SearchPathOptions &searchPathOpts = ctx.SearchPathOpts;
@@ -533,6 +614,18 @@
       });
     }
   } else {
+    // Ideally we should turn this on for all Glibc targets that are actually
+    // using Glibc or a libc that respects that flag. This will cause some
+    // source breakage however (specifically with strerror_r()) on Linux
+    // without a workaround.
+    if (triple.isOSFuchsia()) {
+      // Many of the modern libc features are hidden behind feature macros like
+      // _GNU_SOURCE or _XOPEN_SOURCE.
+      invocationArgStrs.insert(invocationArgStrs.end(), {
+        "-D_GNU_SOURCE",
+      });
+    }
+
     // The module map used for Glibc depends on the target we're compiling for,
     // and is not included in the resource directory with the other implicit
     // module maps. It's at {freebsd|linux}/{arch}/glibc.modulemap.
@@ -553,6 +646,14 @@
     // `swiftc -target x86_64-unknown-linux-gnu -emit-ir` is invoked using
     // a Swift compiler not built for Linux targets.
     if (llvm::sys::fs::exists(GlibcModuleMapPath)) {
+      // Inject VFS replacement for the glibc.modulemap where the paths are
+      // adjusted to match the current target SDK root.
+      StringRef sysroot = searchPathOpts.SDKPath;
+      if (sysroot.empty()){
+        sysroot = "/";
+      }
+      generateGlibcMap(GlibcModuleMapPath, sysroot, triple, imf);
+
       invocationArgStrs.push_back(
         (Twine("-fmodule-map-file=") + GlibcModuleMapPath).str());
     } else {
@@ -844,9 +945,17 @@
   // "clang" for argv[0]
   invocationArgStrs.push_back("clang");
 
+  // Create an in-memory VFS overlay so that a rewritten Glibc.modulemap with
+  // updated sysroot paths can be subbed in based on the target's paths.
+  llvm::IntrusiveRefCntPtr<clang::vfs::OverlayFileSystem>
+    ovs(new clang::vfs::OverlayFileSystem(clang::vfs::getRealFileSystem()));
+  llvm::IntrusiveRefCntPtr<clang::vfs::InMemoryFileSystem>
+    imf(new clang::vfs::InMemoryFileSystem);
+  ovs->pushOverlay(imf);
+
   switch (importerOpts.Mode) {
   case ClangImporterOptions::Modes::Normal:
-    getNormalInvocationArguments(invocationArgStrs, ctx, importerOpts);
+    getNormalInvocationArguments(invocationArgStrs, ctx, importerOpts, imf.get());
     break;
   case ClangImporterOptions::Modes::EmbedBitcode:
     getEmbedBitcodeInvocationArguments(invocationArgStrs, ctx, importerOpts);
@@ -896,7 +1005,7 @@
 
   // Create a new Clang compiler invocation.
   importer->Impl.Invocation =
-      clang::createInvocationFromCommandLine(invocationArgs, clangDiags);
+      clang::createInvocationFromCommandLine(invocationArgs, clangDiags, ovs);
   if (!importer->Impl.Invocation)
     return nullptr;
 
diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt
index 460a362..a412f71 100644
--- a/stdlib/public/Platform/CMakeLists.txt
+++ b/stdlib/public/Platform/CMakeLists.txt
@@ -47,32 +47,6 @@
     set(arch_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}")
     set(module_dir "${SWIFTLIB_DIR}/${arch_subdir}")
 
-    if("${sdk}" STREQUAL "HAIKU")
-      # Haiku doesn't have /usr/include, instead the headers are located
-      # at /system/develop/headers.
-      set(GLIBC_INCLUDE_PATH "/system/develop/headers/posix")
-      set(GLIBC_ARCH_INCLUDE_PATH "/system/develop/headers/posix")
-      set(GLIBC_SYSROOT_RELATIVE_INCLUDE_PATH "/system/develop/headers/")
-      set(GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH "/system/develop/headers/")
-    else()
-      # Determine the location of glibc headers based on the target.
-      set(GLIBC_SYSROOT_RELATIVE_INCLUDE_PATH "/usr/include")
-      set(GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH "${GLIBC_SYSROOT_RELATIVE_INCLUDE_PATH}")
-
-      # Some SDKs place their headers in architecture-specific subfolders.
-      if(("${sdk}" STREQUAL "LINUX" OR "${sdk}" STREQUAL "FREEBSD") AND CMAKE_LIBRARY_ARCHITECTURE)
-        set(GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH "${GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH}/${CMAKE_LIBRARY_ARCHITECTURE}")
-      endif()
-
-      set(GLIBC_INCLUDE_PATH "${GLIBC_SYSROOT_RELATIVE_INCLUDE_PATH}")
-      set(GLIBC_ARCH_INCLUDE_PATH "${GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH}")
-
-      if(NOT "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}" STREQUAL "/")
-        set(GLIBC_INCLUDE_PATH "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}${GLIBC_INCLUDE_PATH}")
-        set(GLIBC_ARCH_INCLUDE_PATH "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}${GLIBC_ARCH_INCLUDE_PATH}")
-      endif()
-    endif()
-
     set(glibc_modulemap_source "glibc.modulemap.gyb")
     set(glibc_modulemap_out "${module_dir}/glibc.modulemap")
 
@@ -85,37 +59,10 @@
         OUTPUT "${glibc_modulemap_out}"
         FLAGS
             "-DCMAKE_SDK=${sdk}"
-            "-DGLIBC_INCLUDE_PATH=${GLIBC_INCLUDE_PATH}"
-            "-DGLIBC_ARCH_INCLUDE_PATH=${GLIBC_ARCH_INCLUDE_PATH}")
+            "-DGLIBC_INCLUDE_PATH=\"<system-include>\""
+            "-DGLIBC_ARCH_INCLUDE_PATH=\"<system-arch-include>\"")
 
     list(APPEND glibc_modulemap_target_list ${glibc_modulemap_target})
-
-    # If this SDK is a target for a non-native host, create a native modulemap
-    # without a sysroot prefix. This is the one we'll install instead.
-    if(NOT "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${arch}_PATH}" STREQUAL "/")
-
-      set(glibc_sysroot_relative_modulemap_out "${module_dir}/sysroot-relative-modulemaps/glibc.modulemap")
-      handle_gyb_source_single(glibc_modulemap_native_target
-          SOURCE "${glibc_modulemap_source}"
-          OUTPUT "${glibc_sysroot_relative_modulemap_out}"
-          FLAGS
-              "-DCMAKE_SDK=${sdk}"
-              "-DGLIBC_INCLUDE_PATH=${GLIBC_SYSROOT_RELATIVE_INCLUDE_PATH}"
-              "-DGLIBC_ARCH_INCLUDE_PATH=${GLIBC_SYSROOT_RELATIVE_ARCH_INCLUDE_PATH}")
-
-      list(APPEND glibc_modulemap_target_list ${glibc_modulemap_native_target})
-      set(glibc_modulemap_out ${glibc_sysroot_relative_modulemap_out})
-    endif()
-
-    # FIXME: When SDK is a cross-compile target (SDK != Host), the generated
-    #        modulemap will be relative to the Host, with hardcoded paths.
-    #        It is not relocatable to the target platform itself.
-    #        This affects any cross-compiled targets that use glibc.modulemap
-
-    swift_install_in_component(sdk-overlay
-        FILES "${glibc_modulemap_out}"
-        DESTINATION "lib/swift/${arch_subdir}")
-
   endforeach()
 endforeach()
 add_custom_target(glibc_modulemap DEPENDS ${glibc_modulemap_target_list})