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-c/Builder.h"
 
#include "llzk/CAPI/Support.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 {

static MlirOpBuilderInsertPoint wrapInsertPoint(OpBuilder::InsertPoint point) {
  auto *block = point.getBlock();
  if (!block) {
    return {.block = {.ptr = nullptr}, .point = {.ptr = nullptr}};
  }
 
  if (point.getPoint() == block->end()) {
    return {.block = wrap(block), .point = {.ptr = nullptr}};
  }
 
  return {.block = wrap(block), .point = wrap(&*point.getPoint())};
}

class ListenerT : public OpBuilder::Listener {
public:
  ListenerT(MlirNotifyOperationInserted op, MlirNotifyBlockInserted block, void *data)
      : opInsertedCb(op), blockInsertedCb(block), userData(data) {}

  void notifyOperationInserted(Operation *op, OpBuilder::InsertPoint previous) final {
    opInsertedCb(wrap(op), wrapInsertPoint(previous), userData);
  }

  void notifyBlockInserted(Block *block, Region *previous, Region::iterator previousIt) final {
    blockInsertedCb(
        wrap(block), wrap(previous),
        (!previous || previous->end() == previousIt) ? MlirBlock {.ptr = nullptr}
                                                     : wrap(&*previousIt),
        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));
}

void mlirOpBuilderSetInsertionPointToEnd(MlirOpBuilder builder, MlirBlock block) {
  unwrap(builder)->setInsertionPointToEnd(unwrap(block));
}

void mlirOpBuilderSetInsertionPoint(MlirOpBuilder builder, MlirOperation operation) {
  unwrap(builder)->setInsertionPoint(unwrap(operation));
}

void mlirOpBuilderSetInsertionPointAfter(MlirOpBuilder builder, MlirOperation operation) {
  unwrap(builder)->setInsertionPointAfter(unwrap(operation));
}

void mlirOpBuilderSetInsertionPointAfterValue(MlirOpBuilder builder, MlirValue value) {
  unwrap(builder)->setInsertionPointAfterValue(unwrap(value));
}

MlirOpBuilderInsertPoint mlirOpBuilderSaveInsertionPoint(MlirOpBuilder builder) {
  return wrapInsertPoint(unwrap(builder)->saveInsertionPoint());
}

void mlirOpBuilderRestoreInsertionPoint(MlirOpBuilder builder, MlirOpBuilderInsertPoint rawIp) {
  auto *block = unwrap(rawIp.block);
  if (!block) {
    OpBuilderT::InsertPoint ip;
    unwrap(builder)->restoreInsertionPoint(ip);
  } else {
    Block::iterator it = rawIp.point.ptr ? Block::iterator(unwrap(rawIp.point)) : block->end();
    OpBuilderT::InsertPoint ip(block, it);
    unwrap(builder)->restoreInsertionPoint(ip);
  }
}

void mlirOpBuilderClearInsertionPoint(MlirOpBuilder builder) {
  unwrap(builder)->clearInsertionPoint();
}

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());
}

MlirOperation mlirOpBuilderInsert(MlirOpBuilder builder, MlirOperation op) {
  return wrap(unwrap(builder)->insert(unwrap(op)));
}
 
//===----------------------------------------------------------------------===//
// 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);
}