[ADT] Add llvm::to_float

[labath]

Summary

The function matches the interface of llvm::to_integer, but as we are
calling out to a C library function (implementing it ourselves seemed
way too complicated), I let it take a Twine argument, so we can avoid a
string copy at least in some cases.

I add a test and replace a couple of existing uses of strtod with this
function.

[zturner]

We also have APFloat::convertFromString, but it looks like it doesn't easily support long double. So, I guess this seems fine to me, but maybe wait a little longer and see if anyone else has suggestions

[efriedma]

it looks like it doesn't easily support long double

APFloat::convertFromString works for every floating-point type supported by APFloat; clang uses it to parse floating-point literals. There isn't any convenient way to convert an APFloat to a long double, but that's mostly because there hasn't been any demand for it; the format of long double is platform-dependent.

[labath]

In D34518#788213, @efriedma wrote:

it looks like it doesn't easily support long double

APFloat::convertFromString works for every floating-point type supported by APFloat; clang uses it to parse floating-point literals. There isn't any convenient way to convert an APFloat to a long double, but that's mostly because there hasn't been any demand for it; the format of long double is platform-dependent.

I don't actually need long double support right now -- I just added it because it was easy.

So the lack of long double would not be a show-stopper for using an APFloat-based solution. However, the convertFromString seems to assume that the input string has already been checked for correctness, as it is full of asserts. This means it's impossible to use it as a drop in replacement for the "parse me this string I got from the user" type of functionality, which is what the existing users of strtod do, and what I intended to use it for. That could of course be fixed, but given that we don't need the fancy features of APFloat here, and strtod is readily available everywhere, I am not sure if it's really worth it.

include/llvm/ADT/StringExtras.h

 // This file contains some functions that are useful when dealing with strings.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STRINGEXTRAS_H
 #define LLVM_ADT_STRINGEXTRAS_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <iterator>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 template<typename T> class SmallVectorImpl;

 
 /// \brief Convert the string \p S to an integer of the specified type using
 /// the radix \p Base.  If \p Base is 0, auto-detects the radix.
 /// Returns true if the number was successfully converted, false otherwise.
 template <typename N> bool to_integer(StringRef S, N &Num, unsigned Base = 0) {
   return !S.getAsInteger(Base, Num);
 }
 
+namespace detail {
+template <typename N>
+inline bool to_float(const Twine &T, N &Num, N (*StrTo)(const char *, char **)) {
+  SmallString<32> Storage;
+  StringRef S = T.toNullTerminatedStringRef(Storage);
+  char *End;
+  N Temp = StrTo(S.data(), &End);
+  if (*End != '\0')
+    return false;
+  Num = Temp;
+  return true;
+}
+}
+
+inline bool to_float(const Twine &T, float &Num) {
+  return detail::to_float(T, Num, std::strtof);
+}
+
+inline bool to_float(const Twine &T, double &Num) {
+  return detail::to_float(T, Num, std::strtod);
+}
+
+inline bool to_float(const Twine &T, long double &Num) {
+  return detail::to_float(T, Num, std::strtold);
+}
+
 static inline std::string utostr(uint64_t X, bool isNeg = false) {
   char Buffer[21];
   char *BufPtr = std::end(Buffer);
 
   if (X == 0) *--BufPtr = '0';  // Handle special case...
 
   while (X) {
     *--BufPtr = '0' + char(X % 10);

lib/Support/CommandLine.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm-c/Support.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
bool parser<unsigned long long>::parse(Option &O, StringRef ArgName,
   if (Arg.getAsInteger(0, Value))
     return O.error("'" + Arg + "' value invalid for uint argument!");
   return false;
 }
 
 // parser<double>/parser<float> implementation
 //
 static bool parseDouble(Option &O, StringRef Arg, double &Value) {
-  SmallString<32> TmpStr(Arg.begin(), Arg.end());
-  const char *ArgStart = TmpStr.c_str();
-  char *End;
-  Value = strtod(ArgStart, &End);
-  if (*End != 0)
-    return O.error("'" + Arg + "' value invalid for floating point argument!");
+  if (to_float(Arg, Value))
     return false;
+  return O.error("'" + Arg + "' value invalid for floating point argument!");
 }
 
 bool parser<double>::parse(Option &O, StringRef ArgName, StringRef Arg,
                            double &Val) {
   return parseDouble(O, Arg, Val);
 }
 
 bool parser<float>::parse(Option &O, StringRef ArgName, StringRef Arg,

lib/Support/YAMLTraits.cpp

 //===- lib/Support/YAMLTraits.cpp -----------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
StringRef ScalarTraits<int64_t>::input(StringRef Scalar, void *, int64_t &Val) {
   return StringRef();
 }
 
 void ScalarTraits<double>::output(const double &Val, void *, raw_ostream &Out) {
   Out << format("%g", Val);
 }
 
 StringRef ScalarTraits<double>::input(StringRef Scalar, void *, double &Val) {
-  SmallString<32> buff(Scalar.begin(), Scalar.end());
-  char *end;
-  Val = strtod(buff.c_str(), &end);
-  if (*end != '\0')
-    return "invalid floating point number";
+  if (to_float(Scalar, Val))
     return StringRef();
+  return "invalid floating point number";
 }
 
 void ScalarTraits<float>::output(const float &Val, void *, raw_ostream &Out) {
   Out << format("%g", Val);
 }
 
 StringRef ScalarTraits<float>::input(StringRef Scalar, void *, float &Val) {
-  SmallString<32> buff(Scalar.begin(), Scalar.end());
-  char *end;
-  Val = strtod(buff.c_str(), &end);
-  if (*end != '\0')
-    return "invalid floating point number";
+  if (to_float(Scalar, Val))
     return StringRef();
+  return "invalid floating point number";
 }
 
 void ScalarTraits<Hex8>::output(const Hex8 &Val, void *, raw_ostream &Out) {
   uint8_t Num = Val;
   Out << format("0x%02X", Num);
 }
 
 StringRef ScalarTraits<Hex8>::input(StringRef Scalar, void *, Hex8 &Val) {

unittests/ADT/StringExtrasTest.cpp

TEST(StringExtrasTest, ToAndFromHex) {
   EXPECT_EQ(OddData, fromHex(StringRef(OddStr).drop_front()));
 
   std::vector<uint8_t> EvenBytes = {0xA5, 0xBD, 0x0D, 0x3E, 0xCD};
   std::string EvenStr = "A5BD0D3ECD";
   StringRef EvenData(reinterpret_cast<const char *>(EvenBytes.data()),
                      EvenBytes.size());
   EXPECT_EQ(EvenStr, toHex(EvenData));
   EXPECT_EQ(EvenData, fromHex(EvenStr));
-}
+}
+
+TEST(StringExtrasTest, to_float) {
+  float F;
+  EXPECT_TRUE(to_float("4.7", F));
+  EXPECT_FLOAT_EQ(4.7, F);
+
+  double D;
+  EXPECT_TRUE(to_float("4.7", D));
+  EXPECT_DOUBLE_EQ(4.7, D);
+
+  long double LD;
+  EXPECT_TRUE(to_float("4.7", LD));
+  EXPECT_DOUBLE_EQ(4.7, LD);
+
+  EXPECT_FALSE(to_float("foo", F));
+  EXPECT_FALSE(to_float("7.4 foo", F));
+  EXPECT_FLOAT_EQ(4.7, F); // F should be unchanged
+}