/build/source/llvm/include/llvm/ADT/Optional.h

Bug Summary

File:	build/source/llvm/include/llvm/ADT/Optional.h
Warning:	line 179, column 13 Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name BytecodeReader.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16 -I tools/mlir/lib/Bytecode/Reader -I /build/source/mlir/lib/Bytecode/Reader -I include -I /build/source/llvm/include -I /build/source/mlir/include -I tools/mlir/include -D MLIR_CUDA_CONVERSIONS_ENABLED=1 -D MLIR_ROCM_CONVERSIONS_ENABLED=1 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1671487667 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-12-20-010714-16201-1 -x c++ /build/source/mlir/lib/Bytecode/Reader/BytecodeReader.cpp

/build/source/mlir/lib/Bytecode/Reader/BytecodeReader.cpp

→

1//===- BytecodeReader.cpp - MLIR Bytecode Reader --------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9// TODO: Support for big-endian architectures.
10// TODO: Properly preserve use lists of values.

12#include "mlir/Bytecode/BytecodeReader.h"
13#include "../Encoding.h"
14#include "mlir/AsmParser/AsmParser.h"
15#include "mlir/Bytecode/BytecodeImplementation.h"
16#include "mlir/IR/BuiltinDialect.h"
17#include "mlir/IR/BuiltinOps.h"
18#include "mlir/IR/OpImplementation.h"
19#include "mlir/IR/Verifier.h"
20#include "llvm/ADT/MapVector.h"
21#include "llvm/ADT/ScopeExit.h"
22#include "llvm/ADT/SmallString.h"
23#include "llvm/ADT/StringExtras.h"
24#include "llvm/Support/MemoryBufferRef.h"
25#include "llvm/Support/SaveAndRestore.h"
26#include "llvm/Support/SourceMgr.h"
27#include <optional>

29#define DEBUG_TYPE"mlir-bytecode-reader" "mlir-bytecode-reader"

31using namespace mlir;

33/// Stringify the given section ID.
34static std::string toString(bytecode::Section::ID sectionID) {
switch (sectionID) {
case bytecode::Section::kString:
  return "String (0)";
case bytecode::Section::kDialect:
  return "Dialect (1)";
case bytecode::Section::kAttrType:
  return "AttrType (2)";
case bytecode::Section::kAttrTypeOffset:
  return "AttrTypeOffset (3)";
case bytecode::Section::kIR:
  return "IR (4)";
case bytecode::Section::kResource:
  return "Resource (5)";
case bytecode::Section::kResourceOffset:
  return "ResourceOffset (6)";
default:
  return ("Unknown (" + Twine(static_cast<unsigned>(sectionID)) + ")").str();
}
53}

55/// Returns true if the given top-level section ID is optional.
56static bool isSectionOptional(bytecode::Section::ID sectionID) {
switch (sectionID) {
case bytecode::Section::kString:
case bytecode::Section::kDialect:
case bytecode::Section::kAttrType:
case bytecode::Section::kAttrTypeOffset:
case bytecode::Section::kIR:
  return false;
case bytecode::Section::kResource:
case bytecode::Section::kResourceOffset:
  return true;
default:
  llvm_unreachable("unknown section ID")::llvm::llvm_unreachable_internal("unknown section ID", "mlir/lib/Bytecode/Reader/BytecodeReader.cpp"
, 68);
}
70}

72//===----------------------------------------------------------------------===//
73// EncodingReader
74//===----------------------------------------------------------------------===//

76namespace {
77class EncodingReader {
78public:
explicit EncodingReader(ArrayRef<uint8_t> contents, Location fileLoc)
    : dataIt(contents.data()), dataEnd(contents.end()), fileLoc(fileLoc) {}
explicit EncodingReader(StringRef contents, Location fileLoc)
    : EncodingReader({reinterpret_cast<const uint8_t *>(contents.data()),
                      contents.size()},
                     fileLoc) {}

/// Returns true if the entire section has been read.
bool empty() const { return dataIt == dataEnd; }

/// Returns the remaining size of the bytecode.
size_t size() const { return dataEnd - dataIt; }

/// Align the current reader position to the specified alignment.
LogicalResult alignTo(unsigned alignment) {
  if (!llvm::isPowerOf2_32(alignment))
    return emitError("expected alignment to be a power-of-two");

  // Shift the reader position to the next alignment boundary.
  while (uintptr_t(dataIt) & (uintptr_t(alignment) - 1)) {
    uint8_t padding;
    if (failed(parseByte(padding)))
      return failure();
    if (padding != bytecode::kAlignmentByte) {
      return emitError("expected alignment byte (0xCB), but got: '0x" +
                       llvm::utohexstr(padding) + "'");
    }
  }

  // Ensure the data iterator is now aligned. This case is unlikely because we
  // *just* went through the effort to align the data iterator.
  if (LLVM_UNLIKELY(!llvm::isAddrAligned(llvm::Align(alignment), dataIt))__builtin_expect((bool)(!llvm::isAddrAligned(llvm::Align(alignment
), dataIt)), false)) {
    return emitError("expected data iterator aligned to ", alignment,
                     ", but got pointer: '0x" +
                         llvm::utohexstr((uintptr_t)dataIt) + "'");
  }

  return success();
}

/// Emit an error using the given arguments.
template <typename... Args>
InFlightDiagnostic emitError(Args &&...args) const {
  return ::emitError(fileLoc).append(std::forward<Args>(args)...);
}
InFlightDiagnostic emitError() const { return ::emitError(fileLoc); }

/// Parse a single byte from the stream.
template <typename T>
LogicalResult parseByte(T &value) {
  if (empty())
    return emitError("attempting to parse a byte at the end of the bytecode");
  value = static_cast<T>(*dataIt++);
  return success();
}
/// Parse a range of bytes of 'length' into the given result.
LogicalResult parseBytes(size_t length, ArrayRef<uint8_t> &result) {
  if (length > size()) {
    return emitError("attempting to parse ", length, " bytes when only ",
                     size(), " remain");
  }
  result = {dataIt, length};
  dataIt += length;
  return success();
}
/// Parse a range of bytes of 'length' into the given result, which can be
/// assumed to be large enough to hold `length`.
LogicalResult parseBytes(size_t length, uint8_t *result) {
  if (length > size()) {
    return emitError("attempting to parse ", length, " bytes when only ",
                     size(), " remain");
  }
  memcpy(result, dataIt, length);
  dataIt += length;
  return success();
}

/// Parse an aligned blob of data, where the alignment was encoded alongside
/// the data.
LogicalResult parseBlobAndAlignment(ArrayRef<uint8_t> &data,
                                    uint64_t &alignment) {
  uint64_t dataSize;
  if (failed(parseVarInt(alignment)) || failed(parseVarInt(dataSize)) ||
      failed(alignTo(alignment)))
    return failure();
  return parseBytes(dataSize, data);
}

/// Parse a variable length encoded integer from the byte stream. The first
/// encoded byte contains a prefix in the low bits indicating the encoded
/// length of the value. This length prefix is a bit sequence of '0's followed
/// by a '1'. The number of '0' bits indicate the number of _additional_ bytes
/// (not including the prefix byte). All remaining bits in the first byte,
/// along with all of the bits in additional bytes, provide the value of the
/// integer encoded in little-endian order.
LogicalResult parseVarInt(uint64_t &result) {
  // Parse the first byte of the encoding, which contains the length prefix.
  if (failed(parseByte(result)))
    return failure();

  // Handle the overwhelmingly common case where the value is stored in a
  // single byte. In this case, the first bit is the `1` marker bit.
  if (LLVM_LIKELY(result & 1)__builtin_expect((bool)(result & 1), true)) {
    result >>= 1;
    return success();
  }

  // Handle the overwhelming uncommon case where the value required all 8
  // bytes (i.e. a really really big number). In this case, the marker byte is
  // all zeros: `00000000`.
  if (LLVM_UNLIKELY(result == 0)__builtin_expect((bool)(result == 0), false))
    return parseBytes(sizeof(result), reinterpret_cast<uint8_t *>(&result));
  return parseMultiByteVarInt(result);
}

/// Parse a signed variable length encoded integer from the byte stream. A
/// signed varint is encoded as a normal varint with zigzag encoding applied,
/// i.e. the low bit of the value is used to indicate the sign.
LogicalResult parseSignedVarInt(uint64_t &result) {
  if (failed(parseVarInt(result)))
    return failure();
  // Essentially (but using unsigned): (x >> 1) ^ -(x & 1)
  result = (result >> 1) ^ (~(result & 1) + 1);
  return success();
}

/// Parse a variable length encoded integer whose low bit is used to encode an
/// unrelated flag, i.e: `(integerValue << 1) | (flag ? 1 : 0)`.
LogicalResult parseVarIntWithFlag(uint64_t &result, bool &flag) {
  if (failed(parseVarInt(result)))
    return failure();
  flag = result & 1;
  result >>= 1;
  return success();
}

/// Skip the first `length` bytes within the reader.
LogicalResult skipBytes(size_t length) {
  if (length > size()) {
    return emitError("attempting to skip ", length, " bytes when only ",
                     size(), " remain");
  }
  dataIt += length;
  return success();
}

/// Parse a null-terminated string into `result` (without including the NUL
/// terminator).
LogicalResult parseNullTerminatedString(StringRef &result) {
  const char *startIt = (const char *)dataIt;
  const char *nulIt = (const char *)memchr(startIt, 0, size());
  if (!nulIt)
    return emitError(
        "malformed null-terminated string, no null character found");

  result = StringRef(startIt, nulIt - startIt);
  dataIt = (const uint8_t *)nulIt + 1;
  return success();
}

/// Parse a section header, placing the kind of section in `sectionID` and the
/// contents of the section in `sectionData`.
LogicalResult parseSection(bytecode::Section::ID &sectionID,
                           ArrayRef<uint8_t> &sectionData) {
  uint8_t sectionIDAndHasAlignment;
  uint64_t length;
  if (failed(parseByte(sectionIDAndHasAlignment)) ||
      failed(parseVarInt(length)))
    return failure();

  // Extract the section ID and whether the section is aligned. The high bit
  // of the ID is the alignment flag.
  sectionID = static_cast<bytecode::Section::ID>(sectionIDAndHasAlignment &
                                                 0b01111111);
  bool hasAlignment = sectionIDAndHasAlignment & 0b10000000;

  // Check that the section is actually valid before trying to process its
  // data.
  if (sectionID >= bytecode::Section::kNumSections)
    return emitError("invalid section ID: ", unsigned(sectionID));

  // Process the section alignment if present.
  if (hasAlignment) {
    uint64_t alignment;
    if (failed(parseVarInt(alignment)) || failed(alignTo(alignment)))
      return failure();
  }

  // Parse the actual section data.
  return parseBytes(static_cast<size_t>(length), sectionData);
}

271private:
/// Parse a variable length encoded integer from the byte stream. This method
/// is a fallback when the number of bytes used to encode the value is greater
/// than 1, but less than the max (9). The provided `result` value can be
/// assumed to already contain the first byte of the value.
/// NOTE: This method is marked noinline to avoid pessimizing the common case
/// of single byte encoding.
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) LogicalResult parseMultiByteVarInt(uint64_t &result) {
  // Count the number of trailing zeros in the marker byte, this indicates the
  // number of trailing bytes that are part of the value. We use `uint32_t`
  // here because we only care about the first byte, and so that be actually
  // get ctz intrinsic calls when possible (the `uint8_t` overload uses a loop
  // implementation).
  uint32_t numBytes =
      llvm::countTrailingZeros<uint32_t>(result, llvm::ZB_Undefined);
  assert(numBytes > 0 && numBytes <= 7 &&(static_cast <bool> (numBytes > 0 && numBytes
 <= 7 && "unexpected number of trailing zeros in varint encoding"
) ? void (0) : __assert_fail ("numBytes > 0 && numBytes <= 7 && \"unexpected number of trailing zeros in varint encoding\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 287, __extension__
 __PRETTY_FUNCTION__))
         "unexpected number of trailing zeros in varint encoding")(static_cast <bool> (numBytes > 0 && numBytes
 <= 7 && "unexpected number of trailing zeros in varint encoding"
) ? void (0) : __assert_fail ("numBytes > 0 && numBytes <= 7 && \"unexpected number of trailing zeros in varint encoding\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 287, __extension__
 __PRETTY_FUNCTION__));

  // Parse in the remaining bytes of the value.
  if (failed(parseBytes(numBytes, reinterpret_cast<uint8_t *>(&result) + 1)))
    return failure();

  // Shift out the low-order bits that were used to mark how the value was
  // encoded.
  result >>= (numBytes + 1);
  return success();
}

/// The current data iterator, and an iterator to the end of the buffer.
const uint8_t *dataIt, *dataEnd;

/// A location for the bytecode used to report errors.
Location fileLoc;
304};
305} // namespace

