llvm-project/mlir/lib/IR/AsmPrinter.cpp

//===- AsmPrinter.cpp - MLIR Assembly Printer Implementation --------------===//
//
// Copyright 2019 The MLIR Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =============================================================================
//
// This file implements the MLIR AsmPrinter class, which is used to implement
// the various print() methods on the core IR objects.
//
//===----------------------------------------------------------------------===//

#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/CFGFunction.h"
#include "mlir/IR/IntegerSet.h"
#include "mlir/IR/MLFunction.h"
#include "mlir/IR/Module.h"
#include "mlir/IR/OpImplementation.h"
#include "mlir/IR/OperationSet.h"
#include "mlir/IR/StandardOps.h"
#include "mlir/IR/Statements.h"
#include "mlir/IR/StmtVisitor.h"
#include "mlir/IR/Types.h"
#include "mlir/Support/STLExtras.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSet.h"
using namespace mlir;

void Identifier::print(raw_ostream &os) const { os << str(); }

void Identifier::dump() const { print(llvm::errs()); }

OpAsmPrinter::~OpAsmPrinter() {}

//===----------------------------------------------------------------------===//
// ModuleState
//===----------------------------------------------------------------------===//

namespace {
class ModuleState {
public:
  /// This is the operation set for the current context if it is knowable (a
  /// context could be determined), otherwise this is null.
  OperationSet *const operationSet;

  explicit ModuleState(MLIRContext *context)
      : operationSet(context ? &OperationSet::get(context) : nullptr) {}

  // Initializes module state, populating affine map state.
  void initialize(const Module *module);

  int getAffineMapId(AffineMap *affineMap) const {
    auto it = affineMapIds.find(affineMap);
    if (it == affineMapIds.end()) {
      return -1;
    }
    return it->second;
  }

  ArrayRef<AffineMap *> getAffineMapIds() const { return affineMapsById; }

  int getIntegerSetId(IntegerSet *integerSet) const {
    auto it = integerSetIds.find(integerSet);
    if (it == integerSetIds.end()) {
      return -1;
    }
    return it->second;
  }

  ArrayRef<IntegerSet *> getIntegerSetIds() const { return integerSetsById; }

private:
  void recordAffineMapReference(AffineMap *affineMap) {
    if (affineMapIds.count(affineMap) == 0) {
      affineMapIds[affineMap] = affineMapsById.size();
      affineMapsById.push_back(affineMap);
    }
  }

  void recordIntegerSetReference(IntegerSet *integerSet) {
    if (integerSetIds.count(integerSet) == 0) {
      integerSetIds[integerSet] = integerSetsById.size();
      integerSetsById.push_back(integerSet);
    }
  }

  // Return true if this map could be printed using the shorthand form.
  static bool hasShorthandForm(AffineMap *boundMap) {
    if (boundMap->isSingleConstant())
      return true;

    // Check if the affine map is single dim id or single symbol identity -
    // (i)->(i) or ()[s]->(i)
    return boundMap->getNumInputs() == 1 && boundMap->getNumResults() == 1 &&
           (boundMap->getResult(0).isa<AffineDimExprRef>() ||
            boundMap->getResult(0).isa<AffineSymbolExprRef>());
  }

  // Visit functions.
  void visitFunction(const Function *fn);
  void visitExtFunction(const ExtFunction *fn);
  void visitCFGFunction(const CFGFunction *fn);
  void visitMLFunction(const MLFunction *fn);
  void visitStatement(const Statement *stmt);
  void visitForStmt(const ForStmt *forStmt);
  void visitIfStmt(const IfStmt *ifStmt);
  void visitOperationStmt(const OperationStmt *opStmt);
  void visitType(const Type *type);
  void visitAttribute(const Attribute *attr);
  void visitOperation(const Operation *op);

  DenseMap<AffineMap *, int> affineMapIds;
  std::vector<AffineMap *> affineMapsById;

  DenseMap<IntegerSet *, int> integerSetIds;
  std::vector<IntegerSet *> integerSetsById;
};
} // end anonymous namespace

// TODO Support visiting other types/instructions when implemented.
void ModuleState::visitType(const Type *type) {
  if (auto *funcType = dyn_cast<FunctionType>(type)) {
    // Visit input and result types for functions.
    for (auto *input : funcType->getInputs())
      visitType(input);
    for (auto *result : funcType->getResults())
      visitType(result);
  } else if (auto *memref = dyn_cast<MemRefType>(type)) {
    // Visit affine maps in memref type.
    for (auto *map : memref->getAffineMaps()) {
      recordAffineMapReference(map);
    }
  }
}

void ModuleState::visitAttribute(const Attribute *attr) {
  if (auto *mapAttr = dyn_cast<AffineMapAttr>(attr)) {
    recordAffineMapReference(mapAttr->getValue());
  } else if (auto *arrayAttr = dyn_cast<ArrayAttr>(attr)) {
    for (auto elt : arrayAttr->getValue()) {
      visitAttribute(elt);
    }
  }
}

void ModuleState::visitOperation(const Operation *op) {
  // Visit all the types used in the operation.
  for (auto *operand : op->getOperands())
    visitType(operand->getType());
  for (auto *result : op->getResults())
    visitType(result->getType());

  // Visit each of the attributes.
  for (auto elt : op->getAttrs())
    visitAttribute(elt.second);
}

void ModuleState::visitExtFunction(const ExtFunction *fn) {
  visitType(fn->getType());
}

void ModuleState::visitCFGFunction(const CFGFunction *fn) {
  visitType(fn->getType());
  for (auto &block : *fn) {
    for (auto &op : block.getOperations()) {
      visitOperation(&op);
    }
  }
}

void ModuleState::visitIfStmt(const IfStmt *ifStmt) {
  recordIntegerSetReference(ifStmt->getIntegerSet());
  for (auto &childStmt : *ifStmt->getThen())
    visitStatement(&childStmt);
  if (ifStmt->hasElse())
    for (auto &childStmt : *ifStmt->getElse())
      visitStatement(&childStmt);
}

void ModuleState::visitForStmt(const ForStmt *forStmt) {
  AffineMap *lbMap = forStmt->getLowerBoundMap();
  if (!hasShorthandForm(lbMap))
    recordAffineMapReference(lbMap);

  AffineMap *ubMap = forStmt->getUpperBoundMap();
  if (!hasShorthandForm(ubMap))
    recordAffineMapReference(ubMap);

  for (auto &childStmt : *forStmt)
    visitStatement(&childStmt);
}

void ModuleState::visitOperationStmt(const OperationStmt *opStmt) {
  for (auto attr : opStmt->getAttrs())
    visitAttribute(attr.second);
}

void ModuleState::visitStatement(const Statement *stmt) {
  switch (stmt->getKind()) {
  case Statement::Kind::If:
    return visitIfStmt(cast<IfStmt>(stmt));
  case Statement::Kind::For:
    return visitForStmt(cast<ForStmt>(stmt));
  case Statement::Kind::Operation:
    return visitOperationStmt(cast<OperationStmt>(stmt));
  default:
    return;
  }
}

void ModuleState::visitMLFunction(const MLFunction *fn) {
  visitType(fn->getType());
  for (auto &stmt : *fn) {
    ModuleState::visitStatement(&stmt);
  }
}

void ModuleState::visitFunction(const Function *fn) {
  switch (fn->getKind()) {
  case Function::Kind::ExtFunc:
    return visitExtFunction(cast<ExtFunction>(fn));
  case Function::Kind::CFGFunc:
    return visitCFGFunction(cast<CFGFunction>(fn));
  case Function::Kind::MLFunc:
    return visitMLFunction(cast<MLFunction>(fn));
  }
}

// Initializes module state, populating affine map and integer set state.
void ModuleState::initialize(const Module *module) {
  for (auto &fn : *module) {
    visitFunction(&fn);
  }
}

//===----------------------------------------------------------------------===//
// ModulePrinter
//===----------------------------------------------------------------------===//

namespace {
class ModulePrinter {
public:
  ModulePrinter(raw_ostream &os, ModuleState &state) : os(os), state(state) {}
  explicit ModulePrinter(const ModulePrinter &printer)
      : os(printer.os), state(printer.state) {}

  template <typename Container, typename UnaryFunctor>
  inline void interleaveComma(const Container &c, UnaryFunctor each_fn) const {
    interleave(c.begin(), c.end(), each_fn, [&]() { os << ", "; });
  }

  void print(const Module *module);
  void printFunctionReference(const Function *func);
  void printAttribute(const Attribute *attr);
  void printType(const Type *type);
  void print(const Function *fn);
  void print(const ExtFunction *fn);
  void print(const CFGFunction *fn);
  void print(const MLFunction *fn);

  void printAffineMap(AffineMap *map);
  void printAffineExpr(AffineExprRef expr);
  void printAffineConstraint(AffineExprRef expr, bool isEq);
  void printIntegerSet(IntegerSet *set);

protected:
  raw_ostream &os;
  ModuleState &state;

  void printFunctionSignature(const Function *fn);
  void printFunctionAttributes(const Function *fn);
  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                             ArrayRef<const char *> elidedAttrs = {});
  void printFunctionResultType(const FunctionType *type);
  void printAffineMapId(int affineMapId) const;
  void printAffineMapReference(AffineMap *affineMap);
  void printIntegerSetId(int integerSetId) const;
  void printIntegerSetReference(IntegerSet *integerSet);

  /// This enum is used to represent the binding stength of the enclosing
  /// context that an AffineExpr is being printed in, so we can intelligently
  /// produce parens.
  enum class BindingStrength {
    Weak,   // + and -
    Strong, // All other binary operators.
  };
  void printAffineExprInternal(AffineExprRef expr,
                               BindingStrength enclosingTightness);
};
} // end anonymous namespace

// Prints function with initialized module state.
void ModulePrinter::print(const Function *fn) {
  switch (fn->getKind()) {
  case Function::Kind::ExtFunc:
    return print(cast<ExtFunction>(fn));
  case Function::Kind::CFGFunc:
    return print(cast<CFGFunction>(fn));
  case Function::Kind::MLFunc:
    return print(cast<MLFunction>(fn));
  }
}

// Prints affine map identifier.
void ModulePrinter::printAffineMapId(int affineMapId) const {
  os << "#map" << affineMapId;
}

void ModulePrinter::printAffineMapReference(AffineMap *affineMap) {
  int mapId = state.getAffineMapId(affineMap);
  if (mapId >= 0) {
    // Map will be printed at top of module so print reference to its id.
    printAffineMapId(mapId);
  } else {
    // Map not in module state so print inline.
    affineMap->print(os);
  }
}

// Prints integer set identifier.
void ModulePrinter::printIntegerSetId(int integerSetId) const {
  os << "@@set" << integerSetId;
}

void ModulePrinter::printIntegerSetReference(IntegerSet *integerSet) {
  int setId;
  if ((setId = state.getIntegerSetId(integerSet)) >= 0) {
    // The set will be printed at top of module; so print reference to its id.
    printIntegerSetId(setId);
  } else {
    // Set not in module state so print inline.
    integerSet->print(os);
  }
}

void ModulePrinter::print(const Module *module) {
  for (const auto &map : state.getAffineMapIds()) {
    printAffineMapId(state.getAffineMapId(map));
    os << " = ";
    map->print(os);
    os << '\n';
  }
  for (const auto &set : state.getIntegerSetIds()) {
    printIntegerSetId(state.getIntegerSetId(set));
    os << " = ";
    set->print(os);
    os << '\n';
  }
  for (auto const &fn : *module)
    print(&fn);
}

/// Print a floating point value in a way that the parser will be able to
/// round-trip losslessly.
static void printFloatValue(double value, raw_ostream &os) {
  APFloat apValue(value);

  // We would like to output the FP constant value in exponential notation,
  // but we cannot do this if doing so will lose precision.  Check here to
  // make sure that we only output it in exponential format if we can parse
  // the value back and get the same value.
  bool isInf = apValue.isInfinity();
  bool isNaN = apValue.isNaN();
  if (!isInf && !isNaN) {
    SmallString<128> strValue;
    apValue.toString(strValue, 6, 0, false);

    // Check to make sure that the stringized number is not some string like
    // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
    // that the string matches the "[-+]?[0-9]" regex.
    assert(((strValue[0] >= '0' && strValue[0] <= '9') ||
            ((strValue[0] == '-' || strValue[0] == '+') &&
             (strValue[1] >= '0' && strValue[1] <= '9'))) &&
           "[-+]?[0-9] regex does not match!");
    // Reparse stringized version!
    if (APFloat(APFloat::IEEEdouble(), strValue).convertToDouble() == value) {
      os << strValue;
      return;
    }
  }

  // Otherwise, print it in a hexadecimal form.  Convert it to an integer so we
  // can print it out using integer math.
  union {
    double doubleValue;
    uint64_t integerValue;
  };
  doubleValue = value;
  os << "0x";
  // Print out 16 nibbles worth of hex digit.
  for (unsigned i = 0; i != 16; ++i) {
    os << llvm::hexdigit(integerValue >> 60);
    integerValue <<= 4;
  }
}

void ModulePrinter::printFunctionReference(const Function *func) {
  os << '@' << func->getName();
}

void ModulePrinter::printAttribute(const Attribute *attr) {
  switch (attr->getKind()) {
  case Attribute::Kind::Bool:
    os << (cast<BoolAttr>(attr)->getValue() ? "true" : "false");
    break;
  case Attribute::Kind::Integer:
    os << cast<IntegerAttr>(attr)->getValue();
    break;
  case Attribute::Kind::Float:
    printFloatValue(cast<FloatAttr>(attr)->getValue(), os);
    break;
  case Attribute::Kind::String:
    os << '"';
    printEscapedString(cast<StringAttr>(attr)->getValue(), os);
    os << '"';
    break;
  case Attribute::Kind::Array:
    os << '[';
    interleaveComma(cast<ArrayAttr>(attr)->getValue(),
                    [&](Attribute *attr) { printAttribute(attr); });
    os << ']';
    break;
  case Attribute::Kind::AffineMap:
    printAffineMapReference(cast<AffineMapAttr>(attr)->getValue());
    break;
  case Attribute::Kind::Type:
    printType(cast<TypeAttr>(attr)->getValue());
    break;
  case Attribute::Kind::Function: {
    auto *function = cast<FunctionAttr>(attr)->getValue();
    if (!function) {
      os << "<<FUNCTION ATTR FOR DELETED FUNCTION>>";
    } else {
      printFunctionReference(function);
      os << " : ";
      printType(function->getType());
    }
    break;
  }
  }
}

void ModulePrinter::printType(const Type *type) {
  switch (type->getKind()) {
  case Type::Kind::Index:
    os << "index";
    return;
  case Type::Kind::BF16:
    os << "bf16";
    return;
  case Type::Kind::F16:
    os << "f16";
    return;
  case Type::Kind::F32:
    os << "f32";
    return;
  case Type::Kind::F64:
    os << "f64";
    return;
  case Type::Kind::TFControl:
    os << "tf_control";
    return;
  case Type::Kind::TFResource:
    os << "tf_resource";
    return;
  case Type::Kind::TFVariant:
    os << "tf_variant";
    return;
  case Type::Kind::TFComplex64:
    os << "tf_complex64";
    return;
  case Type::Kind::TFComplex128:
    os << "tf_complex128";
    return;
  case Type::Kind::TFF32REF:
    os << "tf_f32ref";
    return;
  case Type::Kind::TFString:
    os << "tf_string";
    return;

  case Type::Kind::Integer: {
    auto *integer = cast<IntegerType>(type);
    os << 'i' << integer->getWidth();
    return;
  }
  case Type::Kind::Function: {
    auto *func = cast<FunctionType>(type);
    os << '(';
    interleaveComma(func->getInputs(), [&](Type *type) { printType(type); });
    os << ") -> ";
    auto results = func->getResults();
    if (results.size() == 1)
      os << *results[0];
    else {
      os << '(';
      interleaveComma(results, [&](Type *type) { printType(type); });
      os << ')';
    }
    return;
  }
  case Type::Kind::Vector: {
    auto *v = cast<VectorType>(type);
    os << "vector<";
    for (auto dim : v->getShape())
      os << dim << 'x';
    os << *v->getElementType() << '>';
    return;
  }
  case Type::Kind::RankedTensor: {
    auto *v = cast<RankedTensorType>(type);
    os << "tensor<";
    for (auto dim : v->getShape()) {
      if (dim < 0)
        os << '?';
      else
        os << dim;
      os << 'x';
    }
    os << *v->getElementType() << '>';
    return;
  }
  case Type::Kind::UnrankedTensor: {
    auto *v = cast<UnrankedTensorType>(type);
    os << "tensor<*x";
    printType(v->getElementType());
    os << '>';
    return;
  }
  case Type::Kind::MemRef: {
    auto *v = cast<MemRefType>(type);
    os << "memref<";
    for (auto dim : v->getShape()) {
      if (dim < 0)
        os << '?';
      else
        os << dim;
      os << 'x';
    }
    printType(v->getElementType());
    for (auto map : v->getAffineMaps()) {
      os << ", ";
      printAffineMapReference(map);
    }
    // Only print the memory space if it is the non-default one.
    if (v->getMemorySpace())
      os << ", " << v->getMemorySpace();
    os << '>';
    return;
  }
  }
}

//===----------------------------------------------------------------------===//
// Affine expressions and maps
//===----------------------------------------------------------------------===//

void ModulePrinter::printAffineExpr(AffineExprRef expr) {
  printAffineExprInternal(expr, BindingStrength::Weak);
}

void ModulePrinter::printAffineExprInternal(
    AffineExprRef expr, BindingStrength enclosingTightness) {
  const char *binopSpelling = nullptr;
  switch (expr->getKind()) {
  case AffineExpr::Kind::SymbolId:
    os << 's' << expr.cast<AffineSymbolExprRef>()->getPosition();
    return;
  case AffineExpr::Kind::DimId:
    os << 'd' << expr.cast<AffineDimExprRef>()->getPosition();
    return;
  case AffineExpr::Kind::Constant:
    os << expr.cast<AffineConstantExprRef>()->getValue();
    return;
  case AffineExpr::Kind::Add:
    binopSpelling = " + ";
    break;
  case AffineExpr::Kind::Mul:
    binopSpelling = " * ";
    break;
  case AffineExpr::Kind::FloorDiv:
    binopSpelling = " floordiv ";
    break;
  case AffineExpr::Kind::CeilDiv:
    binopSpelling = " ceildiv ";
    break;
  case AffineExpr::Kind::Mod:
    binopSpelling = " mod ";
    break;
  }

  auto binOp = expr.cast<AffineBinaryOpExprRef>();

  // Handle tightly binding binary operators.
  if (binOp->getKind() != AffineExpr::Kind::Add) {
    if (enclosingTightness == BindingStrength::Strong)
      os << '(';

    printAffineExprInternal(binOp->getLHS(), BindingStrength::Strong);
    os << binopSpelling;
    printAffineExprInternal(binOp->getRHS(), BindingStrength::Strong);

    if (enclosingTightness == BindingStrength::Strong)
      os << ')';
    return;
  }

  // Print out special "pretty" forms for add.
  if (enclosingTightness == BindingStrength::Strong)
    os << '(';

  // Pretty print addition to a product that has a negative operand as a
  // subtraction.
  AffineExprRef rhsExpr = binOp->getRHS();
  if (auto rhs = rhsExpr.dyn_cast<AffineBinaryOpExprRef>()) {
    if (rhs->getKind() == AffineExpr::Kind::Mul) {
      AffineExprRef rrhsExpr = rhs->getRHS();
      if (auto rrhs = rrhsExpr.dyn_cast<AffineConstantExprRef>()) {
        if (rrhs->getValue() == -1) {
          printAffineExprInternal(binOp->getLHS(), BindingStrength::Weak);
          os << " - ";
          printAffineExprInternal(rhs->getLHS(), BindingStrength::Weak);

          if (enclosingTightness == BindingStrength::Strong)
            os << ')';
          return;
        }

        if (rrhs->getValue() < -1) {
          printAffineExprInternal(binOp->getLHS(), BindingStrength::Weak);
          os << " - ";
          printAffineExprInternal(rhs->getLHS(), BindingStrength::Strong);
          os << " * " << -rrhs->getValue();
          if (enclosingTightness == BindingStrength::Strong)
            os << ')';
          return;
        }
      }
    }
  }

  // Pretty print addition to a negative number as a subtraction.
  if (auto rhs = rhsExpr.dyn_cast<AffineConstantExprRef>()) {
    if (rhs->getValue() < 0) {
      printAffineExprInternal(binOp->getLHS(), BindingStrength::Weak);
      os << " - " << -rhs->getValue();
      if (enclosingTightness == BindingStrength::Strong)
        os << ')';
      return;
    }
  }

  printAffineExprInternal(binOp->getLHS(), BindingStrength::Weak);
  os << " + ";
  printAffineExprInternal(binOp->getRHS(), BindingStrength::Weak);

  if (enclosingTightness == BindingStrength::Strong)
    os << ')';
}

void ModulePrinter::printAffineConstraint(AffineExprRef expr, bool isEq) {
  printAffineExprInternal(expr, BindingStrength::Weak);
  isEq ? os << " == 0" : os << " >= 0";
}

void ModulePrinter::printAffineMap(AffineMap *map) {
  // Dimension identifiers.
  os << '(';
  for (int i = 0; i < (int)map->getNumDims() - 1; ++i)
    os << 'd' << i << ", ";
  if (map->getNumDims() >= 1)
    os << 'd' << map->getNumDims() - 1;
  os << ')';

  // Symbolic identifiers.
  if (map->getNumSymbols() != 0) {
    os << '[';
    for (unsigned i = 0; i < map->getNumSymbols() - 1; ++i)
      os << 's' << i << ", ";
    if (map->getNumSymbols() >= 1)
      os << 's' << map->getNumSymbols() - 1;
    os << ']';
  }

  // AffineMap should have at least one result.
  assert(!map->getResults().empty());
  // Result affine expressions.
  os << " -> (";
  interleaveComma(map->getResults(),
                  [&](AffineExprRef expr) { printAffineExpr(expr); });
  os << ')';

  if (!map->isBounded()) {
    return;
  }

  // Print range sizes for bounded affine maps.
  os << " size (";
  interleaveComma(map->getRangeSizes(),
                  [&](AffineExprRef expr) { printAffineExpr(expr); });
  os << ')';
}

void ModulePrinter::printIntegerSet(IntegerSet *set) {
  // Dimension identifiers.
  os << '(';
  for (unsigned i = 1; i < set->getNumDims(); ++i)
    os << 'd' << i - 1 << ", ";
  if (set->getNumDims() >= 1)
    os << 'd' << set->getNumDims() - 1;
  os << ')';

  // Symbolic identifiers.
  if (set->getNumSymbols() != 0) {
    os << '[';
    for (unsigned i = 0; i < set->getNumSymbols() - 1; ++i)
      os << 's' << i << ", ";
    if (set->getNumSymbols() >= 1)
      os << 's' << set->getNumSymbols() - 1;
    os << ']';
  }

  // Print constraints.
  os << " : (";
  auto numConstraints = set->getNumConstraints();
  for (int i = 1; i < numConstraints; ++i) {
    printAffineConstraint(set->getConstraint(i - 1), set->isEq(i - 1));
    os << ", ";
  }
  if (numConstraints >= 1)
    printAffineConstraint(set->getConstraint(numConstraints - 1),
                          set->isEq(numConstraints - 1));
  os << ')';
}

//===----------------------------------------------------------------------===//
// Function printing
//===----------------------------------------------------------------------===//

void ModulePrinter::printFunctionResultType(const FunctionType *type) {
  switch (type->getResults().size()) {
  case 0:
    break;
  case 1:
    os << " -> ";
    printType(type->getResults()[0]);
    break;
  default:
    os << " -> (";
    interleaveComma(type->getResults(),
                    [&](Type *eltType) { printType(eltType); });
    os << ')';
    break;
  }
}

void ModulePrinter::printFunctionAttributes(const Function *fn) {
  auto attrs = fn->getAttrs();
  if (attrs.empty())
    return;
  os << "\n  attributes ";
  printOptionalAttrDict(attrs);
}

void ModulePrinter::printFunctionSignature(const Function *fn) {
  auto type = fn->getType();

  os << "@" << fn->getName() << '(';
  interleaveComma(type->getInputs(),
                  [&](Type *eltType) { printType(eltType); });
  os << ')';

  printFunctionResultType(type);
}

