Struct.cpp

Go to the documentation of this file.

//===-- Struct.cpp - Struct 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-c/Dialect/Struct.h"
 
#include "llzk/CAPI/Builder.h"
#include "llzk/CAPI/Support.h"
#include "llzk/Dialect/Function/IR/Ops.h"
#include "llzk/Dialect/Struct/IR/Dialect.h"
#include "llzk/Dialect/Struct/IR/Ops.h"
#include "llzk/Dialect/Struct/IR/Types.h"
#include "llzk/Dialect/Struct/Transforms/TransformationPasses.h"
#include "llzk/Util/Compare.h"
#include "llzk/Util/SymbolLookup.h"
#include "llzk/Util/TypeHelper.h"
 
#include <mlir-c/BuiltinAttributes.h>
#include <mlir-c/Pass.h>
#include <mlir-c/Support.h>
 
#include <mlir/CAPI/AffineMap.h>
#include <mlir/CAPI/Pass.h>
#include <mlir/CAPI/Registration.h>
#include <mlir/CAPI/Support.h>
#include <mlir/CAPI/Wrap.h>
#include <mlir/IR/BuiltinAttributes.h>
#include <mlir/IR/SymbolTable.h>
 
#include <llvm/ADT/STLExtras.h>
 
using namespace mlir;
using namespace llzk;
using namespace llzk::component;
 
static inline void registerLLZKStructTransformationPasses() { registerTransformationPasses(); }
 
// Include the generated CAPI
#include "llzk/Dialect/Struct/IR/Ops.capi.cpp.inc"
#include "llzk/Dialect/Struct/IR/Types.capi.cpp.inc"
#include "llzk/Dialect/Struct/Transforms/TransformationPasses.capi.cpp.inc"
 
MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(Struct, llzk__component, StructDialect)
 
//===----------------------------------------------------------------------===//
// StructType
//===----------------------------------------------------------------------===//
 
MlirType llzkStruct_StructTypeGet(MlirAttribute name) {
  return wrap(StructType::get(llvm::cast<SymbolRefAttr>(unwrap(name))));
}
 
MlirType llzkStruct_StructTypeGetWithArrayAttr(MlirAttribute name, MlirAttribute params) {
  return wrap(
      StructType::get(
          llvm::cast<SymbolRefAttr>(unwrap(name)), llvm::cast<ArrayAttr>(unwrap(params))
      )
  );
}
 
MlirType llzkStruct_StructTypeGetWithAttrs(
    MlirAttribute name, intptr_t numParams, MlirAttribute const *params
) {
  SmallVector<Attribute> paramsSto;
  return wrap(
      StructType::get(
          llvm::cast<SymbolRefAttr>(unwrap(name)), unwrapList(numParams, params, paramsSto)
      )
  );
}
MlirLogicalResult llzkStructStructTypeGetDefinition(
    MlirType type, MlirOperation root, LlzkSymbolLookupResult *result
) {
  auto structType = mlir::unwrap_cast<StructType>(type);
  auto *rootOp = unwrap(root);
  SymbolTableCollection stc;
  mlir::FailureOr<llzk::SymbolLookupResult<StructDefOp>> lookup =
      structType.getDefinition(stc, rootOp);
 
  if (succeeded(lookup)) {
    // Allocate the result in the heap and store the pointer in the out var.
    result->ptr = new llzk::SymbolLookupResultUntyped(std::move(*lookup));
  }
  return wrap(lookup);
}
 
MlirLogicalResult llzkStructStructTypeGetDefinitionFromModule(
    MlirType type, MlirModule root, LlzkSymbolLookupResult *result
) {
  return llzkStructStructTypeGetDefinition(type, mlirModuleGetOperation(root), result);
}
 
//===----------------------------------------------------------------------===//
// StructDefOp
//===----------------------------------------------------------------------===//
 
MlirBlock llzkStruct_StructDefOpGetBody(MlirOperation op) {
  return wrap(llvm::cast<StructDefOp>(unwrap(op)).getBody());
}
 
MlirType llzkStruct_StructDefOpGetType(MlirOperation op) {
  return wrap(llvm::cast<StructDefOp>(unwrap(op)).getType());
}
 
MlirType llzkStruct_StructDefOpGetTypeWithParams(MlirOperation op, MlirAttribute attr) {
  return wrap(llvm::cast<StructDefOp>(unwrap(op)).getType(llvm::cast<ArrayAttr>(unwrap(attr))));
}
 
void llzkStruct_StructDefOpGetMemberDefs(MlirOperation op, MlirOperation *dst) {
  for (auto [offset, member] :
       llvm::enumerate(llvm::cast<StructDefOp>(unwrap(op)).getMemberDefs())) {
    dst[offset] = wrap(member);
  }
}
 
intptr_t llzkStruct_StructDefOpGetNumMemberDefs(MlirOperation op) {
  return llzk::checkedCast<intptr_t>(llvm::cast<StructDefOp>(unwrap(op)).getMemberDefs().size());
}
 
const char *llzkStruct_StructDefOpGetHeaderString(
    MlirOperation op, intptr_t *strSize, char *(*alloc_string)(size_t)
) {
  auto header = llvm::cast<StructDefOp>(unwrap(op)).getHeaderString();
  *strSize = llzk::checkedCast<intptr_t>(header.size()) + 1; // Plus one because it's a C string.
  char *dst = alloc_string(*strSize);
  dst[header.size()] = 0;
  memcpy(dst, header.data(), header.size());
  return dst;
}
 