307/// Resolve an index into the given entry list. `entry` may either be a
308/// reference, in which case it is assigned to the corresponding value in
309/// `entries`, or a pointer, in which case it is assigned to the address of the
310/// element in `entries`.
311template <typename RangeT, typename T>
312static LogicalResult resolveEntry(EncodingReader &reader, RangeT &entries,
                                uint64_t index, T &entry,
                                StringRef entryStr) {
if (index >= entries.size())
  return reader.emitError("invalid ", entryStr, " index: ", index);

// If the provided entry is a pointer, resolve to the address of the entry.
if constexpr (std::is_convertible_v<llvm::detail::ValueOfRange<RangeT>, T>)
  entry = entries[index];
else
  entry = &entries[index];
return success();
324}

326/// Parse and resolve an index into the given entry list.
327template <typename RangeT, typename T>
328static LogicalResult parseEntry(EncodingReader &reader, RangeT &entries,
                              T &entry, StringRef entryStr) {
uint64_t entryIdx;
if (failed(reader.parseVarInt(entryIdx)))
  return failure();
return resolveEntry(reader, entries, entryIdx, entry, entryStr);
334}

336//===----------------------------------------------------------------------===//
337// StringSectionReader
338//===----------------------------------------------------------------------===//

340namespace {
341/// This class is used to read references to the string section from the
342/// bytecode.
343class StringSectionReader {
344public:
/// Initialize the string section reader with the given section data.
LogicalResult initialize(Location fileLoc, ArrayRef<uint8_t> sectionData);

/// Parse a shared string from the string section. The shared string is
/// encoded using an index to a corresponding string in the string section.
LogicalResult parseString(EncodingReader &reader, StringRef &result) {
  return parseEntry(reader, strings, result, "string");
}

354private:
/// The table of strings referenced within the bytecode file.
SmallVector<StringRef> strings;
357};
358} // namespace

360LogicalResult StringSectionReader::initialize(Location fileLoc,
                                            ArrayRef<uint8_t> sectionData) {
EncodingReader stringReader(sectionData, fileLoc);

// Parse the number of strings in the section.
uint64_t numStrings;
if (failed(stringReader.parseVarInt(numStrings)))
  return failure();
strings.resize(numStrings);

// Parse each of the strings. The sizes of the strings are encoded in reverse
// order, so that's the order we populate the table.
size_t stringDataEndOffset = sectionData.size();
for (StringRef &string : llvm::reverse(strings)) {
  uint64_t stringSize;
  if (failed(stringReader.parseVarInt(stringSize)))
    return failure();
  if (stringDataEndOffset < stringSize) {
    return stringReader.emitError(
        "string size exceeds the available data size");
  }

  // Extract the string from the data, dropping the null character.
  size_t stringOffset = stringDataEndOffset - stringSize;
  string = StringRef(
      reinterpret_cast<const char *>(sectionData.data() + stringOffset),
      stringSize - 1);
  stringDataEndOffset = stringOffset;
}

// Check that the only remaining data was for the strings, i.e. the reader
// should be at the same offset as the first string.
if ((sectionData.size() - stringReader.size()) != stringDataEndOffset) {
  return stringReader.emitError("unexpected trailing data between the "
                                "offsets for strings and their data");
}
return success();
397}

399//===----------------------------------------------------------------------===//
400// BytecodeDialect
401//===----------------------------------------------------------------------===//

403namespace {
404/// This struct represents a dialect entry within the bytecode.
405struct BytecodeDialect {
/// Load the dialect into the provided context if it hasn't been loaded yet.
/// Returns failure if the dialect couldn't be loaded *and* the provided
/// context does not allow unregistered dialects. The provided reader is used
/// for error emission if necessary.
LogicalResult load(EncodingReader &reader, MLIRContext *ctx) {
  if (dialect)
    return success();
  Dialect *loadedDialect = ctx->getOrLoadDialect(name);
  if (!loadedDialect && !ctx->allowsUnregisteredDialects()) {
    return reader.emitError(
        "dialect '", name,
        "' is unknown. If this is intended, please call "
        "allowUnregisteredDialects() on the MLIRContext, or use "
        "-allow-unregistered-dialect with the MLIR tool used.");
  }
  dialect = loadedDialect;

  // If the dialect was actually loaded, check to see if it has a bytecode
  // interface.
  if (loadedDialect)
    interface = dyn_cast<BytecodeDialectInterface>(loadedDialect);
  return success();
}

/// Return the loaded dialect, or nullptr if the dialect is unknown. This can
/// only be called after `load`.
Dialect *getLoadedDialect() const {
  assert(dialect &&(static_cast <bool> (dialect && "expected `load` to be invoked before `getLoadedDialect`"
) ? void (0) : __assert_fail ("dialect && \"expected `load` to be invoked before `getLoadedDialect`\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 434, __extension__
 __PRETTY_FUNCTION__))
         "expected `load` to be invoked before `getLoadedDialect`")(static_cast <bool> (dialect && "expected `load` to be invoked before `getLoadedDialect`"
) ? void (0) : __assert_fail ("dialect && \"expected `load` to be invoked before `getLoadedDialect`\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 434, __extension__
 __PRETTY_FUNCTION__));
  return *dialect;
}

/// The loaded dialect entry. This field is std::nullopt if we haven't
/// attempted to load, nullptr if we failed to load, otherwise the loaded
/// dialect.
std::optional<Dialect *> dialect;

/// The bytecode interface of the dialect, or nullptr if the dialect does not
/// implement the bytecode interface. This field should only be checked if the
/// `dialect` field is not std::nullopt.
const BytecodeDialectInterface *interface = nullptr;

/// The name of the dialect.
StringRef name;
450};

452/// This struct represents an operation name entry within the bytecode.
453struct BytecodeOperationName {
BytecodeOperationName(BytecodeDialect *dialect, StringRef name)
    : dialect(dialect), name(name) {}

/// The loaded operation name, or std::nullopt if it hasn't been processed
/// yet.
std::optional<OperationName> opName;

/// The dialect that owns this operation name.
BytecodeDialect *dialect;

/// The name of the operation, without the dialect prefix.
StringRef name;
466};
467} // namespace

469/// Parse a single dialect group encoded in the byte stream.
470static LogicalResult parseDialectGrouping(
  EncodingReader &reader, MutableArrayRef<BytecodeDialect> dialects,
  function_ref<LogicalResult(BytecodeDialect *)> entryCallback) {
// Parse the dialect and the number of entries in the group.
BytecodeDialect *dialect;
if (failed(parseEntry(reader, dialects, dialect, "dialect")))
  return failure();
uint64_t numEntries;
if (failed(reader.parseVarInt(numEntries)))
  return failure();

for (uint64_t i = 0; i < numEntries; ++i)
  if (failed(entryCallback(dialect)))
    return failure();
return success();
485}

487//===----------------------------------------------------------------------===//
488// ResourceSectionReader
489//===----------------------------------------------------------------------===//

491namespace {
492/// This class is used to read the resource section from the bytecode.
493class ResourceSectionReader {
494public:
/// Initialize the resource section reader with the given section data.
LogicalResult
initialize(Location fileLoc, const ParserConfig &config,
           MutableArrayRef<BytecodeDialect> dialects,
           StringSectionReader &stringReader, ArrayRef<uint8_t> sectionData,
           ArrayRef<uint8_t> offsetSectionData,
           const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef);

/// Parse a dialect resource handle from the resource section.
LogicalResult parseResourceHandle(EncodingReader &reader,
                                  AsmDialectResourceHandle &result) {
  return parseEntry(reader, dialectResources, result, "resource handle");
}

509private:
/// The table of dialect resources within the bytecode file.
SmallVector<AsmDialectResourceHandle> dialectResources;
512};

514class ParsedResourceEntry : public AsmParsedResourceEntry {
515public:
ParsedResourceEntry(StringRef key, AsmResourceEntryKind kind,
                    EncodingReader &reader, StringSectionReader &stringReader,
                    const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef)
    : key(key), kind(kind), reader(reader), stringReader(stringReader),
      bufferOwnerRef(bufferOwnerRef) {}
~ParsedResourceEntry() override = default;

StringRef getKey() const final { return key; }

InFlightDiagnostic emitError() const final { return reader.emitError(); }

AsmResourceEntryKind getKind() const final { return kind; }

FailureOr<bool> parseAsBool() const final {
  if (kind != AsmResourceEntryKind::Bool)
1
Assuming field 'kind' is equal to Bool→
2
←
Taking false branch→
    return emitError() << "expected a bool resource entry, but found a "
                       << toString(kind) << " entry instead";

  bool value;
  if (failed(reader.parseByte(value)))
3
←
Taking false branch→
    return failure();
  return value;
4
←
Calling constructor for 'FailureOr<bool>'→
}
FailureOr<std::string> parseAsString() const final {
  if (kind != AsmResourceEntryKind::String)
    return emitError() << "expected a string resource entry, but found a "
                       << toString(kind) << " entry instead";

  StringRef string;
  if (failed(stringReader.parseString(reader, string)))
    return failure();
  return string.str();
}

FailureOr<AsmResourceBlob>
parseAsBlob(BlobAllocatorFn allocator) const final {
  if (kind != AsmResourceEntryKind::Blob)
    return emitError() << "expected a blob resource entry, but found a "
                       << toString(kind) << " entry instead";

  ArrayRef<uint8_t> data;
  uint64_t alignment;
  if (failed(reader.parseBlobAndAlignment(data, alignment)))
    return failure();

  // If we have an extendable reference to the buffer owner, we don't need to
  // allocate a new buffer for the data, and can use the data directly.
  if (bufferOwnerRef) {
    ArrayRef<char> charData(reinterpret_cast<const char *>(data.data()),
                            data.size());

    // Allocate an unmanager buffer which captures a reference to the owner.
    // For now we just mark this as immutable, but in the future we should
    // explore marking this as mutable when desired.
    return UnmanagedAsmResourceBlob::allocateWithAlign(
        charData, alignment,
        [bufferOwnerRef = bufferOwnerRef](void *, size_t, size_t) {});
  }

  // Allocate memory for the blob using the provided allocator and copy the
  // data into it.
  AsmResourceBlob blob = allocator(data.size(), alignment);
  assert(llvm::isAddrAligned(llvm::Align(alignment), blob.getData().data()) &&(static_cast <bool> (llvm::isAddrAligned(llvm::Align(alignment
), blob.getData().data()) && blob.isMutable() &&
 "blob allocator did not return a properly aligned address") ?
 void (0) : __assert_fail ("llvm::isAddrAligned(llvm::Align(alignment), blob.getData().data()) && blob.isMutable() && \"blob allocator did not return a properly aligned address\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 580, __extension__
 __PRETTY_FUNCTION__))
         blob.isMutable() &&(static_cast <bool> (llvm::isAddrAligned(llvm::Align(alignment
), blob.getData().data()) && blob.isMutable() &&
 "blob allocator did not return a properly aligned address") ?
 void (0) : __assert_fail ("llvm::isAddrAligned(llvm::Align(alignment), blob.getData().data()) && blob.isMutable() && \"blob allocator did not return a properly aligned address\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 580, __extension__
 __PRETTY_FUNCTION__))
         "blob allocator did not return a properly aligned address")(static_cast <bool> (llvm::isAddrAligned(llvm::Align(alignment
), blob.getData().data()) && blob.isMutable() &&
 "blob allocator did not return a properly aligned address") ?
 void (0) : __assert_fail ("llvm::isAddrAligned(llvm::Align(alignment), blob.getData().data()) && blob.isMutable() && \"blob allocator did not return a properly aligned address\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 580, __extension__
 __PRETTY_FUNCTION__));
  memcpy(blob.getMutableData().data(), data.data(), data.size());
  return blob;
}

585private:
StringRef key;
AsmResourceEntryKind kind;
EncodingReader &reader;
StringSectionReader &stringReader;
const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef;
591};
592} // namespace

594template <typename T>
595static LogicalResult
596parseResourceGroup(Location fileLoc, bool allowEmpty,
                 EncodingReader &offsetReader, EncodingReader &resourceReader,
                 StringSectionReader &stringReader, T *handler,
                 const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef,
                 function_ref<LogicalResult(StringRef)> processKeyFn = {}) {
uint64_t numResources;
if (failed(offsetReader.parseVarInt(numResources)))
  return failure();

for (uint64_t i = 0; i < numResources; ++i) {
  StringRef key;
  AsmResourceEntryKind kind;
  uint64_t resourceOffset;
  ArrayRef<uint8_t> data;
  if (failed(stringReader.parseString(offsetReader, key)) ||
      failed(offsetReader.parseVarInt(resourceOffset)) ||
      failed(offsetReader.parseByte(kind)) ||
      failed(resourceReader.parseBytes(resourceOffset, data)))
    return failure();

  // Process the resource key.
  if ((processKeyFn && failed(processKeyFn(key))))
    return failure();

  // If the resource data is empty and we allow it, don't error out when
  // parsing below, just skip it.
  if (allowEmpty && data.empty())
    continue;

  // Ignore the entry if we don't have a valid handler.
  if (!handler)
    continue;

  // Otherwise, parse the resource value.
  EncodingReader entryReader(data, fileLoc);
  ParsedResourceEntry entry(key, kind, entryReader, stringReader,
                            bufferOwnerRef);
  if (failed(handler->parseResource(entry)))
    return failure();
  if (!entryReader.empty()) {
    return entryReader.emitError(
        "unexpected trailing bytes in resource entry '", key, "'");
  }
}
return success();
641}

643LogicalResult ResourceSectionReader::initialize(
  Location fileLoc, const ParserConfig &config,
  MutableArrayRef<BytecodeDialect> dialects,
  StringSectionReader &stringReader, ArrayRef<uint8_t> sectionData,
  ArrayRef<uint8_t> offsetSectionData,
  const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef) {
EncodingReader resourceReader(sectionData, fileLoc);
EncodingReader offsetReader(offsetSectionData, fileLoc);

// Read the number of external resource providers.
uint64_t numExternalResourceGroups;
if (failed(offsetReader.parseVarInt(numExternalResourceGroups)))
  return failure();

// Utility functor that dispatches to `parseResourceGroup`, but implicitly
// provides most of the arguments.
auto parseGroup = [&](auto *handler, bool allowEmpty = false,
                      function_ref<LogicalResult(StringRef)> keyFn = {}) {
  return parseResourceGroup(fileLoc, allowEmpty, offsetReader, resourceReader,
                            stringReader, handler, bufferOwnerRef, keyFn);
};

// Read the external resources from the bytecode.
for (uint64_t i = 0; i < numExternalResourceGroups; ++i) {
  StringRef key;
  if (failed(stringReader.parseString(offsetReader, key)))
    return failure();

  // Get the handler for these resources.
  // TODO: Should we require handling external resources in some scenarios?
  AsmResourceParser *handler = config.getResourceParser(key);
  if (!handler) {
    emitWarning(fileLoc) << "ignoring unknown external resources for '" << key
                         << "'";
  }

  if (failed(parseGroup(handler)))
    return failure();
}

// Read the dialect resources from the bytecode.
MLIRContext *ctx = fileLoc->getContext();
while (!offsetReader.empty()) {
  BytecodeDialect *dialect;
  if (failed(parseEntry(offsetReader, dialects, dialect, "dialect")) ||
      failed(dialect->load(resourceReader, ctx)))
    return failure();
  Dialect *loadedDialect = dialect->getLoadedDialect();
  if (!loadedDialect) {
    return resourceReader.emitError()
           << "dialect '" << dialect->name << "' is unknown";
  }
  const auto *handler = dyn_cast<OpAsmDialectInterface>(loadedDialect);
  if (!handler) {
    return resourceReader.emitError()
           << "unexpected resources for dialect '" << dialect->name << "'";
  }

  // Ensure that each resource is declared before being processed.
  auto processResourceKeyFn = [&](StringRef key) -> LogicalResult {
    FailureOr<AsmDialectResourceHandle> handle =
        handler->declareResource(key);
    if (failed(handle)) {
      return resourceReader.emitError()
             << "unknown 'resource' key '" << key << "' for dialect '"
             << dialect->name << "'";
    }
    dialectResources.push_back(*handle);
    return success();
  };

  // Parse the resources for this dialect. We allow empty resources because we
  // just treat these as declarations.
  if (failed(parseGroup(handler, /*allowEmpty=*/true, processResourceKeyFn)))
    return failure();
}

return success();
721}

723//===----------------------------------------------------------------------===//
724// Attribute/Type Reader
725//===----------------------------------------------------------------------===//

727namespace {
728/// This class provides support for reading attribute and type entries from the
729/// bytecode. Attribute and Type entries are read lazily on demand, so we use
730/// this reader to manage when to actually parse them from the bytecode.
731class AttrTypeReader {
/// This class represents a single attribute or type entry.
template <typename T>
struct Entry {
  /// The entry, or null if it hasn't been resolved yet.
  T entry = {};
  /// The parent dialect of this entry.
  BytecodeDialect *dialect = nullptr;
  /// A flag indicating if the entry was encoded using a custom encoding,
  /// instead of using the textual assembly format.
  bool hasCustomEncoding = false;
  /// The raw data of this entry in the bytecode.
  ArrayRef<uint8_t> data;
};
using AttrEntry = Entry<Attribute>;
using TypeEntry = Entry<Type>;

748public:
AttrTypeReader(StringSectionReader &stringReader,
               ResourceSectionReader &resourceReader, Location fileLoc)
    : stringReader(stringReader), resourceReader(resourceReader),
      fileLoc(fileLoc) {}

/// Initialize the attribute and type information within the reader.
LogicalResult initialize(MutableArrayRef<BytecodeDialect> dialects,
                         ArrayRef<uint8_t> sectionData,
                         ArrayRef<uint8_t> offsetSectionData);

/// Resolve the attribute or type at the given index. Returns nullptr on
/// failure.
Attribute resolveAttribute(size_t index) {
  return resolveEntry(attributes, index, "Attribute");
}
Type resolveType(size_t index) { return resolveEntry(types, index, "Type"); }

/// Parse a reference to an attribute or type using the given reader.
LogicalResult parseAttribute(EncodingReader &reader, Attribute &result) {
  uint64_t attrIdx;
  if (failed(reader.parseVarInt(attrIdx)))
    return failure();
  result = resolveAttribute(attrIdx);
  return success(!!result);
}
LogicalResult parseType(EncodingReader &reader, Type &result) {
  uint64_t typeIdx;
  if (failed(reader.parseVarInt(typeIdx)))
    return failure();
  result = resolveType(typeIdx);
  return success(!!result);
}

template <typename T>
LogicalResult parseAttribute(EncodingReader &reader, T &result) {
  Attribute baseResult;
  if (failed(parseAttribute(reader, baseResult)))
    return failure();
  if ((result = baseResult.dyn_cast<T>()))
    return success();
  return reader.emitError("expected attribute of type: ",
                          llvm::getTypeName<T>(), ", but got: ", baseResult);
}

793private:
/// Resolve the given entry at `index`.
template <typename T>
T resolveEntry(SmallVectorImpl<Entry<T>> &entries, size_t index,
               StringRef entryType);

/// Parse an entry using the given reader that was encoded using the textual
/// assembly format.
template <typename T>
LogicalResult parseAsmEntry(T &result, EncodingReader &reader,
                            StringRef entryType);

/// Parse an entry using the given reader that was encoded using a custom
/// bytecode format.
template <typename T>
LogicalResult parseCustomEntry(Entry<T> &entry, EncodingReader &reader,
                               StringRef entryType);

/// The string section reader used to resolve string references when parsing
/// custom encoded attribute/type entries.
StringSectionReader &stringReader;

/// The resource section reader used to resolve resource references when
/// parsing custom encoded attribute/type entries.
ResourceSectionReader &resourceReader;

/// The set of attribute and type entries.
SmallVector<AttrEntry> attributes;
SmallVector<TypeEntry> types;

/// A location used for error emission.
Location fileLoc;
825};

827class DialectReader : public DialectBytecodeReader {
828public:
DialectReader(AttrTypeReader &attrTypeReader,
              StringSectionReader &stringReader,
              ResourceSectionReader &resourceReader, EncodingReader &reader)
    : attrTypeReader(attrTypeReader), stringReader(stringReader),
      resourceReader(resourceReader), reader(reader) {}

InFlightDiagnostic emitError(const Twine &msg) override {
  return reader.emitError(msg);
}

//===--------------------------------------------------------------------===//
// IR
//===--------------------------------------------------------------------===//

LogicalResult readAttribute(Attribute &result) override {
  return attrTypeReader.parseAttribute(reader, result);
}

LogicalResult readType(Type &result) override {
  return attrTypeReader.parseType(reader, result);
}

FailureOr<AsmDialectResourceHandle> readResourceHandle() override {
  AsmDialectResourceHandle handle;
  if (failed(resourceReader.parseResourceHandle(reader, handle)))
    return failure();
  return handle;
}

//===--------------------------------------------------------------------===//
// Primitives
//===--------------------------------------------------------------------===//

LogicalResult readVarInt(uint64_t &result) override {
  return reader.parseVarInt(result);
}

LogicalResult readSignedVarInt(int64_t &result) override {
  uint64_t unsignedResult;
  if (failed(reader.parseSignedVarInt(unsignedResult)))
    return failure();
  result = static_cast<int64_t>(unsignedResult);
  return success();
}

FailureOr<APInt> readAPIntWithKnownWidth(unsigned bitWidth) override {
  // Small values are encoded using a single byte.
  if (bitWidth <= 8) {
    uint8_t value;
    if (failed(reader.parseByte(value)))
      return failure();
    return APInt(bitWidth, value);
  }

  // Large values up to 64 bits are encoded using a single varint.
  if (bitWidth <= 64) {
    uint64_t value;
    if (failed(reader.parseSignedVarInt(value)))
      return failure();
    return APInt(bitWidth, value);
  }

  // Otherwise, for really big values we encode the array of active words in
  // the value.
  uint64_t numActiveWords;
  if (failed(reader.parseVarInt(numActiveWords)))
    return failure();
  SmallVector<uint64_t, 4> words(numActiveWords);
  for (uint64_t i = 0; i < numActiveWords; ++i)
    if (failed(reader.parseSignedVarInt(words[i])))
      return failure();
  return APInt(bitWidth, words);
}

FailureOr<APFloat>
readAPFloatWithKnownSemantics(const llvm::fltSemantics &semantics) override {
  FailureOr<APInt> intVal =
      readAPIntWithKnownWidth(APFloat::getSizeInBits(semantics));
  if (failed(intVal))
    return failure();
  return APFloat(semantics, *intVal);
}

LogicalResult readString(StringRef &result) override {
  return stringReader.parseString(reader, result);
}

LogicalResult readBlob(ArrayRef<char> &result) override {
  uint64_t dataSize;
  ArrayRef<uint8_t> data;
  if (failed(reader.parseVarInt(dataSize)) ||
      failed(reader.parseBytes(dataSize, data)))
    return failure();
  result = llvm::makeArrayRef(reinterpret_cast<const char *>(data.data()),
                              data.size());
  return success();
}

927private:
AttrTypeReader &attrTypeReader;
StringSectionReader &stringReader;
ResourceSectionReader &resourceReader;
EncodingReader &reader;
932};
933} // namespace

935LogicalResult
936AttrTypeReader::initialize(MutableArrayRef<BytecodeDialect> dialects,
                         ArrayRef<uint8_t> sectionData,
                         ArrayRef<uint8_t> offsetSectionData) {
EncodingReader offsetReader(offsetSectionData, fileLoc);

// Parse the number of attribute and type entries.
uint64_t numAttributes, numTypes;
if (failed(offsetReader.parseVarInt(numAttributes)) ||
    failed(offsetReader.parseVarInt(numTypes)))
  return failure();
attributes.resize(numAttributes);
types.resize(numTypes);

// A functor used to accumulate the offsets for the entries in the given
// range.
uint64_t currentOffset = 0;
auto parseEntries = [&](auto &&range) {
  size_t currentIndex = 0, endIndex = range.size();

  // Parse an individual entry.
  auto parseEntryFn = [&](BytecodeDialect *dialect) -> LogicalResult {
    auto &entry = range[currentIndex++];

    uint64_t entrySize;
    if (failed(offsetReader.parseVarIntWithFlag(entrySize,
                                                entry.hasCustomEncoding)))
      return failure();

    // Verify that the offset is actually valid.
    if (currentOffset + entrySize > sectionData.size()) {
      return offsetReader.emitError(
          "Attribute or Type entry offset points past the end of section");
    }

    entry.data = sectionData.slice(currentOffset, entrySize);
    entry.dialect = dialect;
    currentOffset += entrySize;
    return success();
  };
  while (currentIndex != endIndex)
    if (failed(parseDialectGrouping(offsetReader, dialects, parseEntryFn)))
      return failure();
  return success();
};

// Process each of the attributes, and then the types.
if (failed(parseEntries(attributes)) || failed(parseEntries(types)))
  return failure();

// Ensure that we read everything from the section.
if (!offsetReader.empty()) {
  return offsetReader.emitError(
      "unexpected trailing data in the Attribute/Type offset section");
}
return success();
991}

993template <typename T>
994T AttrTypeReader::resolveEntry(SmallVectorImpl<Entry<T>> &entries, size_t index,
                             StringRef entryType) {
if (index >= entries.size()) {
  emitError(fileLoc) << "invalid " << entryType << " index: " << index;
  return {};
}

// If the entry has already been resolved, there is nothing left to do.
Entry<T> &entry = entries[index];
if (entry.entry)
  return entry.entry;

// Parse the entry.
EncodingReader reader(entry.data, fileLoc);

// Parse based on how the entry was encoded.
if (entry.hasCustomEncoding) {
  if (failed(parseCustomEntry(entry, reader, entryType)))
    return T();
} else if (failed(parseAsmEntry(entry.entry, reader, entryType))) {
  return T();
}

if (!reader.empty()) {
  reader.emitError("unexpected trailing bytes after " + entryType + " entry");
  return T();
}
return entry.entry;
1022}

1024template <typename T>
1025LogicalResult AttrTypeReader::parseAsmEntry(T &result, EncodingReader &reader,
                                          StringRef entryType) {
StringRef asmStr;
if (failed(reader.parseNullTerminatedString(asmStr)))
  return failure();

// Invoke the MLIR assembly parser to parse the entry text.
size_t numRead = 0;
MLIRContext *context = fileLoc->getContext();
if constexpr (std::is_same_v<T, Type>)
  result = ::parseType(asmStr, context, numRead);
else
  result = ::parseAttribute(asmStr, context, numRead);
if (!result)
  return failure();

// Ensure there weren't dangling characters after the entry.
if (numRead != asmStr.size()) {
  return reader.emitError("trailing characters found after ", entryType,
                          " assembly format: ", asmStr.drop_front(numRead));
}
return success();
1047}

1049template <typename T>
1050LogicalResult AttrTypeReader::parseCustomEntry(Entry<T> &entry,
                                             EncodingReader &reader,
                                             StringRef entryType) {
if (failed(entry.dialect->load(reader, fileLoc.getContext())))
  return failure();

// Ensure that the dialect implements the bytecode interface.
if (!entry.dialect->interface) {
  return reader.emitError("dialect '", entry.dialect->name,
                          "' does not implement the bytecode interface");
}

// Ask the dialect to parse the entry.
DialectReader dialectReader(*this, stringReader, resourceReader, reader);
if constexpr (std::is_same_v<T, Type>)
  entry.entry = entry.dialect->interface->readType(dialectReader);
else
  entry.entry = entry.dialect->interface->readAttribute(dialectReader);
return success(!!entry.entry);
1069}

1071//===----------------------------------------------------------------------===//
1072// Bytecode Reader
1073//===----------------------------------------------------------------------===//

