Function.cpp

Go to the documentation of this file.

//===-- Function.cpp - Function dialect C API implementation ----*- 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/Dialect/Function/IR/Dialect.h"
#include "llzk/Dialect/Function/IR/Ops.h"
 
#include "llzk-c/Dialect/Function.h"
#include "llzk-c/Support.h"
 
#include <mlir/CAPI/IR.h>
#include <mlir/CAPI/Pass.h>
#include <mlir/CAPI/Registration.h>
#include <mlir/CAPI/Wrap.h>
#include <mlir/IR/Attributes.h>
#include <mlir/IR/BuiltinAttributes.h>
 
#include <mlir-c/IR.h>
#include <mlir-c/Pass.h>
 
#include <llvm/ADT/SmallVectorExtras.h>
 
using namespace mlir;
using namespace llzk;
using namespace llzk::function;
 
MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(Function, llzk__function, FunctionDialect)
 
static NamedAttribute unwrap(MlirNamedAttribute attr) {
  return NamedAttribute(unwrap(attr.name), unwrap(attr.attribute));
}
 
//===----------------------------------------------------------------------===//
// FuncDefOp
//===----------------------------------------------------------------------===//

MlirOperation llzkFuncDefOpCreateWithAttrsAndArgAttrs(
    MlirLocation location, MlirStringRef name, MlirType funcType, intptr_t numAttrs,
    MlirNamedAttribute const *attrs, intptr_t numArgAttrs, MlirAttribute const *argAttrs
) {
  SmallVector<NamedAttribute> attrsSto;
  SmallVector<Attribute> argAttrsSto;
  SmallVector<DictionaryAttr> unwrappedArgAttrs =
      llvm::map_to_vector(unwrapList(numArgAttrs, argAttrs, argAttrsSto), [](auto attr) {
    return llvm::cast<DictionaryAttr>(attr);
  });
  return wrap(
      FuncDefOp::create(
          unwrap(location), unwrap(name), llvm::cast<FunctionType>(unwrap(funcType)),
          unwrapList(numAttrs, attrs, attrsSto), unwrappedArgAttrs
      )
  );
}
 
bool llzkOperationIsAFuncDefOp(MlirOperation op) { return llvm::isa<FuncDefOp>(unwrap(op)); }
 
bool llzkFuncDefOpGetHasAllowConstraintAttr(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).hasAllowConstraintAttr();
}
 
void llzkFuncDefOpSetAllowConstraintAttr(MlirOperation op, bool value) {
  unwrap_cast<FuncDefOp>(op).setAllowConstraintAttr(value);
}
 
bool llzkFuncDefOpGetHasAllowWitnessAttr(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).hasAllowWitnessAttr();
}
 
void llzkFuncDefOpSetAllowWitnessAttr(MlirOperation op, bool value) {
  unwrap_cast<FuncDefOp>(op).setAllowWitnessAttr(value);
}
 
bool llzkFuncDefOpGetHasAllowNonNativeFieldOpsAttr(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).hasAllowNonNativeFieldOpsAttr();
}
 
void llzkFuncDefOpSetAllowNonNativeFieldOpsAttr(MlirOperation op, bool value) {
  unwrap_cast<FuncDefOp>(op).setAllowNonNativeFieldOpsAttr(value);
}
 
bool llzkFuncDefOpGetHasArgIsPub(MlirOperation op, unsigned argNo) {
  return unwrap_cast<FuncDefOp>(op).hasArgPublicAttr(argNo);
}
 
MlirAttribute llzkFuncDefOpGetFullyQualifiedName(MlirOperation op) {
  return wrap(unwrap_cast<FuncDefOp>(op).getFullyQualifiedName());
}
 
bool llzkFuncDefOpGetNameIsCompute(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).nameIsCompute();
}
 
bool llzkFuncDefOpGetNameIsConstrain(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).nameIsConstrain();
}
 
bool llzkFuncDefOpGetIsInStruct(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).isInStruct();
}
 
bool llzkFuncDefOpGetIsStructCompute(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).isStructCompute();
}
 
bool llzkFuncDefOpGetIsStructConstrain(MlirOperation op) {
  return unwrap_cast<FuncDefOp>(op).isStructConstrain();
}

MlirValue llzkFuncDefOpGetSelfValueFromCompute(MlirOperation op) {
  return wrap(unwrap_cast<FuncDefOp>(op).getSelfValueFromCompute());
}

MlirValue llzkFuncDefOpGetSelfValueFromConstrain(MlirOperation op) {
  return wrap(unwrap_cast<FuncDefOp>(op).getSelfValueFromConstrain());
}