void llzkStruct_StructDefOpGetTemplateParamOpNames(MlirOperation op, MlirAttribute *dst) {
  for (auto [offset, attr] :
       llvm::enumerate(llvm::cast<StructDefOp>(unwrap(op)).getTemplateParamOpNames())) {
    dst[offset] = wrap(attr);
  }
}
 
intptr_t llzkStruct_StructDefOpGetNumTemplateParamOpNames(MlirOperation op) {
  return llzk::checkedCast<intptr_t>(
      llvm::cast<StructDefOp>(unwrap(op)).getTemplateParamOpNames().size()
  );
}
 
void llzkStruct_StructDefOpGetTemplateExprOpNames(MlirOperation op, MlirAttribute *dst) {
  for (auto [offset, attr] :
       llvm::enumerate(llvm::cast<StructDefOp>(unwrap(op)).getTemplateExprOpNames())) {
    dst[offset] = wrap(attr);
  }
}
 
intptr_t llzkStruct_StructDefOpGetNumTemplateExprOpNames(MlirOperation op) {
  return llzk::checkedCast<intptr_t>(
      llvm::cast<StructDefOp>(unwrap(op)).getTemplateExprOpNames().size()
  );
}
 
//===----------------------------------------------------------------------===//
// MemberDefOp
//===----------------------------------------------------------------------===//
 
LLZK_DEFINE_OP_BUILD_METHOD(
    Struct, MemberDefOp, MlirStringRef name, MlirType type, bool isSignal, bool isColumn
) {
  return mlirOpBuilderInsert(
      builder,
      wrap(create<MemberDefOp>(builder, location, unwrap(name), unwrap(type), isSignal, isColumn))
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    Struct, MemberDefOp, WithAttrs, MlirAttribute name, MlirAttribute type, bool isSignal,
    bool isColumn
) {
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberDefOp>(
                       builder, location, llvm::cast<StringAttr>(unwrap(name)),
                       llvm::cast<TypeAttr>(unwrap(type)), isSignal, isColumn
                   )
               )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    Struct, MemberDefOp, WithNamedAttrs, intptr_t numAttrs, MlirNamedAttribute const *attrs,
    bool isSignal, bool isColumn
) {
  SmallVector<NamedAttribute> attrsSto;
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberDefOp>(
                       builder, location, unwrapList(numAttrs, attrs, attrsSto), isSignal, isColumn
                   )
               )
  );
}
 
bool llzkStruct_MemberDefOpGetColumnValue(MlirOperation op) {
  return llvm::cast<MemberDefOp>(unwrap(op)).getColumn();
}
 
void llzkStruct_MemberDefOpSetColumnValue(MlirOperation op, bool newValue) {
  llvm::cast<MemberDefOp>(unwrap(op)).setColumn(newValue);
}
 
bool llzkStruct_MemberDefOpGetSignalValue(MlirOperation op) {
  return llvm::cast<MemberDefOp>(unwrap(op)).getSignal();
}
 
void llzkStruct_MemberDefOpSetSignalValue(MlirOperation op, bool newValue) {
  llvm::cast<MemberDefOp>(unwrap(op)).setSignal(newValue);
}
 
//===----------------------------------------------------------------------===//
// MemberReadOp
//===----------------------------------------------------------------------===//
 
LLZK_DEFINE_OP_BUILD_METHOD(
    Struct, MemberReadOp, MlirType memberType, MlirValue component, MlirIdentifier memberName
) {
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberReadOp>(
                       builder, location, unwrap(memberType), unwrap(component), unwrap(memberName)
                   )
               )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    Struct, MemberReadOp, WithAffineMapDistance, MlirType memberType, MlirValue component,
    MlirIdentifier memberName, MlirAffineMap map, MlirValueRange mapOperands
) {
  SmallVector<Value> mapOperandsSto;
  auto mapAttr = AffineMapAttr::get(unwrap(map));
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberReadOp>(
                       builder, location, unwrap(memberType), unwrap(component), unwrap(memberName),
                       mapAttr, unwrapList(mapOperands.size, mapOperands.values, mapOperandsSto),
                       mapAttr.getAffineMap().getNumDims()
                   )
               )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    Struct, MemberReadOp, WithTemplateSymbolDistance, MlirType memberType, MlirValue component,
    MlirIdentifier memberName, MlirStringRef symbol
) {
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberReadOp>(
                       builder, location, unwrap(memberType), unwrap(component), unwrap(memberName),
                       FlatSymbolRefAttr::get(unwrap(builder)->getStringAttr(unwrap(symbol)))
                   )
               )
  );
}
 
LLZK_DEFINE_SUFFIX_OP_BUILD_METHOD(
    Struct, MemberReadOp, WithLiteralDistance, MlirType memberType, MlirValue component,
    MlirIdentifier memberName, int64_t distance
) {
  return mlirOpBuilderInsert(
      builder, wrap(
                   create<MemberReadOp>(
                       builder, location, unwrap(memberType), unwrap(component), unwrap(memberName),
                       unwrap(builder)->getIndexAttr(distance)
                   )
               )
  );
}