Implement some of MSVC's intrinsics, for ImportC.

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

@@ -0,0 +1,4 @@
+ImportC implements all but three of the MSVC 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), and a handful of undocumented intrinsics.
+
+ImportC now implements all but three of the MSVC 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), and a handful of undocumented intrinsics.
+The MSVC intrinsics are available when targeting the Microsoft C runtime (that is, when the `CRuntime_Microsoft` version identifier is defined).

compiler/src/dmd/cpreprocess.d

@@ -67,9 +67,11 @@ DArray!ubyte preprocess(FileName csrcfile, ref const Loc loc, ref OutBuffer defi
     //printf("preprocess %s\n", csrcfile.toChars());
     version (runPreprocessor)
     {
+        const includePath = FileName.replaceName(toDString(importc_h), "include");
         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);
+        FileName.free(includePath.ptr);
         if (status)
             fatal();
         return text;

compiler/src/dmd/link.d

@@ -940,6 +940,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
@@ -948,7 +949,7 @@ public int runProgram(const char[] exefile, const char*[] runargs, bool verbose,
  * Returns:
  *    error status, 0 for success
  */
-public int runPreprocessor(ref const Loc loc, const(char)[] cpp, const(char)[] filename, const(char)* importc_h, ref Array!(const(char)*) cppswitches,
+public int runPreprocessor(ref const 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);
@@ -994,6 +995,14 @@ public int runPreprocessor(ref const Loc loc, const(char)[] cpp, const(char)[] f
                 buf.printf(" /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.write(" /I");
+                    buf.write(includePath);
+                }
+
                 /* Append preprocessor switches to command line
                  */
                 foreach (a; cppswitches)
@@ -1159,6 +1168,13 @@ public int runPreprocessor(ref const Loc loc, const(char)[] cpp, const(char)[] f
         // 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 @@
+// LINK(windows):
+// REQUIRED_ARGS: -os=windows
+// PERMUTE_ARGS: -betterC -i
+// 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
+
+// Just so the linker doesn't complain.
+int main(void)
+{
+    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 \