14 #include "mlir/IR/BuiltinAttributeInterfaces.h"
15 #include "mlir/IR/Location.h"
16 #include "mlir/IR/SymbolTable.h"
17 #include "llvm/ADT/TypeSwitch.h"
18 #include "llvm/Support/Debug.h"
20 #define DEBUG_TYPE "om-evaluator"
30 return cast<ModuleOp>(symbolTable.getOp());
33 SmallVector<evaluator::EvaluatorValuePtr>
35 ArrayRef<Attribute> attributes) {
36 SmallVector<evaluator::EvaluatorValuePtr> values;
37 values.reserve(attributes.size());
38 for (
auto attr : attributes)
39 values.push_back(std::make_shared<evaluator::AttributeValue>(attr));
44 using namespace evaluator;
50 assert(isFullyEvaluated());
51 return llvm::TypeSwitch<EvaluatorValue *, LogicalResult>(
this)
54 [](
auto v) {
return v->finalizeImpl(); });
58 return llvm::TypeSwitch<const EvaluatorValue *, Type>(
this)
59 .Case<
AttributeValue>([](
auto *attr) -> Type {
return attr->getType(); })
60 .Case<ObjectValue>([](
auto *
object) {
return object->getObjectType(); })
61 .Case<ListValue>([](
auto *list) {
return list->getListType(); })
62 .Case<MapValue>([](
auto *map) {
return map->getMapType(); })
63 .Case<ReferenceValue>([](
auto *ref) {
return ref->getValueType(); })
64 .Case<TupleValue>([](
auto *tuple) {
return tuple->getTupleType(); })
71 FailureOr<evaluator::EvaluatorValuePtr>
75 return TypeSwitch<mlir::Type, FailureOr<evaluator::EvaluatorValuePtr>>(type)
76 .Case([&](circt::om::MapType type) {
78 std::make_shared<evaluator::MapValue>(type, loc);
79 return success(result);
81 .Case([&](circt::om::ListType type) {
83 std::make_shared<evaluator::ListValue>(type, loc);
84 return success(result);
86 .Case([&](mlir::TupleType type) {
88 std::make_shared<evaluator::TupleValue>(type, loc);
89 return success(result);
92 .Case([&](circt::om::ClassType type)
93 -> FailureOr<evaluator::EvaluatorValuePtr> {
95 symbolTable.lookup<ClassOp>(type.getClassName().getValue());
97 return symbolTable.getOp()->emitError(
"unknown class name ")
98 << type.getClassName();
101 std::make_shared<evaluator::ObjectValue>(cls, loc);
103 return success(result);
105 .Default([&](
auto type) {
return failure(); });
110 auto it = objects.find({value, actualParams});
111 if (it != objects.end()) {
112 auto evalVal = it->second;
113 evalVal->setLocIfUnknown(loc);
117 FailureOr<evaluator::EvaluatorValuePtr> result =
118 TypeSwitch<Value, FailureOr<evaluator::EvaluatorValuePtr>>(value)
119 .Case([&](BlockArgument arg) {
120 auto val = (*actualParams)[arg.getArgNumber()];
124 .Case([&](OpResult result) {
125 return TypeSwitch<Operation *,
126 FailureOr<evaluator::EvaluatorValuePtr>>(
127 result.getDefiningOp())
128 .Case([&](ConstantOp op) {
129 return evaluateConstant(op, actualParams, loc);
131 .Case([&](IntegerBinaryArithmeticOp op) {
135 std::make_shared<evaluator::AttributeValue>(
136 op.getResult().getType(), loc);
137 return success(result);
139 .Case<ObjectFieldOp>([&](
auto op) {
143 std::make_shared<evaluator::ReferenceValue>(
144 value.getType(), loc);
145 return success(result);
147 .Case<AnyCastOp>([&](AnyCastOp op) {
148 return getOrCreateValue(op.getInput(), actualParams, loc);
150 .Case<FrozenBasePathCreateOp>([&](FrozenBasePathCreateOp op) {
152 std::make_shared<evaluator::BasePathValue>(
153 op.getPathAttr(), loc);
154 return success(result);
156 .Case<FrozenPathCreateOp>([&](FrozenPathCreateOp op) {
158 std::make_shared<evaluator::PathValue>(
159 op.getTargetKindAttr(), op.getPathAttr(),
160 op.getModuleAttr(), op.getRefAttr(),
161 op.getFieldAttr(), loc);
162 return success(result);
164 .Case<FrozenEmptyPathOp>([&](FrozenEmptyPathOp op) {
166 std::make_shared<evaluator::PathValue>(
168 return success(result);
170 .Case<ListCreateOp, TupleCreateOp, MapCreateOp, ObjectFieldOp>(
172 return getPartiallyEvaluatedValue(op.getType(), loc);
174 .Case<ObjectOp>([&](
auto op) {
175 return getPartiallyEvaluatedValue(op.getType(), op.getLoc());
177 .Default([&](Operation *op) {
178 auto error = op->emitError(
"unable to evaluate value");
179 error.attachNote() <<
"value: " << value;
186 objects[{value, actualParams}] = result.value();
190 FailureOr<evaluator::EvaluatorValuePtr>
195 ClassOp cls = symbolTable.lookup<ClassOp>(className);
197 return symbolTable.getOp()->emitError(
"unknown class name ") << className;
199 auto formalParamNames = cls.getFormalParamNames().getAsRange<StringAttr>();
200 auto formalParamTypes = cls.getBodyBlock()->getArgumentTypes();
203 if (actualParams->size() != formalParamTypes.size()) {
204 auto error = cls.emitError(
"actual parameter list length (")
205 << actualParams->size() <<
") does not match formal "
206 <<
"parameter list length (" << formalParamTypes.size() <<
")";
207 auto &diag = error.attachNote() <<
"actual parameters: ";
210 for (
const auto ¶m : *actualParams) {
217 error.attachNote(cls.getLoc()) <<
"formal parameters: " << formalParamTypes;
222 for (
auto [actualParam, formalParamName, formalParamType] :
223 llvm::zip(*actualParams, formalParamNames, formalParamTypes)) {
224 if (!actualParam || !actualParam.get())
225 return cls.emitError(
"actual parameter for ")
226 << formalParamName <<
" is null";
229 if (isa<AnyType>(formalParamType))
232 Type actualParamType = actualParam->getType();
234 assert(actualParamType &&
"actualParamType must be non-null!");
236 if (actualParamType != formalParamType) {
237 auto error = cls.emitError(
"actual parameter for ")
238 << formalParamName <<
" has invalid type";
239 error.attachNote() <<
"actual parameter: " << *actualParam;
240 error.attachNote() <<
"format parameter type: " << formalParamType;
248 auto *context = cls.getContext();
249 for (
auto &op : cls.getOps())
250 for (
auto result : op.getResults()) {
257 worklist.push({result, actualParams});
260 for (
auto field : cls.getOps<ClassFieldOp>()) {
261 StringAttr name = field.getNameAttr();
262 Value value = field.getValue();
263 FailureOr<evaluator::EvaluatorValuePtr> result =
264 evaluateValue(value, actualParams, field.getLoc());
268 fields[name] = result.value();
272 if (instanceKey.first) {
274 getOrCreateValue(instanceKey.first, instanceKey.second, loc).value();
275 auto *
object = llvm::cast<evaluator::ObjectValue>(result.get());
276 object->setFields(std::move(fields));
282 std::make_shared<evaluator::ObjectValue>(cls, fields, loc);
287 FailureOr<std::shared_ptr<evaluator::EvaluatorValue>>
289 StringAttr className, ArrayRef<evaluator::EvaluatorValuePtr> actualParams) {
290 ClassOp cls = symbolTable.lookup<ClassOp>(className);
292 return symbolTable.getOp()->emitError(
"unknown class name ") << className;
295 std::make_unique<SmallVector<std::shared_ptr<evaluator::EvaluatorValue>>>(
298 actualParametersBuffers.push_back(std::move(parameters));
300 auto loc = cls.getLoc();
301 auto result = evaluateObjectInstance(
302 className, actualParametersBuffers.back().get(), loc);
309 while (!worklist.empty()) {
310 auto [value, args] = worklist.front();
313 auto result = evaluateValue(value, args, loc);
319 if (!result.value()->isFullyEvaluated())
320 worklist.push({value, args});
323 auto &
object = result.value();
326 if (failed(object->finalize()))
327 return cls.emitError() <<
"failed to finalize evaluation. Probably the "
328 "class contains a dataflow cycle";
332 FailureOr<evaluator::EvaluatorValuePtr>
335 auto evaluatorValue = getOrCreateValue(value, actualParams, loc).value();
338 if (evaluatorValue->isFullyEvaluated())
339 return evaluatorValue;
341 return llvm::TypeSwitch<Value, FailureOr<evaluator::EvaluatorValuePtr>>(value)
342 .Case([&](BlockArgument arg) {
343 return evaluateParameter(arg, actualParams, loc);
345 .Case([&](OpResult result) {
346 return TypeSwitch<Operation *, FailureOr<evaluator::EvaluatorValuePtr>>(
347 result.getDefiningOp())
348 .Case([&](ConstantOp op) {
349 return evaluateConstant(op, actualParams, loc);
351 .Case([&](IntegerBinaryArithmeticOp op) {
352 return evaluateIntegerBinaryArithmetic(op, actualParams, loc);
354 .Case([&](ObjectOp op) {
355 return evaluateObjectInstance(op, actualParams);
357 .Case([&](ObjectFieldOp op) {
358 return evaluateObjectField(op, actualParams, loc);
360 .Case([&](ListCreateOp op) {
361 return evaluateListCreate(op, actualParams, loc);
363 .Case([&](TupleCreateOp op) {
364 return evaluateTupleCreate(op, actualParams, loc);
366 .Case([&](TupleGetOp op) {
367 return evaluateTupleGet(op, actualParams, loc);
369 .Case([&](AnyCastOp op) {
370 return evaluateValue(op.getInput(), actualParams, loc);
372 .Case([&](MapCreateOp op) {
373 return evaluateMapCreate(op, actualParams, loc);
375 .Case([&](FrozenBasePathCreateOp op) {
376 return evaluateBasePathCreate(op, actualParams, loc);
378 .Case([&](FrozenPathCreateOp op) {
379 return evaluatePathCreate(op, actualParams, loc);
381 .Case([&](FrozenEmptyPathOp op) {
382 return evaluateEmptyPath(op, actualParams, loc);
384 .Default([&](Operation *op) {
385 auto error = op->emitError(
"unable to evaluate value");
386 error.attachNote() <<
"value: " << value;
395 auto val = (*actualParams)[formalParam.getArgNumber()];
401 FailureOr<circt::om::evaluator::EvaluatorValuePtr>
405 return success(std::make_shared<circt::om::evaluator::AttributeValue>(
406 op.getValue(), loc));
410 FailureOr<EvaluatorValuePtr>
412 IntegerBinaryArithmeticOp op,
ActualParameters actualParams, Location loc) {
414 auto handle = getOrCreateValue(op.getResult(), actualParams, loc);
417 if (handle.value()->isFullyEvaluated())
422 auto lhsResult = evaluateValue(op.getLhs(), actualParams, loc);
423 if (failed(lhsResult))
425 if (!lhsResult.value()->isFullyEvaluated())
428 auto rhsResult = evaluateValue(op.getRhs(), actualParams, loc);
429 if (failed(rhsResult))
431 if (!rhsResult.value()->isFullyEvaluated())
437 llvm::TypeSwitch<evaluator::EvaluatorValue *, om::IntegerAttr>(value)
439 return val->
getAs<om::IntegerAttr>();
442 return cast<evaluator::AttributeValue>(
443 val->getStrippedValue()->get())
444 ->getAs<om::IntegerAttr>();
448 om::IntegerAttr lhs = extractAttr(lhsResult.value().get());
449 om::IntegerAttr rhs = extractAttr(rhsResult.value().get());
451 "expected om::IntegerAttr for IntegerBinaryArithmeticOp operands");
457 APSInt lhsVal = lhs.getValue().getAPSInt();
458 APSInt rhsVal = rhs.getValue().getAPSInt();
459 if (lhsVal.getBitWidth() > rhsVal.getBitWidth())
460 rhsVal = rhsVal.extend(lhsVal.getBitWidth());
461 else if (rhsVal.getBitWidth() > lhsVal.getBitWidth())
462 lhsVal = lhsVal.extend(rhsVal.getBitWidth());
465 FailureOr<APSInt> result = op.evaluateIntegerOperation(lhsVal, rhsVal);
468 return op->emitError(
"failed to evaluate integer operation");
471 MLIRContext *ctx = op->getContext();
476 auto *handleValue = cast<evaluator::AttributeValue>(handle.value().get());
477 auto resultStatus = handleValue->setAttr(resultAttr);
478 if (failed(resultStatus))
481 auto finalizeStatus = handleValue->finalize();
482 if (failed(finalizeStatus))
483 return finalizeStatus;
489 FailureOr<circt::om::Evaluator::ActualParameters>
493 auto parameters = std::make_unique<
494 SmallVector<std::shared_ptr<evaluator::EvaluatorValue>>>();
497 for (
auto input : range) {
498 auto inputResult = getOrCreateValue(input, actualParams, loc);
499 if (failed(inputResult))
501 parameters->push_back(inputResult.value());
504 actualParametersBuffers.push_back(std::move(parameters));
505 return actualParametersBuffers.back().get();
509 FailureOr<evaluator::EvaluatorValuePtr>
512 auto loc = op.getLoc();
513 if (isFullyEvaluated({op, actualParams}))
514 return getOrCreateValue(op, actualParams, loc);
517 createParametersFromOperands(op.getOperands(), actualParams, loc);
520 return evaluateObjectInstance(op.getClassNameAttr(), params.value(), loc,
525 FailureOr<evaluator::EvaluatorValuePtr>
530 FailureOr<evaluator::EvaluatorValuePtr> currentObjectResult =
531 evaluateValue(op.getObject(), actualParams, loc);
532 if (failed(currentObjectResult))
533 return currentObjectResult;
535 auto *currentObject =
536 llvm::cast<evaluator::ObjectValue>(currentObjectResult.value().get());
538 auto objectFieldValue = getOrCreateValue(op, actualParams, loc).value();
543 for (
auto field : op.getFieldPath().getAsRange<FlatSymbolRefAttr>()) {
545 if (!currentObject->getFields().contains(field.getAttr()))
546 return objectFieldValue;
548 auto currentField = currentObject->getField(field.getAttr());
549 finalField = currentField.value();
550 if (
auto *nextObject =
551 llvm::dyn_cast<evaluator::ObjectValue>(finalField.get()))
552 currentObject = nextObject;
556 llvm::cast<evaluator::ReferenceValue>(objectFieldValue.get())
557 ->setValue(finalField);
560 return objectFieldValue;
564 FailureOr<evaluator::EvaluatorValuePtr>
569 SmallVector<evaluator::EvaluatorValuePtr> values;
570 auto list = getOrCreateValue(op, actualParams, loc);
571 for (
auto operand : op.getOperands()) {
572 auto result = evaluateValue(operand, actualParams, loc);
575 if (!result.value()->isFullyEvaluated())
577 values.push_back(result.value());
581 llvm::cast<evaluator::ListValue>(list.value().get())
582 ->setElements(std::move(values));
587 FailureOr<evaluator::EvaluatorValuePtr>
591 SmallVector<evaluator::EvaluatorValuePtr> values;
592 for (
auto operand : op.getOperands()) {
593 auto result = evaluateValue(operand, actualParams, loc);
596 values.push_back(result.value());
600 auto val = getOrCreateValue(op, actualParams, loc);
601 llvm::cast<evaluator::TupleValue>(val.value().get())
602 ->setElements(std::move(values));
609 auto tuple = evaluateValue(op.getInput(), actualParams, loc);
613 cast<evaluator::TupleValue>(tuple.value().get())
614 ->getElements()[op.getIndex()];
622 DenseMap<Attribute, evaluator::EvaluatorValuePtr> elements;
623 auto valueResult = getOrCreateValue(op, actualParams, loc).value();
624 for (
auto operand : op.getOperands()) {
625 auto result = evaluateValue(operand, actualParams, loc);
629 auto &value = result.value();
630 if (!value->isFullyEvaluated())
632 const auto &element =
633 llvm::cast<evaluator::TupleValue>(value.get())->getElements();
634 assert(element.size() == 2);
636 llvm::cast<evaluator::AttributeValue>(element[0].
get())->getAttr();
637 if (!elements.insert({attr, element[1]}).second)
638 return op.emitError() <<
"map contains duplicated keys";
642 llvm::cast<evaluator::MapValue>(valueResult.get())
643 ->setElements(std::move(elements));
647 FailureOr<evaluator::EvaluatorValuePtr>
652 auto valueResult = getOrCreateValue(op, actualParams, loc).value();
653 auto *path = llvm::cast<evaluator::BasePathValue>(valueResult.get());
654 auto result = evaluateValue(op.getBasePath(), actualParams, loc);
657 auto &value = result.value();
658 if (!value->isFullyEvaluated())
660 path->setBasepath(*llvm::cast<evaluator::BasePathValue>(value.get()));
664 FailureOr<evaluator::EvaluatorValuePtr>
669 auto valueResult = getOrCreateValue(op, actualParams, loc).value();
670 auto *path = llvm::cast<evaluator::PathValue>(valueResult.get());
671 auto result = evaluateValue(op.getBasePath(), actualParams, loc);
674 auto &value = result.value();
675 if (!value->isFullyEvaluated())
677 path->setBasepath(*llvm::cast<evaluator::BasePathValue>(value.get()));
683 auto valueResult = getOrCreateValue(op, actualParams, loc).value();
692 FailureOr<EvaluatorValuePtr>
694 auto field = fields.find(name);
695 if (field == fields.end())
696 return cls.emitError(
"field ") << name <<
" does not exist";
697 return success(fields[name]);
703 SmallVector<Attribute> fieldNames;
704 for (
auto &f : fields)
705 fieldNames.push_back(f.first);
707 llvm::sort(fieldNames, [](Attribute a, Attribute b) {
708 return cast<StringAttr>(a).getValue() < cast<StringAttr>(b).getValue();
715 for (
auto &&[e, value] : fields)
728 SmallVector<Attribute> attrs;
729 for (
auto &[key, _] : elements)
730 attrs.push_back(key);
732 std::sort(attrs.begin(), attrs.end(), [](Attribute l, Attribute r) {
733 if (auto lInt = dyn_cast<mlir::IntegerAttr>(l))
734 if (auto rInt = dyn_cast<mlir::IntegerAttr>(r))
735 return lInt.getValue().ult(rInt.getValue());
737 assert(isa<StringAttr>(l) && isa<StringAttr>(r) &&
738 "key type should be integer or string");
739 return cast<StringAttr>(l).getValue() < cast<StringAttr>(r).getValue();
746 for (
auto &&[e, value] : elements)
757 auto result = getStrippedValue();
760 value = std::move(result.value());
769 for (
auto &value : elements) {
782 path(PathAttr::
get(context, {})) {
783 markFullyEvaluated();
787 :
EvaluatorValue(path.getContext(), Kind::BasePath, loc), path(path) {}
790 assert(isFullyEvaluated());
795 assert(!isFullyEvaluated());
796 auto newPath = llvm::to_vector(basepath.
path.getPath());
797 auto oldPath = path.getPath();
798 newPath.append(oldPath.begin(), oldPath.end());
800 markFullyEvaluated();
808 StringAttr module, StringAttr ref,
809 StringAttr field, Location loc)
811 path(path), module(module), ref(ref), field(field) {}
814 PathValue path(
nullptr,
nullptr,
nullptr,
nullptr,
nullptr, loc);
823 SmallString<64> result;
824 switch (targetKind.getValue()) {
825 case TargetKind::DontTouch:
826 result +=
"OMDontTouchedReferenceTarget";
828 case TargetKind::Instance:
829 result +=
"OMInstanceTarget";
831 case TargetKind::MemberInstance:
832 result +=
"OMMemberInstanceTarget";
834 case TargetKind::MemberReference:
835 result +=
"OMMemberReferenceTarget";
837 case TargetKind::Reference:
838 result +=
"OMReferenceTarget";
842 if (!path.getPath().empty())
843 result += path.getPath().front().module;
845 result += module.getValue();
847 for (
const auto &elt : path) {
848 result += elt.module.getValue();
850 result += elt.instance.getValue();
853 if (!module.getValue().empty())
854 result += module.getValue();
855 if (!ref.getValue().empty()) {
857 result += ref.getValue();
859 if (!field.getValue().empty())
860 result += field.getValue();
865 assert(!isFullyEvaluated());
866 auto newPath = llvm::to_vector(basepath.
getPath().getPath());
867 auto oldPath = path.getPath();
868 newPath.append(oldPath.begin(), oldPath.end());
870 markFullyEvaluated();
878 if (cast<TypedAttr>(attr).getType() != this->type)
879 return mlir::emitError(getLoc(),
"cannot set AttributeValue of type ")
880 << this->type <<
" to Attribute " << attr;
881 if (isFullyEvaluated())
882 return mlir::emitError(
884 "cannot set AttributeValue that has already been fully evaluated");
886 markFullyEvaluated();
891 if (!isFullyEvaluated())
892 return mlir::emitError(
893 getLoc(),
"cannot finalize AttributeValue that is not fully evaluated");
assert(baseType &&"element must be base type")
Direction get(bool isOutput)
Returns an output direction if isOutput is true, otherwise returns an input direction.
static LogicalResult finalizeEvaluatorValue(EvaluatorValuePtr &value)
std::shared_ptr< EvaluatorValue > EvaluatorValuePtr
A value of an object in memory.
SmallVector< EvaluatorValuePtr > getEvaluatorValuesFromAttributes(MLIRContext *context, ArrayRef< Attribute > attributes)
FailureOr< evaluator::EvaluatorValuePtr > evaluateBasePathCreate(FrozenBasePathCreateOp op, ActualParameters actualParams, Location loc)
FailureOr< evaluator::EvaluatorValuePtr > evaluateEmptyPath(FrozenEmptyPathOp op, ActualParameters actualParams, Location loc)
FailureOr< evaluator::EvaluatorValuePtr > getPartiallyEvaluatedValue(Type type, Location loc)
FailureOr< EvaluatorValuePtr > evaluateValue(Value value, ActualParameters actualParams, Location loc)
Evaluate a Value in a Class body according to the small expression grammar described in the rationale...
FailureOr< EvaluatorValuePtr > evaluateConstant(ConstantOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for constants.
FailureOr< EvaluatorValuePtr > evaluateIntegerBinaryArithmetic(IntegerBinaryArithmeticOp op, ActualParameters actualParams, Location loc)
mlir::ModuleOp getModule()
Get the Module this Evaluator is built from.
FailureOr< EvaluatorValuePtr > evaluateObjectField(ObjectFieldOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for Object fields.
Evaluator(ModuleOp mod)
Construct an Evaluator with an IR module.
FailureOr< evaluator::EvaluatorValuePtr > evaluateMapCreate(MapCreateOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for Map creation.
FailureOr< evaluator::EvaluatorValuePtr > instantiate(StringAttr className, ArrayRef< EvaluatorValuePtr > actualParams)
Instantiate an Object with its class name and actual parameters.
FailureOr< EvaluatorValuePtr > getOrCreateValue(Value value, ActualParameters actualParams, Location loc)
SmallVectorImpl< std::shared_ptr< evaluator::EvaluatorValue > > * ActualParameters
FailureOr< EvaluatorValuePtr > evaluateListCreate(ListCreateOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for List creation.
std::pair< Value, ActualParameters > ObjectKey
FailureOr< EvaluatorValuePtr > evaluateParameter(BlockArgument formalParam, ActualParameters actualParams, Location loc)
Evaluator dispatch functions for the small expression grammar.
FailureOr< EvaluatorValuePtr > evaluateObjectInstance(StringAttr className, ActualParameters actualParams, Location loc, ObjectKey instanceKey={})
Instantiate an Object with its class name and actual parameters.
FailureOr< EvaluatorValuePtr > evaluateTupleGet(TupleGetOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for List creation.
FailureOr< EvaluatorValuePtr > evaluateTupleCreate(TupleCreateOp op, ActualParameters actualParams, Location loc)
Evaluator dispatch function for Tuple creation.
FailureOr< evaluator::EvaluatorValuePtr > evaluatePathCreate(FrozenPathCreateOp op, ActualParameters actualParams, Location loc)
FailureOr< ActualParameters > createParametersFromOperands(ValueRange range, ActualParameters actualParams, Location loc)
Evaluator dispatch function for Object instances.
Values which can be directly representable by MLIR attributes.
LogicalResult setAttr(Attribute attr)
LogicalResult finalizeImpl()
BasePathValue(MLIRContext *context)
void setBasepath(const BasePathValue &basepath)
Set the basepath which this path is relative to.
om::PathAttr getPath() const
Base class for evaluator runtime values.
void markFullyEvaluated()
A List which contains variadic length of elements with the same type.
LogicalResult finalizeImpl()
ArrayAttr getKeys()
Return an array of keys in the ascending order.
LogicalResult finalizeImpl()
A composite Object, which has a type and fields.
LogicalResult finalizeImpl()
FailureOr< EvaluatorValuePtr > getField(StringAttr field)
Get a field of the Object by name.
ArrayAttr getFieldNames()
Get all the field names of the Object.
StringAttr getAsString() const
void setBasepath(const BasePathValue &basepath)
PathValue(om::TargetKindAttr targetKind, om::PathAttr path, StringAttr module, StringAttr ref, StringAttr field, Location loc)
Create a path value representing a regular path.
static PathValue getEmptyPath(Location loc)
Values which can be used as pointers to different values.
LogicalResult finalizeImpl()