634484885c
We can cast a string to a record via !cast, but we have no mechanism
to check if it is valid and TableGen will raise an error if failed to
cast. Besides, we have no semantic null in TableGen (we have `?` but
different backends handle uninitialized value differently), so operator
like `dyn_cast<>` is hard to implement.
In this patch, we add a new operator `!exists<T>(s)` to check whether
a record with type `T` and name `s` exists. Self-references are allowed
just like `!cast`.
By doing these, we can write code like:
```
class dyn_cast_to_record<string name> {
R value = !if(!exists<R>(name), !cast<R>(name), default_value);
}
defvar v = dyn_cast_to_record<"R0">.value; // R0 or default_value.
```
Reviewed By: tra, nhaehnle
Differential Revision: https://reviews.llvm.org/D127948
68 lines
1.3 KiB
TableGen
68 lines
1.3 KiB
TableGen
// RUN: llvm-tblgen --no-warn-on-unused-template-args %s | FileCheck %s
|
|
// XFAIL: vg_leak
|
|
|
|
class A;
|
|
def a0 : A;
|
|
|
|
class A_check<string name>{
|
|
int exists = !exists<A>(name);
|
|
}
|
|
|
|
def a0_exists : A_check<"a0">;
|
|
def a1_missing : A_check<"a1">;
|
|
|
|
|
|
// Subclasses are allowed.
|
|
|
|
class B;
|
|
class SubOfB : B;
|
|
class B_check<string name> {
|
|
int exists = !exists<B>(name);
|
|
}
|
|
|
|
def sub : SubOfB;
|
|
|
|
def sub_exists : B_check<"sub">;
|
|
def a0_is_not_sub_of_B : B_check<"a0">;
|
|
|
|
|
|
// Self-references are allowed.
|
|
|
|
class Self_check<string name> {
|
|
int exists = !exists<Self_check>(name);
|
|
}
|
|
|
|
def self_reference : Self_check<"self_reference">; // Self-reference
|
|
// There is no record called `current` in current context though we will define it below.
|
|
def current_missing : Self_check<"current">;
|
|
def current : Self_check<"current">;
|
|
|
|
// CHECK: def a0_exists {
|
|
// CHECK: int exists = 1;
|
|
// CHECK: }
|
|
|
|
// CHECK: def a0_is_not_sub_of_B {
|
|
// CHECK: int exists = 0;
|
|
// CHECK: }
|
|
|
|
// CHECK: def a1_missing {
|
|
// CHECK: int exists = 0;
|
|
// CHECK: }
|
|
|
|
// CHECK: def current {
|
|
// CHECK: int exists = 1;
|
|
// CHECK: }
|
|
|
|
// `current` doesn't exist because we define it below `current_missing`.
|
|
// CHECK: def current_missing {
|
|
// CHECK: int exists = 0;
|
|
// CHECK: }
|
|
|
|
// CHECK: def self_reference {
|
|
// CHECK: int exists = 1;
|
|
// CHECK: }
|
|
|
|
// CHECK: def sub_exists {
|
|
// CHECK: int exists = 1;
|
|
// CHECK: }
|