Support.cpp

Go to the documentation of this file.

//===-- Support.cpp - C API general utilities ---------------------*- 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/Support.h"
 
#include "llzk-c/Support.h"
 
#include "llzk/Util/Compare.h"
#include "llzk/Util/SymbolLookup.h"
 
#include <mlir-c/BuiltinAttributes.h>
 
#include <mlir/CAPI/IR.h>
#include <mlir/CAPI/Support.h>
#include <mlir/CAPI/Wrap.h>
#include <mlir/IR/BuiltinAttributes.h>
#include <mlir/IR/Iterators.h>
#include <mlir/IR/SymbolTable.h>
 
#include <cstdint>
#include <cstring>
 
using namespace llzk;
using namespace mlir;

void llzkSymbolLookupResultDestroy(LlzkSymbolLookupResult result) {
  delete reinterpret_cast<SymbolLookupResultUntyped *>(result.ptr);
}

MlirOperation LlzkSymbolLookupResultGetOperation(LlzkSymbolLookupResult wrapped) {
  SymbolLookupResultUntyped *result = reinterpret_cast<SymbolLookupResultUntyped *>(wrapped.ptr);
  return wrap(result->get());
}

void mlirOperationReplaceUsesOfWith(MlirOperation op, MlirValue oldValue, MlirValue newValue) {
  unwrap(op)->replaceUsesOfWith(unwrap(oldValue), unwrap(newValue));
}

static mlir::WalkResult unwrap(MlirWalkResult result) {
  switch (result) {
  case MlirWalkResultAdvance:
    return mlir::WalkResult::advance();
 
  case MlirWalkResultInterrupt:
    return mlir::WalkResult::interrupt();
 
  case MlirWalkResultSkip:
    return mlir::WalkResult::skip();
  }
  llvm_unreachable("unknown result in WalkResult::unwrap");
}
 
void mlirOperationWalkReverse(
    MlirOperation from, MlirOperationWalkCallback callback, void *userData, MlirWalkOrder walkOrder
) {
  switch (walkOrder) {
  case MlirWalkPreOrder:
    unwrap(from)->walk<WalkOrder::PreOrder, ReverseIterator>([callback, userData](Operation *op) {
      return unwrap(callback(wrap(op), userData));
    });
    break;
  case MlirWalkPostOrder:
    unwrap(from)->walk<WalkOrder::PostOrder, ReverseIterator>([callback, userData](Operation *op) {
      return unwrap(callback(wrap(op), userData));
    });
  }
}
 
void llzkSymbolTableInsert(MlirOperation symTableOp, MlirOperation newSymbolOp) {
  SymbolTableCollection symTables;
  symTables.getSymbolTable(unwrap(symTableOp)).insert(unwrap(newSymbolOp));
}
 
//===----------------------------------------------------------------------===//
// LlzkAffineMapOperandsBuilder implementation.
//===----------------------------------------------------------------------===//
 
namespace {
template <typename T> void appendElems(T const *src, intptr_t srcSize, T *&dst, intptr_t &dstSize) {
  assert(srcSize >= 0 && "Negative source size");
  assert(dstSize >= 0 && "Negative destination size");
  T *newDst = static_cast<T *>(std::realloc(dst, (srcSize + dstSize) * sizeof(T)));
  assert(newDst && "Failed to increase the size of buffer");
  dst = newDst; // this temporary + assert prevents `clang-tidy` warnings
  std::memcpy(dst + dstSize, src, srcSize * sizeof(T));
  dstSize += srcSize;
}
 
static void maybeDeallocArray(LlzkAffineMapOperandsBuilder *builder) {
  if (builder->nDimsPerMap >= 0 && builder->dimsPerMap.array) {
    std::free(builder->dimsPerMap.array);
    builder->dimsPerMap.array = nullptr;
  }
}

static void assertArraysAreInSync(LlzkAffineMapOperandsBuilder *builder) {
  intptr_t nDimsPerMap = builder->nDimsPerMap < 0
                             ? unwrap_cast<DenseI32ArrayAttr>(builder->dimsPerMap.attr).size()
                             : builder->nDimsPerMap;
  (void)nDimsPerMap; // To silence unused variable warning if the assert below is compiled out.
  assert(builder->nMapOperands == nDimsPerMap);
}
 
} // namespace
 
