Fix a fuzzer failure by making sure array sizes aren't more than 1e6 bits.

xls/dslx/type_system_v2/BUILD

@@ -983,6 +983,7 @@ cc_library(
         "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
+        "@abseil-cpp//absl/strings",
     ],
 )
 

xls/dslx/type_system_v2/fast_concretizer.cc

@@ -24,6 +24,7 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/substitute.h"
 #include "xls/common/status/ret_check.h"
 #include "xls/common/status/status_macros.h"
 #include "xls/dslx/frontend/ast.h"
@@ -53,6 +54,11 @@ class FastConcretizerImpl : public FastConcretizer,
                            GetBool(signedness_and_bit_count->signedness));
       XLS_ASSIGN_OR_RETURN(uint32_t bit_count,
                            GetU32(signedness_and_bit_count->bit_count));
+      if (bit_count > kMaxBitCount) {
+        return absl::InvalidArgumentError(
+            absl::Substitute("Bit count $0 exceeds maximum limit of $1.",
+                             bit_count, kMaxBitCount));
+      }
       return std::make_unique<BitsType>(is_signed, bit_count);
     }
 

xls/dslx/type_system_v2/inference_table_converter_impl.cc

@@ -1761,6 +1761,13 @@ class InferenceTableConverterImpl : public InferenceTableConverter,
         int64_t bit_count,
         evaluator_->EvaluateU32OrExpr(parametric_context,
                                       signedness_and_bit_count.bit_count));
+    if (bit_count > kMaxBitCount) {
+      return TypeInferenceErrorStatusForAnnotation(
+          annotation->span(), annotation,
+          absl::Substitute("Bit count $0 exceeds maximum limit of $1.",
+                           bit_count, kMaxBitCount),
+          file_table_);
+    }
     if (node) {
       // If resulting type is bits-like, we fabricate a simplified type
       // annotation for the node.

xls/dslx/type_system_v2/type_annotation_utils.h

@@ -32,6 +32,11 @@
 
 namespace xls::dslx {
 
+// The maximum bit count for a type (e.g., array of bits). Too many more bits
+// and the compiler itself will run out of memory. Besides, designs will likely
+// not have a use case for a type with more bits than this.
+inline constexpr int64_t kMaxBitCount = 1000000;
+
 struct StructOrProcRef {
   const StructDefBase* def;
   std::vector<ExprOrType> parametrics;

xls/dslx/type_system_v2/typecheck_module_v2_array_tuple_test.cc

@@ -1813,5 +1813,14 @@ const X = A..s8:3;
                                        "is greater than end value 3")));
 }
 
+TEST(TypecheckV2Test, TooBigConstant) {
+  EXPECT_THAT(
+      R"(
+const too_big = -u32:19;
+const too_bit_array = sN[too_big]:-1;
+)",
+      TypecheckFails(HasSubstr("Bit count 4294967277 exceeds maximum limit of "
+                               "2147483647.")));
+}
 }  // namespace
 }  // namespace xls::dslx