1075namespace {
1076/// This class is used to read a bytecode buffer and translate it into MLIR.
1077class BytecodeReader {
1078public:
BytecodeReader(Location fileLoc, const ParserConfig &config,
               const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef)
    : config(config), fileLoc(fileLoc),
      attrTypeReader(stringReader, resourceReader, fileLoc),
      // Use the builtin unrealized conversion cast operation to represent
      // forward references to values that aren't yet defined.
      forwardRefOpState(UnknownLoc::get(config.getContext()),
                        "builtin.unrealized_conversion_cast", ValueRange(),
                        NoneType::get(config.getContext())),
      bufferOwnerRef(bufferOwnerRef) {}

/// Read the bytecode defined within `buffer` into the given block.
LogicalResult read(llvm::MemoryBufferRef buffer, Block *block);

1093private:
/// Return the context for this config.
MLIRContext *getContext() const { return config.getContext(); }

/// Parse the bytecode version.
LogicalResult parseVersion(EncodingReader &reader);

//===--------------------------------------------------------------------===//
// Dialect Section

LogicalResult parseDialectSection(ArrayRef<uint8_t> sectionData);

/// Parse an operation name reference using the given reader.
FailureOr<OperationName> parseOpName(EncodingReader &reader);

//===--------------------------------------------------------------------===//
// Attribute/Type Section

/// Parse an attribute or type using the given reader.
template <typename T>
LogicalResult parseAttribute(EncodingReader &reader, T &result) {
  return attrTypeReader.parseAttribute(reader, result);
}
LogicalResult parseType(EncodingReader &reader, Type &result) {
  return attrTypeReader.parseType(reader, result);
}

//===--------------------------------------------------------------------===//
// Resource Section

LogicalResult
parseResourceSection(Optional<ArrayRef<uint8_t>> resourceData,
                     Optional<ArrayRef<uint8_t>> resourceOffsetData);

//===--------------------------------------------------------------------===//
// IR Section

/// This struct represents the current read state of a range of regions. This
/// struct is used to enable iterative parsing of regions.
struct RegionReadState {
  RegionReadState(Operation *op, bool isIsolatedFromAbove)
      : RegionReadState(op->getRegions(), isIsolatedFromAbove) {}
  RegionReadState(MutableArrayRef<Region> regions, bool isIsolatedFromAbove)
      : curRegion(regions.begin()), endRegion(regions.end()),
        isIsolatedFromAbove(isIsolatedFromAbove) {}

  /// The current regions being read.
  MutableArrayRef<Region>::iterator curRegion, endRegion;

  /// The number of values defined immediately within this region.
  unsigned numValues = 0;

  /// The current blocks of the region being read.
  SmallVector<Block *> curBlocks;
  Region::iterator curBlock = {};

  /// The number of operations remaining to be read from the current block
  /// being read.
  uint64_t numOpsRemaining = 0;

  /// A flag indicating if the regions being read are isolated from above.
  bool isIsolatedFromAbove = false;
};

LogicalResult parseIRSection(ArrayRef<uint8_t> sectionData, Block *block);
LogicalResult parseRegions(EncodingReader &reader,
                           std::vector<RegionReadState> &regionStack,
                           RegionReadState &readState);
FailureOr<Operation *> parseOpWithoutRegions(EncodingReader &reader,
                                             RegionReadState &readState,
                                             bool &isIsolatedFromAbove);

LogicalResult parseRegion(EncodingReader &reader, RegionReadState &readState);
LogicalResult parseBlock(EncodingReader &reader, RegionReadState &readState);
LogicalResult parseBlockArguments(EncodingReader &reader, Block *block);

//===--------------------------------------------------------------------===//
// Value Processing

/// Parse an operand reference using the given reader. Returns nullptr in the
/// case of failure.
Value parseOperand(EncodingReader &reader);

/// Sequentially define the given value range.
LogicalResult defineValues(EncodingReader &reader, ValueRange values);

/// Create a value to use for a forward reference.
Value createForwardRef();

//===--------------------------------------------------------------------===//
// Fields

/// This class represents a single value scope, in which a value scope is
/// delimited by isolated from above regions.
struct ValueScope {
  /// Push a new region state onto this scope, reserving enough values for
  /// those defined within the current region of the provided state.
  void push(RegionReadState &readState) {
    nextValueIDs.push_back(values.size());
    values.resize(values.size() + readState.numValues);
  }

  /// Pop the values defined for the current region within the provided region
  /// state.
  void pop(RegionReadState &readState) {
    values.resize(values.size() - readState.numValues);
    nextValueIDs.pop_back();
  }

  /// The set of values defined in this scope.
  std::vector<Value> values;

  /// The ID for the next defined value for each region current being
  /// processed in this scope.
  SmallVector<unsigned, 4> nextValueIDs;
};

/// The configuration of the parser.
const ParserConfig &config;

/// A location to use when emitting errors.
Location fileLoc;

/// The reader used to process attribute and types within the bytecode.
AttrTypeReader attrTypeReader;

/// The version of the bytecode being read.
uint64_t version = 0;

/// The producer of the bytecode being read.
StringRef producer;

/// The table of IR units referenced within the bytecode file.
SmallVector<BytecodeDialect> dialects;
SmallVector<BytecodeOperationName> opNames;

/// The reader used to process resources within the bytecode.
ResourceSectionReader resourceReader;

/// The table of strings referenced within the bytecode file.
StringSectionReader stringReader;

/// The current set of available IR value scopes.
std::vector<ValueScope> valueScopes;
/// A block containing the set of operations defined to create forward
/// references.
Block forwardRefOps;
/// A block containing previously created, and no longer used, forward
/// reference operations.
Block openForwardRefOps;
/// An operation state used when instantiating forward references.
OperationState forwardRefOpState;

/// The optional owning source manager, which when present may be used to
/// extend the lifetime of the input buffer.
const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef;
1249};
1250} // namespace

1252LogicalResult BytecodeReader::read(llvm::MemoryBufferRef buffer, Block *block) {
EncodingReader reader(buffer.getBuffer(), fileLoc);

// Skip over the bytecode header, this should have already been checked.
if (failed(reader.skipBytes(StringRef("ML\xefR").size())))
  return failure();
// Parse the bytecode version and producer.
if (failed(parseVersion(reader)) ||
    failed(reader.parseNullTerminatedString(producer)))
  return failure();

// Add a diagnostic handler that attaches a note that includes the original
// producer of the bytecode.
ScopedDiagnosticHandler diagHandler(getContext(), [&](Diagnostic &diag) {
  diag.attachNote() << "in bytecode version " << version
                    << " produced by: " << producer;
  return failure();
});

// Parse the raw data for each of the top-level sections of the bytecode.
Optional<ArrayRef<uint8_t>> sectionDatas[bytecode::Section::kNumSections];
while (!reader.empty()) {
  // Read the next section from the bytecode.
  bytecode::Section::ID sectionID;
  ArrayRef<uint8_t> sectionData;
  if (failed(reader.parseSection(sectionID, sectionData)))
    return failure();

  // Check for duplicate sections, we only expect one instance of each.
  if (sectionDatas[sectionID]) {
    return reader.emitError("duplicate top-level section: ",
                            toString(sectionID));
  }
  sectionDatas[sectionID] = sectionData;
}
// Check that all of the required sections were found.
for (int i = 0; i < bytecode::Section::kNumSections; ++i) {
  bytecode::Section::ID sectionID = static_cast<bytecode::Section::ID>(i);
  if (!sectionDatas[i] && !isSectionOptional(sectionID)) {
    return reader.emitError("missing data for top-level section: ",
                            toString(sectionID));
  }
}

// Process the string section first.
if (failed(stringReader.initialize(
        fileLoc, *sectionDatas[bytecode::Section::kString])))
  return failure();

// Process the dialect section.
if (failed(parseDialectSection(*sectionDatas[bytecode::Section::kDialect])))
  return failure();

// Process the resource section if present.
if (failed(parseResourceSection(
        sectionDatas[bytecode::Section::kResource],
        sectionDatas[bytecode::Section::kResourceOffset])))
  return failure();

// Process the attribute and type section.
if (failed(attrTypeReader.initialize(
        dialects, *sectionDatas[bytecode::Section::kAttrType],
        *sectionDatas[bytecode::Section::kAttrTypeOffset])))
  return failure();

// Finally, process the IR section.
return parseIRSection(*sectionDatas[bytecode::Section::kIR], block);
1319}

1321LogicalResult BytecodeReader::parseVersion(EncodingReader &reader) {
if (failed(reader.parseVarInt(version)))
  return failure();

// Validate the bytecode version.
uint64_t currentVersion = bytecode::kVersion;
if (version < currentVersion) {
  return reader.emitError("bytecode version ", version,
                          " is older than the current version of ",
                          currentVersion, ", and upgrade is not supported");
}
if (version > currentVersion) {
  return reader.emitError("bytecode version ", version,
                          " is newer than the current version ",
                          currentVersion);
}
return success();
1338}

1340//===----------------------------------------------------------------------===//
1341// Dialect Section

1343LogicalResult
1344BytecodeReader::parseDialectSection(ArrayRef<uint8_t> sectionData) {
EncodingReader sectionReader(sectionData, fileLoc);

// Parse the number of dialects in the section.
uint64_t numDialects;
if (failed(sectionReader.parseVarInt(numDialects)))
  return failure();
dialects.resize(numDialects);

// Parse each of the dialects.
for (uint64_t i = 0; i < numDialects; ++i)
  if (failed(stringReader.parseString(sectionReader, dialects[i].name)))
    return failure();

// Parse the operation names, which are grouped by dialect.
auto parseOpName = [&](BytecodeDialect *dialect) {
  StringRef opName;
  if (failed(stringReader.parseString(sectionReader, opName)))
    return failure();
  opNames.emplace_back(dialect, opName);
  return success();
};
while (!sectionReader.empty())
  if (failed(parseDialectGrouping(sectionReader, dialects, parseOpName)))
    return failure();
return success();
1370}

1372FailureOr<OperationName> BytecodeReader::parseOpName(EncodingReader &reader) {
BytecodeOperationName *opName = nullptr;
if (failed(parseEntry(reader, opNames, opName, "operation name")))
  return failure();

// Check to see if this operation name has already been resolved. If we
// haven't, load the dialect and build the operation name.
if (!opName->opName) {
  if (failed(opName->dialect->load(reader, getContext())))
    return failure();
  opName->opName.emplace((opName->dialect->name + "." + opName->name).str(),
                         getContext());
}
return *opName->opName;
1386}

1388//===----------------------------------------------------------------------===//
1389// Resource Section

1391LogicalResult BytecodeReader::parseResourceSection(
  Optional<ArrayRef<uint8_t>> resourceData,
  Optional<ArrayRef<uint8_t>> resourceOffsetData) {
// Ensure both sections are either present or not.
if (resourceData.has_value() != resourceOffsetData.has_value()) {
  if (resourceOffsetData)
    return emitError(fileLoc, "unexpected resource offset section when "
                              "resource section is not present");
  return emitError(
      fileLoc,
      "expected resource offset section when resource section is present");
}

// If the resource sections are absent, there is nothing to do.
if (!resourceData)
  return success();

// Initialize the resource reader with the resource sections.
return resourceReader.initialize(fileLoc, config, dialects, stringReader,
                                 *resourceData, *resourceOffsetData,
                                 bufferOwnerRef);
1412}

1414//===----------------------------------------------------------------------===//
1415// IR Section

1417LogicalResult BytecodeReader::parseIRSection(ArrayRef<uint8_t> sectionData,
                                           Block *block) {
EncodingReader reader(sectionData, fileLoc);

// A stack of operation regions currently being read from the bytecode.
std::vector<RegionReadState> regionStack;

// Parse the top-level block using a temporary module operation.
OwningOpRef<ModuleOp> moduleOp = ModuleOp::create(fileLoc);
regionStack.emplace_back(*moduleOp, /*isIsolatedFromAbove=*/true);
regionStack.back().curBlocks.push_back(moduleOp->getBody());
regionStack.back().curBlock = regionStack.back().curRegion->begin();
if (failed(parseBlock(reader, regionStack.back())))
  return failure();
valueScopes.emplace_back();
valueScopes.back().push(regionStack.back());

// Iteratively parse regions until everything has been resolved.
while (!regionStack.empty())
  if (failed(parseRegions(reader, regionStack, regionStack.back())))
    return failure();
if (!forwardRefOps.empty()) {
  return reader.emitError(
      "not all forward unresolved forward operand references");
}

// Verify that the parsed operations are valid.
if (config.shouldVerifyAfterParse() && failed(verify(*moduleOp)))
  return failure();

// Splice the parsed operations over to the provided top-level block.
auto &parsedOps = moduleOp->getBody()->getOperations();
auto &destOps = block->getOperations();
destOps.splice(destOps.end(), parsedOps, parsedOps.begin(), parsedOps.end());
return success();
1452}

