Lines Matching defs:reader
34 #define DEBUG_TYPE "mlir-bytecode-reader"
104 /// Align the current reader position to the specified alignment.
113 // Shift the reader position to the next alignment boundary.
237 /// Skip the first `length` bytes within the reader.
340 static LogicalResult resolveEntry(EncodingReader &reader, RangeT &entries,
344 return reader.emitError("invalid ", entryStr, " index: ", index);
356 static LogicalResult parseEntry(EncodingReader &reader, RangeT &entries,
359 if (failed(reader.parseVarInt(entryIdx)))
361 return resolveEntry(reader, entries, entryIdx, entry, entryStr);
373 /// Initialize the string section reader with the given section data.
378 LogicalResult parseString(EncodingReader &reader, StringRef &result) const {
379 return parseEntry(reader, strings, result, "string");
385 LogicalResult parseStringWithFlag(EncodingReader &reader, StringRef &result,
388 if (failed(reader.parseVarIntWithFlag(entryIdx, flag)))
390 return parseStringAtIndex(reader, entryIdx, result);
395 LogicalResult parseStringAtIndex(EncodingReader &reader, uint64_t index,
397 return resolveEntry(reader, strings, index, result, "string");
436 // Check that the only remaining data was for the strings, i.e. the reader
456 /// context does not allow unregistered dialects. The provided reader is used
458 LogicalResult load(const DialectReader &reader, MLIRContext *ctx);
512 EncodingReader &reader,
517 if (failed(parseEntry(reader, dialects, dialect, "dialect")))
520 if (failed(reader.parseVarInt(numEntries)))
537 /// Initialize the resource section reader with the given section data.
546 LogicalResult parseResourceHandle(EncodingReader &reader,
548 return parseEntry(reader, dialectResources, result, "resource handle");
560 EncodingReader &reader, StringSectionReader &stringReader,
562 : key(key), kind(kind), reader(reader), stringReader(stringReader),
568 InFlightDiagnostic emitError() const final { return reader.emitError(); }
578 if (failed(reader.parseByte(value)))
588 if (failed(stringReader.parseString(reader, string)))
601 if (failed(reader.parseBlobAndAlignment(data, alignment)))
631 EncodingReader &reader;
784 /// this reader to manage when to actually parse them from the bytecode.
812 /// Initialize the attribute and type information within the reader.
825 /// Parse a reference to an attribute or type using the given reader.
826 LogicalResult parseAttribute(EncodingReader &reader, Attribute &result) {
828 if (failed(reader.parseVarInt(attrIdx)))
833 LogicalResult parseOptionalAttribute(EncodingReader &reader,
837 if (failed(reader.parseVarIntWithFlag(attrIdx, flag)))
845 LogicalResult parseType(EncodingReader &reader, Type &result) {
847 if (failed(reader.parseVarInt(typeIdx)))
854 LogicalResult parseAttribute(EncodingReader &reader, T &result) {
856 if (failed(parseAttribute(reader, baseResult)))
860 return reader.emitError("expected attribute of type: ",
870 /// Parse an entry using the given reader that was encoded using the textual
873 LogicalResult parseAsmEntry(T &result, EncodingReader &reader,
876 /// Parse an entry using the given reader that was encoded using a custom
879 LogicalResult parseCustomEntry(Entry<T> &entry, EncodingReader &reader,
882 /// The string section reader used to resolve string references when parsing
886 /// The resource section reader used to resolve resource references when
914 EncodingReader &reader, uint64_t &bytecodeVersion)
917 reader(reader), bytecodeVersion(bytecodeVersion) {}
920 return reader.emitError(msg);
947 Location getLoc() const { return reader.getLoc(); }
954 return attrTypeReader.parseAttribute(reader, result);
957 return attrTypeReader.parseOptionalAttribute(reader, result);
960 return attrTypeReader.parseType(reader, result);
965 if (failed(resourceReader.parseResourceHandle(reader, handle)))
975 return reader.parseVarInt(result);
980 if (failed(reader.parseSignedVarInt(unsignedResult)))
990 if (failed(reader.parseByte(value)))
998 if (failed(reader.parseSignedVarInt(value)))
1006 if (failed(reader.parseVarInt(numActiveWords)))
1010 if (failed(reader.parseSignedVarInt(words[i])))
1025 return stringReader.parseString(reader, result);
1031 if (failed(reader.parseVarInt(dataSize)) ||
1032 failed(reader.parseBytes(dataSize, data)))
1040 return reader.parseByte(result);
1048 EncodingReader &reader;
1055 /// Initialize the properties section reader with the given section data.
1100 // "Seek" to the requested offset by getting a new reader with the right
1102 EncodingReader reader(propertiesBuffers.drop_front(propertiesOffset),
1106 dialectReader.withEncodingReader(reader).readBlob(rawProperties)))
1109 // Setup a new reader to read from the `rawProperties` sub-buffer.
1110 EncodingReader reader(
1112 DialectReader propReader = dialectReader.withEncodingReader(reader);
1206 EncodingReader reader(entry.data, fileLoc);
1210 if (failed(parseCustomEntry(entry, reader, entryType)))
1212 } else if (failed(parseAsmEntry(entry.entry, reader, entryType))) {
1216 if (!reader.empty()) {
1217 reader.emitError("unexpected trailing bytes after " + entryType + " entry");
1224 LogicalResult AttrTypeReader::parseAsmEntry(T &result, EncodingReader &reader,
1227 if (failed(reader.parseNullTerminatedString(asmStr)))
1244 return reader.emitError("trailing characters found after ", entryType,
1252 EncodingReader &reader,
1255 reader, bytecodeVersion);
1270 // Reset the reader if we failed to parse, so we can fall through the
1272 reader = EncodingReader(entry.data, reader.getLoc());
1285 // Reset the reader if we failed to parse, so we can fall through the
1287 reader = EncodingReader(entry.data, reader.getLoc());
1293 return reader.emitError("dialect '", entry.dialect->name,
1403 LogicalResult parseVersion(EncodingReader &reader);
1410 /// Parse an operation name reference using the given reader, and set the
1413 FailureOr<OperationName> parseOpName(EncodingReader &reader,
1419 /// Parse an attribute or type using the given reader.
1421 LogicalResult parseAttribute(EncodingReader &reader, T &result) {
1422 return attrTypeReader.parseAttribute(reader, result);
1424 LogicalResult parseType(EncodingReader &reader, Type &result) {
1425 return attrTypeReader.parseType(reader, result);
1432 parseResourceSection(EncodingReader &reader,
1442 RegionReadState(Operation *op, EncodingReader *reader,
1444 : RegionReadState(op->getRegions(), reader, isIsolatedFromAbove) {}
1445 RegionReadState(MutableArrayRef<Region> regions, EncodingReader *reader,
1447 : curRegion(regions.begin()), endRegion(regions.end()), reader(reader),
1452 /// This is the reader to use for this region, this pointer is pointing to
1453 /// the parent region reader unless the current region is IsolatedFromAbove,
1456 EncodingReader *reader;
1477 FailureOr<Operation *> parseOpWithoutRegions(EncodingReader &reader,
1482 LogicalResult parseBlockHeader(EncodingReader &reader,
1484 LogicalResult parseBlockArguments(EncodingReader &reader, Block *block);
1489 /// Parse an operand reference using the given reader. Returns nullptr in the
1491 Value parseOperand(EncodingReader &reader);
1494 LogicalResult defineValues(EncodingReader &reader, ValueRange values);
1525 FailureOr<UseListMapT> parseUseListOrderForRange(EncodingReader &reader,
1579 /// The reader used to process attribute and types within the bytecode.
1593 /// The reader used to process resources within the bytecode.
1633 EncodingReader reader(buffer.getBuffer(), fileLoc);
1639 if (failed(reader.skipBytes(StringRef("ML\xefR").size())))
1642 if (failed(parseVersion(reader)) ||
1643 failed(reader.parseNullTerminatedString(producer)))
1657 while (!reader.empty()) {
1661 if (failed(reader.parseSection(sectionID, sectionData)))
1666 return reader.emitError("duplicate top-level section: ",
1675 return reader.emitError("missing data for top-level section: ",
1697 reader, sectionDatas[bytecode::Section::kResource],
1711 LogicalResult BytecodeReader::Impl::parseVersion(EncodingReader &reader) {
1712 if (failed(reader.parseVarInt(version)))
1719 return reader.emitError("bytecode version ", version,
1724 return reader.emitError("bytecode version ", version,
1737 LogicalResult BytecodeDialect::load(const DialectReader &reader,
1743 return reader.emitError("dialect '")
1757 return reader.emitError("dialect '")
1761 EncodingReader encReader(versionBuffer, reader.getLoc());
1762 DialectReader versionReader = reader.withEncodingReader(encReader);
1847 BytecodeReader::Impl::parseOpName(EncodingReader &reader,
1850 if (failed(parseEntry(reader, opNames, opName, "operation name")))
1865 dialectsMap, reader, version);
1879 EncodingReader &reader, std::optional<ArrayRef<uint8_t>> resourceData,
1895 // Initialize the resource reader with the resource sections.
1897 dialectsMap, reader, version);
1907 BytecodeReader::Impl::parseUseListOrderForRange(EncodingReader &reader,
1911 if (numResults > 1 && failed(reader.parseVarInt(numValuesToRead)))
1916 if (numResults > 1 && failed(reader.parseVarInt(resultIdx)))
1921 if (failed(reader.parseVarIntWithFlag(numValues, indexPairEncoding)))
1927 if (failed(reader.parseVarInt(index)))
2067 EncodingReader reader(sectionData, fileLoc);
2074 regionStack.emplace_back(*moduleOp, &reader, /*isIsolatedFromAbove=*/true);
2077 if (failed(parseBlockHeader(reader, regionStack.back())))
2087 return reader.emitError(
2093 return reader.emitError(
2140 EncodingReader &reader = *readState.reader;
2147 parseOpWithoutRegions(reader, readState, isIsolatedFromAbove);
2156 RegionReadState childState(*op, &reader, isIsolatedFromAbove);
2162 if (failed(reader.parseSection(sectionID, sectionData)))
2168 childState.reader = childState.owningReader.get();
2191 if (failed(parseBlockHeader(reader, readState)))
2212 BytecodeReader::Impl::parseOpWithoutRegions(EncodingReader &reader,
2217 FailureOr<OperationName> opName = parseOpName(reader, wasRegistered);
2224 if (failed(reader.parseByte(opMask)))
2229 if (failed(parseAttribute(reader, opLoc)))
2239 if (failed(parseAttribute(reader, dictAttr)))
2257 dialectsMap, reader, version);
2264 if (failed(parseAttribute(reader, opState.propertiesAttr)))
2272 if (failed(reader.parseVarInt(numResults)))
2276 if (failed(parseType(reader, opState.types[i])))
2283 if (failed(reader.parseVarInt(numOperands)))
2287 if (!(opState.operands[i] = parseOperand(reader)))
2294 if (failed(reader.parseVarInt(numSuccs)))
2298 if (failed(parseEntry(reader, readState.curBlocks, opState.successors[i],
2310 auto parseResult = parseUseListOrderForRange(reader, numResults);
2319 if (failed(reader.parseVarIntWithFlag(numRegions, isIsolatedFromAbove)))
2335 failed(defineValues(reader, op->getResults())))
2352 EncodingReader &reader = *readState.reader;
2356 if (failed(reader.parseVarInt(numBlocks)))
2365 if (failed(reader.parseVarInt(numValues)))
2383 return parseBlockHeader(reader, readState);
2387 BytecodeReader::Impl::parseBlockHeader(EncodingReader &reader,
2390 if (failed(reader.parseVarIntWithFlag(readState.numOpsRemaining, hasArgs)))
2394 if (hasArgs && failed(parseBlockArguments(reader, &*readState.curBlock)))
2402 if (hasArgs && failed(reader.parseByte(hasUseListOrders)))
2410 parseUseListOrderForRange(reader, blk.getNumArguments());
2423 LogicalResult BytecodeReader::Impl::parseBlockArguments(EncodingReader &reader,
2427 if (failed(reader.parseVarInt(numArgs)))
2443 if (failed(reader.parseVarIntWithFlag(typeIdx, hasLoc)) ||
2446 if (hasLoc && failed(parseAttribute(reader, argLoc)))
2450 if (failed(parseType(reader, argType)) ||
2451 failed(parseAttribute(reader, argLoc)))
2458 return defineValues(reader, block->getArguments());
2464 Value BytecodeReader::Impl::parseOperand(EncodingReader &reader) {
2467 if (failed(parseEntry(reader, values, value, "value")))
2476 LogicalResult BytecodeReader::Impl::defineValues(EncodingReader &reader,
2484 return reader.emitError(
2582 BytecodeReader::Impl reader(sourceFileLoc, config, /*lazyLoading=*/false,
2584 return reader.read(block, /*lazyOpsCallback=*/nullptr);