diff --git a/src/core/bitop.d b/src/core/bitop.d
index ebfdda67a3..5c00f99226 100644
--- a/src/core/bitop.d
+++ b/src/core/bitop.d
@@ -30,6 +30,7 @@ else version (X86)
  *      The bit number of the first bit set.
  *      The return value is undefined if v is zero.
  */
+pragma(DigitalMars_intrinsic, "bsf")
 int bsf(size_t v) pure;
 
 ///
@@ -46,6 +47,7 @@ unittest
  *      The bit number of the first bit set.
  *      The return value is undefined if v is zero.
  */
+pragma(DigitalMars_intrinsic, "bsr")
 int bsr(size_t v) pure;
 
 ///
@@ -84,12 +86,14 @@ int bt(in size_t* p, size_t bitnum) pure @system
 /**
  * Tests and complements the bit.
  */
+pragma(DigitalMars_intrinsic, "btc")
 int btc(size_t* p, size_t bitnum) pure @system;
 
 
 /**
  * Tests and resets (sets to 0) the bit.
  */
+pragma(DigitalMars_intrinsic, "btr")
 int btr(size_t* p, size_t bitnum) pure @system;
 
 
@@ -106,6 +110,7 @@ p[index / (size_t.sizeof*8)] & (1 << (index & ((size_t.sizeof*8) - 1)))
  *      A non-zero value if the bit was set, and a zero
  *      if it was clear.
  */
+pragma(DigitalMars_intrinsic, "bts")
 int bts(size_t* p, size_t bitnum) pure @system;
 
 ///
@@ -154,6 +159,7 @@ int bts(size_t* p, size_t bitnum) pure @system;
  * byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3
  * becomes byte 0.
  */
+pragma(DigitalMars_intrinsic, "bswap")
 uint bswap(uint v) pure;
 
 version (DigitalMars) version (AnyX86) @system // not pure
@@ -161,36 +167,42 @@ version (DigitalMars) version (AnyX86) @system // not pure
     /**
      * Reads I/O port at port_address.
      */
+    pragma(DigitalMars_intrinsic, "inp")
     ubyte inp(uint port_address);
 
 
     /**
      * ditto
      */
+    pragma(DigitalMars_intrinsic, "inp")
     ushort inpw(uint port_address);
 
 
     /**
      * ditto
      */
+    pragma(DigitalMars_intrinsic, "inp")
     uint inpl(uint port_address);
 
 
     /**
      * Writes and returns value to I/O port at port_address.
      */
+    pragma(DigitalMars_intrinsic, "outp")
     ubyte outp(uint port_address, ubyte value);
 
 
     /**
      * ditto
      */
+    pragma(DigitalMars_intrinsic, "outp")
     ushort outpw(uint port_address, ushort value);
 
 
     /**
      * ditto
      */
+    pragma(DigitalMars_intrinsic, "outp")
     uint outpl(uint port_address, uint value);
 }
 
@@ -201,12 +213,15 @@ version (AnyX86)
      * using the X86 SSE4 POPCNT instruction.
      * POPCNT is not available on all X86 CPUs.
      */
+    pragma(DigitalMars_intrinsic, "popcnt")
     ushort _popcnt( ushort x ) pure;
     /// ditto
+    pragma(DigitalMars_intrinsic, "popcnt")
     int _popcnt( uint x ) pure;
     version (X86_64)
     {
         /// ditto
+        pragma(DigitalMars_intrinsic, "popcnt")
         int _popcnt( ulong x ) pure;
     }
 
@@ -276,15 +291,21 @@ version (AnyX86)
  * They may be used to guarantee a write or read cycle occurs at a specified address.
  */
 