void ModulePrinter::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                                          ArrayRef<const char *> elidedAttrs) {
  // If there are no attributes, then there is nothing to be done.
  if (attrs.empty())
    return;

  // Filter out any attributes that shouldn't be included.
  SmallVector<NamedAttribute, 8> filteredAttrs;
  for (auto attr : attrs) {
    auto attrName = attr.first.strref();
    // Never print attributes that start with a colon.  These are internal
    // attributes that represent location or other internal metadata.
    if (attrName.startswith(":"))
      return;

    // If the caller has requested that this attribute be ignored, then drop it.
    bool ignore = false;
    for (const char *elide : elidedAttrs)
      ignore |= attrName == StringRef(elide);

    // Otherwise add it to our filteredAttrs list.
    if (!ignore) {
      filteredAttrs.push_back(attr);
    }
  }

  // If there are no attributes left to print after filtering, then we're done.
  if (filteredAttrs.empty())
    return;

  // Otherwise, print them all out in braces.
  os << " {";
  interleaveComma(filteredAttrs, [&](NamedAttribute attr) {
    os << attr.first << ": ";
    printAttribute(attr.second);
  });
  os << '}';
}

void ModulePrinter::print(const ExtFunction *fn) {
  os << "extfunc ";
  printFunctionSignature(fn);
  printFunctionAttributes(fn);
  os << '\n';
}

namespace {

// FunctionPrinter contains common functionality for printing
// CFG and ML functions.
class FunctionPrinter : public ModulePrinter, private OpAsmPrinter {
public:
  FunctionPrinter(const ModulePrinter &other) : ModulePrinter(other) {}

  void printOperation(const Operation *op);
  void printDefaultOp(const Operation *op);

  // Implement OpAsmPrinter.
  raw_ostream &getStream() const { return os; }
  void printType(const Type *type) { ModulePrinter::printType(type); }
  void printAttribute(const Attribute *attr) {
    ModulePrinter::printAttribute(attr);
  }
  void printAffineMap(AffineMap *map) {
    return ModulePrinter::printAffineMapReference(map);
  }
  void printIntegerSet(IntegerSet *set) {
    return ModulePrinter::printIntegerSetReference(set);
  }
  void printAffineExpr(AffineExprRef expr) {
    return ModulePrinter::printAffineExpr(expr);
  }
  void printFunctionReference(const Function *func) {
    return ModulePrinter::printFunctionReference(func);
  }
  void printFunctionAttributes(const Function *func) {
    return ModulePrinter::printFunctionAttributes(func);
  }
  void printOperand(const SSAValue *value) { printValueID(value); }

  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                             ArrayRef<const char *> elidedAttrs = {}) {
    return ModulePrinter::printOptionalAttrDict(attrs, elidedAttrs);
  };

  enum { nameSentinel = ~0U };

protected:
  void numberValueID(const SSAValue *value) {
    assert(!valueIDs.count(value) && "Value numbered multiple times");

    SmallString<32> specialNameBuffer;
    llvm::raw_svector_ostream specialName(specialNameBuffer);

    // Give constant integers special names.
    if (auto *op = value->getDefiningOperation()) {
      if (auto intOp = op->getAs<ConstantIntOp>()) {
        // i1 constants get special names.
        if (intOp->getType()->isInteger(1)) {
          specialName << (intOp->getValue() ? "true" : "false");
        } else {
          specialName << 'c' << intOp->getValue() << '_' << *intOp->getType();
        }
      } else if (auto intOp = op->getAs<ConstantIndexOp>()) {
        specialName << 'c' << intOp->getValue();
      } else if (auto constant = op->getAs<ConstantOp>()) {
        if (isa<FunctionAttr>(constant->getValue()))
          specialName << 'f';
        else
          specialName << "cst";
      }
    }

    if (specialNameBuffer.empty()) {
      switch (value->getKind()) {
      case SSAValueKind::BBArgument:
        // If this is an argument to the function, give it an 'arg' name.
        if (auto *bb = cast<BBArgument>(value)->getOwner())
          if (auto *fn = bb->getFunction())
            if (&fn->front() == bb) {
              specialName << "arg" << nextArgumentID++;
              break;
            }
        // Otherwise number it normally.
        LLVM_FALLTHROUGH;
      case SSAValueKind::InstResult:
      case SSAValueKind::StmtResult:
        // This is an uninteresting result, give it a boring number and be
        // done with it.
        valueIDs[value] = nextValueID++;
        return;
      case SSAValueKind::MLFuncArgument:
        specialName << "arg" << nextArgumentID++;
        break;
      case SSAValueKind::ForStmt:
        specialName << 'i' << nextLoopID++;
        break;
      }
    }

    // Ok, this value had an interesting name.  Remember it with a sentinel.
    valueIDs[value] = nameSentinel;

    // Remember that we've used this name, checking to see if we had a conflict.
    auto insertRes = usedNames.insert(specialName.str());
    if (insertRes.second) {
      // If this is the first use of the name, then we're successful!
      valueNames[value] = insertRes.first->first();
      return;
    }

    // Otherwise, we had a conflict - probe until we find a unique name.  This
    // is guaranteed to terminate (and usually in a single iteration) because it
    // generates new names by incrementing nextConflictID.
    while (1) {
      std::string probeName =
          specialName.str().str() + "_" + llvm::utostr(nextConflictID++);
      insertRes = usedNames.insert(probeName);
      if (insertRes.second) {
        // If this is the first use of the name, then we're successful!
        valueNames[value] = insertRes.first->first();
        return;
      }
    }
  }

  void printValueID(const SSAValue *value, bool printResultNo = true) const {
    int resultNo = -1;
    auto lookupValue = value;

    // If this is a reference to the result of a multi-result instruction or
    // statement, print out the # identifier and make sure to map our lookup
    // to the first result of the instruction.
    if (auto *result = dyn_cast<InstResult>(value)) {
      if (result->getOwner()->getNumResults() != 1) {
        resultNo = result->getResultNumber();
        lookupValue = result->getOwner()->getResult(0);
      }
    } else if (auto *result = dyn_cast<StmtResult>(value)) {
      if (result->getOwner()->getNumResults() != 1) {
        resultNo = result->getResultNumber();
        lookupValue = result->getOwner()->getResult(0);
      }
    }

    auto it = valueIDs.find(lookupValue);
    if (it == valueIDs.end()) {
      os << "<<INVALID SSA VALUE>>";
      return;
    }

    os << '%';
    if (it->second != nameSentinel) {
      os << it->second;
    } else {
      auto nameIt = valueNames.find(lookupValue);
      assert(nameIt != valueNames.end() && "Didn't have a name entry?");
      os << nameIt->second;
    }

    if (resultNo != -1 && printResultNo)
      os << '#' << resultNo;
  }

private:
  /// This is the value ID for each SSA value in the current function.  If this
  /// returns ~0, then the valueID has an entry in valueNames.
  DenseMap<const SSAValue *, unsigned> valueIDs;
  DenseMap<const SSAValue *, StringRef> valueNames;

