Add scalar lowering for sqrt intrinsic.

crosstest/test_arith_main.cpp

 /* crosstest.py --test=test_arith.cpp --test=test_arith_frem.ll \
-   --driver=test_arith_main.cpp --prefix=Subzero_ --output=test_arith */
+   --test=test_arith_sqrt.ll --driver=test_arith_main.cpp \
+   --prefix=Subzero_ --output=test_arith */
 
 #include <stdint.h>
 
 #include <cfloat>
 #include <cstring> // memcmp
 #include <iostream>
 
 // Include test_arith.h twice - once normally, and once within the
 // Subzero_ namespace, corresponding to the llc and Subzero translated
 // object files, respectively.
@@ skipping 103 matching lines @@
       }
     }
   }
 }
 
 template <typename Type>
 void testsFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   static const Type NegInf = -1.0 / 0.0;
   static const Type PosInf = 1.0 / 0.0;
   static const Type Nan = 0.0 / 0.0;
+  static const Type NegNan = -0.0 / 0.0;
   volatile Type Values[] = {
     0,                    1,                    0x7e,
     0x7f,                 0x80,                 0x81,
     0xfe,                 0xff,                 0x7ffe,
     0x7fff,               0x8000,               0x8001,
     0xfffe,               0xffff,               0x7ffffffe,
     0x7fffffff,           0x80000000,           0x80000001,
     0xfffffffe,           0xffffffff,           0x100000000ll,
     0x100000001ll,        0x7ffffffffffffffell, 0x7fffffffffffffffll,
     0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell,
     0xffffffffffffffffll, NegInf,               PosInf,
-    Nan,                  FLT_MIN,              FLT_MAX,
+    Nan,                  NegNan,               -0.0,
+    FLT_MIN,              FLT_MAX,
     DBL_MIN,              DBL_MAX
   };
   const static size_t NumValues = sizeof(Values) / sizeof(*Values);
   typedef Type (*FuncType)(Type, Type);
   static struct {
     const char *Name;
     FuncType FuncLlc;
     FuncType FuncSz;
   } Funcs[] = {
 #define X(inst, op, func)                                                      \
@@ skipping 18 matching lines @@
         } else {
           ++Failures;
           std::cout << std::fixed << "test" << Funcs[f].Name
                     << (8 * sizeof(Type)) << "(" << Value1 << ", " << Value2
                     << "): sz=" << ResultSz << " llc=" << ResultLlc
                     << std::endl;
         }
       }
     }
   }
+  for (size_t i = 0; i < NumValues; ++i) {
+    Type Value = Values[i];
+    ++TotalTests;
+    Type ResultSz = Subzero_::mySqrt(Value);
+    Type ResultLlc = mySqrt(Value);
+    // Compare results using memcmp() in case they are both NaN.
+    if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
+      ++Passes;
+    } else {
+      ++Failures;
+      std::cout << std::fixed << "test_sqrt"
+                << (8 * sizeof(Type)) << "(" << Value
+                << "): sz=" << ResultSz << " llc=" << ResultLlc
+                << std::endl;
+    }
+  }
 }
 
 int main(int argc, char **argv) {
   size_t TotalTests = 0;
   size_t Passes = 0;
   size_t Failures = 0;
 
   testsInt<uint8_t, int8_t>(TotalTests, Passes, Failures);
   testsInt<uint16_t, int16_t>(TotalTests, Passes, Failures);
   testsInt<uint32_t, int32_t>(TotalTests, Passes, Failures);
   testsInt<uint64_t, int64_t>(TotalTests, Passes, Failures);
   testsFp<float>(TotalTests, Passes, Failures);
   testsFp<double>(TotalTests, Passes, Failures);
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }