RTGTest.cpp

Go to the documentation of this file.

//===- RTGTest.cpp - C interface for the RTGTest dialect ------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "circt-c/Dialect/RTGTest.h"
#include "circt/Dialect/RTGTest/IR/RTGTestAttributes.h"
#include "circt/Dialect/RTGTest/IR/RTGTestDialect.h"
#include "circt/Dialect/RTGTest/IR/RTGTestTypes.h"
 
#include "mlir/CAPI/Registration.h"
 
using namespace circt;
using namespace circt::rtgtest;
 
//===----------------------------------------------------------------------===//
// Dialect API.
//===----------------------------------------------------------------------===//
 
MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(RTGTest, rtgtest, RTGTestDialect)
 
//===----------------------------------------------------------------------===//
// Type API.
//===----------------------------------------------------------------------===//
 
bool rtgtestTypeIsACPU(MlirType type) { return isa<CPUType>(unwrap(type)); }
 
MlirType rtgtestCPUTypeGet(MlirContext ctxt) {
  return wrap(CPUType::get(unwrap(ctxt)));
}
MlirType rtgtestCPUTypeGet(MlirContext ctxt) {…}
 
bool rtgtestTypeIsAIntegerRegister(MlirType type) {
  return isa<IntegerRegisterType>(unwrap(type));
}
bool rtgtestTypeIsAIntegerRegister(MlirType type) {…}
 
MlirType rtgtestIntegerRegisterTypeGet(MlirContext ctxt) {
  return wrap(IntegerRegisterType::get(unwrap(ctxt)));
}
MlirType rtgtestIntegerRegisterTypeGet(MlirContext ctxt) {…}
 
//===----------------------------------------------------------------------===//
// Attribute API.
//===----------------------------------------------------------------------===//
 
bool rtgtestAttrIsACPU(MlirAttribute attr) {
  return isa<CPUAttr>(unwrap(attr));
}
bool rtgtestAttrIsACPU(MlirAttribute attr) {…}
 
MlirAttribute rtgtestCPUAttrGet(MlirContext ctxt, unsigned id) {
  return wrap(CPUAttr::get(unwrap(ctxt), id));
}
MlirAttribute rtgtestCPUAttrGet(MlirContext ctxt, unsigned id) {…}
 
unsigned rtgtestCPUAttrGetId(MlirAttribute attr) {
  return cast<CPUAttr>(unwrap(attr)).getId();
}
unsigned rtgtestCPUAttrGetId(MlirAttribute attr) {…}
 
// Registers
//===----------------------------------------------------------------------===//
 
