Add a c_str() method to StringRef, similar to data() but asserting if the string isn't null terminated (NFC)

[mehdi_amini]

Summary

As I'm trying to replace our uses of raw "const char *"
with StringRef, one issue that came up is that calling .data()
on a StringRef is seen as "dangerous": there is no guarantee
that the String will be null terminated.

This is an attempt to alleviate this issue: instead of calling
data(), users that knows (because of an API contract) that a
StringRef must be null terminated can call c_str() instead.

[zturner]

Not sure how I feel about this. It's convenient, but it has potential for abuse. Where did you run into issues porting code to StringRef that this solves? I've done a lot of StringRef porting in LLDB by now, and I've always managed to find a solution to this. Usually it involves trickling the StringRef changes down further (often in a separate CL that can be made more isolated) and then coming back to your original CL, where now you have StringRefs to work with rather than const char *. Does that not work in your cases?

[mehdi_amini]

In D25255#561566, @zturner wrote:

Not sure how I feel about this. It's convenient, but it has potential for abuse. Where did you run into issues porting code to StringRef that this solves?

I ran into this with "printf" like API at some point, or with places that can't be converted to StringRef because of space constraint, like MachineOperand. So you're out of the IR and you have to use .data() to initialize the MO. Later you may construct a StringRef from this "const char *" again.

I've done a lot of StringRef porting in LLDB by now, and I've always managed to find a solution to this. Usually it involves trickling the StringRef changes down further

Usually that's what I do, yes. The problem is when you reach some cases like above.

[mehdi_amini]

The conclusion on the email thread is that StringRef is not suitable to represent C-string, and we need a new separate class for that. In the meantime, clients will have to live with .data()

llvm/include/llvm/ADT/StringRef.h

 //===--- StringRef.h - Constant String Reference Wrapper --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STRINGREF_H
 #define LLVM_ADT_STRINGREF_H
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <limits>
 #include <string>
 #include <utility>
 
 namespace llvm {
public:
     /// @name String Operations
     /// @{
 
     /// data - Get a pointer to the start of the string (which may not be null
     /// terminated).
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     const char *data() const { return Data; }
 
+    /// Get a pointer to the start of the string, enforcing that it is null
+    /// terminated. This is intended to be used when the contract of the API is
+    /// to return a null terminated string.
+    const char *c_str() const {
+#if !defined(NDEBUG) || LLVM_ADDRESS_SANITIZER_BUILD ||                        \
+    LLVM_MEMORY_SANITIZER_BUILD
+      if (Data[size()] != '\0')
+        report_fatal_error("c_str() called on a non-null terminated string");
+#endif
+      return Data;
+    }
+
     /// empty - Check if the string is empty.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     bool empty() const { return Length == 0; }
 
     /// size - Get the string size.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     size_t size() const { return Length; }