1454LogicalResult
1455BytecodeReader::parseRegions(EncodingReader &reader,
                           std::vector<RegionReadState> &regionStack,
                           RegionReadState &readState) {
// Read the regions of this operation.
for (; readState.curRegion != readState.endRegion; ++readState.curRegion) {
  // If the current block hasn't been setup yet, parse the header for this
  // region.
  if (readState.curBlock == Region::iterator()) {
    if (failed(parseRegion(reader, readState)))
      return failure();

    // If the region is empty, there is nothing to more to do.
    if (readState.curRegion->empty())
      continue;
  }

  // Parse the blocks within the region.
  do {
    while (readState.numOpsRemaining--) {
      // Read in the next operation. We don't read its regions directly, we
      // handle those afterwards as necessary.
      bool isIsolatedFromAbove = false;
      FailureOr<Operation *> op =
          parseOpWithoutRegions(reader, readState, isIsolatedFromAbove);
      if (failed(op))
        return failure();

      // If the op has regions, add it to the stack for processing.
      if ((*op)->getNumRegions()) {
        regionStack.emplace_back(*op, isIsolatedFromAbove);

        // If the op is isolated from above, push a new value scope.
        if (isIsolatedFromAbove)
          valueScopes.emplace_back();
        return success();
      }
    }

    // Move to the next block of the region.
    if (++readState.curBlock == readState.curRegion->end())
      break;
    if (failed(parseBlock(reader, readState)))
      return failure();
  } while (true);

  // Reset the current block and any values reserved for this region.
  readState.curBlock = {};
  valueScopes.back().pop(readState);
}

// When the regions have been fully parsed, pop them off of the read stack. If
// the regions were isolated from above, we also pop the last value scope.
if (readState.isIsolatedFromAbove)
  valueScopes.pop_back();
regionStack.pop_back();
return success();
1511}

1513FailureOr<Operation *>
1514BytecodeReader::parseOpWithoutRegions(EncodingReader &reader,
                                    RegionReadState &readState,
                                    bool &isIsolatedFromAbove) {
// Parse the name of the operation.
FailureOr<OperationName> opName = parseOpName(reader);
if (failed(opName))
  return failure();

// Parse the operation mask, which indicates which components of the operation
// are present.
uint8_t opMask;
if (failed(reader.parseByte(opMask)))
  return failure();

/// Parse the location.
LocationAttr opLoc;
if (failed(parseAttribute(reader, opLoc)))
  return failure();

// With the location and name resolved, we can start building the operation
// state.
OperationState opState(opLoc, *opName);

// Parse the attributes of the operation.
if (opMask & bytecode::OpEncodingMask::kHasAttrs) {
  DictionaryAttr dictAttr;
  if (failed(parseAttribute(reader, dictAttr)))
    return failure();
  opState.attributes = dictAttr;
}

/// Parse the results of the operation.
if (opMask & bytecode::OpEncodingMask::kHasResults) {
  uint64_t numResults;
  if (failed(reader.parseVarInt(numResults)))
    return failure();
  opState.types.resize(numResults);
  for (int i = 0, e = numResults; i < e; ++i)
    if (failed(parseType(reader, opState.types[i])))
      return failure();
}

/// Parse the operands of the operation.
if (opMask & bytecode::OpEncodingMask::kHasOperands) {
  uint64_t numOperands;
  if (failed(reader.parseVarInt(numOperands)))
    return failure();
  opState.operands.resize(numOperands);
  for (int i = 0, e = numOperands; i < e; ++i)
    if (!(opState.operands[i] = parseOperand(reader)))
      return failure();
}

/// Parse the successors of the operation.
if (opMask & bytecode::OpEncodingMask::kHasSuccessors) {
  uint64_t numSuccs;
  if (failed(reader.parseVarInt(numSuccs)))
    return failure();
  opState.successors.resize(numSuccs);
  for (int i = 0, e = numSuccs; i < e; ++i) {
    if (failed(parseEntry(reader, readState.curBlocks, opState.successors[i],
                          "successor")))
      return failure();
  }
}

/// Parse the regions of the operation.
if (opMask & bytecode::OpEncodingMask::kHasInlineRegions) {
  uint64_t numRegions;
  if (failed(reader.parseVarIntWithFlag(numRegions, isIsolatedFromAbove)))
    return failure();

  opState.regions.reserve(numRegions);
  for (int i = 0, e = numRegions; i < e; ++i)
    opState.regions.push_back(std::make_unique<Region>());
}

// Create the operation at the back of the current block.
Operation *op = Operation::create(opState);
readState.curBlock->push_back(op);

// If the operation had results, update the value references.
if (op->getNumResults() && failed(defineValues(reader, op->getResults())))
  return failure();

return op;
1600}

1602LogicalResult BytecodeReader::parseRegion(EncodingReader &reader,
                                        RegionReadState &readState) {
// Parse the number of blocks in the region.
uint64_t numBlocks;
if (failed(reader.parseVarInt(numBlocks)))
  return failure();

// If the region is empty, there is nothing else to do.
if (numBlocks == 0)
  return success();

// Parse the number of values defined in this region.
uint64_t numValues;
if (failed(reader.parseVarInt(numValues)))
  return failure();
readState.numValues = numValues;

// Create the blocks within this region. We do this before processing so that
// we can rely on the blocks existing when creating operations.
readState.curBlocks.clear();
readState.curBlocks.reserve(numBlocks);
for (uint64_t i = 0; i < numBlocks; ++i) {
  readState.curBlocks.push_back(new Block());
  readState.curRegion->push_back(readState.curBlocks.back());
}

// Prepare the current value scope for this region.
valueScopes.back().push(readState);

// Parse the entry block of the region.
readState.curBlock = readState.curRegion->begin();
return parseBlock(reader, readState);
1634}

1636LogicalResult BytecodeReader::parseBlock(EncodingReader &reader,
                                       RegionReadState &readState) {
bool hasArgs;
if (failed(reader.parseVarIntWithFlag(readState.numOpsRemaining, hasArgs)))
  return failure();

// Parse the arguments of the block.
if (hasArgs && failed(parseBlockArguments(reader, &*readState.curBlock)))
  return failure();

// We don't parse the operations of the block here, that's done elsewhere.
return success();
1648}

1650LogicalResult BytecodeReader::parseBlockArguments(EncodingReader &reader,
                                                Block *block) {
// Parse the value ID for the first argument, and the number of arguments.
uint64_t numArgs;
if (failed(reader.parseVarInt(numArgs)))
  return failure();

SmallVector<Type> argTypes;
SmallVector<Location> argLocs;
argTypes.reserve(numArgs);
argLocs.reserve(numArgs);

while (numArgs--) {
  Type argType;
  LocationAttr argLoc;
  if (failed(parseType(reader, argType)) ||
      failed(parseAttribute(reader, argLoc)))
    return failure();

  argTypes.push_back(argType);
  argLocs.push_back(argLoc);
}
block->addArguments(argTypes, argLocs);
return defineValues(reader, block->getArguments());
1674}

1676//===----------------------------------------------------------------------===//
1677// Value Processing

1679Value BytecodeReader::parseOperand(EncodingReader &reader) {
std::vector<Value> &values = valueScopes.back().values;
Value *value = nullptr;
if (failed(parseEntry(reader, values, value, "value")))
  return Value();

// Create a new forward reference if necessary.
if (!*value)
  *value = createForwardRef();
return *value;
1689}

1691LogicalResult BytecodeReader::defineValues(EncodingReader &reader,
                                         ValueRange newValues) {
ValueScope &valueScope = valueScopes.back();
std::vector<Value> &values = valueScope.values;

unsigned &valueID = valueScope.nextValueIDs.back();
unsigned valueIDEnd = valueID + newValues.size();
if (valueIDEnd > values.size()) {
  return reader.emitError(
      "value index range was outside of the expected range for "
      "the parent region, got [",
      valueID, ", ", valueIDEnd, "), but the maximum index was ",
      values.size() - 1);
}

// Assign the values and update any forward references.
for (unsigned i = 0, e = newValues.size(); i != e; ++i, ++valueID) {
  Value newValue = newValues[i];

  // Check to see if a definition for this value already exists.
  if (Value oldValue = std::exchange(values[valueID], newValue)) {
    Operation *forwardRefOp = oldValue.getDefiningOp();

    // Assert that this is a forward reference operation. Given how we compute
    // definition ids (incrementally as we parse), it shouldn't be possible
    // for the value to be defined any other way.
    assert(forwardRefOp && forwardRefOp->getBlock() == &forwardRefOps &&(static_cast <bool> (forwardRefOp && forwardRefOp
->getBlock() == &forwardRefOps && "value index was already defined?"
) ? void (0) : __assert_fail ("forwardRefOp && forwardRefOp->getBlock() == &forwardRefOps && \"value index was already defined?\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 1718, __extension__
 __PRETTY_FUNCTION__))
           "value index was already defined?")(static_cast <bool> (forwardRefOp && forwardRefOp
->getBlock() == &forwardRefOps && "value index was already defined?"
) ? void (0) : __assert_fail ("forwardRefOp && forwardRefOp->getBlock() == &forwardRefOps && \"value index was already defined?\""
, "mlir/lib/Bytecode/Reader/BytecodeReader.cpp", 1718, __extension__
 __PRETTY_FUNCTION__));

    oldValue.replaceAllUsesWith(newValue);
    forwardRefOp->moveBefore(&openForwardRefOps, openForwardRefOps.end());
  }
}
return success();
1725}

1727Value BytecodeReader::createForwardRef() {
// Check for an avaliable existing operation to use. Otherwise, create a new
// fake operation to use for the reference.
if (!openForwardRefOps.empty()) {
  Operation *op = &openForwardRefOps.back();
  op->moveBefore(&forwardRefOps, forwardRefOps.end());
} else {
  forwardRefOps.push_back(Operation::create(forwardRefOpState));
}
return forwardRefOps.back().getResult(0);
1737}

1739//===----------------------------------------------------------------------===//
1740// Entry Points
1741//===----------------------------------------------------------------------===//

1743bool mlir::isBytecode(llvm::MemoryBufferRef buffer) {
return buffer.getBuffer().startswith("ML\xefR");
1745}

