//===-- 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 = "get<$_resultType>(context, $_args)";
}
class DialectType<dag d> : DialectAttrOrType<d>, TypeKind {
let cParser = "succeeded($_reader.readType<$_resultType>($_var))";
let cBuilder = "get<$_resultType>(context, $_args)";
}
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
Codebase Browser
llvm