[libc][NFC] Simplify string-table generation internals.

[michaelrj]

I think you meant to put me as a reviewer instead of the description.

The code LGTM.

libc/src/__support/StringUtil/error_to_string.cpp

constexpr size_t max_buff_size() {
   return (unknown_str_len + 1 + max_num_len) * sizeof(char);
 }
 
 // This is to hold error strings that have to be custom built. It may be
 // rewritten on every call to strerror (or other error to string function).
 constexpr size_t ERR_BUFFER_SIZE = max_buff_size();
 thread_local char error_buffer[ERR_BUFFER_SIZE];
 
-constexpr size_t RAW_ARRAY_LEN = PLATFORM_ERRORS.size();
-constexpr size_t TOTAL_STR_LEN =
-    total_str_len(PLATFORM_ERRORS.data(), RAW_ARRAY_LEN);
+constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_ERRORS);
 
 // Since the StringMappings array is a map from error numbers to their
 // corresponding strings, we have to have an array large enough we can use the
 // error numbers as indexes. The current linux configuration has 132 values with
 // the maximum value being 133 (41 and 58 are skipped). If other platforms use
 // negative numbers or discontiguous ranges, then the array should be turned
 // into a proper hashmap.
-constexpr size_t ERR_ARRAY_SIZE =
-    max_key_val(PLATFORM_ERRORS.data(), RAW_ARRAY_LEN) + 1;
+constexpr size_t ERR_ARRAY_SIZE = max_key_val(PLATFORM_ERRORS) + 1;
 
-static constexpr MessageMapper<ERR_ARRAY_SIZE, TOTAL_STR_LEN>
-    error_mapper(PLATFORM_ERRORS.data(), RAW_ARRAY_LEN);
+constexpr MessageMapper<ERR_ARRAY_SIZE, TOTAL_STR_LEN>
+    error_mapper(PLATFORM_ERRORS);
 
 cpp::string_view build_error_string(int err_num, cpp::span<char> buffer) {
   // if the buffer can't hold "Unknown error" + ' ' + num_str, then just
   // return "Unknown error".
   if (buffer.size() <
       (sizeof("Unknown error") + 1 + IntegerToString::dec_bufsize<int>()))
     return const_cast<char *>("Unknown error");
 

libc/src/__support/StringUtil/message_mapper.h

struct MsgMapping {
   constexpr MsgMapping() : num(0), msg() { ; }
 
   constexpr MsgMapping(int init_num, const char *init_msg)
       : num(init_num), msg(init_msg) {
     ;
   }
 };
 
-constexpr size_t total_str_len(const MsgMapping *array, size_t len) {
+template <size_t N> using MsgTable = cpp::array<MsgMapping, N>;
+
+template <size_t N> constexpr size_t total_str_len(const MsgTable<N> &table) {
   size_t total = 0;
-  for (size_t i = 0; i < len; ++i) {
+  for (size_t i = 0; i < table.size(); ++i) {
     // add 1 for the null terminator.
-    total += array[i].msg.size() + 1;
+    total += table[i].msg.size() + 1;
   }
   return total;
 }
 
-constexpr size_t max_key_val(const MsgMapping *array, size_t len) {
+template <size_t N> constexpr size_t max_key_val(const MsgTable<N> &table) {
   int max = 0;
-  for (size_t i = 0; i < len; ++i) {
-    if (array[i].num > max) {
-      max = array[i].num;
+  for (size_t i = 0; i < table.size(); ++i) {
+    if (table[i].num > max) {
+      max = table[i].num;
     }
   }
   // max will never be negative since the starting value is 0. This is good,
   // since it's used as a length.
   return static_cast<size_t>(max);
 }
 
 template <size_t ARR_SIZE, size_t TOTAL_STR_LEN> class MessageMapper {
   int msg_offsets[ARR_SIZE] = {-1};
   char string_array[TOTAL_STR_LEN] = {'\0'};
 
 public:
-  constexpr MessageMapper(const MsgMapping raw_array[], size_t raw_array_len) {
+  template <size_t N> constexpr MessageMapper(const MsgTable<N> &table) {
     cpp::string_view string_mappings[ARR_SIZE] = {""};
-    for (size_t i = 0; i < raw_array_len; ++i)
-      string_mappings[raw_array[i].num] = raw_array[i].msg;
+    for (size_t i = 0; i < table.size(); ++i)
+      string_mappings[table[i].num] = table[i].msg;
 
     int string_array_index = 0;
     for (size_t cur_num = 0; cur_num < ARR_SIZE; ++cur_num) {
       if (string_mappings[cur_num].size() != 0) {
         msg_offsets[cur_num] = string_array_index;
         // No need to replace with proper strcpy, this is evaluated at compile
         // time.
         for (size_t i = 0; i < string_mappings[cur_num].size() + 1;
if (num >= 0 && static_cast<size_t>(num) < ARR_SIZE &&
         msg_offsets[num] != -1) {
       return {string_array + msg_offsets[num]};
     } else {
       return cpp::optional<cpp::string_view>();
     }
   }
 };
 
-template <size_t N> using MsgTable = cpp::array<MsgMapping, N>;
-
 template <size_t N1, size_t N2>
 constexpr MsgTable<N1 + N2> operator+(const MsgTable<N1> &t1,
                                       const MsgTable<N2> &t2) {
   MsgTable<N1 + N2> res{};
   for (size_t i = 0; i < N1; ++i)
     res[i] = t1[i];
   for (size_t i = 0; i < N2; ++i)
     res[N1 + i] = t2[i];
   return res;
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_MESSAGE_MAPPER_H

libc/src/__support/StringUtil/signal_to_string.cpp

constexpr size_t max_buff_size() {
   return (base_str_len + 1 + max_num_len) * sizeof(char);
 }
 
 // This is to hold signal strings that have to be custom built. It may be
 // rewritten on every call to strsignal (or other signal to string function).
 constexpr size_t SIG_BUFFER_SIZE = max_buff_size();
 thread_local char signal_buffer[SIG_BUFFER_SIZE];
 
-constexpr size_t RAW_ARRAY_LEN = PLATFORM_SIGNALS.size();
-constexpr size_t TOTAL_STR_LEN =
-    total_str_len(PLATFORM_SIGNALS.data(), RAW_ARRAY_LEN);
+constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_SIGNALS);
 
-constexpr size_t SIG_ARRAY_SIZE =
-    max_key_val(PLATFORM_SIGNALS.data(), RAW_ARRAY_LEN) + 1;
+constexpr size_t SIG_ARRAY_SIZE = max_key_val(PLATFORM_SIGNALS) + 1;
 
-static constexpr MessageMapper<SIG_ARRAY_SIZE, TOTAL_STR_LEN>
-    signal_mapper(PLATFORM_SIGNALS.data(), RAW_ARRAY_LEN);
+constexpr MessageMapper<SIG_ARRAY_SIZE, TOTAL_STR_LEN>
+    signal_mapper(PLATFORM_SIGNALS);
 
 cpp::string_view build_signal_string(int sig_num, cpp::span<char> buffer) {
   cpp::string_view base_str;
   if (sig_num >= SIGRTMIN && sig_num <= SIGRTMAX) {
     base_str = cpp::string_view("Real-time signal");
     sig_num -= SIGRTMIN;
   } else {
     base_str = cpp::string_view("Unknown signal");