[circt-synth] Allow AIGER file to be an input file (#9054)

Similar to firtool taking fir file as an input file this commit
changes circt-synth to parse an aiger file directly.

Author: uenoku

test/circt-synth/aiger.mlir

@@ -0,0 +1,8 @@
+// RUN: circt-translate --export-aiger %s | circt-synth --input-format=aiger | FileCheck %s
+// RUN: circt-translate --export-aiger %s -o %t.aig && circt-synth %t.aig | FileCheck %s
+// CHECK-LABEL: @aiger_top(
+// CHECK: synth.aig.and_inv %a, not %b : i1
+hw.module @and(in %a: i1, in %b: i1, out and: i1) {
+  %0 = synth.aig.and_inv %a, not %b : i1
+  hw.output %0 : i1
+}

tools/circt-synth/CMakeLists.txt

@@ -12,6 +12,7 @@ target_link_libraries(circt-synth
   CIRCTDebug
   CIRCTEmit
   CIRCTHW
+  CIRCTImportAIGER
   CIRCTLTL
   CIRCTOM
   CIRCTSeq

tools/circt-synth/circt-synth.cpp

@@ -11,6 +11,7 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "circt/Conversion/ImportAIGER.h"
 #include "circt/Conversion/SynthToComb.h"
 #include "circt/Dialect/Comb/CombDialect.h"
 #include "circt/Dialect/Comb/CombOps.h"
@@ -33,6 +34,7 @@
 #include "circt/Support/Passes.h"
 #include "circt/Support/Version.h"
 #include "circt/Transforms/Passes.h"
+#include "mlir/Bytecode/BytecodeReader.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/OwningOpRef.h"
@@ -61,6 +63,19 @@ using namespace synth;
 
 static cl::OptionCategory mainCategory("circt-synth Options");
 
+/// Allow the user to specify the input file format.  This can be used to
+/// override the input, and can be used to specify ambiguous cases like standard
+/// input.
+enum InputFormatKind { InputUnspecified, InputAIGERFile, InputMLIRFile };
+
+static cl::opt<InputFormatKind> inputFormat(
+    "input-format", cl::desc("Specify the input file format"),
+    cl::values(clEnumValN(InputUnspecified, "unspecified",
+                          "Unspecified input format"),
+               clEnumValN(InputAIGERFile, "aiger", "AIGER input format"),
+               clEnumValN(InputMLIRFile, "mlir", "MLIR input format")),
+    cl::init(InputUnspecified), cl::cat(mainCategory));
+
 static cl::opt<std::string> inputFilename(cl::Positional, cl::init("-"),
                                           cl::desc("Specify an input file"),
                                           cl::value_desc("filename"),
@@ -300,11 +315,48 @@ static LogicalResult executeSynthesis(MLIRContext &context) {
   applyDefaultTimingManagerCLOptions(tm);
   auto ts = tm.getRootScope();
 
+  // Set up the input file.
+  std::unique_ptr<llvm::MemoryBuffer> input;
+
+  {
+    std::string errorMessage;
+    input = openInputFile(inputFilename, &errorMessage);
+    if (!input) {
+      llvm::errs() << errorMessage << "\n";
+      return failure();
+    }
+  }
+
+  // Figure out the input format if unspecified.
+  if (inputFormat == InputUnspecified) {
+    if (StringRef(inputFilename).ends_with(".aig"))
+      inputFormat = InputAIGERFile;
+    else if (StringRef(inputFilename).ends_with(".mlir") ||
+             StringRef(inputFilename).ends_with(".mlirbc") ||
+             mlir::isBytecode(*input))
+      inputFormat = InputMLIRFile;
+    else {
+      llvm::errs() << "unknown input format: "
+                      "specify with -format=aiger or -format=mlir\n";
+      return failure();
+    }
+  }
+  llvm::SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(input), llvm::SMLoc());
   OwningOpRef<ModuleOp> module;
   {
-    auto parserTimer = ts.nest("Parse MLIR input");
     // Parse the provided input files.
-    module = parseSourceFile<ModuleOp>(inputFilename, &context);
+    if (inputFormat == InputAIGERFile) {
+      circt::aiger::ImportAIGEROptions options;
+      module =
+          OwningOpRef<ModuleOp>(ModuleOp::create(UnknownLoc::get(&context)));
+      if (failed(aiger::importAIGER(sourceMgr, &context, ts, module.get(),
+                                    &options)))
+        module = {};
+    } else {
+      auto parserTimer = ts.nest("Parse MLIR input");
+      module = parseSourceFile<ModuleOp>(sourceMgr, &context);
+    }
   }
   if (!module)
     return failure();