pipelines.cpp

Go to the documentation of this file.

//===- pipelines.cpp - Arcilator lowering pipelines -----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the 'arcilator' lowering pipelines.
//
//===----------------------------------------------------------------------===//
 
#include "circt/Tools/arcilator/pipelines.h"
 
#include "circt/Conversion/ArcToLLVM.h"
#include "circt/Conversion/CombToArith.h"
#include "circt/Conversion/ConvertToArcs.h"
#include "circt/Conversion/Passes.h"
#include "circt/Conversion/SeqToSV.h"
#include "circt/Dialect/Arc/ArcOps.h"
#include "circt/Dialect/Arc/ArcPasses.h"
#include "circt/Dialect/Emit/EmitPasses.h"
#include "circt/Dialect/HW/HWPasses.h"
#include "circt/Dialect/OM/OMPasses.h"
#include "circt/Dialect/Seq/SeqPasses.h"
#include "circt/Dialect/Sim/SimPasses.h"
#include "circt/Support/Passes.h"
#include "mlir/Transforms/Passes.h"
 
using namespace mlir;
using namespace circt;
using namespace arc;
 
void circt::populateArcPreprocessingPipeline(
    OpPassManager &pm, const ArcPreprocessingOptions &options) {
  pm.addPass(arc::createResolveXMRRef());
  pm.addPass(om::createStripOMPass());
  pm.addPass(emit::createStripEmitPass());
  pm.addPass(createLowerFirMemPass());
  pm.addPass(createLowerVerifSimulationsPass());
  {
    arc::AddTapsOptions opts;
    opts.tapPorts = options.observePorts;
    opts.tapWires = options.observeWires;
    opts.tapNamedValues = options.observeNamedValues;
    pm.addPass(arc::createAddTaps(opts));
  }
  pm.addPass(arc::createStripSV({options.asyncResetsAsSync}));
  {
    arc::InferMemoriesOptions opts;
    opts.tapPorts = options.observePorts;
    opts.tapMemories = options.observeMemories;
    pm.addPass(arc::createInferMemories(opts));
  }
  pm.addPass(sim::createLowerDPIFunc());
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
}
 
void circt::populateArcConversionPipeline(OpPassManager &pm,
                                          const ArcConversionOptions &options) {
  {
    sim::SquashSimTriggeredOptions opts;
    opts.convertToHW = true;
    pm.addNestedPass<hw::HWModuleOp>(sim::createSquashSimTriggered(opts));
  }
  pm.addPass(arc::createLowerProcessesPass());
  {
    ConvertToArcsPassOptions opts;
    opts.tapRegisters = options.observeRegisters;
    pm.addPass(createConvertToArcsPass(opts));
  }
  if (options.shouldDedup)
    pm.addPass(arc::createDedup());
  pm.addPass(hw::createFlattenModules());
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
}
 
void circt::populateArcOptimizationPipeline(
    OpPassManager &pm, const ArcOptimizationOptions &options) {
  // Perform arc-level optimizations that are not specific to software
  // simulation.
  pm.addPass(arc::createSplitLoops());
  if (options.shouldDedup)
    pm.addPass(arc::createDedup());
  {
    arc::InferStatePropertiesOptions opts;
    opts.detectEnables = options.shouldDetectEnables;
    opts.detectResets = options.shouldDetectResets;
    pm.addPass(arc::createInferStateProperties(opts));
  }
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
  pm.addNestedPass<hw::HWModuleOp>(arc::createMergeTaps());
  if (options.shouldMakeLUTs)
    pm.addPass(arc::createMakeTables());
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
 
  // Now some arguments may be unused because reset conditions are not passed as
  // inputs anymore pm.addPass(arc::createRemoveUnusedArcArguments());
  // Because we replace a lot of StateOp inputs with constants in the enable
  // patterns we may be able to sink a lot of them
  // TODO: maybe merge RemoveUnusedArcArguments with SinkInputs?
  // pm.addPass(arc::createSinkInputs());
  // pm.addPass(createCSEPass());
  // pm.addPass(createSimpleCanonicalizerPass());
  // Removing some muxes etc. may lead to additional dedup opportunities
  // if (options.shouldDedup)
  // pm.addPass(arc::createDedup());
}
 
void circt::populateArcStateLoweringPipeline(
    OpPassManager &pm, const ArcStateLoweringOptions &options) {
  pm.addPass(arc::createLowerStatePass());
 
  // TODO: LowerClocksToFuncsPass might not properly consider scf.if operations
  // (or nested regions in general) and thus errors out when muxes are also
  // converted in the hw.module or arc.model
  // TODO: InlineArcs seems to not properly handle scf.if operations, thus the
  // following is commented out
  // pm.addPass(arc::createMuxToControlFlow());
  if (options.shouldInline)
    pm.addPass(arc::createInlineArcs());
 
  pm.addPass(arc::createMergeIfsPass());
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
  pm.addPass(arc::createLowerCoroutinesPass());
}
 
void circt::populateArcStateAllocationPipeline(
    OpPassManager &pm, const ArcStateAllocationOptions &options) {
  pm.addPass(arc::createLowerArcsToFuncs());
  pm.addPass(arc::createRemoveI0Types());
  {
    AllocateStateOptions allocStateOpts;
    allocStateOpts.insertTraceTaps = options.insertTraceTaps;
    pm.nest<arc::ModelOp>().addPass(arc::createAllocateState(allocStateOpts));
  }
  pm.nest<arc::ModelOp>().addPass(arc::createAllocateState());
  pm.addPass(arc::createLowerClocksToFuncs()); // no CSE between state alloc
                                               // and clock func lowering
  if (options.splitFuncsThreshold.getNumOccurrences()) {
    pm.addPass(arc::createSplitFuncs({options.splitFuncsThreshold}));
  }
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
}
 
void circt::populateArcToLLVMPipeline(OpPassManager &pm,
                                      const ArcToLLVMOptions &options) {
  if (!options.noGenerateDriver)
    pm.addPass(createGenerateDriver());
  {
    hw::HWConvertBitcastsOptions options;
    options.allowPartialConversion = false;
    pm.addPass(hw::createHWConvertBitcasts(options));
  }
  if (!options.noRuntime) {
    InsertRuntimeOptions opts;
    opts.extraArgs = options.extraRuntimeArgs;
    opts.traceFileName = options.traceFileName;
    pm.addPass(createInsertRuntime(opts));
  }
  if (options.bufferizeArrays) {
    pm.addPass(createLowerArrays());
  }
  pm.addPass(createLowerArcToLLVMPass());
  pm.addPass(createCSEPass());
  pm.addPass(arc::createArcCanonicalizer());
}