diff --git a/include/llvm/ADT/StringRef.h b/include/llvm/ADT/StringRef.h index ec0c2849f37..a35dfbfebac 100644 --- a/include/llvm/ADT/StringRef.h +++ b/include/llvm/ADT/StringRef.h @@ -10,6 +10,8 @@ #ifndef LLVM_ADT_STRINGREF_H #define LLVM_ADT_STRINGREF_H +#include "llvm/Support/Compiler.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/type_traits.h" #include #include @@ -70,7 +72,7 @@ namespace llvm { /// @{ /// Construct an empty string ref. - /*implicit*/ StringRef() : Data(0), Length(0) {} + /*implicit*/ LLVM_CONSTEXPR StringRef() : Data(0), Length(0) {} /// Construct a string ref from a cstring. /*implicit*/ StringRef(const char *Str) @@ -80,11 +82,8 @@ namespace llvm { } /// Construct a string ref from a pointer and length. - /*implicit*/ StringRef(const char *data, size_t length) - : Data(data), Length(length) { - assert((data || length == 0) && - "StringRef cannot be built from a NULL argument with non-null length"); - } + /*implicit*/ LLVM_CONSTEXPR StringRef(const char *data, size_t length) + : Data(data), Length((llvm_expect(data || length == 0), length)) {} /// Construct a string ref from an std::string. /*implicit*/ StringRef(const std::string &Str) @@ -104,24 +103,20 @@ namespace llvm { /// data - Get a pointer to the start of the string (which may not be null /// terminated). - const char *data() const { return Data; } + LLVM_CONSTEXPR const char *data() const { return Data; } /// empty - Check if the string is empty. - bool empty() const { return Length == 0; } + LLVM_CONSTEXPR bool empty() const { return Length == 0; } /// size - Get the string size. - size_t size() const { return Length; } + LLVM_CONSTEXPR size_t size() const { return Length; } /// front - Get the first character in the string. - char front() const { - assert(!empty()); - return Data[0]; - } + LLVM_CONSTEXPR char front() const { return llvm_expect(!empty()), Data[0]; } /// back - Get the last character in the string. - char back() const { - assert(!empty()); - return Data[Length-1]; + LLVM_CONSTEXPR char back() const { + return llvm_expect(!empty()), Data[Length - 1]; } /// equals - Check for string equality, this is more efficient than @@ -187,9 +182,8 @@ namespace llvm { /// @name Operator Overloads /// @{ - char operator[](size_t Index) const { - assert(Index < Length && "Invalid index!"); - return Data[Index]; + LLVM_CONSTEXPR char operator[](size_t Index) const { + return llvm_expect(Index < Length), Data[Index]; } /// @} @@ -547,6 +541,20 @@ namespace llvm { /// @} + /// ConstStringRef - A \c StringRef carrying the additional stipulation that + /// the referenced string is a compile-time constant. + /// + /// Use this to specify function parameters that require fixed inputs such + /// as debug and diagnostic messages or format strings. + class ConstStringRef : public StringRef { + public: + /*implicit*/ LLVM_CONSTEXPR ConstStringRef() : StringRef() {} + + template + /*implicit*/ LLVM_CONSTEXPR ConstStringRef(const char (&data)[N]) + : StringRef(data, (llvm_expect(N > 0 && data[N - 1] == '\0'), N - 1)) {} + }; + /// \brief Compute a hash_code for a StringRef. hash_code hash_value(StringRef S); diff --git a/include/llvm/Support/ErrorHandling.h b/include/llvm/Support/ErrorHandling.h index b948d97bff9..d2f16821bff 100644 --- a/include/llvm/Support/ErrorHandling.h +++ b/include/llvm/Support/ErrorHandling.h @@ -15,11 +15,11 @@ #ifndef LLVM_SUPPORT_ERRORHANDLING_H #define LLVM_SUPPORT_ERRORHANDLING_H -#include "llvm/ADT/StringRef.h" #include "llvm/Support/Compiler.h" #include namespace llvm { + class StringRef; class Twine; /// An error handler callback. @@ -78,7 +78,7 @@ namespace llvm { bool gen_crash_diag = true); LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const std::string &reason, bool gen_crash_diag = true); - LLVM_ATTRIBUTE_NORETURN void report_fatal_error(StringRef reason, + LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const StringRef &reason, bool gen_crash_diag = true); LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const Twine &reason, bool gen_crash_diag = true); @@ -108,4 +108,14 @@ namespace llvm { #define llvm_unreachable(msg) ::llvm::llvm_unreachable_internal() #endif +/// An assert macro that's usable in constexprs and that becomes an optimizer +/// hint in NDEBUG builds. +/// +/// Unlike \c assert() the \param test expression may be evaluated in optimized +/// builds and so should be simple, accurate and never have side effects. +#define llvm_expect(test) (void)(!!(test) ? 0 : (llvm_unreachable(#test), 0)) + +// TODO: Update other headers to explicitly include StringRef.h and drop this. +#include "llvm/ADT/StringRef.h" + #endif diff --git a/lib/Support/ErrorHandling.cpp b/lib/Support/ErrorHandling.cpp index 1aa8303b9e2..141319ca4ea 100644 --- a/lib/Support/ErrorHandling.cpp +++ b/lib/Support/ErrorHandling.cpp @@ -58,7 +58,7 @@ void llvm::report_fatal_error(const std::string &Reason, bool GenCrashDiag) { report_fatal_error(Twine(Reason), GenCrashDiag); } -void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) { +void llvm::report_fatal_error(const StringRef &Reason, bool GenCrashDiag) { report_fatal_error(Twine(Reason), GenCrashDiag); } diff --git a/unittests/ADT/StringRefTest.cpp b/unittests/ADT/StringRefTest.cpp index 0ab8fcf6f00..b240a87ef75 100644 --- a/unittests/ADT/StringRefTest.cpp +++ b/unittests/ADT/StringRefTest.cpp @@ -531,4 +531,22 @@ TEST(StringRefTest, joinStrings) { EXPECT_TRUE(v2_join3); } +static void fn_stringref(StringRef str) { + EXPECT_TRUE(str == "hello"); +} +static void fn_conststringref(ConstStringRef str) { + fn_stringref(str); +} + +TEST(StringRefTest, constStringRef) { + LLVM_CONSTEXPR ConstStringRef csr("hello"); +#if __has_feature(cxx_constexpr) || defined(__GXX_EXPERIMENTAL_CXX0X__) + LLVM_STATIC_ASSERT(csr[0] != csr[1], ""); + LLVM_STATIC_ASSERT(csr[2] == csr[3], ""); + LLVM_STATIC_ASSERT(csr.size() == 5, ""); +#endif + llvm_expect(csr[2] == csr[3]); + fn_conststringref(csr); +} + } // end anonymous namespace