AttributeHelper.h

Go to the documentation of this file.

//===-- AttributeHelper.h ---------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
 
#pragma once
 
#include "llzk/Util/DynamicAPIntHelper.h"
#include "llzk/Util/StreamHelper.h"
 
#include <mlir/IR/DialectImplementation.h>
 
#include <llvm/ADT/APInt.h>
#include <llvm/ADT/Hashing.h>
 
#include <utility>
 
template <> struct mlir::FieldParser<llvm::APInt> {
  static mlir::FailureOr<llvm::APInt> parse(mlir::AsmParser &parser) {
    auto loc = parser.getCurrentLocation();
    llvm::APInt val;
    auto result = parser.parseOptionalInteger(val);
    if (!result.has_value() || *result) {
      return parser.emitError(loc, "expected integer value");
    } else {
      return val;
    }
  }
};
 
namespace llzk {

class DynamicAPIntValue {
public:
  DynamicAPIntValue(const llvm::DynamicAPInt &integer) : value(integer) {}

  operator const llvm::DynamicAPInt &() const { return value; }
 
  friend bool operator==(const DynamicAPIntValue &a, const DynamicAPIntValue &b) {
    return a.value == b.value;
  }
 
  friend llvm::hash_code hash_value(const DynamicAPIntValue &key) {
    return hashDynamicAPInt(key.value);
  }
 
private:
  llvm::DynamicAPInt value;
};

inline mlir::FailureOr<DynamicAPIntValue> parseDynamicAPIntValue(mlir::AsmParser &parser) {
  auto value = mlir::FieldParser<llvm::APInt>::parse(parser);
  if (mlir::failed(value)) {
    return mlir::failure();
  }
  return DynamicAPIntValue(llvm::DynamicAPInt(*value));
}

inline llvm::DynamicAPInt integerAttrToDynamicAPInt(mlir::IntegerAttr attr) {
  auto type = llvm::dyn_cast<mlir::IntegerType>(attr.getType());
  bool isUnsigned = type && (type.isUnsigned() || (type.isSignless() && type.getWidth() == 1));
  return isUnsigned ? toDynamicAPInt(attr.getValue()) : llvm::DynamicAPInt(attr.getValue());
}

inline int64_t fromAPInt(const llvm::APInt &i) {
  if (!i.isSignedIntN(64)) {
    llvm::report_fatal_error("integer is not representable as an index");
  }
  return i.getSExtValue();
}
 
inline bool isNullOrEmpty(mlir::ArrayAttr a) { return !a || a.empty(); }
inline bool isNullOrEmpty(mlir::DenseArrayAttr a) { return !a || a.empty(); }
inline bool isNullOrEmpty(mlir::DictionaryAttr a) { return !a || a.empty(); }
 
inline void appendWithoutType(mlir::raw_ostream &os, mlir::Attribute a) { a.print(os, true); }
inline std::string stringWithoutType(mlir::Attribute a) {
  return buildStringViaCallback(appendWithoutType, a);
}
 
void printAttrs(
    mlir::AsmPrinter &printer, mlir::ArrayRef<mlir::Attribute> attrs,
    const mlir::StringRef &separator
);
 
} // namespace llzk