LlzkAffineMapOperandsBuilder llzkAffineMapOperandsBuilderCreate() {
  LlzkAffineMapOperandsBuilder builder;
  builder.nMapOperands = 0;
  builder.mapOperands = nullptr;
  builder.nDimsPerMap = 0;
  builder.dimsPerMap.array = nullptr;
 
  return builder;
}
 
void llzkAffineMapOperandsBuilderDestroy(LlzkAffineMapOperandsBuilder *builder) {
  if (!builder) {
    return;
  }
  if (builder->mapOperands) {
    std::free(builder->mapOperands);
  }
  maybeDeallocArray(builder);
  // Reset values to 0/NULL.
  *builder = llzkAffineMapOperandsBuilderCreate();
}
 
void llzkAffineMapOperandsBuilderAppendOperands(
    LlzkAffineMapOperandsBuilder *builder, intptr_t n, MlirValueRange const *mapOperands
) {
  appendElems(mapOperands, n, builder->mapOperands, builder->nMapOperands);
}
 
void llzkAffineMapOperandsBuilderAppendOperandsWithDimCount(
    LlzkAffineMapOperandsBuilder *builder, intptr_t n, MlirValueRange const *mapOperands,
    int32_t const *dimsPerMap
) {
  assertArraysAreInSync(builder);
  llzkAffineMapOperandsBuilderAppendOperands(builder, n, mapOperands);
  llzkAffineMapOperandsBuilderAppendDimCount(builder, n, dimsPerMap);
  assertArraysAreInSync(builder);
}
 
void llzkAffineMapOperandsBuilderAppendDimCount(
    LlzkAffineMapOperandsBuilder *builder, intptr_t n, int32_t const *dimsPerMap
) {
  llzkAffineMapOperandsBuilderConvertDimsPerMapToArray(builder);
  appendElems(dimsPerMap, n, builder->dimsPerMap.array, builder->nDimsPerMap);
}
 
void llzkAffineMapOperandsBuilderSetDimsPerMapFromAttr(
    LlzkAffineMapOperandsBuilder *builder, MlirAttribute attribute
) {
  assert(mlirAttributeIsADenseI32Array(attribute) && "Attribute is not a DenseI32Array");
  maybeDeallocArray(builder);
  builder->nDimsPerMap = -1;
  builder->dimsPerMap.attr = attribute;
}
 
void llzkAffineMapOperandsBuilderConvertDimsPerMapToArray(LlzkAffineMapOperandsBuilder *builder) {
  if (builder->nDimsPerMap >= 0) {
    return;
  }
  auto attrData = mlir::unwrap_cast<DenseI32ArrayAttr>(builder->dimsPerMap.attr).asArrayRef();
  size_t realSize = attrData.size() * sizeof(decltype(attrData)::value_type);
  builder->dimsPerMap.array = static_cast<int32_t *>(std::malloc(realSize));
  std::memcpy(builder->dimsPerMap.array, attrData.data(), realSize);
  builder->nDimsPerMap = llzk::checkedCast<intptr_t>(attrData.size());
}
 
void llzkAffineMapOperandsBuilderConvertDimsPerMapToAttr(
    LlzkAffineMapOperandsBuilder *builder, MlirContext context
) {
 
  auto attr = llzkAffineMapOperandsBuilderGetDimsPerMapAttr(*builder, context);
  llzkAffineMapOperandsBuilderSetDimsPerMapFromAttr(builder, attr);
}
 
MlirAttribute llzkAffineMapOperandsBuilderGetDimsPerMapAttr(
    LlzkAffineMapOperandsBuilder builder, MlirContext context
) {
  if (builder.nDimsPerMap < 0) {
    return builder.dimsPerMap.attr;
  }
  return mlirDenseI32ArrayGet(context, builder.nDimsPerMap, builder.dimsPerMap.array);
}