  /// This keeps track of all of the non-numeric names that are in flight,
  /// allowing us to check for duplicates.
  llvm::StringSet<> usedNames;

  /// This is the next value ID to assign in numbering.
  unsigned nextValueID = 0;
  /// This is the ID to assign to the next induction variable.
  unsigned nextLoopID = 0;
  /// This is the next ID to assign to an MLFunction argument.
  unsigned nextArgumentID = 0;

  /// This is the next ID to assign when a name conflict is detected.
  unsigned nextConflictID = 0;
};
} // end anonymous namespace

void FunctionPrinter::printOperation(const Operation *op) {
  if (op->getNumResults()) {
    printValueID(op->getResult(0), /*printResultNo=*/false);
    os << " = ";
  }

  // Check to see if this is a known operation.  If so, use the registered
  // custom printer hook.
  if (auto *opInfo = state.operationSet->lookup(op->getName())) {
    opInfo->printAssembly(op, this);
    return;
  }

  // Otherwise use the standard verbose printing approach.
  printDefaultOp(op);
}

void FunctionPrinter::printDefaultOp(const Operation *op) {
  os << '"';
  printEscapedString(op->getName(), os);
  os << "\"(";

  interleaveComma(op->getOperands(),
                  [&](const SSAValue *value) { printValueID(value); });

  os << ')';
  auto attrs = op->getAttrs();
  printOptionalAttrDict(attrs);

  // Print the type signature of the operation.
  os << " : (";
  interleaveComma(op->getOperands(),
                  [&](const SSAValue *value) { printType(value->getType()); });
  os << ") -> ";

  if (op->getNumResults() == 1) {
    printType(op->getResult(0)->getType());
  } else {
    os << '(';
    interleaveComma(op->getResults(), [&](const SSAValue *result) {
      printType(result->getType());
    });
    os << ')';
  }
}

//===----------------------------------------------------------------------===//
// CFG Function printing
//===----------------------------------------------------------------------===//

namespace {
class CFGFunctionPrinter : public FunctionPrinter {
public:
  CFGFunctionPrinter(const CFGFunction *function, const ModulePrinter &other);

  const CFGFunction *getFunction() const { return function; }

  void print();
  void print(const BasicBlock *block);

  void print(const Instruction *inst);
  void print(const OperationInst *inst);
  void print(const ReturnInst *inst);
  void print(const BranchInst *inst);
  void print(const CondBranchInst *inst);

  void printBBName(const BasicBlock *block) { os << "bb" << getBBID(block); }

  unsigned getBBID(const BasicBlock *block) {
    auto it = basicBlockIDs.find(block);
    assert(it != basicBlockIDs.end() && "Block not in this function?");
    return it->second;
  }

private:
  const CFGFunction *function;
  DenseMap<const BasicBlock *, unsigned> basicBlockIDs;

  void numberValuesInBlock(const BasicBlock *block);
};
} // end anonymous namespace

CFGFunctionPrinter::CFGFunctionPrinter(const CFGFunction *function,
                                       const ModulePrinter &other)
    : FunctionPrinter(other), function(function) {
  // Each basic block gets a unique ID per function.
  unsigned blockID = 0;
  for (auto &block : *function) {
    basicBlockIDs[&block] = blockID++;
    numberValuesInBlock(&block);
  }
}

/// Number all of the SSA values in the specified basic block.
void CFGFunctionPrinter::numberValuesInBlock(const BasicBlock *block) {
  for (auto *arg : block->getArguments()) {
    numberValueID(arg);
  }
  for (auto &op : *block) {
    // We number instruction that have results, and we only number the first
    // result.
    if (op.getNumResults() != 0)
      numberValueID(op.getResult(0));
  }

  // Terminators do not define values.
}

void CFGFunctionPrinter::print() {
  os << "cfgfunc ";
  printFunctionSignature(getFunction());
  printFunctionAttributes(getFunction());
  os << " {\n";

  for (auto &block : *function)
    print(&block);
  os << "}\n\n";
}

void CFGFunctionPrinter::print(const BasicBlock *block) {
  printBBName(block);

  if (!block->args_empty()) {
    os << '(';
    interleaveComma(block->getArguments(), [&](const BBArgument *arg) {
      printValueID(arg);
      os << ": ";
      printType(arg->getType());
    });
    os << ')';
  }
  os << ':';

  // Print out some context information about the predecessors of this block.
  if (!block->getFunction()) {
    os << "\t// block is not in a function!";
  } else if (block->hasNoPredecessors()) {
    // Don't print "no predecessors" for the entry block.
    if (block != &block->getFunction()->front())
      os << "\t// no predecessors";
  } else if (auto *pred = block->getSinglePredecessor()) {
    os << "\t// pred: ";
    printBBName(pred);
  } else {
    // We want to print the predecessors in increasing numeric order, not in
    // whatever order the use-list is in, so gather and sort them.
    SmallVector<unsigned, 4> predIDs;
    for (auto *pred : block->getPredecessors())
      predIDs.push_back(getBBID(pred));
    llvm::array_pod_sort(predIDs.begin(), predIDs.end());

    os << "\t// " << predIDs.size() << " preds: ";

    interleaveComma(predIDs, [&](unsigned predID) { os << "bb" << predID; });
  }
  os << '\n';

  for (auto &inst : block->getOperations()) {
    os << "  ";
    print(&inst);
    os << '\n';
  }

  os << "  ";
  print(block->getTerminator());
  os << '\n';
}

void CFGFunctionPrinter::print(const Instruction *inst) {
  if (!inst) {
    os << "<<null instruction>>\n";
    return;
  }
  switch (inst->getKind()) {
  case Instruction::Kind::Operation:
    return print(cast<OperationInst>(inst));
  case TerminatorInst::Kind::Branch:
    return print(cast<BranchInst>(inst));
  case TerminatorInst::Kind::CondBranch:
    return print(cast<CondBranchInst>(inst));
  case TerminatorInst::Kind::Return:
    return print(cast<ReturnInst>(inst));
  }
}

void CFGFunctionPrinter::print(const OperationInst *inst) {
  printOperation(inst);
}

