Roll back continuation changes.

Future function slice and BValue tracking approach will be very different.

PiperOrigin-RevId: 601817637

Author: Sean Purser-Haskell

xls/contrib/xlscc/translate_block.cc

@@ -949,16 +949,10 @@ absl::StatusOr<Translator::SubFSMReturn> Translator::GenerateSubFSM(
   const int64_t context_out_ret_idx =
       outer_prepared.return_index_for_op.at(&invoke_context_out.op);
 
-  // Extract continuation from first_ret_val
-  xls::BValue ret_value_with_continuation =
+  xls::BValue ret_io_value =
       GetFlexTupleField(first_ret_val, context_out_ret_idx,
                         outer_prepared.xls_func->return_value_count, body_loc);
 
-  XLS_ASSIGN_OR_RETURN(xls::BValue ret_io_value,
-                       UnpackAndApplyContinuationIn(
-                           invoke_context_out.op, ret_value_with_continuation,
-                           /*includes_io_value=*/true, body_loc));
-
   xls::BValue context_out = pb.TupleIndex(ret_io_value, /*idx=*/0, body_loc);
 
   // Generate inner FSM
@@ -971,10 +965,7 @@ absl::StatusOr<Translator::SubFSMReturn> Translator::GenerateSubFSM(
 
   outer_prepared.token = contents_ret.token_out;
 
-  XLS_ASSIGN_OR_RETURN(
-      xls::BValue context_in,
-      AddContinuationToIOReturn(invoke_context_in.op, contents_ret.out_tuple,
-                                body_loc));
+  xls::BValue context_in = contents_ret.out_tuple;
 
   // Get context in from inner FSM
   const int64_t context_in_arg_idx =
@@ -1020,16 +1011,10 @@ absl::StatusOr<xls::BValue> Translator::GenerateIOInvoke(
   xls::SourceInfo op_loc = op.op_location;
   const int64_t return_index = prepared.return_index_for_op.at(&op);
 
-  // Extract continuation from last_ret_val
-  xls::BValue ret_value_with_continuation = GetFlexTupleField(
+  xls::BValue ret_io_value = GetFlexTupleField(
       last_ret_val, return_index, prepared.xls_func->return_value_count, op_loc,
       /*name=*/
-      absl::StrFormat("%s_ret_value_with_continuation", op.final_param_name));
-
-  XLS_ASSIGN_OR_RETURN(
-      xls::BValue ret_io_value,
-      UnpackAndApplyContinuationIn(op, ret_value_with_continuation,
-                                   /*includes_io_value=*/true, op_loc));
+      absl::StrFormat("%s_ret_io_value", op.final_param_name));
 
   xls::BValue arg_io_val;
 
@@ -1143,11 +1128,11 @@ absl::StatusOr<xls::BValue> Translator::GenerateIOInvoke(
     XLS_CHECK("Unknown IOOp type" == nullptr);
   }
 
-  // Add the continuation to the IO argument and store
-  const int64_t arg_index = prepared.arg_index_for_op.at(&op);
-  XLS_CHECK(arg_index >= 0 && arg_index < prepared.args.size());
-  XLS_ASSIGN_OR_RETURN(prepared.args[arg_index],
-                       AddContinuationToIOReturn(op, arg_io_val, op_loc));
+  if (prepared.arg_index_for_op.contains(&op)) {
+    const int64_t arg_index = prepared.arg_index_for_op.at(&op);
+    XLS_CHECK(arg_index >= 0 && arg_index < prepared.args.size());
+    prepared.args[arg_index] = arg_io_val;
+  }
 
   // The function is invoked again with the value received from the channel
   //  for each read() Op. The final invocation will produce all complete
@@ -1525,10 +1510,12 @@ Translator::GenerateIRBlockPrepare(
     switch (param.type) {
       case xlscc::SideEffectingParameterType::kIOOp: {
         const IOOp& op = *param.io_op;
-        xls::BValue val =
-            pb.Literal(xls::ZeroOfType(param.xls_io_param_type), body_loc);
-        prepared.arg_index_for_op[&op] = prepared.args.size();
-        prepared.args.push_back(val);
+        if (op.op == OpType::kRead || op.op == OpType::kRecv) {
+          xls::BValue val =
+              pb.Literal(xls::ZeroOfType(param.xls_io_param_type), body_loc);
+          prepared.arg_index_for_op[&op] = prepared.args.size();
+          prepared.args.push_back(val);
+        }
         break;
       }
       case xlscc::SideEffectingParameterType::kStatic: {

xls/contrib/xlscc/translate_io.cc

@@ -41,145 +41,11 @@
 #include "xls/ir/type.h"
 #include "xls/ir/value_helpers.h"
 
-// TODO(seanhaskell): Remove when continuations are finished
-constexpr bool kDebugUseContinuations = false;
-
 namespace xlscc {
 
-absl::Status Translator::AddToContinuationNonDestructively(
-    Continuation& continuation, const xls::SourceInfo& loc) {
-  absl::flat_hash_set<const clang::NamedDecl*> decls_to_pass;
-
-  // Get variables to pass
-  std::vector<const clang::NamedDecl*> decls_sorted;
-  decls_sorted.reserve(context().variables.size());
-  for (const auto& [decl, _] : context().variables) {
-    decls_sorted.push_back(decl);
-  }
-  // Sort for determinism
-  context().sf->SortNamesDeterministically(decls_sorted);
-
-  for (const clang::NamedDecl* decl : decls_sorted) {
-    const CValue& cvar = context().variables.at(decl);
-    // Pure syntactic sugar values (eg channels) don't need to be passed
-    if (!cvar.rvalue().valid()) {
-      continue;
-    }
-    continuation.vars_to_pass.push_back(
-        ContinuationItem{.decl = decl, .ctype = cvar.type()});
-    decls_to_pass.insert(decl);
-  }
-
-  // Calculate variables accessed using reference counts
-  const absl::flat_hash_map<const clang::NamedDecl*, int64_t>&
-      vars_accessed_last = context().variables_accessed_at_last_continuation;
-
-  for (const auto& [decl, count] : context().variables_accessed) {
-    if (!decls_to_pass.contains(decl)) {
-      continue;
-    }
-    auto found_last = vars_accessed_last.find(decl);
-    if (found_last != vars_accessed_last.end() && found_last->second == count) {
-      continue;
-    }
-    XLSCC_CHECK(
-        found_last == vars_accessed_last.end() || found_last->second < count,
-        loc);
-    continuation.vars_accessed_since_last_continuation.push_back(decl);
-  }
-
-  context().variables_accessed_at_last_continuation =
-      context().variables_accessed;
-  context().variables_masked_by_assignment.clear();
-
-  // Build data types
-  auto active_type = std::make_shared<CBoolType>();
-  std::vector<std::shared_ptr<CType>> tuple_ctypes;
-  tuple_ctypes.reserve(continuation.vars_to_pass.size() + 1);
-  tuple_ctypes.push_back(active_type);
-
-  for (const ContinuationItem& item : continuation.vars_to_pass) {
-    tuple_ctypes.push_back(item.ctype);
-  }
-
-  if (!kDebugUseContinuations) {
-    tuple_ctypes.clear();
-  }
-
-  continuation.param_part_ctype = std::make_shared<CInternalTuple>(
-      std::vector<std::shared_ptr<CType>>(tuple_ctypes));
-  return absl::OkStatus();
-}
-
-absl::StatusOr<xls::BValue> Translator::UnpackAndApplyContinuationIn(
-    const IOOp& op, xls::BValue param_in_bval, bool includes_io_value,
-    const xls::SourceInfo& loc) {
-  std::string node_name_prefix = absl::StrFormat(
-      "__%s_%i_continuation_in", op.final_param_name, op.channel_op_index);
-
-  xls::BValue continuation_in_bval = param_in_bval;
-  xls::BValue input_io_value;
-
-  // Extract the IO input from the tuple, if present
-  if (includes_io_value) {
-    // Extract the IO input part from the continuation part
-    input_io_value = context().fb->TupleIndex(
-        param_in_bval, /*idx=*/0, loc,
-        /*name=*/
-        absl::StrFormat("__%s_%i_io_in", op.final_param_name,
-                        op.channel_op_index));
-
-    continuation_in_bval = context().fb->TupleIndex(
-        param_in_bval, /*idx=*/1, loc,
-        /*name=*/
-        absl::StrFormat("__%s_%i_continuation_in", op.final_param_name,
-                        op.channel_op_index));
-  }
-
-  // TODO(seanhaskell): Apply continuation_in_bval.
-  // TODO(seanhaskell): Side-channel values that aren't in this scope / context
-
-  return input_io_value;
-}
-
-absl::StatusOr<xls::BValue> Translator::GetContinuationOut(
-    const Continuation& continuation, const xls::SourceInfo& loc,
-    std::string_view node_name_prefix) {
-  XLS_ASSIGN_OR_RETURN(xls::Type * param_part_xls_type,
-                       TranslateTypeToXLS(continuation.param_part_ctype, loc));
-
-  // TODO(seanhaskell): Get continuation values from context
-  xls::BValue ret = context().fb->Literal(
-      xls::ZeroOfType(param_part_xls_type), loc,
-      /*name=*/absl::StrFormat("%s_default", node_name_prefix));
-  return ret;
-}
-
-absl::StatusOr<xls::BValue> Translator::AddContinuationToIOReturn(
-    const IOOp& op, xls::BValue retval, const xls::SourceInfo& loc) {
-  XLS_ASSIGN_OR_RETURN(
-      xls::BValue continuation_out_bval,
-      GetContinuationOut(
-          op.continuation, loc, /*node_name_prefix=*/
-          absl::StrFormat("__%s_%i_continuation_out", op.final_param_name,
-                          op.channel_op_index)));
-
-  // This function is also used for formatting parameters, so it must handle
-  // the empty case
-  if (!retval.valid()) {
-    return continuation_out_bval;
-  }
-
-  return context().fb->Tuple(
-      {retval, continuation_out_bval}, loc,
-      /*name=*/
-      absl::StrFormat("__%s_%i_io_plus_continuation", op.final_param_name,
-                      op.channel_op_index));
-}
-
-absl::StatusOr<IOOp*> Translator::AddOpToChannel(
-    IOOp& op, IOChannel* channel, const xls::SourceInfo& loc, bool mask,
-    bool add_continuation_to_return) {
+absl::StatusOr<IOOp*> Translator::AddOpToChannel(IOOp& op, IOChannel* channel,
+                                                 const xls::SourceInfo& loc,
+                                                 bool mask) {
   context().any_side_effects_requested = true;
   context().any_io_ops_requested = true;
 
@@ -215,9 +81,6 @@ absl::StatusOr<IOOp*> Translator::AddOpToChannel(
     op.channel_op_index = context().sf->trace_count++;
   }
 
-  // Add continuation non-destructively (may be aggregating from callee op)
-  XLS_RETURN_IF_ERROR(AddToContinuationNonDestructively(op.continuation, loc));
-
   std::shared_ptr<CType> channel_item_type;
 
   // Channel must be inserted first by AddOpToChannel
@@ -231,58 +94,42 @@ absl::StatusOr<IOOp*> Translator::AddOpToChannel(
     }
   }
 
-  XLSCC_CHECK_NE(op.continuation.param_part_ctype, nullptr, loc);
-  std::shared_ptr<CType> param_type = op.continuation.param_part_ctype;
-
-  // Add the continuation via a tuple if there is an IO input, (io_item,
-  // continuation)
-  if (channel_item_type) {
-    param_type =
-        std::make_shared<CInternalTuple>(std::vector<std::shared_ptr<CType>>(
-            {channel_item_type, op.continuation.param_part_ctype}));
-  }
+  std::shared_ptr<CType> param_type = channel_item_type;
 
   xls::Type* xls_param_type = nullptr;
-  XLS_ASSIGN_OR_RETURN(xls_param_type, TranslateTypeToXLS(param_type, loc));
-  std::string safe_param_name;
-  if (op.channel != nullptr) {
-    const std::string channel_name = op.channel->unique_name;
-    safe_param_name =
-        absl::StrFormat("%s_op%i", channel_name, op.channel_op_index);
-  } else {
-    safe_param_name = absl::StrFormat("default_op%i", op.channel_op_index);
-  }
-
-  xls::BValue pbval = context().fb->Param(safe_param_name, xls_param_type, loc);
+  if (param_type != nullptr) {
+    XLS_ASSIGN_OR_RETURN(xls_param_type, TranslateTypeToXLS(param_type, loc));
+    std::string safe_param_name;
+    if (op.channel != nullptr) {
+      const std::string channel_name = op.channel->unique_name;
+      safe_param_name =
+          absl::StrFormat("%s_op%i", channel_name, op.channel_op_index);
+    } else {
+      safe_param_name = absl::StrFormat("default_op%i", op.channel_op_index);
+    }
 
-  // Check for duplicate params
-  if (!pbval.valid()) {
-    return absl::InternalError(ErrorMessage(
-        loc,
-        "Failed to create implicit parameter %s, duplicate? See b/239861050",
-        safe_param_name.c_str()));
-  }
+    xls::BValue pbval =
+        context().fb->Param(safe_param_name, xls_param_type, loc);
 
-  const std::string final_param_name =
-      pbval.node()->As<xls::Param>()->GetName();
+    // Check for duplicate params
+    if (!pbval.valid()) {
+      return absl::InternalError(ErrorMessage(
+          loc,
+          "Failed to create implicit parameter %s, duplicate? See b/239861050",
+          safe_param_name.c_str()));
+    }
 
-  op.final_param_name = final_param_name;
+    const std::string final_param_name =
+        pbval.node()->As<xls::Param>()->GetName();
 
-  XLS_ASSIGN_OR_RETURN(
-      xls::BValue input_io_value,
-      UnpackAndApplyContinuationIn(
-          op, pbval,
-          /*includes_io_value=*/channel_item_type != nullptr, loc));
+    op.final_param_name = final_param_name;
 
-  if (channel_item_type) {
-    XLSCC_CHECK(input_io_value.valid(), loc);
-    op.input_value = CValue(input_io_value, channel_item_type);
-  }
+    xls::BValue input_io_value = pbval;
 
-  // Add continuation to return value.
-  if (add_continuation_to_return) {
-    XLS_ASSIGN_OR_RETURN(op.ret_value,
-                         AddContinuationToIOReturn(op, op.ret_value, loc));
+    if (channel_item_type) {
+      XLSCC_CHECK(input_io_value.valid(), loc);
+      op.input_value = CValue(input_io_value, channel_item_type);
+    }
   }
 
   XLS_ASSIGN_OR_RETURN(std::optional<const IOOp*> last_op,
@@ -297,14 +144,16 @@ absl::StatusOr<IOOp*> Translator::AddOpToChannel(
   // once "token phi" type features are available.
   context().sf->io_ops.push_back(op);
 
-  // Due to the continuations, there is always a parameter
-  SideEffectingParameter side_effecting_param;
-  side_effecting_param.type = SideEffectingParameterType::kIOOp;
-  XLSCC_CHECK(!final_param_name.empty(), loc);
-  side_effecting_param.param_name = final_param_name;
-  side_effecting_param.xls_io_param_type = xls_param_type;
-  side_effecting_param.io_op = &context().sf->io_ops.back();
-  context().sf->side_effecting_parameters.push_back(side_effecting_param);
+  if (param_type != nullptr) {
+    XLSCC_CHECK_NE(xls_param_type, nullptr, loc);
+    SideEffectingParameter side_effecting_param;
+    side_effecting_param.type = SideEffectingParameterType::kIOOp;
+    XLSCC_CHECK(!op.final_param_name.empty(), loc);
+    side_effecting_param.param_name = op.final_param_name;
+    side_effecting_param.xls_io_param_type = xls_param_type;
+    side_effecting_param.io_op = &context().sf->io_ops.back();
+    context().sf->side_effecting_parameters.push_back(side_effecting_param);
+  }
 
   return &context().sf->io_ops.back();
 }