bool rtgtestAttrIsARegZero(MlirAttribute attr) {
  return isa<RegZeroAttr>(unwrap(attr));
}
bool rtgtestAttrIsARegZero(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegZeroAttrGet(MlirContext ctxt) {
  return wrap(RegZeroAttr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegZeroAttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegRa(MlirAttribute attr) {
  return isa<RegRaAttr>(unwrap(attr));
}
bool rtgtestAttrIsARegRa(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegRaAttrGet(MlirContext ctxt) {
  return wrap(RegRaAttr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegRaAttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegSp(MlirAttribute attr) {
  return isa<RegSpAttr>(unwrap(attr));
}
bool rtgtestAttrIsARegSp(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegSpAttrGet(MlirContext ctxt) {
  return wrap(RegSpAttr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegSpAttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegGp(MlirAttribute attr) {
  return isa<RegGpAttr>(unwrap(attr));
}
bool rtgtestAttrIsARegGp(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegGpAttrGet(MlirContext ctxt) {
  return wrap(RegGpAttr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegGpAttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegTp(MlirAttribute attr) {
  return isa<RegTpAttr>(unwrap(attr));
}
bool rtgtestAttrIsARegTp(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegTpAttrGet(MlirContext ctxt) {
  return wrap(RegTpAttr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegTpAttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT0(MlirAttribute attr) {
  return isa<RegT0Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT0(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT0AttrGet(MlirContext ctxt) {
  return wrap(RegT0Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT0AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT1(MlirAttribute attr) {
  return isa<RegT1Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT1(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT1AttrGet(MlirContext ctxt) {
  return wrap(RegT1Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT1AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT2(MlirAttribute attr) {
  return isa<RegT2Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT2(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT2AttrGet(MlirContext ctxt) {
  return wrap(RegT2Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT2AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS0(MlirAttribute attr) {
  return isa<RegS0Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS0(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS0AttrGet(MlirContext ctxt) {
  return wrap(RegS0Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS0AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS1(MlirAttribute attr) {
  return isa<RegS1Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS1(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS1AttrGet(MlirContext ctxt) {
  return wrap(RegS1Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS1AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA0(MlirAttribute attr) {
  return isa<RegA0Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA0(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA0AttrGet(MlirContext ctxt) {
  return wrap(RegA0Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA0AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA1(MlirAttribute attr) {
  return isa<RegA1Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA1(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA1AttrGet(MlirContext ctxt) {
  return wrap(RegA1Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA1AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA2(MlirAttribute attr) {
  return isa<RegA2Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA2(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA2AttrGet(MlirContext ctxt) {
  return wrap(RegA2Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA2AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA3(MlirAttribute attr) {
  return isa<RegA3Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA3(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA3AttrGet(MlirContext ctxt) {
  return wrap(RegA3Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA3AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA4(MlirAttribute attr) {
  return isa<RegA4Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA4(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA4AttrGet(MlirContext ctxt) {
  return wrap(RegA4Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA4AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA5(MlirAttribute attr) {
  return isa<RegA5Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA5(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA5AttrGet(MlirContext ctxt) {
  return wrap(RegA5Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA5AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA6(MlirAttribute attr) {
  return isa<RegA6Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA6(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA6AttrGet(MlirContext ctxt) {
  return wrap(RegA6Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA6AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegA7(MlirAttribute attr) {
  return isa<RegA7Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegA7(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegA7AttrGet(MlirContext ctxt) {
  return wrap(RegA7Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegA7AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS2(MlirAttribute attr) {
  return isa<RegS2Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS2(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS2AttrGet(MlirContext ctxt) {
  return wrap(RegS2Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS2AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS3(MlirAttribute attr) {
  return isa<RegS3Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS3(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS3AttrGet(MlirContext ctxt) {
  return wrap(RegS3Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS3AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS4(MlirAttribute attr) {
  return isa<RegS4Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS4(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS4AttrGet(MlirContext ctxt) {
  return wrap(RegS4Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS4AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS5(MlirAttribute attr) {
  return isa<RegS5Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS5(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS5AttrGet(MlirContext ctxt) {
  return wrap(RegS5Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS5AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS6(MlirAttribute attr) {
  return isa<RegS6Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS6(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS6AttrGet(MlirContext ctxt) {
  return wrap(RegS6Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS6AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS7(MlirAttribute attr) {
  return isa<RegS7Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS7(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS7AttrGet(MlirContext ctxt) {
  return wrap(RegS7Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS7AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS8(MlirAttribute attr) {
  return isa<RegS8Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS8(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS8AttrGet(MlirContext ctxt) {
  return wrap(RegS8Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS8AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS9(MlirAttribute attr) {
  return isa<RegS9Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS9(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS9AttrGet(MlirContext ctxt) {
  return wrap(RegS9Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS9AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS10(MlirAttribute attr) {
  return isa<RegS10Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS10(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS10AttrGet(MlirContext ctxt) {
  return wrap(RegS10Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS10AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegS11(MlirAttribute attr) {
  return isa<RegS11Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegS11(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegS11AttrGet(MlirContext ctxt) {
  return wrap(RegS11Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegS11AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT3(MlirAttribute attr) {
  return isa<RegT3Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT3(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT3AttrGet(MlirContext ctxt) {
  return wrap(RegT3Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT3AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT4(MlirAttribute attr) {
  return isa<RegT4Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT4(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT4AttrGet(MlirContext ctxt) {
  return wrap(RegT4Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT4AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT5(MlirAttribute attr) {
  return isa<RegT5Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT5(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT5AttrGet(MlirContext ctxt) {
  return wrap(RegT5Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT5AttrGet(MlirContext ctxt) {…}
 
bool rtgtestAttrIsARegT6(MlirAttribute attr) {
  return isa<RegT6Attr>(unwrap(attr));
}
bool rtgtestAttrIsARegT6(MlirAttribute attr) {…}
 
MlirAttribute rtgtestRegT6AttrGet(MlirContext ctxt) {
  return wrap(RegT6Attr::get(unwrap(ctxt)));
}
MlirAttribute rtgtestRegT6AttrGet(MlirContext ctxt) {…}