[xlscc] Add option to set control channel FIFO depth for multi-block designs.

Sets a default FIFO depth of 0 for sub-block control channels,
and adds the [[hls_control_channel_depth(N)]] Clang attribute to allow
the depth to be explicitly set.

xlscc represents C++ control flow by putting IO operations
in a serial token chain according to the order in the code.
This also applies to IO operations for calls to sub-blocks,
specifically in this case the send on the control channel.

PiperOrigin-RevId: 706841832

Author: Sean Purser-Haskell

xls/contrib/xlscc/BUILD

@@ -139,6 +139,7 @@ cc_library(
         "//xls/ir:value_utils",
         "//xls/solvers:z3_ir_translator",
         "//xls/solvers:z3_utils",
+        "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:btree",

xls/contrib/xlscc/cc_parser.cc

@@ -720,6 +720,75 @@ static clang::ParsedAttrInfoRegistry::Add<XlsBlockAttrInfo> hls_block(
     "hls_block",
     "Marks a function its own HLS block, below the top in the hierarchy.");
 
+struct XlsControlChannelDepthAttrInfo : public clang::ParsedAttrInfo {
+  XlsControlChannelDepthAttrInfo() {
+    // GNU-style __attribute__(("hls_control_channel_depth")) and C++/C23-style
+    // [[hls_control_channel_depth]] and [[xlscc::hls_control_channel_depth]]
+    // supported.
+    static constexpr Spelling S[] = {
+        {clang::ParsedAttr::AS_GNU, "hls_control_channel_depth"},
+        {clang::ParsedAttr::AS_C23, "hls_control_channel_depth"},
+        {clang::ParsedAttr::AS_CXX11, "hls_control_channel_depth"},
+        {clang::ParsedAttr::AS_CXX11, "xlscc::hls_control_channel_depth"}};
+    Spellings = S;
+    NumArgs = 1;
+  }
+
+  bool diagAppertainsToDecl(clang::Sema& S, const clang::ParsedAttr& Attr,
+                            const clang::Decl* D) const override {
+    // This attribute appertains to functions only.
+    if (!isa<clang::FunctionDecl>(D)) {
+      S.Diag(Attr.getLoc(), clang::diag::warn_attribute_wrong_decl_type_str)
+          << Attr << Attr.isRegularKeywordAttribute() << "functions";
+      return false;
+    }
+    return true;
+  }
+
+  AttrHandling handleDeclAttribute(
+      clang::Sema& S, clang::Decl* D,
+      const clang::ParsedAttr& Attr) const override {
+    clang::Attr* Result;
+    if (!CreateAttr(S, Attr, Result)) {
+      return AttributeNotApplied;
+    }
+    D->addAttr(Result);
+    return AttributeApplied;
+  }
+
+ private:
+  bool CreateAttr(clang::Sema& S, const clang::ParsedAttr& Attr,
+                  clang::Attr*& Result) const {
+    CHECK_EQ(Attr.getNumArgs(), 1);
+
+    auto invalid_argument = [&]() {
+      unsigned ID = S.getDiagnostics().getCustomDiagID(
+          clang::DiagnosticsEngine::Error,
+          "the argument to the 'hls_control_channel_depth' attribute must be "
+          "an integer >= 1");
+      S.Diag(Attr.getLoc(), ID);
+      return false;
+    };
+
+    clang::Expr* args[1];
+    if (!Attr.isArgExpr(0)) {
+      return invalid_argument();
+    }
+    args[0] = Attr.getArgAsExpr(0);
+    if (!args[0]->isIntegerConstantExpr(S.Context) ||
+        !args[0]->EvaluateKnownConstInt(S.Context).isStrictlyPositive()) {
+      return invalid_argument();
+    }
+    Result = clang::AnnotateAttr::Create(S.Context, "hls_control_channel_depth",
+                                         args, /*ArgsSize=*/1, Attr.getRange());
+    return true;
+  }
+};
+static clang::ParsedAttrInfoRegistry::Add<XlsControlChannelDepthAttrInfo>
+    hls_control_channel_depth("hls_control_channel_depth",
+                              "Sets the depth of the control channel FIFO for "
+                              "a sub-block. Default is 0.");
+
 class HlsArgsPragmaHandler : public clang::PragmaHandler {
  public:
   explicit HlsArgsPragmaHandler(const std::string& pragma_name,

xls/contrib/xlscc/translate_loops.cc

@@ -67,7 +67,7 @@ namespace xlscc {
 
 absl::Status Translator::GenerateIR_Loop(
     bool always_first_iter, const clang::Stmt* loop_stmt,
-    clang::ArrayRef<const clang::Attr*> attrs, const clang::Stmt* init,
+    clang::ArrayRef<const clang::AnnotateAttr*> attrs, const clang::Stmt* init,
     const clang::Expr* cond_expr, const clang::Stmt* inc,
     const clang::Stmt* body, const clang::PresumedLoc& presumed_loc,
     const xls::SourceInfo& loc, clang::ASTContext& ctx) {
@@ -79,54 +79,33 @@ absl::Status Translator::GenerateIR_Loop(
     }
   }
 
+  bool is_asap = HasAnnotation(attrs, "xlscc_asap");
+
   int64_t init_interval = -1;
+  XLS_ASSIGN_OR_RETURN(std::optional<int64_t> init_interval_optional,
+                       GetAnnotationWithNonNegativeIntegerParam(
+                           attrs, "hls_pipeline_init_interval", loc, ctx));
+
+  if (init_interval_optional.has_value()) {
+    init_interval = init_interval_optional.value();
+  } else {
+    // Pipelined loops can inherit their initiation interval from enclosing
+    // loops, so they can be allowed not to have a #pragma.
+    CHECK(!context().in_pipelined_for_body ||
+          (context().outer_pipelined_loop_init_interval > 0));
+    init_interval = context().outer_pipelined_loop_init_interval;
+  }
+
   int64_t unroll_factor = context().for_loops_default_unroll
                               ? std::numeric_limits<int64_t>::max()
                               : 0;
-  bool is_asap = false;
-  for (const clang::Attr* attr : attrs) {
-    if (const clang::AnnotateAttr* annotate =
-            llvm::dyn_cast<clang::AnnotateAttr>(attr);
-        annotate != nullptr) {
-      if (annotate->getAnnotation() == "hls_unroll") {
-        if (annotate->args_size() == 0) {
-          unroll_factor = std::numeric_limits<int64_t>::max();
-        } else if (annotate->args_size() > 1) {
-          return absl::InvalidArgumentError(
-              "hls_unroll must have at most one argument");
-        } else if (clang::Expr::EvalResult result;
-                   (*annotate->args().begin())->EvaluateAsInt(result, ctx) &&
-                   result.Val.getInt().isStrictlyPositive() &&
-                   result.Val.getInt().isRepresentableByInt64()) {
-          unroll_factor = result.Val.getInt().getExtValue();
-        } else {
-          return absl::InvalidArgumentError(
-              "hls_unroll argument (if provided) must be a positive integer");
-        }
-        continue;
-      }
-
-      if (annotate->getAnnotation() == "hls_pipeline_init_interval") {
-        if (annotate->args_size() != 1) {
-          return absl::InvalidArgumentError(
-              "hls_pipeline_init_interval must have exactly one argument");
-        }
-        clang::Expr::EvalResult result;
-        if (!(*annotate->args().begin())->EvaluateAsInt(result, ctx) ||
-            !result.Val.getInt().isStrictlyPositive() ||
-            !result.Val.getInt().isRepresentableByInt64()) {
-          return absl::InvalidArgumentError(
-              "the argument to the 'hls_pipeline_init_interval' attribute must "
-              "be an integer >= 1");
-        }
-        init_interval = result.Val.getInt().getExtValue();
-        continue;
-      }
+  XLS_ASSIGN_OR_RETURN(
+      std::optional<int64_t> unroll_factor_optional,
+      GetAnnotationWithNonNegativeIntegerParam(attrs, "hls_unroll", loc, ctx,
+                                               /*default_value=*/1));
 
-      if (annotate->getAnnotation() == "xlscc_asap") {
-        is_asap = true;
-      }
-    }
+  if (unroll_factor_optional.has_value()) {
+    unroll_factor = unroll_factor_optional.value();
   }
 
   if (unroll_factor > 0) {
@@ -141,14 +120,6 @@ absl::Status Translator::GenerateIR_Loop(
                                    body, ctx, loc);
   }
 
-  // Pipelined loops can inherit their initiation interval from enclosing
-  // loops, so they can be allowed not to have a #pragma.
-  if (init_interval < 0) {
-    CHECK(!context().in_pipelined_for_body ||
-          (context().outer_pipelined_loop_init_interval > 0));
-    init_interval = context().outer_pipelined_loop_init_interval;
-  }
-
   if (init_interval <= 0) {
     return absl::UnimplementedError(
         ErrorMessage(loc, "Loop statement missing #pragma or attribute"));