[vt, sdf, usd] fix array-bounds warnings on GCC 13

Five false-positive warning sites caused by GCC 13 losing bound
information during aggressive inlining.

pxr/base/vt/streamOut.cpp
  Change dimension == shape.GetRank() - 1 to dimension + 1 >= shape.GetRank()
  in _StreamArrayRecursive. GCC can see GetRank() returns at most 4 and
  proves dimension <= 2 < NumOtherDims in the else branch.

pxr/usd/sdf/schema.cpp
  Add static_cast<size_t>(level) < std::size(valueTupleDimensions.d)
  to the else-if in _AddValuesToValueContext. GCC cannot bound the plain
  size_t size member but can see std::size(d) == 2.

pxr/usd/usd/clip.cpp
  Introduce bracketingTimesEnd as begin + std::min(numTimes, size())
  in GetBracketingTimeSamplesForPath. Restores the upper bound lost after
  std::distance, preventing std::sort's _S_threshold==16 path from
  appearing reachable on the 5-element array.

pxr/usd/sdf/predicateLibrary.h
  Replace std::vector<bool> with std::vector<uint8_t> for boundArgs.
  The vector<bool> bit-packing specialisation triggers -Warray-bounds and
  -Wstringop-overflow when its word-level memmove is inlined into
  _TryBindArgs; uint8_t uses the standard path GCC analyses correctly.

Author: nvidia-jomiller

pxr/base/vt/streamOut.cpp

@@ -77,7 +77,7 @@ _StreamArrayRecursive(
     size_t dimension)
 {
     out << '[';
-    if (dimension == shape.GetRank() - 1) {
+    if (dimension + 1 >= shape.GetRank()) {
         for (size_t j = 0; j < lastDimSize; ++j) {
             if (j) { out << ", "; }
             streamNextElem(out);

pxr/usd/sdf/predicateLibrary.h

@@ -459,7 +459,7 @@ class SdfPredicateLibrary
         ParamType &param,
         bool &boundAllParams,
         std::vector<SdfPredicateExpression::FnArg> const &args,
-        std::vector<bool> &boundArgs,
+        std::vector<uint8_t> &boundArgs,
         NamesAndDefaults const &namesAndDefaults) {
 
         // Bind the index-th 'param' from 'args' &
@@ -496,7 +496,7 @@ class SdfPredicateLibrary
             VtValue cast = VtValue::Cast<ParamType>(val);
             if (!cast.IsEmpty()) {
                 param = cast.UncheckedRemove<ParamType>();
-                boundArgs[argIndex] = true;
+                boundArgs[argIndex] = 1;
                 return true;
             }
             boundAllParams = false;
@@ -550,12 +550,12 @@ class SdfPredicateLibrary
                  std::vector<SdfPredicateExpression::FnArg> const &args,
                  NamesAndDefaults const &namesAndDefaults,
                  std::index_sequence<I...>,
-                 std::vector<bool> &boundArgs) {
+                 std::vector<uint8_t> &boundArgs) {
 
         // A fold expression would let us just do &&, but that's '17, so we just
         // do all of them and set a bool.
         bool bound = true;
-        boundArgs.assign(args.size(), false);
+        boundArgs.assign(args.size(), 0);
         // Need a unused array so we can use an initializer list to invoke
         // _TryBindOne N times.
         int unused[] = {
@@ -572,7 +572,7 @@ class SdfPredicateLibrary
     static void
     _FillArbitraryArgs(std::true_type,
                        std::vector<SdfPredicateExpression::FnArg> const &args,
-                       std::vector<bool> const &boundArgs,
+                       std::vector<uint8_t> const &boundArgs,
                        Tuple &typedArgs) {
         std::vector<SdfPredicateExpression::FnArg> &rest =
             std::get<std::tuple_size<Tuple>::value-1>(typedArgs);
@@ -591,7 +591,7 @@ class SdfPredicateLibrary
     static void
     _FillArbitraryArgs(std::false_type,
                        std::vector<SdfPredicateExpression::FnArg> const &,
-                       std::vector<bool> const &,
+                       std::vector<uint8_t> const &,
                        T const &) {
         // Do nothing.
     }
@@ -657,7 +657,7 @@ class SdfPredicateLibrary
         }
 
         ParamsTuple typedArgs;
-        std::vector<bool> boundArgs;
+        std::vector<uint8_t> boundArgs;
         if (_TryBindArgs(typedArgs, args, namesAndDefaults,
                          std::make_index_sequence<NumBindableArgs> {},
                          boundArgs)) {

pxr/usd/sdf/schema.cpp

@@ -31,6 +31,7 @@
 #include "pxr/base/vt/dictionary.h"
 
 #include <deque>
+#include <iterator>
 #include <map>
 #include <set>
 #include <vector>
@@ -1538,7 +1539,8 @@ _AddValuesToValueContext(std::deque<Value> *values, Sdf_ParserValueContext *cont
             context->AppendValue(values->front());
             values->pop_front();
         }
-    } else if (static_cast<size_t>(level) < context->valueTupleDimensions.size) {
+    } else if (static_cast<size_t>(level) < context->valueTupleDimensions.size &&
+               static_cast<size_t>(level) < std::size(context->valueTupleDimensions.d)) {
         context->BeginTuple();
         for (size_t i = 0; i < context->valueTupleDimensions.d[level]; i++) {
             _AddValuesToValueContext(values, context, level + 1);

pxr/usd/usd/clip.cpp

@@ -430,9 +430,10 @@ Usd_Clip::GetBracketingTimeSamplesForPath(
         return true;
     }
 
-    std::sort(bracketingTimes.begin(), bracketingTimes.begin() + numTimes);
-    auto uniqueIt = std::unique(
-        bracketingTimes.begin(), bracketingTimes.begin() + numTimes);
+    const auto bracketingTimesEnd =
+        bracketingTimes.begin() + std::min(numTimes, bracketingTimes.size());
+    std::sort(bracketingTimes.begin(), bracketingTimesEnd);
+    auto uniqueIt = std::unique(bracketingTimes.begin(), bracketingTimesEnd);
     return _GetBracketingTimeSamples(
         bracketingTimes.begin(), uniqueIt, time, tLower, tUpper);
 }