Implement some of MSVC's intrinsics, for ImportC.

changelog/druntime.importc-initial-msvc-intrinsics.dd

@@ -0,0 +1,19 @@
+ImportC implements the vast majority of MSVC's intrinsics: 461 of them to be exact.
+
+ImportC now implements the vast majority of MSVC's intrinsics: 461 of them to be exact.
+All but three of the intrinsics [listed here](https://web.archive.org/web/20240412171516/https://learn.microsoft.com/en-ie/cpp/intrinsics/alphabetical-listing-of-intrinsic-functions?view=msvc-170) are implemented, alongside a handful of undocumented intrinsics, accompanied by a smattering of ISA-specific intrinsics.
+
+The presence of these intrinsics greatly improves ImportC's ability to successfully import C headers when targeting Windows.
+Notably, `Windows.h` can now be successfully included by ImportC.
+
+To make use of MSVC intrinsics in ImportC, simply `#include` the `importc_msvc_builtins.h` header before any C code that uses MSVC intrinsics:
+```c
+#include <importc_msvc_builtins.h>
+#include <windows.h>
+```
+MSVC intrinsics are available when targeting the Microsoft C runtime (that is, when the `CRuntime_Microsoft` version identifier is defined).
+
+Every intrinsic implemented has received optimised code for LDC, GDC, and DMD.
+Each intrinsic, where possible, has a CTFE-compatible code path.
+
+(Owing to the newness of DMD's AArch64 backend, MSVC intrinsics have not yet been implemented for DMD AArch64 targets. They have been implemented for LDC and GDC AArch64 targets.)

compiler/src/dmd/cpreprocess.d

@@ -67,9 +67,11 @@ DArray!ubyte preprocess(FileName csrcfile, Loc loc, ref OutBuffer defines)
     //printf("preprocess %s\n", csrcfile.toChars());
     version (runPreprocessor)
     {
+        const includePath = FileName.replaceName(toDString(importc_h), "include");
+        scope(exit) FileName.free(includePath.ptr);
         const command = global.params.cpp ? toDString(global.params.cpp) : cppCommand();
         DArray!ubyte text;
-        int status = runPreprocessor(loc, command, csrcfile.toString(), importc_h, global.params.cppswitches, global.params.v.verbose, global.errorSink, defines, text);
+        int status = runPreprocessor(loc, command, csrcfile.toString(), importc_h, includePath, global.params.cppswitches, global.params.v.verbose, global.errorSink, defines, text);
         if (status)
             fatal();
         return text;

compiler/src/dmd/link.d

@@ -968,6 +968,7 @@ public int runProgram(const char[] exefile, const char*[] runargs, bool verbose,
  *    cpp = name of C preprocessor program
  *    filename = C source file name
  *    importc_h = filename of importc.h
+ *    includePath = path passed to the preprocessor as an include path
  *    cppswitches = array of switches to pass to C preprocessor
  *    verbose = print progress to eSink
  *    eSink = for verbose messages and error messages
@@ -976,7 +977,7 @@ public int runProgram(const char[] exefile, const char*[] runargs, bool verbose,
  * Returns:
  *    error status, 0 for success
  */
-public int runPreprocessor(Loc loc, const(char)[] cpp, const(char)[] filename, const(char)* importc_h, ref Array!(const(char)*) cppswitches,
+public int runPreprocessor(Loc loc, const(char)[] cpp, const(char)[] filename, const(char)* importc_h, const(char)[] includePath, ref Array!(const(char)*) cppswitches,
     bool verbose, ErrorSink eSink, ref OutBuffer defines, out DArray!ubyte text)
 {
     //printf("runPreprocessor() cpp: %.*s filename: %.*s\n", cast(int)cpp.length, cpp.ptr, cast(int)filename.length, filename.ptr);
@@ -1026,6 +1027,13 @@ public int runPreprocessor(Loc loc, const(char)[] cpp, const(char)[] filename, c
                 buf.printf(" /std:c11 /P /Zc:preprocessor /PD /nologo /utf-8 \"%.*s\" \"/FI%s\" \"/Fi%.*s\"",
                     cast(int)filename.length, filename.ptr, importc_h, cast(int)output.length, output.ptr);
 
+                /* Append the include path, if it was provided
+                 */
+                if (includePath)
+                {
+                    buf.printf(` "/I%.*s"`, cast(int)includePath.length, includePath.ptr);
+                }
+
                 /* Append preprocessor switches to command line
                  */
                 foreach (a; cppswitches)
@@ -1196,6 +1204,13 @@ public int runPreprocessor(Loc loc, const(char)[] cpp, const(char)[] filename, c
         // need to redefine some macros in importc.h
         argv.push("-Wno-builtin-macro-redefined");
 
+        // append the include path, if it was provided
+        if (includePath)
+        {
+            argv.push("-I");
+            argv.push(includePath.xarraydup.ptr);
+        }
+
         if (target.os == Target.OS.OSX)
         {
             argv.push("-fno-blocks");       // disable clang blocks extension

compiler/test/compilable/msvc_intrinsics.c

@@ -0,0 +1,42 @@
+// DISABLED: osx linux freebsd openbsd netbsd dragonflybsd hurd
+// LINK(windows):
+// PERMUTE_ARGS: -betterC
+// Checking that the MSVC intrinsics reimplemented for ImportC are actually available from C.
+
+#include <importc_msvc_builtins.h>
+
+#ifndef __IMPORTC_MSVC_BUILTINS__
+#error importc_msvc_builtins.h should define __IMPORTC_MSVC_BUILTINS__.
+#endif
+
+// It should be safe to include importc_msvc_builtins.h multiple times.
+#include <importc_msvc_builtins.h>
+
+// Are the MSVC intrinsics actually usable from C?
+#if defined(_M_AMD64)
+unsigned long long multiplyU128(unsigned long long a, unsigned long long b, unsigned long long* high)
+{
+    return _umul128(a, b, high);
+}
+#elif defined(_M_IX86)
+int interlockedAddLarge(long long *target, int value)
+{
+    return _InterlockedAddLargeStatistic(target, value);
+}
+#elif defined(_M_ARM64)
+unsigned long long multiplyUHigh64(unsigned long long a, unsigned long long b)
+{
+    return __umulh(a, b);
+}
+#elif defined(_M_ARM)
+void dmb(void)
+{
+    __dmb(11);
+}
+#endif
+
+int main(void)
+{
+    __assume(1);
+    return 0;
+}

druntime/mak/COPY

@@ -1,7 +1,9 @@
 COPY=\
 	$(IMPDIR)\object.d \
 	$(IMPDIR)\__importc_builtins.di \
+	$(IMPDIR)\__builtins_msvc.d \
 	$(IMPDIR)\importc.h \
+	$(IMPDIR)\include\importc_msvc_builtins.h \
 	\
 	$(IMPDIR)\core\gc\config.d \
 	$(IMPDIR)\core\gc\gcinterface.d \