Fix "the the" typo in documentation and user facing strings

[briantracy]

Summary

There are many more instances of this pattern, but I chose to limit this change to .rst files (docs), anything in libcxx/include, and string literals. These have the highest chance of being seen by end users.

[Mordante]

Thanks for these fixes. SGTM, but I want to see the CI pass.

clang/lib/StaticAnalyzer/Checkers/cert/InvalidPtrChecker.cpp

135

I'm not familiar with the static analyzers, so I don't know whether this breaks a test.
I see the pre-commit CI couldn't apply your patch. Can you rebase this patch on main so the CI runs?

[briantracy]

Updated sanitizer tests to include newly fixed error message strings.

[Mordante]

I see some test time-outs, but they seem to happen quite often.
LGTM, but please wait a few days before landing this patch to give other reviewers time to have a look.

[martong]

LGTM

[briantracy]

Thank you Mark and Gabor. At your discretion, could you commit this on my behalf? My email is "[e-mail]" and full name is "Brian Tracy". Thanks again.

[ldionne]

Thanks!

clang/docs/LanguageExtensions.rst

 
 The pragma can also be used with ``off`` which turns FP contraction off for a
 section of the code. This can be useful when fast contraction is otherwise
 enabled for the translation unit with the ``-ffp-contract=fast-honor-pragmas`` flag.
 Note that ``-ffp-contract=fast`` will override pragmas to fuse multiply and
 addition across statements regardless of any controlling pragmas.
 
 ``#pragma clang fp exceptions`` specifies floating point exception behavior. It
