Get rid of ad hoc TIv1 use in VAST->DSLX for the purpose of invoking std::pow().

PiperOrigin-RevId: 811882215

Author: richmckeever

xls/codegen/vast/BUILD

@@ -207,7 +207,6 @@ cc_library(
         "//xls/dslx/frontend:scanner",
         "//xls/dslx/type_system:deduce",
         "//xls/dslx/type_system:deduce_ctx",
-        "//xls/dslx/type_system:parametric_env",
         "//xls/dslx/type_system:type",
         "//xls/dslx/type_system:type_info",
         "//xls/dslx/type_system:typecheck_function",

xls/codegen/vast/dslx_builder.cc

@@ -58,7 +58,6 @@
 #include "xls/dslx/parse_and_typecheck.h"
 #include "xls/dslx/type_system/deduce.h"
 #include "xls/dslx/type_system/deduce_ctx.h"
-#include "xls/dslx/type_system/parametric_env.h"
 #include "xls/dslx/type_system/type.h"
 #include "xls/dslx/type_system/type_info.h"
 #include "xls/dslx/type_system/typecheck_function.h"
@@ -75,17 +74,6 @@
 namespace xls {
 namespace {
 
-absl::StatusOr<bool> IsNegative(const dslx::InterpValue& value) {
-  if (!value.IsSigned()) {
-    return false;
-  }
-  XLS_ASSIGN_OR_RETURN(int64_t bit_count, value.GetBitCount());
-  auto zero = dslx::InterpValue::MakeSBits(bit_count, 0);
-  XLS_ASSIGN_OR_RETURN(auto lt_zero, value.Lt(zero));
-  XLS_ASSIGN_OR_RETURN(int64_t lt_zero_bit_value, lt_zero.GetBitValueViaSign());
-  return lt_zero_bit_value == 1;
-}
-
 std::string GetTypeDefName(const dslx::TypeDefinition& type_def) {
   return absl::visit(Visitor{
                          [&](const dslx::ColonRef* n) { return n->ToString(); },
@@ -462,56 +450,35 @@ dslx::Unop* DslxBuilder::HandleUnaryOperator(const dslx::Span& span,
 }
 
 absl::StatusOr<dslx::Expr*> DslxBuilder::HandleIntegerExponentiation(
-    const dslx::Span& span, dslx::Expr* lhs, dslx::Expr* rhs) {
-  // TODO(b/330575305): 2022-03-16: Switch the model to deduce after
-  // constructing a value instead of deducing immediately beforehand.
-  XLS_RETURN_IF_ERROR(deduce_ctx().Deduce(lhs).status());
-  XLS_RETURN_IF_ERROR(deduce_ctx().Deduce(rhs).status());
-  XLS_ASSIGN_OR_RETURN(dslx::InterpValue lhs_value,
-                       InterpretExpr(import_data(), type_info(), lhs));
-  if (!lhs_value.HasBits()) {
-    return absl::InvalidArgumentError("pow() LHS isn't bits-typed.");
-  }
-
-  XLS_ASSIGN_OR_RETURN(dslx::InterpValue rhs_value,
-                       InterpretExpr(import_data(), type_info(), rhs));
-  if (!rhs_value.HasBits()) {
-    return absl::InvalidArgumentError("pow() RHS isn't bits-typed.");
-  }
-
-  XLS_ASSIGN_OR_RETURN(bool is_negative, IsNegative(rhs_value));
-  if (is_negative) {
-    return absl::InvalidArgumentError(absl::StrCat(
-        "RHS of pow() cannot be negative: ", rhs_value.ToString()));
-  }
-
+    const dslx::Span& span, dslx::Expr* lhs, dslx::Expr* rhs,
+    verilog::Expression* vast_rhs) {
+  XLS_ASSIGN_OR_RETURN(int64_t rhs_value,
+                       verilog::FoldEntireVastExpr(vast_rhs, vast_type_map_));
+  if (rhs_value < 0) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("RHS of pow() cannot be negative: ", rhs_value));
+  }
+
+  XLS_ASSIGN_OR_RETURN(verilog::DataType * vast_rhs_type,
+                       GetVastDataType(vast_rhs));
+  XLS_ASSIGN_OR_RETURN(int64_t rhs_bit_count,
+                       vast_rhs_type->FlatBitCountAsInt64());
   auto* element_type = module().Make<dslx::BuiltinTypeAnnotation>(
       span, dslx::BuiltinType::kUN,
       module().GetOrCreateBuiltinNameDef(dslx::BuiltinType::kUN));
-  XLS_ASSIGN_OR_RETURN(int64_t rhs_bit_count, rhs_value.GetBitCount());
   auto* array_dim =
       module().Make<dslx::Number>(span, absl::StrCat(rhs_bit_count),
                                   dslx::NumberKind::kOther, /*type=*/nullptr);
   auto* new_rhs_type =
       module().Make<dslx::ArrayTypeAnnotation>(span, element_type, array_dim);
   rhs = module().Make<dslx::Cast>(span, rhs, new_rhs_type);
 
-  std::string power_fn = lhs_value.IsUBits() ? "upow" : "spow";
   XLS_ASSIGN_OR_RETURN(dslx::Import * std,
                        GetOrImportModule(dslx::ImportTokens({"std"})));
   auto* colon_ref = module().Make<dslx::ColonRef>(
-      span, module().Make<dslx::NameRef>(span, "std", &std->name_def()),
-      power_fn);
+      span, module().Make<dslx::NameRef>(span, "std", &std->name_def()), "pow");
   auto* invocation = module().Make<dslx::Invocation>(
       span, colon_ref, std::vector<dslx::Expr*>({lhs, rhs}));
-  dslx::ParametricEnv parametric_env(
-      absl::flat_hash_map<std::string, dslx::InterpValue>{
-          {"N", dslx::InterpValue::MakeUBits(32, rhs_bit_count)}});
-  XLS_RETURN_IF_ERROR(type_info().AddInvocationTypeInfo(
-      *invocation, /*callee=*/nullptr, /*caller=*/nullptr,
-      /*caller_env=*/deduce_ctx().GetCurrentParametricEnv(),
-      /*callee_env=*/parametric_env,
-      /*derived_type_info=*/nullptr));
   return invocation;
 }
 

xls/codegen/vast/dslx_builder.h

@@ -156,7 +156,8 @@ class DslxBuilder {
                                   dslx::UnopKind unop_kind, dslx::Expr* arg);
 
   absl::StatusOr<dslx::Expr*> HandleIntegerExponentiation(
-      const dslx::Span& span, dslx::Expr* lhs, dslx::Expr* rhs);
+      const dslx::Span& span, dslx::Expr* lhs, dslx::Expr* rhs,
+      verilog::Expression* vast_rhs);
 
   absl::StatusOr<dslx::Number*> HandleConstVal(
       const dslx::Span& span, const Bits& bits,

xls/codegen/vast/translate_vast_to_dslx.cc

@@ -189,8 +189,8 @@ class VastToDslxTranslator {
         kind = dslx::BinopKind::kDiv;
         break;
       case verilog::OperatorKind::kPower: {
-        XLS_ASSIGN_OR_RETURN(
-            result, dslx_builder_->HandleIntegerExponentiation(span, lhs, rhs));
+        XLS_ASSIGN_OR_RETURN(result, dslx_builder_->HandleIntegerExponentiation(
+                                         span, lhs, rhs, op->rhs()));
         break;
       }
       default:

xls/codegen/vast/translate_vast_to_dslx_test.cc

@@ -920,8 +920,8 @@ pub const power = u16:0x3;
 
 import std;
 
-pub const upow_result = std::upow(upow_lhs, power);
-pub const spow_result = std::spow(spow_lhs, power) as u16;
+pub const upow_result = std::pow(upow_lhs, power);
+pub const spow_result = std::pow(spow_lhs, power) as u16;
 )";
 
   XLS_EXPECT_VAST_TRANSLATION(f, kExpected);
@@ -1582,7 +1582,7 @@ pub type foo_t = bits[42];
 
 import std;
 
-pub const MiB = std::spow(s32:2, s32:20 as uN[32]) as u32;
+pub const MiB = std::pow(s32:2, s32:20 as uN[32]) as u32;
 pub const Value1 = foo_t:64 * MiB as foo_t;
 pub const Value2 = foo_t:0x0;
 )";