CIRCT  19.0.0git
ESILowerTypes.cpp
Go to the documentation of this file.
1 //===- ESILowerTypes.cpp ----------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Lower high-level ESI types to HW conversions and pass.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "../PassDetails.h"
14 
19 
20 #include "mlir/IR/BuiltinTypes.h"
21 #include "mlir/Interfaces/ControlFlowInterfaces.h"
22 #include "mlir/Pass/Pass.h"
23 #include "mlir/Transforms/DialectConversion.h"
24 
25 namespace circt {
26 namespace esi {
27 #define GEN_PASS_DEF_LOWERESITYPES
28 #include "circt/Dialect/ESI/ESIPasses.h.inc"
29 } // namespace esi
30 } // namespace circt
31 
32 using namespace circt;
33 using namespace circt::esi;
34 
35 namespace {
36 /// Lower all "high-level" ESI types on modules to some lower construct.
37 struct ESILowerTypesPass
38  : public circt::esi::impl::LowerESITypesBase<ESILowerTypesPass> {
39  void runOnOperation() override;
40 };
41 } // anonymous namespace
42 
43 namespace {
44 /// Materializations and type conversions to lower ESI data windows.
45 class LowerTypesConverter : public TypeConverter {
46 public:
47  LowerTypesConverter() {
48  addConversion([](Type t) { return t; });
49  addConversion([](WindowType window) { return window.getLoweredType(); });
50  addSourceMaterialization(wrapMaterialization);
51  addArgumentMaterialization(wrapMaterialization);
52  addTargetMaterialization(unwrapMaterialization);
53  }
54 
55 private:
56  static std::optional<mlir::Value> wrapMaterialization(OpBuilder &b,
57  WindowType resultType,
58  ValueRange inputs,
59  Location loc) {
60  if (inputs.size() != 1)
61  return std::nullopt;
62  auto wrap = b.create<WrapWindow>(loc, resultType, inputs[0]);
63  return wrap.getWindow();
64  }
65 
66  static std::optional<mlir::Value>
67  unwrapMaterialization(OpBuilder &b, hw::UnionType resultType,
68  ValueRange inputs, Location loc) {
69  if (inputs.size() != 1 || !isa<WindowType>(inputs[0].getType()))
70  return std::nullopt;
71  auto unwrap = b.create<UnwrapWindow>(loc, resultType, inputs[0]);
72  return unwrap.getFrame();
73  }
74 };
75 } // namespace
76 
77 void ESILowerTypesPass::runOnOperation() {
78  ConversionTarget target(getContext());
79 
80  // We need to lower instances, modules, and outputs with data windows.
81  target.markUnknownOpDynamicallyLegal([](Operation *op) {
82  return TypeSwitch<Operation *, bool>(op)
83  .Case([](igraph::InstanceOpInterface inst) {
84  return !(
85  llvm::any_of(inst->getOperandTypes(), hw::type_isa<WindowType>) ||
86  llvm::any_of(inst->getResultTypes(), hw::type_isa<WindowType>));
87  })
88  .Case([](hw::HWMutableModuleLike mod) {
89  auto isWindowPort = [](hw::PortInfo p) {
90  return hw::type_isa<WindowType>(p.type);
91  };
92  return !(llvm::any_of(mod.getPortList(), isWindowPort));
93  })
94  .Default([](Operation *op) {
95  if (op->hasTrait<OpTrait::ReturnLike>())
96  return !llvm::any_of(op->getOperandTypes(),
97  hw::type_isa<WindowType>);
98  return true;
99  });
100  });
101 
102  LowerTypesConverter types;
103  RewritePatternSet patterns(&getContext());
104  patterns.add<TypeConversionPattern>(types, &getContext());
105  if (failed(
106  applyPartialConversion(getOperation(), target, std::move(patterns))))
107  signalPassFailure();
108 }
109 
110 std::unique_ptr<OperationPass<ModuleOp>>
112  return std::make_unique<ESILowerTypesPass>();
113 }
return wrap(CMemoryType::get(unwrap(ctx), baseType, numElements))
static EvaluatorValuePtr unwrap(OMEvaluatorValue c)
Definition: OM.cpp:96
llvm::SmallVector< StringAttr > inputs
std::unique_ptr< OperationPass< ModuleOp > > createESITypeLoweringPass()
The InstanceGraph op interface, see InstanceGraphInterface.td for more details.
Definition: DebugAnalysis.h:21
Definition: esi.py:1
Generic pattern which replaces an operation by one of the same operation name, but with converted att...