Builder.cpp

Go to the documentation of this file.

//===-- Builder.cpp - C API for op builder ----------------------*- C++ -*-===//
//
// Part of the LLZK Project, under the Apache License v2.0.
// See LICENSE.txt for license information.
// Copyright 2025 Veridise Inc.
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
 
#include "llzk/CAPI/Builder.h"
#include "llzk/CAPI/Support.h"
 
#include "llzk-c/Builder.h"
 
#include <mlir/CAPI/IR.h>
#include <mlir/CAPI/Support.h>
#include <mlir/CAPI/Wrap.h>
#include <mlir/IR/Builders.h>
 
using namespace mlir;
 
using OpBuilderT = OpBuilder;
 
namespace {
 
class ListenerT : public OpBuilder::Listener {
public:
  ListenerT(MlirNotifyOperationInserted op, MlirNotifyBlockInserted block, void *data)
      : opInsertedCb(op), blockInsertedCb(block), userData(data) {}
 
  void notifyOperationInserted(Operation *op) final { opInsertedCb(wrap(op), userData); }
 
  void notifyBlockCreated(Block *block) final { blockInsertedCb(wrap(block), userData); }
 
private:
  MlirNotifyOperationInserted opInsertedCb;
  MlirNotifyBlockInserted blockInsertedCb;
  void *userData = nullptr;
};
 
} // namespace
 
//===----------------------------------------------------------------------===//
// MlirOpBuilder
//===----------------------------------------------------------------------===//
 
MlirOpBuilder mlirOpBuilderCreate(MlirContext ctx) {
  return MlirOpBuilder {.ptr = new OpBuilderT(unwrap(ctx))};
}
 
MlirOpBuilder mlirOpBuilderCreateWithListener(MlirContext ctx, MlirOpBuilderListener listener) {
  auto *l = reinterpret_cast<ListenerT *>(listener.ptr);
  return MlirOpBuilder {.ptr = new OpBuilderT(unwrap(ctx), l)};
}
 
void mlirOpBuilderDestroy(MlirOpBuilder builder) {
  delete reinterpret_cast<OpBuilderT *>(builder.ptr);
}
 
MlirContext mlirOpBuilderGetContext(MlirOpBuilder builder) {
  return wrap(unwrap(builder)->getContext());
}
 
void mlirOpBuilderSetInsertionPointToStart(MlirOpBuilder builder, MlirBlock block) {
  unwrap(builder)->setInsertionPointToStart(unwrap(block));
}
 
MlirOperation mlirOpBuilderGetInsertionPoint(MlirOpBuilder builder) {
  auto it = unwrap(builder)->getInsertionPoint();
  auto *blk = unwrap(builder)->getInsertionBlock();
  if (!blk) {
    return MlirOperation {nullptr};
  }
 
  return wrap(it != blk->end() ? &*it : nullptr);
}

MlirBlock mlirOpBuilderGetInsertionBlock(MlirOpBuilder builder) {
  return wrap(unwrap(builder)->getInsertionBlock());
}
 
//===----------------------------------------------------------------------===//
// MlirOpBuilderListener
//===----------------------------------------------------------------------===//
 
MlirOpBuilderListener mlirOpBuilderListenerCreate(
    MlirNotifyOperationInserted opCb, MlirNotifyBlockInserted blockCb, void *userData
) {
  return MlirOpBuilderListener {.ptr = new ListenerT(opCb, blockCb, userData)};
}
 
void mlirOpBuilderListenerDestroy(MlirOpBuilderListener listener) {
  delete reinterpret_cast<ListenerT *>(listener.ptr);
}