CustomDirectiveImpl.cpp

Go to the documentation of this file.

//===- CustomDirectiveImpl.cpp - Custom TableGen directives ---------------===//
//
// 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/Support/CustomDirectiveImpl.h"
#include "llvm/ADT/SmallString.h"
 
using namespace circt;
 
ParseResult circt::parseImplicitSSAName(OpAsmParser &parser, StringAttr &attr) {
  // Use the explicit name if one is provided as `name "xyz"`.
  if (!parser.parseOptionalKeyword("name")) {
    std::string str;
    if (parser.parseString(&str))
      return failure();
    attr = parser.getBuilder().getStringAttr(str);
    return success();
  }
 
  // Infer the name from the SSA name of the operation's first result.
  auto resultName = parser.getResultName(0).first;
  if (!resultName.empty() && isdigit(resultName[0]))
    resultName = "";
  attr = parser.getBuilder().getStringAttr(resultName);
  return success();
}
 
ParseResult circt::parseImplicitSSANames(OpAsmParser &parser, ArrayAttr &attr) {
  SmallVector<Attribute> names;
  unsigned resultIndex = 0;
  while (resultIndex < parser.getNumResults()) {
    auto resultName = parser.getResultName(resultIndex++).first;
    if (!resultName.empty() && isdigit(resultName[0]))
      resultName = "";
    names.push_back(parser.getBuilder().getStringAttr(resultName));
  }
  attr = parser.getBuilder().getArrayAttr(names);
  return success();
}
 
ParseResult circt::parseImplicitSSAName(OpAsmParser &parser,
                                        NamedAttrList &attrs) {
  if (parser.parseOptionalAttrDict(attrs))
    return failure();
  inferImplicitSSAName(parser, attrs);
  return success();
}
 
bool circt::inferImplicitSSAName(OpAsmParser &parser, NamedAttrList &attrs) {
  // Don't do anything if a `name` attribute is explicitly provided.
  if (attrs.get("name"))
    return false;
 
  // Infer the name from the SSA name of the operation's first result.
  auto resultName = parser.getResultName(0).first;
  if (!resultName.empty() && isdigit(resultName[0]))
    resultName = "";
  auto nameAttr = parser.getBuilder().getStringAttr(resultName);
  auto *context = parser.getBuilder().getContext();
  attrs.push_back({StringAttr::get(context, "name"), nameAttr});
  return true;
}
 
void circt::printImplicitSSANames(OpAsmPrinter &printer, Operation *op,
                                  ArrayAttr attr) {
  // The names are already printed by the standard SSA result syntax.
}
 
void circt::printImplicitSSAName(OpAsmPrinter &printer, Operation *op,
                                 StringAttr attr) {
  SmallString<32> resultNameStr;
  llvm::raw_svector_ostream tmpStream(resultNameStr);
  printer.printOperand(op->getResult(0), tmpStream);
  auto actualName = tmpStream.str().drop_front();
  // Optional names are printed as digits.
  if (!attr)
    return;
  auto expectedName = attr.getValue();
  // Anonymous names are printed as digits, which is fine.
  if (actualName == expectedName ||
      (expectedName.empty() && isdigit(actualName[0])))
    return;
 
  printer << " name " << attr;
}
 
void circt::printImplicitSSAName(OpAsmPrinter &printer, Operation *op,
                                 DictionaryAttr attrs,
                                 ArrayRef<StringRef> extraElides) {
  SmallVector<StringRef, 2> elides(extraElides.begin(), extraElides.end());
  elideImplicitSSAName(printer, op, attrs, elides);
  printer.printOptionalAttrDict(attrs.getValue(), elides);
}
 
void circt::elideImplicitSSAName(OpAsmPrinter &printer, Operation *op,
                                 DictionaryAttr attrs,
                                 SmallVectorImpl<StringRef> &elides) {
  SmallString<32> resultNameStr;
  llvm::raw_svector_ostream tmpStream(resultNameStr);
  printer.printOperand(op->getResult(0), tmpStream);
  auto actualName = tmpStream.str().drop_front();
  auto expectedName = attrs.getAs<StringAttr>("name").getValue();
  // Anonymous names are printed as digits, which is fine.
  if (actualName == expectedName ||
      (expectedName.empty() && isdigit(actualName[0])))
    elides.push_back("name");
}
 
ParseResult circt::parseOptionalBinaryOpTypes(OpAsmParser &parser, Type &lhs,
                                              Type &rhs) {
  if (parser.parseType(lhs))
    return failure();
 
  // Parse an optional rhs type.
  if (parser.parseOptionalComma()) {
    rhs = lhs;
  } else {
    if (parser.parseType(rhs))
      return failure();
  }
  return success();
}
 
void circt::printOptionalBinaryOpTypes(OpAsmPrinter &p, Operation *op, Type lhs,
                                       Type rhs) {
  p << lhs;
  // If operand types are not same, print a rhs type.
  if (lhs != rhs)
    p << ", " << rhs;
}
 
ParseResult circt::parseKeywordBool(OpAsmParser &parser, BoolAttr &attr,
                                    StringRef trueKeyword,
                                    StringRef falseKeyword) {
  if (succeeded(parser.parseOptionalKeyword(trueKeyword))) {
    attr = BoolAttr::get(parser.getContext(), true);
  } else if (succeeded(parser.parseOptionalKeyword(falseKeyword))) {
    attr = BoolAttr::get(parser.getContext(), false);
  } else {
    return parser.emitError(parser.getCurrentLocation())
           << "expected keyword \"" << trueKeyword << "\" or \"" << falseKeyword
           << "\"";
  }
  return success();
}
 
void circt::printKeywordBool(OpAsmPrinter &printer, Operation *op,
                             BoolAttr attr, StringRef trueKeyword,
                             StringRef falseKeyword) {
  if (attr.getValue())
    printer << trueKeyword;
  else
    printer << falseKeyword;
}
 
ParseResult circt::parseVariadicInvertibleOperands(
    OpAsmParser &parser,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands, Type &resultType,
    mlir::DenseBoolArrayAttr &inverted, NamedAttrList &attrDict) {
  SmallVector<bool> inverts;
 
  while (true) {
    inverts.push_back(succeeded(parser.parseOptionalKeyword("not")));
    operands.push_back(OpAsmParser::UnresolvedOperand());
 
    if (parser.parseOperand(operands.back()))
      return failure();
    if (parser.parseOptionalComma())
      break;
  }
 
  if (parser.parseOptionalAttrDict(attrDict) || parser.parseColon() ||
      parser.parseCustomTypeWithFallback(resultType))
    return failure();
 
  inverted = parser.getBuilder().getDenseBoolArrayAttr(inverts);
  return success();
}
 
void circt::printVariadicInvertibleOperands(OpAsmPrinter &printer,
                                            Operation *op,
                                            OperandRange operands,
                                            Type resultType,
                                            mlir::DenseBoolArrayAttr inverted,
                                            DictionaryAttr attrDict) {
 
  llvm::interleaveComma(llvm::zip(inverted.asArrayRef(), operands), printer,
                        [&](auto &&pair) {
                          auto [invert, input] = pair;
                          if (invert)
                            printer << "not ";
                          printer << input;
                        });
  printer.printOptionalAttrDict(attrDict.getValue(), {"inverted"});
  printer << " : ";
  printer.printType(resultType);
}