1747/// Read the bytecode from the provided memory buffer reference.
1748/// `bufferOwnerRef` if provided is the owning source manager for the buffer,
1749/// and may be used to extend the lifetime of the buffer.
1750static LogicalResult
1751readBytecodeFileImpl(llvm::MemoryBufferRef buffer, Block *block,
                   const ParserConfig &config,
                   const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef) {
Location sourceFileLoc =
    FileLineColLoc::get(config.getContext(), buffer.getBufferIdentifier(),
                        /*line=*/0, /*column=*/0);
if (!isBytecode(buffer)) {
  return emitError(sourceFileLoc,
                   "input buffer is not an MLIR bytecode file");
}

BytecodeReader reader(sourceFileLoc, config, bufferOwnerRef);
return reader.read(buffer, block);
1764}

1766LogicalResult mlir::readBytecodeFile(llvm::MemoryBufferRef buffer, Block *block,
                                   const ParserConfig &config) {
return readBytecodeFileImpl(buffer, block, config, /*bufferOwnerRef=*/{});
1769}
1770LogicalResult
1771mlir::readBytecodeFile(const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
                     Block *block, const ParserConfig &config) {
return readBytecodeFileImpl(
    *sourceMgr->getMemoryBuffer(sourceMgr->getMainFileID()), block, config,
    sourceMgr);
1776}

←

/build/source/mlir/include/mlir/Support/LogicalResult.h

→

1//===- LogicalResult.h - Utilities for handling success/failure -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8 
9#ifndef MLIR_SUPPORT_LOGICALRESULT_H
10#define MLIR_SUPPORT_LOGICALRESULT_H
11 
12#include "mlir/Support/LLVM.h"
13#include "llvm/ADT/Optional.h"
14 
15namespace mlir {
16 
17/// This class represents an efficient way to signal success or failure. It
18/// should be preferred over the use of `bool` when appropriate, as it avoids
19/// all of the ambiguity that arises in interpreting a boolean result. This
20/// class is marked as NODISCARD to ensure that the result is processed. Users
21/// may explicitly discard a result by using `(void)`, e.g.
22/// `(void)functionThatReturnsALogicalResult();`. Given the intended nature of
23/// this class, it generally shouldn't be used as the result of functions that
24/// very frequently have the result ignored. This class is intended to be used
25/// in conjunction with the utility functions below.
26struct [[nodiscard]] LogicalResult {
27public:
28  /// If isSuccess is true a `success` result is generated, otherwise a
29  /// 'failure' result is generated.
30  static LogicalResult success(bool isSuccess = true) {
31    return LogicalResult(isSuccess);
32  }
33 
34  /// If isFailure is true a `failure` result is generated, otherwise a
35  /// 'success' result is generated.
36  static LogicalResult failure(bool isFailure = true) {
37    return LogicalResult(!isFailure);
38  }
39 
40  /// Returns true if the provided LogicalResult corresponds to a success value.
41  bool succeeded() const { return isSuccess; }
42 
43  /// Returns true if the provided LogicalResult corresponds to a failure value.
44  bool failed() const { return !isSuccess; }
45 
46private:
47  LogicalResult(bool isSuccess) : isSuccess(isSuccess) {}
48 
49  /// Boolean indicating if this is a success result, if false this is a
50  /// failure result.
51  bool isSuccess;
52};
53 
54/// Utility function to generate a LogicalResult. If isSuccess is true a
55/// `success` result is generated, otherwise a 'failure' result is generated.
56inline LogicalResult success(bool isSuccess = true) {
57  return LogicalResult::success(isSuccess);
58}
59 
60/// Utility function to generate a LogicalResult. If isFailure is true a
61/// `failure` result is generated, otherwise a 'success' result is generated.
62inline LogicalResult failure(bool isFailure = true) {
63  return LogicalResult::failure(isFailure);
64}
65 
66/// Utility function that returns true if the provided LogicalResult corresponds
67/// to a success value.
68inline bool succeeded(LogicalResult result) { return result.succeeded(); }
69 
70/// Utility function that returns true if the provided LogicalResult corresponds
71/// to a failure value.
72inline bool failed(LogicalResult result) { return result.failed(); }
73 
74/// This class provides support for representing a failure result, or a valid
75/// value of type `T`. This allows for integrating with LogicalResult, while
76/// also providing a value on the success path.
77template <typename T>
78class [[nodiscard]] FailureOr : public Optional<T> {
79public:
80  /// Allow constructing from a LogicalResult. The result *must* be a failure.
81  /// Success results should use a proper instance of type `T`.
82  FailureOr(LogicalResult result) {
83    assert(failed(result) &&(static_cast <bool> (failed(result) && "success should be constructed with an instance of 'T'"
) ? void (0) : __assert_fail ("failed(result) && \"success should be constructed with an instance of 'T'\""
, "mlir/include/mlir/Support/LogicalResult.h", 84, __extension__
 __PRETTY_FUNCTION__))
84           "success should be constructed with an instance of 'T'")(static_cast <bool> (failed(result) && "success should be constructed with an instance of 'T'"
) ? void (0) : __assert_fail ("failed(result) && \"success should be constructed with an instance of 'T'\""
, "mlir/include/mlir/Support/LogicalResult.h", 84, __extension__
 __PRETTY_FUNCTION__));
85  }
86  FailureOr() : FailureOr(failure()) {}
87  FailureOr(T &&y) : Optional<T>(std::forward<T>(y)) {}
5
←
Calling constructor for 'Optional<bool>'→
88  FailureOr(const T &y) : Optional<T>(y) {}
89  template <typename U,
90            std::enable_if_t<std::is_constructible<T, U>::value> * = nullptr>
91  FailureOr(const FailureOr<U> &other)
92      : Optional<T>(failed(other) ? Optional<T>() : Optional<T>(*other)) {}
93 
94  operator LogicalResult() const { return success(this->has_value()); }
95 
96private:
97  /// Hide the bool conversion as it easily creates confusion.
98  using Optional<T>::operator bool;
99  using Optional<T>::has_value;
100};
101 
102/// Wrap a value on the success path in a FailureOr of the same value type.
103template <typename T,
104          typename = std::enable_if_t<!std::is_convertible_v<T, bool>>>
105inline auto success(T &&t) {
106  return FailureOr<std::decay_t<T>>(std::forward<T>(t));
107}
108 
109/// This class represents success/failure for parsing-like operations that find
110/// it important to chain together failable operations with `||`.  This is an
111/// extended version of `LogicalResult` that allows for explicit conversion to
112/// bool.
113///
114/// This class should not be used for general error handling cases - we prefer
115/// to keep the logic explicit with the `succeeded`/`failed` predicates.
116/// However, traditional monadic-style parsing logic can sometimes get
117/// swallowed up in boilerplate without this, so we provide this for narrow
118/// cases where it is important.
119///
120class [[nodiscard]] ParseResult : public LogicalResult {
121public:
122  ParseResult(LogicalResult result = success()) : LogicalResult(result) {}
123 
124  /// Failure is true in a boolean context.
125  explicit operator bool() const { return failed(); }
126};
127 
128} // namespace mlir
129 
130#endif // MLIR_SUPPORT_LOGICALRESULT_H

←

/build/source/llvm/include/llvm/ADT/Optional.h

1//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10///  This file provides Optional, a template class modeled in the spirit of
11///  OCaml's 'opt' variant.  The idea is to strongly type whether or not
12///  a value can be optional.
13///
14//===----------------------------------------------------------------------===//
15 
16#ifndef LLVM_ADT_OPTIONAL_H
17#define LLVM_ADT_OPTIONAL_H
18 
19#include "llvm/ADT/Hashing.h"
20#include "llvm/Support/Compiler.h"
21#include "llvm/Support/type_traits.h"
22#include <cassert>
23#include <new>
24#include <utility>
25 
26namespace llvm {
27 
28namespace optional_detail {
29 
30/// Storage for any type.
31//
32// The specialization condition intentionally uses
33// llvm::is_trivially_{copy/move}_constructible instead of
34// std::is_trivially_{copy/move}_constructible. GCC versions prior to 7.4 may
35// instantiate the copy/move constructor of `T` when
36// std::is_trivially_{copy/move}_constructible is instantiated.  This causes
37// compilation to fail if we query the trivially copy/move constructible
38// property of a class which is not copy/move constructible.
39//
40// The current implementation of OptionalStorage insists that in order to use
41// the trivial specialization, the value_type must be trivially copy
42// constructible and trivially copy assignable due to =default implementations
43// of the copy/move constructor/assignment.  It does not follow that this is
44// necessarily the case std::is_trivially_copyable is true (hence the expanded
45// specialization condition).
46//
47// The move constructible / assignable conditions emulate the remaining behavior
48// of std::is_trivially_copyable.
49template <typename T,
50          bool = (llvm::is_trivially_copy_constructible<T>::value &&
51                  std::is_trivially_copy_assignable<T>::value &&
52                  (llvm::is_trivially_move_constructible<T>::value ||
53                   !std::is_move_constructible<T>::value) &&
54                  (std::is_trivially_move_assignable<T>::value ||
55                   !std::is_move_assignable<T>::value))>
56class OptionalStorage {
57  union {
58    char empty;
59    T val;
60  };
61  bool hasVal = false;
62 
63public:
64  ~OptionalStorage() { reset(); }
65 
66  constexpr OptionalStorage() noexcept : empty() {}
67 
68  constexpr OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
69    if (other.has_value()) {
70      emplace(other.val);
71    }
72  }
73  constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
74    if (other.has_value()) {
75      emplace(std::move(other.val));
76    }
77  }
78 
79  template <class... Args>
80  constexpr explicit OptionalStorage(std::in_place_t, Args &&...args)
81      : val(std::forward<Args>(args)...), hasVal(true) {}
82 
83  void reset() noexcept {
84    if (hasVal) {
85      val.~T();
86      hasVal = false;
87    }
88  }
89 
90  constexpr bool has_value() const noexcept { return hasVal; }
91 
92  T &value() &noexcept {
93    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 93, __extension__
 __PRETTY_FUNCTION__));
94    return val;
95  }
96  constexpr T const &value() const &noexcept {
97    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 97, __extension__
 __PRETTY_FUNCTION__));
98    return val;
99  }
100  T &&value() &&noexcept {
101    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 101, __extension__
 __PRETTY_FUNCTION__));