-ubyte  volatileLoad(ubyte * ptr);
-ushort volatileLoad(ushort* ptr);  /// ditto
-uint   volatileLoad(uint  * ptr);  /// ditto
-ulong  volatileLoad(ulong * ptr);  /// ditto
+pragma(DigitalMars_intrinsic, "ind")
+{
+    ubyte  volatileLoad(ubyte * ptr);
+    ushort volatileLoad(ushort* ptr);  /// ditto
+    uint   volatileLoad(uint  * ptr);  /// ditto
+    ulong  volatileLoad(ulong * ptr);  /// ditto
+}
 
-void volatileStore(ubyte * ptr, ubyte  value);   /// ditto
-void volatileStore(ushort* ptr, ushort value);   /// ditto
-void volatileStore(uint  * ptr, uint   value);   /// ditto
-void volatileStore(ulong * ptr, ulong  value);   /// ditto
+pragma(DigitalMars_intrinsic, "eq")
+{
+    void volatileStore(ubyte * ptr, ubyte  value);   /// ditto
+    void volatileStore(ushort* ptr, ushort value);   /// ditto
+    void volatileStore(uint  * ptr, uint   value);   /// ditto
+    void volatileStore(ulong * ptr, ulong  value);   /// ditto
+}
 
 @system unittest
 {
diff --git a/src/core/math.d b/src/core/math.d
index 0541cf3dbe..e12c424888 100644
--- a/src/core/math.d
+++ b/src/core/math.d
@@ -40,6 +40,7 @@ public:
  *      Results are undefined if |x| >= $(POWER 2,64).
  */
 
+pragma(DigitalMars_intrinsic, "cos")
 real cos(real x) @safe pure nothrow;       /* intrinsic */
 
 /***********************************
@@ -55,6 +56,7 @@ real cos(real x) @safe pure nothrow;       /* intrinsic */
  *      Results are undefined if |x| >= $(POWER 2,64).
  */
 
+pragma(DigitalMars_intrinsic, "sin")
 real sin(real x) @safe pure nothrow;       /* intrinsic */
 
 /*****************************************
@@ -63,6 +65,7 @@ real sin(real x) @safe pure nothrow;       /* intrinsic */
  * greater than long.max, the result is
  * indeterminate.
  */
+pragma(DigitalMars_intrinsic, "rndtol")
 long rndtol(real x) @safe pure nothrow;    /* intrinsic */
 
 
@@ -85,6 +88,7 @@ extern (C) real rndtonl(real x);
  *      )
  */
 
+pragma(DigitalMars_intrinsic, "sqrt")
 @safe pure nothrow
 {
     float sqrt(float x);    /* intrinsic */
@@ -97,6 +101,7 @@ extern (C) real rndtonl(real x);
  * References: frexp
  */
 
+pragma(DigitalMars_intrinsic, "scale")
 real ldexp(real n, int exp) @safe pure nothrow;    /* intrinsic */
 
 unittest {
@@ -124,6 +129,7 @@ unittest {
  *      $(TR $(TD $(PLUSMN)$(INFIN)) $(TD +$(INFIN)) )
  *      )
  */
+pragma(DigitalMars_intrinsic, "abs")
 real fabs(real x) @safe pure nothrow;      /* intrinsic */
 
 /**********************************
@@ -134,6 +140,7 @@ real fabs(real x) @safe pure nothrow;      /* intrinsic */
  * $(B nearbyint) performs
  * the same operation, but does not set the FE_INEXACT exception.
  */
+pragma(DigitalMars_intrinsic, "rint")
 real rint(real x) @safe pure nothrow;      /* intrinsic */
 
 /***********************************
@@ -141,7 +148,9 @@ real rint(real x) @safe pure nothrow;      /* intrinsic */
  * translate to a single x87 instruction.
  */
 
+pragma(DigitalMars_intrinsic, "yl2x")
 real yl2x(real x, real y)   @safe pure nothrow;       // y * log2(x)
+pragma(DigitalMars_intrinsic, "yl2xp1")
 real yl2xp1(real x, real y) @safe pure nothrow;       // y * log2(x + 1)
 
 unittest