void CFGFunctionPrinter::print(const BranchInst *inst) {
  os << "br ";
  printBBName(inst->getDest());

  if (inst->getNumOperands() != 0) {
    os << '(';
    interleaveComma(inst->getOperands(),
                    [&](const CFGValue *operand) { printValueID(operand); });
    os << ") : ";
    interleaveComma(inst->getOperands(), [&](const CFGValue *operand) {
      printType(operand->getType());
    });
  }
}

void CFGFunctionPrinter::print(const CondBranchInst *inst) {
  os << "cond_br ";
  printValueID(inst->getCondition());

  os << ", ";
  printBBName(inst->getTrueDest());
  if (inst->getNumTrueOperands() != 0) {
    os << '(';
    interleaveComma(inst->getTrueOperands(),
                    [&](const CFGValue *operand) { printValueID(operand); });
    os << " : ";
    interleaveComma(inst->getTrueOperands(), [&](const CFGValue *operand) {
      printType(operand->getType());
    });
    os << ")";
  }

  os << ", ";
  printBBName(inst->getFalseDest());
  if (inst->getNumFalseOperands() != 0) {
    os << '(';
    interleaveComma(inst->getFalseOperands(),
                    [&](const CFGValue *operand) { printValueID(operand); });
    os << " : ";
    interleaveComma(inst->getFalseOperands(), [&](const CFGValue *operand) {
      printType(operand->getType());
    });
    os << ")";
  }
}

void CFGFunctionPrinter::print(const ReturnInst *inst) {
  os << "return";

  if (inst->getNumOperands() == 0)
    return;

  os << ' ';
  interleaveComma(inst->getOperands(),
                  [&](const CFGValue *operand) { printValueID(operand); });
  os << " : ";
  interleaveComma(inst->getOperands(), [&](const CFGValue *operand) {
    printType(operand->getType());
  });
}

void ModulePrinter::print(const CFGFunction *fn) {
  CFGFunctionPrinter(fn, *this).print();
}

//===----------------------------------------------------------------------===//
// ML Function printing
//===----------------------------------------------------------------------===//

namespace {
class MLFunctionPrinter : public FunctionPrinter {
public:
  MLFunctionPrinter(const MLFunction *function, const ModulePrinter &other);

  const MLFunction *getFunction() const { return function; }

  // Prints ML function.
  void print();

  // Prints ML function signature.
  void printFunctionSignature();

  // Methods to print ML function statements.
  void print(const Statement *stmt);
  void print(const OperationStmt *stmt);
  void print(const ForStmt *stmt);
  void print(const IfStmt *stmt);
  void print(const StmtBlock *block);

  // Print loop bounds.
  void printDimAndSymbolList(ArrayRef<StmtOperand> ops, unsigned numDims);
  void printBound(AffineBound bound, const char *prefix);

  // Number of spaces used for indenting nested statements.
  const static unsigned indentWidth = 2;

private:
  void numberValues();

  const MLFunction *function;
  int numSpaces;
};
} // end anonymous namespace

MLFunctionPrinter::MLFunctionPrinter(const MLFunction *function,
                                     const ModulePrinter &other)
    : FunctionPrinter(other), function(function), numSpaces(0) {
  assert(function && "Cannot print nullptr function");
  numberValues();
}

/// Number all of the SSA values in this ML function.
void MLFunctionPrinter::numberValues() {
  // Numbers ML function arguments.
  for (auto *arg : function->getArguments())
    numberValueID(arg);

  // Walks ML function statements and numbers for statements and
  // the first result of the operation statements.
  struct NumberValuesPass : public StmtWalker<NumberValuesPass> {
    NumberValuesPass(MLFunctionPrinter *printer) : printer(printer) {}
    void visitOperationStmt(OperationStmt *stmt) {
      if (stmt->getNumResults() != 0)
        printer->numberValueID(stmt->getResult(0));
    }
    void visitForStmt(ForStmt *stmt) { printer->numberValueID(stmt); }
    MLFunctionPrinter *printer;
  };

  NumberValuesPass pass(this);
  // TODO: it'd be cleaner to have constant visitor instead of using const_cast.
  pass.walk(const_cast<MLFunction *>(function));
}

void MLFunctionPrinter::print() {
  os << "mlfunc ";
  printFunctionSignature();
  printFunctionAttributes(getFunction());
  os << " {\n";
  print(function);
  os << "}\n\n";
}

void MLFunctionPrinter::printFunctionSignature() {
  auto type = function->getType();

  os << "@" << function->getName() << '(';

  for (unsigned i = 0, e = function->getNumArguments(); i != e; ++i) {
    if (i > 0)
      os << ", ";
    auto *arg = function->getArgument(i);
    printOperand(arg);
    os << " : ";
    printType(arg->getType());
  }
  os << ")";
  printFunctionResultType(type);
}

void MLFunctionPrinter::print(const StmtBlock *block) {
  numSpaces += indentWidth;
  for (auto &stmt : block->getStatements()) {
    print(&stmt);
    os << "\n";
  }
  numSpaces -= indentWidth;
}

void MLFunctionPrinter::print(const Statement *stmt) {
  switch (stmt->getKind()) {
  case Statement::Kind::Operation:
    return print(cast<OperationStmt>(stmt));
  case Statement::Kind::For:
    return print(cast<ForStmt>(stmt));
  case Statement::Kind::If:
    return print(cast<IfStmt>(stmt));
  }
}

void MLFunctionPrinter::print(const OperationStmt *stmt) {
  os.indent(numSpaces);
  printOperation(stmt);
}

void MLFunctionPrinter::print(const ForStmt *stmt) {
  os.indent(numSpaces) << "for ";
  printOperand(stmt);
  os << " = ";
  printBound(stmt->getLowerBound(), "max");
  os << " to ";
  printBound(stmt->getUpperBound(), "min");

  if (stmt->getStep() != 1)
    os << " step " << stmt->getStep();

  os << " {\n";
  print(static_cast<const StmtBlock *>(stmt));
  os.indent(numSpaces) << "}";
}

void MLFunctionPrinter::printDimAndSymbolList(ArrayRef<StmtOperand> ops,
                                              unsigned numDims) {
  auto printComma = [&]() { os << ", "; };
  os << '(';
  interleave(ops.begin(), ops.begin() + numDims,
             [&](const StmtOperand &v) { printOperand(v.get()); }, printComma);
  os << ')';

  if (numDims < ops.size()) {
    os << '[';
    interleave(ops.begin() + numDims, ops.end(),
               [&](const StmtOperand &v) { printOperand(v.get()); },
               printComma);
    os << ']';
  }
}