102    return std::move(val);
103  }
104 
105  template <class... Args> void emplace(Args &&...args) {
106    reset();
107    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
108    hasVal = true;
109  }
110 
111  OptionalStorage &operator=(T const &y) {
112    if (has_value()) {
113      val = y;
114    } else {
115      ::new ((void *)std::addressof(val)) T(y);
116      hasVal = true;
117    }
118    return *this;
119  }
120  OptionalStorage &operator=(T &&y) {
121    if (has_value()) {
122      val = std::move(y);
123    } else {
124      ::new ((void *)std::addressof(val)) T(std::move(y));
125      hasVal = true;
126    }
127    return *this;
128  }
129 
130  OptionalStorage &operator=(OptionalStorage const &other) {
131    if (other.has_value()) {
132      if (has_value()) {
133        val = other.val;
134      } else {
135        ::new ((void *)std::addressof(val)) T(other.val);
136        hasVal = true;
137      }
138    } else {
139      reset();
140    }
141    return *this;
142  }
143 
144  OptionalStorage &operator=(OptionalStorage &&other) {
145    if (other.has_value()) {
146      if (has_value()) {
147        val = std::move(other.val);
148      } else {
149        ::new ((void *)std::addressof(val)) T(std::move(other.val));
150        hasVal = true;
151      }
152    } else {
153      reset();
154    }
155    return *this;
156  }
157};
158 
159template <typename T> class OptionalStorage<T, true> {
160  union {
161    char empty;
162    T val;
163  };
164  bool hasVal = false;
165 
166public:
167  ~OptionalStorage() = default;
168 
169  constexpr OptionalStorage() noexcept : empty{} {}
170 
171  constexpr OptionalStorage(OptionalStorage const &other) = default;
172  constexpr OptionalStorage(OptionalStorage &&other) = default;
173 
174  OptionalStorage &operator=(OptionalStorage const &other) = default;
175  OptionalStorage &operator=(OptionalStorage &&other) = default;
176 
177  template <class... Args>
178  constexpr explicit OptionalStorage(std::in_place_t, Args &&...args)
179      : val(std::forward<Args>(args)...), hasVal(true) {}
7
←
Assigned value is garbage or undefined
180 
181  void reset() noexcept {
182    if (hasVal) {
183      val.~T();
184      hasVal = false;
185    }
186  }
187 
188  constexpr bool has_value() const noexcept { return hasVal; }
189 
190  T &value() &noexcept {
191    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 191, __extension__
 __PRETTY_FUNCTION__));
192    return val;
193  }
194  constexpr T const &value() const &noexcept {
195    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 195, __extension__
 __PRETTY_FUNCTION__));
196    return val;
197  }
198  T &&value() &&noexcept {
199    assert(hasVal)(static_cast <bool> (hasVal) ? void (0) : __assert_fail
 ("hasVal", "llvm/include/llvm/ADT/Optional.h", 199, __extension__
 __PRETTY_FUNCTION__));
200    return std::move(val);
201  }
202 
203  template <class... Args> void emplace(Args &&...args) {
204    reset();
205    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
206    hasVal = true;
207  }
208 
209  OptionalStorage &operator=(T const &y) {
210    if (has_value()) {
211      val = y;
212    } else {
213      ::new ((void *)std::addressof(val)) T(y);
214      hasVal = true;
215    }
216    return *this;
217  }
218  OptionalStorage &operator=(T &&y) {
219    if (has_value()) {
220      val = std::move(y);
221    } else {
222      ::new ((void *)std::addressof(val)) T(std::move(y));
223      hasVal = true;
224    }
225    return *this;
226  }
227};
228 
229} // namespace optional_detail
230 
231template <typename T> class Optional {
232  optional_detail::OptionalStorage<T> Storage;
233 
234public:
235  using value_type = T;
236 
237  constexpr Optional() = default;
238  constexpr Optional(std::nullopt_t) {}
239 
240  constexpr Optional(const T &y) : Storage(std::in_place, y) {}
241  constexpr Optional(const Optional &O) = default;
242 
243  constexpr Optional(T &&y) : Storage(std::in_place, std::move(y)) {}
6
←
Calling constructor for 'OptionalStorage<bool, true>'→
244  constexpr Optional(Optional &&O) = default;
245 
246  template <typename... ArgTypes>
247  constexpr Optional(std::in_place_t, ArgTypes &&...Args)
248      : Storage(std::in_place, std::forward<ArgTypes>(Args)...) {}
249 
250  Optional &operator=(T &&y) {
251    Storage = std::move(y);
252    return *this;
253  }
254  Optional &operator=(Optional &&O) = default;
255 
256  /// Create a new object by constructing it in place with the given arguments.
257  template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
258    Storage.emplace(std::forward<ArgTypes>(Args)...);
259  }
260 
261  Optional &operator=(const T &y) {
262    Storage = y;
263    return *this;
264  }
265  Optional &operator=(const Optional &O) = default;
266 
267  void reset() { Storage.reset(); }
268 
269  LLVM_DEPRECATED("Use &*X instead.", "&*X")__attribute__((deprecated("Use &*X instead.", "&*X"))
)
270  constexpr const T *getPointer() const { return &Storage.value(); }
271  LLVM_DEPRECATED("Use &*X instead.", "&*X")__attribute__((deprecated("Use &*X instead.", "&*X"))
)
272  T *getPointer() { return &Storage.value(); }
273  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")__attribute__((deprecated("std::optional::value is throwing. Use *X instead"
, "*X")))
274  constexpr const T &value() const & { return Storage.value(); }
275  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")__attribute__((deprecated("std::optional::value is throwing. Use *X instead"
, "*X")))
276  T &value() & { return Storage.value(); }
277 
278  constexpr explicit operator bool() const { return has_value(); }
279  constexpr bool has_value() const { return Storage.has_value(); }
280  constexpr const T *operator->() const { return &Storage.value(); }
281  T *operator->() { return &Storage.value(); }
282  constexpr const T &operator*() const & { return Storage.value(); }
283  T &operator*() & { return Storage.value(); }
284 
285  template <typename U> constexpr T value_or(U &&alt) const & {
286    return has_value() ? operator*() : std::forward<U>(alt);
287  }
288 
289  LLVM_DEPRECATED("std::optional::value is throwing. Use *X instead", "*X")__attribute__((deprecated("std::optional::value is throwing. Use *X instead"
, "*X")))
290  T &&value() && { return std::move(Storage.value()); }
291  T &&operator*() && { return std::move(Storage.value()); }
292 
293  template <typename U> T value_or(U &&alt) && {
294    return has_value() ? std::move(operator*()) : std::forward<U>(alt);
295  }
296};
297 
298template<typename T>
299Optional(const T&) -> Optional<T>;
300 
301template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
302  return O ? hash_combine(true, *O) : hash_value(false);
303}
304 
305template <typename T, typename U>
306constexpr bool operator==(const Optional<T> &X, const Optional<U> &Y) {
307  if (X && Y)
308    return *X == *Y;
309  return X.has_value() == Y.has_value();
310}
311 
312template <typename T, typename U>
313constexpr bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
314  return !(X == Y);
315}
316 
317template <typename T, typename U>
318constexpr bool operator<(const Optional<T> &X, const Optional<U> &Y) {
319  if (X && Y)
320    return *X < *Y;
321  return X.has_value() < Y.has_value();
322}
323 
324template <typename T, typename U>
325constexpr bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
326  return !(Y < X);
327}
328 
329template <typename T, typename U>
330constexpr bool operator>(const Optional<T> &X, const Optional<U> &Y) {
331  return Y < X;
332}
333 
334template <typename T, typename U>
335constexpr bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
336  return !(X < Y);
337}
338 
339template <typename T>
340constexpr bool operator==(const Optional<T> &X, std::nullopt_t) {
341  return !X;
342}
343 
344template <typename T>
345constexpr bool operator==(std::nullopt_t, const Optional<T> &X) {
346  return X == std::nullopt;
347}
348 
349template <typename T>
350constexpr bool operator!=(const Optional<T> &X, std::nullopt_t) {
351  return !(X == std::nullopt);
352}
353 
354template <typename T>
355constexpr bool operator!=(std::nullopt_t, const Optional<T> &X) {
356  return X != std::nullopt;
357}
358 
359template <typename T>
360constexpr bool operator<(const Optional<T> &, std::nullopt_t) {
361  return false;
362}
363 
364template <typename T>
365constexpr bool operator<(std::nullopt_t, const Optional<T> &X) {
366  return X.has_value();
367}
368 
369template <typename T>
370constexpr bool operator<=(const Optional<T> &X, std::nullopt_t) {
371  return !(std::nullopt < X);
372}
373 
374template <typename T>
375constexpr bool operator<=(std::nullopt_t, const Optional<T> &X) {
376  return !(X < std::nullopt);
377}
378 
379template <typename T>
380constexpr bool operator>(const Optional<T> &X, std::nullopt_t) {
381  return std::nullopt < X;
382}
383 
384template <typename T>
385constexpr bool operator>(std::nullopt_t, const Optional<T> &X) {
386  return X < std::nullopt;
387}
388 
389template <typename T>
390constexpr bool operator>=(const Optional<T> &X, std::nullopt_t) {
391  return std::nullopt <= X;
392}
393 
394template <typename T>
395constexpr bool operator>=(std::nullopt_t, const Optional<T> &X) {
396  return X <= std::nullopt;
397}
398 
399template <typename T>
400constexpr bool operator==(const Optional<T> &X, const T &Y) {
401  return X && *X == Y;
402}
403 
404template <typename T>
405constexpr bool operator==(const T &X, const Optional<T> &Y) {
406  return Y && X == *Y;
407}
408 
409template <typename T>
410constexpr bool operator!=(const Optional<T> &X, const T &Y) {
411  return !(X == Y);
412}
413 
414template <typename T>
415constexpr bool operator!=(const T &X, const Optional<T> &Y) {
416  return !(X == Y);
417}
418 
419template <typename T>
420constexpr bool operator<(const Optional<T> &X, const T &Y) {
421  return !X || *X < Y;
422}
423 
424template <typename T>
425constexpr bool operator<(const T &X, const Optional<T> &Y) {
426  return Y && X < *Y;
427}
428 
429template <typename T>
430constexpr bool operator<=(const Optional<T> &X, const T &Y) {
431  return !(Y < X);
432}
433 
434template <typename T>
435constexpr bool operator<=(const T &X, const Optional<T> &Y) {
436  return !(Y < X);
437}
438 
439template <typename T>
440constexpr bool operator>(const Optional<T> &X, const T &Y) {
441  return Y < X;
442}
443 
444template <typename T>
445constexpr bool operator>(const T &X, const Optional<T> &Y) {
446  return Y < X;
447}
448 
449template <typename T>
450constexpr bool operator>=(const Optional<T> &X, const T &Y) {
451  return !(X < Y);
452}
453 
454template <typename T>
455constexpr bool operator>=(const T &X, const Optional<T> &Y) {
456  return !(X < Y);
457}
458 
459} // end namespace llvm
460 
461#endif // LLVM_ADT_OPTIONAL_H