181 lines
6.3 KiB
TableGen
181 lines
6.3 KiB
TableGen
//===-- BytecodeBase.td - Base bytecode R/W defs -----------*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the base bytecode reader/writer definition file.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef BYTECODE_BASE
|
|
#define BYTECODE_BASE
|
|
|
|
class Bytecode<string parse="", string build="", string print="", string get="", string t=""> {
|
|
// Template for parsing.
|
|
// $_reader == dialect bytecode reader
|
|
// $_resultType == result type of parsed instance
|
|
// $_var == variable being parsed
|
|
// If parser is not specified, then the parse of members is used.
|
|
string cParser = parse;
|
|
|
|
// Template for building from parsed.
|
|
// $_resultType == result type of parsed instance
|
|
// $_args == args/members comma separated
|
|
string cBuilder = build;
|
|
|
|
// Template for printing.
|
|
// $_writer == dialect bytecode writer
|
|
// $_name == parent attribute/type name
|
|
// $_getter == getter
|
|
string cPrinter = print;
|
|
|
|
// Template for getter from in memory form.
|
|
// $_attrType == attribute/type
|
|
// $_member == member instance
|
|
// $_getMember == get + UpperCamelFromSnake($_member)
|
|
string cGetter = get;
|
|
|
|
// Type built.
|
|
// Note: if cType is empty, then name of def is used.
|
|
string cType = t;
|
|
|
|
// Predicate guarding parse method as an Attribute/Type could have multiple
|
|
// parse methods, specify predicates to be orthogonal and cover entire
|
|
// "print space" to avoid order dependence.
|
|
// If empty then method is unconditional.
|
|
// $_val == predicate function to apply on value dyn_casted to cType.
|
|
string printerPredicate = "";
|
|
}
|
|
|
|
class WithParser<string p="", Bytecode t=Bytecode<>> :
|
|
Bytecode<p, t.cBuilder, t.cPrinter, t.cGetter, t.cType>;
|
|
class WithBuilder<string b="", Bytecode t=Bytecode<>> :
|
|
Bytecode<t.cParser, b, t.cPrinter, t.cGetter, t.cType>;
|
|
class WithPrinter<string p="", Bytecode t=Bytecode<>> :
|
|
Bytecode<t.cParser, t.cBuilder, p, t.cGetter, t.cType>;
|
|
class WithType<string ty="", Bytecode t=Bytecode<>> :
|
|
Bytecode<t.cParser, t.cBuilder, t.cPrinter, t.cGetter, ty>;
|
|
class WithGetter<string g="", Bytecode t=Bytecode<>> :
|
|
Bytecode<t.cParser, t.cBuilder, t.cPrinter, g, t.cType>;
|
|
|
|
// Representation of a bytecode element consisting of other bytecode atoms.
|
|
// E.g., it is effectively a struct of bytecode elements. Set the members by
|
|
// define a members dag: `dag members = (attr ...)`.
|
|
class CompositeBytecode<string t = ""> : WithType<t>;
|
|
|
|
class AttributeKind :
|
|
WithParser <"succeeded($_reader.readAttribute($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeAttribute($_getter)">>>;
|
|
def Attribute : AttributeKind;
|
|
class TypeKind :
|
|
WithParser <"succeeded($_reader.readType($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeType($_getter)">>>;
|
|
def Type : TypeKind;
|
|
|
|
def VarInt :
|
|
WithParser <"succeeded($_reader.readVarInt($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeVarInt($_getter)",
|
|
WithType <"uint64_t">>>>;
|
|
def SignedVarInt :
|
|
WithParser <"succeeded($_reader.readSignedVarInt($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeSignedVarInt($_getter)",
|
|
WithType <"int64_t">>>>;
|
|
def Blob :
|
|
WithParser <"succeeded($_reader.readBlob($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeOwnedBlob($_getter)",
|
|
WithType <"ArrayRef<char>">>>>;
|
|
def Bool :
|
|
WithParser <"succeeded($_reader.readBool($_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeOwnedBool($_getter)",
|
|
WithType <"bool">>>>;
|
|
class KnownWidthAPInt<string s> :
|
|
WithParser <"succeeded(readAPIntWithKnownWidth($_reader, " # s # ", $_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeAPIntWithKnownWidth($_getter)",
|
|
WithType <"FailureOr<APInt>">>>>;
|
|
class KnownSemanticsAPFloat<string s> :
|
|
WithParser <"succeeded(readAPFloatWithKnownSemantics($_reader, " # s # ", $_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeAPFloatWithKnownSemantics($_getter)",
|
|
WithType <"FailureOr<APFloat>">>>>;
|
|
class ResourceHandle<string s> :
|
|
WithParser <"succeeded(readResourceHandle<" # s # ">($_reader, $_var))",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"$_writer.writeResourceHandle($_getter)",
|
|
WithType <"FailureOr<" # s # ">">>>>;
|
|
|
|
// Helper to define variable that is defined later but not parsed nor printed.
|
|
class LocalVar<string t, string d> :
|
|
WithParser <"(($_var = " # d # "), true)",
|
|
WithBuilder<"$_args",
|
|
WithPrinter<"",
|
|
WithType <t>>>>;
|
|
|
|
// Array instances.
|
|
class Array<Bytecode t> {
|
|
Bytecode elemT = t;
|
|
|
|
string cBuilder = "$_args";
|
|
}
|
|
// - Array elements currently needs a different bytecode type to accommodate
|
|
// for the list print/parsing.
|
|
class List<Bytecode t> : WithGetter<"$_member", t>;
|
|
def SignedVarIntList : List<SignedVarInt>;
|
|
def BoolList : List<Bool>;
|
|
|
|
// Define dialect attribute or type.
|
|
class DialectAttrOrType<dag d> {
|
|
// Any members starting with underscore is not fed to create function but
|
|
// treated as purely local variable.
|
|
dag members = d;
|
|
|
|
// When needing to specify a custom return type.
|
|
string cType = "";
|
|
|
|
// Any post-processing that needs to be done.
|
|
code postProcess = "";
|
|
}
|
|
|
|
class DialectAttribute<dag d> : DialectAttrOrType<d>, AttributeKind {
|
|
let cParser = "succeeded($_reader.readAttribute<$_resultType>($_var))";
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, $_args)";
|
|
}
|
|
class DialectType<dag d> : DialectAttrOrType<d>, TypeKind {
|
|
let cParser = "succeeded($_reader.readType<$_resultType>($_var))";
|
|
let cBuilder = "getChecked<$_resultType>([&]() { return reader.emitError(); }, context, $_args)";
|
|
}
|
|
// Variant of the above, where it never prints. Useful for staging.
|
|
class DialectTypeNoPrint<dag d> : DialectType<d> {
|
|
let printerPredicate = "false";
|
|
}
|
|
|
|
class DialectAttributes<string d> {
|
|
string dialect = d;
|
|
list<DialectAttrOrType> elems;
|
|
}
|
|
|
|
class DialectTypes<string d> {
|
|
string dialect = d;
|
|
list<DialectAttrOrType> elems;
|
|
}
|
|
|
|
def attr;
|
|
def type;
|
|
|
|
// Marker to indicate a skipped attribute or type in the enum. Could either be
|
|
// reserved for a future value or for marking a previously used value as dead.
|
|
def none;
|
|
def ReservedOrDead : DialectAttrOrType<(none)>;
|
|
|
|
#endif // BYTECODE_BASE
|
|
|