MlirType llzkFuncDefOpGetSingleResultTypeOfCompute(MlirOperation op) {
  return wrap(unwrap_cast<FuncDefOp>(op).getSingleResultTypeOfCompute());
}
 
//===----------------------------------------------------------------------===//
// CallOp
//===----------------------------------------------------------------------===//
 
static auto unwrapCallee(MlirOperation op) { return llvm::cast<FuncDefOp>(unwrap(op)); }
 
static auto unwrapDims(MlirAttribute attr) { return llvm::cast<DenseI32ArrayAttr>(unwrap(attr)); }
 
static auto unwrapName(MlirAttribute attr) { return llvm::cast<SymbolRefAttr>(unwrap(attr)); }
 
LLZK_DEFINE_OP_BUILD_METHOD(
    CallOp, intptr_t numResults, MlirType const *results, MlirAttribute name, intptr_t numOperands,
    MlirValue const *operands
) {
  SmallVector<Type> resultsSto;
  SmallVector<Value> operandsSto;
  return wrap(
      create<CallOp>(
          builder, location, unwrapList(numResults, results, resultsSto), unwrapName(name),
          unwrapList(numOperands, operands, operandsSto)
      )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    CallOp, ToCallee, MlirOperation callee, intptr_t numOperands, MlirValue const *operands
) {
  SmallVector<Value> operandsSto;
  return wrap(
      create<CallOp>(
          builder, location, unwrapCallee(callee), unwrapList(numOperands, operands, operandsSto)
      )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    CallOp, WithMapOperands, intptr_t numResults, MlirType const *results, MlirAttribute name,
    LlzkAffineMapOperandsBuilder mapOperands, intptr_t numArgOperands, MlirValue const *argOperands
) {
  SmallVector<Type> resultsSto;
  SmallVector<Value> argOperandsSto;
  MapOperandsHelper<> mapOperandsHelper(mapOperands.nMapOperands, mapOperands.mapOperands);
  auto numDimsPerMap =
      llzkAffineMapOperandsBuilderGetDimsPerMapAttr(mapOperands, mlirLocationGetContext(location));
  return wrap(
      create<CallOp>(
          builder, location, unwrapList(numResults, results, resultsSto), unwrapName(name),
          *mapOperandsHelper, unwrapDims(numDimsPerMap),
          unwrapList(numArgOperands, argOperands, argOperandsSto)
      )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    CallOp, ToCalleeWithMapOperands, MlirOperation callee, LlzkAffineMapOperandsBuilder mapOperands,
    intptr_t numArgOperands, MlirValue const *argOperands
) {
  SmallVector<Value> argOperandsSto;
  MapOperandsHelper<> mapOperandsHelper(mapOperands.nMapOperands, mapOperands.mapOperands);
  auto numDimsPerMap =
      llzkAffineMapOperandsBuilderGetDimsPerMapAttr(mapOperands, mlirLocationGetContext(location));
  return wrap(
      create<CallOp>(
          builder, location, unwrapCallee(callee), *mapOperandsHelper, unwrapDims(numDimsPerMap),
          unwrapList(numArgOperands, argOperands, argOperandsSto)
      )
  );
}
 
bool llzkOperationIsACallOp(MlirOperation op) { return llvm::isa<CallOp>(unwrap(op)); }
 
MlirType llzkCallOpGetCalleeType(MlirOperation op) {
  return wrap(unwrap_cast<CallOp>(op).getCalleeType());
}
 
bool llzkCallOpGetCalleeIsCompute(MlirOperation op) {
  return unwrap_cast<CallOp>(op).calleeIsCompute();
}
 
bool llzkCallOpGetCalleeIsConstrain(MlirOperation op) {
  return unwrap_cast<CallOp>(op).calleeIsConstrain();
}
 
bool llzkCallOpGetCalleeIsStructCompute(MlirOperation op) {
  return unwrap_cast<CallOp>(op).calleeIsStructCompute();
}
 
bool llzkCallOpGetCalleeIsStructConstrain(MlirOperation op) {
  return unwrap_cast<CallOp>(op).calleeIsStructConstrain();
}

MlirValue llzkCallOpGetSelfValueFromCompute(MlirOperation op) {
  return wrap(unwrap_cast<CallOp>(op).getSelfValueFromCompute());
}

MlirValue llzkCallOpGetSelfValueFromConstrain(MlirOperation op) {
  return wrap(unwrap_cast<CallOp>(op).getSelfValueFromConstrain());
}
 
MlirType llzkCallOpGetSingleResultTypeOfCompute(MlirOperation op) {
  return wrap(unwrap_cast<CallOp>(op).getSingleResultTypeOfCompute());
}