[libc] add mock arg list

[michaelrj]

Summary

For testing purposes we need to be able to mock out the ArgList class.
This patch adds a mock version of that class as well as a flag to enable
it.

[sivachandra]

libc/src/__support/arg_list.h

36

Add a comment explaining under what contexts this is useful.

42

Remove the argname vlist here, then you shouldn't need the copy to suppress unused parameter warnings.

60

Since we don't care about the return value, this can be just T().

66

I think this can be improved to make it cleaner but to keep the scope of this change small, let us just do one more thing here: Move this to parser.h so that only the class Parser has to worry about it.

libc/src/stdio/fprintf.cpp

24 ↗

(On Diff #497836)

Why should this and others outside of the class Parser change?

[michaelrj]

narrow the scope of the ArgProvider switch

[michaelrj]

libc/src/__support/arg_list.h

60

We don't care right now, but in the future I plan to use the return values to help distinguish between blocks when fuzzing the printf parser.

libc/src/__support/arg_list.h

 //===-- Holder Class for manipulating va_lists ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_ARG_LIST_H
 #define LLVM_LIBC_SRC_SUPPORT_ARG_LIST_H
 
 #include "src/__support/common.h"
 
 #include <stdarg.h>
+#include <stddef.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 class ArgList {
   va_list vlist;
 
 public:
   LIBC_INLINE ArgList(va_list vlist) { va_copy(this->vlist, vlist); }
   LIBC_INLINE ArgList(ArgList &other) { va_copy(this->vlist, other.vlist); }
   LIBC_INLINE ~ArgList() { va_end(this->vlist); }
 
   LIBC_INLINE ArgList &operator=(ArgList &rhs) {
     va_copy(vlist, rhs.vlist);
     return *this;
   }
 
   template <class T> LIBC_INLINE T next_var() { return va_arg(vlist, T); }
 };
 
+// Used for testing things that use an ArgList when it's impossible to know what
+// the arguments should be ahead of time. An example of this would be fuzzing,
+// since a function passed a random input could request unpredictable arguments.
+class MockArgList {
+  size_t arg_counter = 0;
+
+public:
+  LIBC_INLINE MockArgList() = default;
+  LIBC_INLINE MockArgList(va_list) { ; }
+  LIBC_INLINE MockArgList(MockArgList &other) {
+    arg_counter = other.arg_counter;
+  }
+  LIBC_INLINE ~MockArgList() = default;
+
+  LIBC_INLINE MockArgList &operator=(MockArgList &rhs) {
+    arg_counter = rhs.arg_counter;
+    return *this;
+  }
+
+  template <class T> LIBC_INLINE T next_var() {
+    ++arg_counter;
+    return T(arg_counter);
+  }
+
+  size_t read_count() const { return arg_counter; }
+};
+
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ARG_LIST_H

libc/src/stdio/printf_core/parser.h

 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/printf_config.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
+#ifndef LIBC_COPT_MOCK_ARG_LIST
+using ArgProvider = internal::ArgList;
+#else  // not defined LIBC_COPT_MOCK_ARG_LIST
+using ArgProvider = internal::MockArgList;
+#endif // LIBC_COPT_MOCK_ARG_LIST
+
 class Parser {
   const char *__restrict str;
 
   size_t cur_pos = 0;
-  internal::ArgList args_cur;
+  ArgProvider args_cur;
 
 #ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
   // args_start stores the start of the va_args, which is allows getting the
   // value of arguments that have already been passed. args_index is tracked so
   // that we know which argument args_cur is on.
-  internal::ArgList args_start;
+  ArgProvider args_start;
   size_t args_index = 1;
 
   // Defined in printf_config.h
   static constexpr size_t DESC_ARR_LEN = LIBC_COPT_PRINTF_INDEX_ARR_LEN;
 
-  // desc_arr stores the sizes of the variables in the ArgList. This is used in
-  // index mode to reduce repeated string parsing. The sizes are stored as
+  // desc_arr stores the sizes of the variables in the ArgProvider. This is used
+  // in index mode to reduce repeated string parsing. The sizes are stored as
   // TypeDesc objects, which store the size as well as minimal type information.
   // This is necessary because some systems separate the floating point and
   // integer values in va_args.
   TypeDesc desc_arr[DESC_ARR_LEN] = {{0, Integer}};
 
   // TODO: Look into object stores for optimization.
 
 #endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 public:
 #ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
-  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, ArgProvider &args)
       : str(new_str), args_cur(args), args_start(args) {}
 #else
-  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, ArgProvider &args)
       : str(new_str), args_cur(args) {}
 #endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its
   // variables stored in the format section.
   FormatSection get_next_section();
if (!(index == 0 || index == args_index))
       args_to_index(index);
 
     set_type_desc(index, type_desc_from_type<T>());
 
     ++args_index;
     return get_next_arg_value<T>();
   }
 
-  // the ArgList can only return the next item in the list. This function is
+  // the ArgProvider can only return the next item in the list. This function is
   // used in index mode when the item that needs to be read is not the next one.
   // It moves cur_args to the index requested so the the appropriate value may
   // be read. This may involve parsing the format string, and is in the worst
   // case an O(n^2) operation.
   void args_to_index(size_t index);
 
   // get_type_desc assumes that this format string uses index mode. It iterates
   // through the format string until it finds a format specifier that defines