97 lines
3.9 KiB
C++
97 lines
3.9 KiB
C++
//===- BytecodeReader.h - MLIR Bytecode Reader ------------------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This header defines interfaces to read MLIR bytecode files/streams.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef MLIR_BYTECODE_BYTECODEREADER_H
|
|
#define MLIR_BYTECODE_BYTECODEREADER_H
|
|
|
|
#include "mlir/IR/AsmState.h"
|
|
#include "mlir/Support/LLVM.h"
|
|
#include <functional>
|
|
#include <memory>
|
|
|
|
namespace llvm {
|
|
class MemoryBufferRef;
|
|
class SourceMgr;
|
|
} // namespace llvm
|
|
|
|
namespace mlir {
|
|
/// The BytecodeReader allows to load MLIR bytecode files, while keeping the
|
|
/// state explicitly available in order to support lazy loading.
|
|
/// The `finalize` method must be called before destruction.
|
|
class BytecodeReader {
|
|
public:
|
|
/// Create a bytecode reader for the given buffer. If `lazyLoad` is true,
|
|
/// isolated regions aren't loaded eagerly.
|
|
explicit BytecodeReader(
|
|
llvm::MemoryBufferRef buffer, const ParserConfig &config, bool lazyLoad,
|
|
const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef = {});
|
|
~BytecodeReader();
|
|
|
|
/// Read the operations defined within the given memory buffer, containing
|
|
/// MLIR bytecode, into the provided block. If the reader was created with
|
|
/// `lazyLoad` enabled, isolated regions aren't loaded eagerly.
|
|
/// The lazyOps call back is invoked for every ops that can be lazy-loaded.
|
|
/// This let the client decide if the op should be materialized
|
|
/// immediately or delayed.
|
|
LogicalResult readTopLevel(
|
|
Block *block, llvm::function_ref<bool(Operation *)> lazyOps =
|
|
[](Operation *) { return false; });
|
|
|
|
/// Return the number of ops that haven't been materialized yet.
|
|
int64_t getNumOpsToMaterialize() const;
|
|
|
|
/// Return true if the provided op is materializable.
|
|
bool isMaterializable(Operation *op);
|
|
|
|
/// Materialize the provide operation. The provided operation must be
|
|
/// materializable.
|
|
/// The lazyOps call back is invoked for every ops that can be lazy-loaded.
|
|
/// This let the client decide if the op should be materialized immediately or
|
|
/// delayed.
|
|
/// !! Using this materialize withing an IR walk() can be confusing: make sure
|
|
/// to use a PreOrder traversal !!
|
|
LogicalResult materialize(
|
|
Operation *op, llvm::function_ref<bool(Operation *)> lazyOpsCallback =
|
|
[](Operation *) { return false; });
|
|
|
|
/// Finalize the lazy-loading by calling back with every op that hasn't been
|
|
/// materialized to let the client decide if the op should be deleted or
|
|
/// materialized. The op is materialized if the callback returns true, deleted
|
|
/// otherwise. The implementation of the callback must be thread-safe.
|
|
LogicalResult finalize(function_ref<bool(Operation *)> shouldMaterialize =
|
|
[](Operation *) { return true; });
|
|
|
|
class Impl;
|
|
|
|
private:
|
|
std::unique_ptr<Impl> impl;
|
|
};
|
|
|
|
/// Returns true if the given buffer starts with the magic bytes that signal
|
|
/// MLIR bytecode.
|
|
bool isBytecode(llvm::MemoryBufferRef buffer);
|
|
|
|
/// Read the operations defined within the given memory buffer, containing MLIR
|
|
/// bytecode, into the provided block.
|
|
LogicalResult readBytecodeFile(llvm::MemoryBufferRef buffer, Block *block,
|
|
const ParserConfig &config);
|
|
/// An overload with a source manager whose main file buffer is used for
|
|
/// parsing. The lifetime of the source manager may be freely extended during
|
|
/// parsing such that the source manager is not destroyed before the parsed IR.
|
|
LogicalResult
|
|
readBytecodeFile(const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
|
|
Block *block, const ParserConfig &config);
|
|
|
|
} // namespace mlir
|
|
|
|
#endif // MLIR_BYTECODE_BYTECODEREADER_H
|