-may take one the the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of
+may take one of the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of
 these values is same as for `constrained floating point intrinsics <http://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics>`_.
 
 .. code-block:: c++
 
   {
     // Preserve floating point exceptions
     #pragma clang fp exceptions(strict)
     z = x + y;

clang/docs/MatrixTypes.rst

 * *M*, *M1*, *M2*, *M3* - Matrix types
 * *T* - Element type
 * *row*, *col* - Row and column arguments respectively.
 
 
 ``M2 __builtin_matrix_transpose(M1 matrix)``
 
 **Remarks**: The return type is a cv-unqualified matrix type that has the same
-element type as ``M1`` and has the the same number of rows as ``M1`` has columns and
+element type as ``M1`` and has the same number of rows as ``M1`` has columns and
 the same number of columns as ``M1`` has rows.
 
 **Returns**: A matrix ``Res`` equivalent to the code below, where ``col`` refers to the
 number of columns of ``M``, and ``row`` to the number of rows of ``M``.
 
 **Effects**: Equivalent to:
 
 .. code-block:: c++

clang/docs/UndefinedBehaviorSanitizer.rst

-  ``-fsanitize=implicit-unsigned-integer-truncation``,
      width, is not equal to the original value before the downcast.
      The ``-fsanitize=implicit-unsigned-integer-truncation`` handles conversions
      between two ``unsigned`` types, while
      ``-fsanitize=implicit-signed-integer-truncation`` handles the rest of the
      conversions - when either one, or both of the types are signed.
      Issues caught by these sanitizers are not undefined behavior,
      but are often unintentional.
   -  ``-fsanitize=implicit-integer-sign-change``: Implicit conversion between
-     integer types, if that changes the sign of the value. That is, if the the
+     integer types, if that changes the sign of the value. That is, if the
      original value was negative and the new value is positive (or zero),
      or the original value was positive, and the new value is negative.
      Issues caught by this sanitizer are not undefined behavior,
      but are often unintentional.
   -  ``-fsanitize=integer-divide-by-zero``: Integer division by zero.
   -  ``-fsanitize=nonnull-attribute``: Passing null pointer as a function
      parameter which is declared to never be null.
   -  ``-fsanitize=null``: Use of a null pointer or creation of a null

clang/docs/analyzer/checkers.rst

void buffer_size_constraint_violation(FILE *file) {
     enum { BUFFER_SIZE = 1024 };
     wchar_t wbuf[BUFFER_SIZE];
 
     const size_t size = sizeof(*wbuf);   // 4
     const size_t nitems = sizeof(wbuf);  // 4096
 
     // Below we receive a warning because the 3rd parameter should be the
     // number of elements to read, not the size in bytes. This case is a known
-    // vulnerability described by the the ARR38-C SEI-CERT rule.
+    // vulnerability described by the ARR38-C SEI-CERT rule.
     fread(wbuf, size, nitems, file);
   }
 
 **Limitations**
 
 The checker is in alpha because the reports cannot provide notes about the
 values of the arguments. Without this information it is hard to confirm if the
 constraint is indeed violated. For example, consider the above case for

clang/lib/StaticAnalyzer/Checkers/cert/InvalidPtrChecker.cpp

if (const MemRegion *const *Reg = State->get<PreviousCallResultMap>(FD)) {
     const MemRegion *PrevReg = *Reg;
     State = State->add<InvalidMemoryRegions>(PrevReg);
     Note = C.getNoteTag([PrevReg, FD](PathSensitiveBugReport &BR,
                                       llvm::raw_ostream &Out) {
       if (!BR.isInteresting(PrevReg))
         return;
       Out << '\'';
       FD->getNameForDiagnostic(Out, FD->getASTContext().getLangOpts(), true);
-      Out << "' call may invalidate the the result of the previous " << '\'';
+      Out << "' call may invalidate the result of the previous " << '\'';
       FD->getNameForDiagnostic(Out, FD->getASTContext().getLangOpts(), true);
       Out << '\'';
     });
   }
 
   const LocationContext *LCtx = C.getLocationContext();
   const auto *CE = cast<CallExpr>(Call.getOriginExpr());
 

clang/test/Analysis/cert/env34-c.c

 void getenv_test2(void) {
   char *p, *p2;
 
   p = getenv("VAR");
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   p2 = getenv("VAR2");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test3(void) {
   char *p, *p2, *p3;
 
   p = getenv("VAR");
   *p; // no-warning
 
   p = getenv("VAR2");
   // expected-note@-1{{previous function call was here}}
   p2 = getenv("VAR2");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   p3 = getenv("VAR3");
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test4(void) {
   char *p, *p2, *p3;
 
   p = getenv("VAR");
   // expected-note@-1{{previous function call was here}}
   p2 = getenv("VAR2");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
   p3 = getenv("VAR3");
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test5(void) {
   char *p, *p2, *p3;
 
   p = getenv("VAR");
   p2 = getenv("VAR2");
   // expected-note@-1{{previous function call was here}}
   p3 = getenv("VAR3");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   *p2;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test6(void) {
   char *p, *p2;
   p = getenv("VAR");
   *p; // no-warning
 
   p = getenv("VAR2");
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   p2 = getenv("VAR3");
   // expected-note@-1{{previous function call was here}}
-  // expected-note@-2{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-2{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 
   *p2; // no-warning
 
   p = getenv("VAR4");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   *p; // no-warning
   *p2;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test7(void) {
   char *p, *p2;
   p = getenv("VAR");
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   p2 = getenv("VAR2");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   foo(p);
   // expected-warning@-1{{use of invalidated pointer 'p' in a function call}}
   // expected-note@-2{{use of invalidated pointer 'p' in a function call}}
 }
 
 void getenv_test8(void) {
   static const char *array[] = {
      0,
      0,
      "/var/tmp",
      "/usr/tmp",
      "/tmp",
      "."
   };
 
   if( !array[0] )
   // expected-note@-1{{Taking true branch}}
     array[0] = getenv("TEMPDIR");
     // expected-note@-1{{previous function call was here}}
 
   if( !array[1] )
   // expected-note@-1{{Taking true branch}}
     array[1] = getenv("TMPDIR");
-    // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   *array[0];
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test9(void) {
   char *p, *p2;
   p = getenv("something");
   p = bar();
   p2 = getenv("something");
   *p; // no-warning: p does not point to getenv anymore
 }
 
 void getenv_test10(void) {
   strcmp(getenv("VAR1"), getenv("VAR2"));
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
   // expected-note@-2{{previous function call was here}}
   // expected-warning@-3{{use of invalidated pointer 'getenv("VAR1")' in a function call}}
   // expected-note@-4{{use of invalidated pointer 'getenv("VAR1")' in a function call}}
 }
 
 void dereference_pointer(char* a) {
   *a;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void getenv_test11(void) {
   char *p = getenv("VAR");
   // expected-note@-1{{previous function call was here}}
 
   char *pp = getenv("VAR2");
-  // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+  // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
 
   dereference_pointer(p);
   // expected-note@-1{{Calling 'dereference_pointer'}}
 }
 
 void getenv_test12(int flag1, int flag2) {
   char *p = getenv("VAR");
   // expected-note@-1{{previous function call was here}}
 
   if (flag1) {
     // expected-note@-1{{Assuming 'flag1' is not equal to 0}}
     // expected-note@-2{{Taking true branch}}
     char *pp = getenv("VAR2");
-    // expected-note@-1{{'getenv' call may invalidate the the result of the previous 'getenv'}}
+    // expected-note@-1{{'getenv' call may invalidate the result of the previous 'getenv'}}
   }
 
   if (flag2) {
     // expected-note@-1{{Assuming 'flag2' is not equal to 0}}
     // expected-note@-2{{Taking true branch}}
     *p;
     // expected-warning@-1{{dereferencing an invalid pointer}}
     // expected-note@-2{{dereferencing an invalid pointer}}
   }
 }
 
 void setlocale_test1(void) {
   char *p, *p2;
   p = setlocale(0, "VAR");
   *p; // no-warning
 
   p = setlocale(0, "VAR2");
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   p2 = setlocale(0, "VAR3");
-  // expected-note@-1{{'setlocale' call may invalidate the the result of the previous 'setlocale'}}
+  // expected-note@-1{{'setlocale' call may invalidate the result of the previous 'setlocale'}}
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void setlocale_test2(int flag) {
   char *p, *p2;
   p = setlocale(0, "VAR");
   *p; // no-warning
 
   p = setlocale(0, "VAR2");
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   if (flag) {
     // expected-note@-1{{Assuming 'flag' is not equal to 0}}
     // expected-note@-2{{Taking true branch}}
     p2 = setlocale(0, "VAR3");
-    // expected-note@-1{{'setlocale' call may invalidate the the result of the previous 'setlocale'}}
+    // expected-note@-1{{'setlocale' call may invalidate the result of the previous 'setlocale'}}
   }
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void strerror_test1(void) {
   char *p, *p2;
 
   p = strerror(0);
   *p; // no-warning
 
   p = strerror(1);
   // expected-note@-1{{previous function call was here}}
   *p; // no-warning
 
   p2 = strerror(2);
-  // expected-note@-1{{'strerror' call may invalidate the the result of the previous 'strerror'}}
+  // expected-note@-1{{'strerror' call may invalidate the result of the previous 'strerror'}}
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void strerror_test2(int errno) {
   char *p, *p2;
void strerror_test2(int errno) {
   }
 
   *p; // no-warning
 
   if (errno) {
     // expected-note@-1{{Assuming 'errno' is not equal to 0}}
     // expected-note@-2{{Taking true branch}}
     p2 = strerror(errno);
-    // expected-note@-1{{'strerror' call may invalidate the the result of the previous 'strerror'}}
+    // expected-note@-1{{'strerror' call may invalidate the result of the previous 'strerror'}}
   }
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void asctime_test(void) {
   const tm *t;
   const tm *tt;
 
   char* p = asctime(t);
   // expected-note@-1{{previous function call was here}}
   char* pp = asctime(tt);
-  // expected-note@-1{{'asctime' call may invalidate the the result of the previous 'asctime'}}
+  // expected-note@-1{{'asctime' call may invalidate the result of the previous 'asctime'}}
 
   *p;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void localeconv_test1(void) {
   lconv *lc1 = localeconv();
   // expected-note@-1{{previous function call was here}}
   lconv *lc2 = localeconv();
-  // expected-note@-1{{'localeconv' call may invalidate the the result of the previous 'localeconv'}}
+  // expected-note@-1{{'localeconv' call may invalidate the result of the previous 'localeconv'}}
 
   *lc1;
   // expected-warning@-1{{dereferencing an invalid pointer}}
   // expected-note@-2{{dereferencing an invalid pointer}}
 }
 
 void localeconv_test2(void) {
   // TODO: false negative
   lconv *lc1 = localeconv();
   lconv *lc2 = localeconv();
   lc1->field;
 }

libcxx/include/__iterator/advance.h

else {
       }
     }
   }
 
   // Preconditions:
   //   * If `n > 0`, [i, bound) denotes a range.
   //   * If `n == 0`, [i, bound) or [bound, i) denotes a range.
   //   * If `n < 0`, [bound, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model `same_as<I, S>`.
-  // Returns: `n - M`, where `M` is the difference between the the ending and starting position.
+  // Returns: `n - M`, where `M` is the difference between the ending and starting position.
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
   _LIBCPP_HIDE_FROM_ABI
   constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n, _Sp __bound) const {
     _LIBCPP_ASSERT((__n >= 0) || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
                    "If `n < 0`, then `bidirectional_iterator<I> && same_as<I, S>` must be true.");
     // If `S` and `I` model `sized_sentinel_for<S, I>`:
     if constexpr (sized_sentinel_for<_Sp, _Ip>) {
       // If |n| >= |bound - i|, equivalent to `ranges::advance(i, bound)`.

libcxx/src/filesystem/operations.cpp

path path::lexically_relative(const path& base) const {
   int ElemCount = DetermineLexicalElementCount(PPBase);
   if (ElemCount < 0)
     return {};
 
   // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
   if (ElemCount == 0 && (PP.atEnd() || *PP == PATHSTR("")))
     return PATHSTR(".");
 
-  // return a path constructed with 'n' dot-dot elements, followed by the the
+  // return a path constructed with 'n' dot-dot elements, followed by the
   // elements of '*this' after the mismatch.
   path Result;
   // FIXME: Reserve enough room in Result that it won't have to re-allocate.
   while (ElemCount--)
     Result /= PATHSTR("..");
   for (; PP; ++PP)
     Result /= *PP;
   return Result;

llvm/docs/AMDGPUUsage.rst

".value_kind"          string         Required  Kernel argument kind that
                                                      "hidden_group_size_z"
                                                        The grid dispatch work-group size for the Z dimension is
                                                        passed in the kernarg. This size only applies to the
                                                        non-partial work-groups. This is the same value as the AQL
                                                        dispatch packet work-group size. If the grid dimensionality
                                                        is 1 or 2, then must be 1.
 
                                                      "hidden_remainder_x"
-                                                       The grid dispatch work group size of the the partial work group
+                                                       The grid dispatch work group size of the partial work group
                                                        of the X dimension, if it exists. Must be zero if a partial
                                                        work group does not exist in the X dimension.
 
                                                      "hidden_remainder_y"
-                                                       The grid dispatch work group size of the the partial work group
+                                                       The grid dispatch work group size of the partial work group
                                                        of the Y dimension, if it exists. Must be zero if a partial
                                                        work group does not exist in the Y dimension.
 
                                                      "hidden_remainder_z"
-                                                       The grid dispatch work group size of the the partial work group
+                                                       The grid dispatch work group size of the partial work group
                                                        of the Z dimension, if it exists. Must be zero if a partial
                                                        work group does not exist in the Z dimension.
 
                                                      "hidden_grid_dims"
                                                        The grid dispatch dimensionality. This is the same value
                                                        as the AQL dispatch packet dimensionality. Must be a value
                                                        between 1 and 3.
 

llvm/docs/BugLifeCycle.rst

 
 .. _Actively working on fixing:
 
 Actively working on fixing bugs
 ===============================
 
 Please remember to assign the bug to yourself if you're actively working on
 fixing it and to unassign it when you're no longer actively working on it.  You
-unassign a bug by removing the person from the the ``Assignees`` field.
+unassign a bug by removing the person from the ``Assignees`` field.
 
 .. _Closing:
 
 Resolving/Closing bugs
 ======================
 
 Resolving bugs is good! Make sure to properly record the reason for resolving.
 Examples of reasons for resolving are:

llvm/docs/CodingStandards.rst

 
 .. code-block:: c++
 
   BasicBlock *BB = ...
   for (Instruction &I : *BB)
     ... use I ...
 
 Usage of ``std::for_each()``/``llvm::for_each()`` functions is discouraged,
-unless the the callable object already exists.
+unless the callable object already exists.
 
 Don't evaluate ``end()`` every time through a loop
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 In cases where range-based ``for`` loops can't be used and it is necessary
 to write an explicit iterator-based loop, pay close attention to whether
 ``end()`` is re-evaluated on each loop iteration. One common mistake is to
 write a loop in this style:

llvm/docs/CommandGuide/llvm-profdata.rst

 
  Supplement an instrumentation profile with sample profile. The sample profile
  is the input of the flag. Output will be in instrumentation format (only works
  with -instr).
 
 .. option:: --zero-counter-threshold=<float>
 
  For the function which is cold in instr profile but hot in sample profile, if
- the ratio of the number of zero counters divided by the the total number of
+ the ratio of the number of zero counters divided by the total number of
  counters is above the threshold, the profile of the function will be regarded
  as being harmful for performance and will be dropped.
 
 .. option:: --instr-prof-cold-threshold=<int>
 
  User specified cold threshold for instr profile which will override the cold
  threshold got from profile summary.
 

llvm/include/llvm/Analysis/Loads.h

bool isSafeToLoadUnconditionally(Value *V, Align Alignment, APInt &Size,
                                  Instruction *ScanFrom = nullptr,
                                  const DominatorTree *DT = nullptr,
                                  const TargetLibraryInfo *TLI = nullptr);
 
 /// Return true if we can prove that the given load (which is assumed to be
 /// within the specified loop) would access only dereferenceable memory, and
 /// be properly aligned on every iteration of the specified loop regardless of
 /// its placement within the loop. (i.e. does not require predication beyond
-/// that required by the the header itself and could be hoisted into the header
+/// that required by the header itself and could be hoisted into the header
 /// if desired.)  This is more powerful than the variants above when the
-/// address loaded from is analyzeable by SCEV.  
+/// address loaded from is analyzeable by SCEV.
 bool isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L,
                                        ScalarEvolution &SE,
                                        DominatorTree &DT);
 
 /// Return true if we know that executing a load from this value cannot trap.
 ///
 /// If DT and ScanFrom are specified this method performs context-sensitive
 /// analysis and returns true if it is safe to load immediately before ScanFrom.

llvm/include/llvm/ExecutionEngine/Orc/Core.h

public:
   /// A utility function for looking up initializer symbols. Performs a blocking
   /// lookup for the given symbols in each of the given JITDylibs.
   ///
   /// Note: This function is deprecated and will be removed in the near future.
   static Expected<DenseMap<JITDylib *, SymbolMap>>
   lookupInitSymbols(ExecutionSession &ES,
                     const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
 
-  /// Performs an async lookup for the the given symbols in each of the given
+  /// Performs an async lookup for the given symbols in each of the given
   /// JITDylibs, calling the given handler once all lookups have completed.
   static void
   lookupInitSymbolsAsync(unique_function<void(Error)> OnComplete,
                          ExecutionSession &ES,
                          const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
 };
 
 /// A materialization task.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

bool operator==(const SpillLocationNo &Other) const {
     return SpillNo == Other.SpillNo;
   }
   bool operator!=(const SpillLocationNo &Other) const {
     return !(*this == Other);
   }
 };
 
 /// Meta qualifiers for a value. Pair of whatever expression is used to qualify
-/// the the value, and Boolean of whether or not it's indirect.
+/// the value, and Boolean of whether or not it's indirect.
 class DbgValueProperties {
 public:
   DbgValueProperties(const DIExpression *DIExpr, bool Indirect)
       : DIExpr(DIExpr), Indirect(Indirect) {}
 
   /// Extract properties from an existing DBG_VALUE instruction.
   DbgValueProperties(const MachineInstr &MI) {
     assert(MI.isDebugValue());

llvm/tools/llvm-profdata/llvm-profdata.cpp

cl::opt<std::string> SupplInstrWithSample(
       cl::desc("Supplement an instr profile with sample profile, to correct "
                "the profile unrepresentativeness issue. The sample "
                "profile is the input of the flag. Output will be in instr "
                "format (The flag only works with -instr)"));
   cl::opt<float> ZeroCounterThreshold(
       "zero-counter-threshold", cl::init(0.7), cl::Hidden,
       cl::desc("For the function which is cold in instr profile but hot in "
                "sample profile, if the ratio of the number of zero counters "
-               "divided by the the total number of counters is above the "
+               "divided by the total number of counters is above the "
                "threshold, the profile of the function will be regarded as "
                "being harmful for performance and will be dropped."));
   cl::opt<unsigned> SupplMinSizeThreshold(
       "suppl-min-size-threshold", cl::init(10), cl::Hidden,
       cl::desc("If the size of a function is smaller than the threshold, "
                "assume it can be inlined by PGO early inliner and it won't "
                "be adjusted based on sample profile."));
   cl::opt<unsigned> InstrProfColdThreshold(