[ADT] Force attribute used on functions marked as always_inline.

[davide]

Summary

If the functions are always inlined, the compiler is not forced
to emit their body, so the debugger can't evaluate them.

e.g.

$1 = (StringRef) "patatino"
(lldb) expr $1.size()
error: Couldn't lookup symbols:

attribute((used)) forces the symbols to be emitted even if
they're not referenced. An alternatve proposed was that of
dropping always_inline entirely from LLVM, as it should be
used exclusively where not inlining a function causes correctness
issues. Some concerns have been raised about tblgen being too
slow without the annotations.

[dexonsmith]

llvm/include/llvm/ADT/SmallVector.h

128

I don't think we want this for Release or RelWithDebInfo builds since it will bloat the binaries. How is LLVM_ATTRIBUTE_USED conditionalized in those cases?

llvm/include/llvm/ADT/StringRef.h

127

This already has LLVM_NODISCARD. How does that differ from LLVM_ATTRIBUTE_USED?

[davide]

llvm/include/llvm/ADT/SmallVector.h

128

Thanks, I agree this should be emitted only at -O0.
Is there an easy way of conveying that information?

llvm/include/llvm/ADT/StringRef.h

127

They're completely different attributes, to the best of my knowledge.

1. attribute((used)) forces the symbol to be emitted even if unreferenced.

http://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Variable-Attributes.html

2. [[nodiscard]] causes the compiler to emit a warning if the return value is discarded.

https://en.cppreference.com/w/cpp/language/attributes

Example:

* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100000fa3 a.out`main at pat.cpp:12:3
   9   	
   10  	int main(void) {
   11  	  Baciotto blondie;
-> 12  	  return blondie.patatino();
   13  	}
(lldb) p blondie
(Baciotto) $0 = {}
(lldb) p blondie.patatino()
(int) $1 = 23
(lldb) ^D
Davides-Mac-Pro:bin davide$ cat pat.cpp 
class Baciotto {
public:
  __attribute__((used))
  __attribute__((always_inline))
  int patatino() {
    return 23;
  }
};

int main(void) {
  Baciotto blondie;
  return blondie.patatino();
}

If you use [[nodiscard]], the symbol won't be emitted.

[chandlerc]

I honestly still think this is a poor alternative. I much prefer optimized tablegen if it matters. I'd much prefer defaulting to that in non-release builds as well. I think we should be using fewer attributes to manually hijack the optimizer and instead simply let the optimizer do its job when it is needed. =/

[mehdi_amini]

What about creating a new macrothat carry the semantic we're looking for here: "LLVM_KEEP_FOR_DEBUG"?
We can conditionally define it based on NDEBUG or add a CMake flag for it that is enabled in debug build (the latter has the advantage that it would allow to turn it on even in release builds when needing to debug these)

[davide]

In D56567#1353607, @chandlerc wrote:

I honestly still think this is a poor alternative. I much prefer optimized tablegen if it matters. I'd much prefer defaulting to that in non-release builds as well. I think we should be using fewer attributes to manually hijack the optimizer and instead simply let the optimizer do its job when it is needed. =/

There's no optimizer here as this is, by definition, unoptimized code.
I tend to share your feelings here about the fact that slapping bajillion attributes on functions isn't great.
I don't have any strong preferences (I just care about evaluating expression in the debugger :), I'm just mostly worried that the slowdown might be unacceptable for people. But I assume we can always re-evaluate this later.

[davide]

In D56567#1353608, @mehdi_amini wrote:

What about creating a new macrothat carry the semantic we're looking for here: "LLVM_KEEP_FOR_DEBUG"?
We can conditionally define it based on NDEBUG or add a CMake flag for it that is enabled in debug build (the latter has the advantage that it would allow to turn it on even in release builds when needing to debug these)

In case we decide to go this route, I guess something like this will do.

[danilaml]

How big is the slowdown?

[davide]

Decided to go with a different approach.

llvm/include/llvm/ADT/SmallVector.h

public:
   using reverse_iterator = std::reverse_iterator<iterator>;
 
   using reference = T &;
   using const_reference = const T &;
   using pointer = T *;
   using const_pointer = const T *;
 
   // forward iterator creation methods.
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   iterator begin() { return (iterator)this->BeginX; }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   const_iterator begin() const { return (const_iterator)this->BeginX; }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   iterator end() { return begin() + size(); }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   const_iterator end() const { return begin() + size(); }
 
   // reverse iterator creation methods.
   reverse_iterator rbegin()            { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
   reverse_iterator rend()              { return reverse_iterator(begin()); }
   const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
 
   size_type size_in_bytes() const { return size() * sizeof(T); }
   size_type max_size() const { return size_type(-1) / sizeof(T); }
 
   size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
 
   /// Return a pointer to the vector's buffer, even if empty().
   pointer data() { return pointer(begin()); }
   /// Return a pointer to the vector's buffer, even if empty().
   const_pointer data() const { return const_pointer(begin()); }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   reference operator[](size_type idx) {
     assert(idx < size());
     return begin()[idx];
   }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   const_reference operator[](size_type idx) const {
     assert(idx < size());
     return begin()[idx];
   }
 
   reference front() {
     assert(!empty());
     return begin()[0];

llvm/include/llvm/ADT/StringRef.h

private:
     /// The start of the string, in an external buffer.
     const char *Data = nullptr;
 
     /// The length of the string.
     size_t Length = 0;
 
     // Workaround memcmp issue with null pointers (undefined behavior)
     // by providing a specialized version
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     static int compareMemory(const char *Lhs, const char *Rhs, size_t Length) {
       if (Length == 0) { return 0; }
       return ::memcmp(Lhs,Rhs,Length);
     }
 
   public:
     /// @name Constructors
     /// @{
 
     /// Construct an empty string ref.
     /*implicit*/ StringRef() = default;
 
     /// Disable conversion from nullptr.  This prevents things like
     /// if (S == nullptr)
     StringRef(std::nullptr_t) = delete;
 
     /// Construct a string ref from a cstring.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     /*implicit*/ StringRef(const char *Str)
         : Data(Str), Length(Str ? ::strlen(Str) : 0) {}
 
     /// Construct a string ref from a pointer and length.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     /*implicit*/ constexpr StringRef(const char *data, size_t length)
         : Data(data), Length(length) {}
 
     /// Construct a string ref from an std::string.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     /*implicit*/ StringRef(const std::string &Str)
       : Data(Str.data()), Length(Str.length()) {}
 
     static StringRef withNullAsEmpty(const char *data) {
       return StringRef(data ? data : "");
     }
 
     /// @}
public:
 
     /// @}
     /// @name String Operations
     /// @{
 
     /// data - Get a pointer to the start of the string (which may not be null
     /// terminated).
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     const char *data() const { return Data; }
 
     /// empty - Check if the string is empty.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool empty() const { return Length == 0; }
 
     /// size - Get the string size.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     size_t size() const { return Length; }
 
     /// front - Get the first character in the string.
     LLVM_NODISCARD
     char front() const {
       assert(!empty());
       return Data[0];
     }
LLVM_NODISCARD StringRef copy(Allocator &A) const {
       char *S = A.template Allocate<char>(Length);
       std::copy(begin(), end(), S);
       return StringRef(S, Length);
     }
 
     /// equals - Check for string equality, this is more efficient than
     /// compare() when the relative ordering of inequal strings isn't needed.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool equals(StringRef RHS) const {
       return (Length == RHS.Length &&
               compareMemory(Data, RHS.Data, RHS.Length) == 0);
     }
 
     /// equals_lower - Check for string equality, ignoring case.
     LLVM_NODISCARD
     bool equals_lower(StringRef RHS) const {
       return Length == RHS.Length && compare_lower(RHS) == 0;
     }
 
     /// compare - Compare two strings; the result is -1, 0, or 1 if this string
     /// is lexicographically less than, equal to, or greater than the \p RHS.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     int compare(StringRef RHS) const {
       // Check the prefix for a mismatch.
       if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length)))
         return Res < 0 ? -1 : 1;
 
       // Otherwise the prefixes match, so we only need to check the lengths.
       if (Length == RHS.Length)
         return 0;
public:
     }
 
     /// @}
     /// @name String Predicates
     /// @{
 
     /// Check if this string starts with the given \p Prefix.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool startswith(StringRef Prefix) const {
       return Length >= Prefix.Length &&
              compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
     }
 
     /// Check if this string starts with the given \p Prefix, ignoring case.
     LLVM_NODISCARD
     bool startswith_lower(StringRef Prefix) const;
 
     /// Check if this string ends with the given \p Suffix.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool endswith(StringRef Suffix) const {
       return Length >= Suffix.Length &&
         compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
     }
 
     /// Check if this string ends with the given \p Suffix, ignoring case.
     LLVM_NODISCARD
     bool endswith_lower(StringRef Suffix) const;
 
     /// @}
     /// @name String Searching
     /// @{
 
     /// Search for the first character \p C in the string.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     size_t find(char C, size_t From = 0) const {
       size_t FindBegin = std::min(From, Length);
       if (FindBegin < Length) { // Avoid calling memchr with nullptr.
         // Just forward to memchr, which is faster than a hand-rolled loop.
         if (const void *P = ::memchr(Data + FindBegin, C, Length - FindBegin))
           return static_cast<const char *>(P) - Data;
       }
       return npos;
     }
 
     /// Search for the first character \p C in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
     size_t find_lower(char C, size_t From = 0) const;
 
     /// Search for the first character satisfying the predicate \p F
     ///
     /// \returns The index of the first character satisfying \p F starting from
     /// \p From, or npos if not found.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     size_t find_if(function_ref<bool(char)> F, size_t From = 0) const {
       StringRef S = drop_front(From);
       while (!S.empty()) {
         if (F(S.front()))
           return size() - S.size();
         S = S.drop_front();
       }
       return npos;
     }
 
     /// Search for the first character not satisfying the predicate \p F
     ///
     /// \returns The index of the first character not satisfying \p F starting
     /// from \p From, or npos if not found.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     size_t find_if_not(function_ref<bool(char)> F, size_t From = 0) const {
       return find_if([F](char c) { return !F(c); }, From);
     }
 
     /// Search for the first string \p Str in the string.
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
public:
     ///
     /// Complexity: O(size() + Chars.size())
     LLVM_NODISCARD
     size_t find_last_not_of(StringRef Chars, size_t From = npos) const;
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool contains(StringRef Other) const { return find(Other) != npos; }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool contains(char C) const { return find_first_of(C) != npos; }
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool contains_lower(StringRef Other) const {
       return find_lower(Other) != npos;
     }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool contains_lower(char C) const { return find_lower(C) != npos; }
 
     /// @}
     /// @name Helpful Algorithms
     /// @{
 
     /// Return the number of occurrences of \p C in the string.
     LLVM_NODISCARD
public:
     /// \param Start The index of the starting character in the substring; if
     /// the index is npos or greater than the length of the string then the
     /// empty substring will be returned.
     ///
     /// \param N The number of characters to included in the substring. If N
     /// exceeds the number of characters remaining in the string, the string
     /// suffix (starting with \p Start) will be returned.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef substr(size_t Start, size_t N = npos) const {
       Start = std::min(Start, Length);
       return StringRef(Data + Start, std::min(N, Length - Start));
     }
 
     /// Return a StringRef equal to 'this' but with only the first \p N
     /// elements remaining.  If \p N is greater than the length of the
     /// string, the entire string is returned.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef take_front(size_t N = 1) const {
       if (N >= size())
         return *this;
       return drop_back(size() - N);
     }
 
     /// Return a StringRef equal to 'this' but with only the last \p N
     /// elements remaining.  If \p N is greater than the length of the
     /// string, the entire string is returned.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef take_back(size_t N = 1) const {
       if (N >= size())
         return *this;
       return drop_front(size() - N);
     }
 
     /// Return the longest prefix of 'this' such that every character
     /// in the prefix satisfies the given predicate.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef take_while(function_ref<bool(char)> F) const {
       return substr(0, find_if_not(F));
     }
 
     /// Return the longest prefix of 'this' such that no character in
     /// the prefix satisfies the given predicate.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef take_until(function_ref<bool(char)> F) const {
       return substr(0, find_if(F));
     }
 
     /// Return a StringRef equal to 'this' but with the first \p N elements
     /// dropped.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef drop_front(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(N);
     }
 
     /// Return a StringRef equal to 'this' but with the last \p N elements
     /// dropped.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef drop_back(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(0, size()-N);
     }
 
     /// Return a StringRef equal to 'this', but with all characters satisfying
     /// the given predicate dropped from the beginning of the string.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef drop_while(function_ref<bool(char)> F) const {
       return substr(find_if_not(F));
     }
 
     /// Return a StringRef equal to 'this', but with all characters not
     /// satisfying the given predicate dropped from the beginning of the string.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef drop_until(function_ref<bool(char)> F) const {
       return substr(find_if(F));
     }
 
     /// Returns true if this StringRef has the given prefix and removes that
     /// prefix.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool consume_front(StringRef Prefix) {
       if (!startswith(Prefix))
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     bool consume_back(StringRef Suffix) {
       if (!endswith(Suffix))
         return false;
 
       *this = drop_back(Suffix.size());
       return true;
     }
 
     /// Return a reference to the substring from [Start, End).
     ///
     /// \param Start The index of the starting character in the substring; if
     /// the index is npos or greater than the length of the string then the
     /// empty substring will be returned.
     ///
     /// \param End The index following the last character to include in the
     /// substring. If this is npos or exceeds the number of characters
     /// remaining in the string, the string suffix (starting with \p Start)
     /// will be returned. If this is less than \p Start, an empty string will
     /// be returned.
     LLVM_NODISCARD
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
     StringRef slice(size_t Start, size_t End) const {
       Start = std::min(Start, Length);
       End = std::min(std::max(Start, End), Length);
       return StringRef(Data + Start, End - Start);
     }
 
     /// Split into two substrings around the first occurrence of a separator
     /// character.
#endif
     static constexpr StringLiteral withInnerNUL(const char (&Str)[N]) {
       return StringLiteral(Str, N - 1);
     }
   };
 
   /// @name StringRef Comparison Operators
   /// @{
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   inline bool operator==(StringRef LHS, StringRef RHS) {
     return LHS.equals(RHS);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); }
 
   inline bool operator<(StringRef LHS, StringRef RHS) {
     return LHS.compare(RHS) == -1;
   }
 
   inline bool operator<=(StringRef LHS, StringRef RHS) {
     return LHS.compare(RHS) != 1;

llvm/include/llvm/ADT/StringSwitch.h

class StringSwitch {
   /// The string we are matching.
   const StringRef Str;
 
   /// The pointer to the result of this switch statement, once known,
   /// null before that.
   Optional<T> Result;
 
 public:
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   explicit StringSwitch(StringRef S)
   : Str(S), Result() { }
 
   // StringSwitch is not copyable.
   StringSwitch(const StringSwitch &) = delete;
 
   // StringSwitch is not assignable due to 'Str' being 'const'.
   void operator=(const StringSwitch &) = delete;
   void operator=(StringSwitch &&other) = delete;
 
   StringSwitch(StringSwitch &&other)
     : Str(other.Str), Result(std::move(other.Result)) { }
 
   ~StringSwitch() = default;
 
   // Case-sensitive case matchers
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Case(StringLiteral S, T Value) {
     if (!Result && Str == S) {
       Result = std::move(Value);
     }
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch& EndsWith(StringLiteral S, T Value) {
     if (!Result && Str.endswith(S)) {
       Result = std::move(Value);
     }
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch& StartsWith(StringLiteral S, T Value) {
     if (!Result && Str.startswith(S)) {
       Result = std::move(Value);
     }
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, T Value) {
     return Case(S0, Value).Case(S1, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       T Value) {
     return Case(S0, Value).Cases(S1, S2, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       StringLiteral S6, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       StringLiteral S6, StringLiteral S7, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       StringLiteral S6, StringLiteral S7, StringLiteral S8,
                       T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, S8, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       StringLiteral S6, StringLiteral S7, StringLiteral S8,
                       StringLiteral S9, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, S8, S9, Value);
   }
 
   // Case-insensitive case matchers.
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &CaseLower(StringLiteral S, T Value) {
     if (!Result && Str.equals_lower(S))
       Result = std::move(Value);
 
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
     if (!Result && Str.endswith_lower(S))
       Result = Value;
 
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
     if (!Result && Str.startswith_lower(S))
       Result = std::move(Value);
 
     return *this;
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) {
     return CaseLower(S0, Value).CaseLower(S1, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                            T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                            StringLiteral S3, T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, S3, Value);
   }
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                            StringLiteral S3, StringLiteral S4, T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, S3, S4, Value);
   }
 
   LLVM_NODISCARD
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   R Default(T Value) {
     if (Result)
       return std::move(*Result);
     return Value;
   }
 
   LLVM_NODISCARD
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_USED
   operator R() {
     assert(Result && "Fell off the end of a string-switch");
     return std::move(*Result);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_STRINGSWITCH_H