void MLFunctionPrinter::printBound(AffineBound bound, const char *prefix) {
  AffineMap *map = bound.getMap();

  // Check if this bound should be printed using short-hand notation.
  // The decision to restrict printing short-hand notation to trivial cases
  // comes from the will to roundtrip MLIR binary -> text -> binary in a
  // lossless way.
  // Therefore, short-hand parsing and printing is only supported for
  // zero-operand constant maps and single symbol operand identity maps.
  if (map->getNumResults() == 1) {
    AffineExprRef expr = map->getResult(0);

    // Print constant bound.
    if (map->getNumDims() == 0 && map->getNumSymbols() == 0) {
      if (auto constExpr = expr.dyn_cast<AffineConstantExprRef>()) {
        os << constExpr->getValue();
        return;
      }
    }

    // Print bound that consists of a single SSA symbol if the map is over a
    // single symbol.
    if (map->getNumDims() == 0 && map->getNumSymbols() == 1) {
      if (auto symExpr = expr.dyn_cast<AffineSymbolExprRef>()) {
        printOperand(bound.getOperand(0));
        return;
      }
    }
  } else {
    // Map has multiple results. Print 'min' or 'max' prefix.
    os << prefix << ' ';
  }

  // Print the map and its operands.
  printAffineMapReference(map);
  printDimAndSymbolList(bound.getStmtOperands(), map->getNumDims());
}

void MLFunctionPrinter::print(const IfStmt *stmt) {
  os.indent(numSpaces) << "if ";
  IntegerSet *set = stmt->getIntegerSet();
  printIntegerSetReference(set);
  printDimAndSymbolList(stmt->getStmtOperands(), set->getNumDims());
  os << " {\n";
  print(stmt->getThen());
  os.indent(numSpaces) << "}";
  if (stmt->hasElse()) {
    os << " else {\n";
    print(stmt->getElse());
    os.indent(numSpaces) << "}";
  }
}

void ModulePrinter::print(const MLFunction *fn) {
  MLFunctionPrinter(fn, *this).print();
}

//===----------------------------------------------------------------------===//
// print and dump methods
//===----------------------------------------------------------------------===//

void Attribute::print(raw_ostream &os) const {
  ModuleState state(/*no context is known*/ nullptr);
  ModulePrinter(os, state).printAttribute(this);
}

void Attribute::dump() const { print(llvm::errs()); }

void Type::print(raw_ostream &os) const {
  ModuleState state(getContext());
  ModulePrinter(os, state).printType(this);
}

void Type::dump() const { print(llvm::errs()); }

void AffineMap::dump() {
  print(llvm::errs());
  llvm::errs() << "\n";
}

void AffineExpr::dump() {
  print(llvm::errs());
  llvm::errs() << "\n";
}

void IntegerSet::dump() {
  print(llvm::errs());
  llvm::errs() << "\n";
}

void AffineExpr::print(raw_ostream &os) {
  ModuleState state(/*no context is known*/ nullptr);
  ModulePrinter(os, state).printAffineExpr(this);
}

void AffineMap::print(raw_ostream &os) {
  ModuleState state(/*no context is known*/ nullptr);
  ModulePrinter(os, state).printAffineMap(this);
}

void IntegerSet::print(raw_ostream &os) {
  ModuleState state(/*no context is known*/ nullptr);
  ModulePrinter(os, state).printIntegerSet(this);
}

void SSAValue::print(raw_ostream &os) const {
  switch (getKind()) {
  case SSAValueKind::BBArgument:
    // TODO: Improve this.
    os << "<bb argument>\n";
    return;
  case SSAValueKind::InstResult:
    return getDefiningInst()->print(os);
  case SSAValueKind::MLFuncArgument:
    // TODO: Improve this.
    os << "<function argument>\n";
    return;
  case SSAValueKind::StmtResult:
    return getDefiningStmt()->print(os);
  case SSAValueKind::ForStmt:
    return cast<ForStmt>(this)->print(os);
  }
}

void SSAValue::dump() const { print(llvm::errs()); }

void Instruction::print(raw_ostream &os) const {
  if (!getFunction()) {
    os << "<<UNLINKED INSTRUCTION>>\n";
    return;
  }
  ModuleState state(getFunction()->getContext());
  ModulePrinter modulePrinter(os, state);
  CFGFunctionPrinter(getFunction(), modulePrinter).print(this);
}

void Instruction::dump() const {
  print(llvm::errs());
  llvm::errs() << "\n";
}

void BasicBlock::print(raw_ostream &os) const {
  if (!getFunction()) {
    os << "<<UNLINKED BLOCK>>\n";
    return;
  }
  ModuleState state(getFunction()->getContext());
  ModulePrinter modulePrinter(os, state);
  CFGFunctionPrinter(getFunction(), modulePrinter).print(this);
}

void BasicBlock::dump() const { print(llvm::errs()); }

/// Print out the name of the basic block without printing its body.
void BasicBlock::printAsOperand(raw_ostream &os, bool printType) {
  if (!getFunction()) {
    os << "<<UNLINKED BLOCK>>\n";
    return;
  }
  ModuleState state(getFunction()->getContext());
  ModulePrinter modulePrinter(os, state);
  CFGFunctionPrinter(getFunction(), modulePrinter).printBBName(this);
}

void Statement::print(raw_ostream &os) const {
  MLFunction *function = findFunction();
  if (!function) {
    os << "<<UNLINKED STATEMENT>>\n";
    return;
  }

  ModuleState state(function->getContext());
  ModulePrinter modulePrinter(os, state);
  MLFunctionPrinter(function, modulePrinter).print(this);
}

void Statement::dump() const { print(llvm::errs()); }

void StmtBlock::printBlock(raw_ostream &os) const {
  MLFunction *function = findFunction();
  ModuleState state(function->getContext());
  ModulePrinter modulePrinter(os, state);
  MLFunctionPrinter(function, modulePrinter).print(this);
}

void StmtBlock::dumpBlock() const { printBlock(llvm::errs()); }

void Function::print(raw_ostream &os) const {
  ModuleState state(getContext());
  ModulePrinter(os, state).print(this);
}

void Function::dump() const { print(llvm::errs()); }

void Module::print(raw_ostream &os) const {
  ModuleState state(getContext());
  state.initialize(this);
  ModulePrinter(os, state).print(this);
}

void Module::dump() const { print(llvm::errs()); }