diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/404.html b/404.html new file mode 100644 index 0000000000..e83b302829 --- /dev/null +++ b/404.html @@ -0,0 +1,952 @@ + + + + + + + + + + + + + + + + + + VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ +

404 - Not found

+ +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/CONTRIBUTING/index.html b/CONTRIBUTING/index.html new file mode 100644 index 0000000000..a20f49ef02 --- /dev/null +++ b/CONTRIBUTING/index.html @@ -0,0 +1,1121 @@ + + + + + + + + + + + + + + + + + + + + + + How to contribute - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Contributing to VAST

+

First, thanks for your interest in contributing to VAST! We welcome and +appreciate all contributions, including bug reports, feature suggestions, +tutorials/blog posts, and code improvements.

+

If you're unsure where to start, we recommend our good first issue issue label.

+

Bug reports and feature suggestions

+

Bug reports and feature suggestions can be submitted to our issue tracker.

+

When reporting a bug please provide a minimal example with steps to reproduce the issue +if possible. It helps us a lot, as we can get to the bottom of the issue much faster and can +even use it as a test case to catch future regressions.

+

Questions

+

Questions can be submitted to the discussion page.

+ +

For legal reasons, we require contributors to sign our Contributor License +Agreement. This will be +automatically checked as part of our CI.

+

Git & Pull Requests

+

VAST uses the pull request contribution model. Please make an account on +Github, fork this repo, and submit code contributions via pull request. For +more documentation, look here.

+

Since VAST does not squash commits in a pull request, it is important to uphold +some culture when it comes to commits.

+
    +
  • Commit should ideally be one simple change.
    • +
  • Commit messages follow a simple format: + component: Simple sentence with a dot. with maximum of 80 chars and optional longer + message.
    • +
  • When unsure what component commit modifies, run git log on the modified file(s).
    • +
  • Commits should modify only one component (as a result the project does not have + to build with each separate commit)
    • +
  • If you are having troubles coming up with a simple sentence as a commit message, + that is short enough, it may be a good indicator that the commit should be split.
    • +
+

Some pull request guidelines:

+
    +
  • Minimize irrelevant changes (formatting, whitespace, etc) to code that would + otherwise not be touched by this patch. Save formatting or style corrections + for a separate pull request that does not make any semantic changes.
    • +
  • When possible, large changes should be split up into smaller focused pull + requests.
    • +
  • Fill out the pull request description with a summary of what your patch does, + key changes that have been made, and any further points of discussion, if + applicable.
    • +
  • Title your pull request with a brief description of what it's changing. + "Fixes #123" is a good comment to add to the description, but makes for an + unclear title on its own.
    • +
  • CI must pass for the PR to be merged.
    • +
  • There must be a review from some maintainer that accepts changes for the PR to be merged.
    • +
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Designs/abi/index.html b/Designs/abi/index.html new file mode 100644 index 0000000000..4df17fd991 --- /dev/null +++ b/Designs/abi/index.html @@ -0,0 +1,1127 @@ + + + + + + + + + + + + + + + + + + Abi - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Abi

+ +

ABI

+

VAST partially models ABI specifications for function types and therefore +callsites. While the specification goes into details regarding registers, for +now VAST only offers lowering similar to what clang codegen does - argument and +return types are coerced to types that will easily fit their respective +registers once that allocation takes place. There is nothing preventing +inclusion of information about registers as well (for example as metadata or +separate operations/dialect), however it is not yet implemented.

+

Similar to other transformation in VAST, ABI modelling tries to be as modular as +possible and as such can be split into three distinct steps:

+
    +
  • Compute classification of types
    • +
  • Encode computed classification into module
    • +
  • Lower transformed module into some "executable" dialect
    • +
+

Main goal for now is to lower function prototypes to match the types produced by +clang, so that VAST emitted LLVM can be used as drop-in replacement for clang +one.

+

When reading this document please keep in mind that implementation of this +feature is still ongoing and therefore particular technical details could change +drastically (although we hope that overall design will remain the same).

+

Classification

+

Mirrors what clang does, but instead of locking the computed information away, +we expose the API. In ideal world we would like to keep the algorithm(s, as +there may be multiple per different ABIs) generic. This can be achieved by +requiring users to implement & provide interface that specifies various details +about used types; algorithm will be same when talking about hl or LLVM types +after all.

+

ABI Dialect

+

Once classification for a function is computed, we need to:

+
    +
  • Change function prototype
    • +
  • Encode how new types match to the old types + some oddities such as sret.
    • +
+

To facilitate this, VAST contains abi dialect, which operations encode +"high-level" descriptions of type transformations that can occur during ABI +lowering as operations. This is not very different from what clang does, but +VAST does it over multiple steps.

+

For functions, type change itself is easy and to mark that function is +transformed, abi.func operation is used instead of original one to define the +newly formed function. However, as arguments and return types are different, we +introduce abi.prologue and abi.epilogue operations.

+

Consider following function we want to lower:

+

Disclaimer: Since abi dialect does not have nice formatting, therefore examples in +this section contain some artistic liberty, but semantics (and operations) are +preserved.

+
strut Point{ int; int; int; };
+
+int size( struct Point p ) { ... }
+
+

After running the classification, we discover that type of size should be +( i64, i32 ) -> i32 - both arguments and +returned value are passed directly. Therefore we encode it as follows:

+
abi.func size(i64 %arg0_0, i32 %arg0_1 ) -> i32
+{
+    %arg = abi.prologue -> hl.lvalue< hl.struct< "Point" > >
+    {
+        %0 = abi.direct %arg0_0, %arg0_1: (i64, i32) -> hl.struct< "Point" >
+        abi.yield %0
+    }
+
+    // Computation can continue as before, because %arg has a correct type
+
+    %ret = ... value that was previously returned ... -> i32
+    %out = abi.epilogue
+    {
+        %0 = abi.direct %ret: i32 -> i32
+        abi.yield %0
+    }
+    hl.return %out
+}
+
+

In case, there were multiple function arguments, the abi.prologue would return +more values.

+

+%args = abi.prologue -> (hl.lvalue< hl.struct< "Point" > >, i32 )
+{
+    %0 = abi.direct %arg0_0, %arg0_1
+    %1 = abi.direct %arg1
+    abi.yield %0, %1
+}
+
+

TODO: Add extra examples, at least memory and sret.

+

This design allows easy analysis and subsequent rewrite (as each function has a +prologue and epilogue and returned values are explicitly yielded).

+

Callsites are transformed in the same manner (unfortunately, they look more +complicated due to nested regions):

+

+%x = hl.call< "size" > %arg: hl.struct< "Point" > -> i32
+
+%x = abi.call< "size" >: () -> i32
+{
+    %arg0_0, %arg0_1 = abi.call_args: () -> (i64, i32)
+    {
+        %0, %1 = abi.direct %arg
+        abi.yield %0, %1
+    }
+    %x' = hl.call< "size" > %arg0_0, &arg0_1 : (i64, i32) -> i32
+    %0 = abi.call_rets : () -> i32
+    {
+        %0 = abi.direct %x' : i32 -> i32
+        abi.yield %0
+    }
+    abi.yield %0
+}
+
+
+

For now, same abi operations are used to encode transformation in callsite and +function (although they change the value in a "opposite direction"), this may be +later revisited, but for now it is enough to look at the parent operation to +determine whether the transformation lies in a function or callsite.

+

Lowering to some executable dialect

+

While abi dialect provides us with all the information required to do the +transformation, it does not "compute" anything. Rather this lowering is left to +a next pass. We hope by splitting the transformation into 2, +we achieve the following:

+
    +
  • We can implement multiple "backends" - whether back to hl, llvm or totally + random dialect of user choice.
    • +
  • Re-use existing implementation of classification algorithm.
    • +
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Designs/cpp2-parameters/index.html b/Designs/cpp2-parameters/index.html new file mode 100644 index 0000000000..26c55d747e --- /dev/null +++ b/Designs/cpp2-parameters/index.html @@ -0,0 +1,1081 @@ + + + + + + + + + + + + + + + + + + Cpp2 parameters - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Cpp2 parameters

+ +

Lifting parameter passing [https://github.com/hsutter/708/blob/main/708.pdf]

+

The proposed way of parameter passing for next-gen c++ is to use declarative style:

+
f(     in X x) // x can be read from
+f(  inout X x) // x can be used in read and write
+f(    out X x) // x can be writen to
+f(   move X x) // x will be moved from
+f(forward X x) // x will be passed along
+
+

Similar holds for return values:

+
auto f()    move X { /* ... */ } // move X to caller
+auto f()         X { /* ... */ } // possibly same
+auto f() forward X { /* ... */ } // pass along X to the caller
+
+

Using the semantics aware vast dialects, we can design a method to automatically modernize code to use a declarative style of parameter passing.

+

Examples

+ + + + + + + + + + + + + + + + + +
+CPP + +CPP2 +
+ +
+void f(const X& x) {
+    g(x);
+}
+
+		 + +
+void f(in X x) {
+    g(x);
+}
+
+
+VAST high-level dialect + +Transformed to parameter dialect +
+ +
+hl.func @f(%x: !hl.ref< !hl.lvalue< !hl.struct< "X" > >, const >) {
+    %0 = hl.call @g(%x) : (!hl.ref< !hl.lvalue< !hl.struct< "X" > >, const >) -> !hl.void
+}
+
+		 + +
+hl.func @f(%x: !par.in< !hl.lvalue< !hl.struct< "X" > > >) {
+    %0 = hl.call @g(%x) : (!par.in< !hl.lvalue< !hl.struct< "X" > > >) -> !hl.void
+}
+
+
+ +

The transformation will be probably overapproximating, in cases when the analysis cannot determine the precise category, i.e., inout oveapproximates in and out parameters.

+

Dialect

+

The dialect will define type adaptors for each parameter category:

+
!par.in< T >
+!par.out< T >
+!par.inout< T >
+!par.move< T >
+!par.forward< T >
+
+

Parameter categories can also be present as type attributes not to mess up the rest of the type trait system. +This needs further investigation.

+

The advantage of the type adaptors we can enforce the correct usage of values. For example, we can forbid usage of out parameter in other places than assignment.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/GettingStarted/build/index.html b/GettingStarted/build/index.html new file mode 100644 index 0000000000..337c7b93a7 --- /dev/null +++ b/GettingStarted/build/index.html @@ -0,0 +1,1097 @@ + + + + + + + + + + + + + + + + + + + + + + Build & Run - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Build & Run

+ +

Dependencies

+

Currently, it is necessary to use clang (due to gcc bug) to build VAST. On Linux it is also necessary to use lld at the moment.

+

VAST uses llvm-17 which can be obtained from the repository provided by LLVM.

+

Before building (for Ubuntu) get all the necessary dependencies by running

+
apt-get install build-essential cmake ninja-build libstdc++-12-dev llvm-17 libmlir-17 libmlir-17-dev mlir-17-tools libclang-17-dev
+
+

or an equivalent command for your operating system of choice.

+

Instructions

+

To configure project run cmake with following default options. +In case clang isn't your default compiler prefix the command with CC=clang CXX=clang++. +If you want to use system installed llvm and mlir (on Ubuntu) use:

+
cmake --preset ninja-multi-default \
+    --toolchain ./cmake/lld.toolchain.cmake \
+    -DCMAKE_PREFIX_PATH=/usr/lib/llvm-17/
+
+

To use a specific llvm provide -DCMAKE_PREFIX_PATH=<llvm & mlir instalation paths> option, where CMAKE_PREFIX_PATH points to directory containing LLVMConfig.cmake and MLIRConfig.cmake.

+

Note: vast requires LLVM with RTTI enabled. Use LLVM_ENABLE_RTTI=ON if you build your own LLVM.

+

Finally, build the project:

+
cmake --build --preset ninja-rel
+
+

Use ninja-deb preset for debug build.

+

Run

+

To run mlir codegen of highlevel dialect use.

+
./builds/ninja-multi-default/tools/vast-front/Release/vast-front -vast-emit-mlir=<dialect> <input.c> -o <output.mlir>
+
+

Supported dialects are: hl, ll, llvm

+

Test

+
ctest --preset ninja-deb
+
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/GettingStarted/debug/index.html b/GettingStarted/debug/index.html new file mode 100644 index 0000000000..b6a34c2984 --- /dev/null +++ b/GettingStarted/debug/index.html @@ -0,0 +1,1098 @@ + + + + + + + + + + + + + + + + + + + + + + Debug - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Debug

+ +

Debugging

+

VAST makes use of the MLIR infrastructure to facilitate the reproduction of crashes within the pipeline. You can refer to the MLIR documentation on crash and failure reproduction for more details. We provide a similar set of options in vast-front to aid in debugging.

+

Generating Crash Reproducers

+

To generate a minimal reproducer for a crashed pipeline of vast-front, use the following option:

+
-vast-emit-crash-reproducer="reproducer.mlir" 
+
+

This option disables multithreading to ensure a comprehensive crash report. You can then load and examine the crash report using the following command:

+
vast-opt -run-reproducer reproducer.mlir
+
+

Pipeline Information

+

To obtain a detailed insight into the pipeline, you can use the following option of vast-front:

+
-vast-print-pipeline
+
+

This option dumps the pipeline string to the standard error stream. You can use this information for a more specific investigation of the pipeline. Execute the pipeline with the printed string using the following command:

+
vast-opt --pass-pipeline="pipeline-string"
+
+

Debug Pipeline

+

With the -vast-debug option, you get more detailed crash reports. It shows MLIR operations when there's an error and provides current stack traces.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/GettingStarted/extend/index.html b/GettingStarted/extend/index.html new file mode 100644 index 0000000000..a259b51b6a --- /dev/null +++ b/GettingStarted/extend/index.html @@ -0,0 +1,1057 @@ + + + + + + + + + + + + + + + + + + + + + + How to create a new dialect - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

How to create a new dialect

+ +

How to Start Extending VAST?

+

VAST offers a handy script to generate a variety of MLIR primitives. You can find the script at scripts/templater.py. This tool is designed to help you create dialects, passes, operations, types, and attributes interactively.

+

Usage

+

Just run the script. It has been designed to provide a guided process for generating the desired primitives. If you find anything confusing or unintuitive, please don't hesitate to open an issue so that we can address it.

+

When you run the script, it will generate the basic skeleton for your chosen primitive. It will list the generated files which you can freely modify to provide desired functionality.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Projects/related/index.html b/Projects/related/index.html new file mode 100644 index 0000000000..ecdbcabc0c --- /dev/null +++ b/Projects/related/index.html @@ -0,0 +1,1048 @@ + + + + + + + + + + + + + + + + + + Related - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Related

+ + +

LLVM Test Suite

+

Test suite extended to generate reports for VAST MLIR dialects.

+

Benchamrks

+

C/C++ benchmarks for VAST.

+

Miller

+

VAST MLIR Abstract Interpreter

+

VAST-Checker

+

VAST-based tool that scans C code for variants of the Sequoia bug.

+

Macroni

+

Compiler frontend for C and C++ that utilizes PASTA for code parsing and VAST +for representing the code as MLIR. Notably, it extends VAST MLIR to handle macro +expansions in its dialects.

+

PoTATo

+

Dialect-based points-to analysis for MLIR.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Tools/vast-front/index.html b/Tools/vast-front/index.html new file mode 100644 index 0000000000..f5a39449f6 --- /dev/null +++ b/Tools/vast-front/index.html @@ -0,0 +1,986 @@ + + + + + + + + + + + + + + + + + + + + + + Compiler Driver - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: Compiler Driver

+

WIP vast-front

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Tools/vast-lsp-server/index.html b/Tools/vast-lsp-server/index.html new file mode 100644 index 0000000000..e894b5f6d7 --- /dev/null +++ b/Tools/vast-lsp-server/index.html @@ -0,0 +1,1037 @@ + + + + + + + + + + + + + + + + + + + + + + LSP Server - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: Language Server Protocol

+

VAST provides an implementation of LSP language server in the form of the vast-lsp-server tool. This tool interacts with the MLIR C++ API to support rich language queries, such as “Find Definition”.

+

The tool easily integrates with VSCode extension MLIR. The user needs to point the extension to mlir-lsp-server. To do so, one can create a symbolic link named mlir-lsp-server to point to built vast-lsp-server.

+

Build

+

To build vast-lsp-server use:

+
cmake --build <build-dir> --target vast-lsp-server
+
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Tools/vast-opt/index.html b/Tools/vast-opt/index.html new file mode 100644 index 0000000000..e885f0172d --- /dev/null +++ b/Tools/vast-opt/index.html @@ -0,0 +1,1190 @@ + + + + + + + + + + + + + + + + + + + + + + Optimizer - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: Optimizer

+

After mlir module from vast-cc is produced, we can leverage our optimisation pipeline to transform module in various ways. The lowest level we can do is LLVM dialect, from which we can dump LLVM IR if desired.

+

Overall design philosophy is that passes try to be really modular, self-contained and doing one thing properly - all while trying to preserve provenance metadata. Sometimes this does not exactly hold (transformation from HL into LL is huge) but it is what we strive for. Passes will more often than not have some dependencies between themselves - always consult documentation if unsure and report an issue if wiki is out of date on this.

+

Metadata and passes

+

TODO: Improve once we have examples

+

TL;DR: Vast provided passes always try to keep metadata (and they should do a good job), but for passes from other sources this does not hold and probably some heuristic will be used to re-compute them in best-effort.

+

Passes

+

Passes we have implemented can be roughly grouped into several categories. We also note some of the native mlir passes that are needed to continue with transformations to reach LLVM dialect.

+

Type lowering

+

A common prerequisite for other passes is to lower HL types into standard types. This can be done in two steps: + * --vast-hl-lower-types + - Converts simple (non-struct) types according to provided data layout (embedded in the mlir module metadata). + * --vast-hl-structs-to-tuples + - Converts HL struct types into standard tuples

+

While these should be commutative, the preferred order is --vast-hl-lower-types --vast-hl-structs-to-tuples

+

HL -> SCF

+
    +
  • --vast-hl-to-scf
    • +
  • Requires:
      +
    • Type lowering
      • +
    +
    • +
  • Conversion of HL control flow ops (currently only hl.if and hl.while) into their scf equivalents. Since scf requires i1 in their conditions, additional casts may be inserted to satisfy this requirement (currently they are emitted in HL however this behaviour should customisable eventually.
    • +
+

To produce an LLVM following addition passes must be run +--convert-scf-to-std --convert-std-to-llvm and possibly --vast-hl-to-ll as well (or some equivalent, depending on how conditions are coerced)

+

HL -> LL

+
    +
  • --vast-hl-to-ll
    • +
  • Requires:
      +
    • Type lowering
      • +
    • Some form of control flow lowering
      • +
    +
    • +
  • Lower all HL operation into their LLVM dialect equivalents - this is a rather huge pass, for details see its documentation.
    • +
+

LLVM Dump

+
    +
  • --vast-llvm-dump
    • +
  • Requires:
      +
    • Entire module must be in LLVM dialect (or have operation for which conversion hooks are provided)
      • +
    +
    • +
  • LLVM bitcode is dumped to llvm::errs() in human readable form. Since passes can run in parallel, dump to file is non-trivial.
    • +
+

Example Usage

+

Let's say we have file main.c which we want to lower into some dialect. First let's have a look at some generic invocations we may find handy:

+

To get mlir module via vast-cc

+
vast-cc --ccopts -xc --from-source main.c
+
+

A quick remainder + * --ccopts -xc says we are doing C not C++ + * --from-source file says that source code comes from the file

+

Once we have the module, we can invoke vast-opt, with easiest way being a simple pipe

+
vast-cc --ccopts -xc --from-source main.c | vast-opt pass-we-want another-pass-we-want
+
+

If we want, we can also chain pipes

+
vast-cc --ccopts -xc --from-source main.c | vast-opt pass | vast-opt another-pass | ...
+
+

Now, let's say we want to lower into LLVM bitcode, therefore the invocation will look as follows

+
vast-cc --ccopts -xc --from-source main.c | vast-opt --vast-hl-lower-types --vast-hl-structs-to-tuples
+                                                     --vast-hl-to-scf --convert-scf-to-std --convert-std-to-llvm
+                                                     --vast-hl-to-ll
+
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Tools/vast-query/index.html b/Tools/vast-query/index.html new file mode 100644 index 0000000000..3fd59ae08f --- /dev/null +++ b/Tools/vast-query/index.html @@ -0,0 +1,999 @@ + + + + + + + + + + + + + + + + + + + + + + Query - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: Query

+

vast-query is a command line tool to query symbols in the vast generated MLIR. Its primary purpose is to test symbols and their use edges in the produced MLIR. Example of usage:

+
vast-query [options] <input file>
+
+

Options:

+
  --scope=<function name>      - Show values from scope of a given function
+  --show-symbols=<value>       - Show MLIR symbols
+    =functions                 -   show function symbols
+    =types                     -   show type symbols
+    =records                   -   show record symbols
+    =vars                      -   show variable symbols
+    =globs                     -   show global variable symbols
+    =all                       -   show all symbols
+  --symbol-users=<symbol name> - Show users of a given symbol
+
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/Tools/vast-repl/index.html b/Tools/vast-repl/index.html new file mode 100644 index 0000000000..c9c06c46f5 --- /dev/null +++ b/Tools/vast-repl/index.html @@ -0,0 +1,1002 @@ + + + + + + + + + + + + + + + + + + + + + + REPL - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + Skip to content + + +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: REPL

+

WIP vast-repl is an interactive MLIR query and modification tool.

+

Commands:

+
exit            - exits repl
+
+help            - prints help
+load <filename> - loads source from file
+
+show <value>    - displays queried value
+    =source         - loaded source code
+    =ast            - clang ast
+    =module         - current VAST MLIR module
+    =symbols        - present symbols in the module
+
+meta <action>   - operates on metadata for given symbol
+    =add <symbol> <id> - adds <id> meta to <symbol>
+    =get <id>          - gets symbol with <id> meta
+
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/assets/images/favicon.png b/assets/images/favicon.png new file mode 100644 index 0000000000..1cf13b9f9d Binary files /dev/null and b/assets/images/favicon.png differ diff --git a/assets/javascripts/bundle.51d95adb.min.js b/assets/javascripts/bundle.51d95adb.min.js new file mode 100644 index 0000000000..b20ec6835b --- /dev/null +++ b/assets/javascripts/bundle.51d95adb.min.js @@ -0,0 +1,29 @@ +"use strict";(()=>{var Hi=Object.create;var xr=Object.defineProperty;var Pi=Object.getOwnPropertyDescriptor;var $i=Object.getOwnPropertyNames,kt=Object.getOwnPropertySymbols,Ii=Object.getPrototypeOf,Er=Object.prototype.hasOwnProperty,an=Object.prototype.propertyIsEnumerable;var on=(e,t,r)=>t in e?xr(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,P=(e,t)=>{for(var r in t||(t={}))Er.call(t,r)&&on(e,r,t[r]);if(kt)for(var r of kt(t))an.call(t,r)&&on(e,r,t[r]);return e};var sn=(e,t)=>{var r={};for(var n in e)Er.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&kt)for(var n of kt(e))t.indexOf(n)<0&&an.call(e,n)&&(r[n]=e[n]);return r};var Ht=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Fi=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of $i(t))!Er.call(e,o)&&o!==r&&xr(e,o,{get:()=>t[o],enumerable:!(n=Pi(t,o))||n.enumerable});return e};var yt=(e,t,r)=>(r=e!=null?Hi(Ii(e)):{},Fi(t||!e||!e.__esModule?xr(r,"default",{value:e,enumerable:!0}):r,e));var fn=Ht((wr,cn)=>{(function(e,t){typeof wr=="object"&&typeof cn!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(wr,function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(T){return!!(T&&T!==document&&T.nodeName!=="HTML"&&T.nodeName!=="BODY"&&"classList"in T&&"contains"in T.classList)}function f(T){var Ke=T.type,We=T.tagName;return!!(We==="INPUT"&&a[Ke]&&!T.readOnly||We==="TEXTAREA"&&!T.readOnly||T.isContentEditable)}function c(T){T.classList.contains("focus-visible")||(T.classList.add("focus-visible"),T.setAttribute("data-focus-visible-added",""))}function u(T){T.hasAttribute("data-focus-visible-added")&&(T.classList.remove("focus-visible"),T.removeAttribute("data-focus-visible-added"))}function p(T){T.metaKey||T.altKey||T.ctrlKey||(s(r.activeElement)&&c(r.activeElement),n=!0)}function m(T){n=!1}function d(T){s(T.target)&&(n||f(T.target))&&c(T.target)}function h(T){s(T.target)&&(T.target.classList.contains("focus-visible")||T.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(T.target))}function v(T){document.visibilityState==="hidden"&&(o&&(n=!0),B())}function B(){document.addEventListener("mousemove",z),document.addEventListener("mousedown",z),document.addEventListener("mouseup",z),document.addEventListener("pointermove",z),document.addEventListener("pointerdown",z),document.addEventListener("pointerup",z),document.addEventListener("touchmove",z),document.addEventListener("touchstart",z),document.addEventListener("touchend",z)}function re(){document.removeEventListener("mousemove",z),document.removeEventListener("mousedown",z),document.removeEventListener("mouseup",z),document.removeEventListener("pointermove",z),document.removeEventListener("pointerdown",z),document.removeEventListener("pointerup",z),document.removeEventListener("touchmove",z),document.removeEventListener("touchstart",z),document.removeEventListener("touchend",z)}function z(T){T.target.nodeName&&T.target.nodeName.toLowerCase()==="html"||(n=!1,re())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",m,!0),document.addEventListener("pointerdown",m,!0),document.addEventListener("touchstart",m,!0),document.addEventListener("visibilitychange",v,!0),B(),r.addEventListener("focus",d,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)})});var un=Ht(Sr=>{(function(e){var t=function(){try{return!!Symbol.iterator}catch(c){return!1}},r=t(),n=function(c){var u={next:function(){var p=c.shift();return{done:p===void 0,value:p}}};return r&&(u[Symbol.iterator]=function(){return u}),u},o=function(c){return encodeURIComponent(c).replace(/%20/g,"+")},i=function(c){return decodeURIComponent(String(c).replace(/\+/g," "))},a=function(){var c=function(p){Object.defineProperty(this,"_entries",{writable:!0,value:{}});var m=typeof p;if(m!=="undefined")if(m==="string")p!==""&&this._fromString(p);else if(p instanceof c){var d=this;p.forEach(function(re,z){d.append(z,re)})}else if(p!==null&&m==="object")if(Object.prototype.toString.call(p)==="[object Array]")for(var h=0;hd[0]?1:0}),c._entries&&(c._entries={});for(var p=0;p1?i(d[1]):"")}})})(typeof global!="undefined"?global:typeof window!="undefined"?window:typeof self!="undefined"?self:Sr);(function(e){var t=function(){try{var o=new e.URL("b","http://a");return o.pathname="c d",o.href==="http://a/c%20d"&&o.searchParams}catch(i){return!1}},r=function(){var o=e.URL,i=function(f,c){typeof f!="string"&&(f=String(f)),c&&typeof c!="string"&&(c=String(c));var u=document,p;if(c&&(e.location===void 0||c!==e.location.href)){c=c.toLowerCase(),u=document.implementation.createHTMLDocument(""),p=u.createElement("base"),p.href=c,u.head.appendChild(p);try{if(p.href.indexOf(c)!==0)throw new Error(p.href)}catch(T){throw new Error("URL unable to set base "+c+" due to "+T)}}var m=u.createElement("a");m.href=f,p&&(u.body.appendChild(m),m.href=m.href);var d=u.createElement("input");if(d.type="url",d.value=f,m.protocol===":"||!/:/.test(m.href)||!d.checkValidity()&&!c)throw new TypeError("Invalid URL");Object.defineProperty(this,"_anchorElement",{value:m});var h=new e.URLSearchParams(this.search),v=!0,B=!0,re=this;["append","delete","set"].forEach(function(T){var Ke=h[T];h[T]=function(){Ke.apply(h,arguments),v&&(B=!1,re.search=h.toString(),B=!0)}}),Object.defineProperty(this,"searchParams",{value:h,enumerable:!0});var z=void 0;Object.defineProperty(this,"_updateSearchParams",{enumerable:!1,configurable:!1,writable:!1,value:function(){this.search!==z&&(z=this.search,B&&(v=!1,this.searchParams._fromString(this.search),v=!0))}})},a=i.prototype,s=function(f){Object.defineProperty(a,f,{get:function(){return this._anchorElement[f]},set:function(c){this._anchorElement[f]=c},enumerable:!0})};["hash","host","hostname","port","protocol"].forEach(function(f){s(f)}),Object.defineProperty(a,"search",{get:function(){return this._anchorElement.search},set:function(f){this._anchorElement.search=f,this._updateSearchParams()},enumerable:!0}),Object.defineProperties(a,{toString:{get:function(){var f=this;return function(){return f.href}}},href:{get:function(){return this._anchorElement.href.replace(/\?$/,"")},set:function(f){this._anchorElement.href=f,this._updateSearchParams()},enumerable:!0},pathname:{get:function(){return this._anchorElement.pathname.replace(/(^\/?)/,"/")},set:function(f){this._anchorElement.pathname=f},enumerable:!0},origin:{get:function(){var f={"http:":80,"https:":443,"ftp:":21}[this._anchorElement.protocol],c=this._anchorElement.port!=f&&this._anchorElement.port!=="";return this._anchorElement.protocol+"//"+this._anchorElement.hostname+(c?":"+this._anchorElement.port:"")},enumerable:!0},password:{get:function(){return""},set:function(f){},enumerable:!0},username:{get:function(){return""},set:function(f){},enumerable:!0}}),i.createObjectURL=function(f){return o.createObjectURL.apply(o,arguments)},i.revokeObjectURL=function(f){return o.revokeObjectURL.apply(o,arguments)},e.URL=i};if(t()||r(),e.location!==void 0&&!("origin"in e.location)){var n=function(){return e.location.protocol+"//"+e.location.hostname+(e.location.port?":"+e.location.port:"")};try{Object.defineProperty(e.location,"origin",{get:n,enumerable:!0})}catch(o){setInterval(function(){e.location.origin=n()},100)}}})(typeof global!="undefined"?global:typeof window!="undefined"?window:typeof self!="undefined"?self:Sr)});var Qr=Ht((Lt,Kr)=>{/*! + * clipboard.js v2.0.11 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */(function(t,r){typeof Lt=="object"&&typeof Kr=="object"?Kr.exports=r():typeof define=="function"&&define.amd?define([],r):typeof Lt=="object"?Lt.ClipboardJS=r():t.ClipboardJS=r()})(Lt,function(){return function(){var e={686:function(n,o,i){"use strict";i.d(o,{default:function(){return ki}});var a=i(279),s=i.n(a),f=i(370),c=i.n(f),u=i(817),p=i.n(u);function m(j){try{return document.execCommand(j)}catch(O){return!1}}var d=function(O){var w=p()(O);return m("cut"),w},h=d;function v(j){var O=document.documentElement.getAttribute("dir")==="rtl",w=document.createElement("textarea");w.style.fontSize="12pt",w.style.border="0",w.style.padding="0",w.style.margin="0",w.style.position="absolute",w.style[O?"right":"left"]="-9999px";var k=window.pageYOffset||document.documentElement.scrollTop;return w.style.top="".concat(k,"px"),w.setAttribute("readonly",""),w.value=j,w}var B=function(O,w){var k=v(O);w.container.appendChild(k);var F=p()(k);return m("copy"),k.remove(),F},re=function(O){var w=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},k="";return typeof O=="string"?k=B(O,w):O instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(O==null?void 0:O.type)?k=B(O.value,w):(k=p()(O),m("copy")),k},z=re;function T(j){return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?T=function(w){return typeof w}:T=function(w){return w&&typeof Symbol=="function"&&w.constructor===Symbol&&w!==Symbol.prototype?"symbol":typeof w},T(j)}var Ke=function(){var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},w=O.action,k=w===void 0?"copy":w,F=O.container,q=O.target,Le=O.text;if(k!=="copy"&&k!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(q!==void 0)if(q&&T(q)==="object"&&q.nodeType===1){if(k==="copy"&&q.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(k==="cut"&&(q.hasAttribute("readonly")||q.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(Le)return z(Le,{container:F});if(q)return k==="cut"?h(q):z(q,{container:F})},We=Ke;function Ie(j){return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?Ie=function(w){return typeof w}:Ie=function(w){return w&&typeof Symbol=="function"&&w.constructor===Symbol&&w!==Symbol.prototype?"symbol":typeof w},Ie(j)}function Ti(j,O){if(!(j instanceof O))throw new TypeError("Cannot call a class as a function")}function nn(j,O){for(var w=0;w0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof F.action=="function"?F.action:this.defaultAction,this.target=typeof F.target=="function"?F.target:this.defaultTarget,this.text=typeof F.text=="function"?F.text:this.defaultText,this.container=Ie(F.container)==="object"?F.container:document.body}},{key:"listenClick",value:function(F){var q=this;this.listener=c()(F,"click",function(Le){return q.onClick(Le)})}},{key:"onClick",value:function(F){var q=F.delegateTarget||F.currentTarget,Le=this.action(q)||"copy",Rt=We({action:Le,container:this.container,target:this.target(q),text:this.text(q)});this.emit(Rt?"success":"error",{action:Le,text:Rt,trigger:q,clearSelection:function(){q&&q.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(F){return yr("action",F)}},{key:"defaultTarget",value:function(F){var q=yr("target",F);if(q)return document.querySelector(q)}},{key:"defaultText",value:function(F){return yr("text",F)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(F){var q=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return z(F,q)}},{key:"cut",value:function(F){return h(F)}},{key:"isSupported",value:function(){var F=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],q=typeof F=="string"?[F]:F,Le=!!document.queryCommandSupported;return q.forEach(function(Rt){Le=Le&&!!document.queryCommandSupported(Rt)}),Le}}]),w}(s()),ki=Ri},828:function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,f){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(f))return s;s=s.parentNode}}n.exports=a},438:function(n,o,i){var a=i(828);function s(u,p,m,d,h){var v=c.apply(this,arguments);return u.addEventListener(m,v,h),{destroy:function(){u.removeEventListener(m,v,h)}}}function f(u,p,m,d,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof m=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,m,d,h)}))}function c(u,p,m,d){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&d.call(u,h)}}n.exports=f},879:function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}},370:function(n,o,i){var a=i(879),s=i(438);function f(m,d,h){if(!m&&!d&&!h)throw new Error("Missing required arguments");if(!a.string(d))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(m))return c(m,d,h);if(a.nodeList(m))return u(m,d,h);if(a.string(m))return p(m,d,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function c(m,d,h){return m.addEventListener(d,h),{destroy:function(){m.removeEventListener(d,h)}}}function u(m,d,h){return Array.prototype.forEach.call(m,function(v){v.addEventListener(d,h)}),{destroy:function(){Array.prototype.forEach.call(m,function(v){v.removeEventListener(d,h)})}}}function p(m,d,h){return s(document.body,m,d,h)}n.exports=f},817:function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var f=window.getSelection(),c=document.createRange();c.selectNodeContents(i),f.removeAllRanges(),f.addRange(c),a=f.toString()}return a}n.exports=o},279:function(n){function o(){}o.prototype={on:function(i,a,s){var f=this.e||(this.e={});return(f[i]||(f[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var f=this;function c(){f.off(i,c),a.apply(s,arguments)}return c._=a,this.on(i,c,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),f=0,c=s.length;for(f;f{"use strict";/*! + * escape-html + * Copyright(c) 2012-2013 TJ Holowaychuk + * Copyright(c) 2015 Andreas Lubbe + * Copyright(c) 2015 Tiancheng "Timothy" Gu + * MIT Licensed + */var is=/["'&<>]/;Jo.exports=as;function as(e){var t=""+e,r=is.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i0&&i[i.length-1])&&(c[0]===6||c[0]===2)){r=0;continue}if(c[0]===3&&(!i||c[1]>i[0]&&c[1]=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function W(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function D(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n1||s(m,d)})})}function s(m,d){try{f(n[m](d))}catch(h){p(i[0][3],h)}}function f(m){m.value instanceof Xe?Promise.resolve(m.value.v).then(c,u):p(i[0][2],m)}function c(m){s("next",m)}function u(m){s("throw",m)}function p(m,d){m(d),i.shift(),i.length&&s(i[0][0],i[0][1])}}function mn(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof xe=="function"?xe(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,f){a=e[i](a),o(s,f,a.done,a.value)})}}function o(i,a,s,f){Promise.resolve(f).then(function(c){i({value:c,done:s})},a)}}function A(e){return typeof e=="function"}function at(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var $t=at(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription: +`+r.map(function(n,o){return o+1+") "+n.toString()}).join(` + `):"",this.name="UnsubscriptionError",this.errors=r}});function De(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var Fe=function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=xe(a),f=s.next();!f.done;f=s.next()){var c=f.value;c.remove(this)}}catch(v){t={error:v}}finally{try{f&&!f.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(A(u))try{u()}catch(v){i=v instanceof $t?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var m=xe(p),d=m.next();!d.done;d=m.next()){var h=d.value;try{dn(h)}catch(v){i=i!=null?i:[],v instanceof $t?i=D(D([],W(i)),W(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{d&&!d.done&&(o=m.return)&&o.call(m)}finally{if(n)throw n.error}}}if(i)throw new $t(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)dn(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&De(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&De(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=function(){var t=new e;return t.closed=!0,t}(),e}();var Or=Fe.EMPTY;function It(e){return e instanceof Fe||e&&"closed"in e&&A(e.remove)&&A(e.add)&&A(e.unsubscribe)}function dn(e){A(e)?e():e.unsubscribe()}var Ae={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var st={setTimeout:function(e,t){for(var r=[],n=2;n0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Or:(this.currentObservers=null,s.push(r),new Fe(function(){n.currentObservers=null,De(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new wn(r,n)},t}(U);var wn=function(e){ne(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Or},t}(E);var Et={now:function(){return(Et.delegate||Date).now()},delegate:void 0};var wt=function(e){ne(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=Et);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,f=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+f)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),f=0;f0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=ut.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(ut.cancelAnimationFrame(n),r._scheduled=void 0)},t}(Ut);var On=function(e){ne(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n=this._scheduled;this._scheduled=void 0;var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t}(Wt);var we=new On(Tn);var R=new U(function(e){return e.complete()});function Dt(e){return e&&A(e.schedule)}function kr(e){return e[e.length-1]}function Qe(e){return A(kr(e))?e.pop():void 0}function Se(e){return Dt(kr(e))?e.pop():void 0}function Vt(e,t){return typeof kr(e)=="number"?e.pop():t}var pt=function(e){return e&&typeof e.length=="number"&&typeof e!="function"};function zt(e){return A(e==null?void 0:e.then)}function Nt(e){return A(e[ft])}function qt(e){return Symbol.asyncIterator&&A(e==null?void 0:e[Symbol.asyncIterator])}function Kt(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Ki(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qt=Ki();function Yt(e){return A(e==null?void 0:e[Qt])}function Gt(e){return ln(this,arguments,function(){var r,n,o,i;return Pt(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,Xe(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,Xe(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,Xe(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function Bt(e){return A(e==null?void 0:e.getReader)}function $(e){if(e instanceof U)return e;if(e!=null){if(Nt(e))return Qi(e);if(pt(e))return Yi(e);if(zt(e))return Gi(e);if(qt(e))return _n(e);if(Yt(e))return Bi(e);if(Bt(e))return Ji(e)}throw Kt(e)}function Qi(e){return new U(function(t){var r=e[ft]();if(A(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Yi(e){return new U(function(t){for(var r=0;r=2;return function(n){return n.pipe(e?_(function(o,i){return e(o,i,n)}):me,Oe(1),r?He(t):zn(function(){return new Xt}))}}function Nn(){for(var e=[],t=0;t=2,!0))}function fe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new E}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,f=s===void 0?!0:s;return function(c){var u,p,m,d=0,h=!1,v=!1,B=function(){p==null||p.unsubscribe(),p=void 0},re=function(){B(),u=m=void 0,h=v=!1},z=function(){var T=u;re(),T==null||T.unsubscribe()};return g(function(T,Ke){d++,!v&&!h&&B();var We=m=m!=null?m:r();Ke.add(function(){d--,d===0&&!v&&!h&&(p=jr(z,f))}),We.subscribe(Ke),!u&&d>0&&(u=new et({next:function(Ie){return We.next(Ie)},error:function(Ie){v=!0,B(),p=jr(re,o,Ie),We.error(Ie)},complete:function(){h=!0,B(),p=jr(re,a),We.complete()}}),$(T).subscribe(u))})(c)}}function jr(e,t){for(var r=[],n=2;ne.next(document)),e}function K(e,t=document){return Array.from(t.querySelectorAll(e))}function V(e,t=document){let r=se(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function se(e,t=document){return t.querySelector(e)||void 0}function _e(){return document.activeElement instanceof HTMLElement&&document.activeElement||void 0}function tr(e){return L(b(document.body,"focusin"),b(document.body,"focusout")).pipe(ke(1),l(()=>{let t=_e();return typeof t!="undefined"?e.contains(t):!1}),N(e===_e()),Y())}function Be(e){return{x:e.offsetLeft,y:e.offsetTop}}function Yn(e){return L(b(window,"load"),b(window,"resize")).pipe(Ce(0,we),l(()=>Be(e)),N(Be(e)))}function rr(e){return{x:e.scrollLeft,y:e.scrollTop}}function dt(e){return L(b(e,"scroll"),b(window,"resize")).pipe(Ce(0,we),l(()=>rr(e)),N(rr(e)))}var Bn=function(){if(typeof Map!="undefined")return Map;function e(t,r){var n=-1;return t.some(function(o,i){return o[0]===r?(n=i,!0):!1}),n}return function(){function t(){this.__entries__=[]}return Object.defineProperty(t.prototype,"size",{get:function(){return this.__entries__.length},enumerable:!0,configurable:!0}),t.prototype.get=function(r){var n=e(this.__entries__,r),o=this.__entries__[n];return o&&o[1]},t.prototype.set=function(r,n){var o=e(this.__entries__,r);~o?this.__entries__[o][1]=n:this.__entries__.push([r,n])},t.prototype.delete=function(r){var n=this.__entries__,o=e(n,r);~o&&n.splice(o,1)},t.prototype.has=function(r){return!!~e(this.__entries__,r)},t.prototype.clear=function(){this.__entries__.splice(0)},t.prototype.forEach=function(r,n){n===void 0&&(n=null);for(var o=0,i=this.__entries__;o0},e.prototype.connect_=function(){!zr||this.connected_||(document.addEventListener("transitionend",this.onTransitionEnd_),window.addEventListener("resize",this.refresh),xa?(this.mutationsObserver_=new MutationObserver(this.refresh),this.mutationsObserver_.observe(document,{attributes:!0,childList:!0,characterData:!0,subtree:!0})):(document.addEventListener("DOMSubtreeModified",this.refresh),this.mutationEventsAdded_=!0),this.connected_=!0)},e.prototype.disconnect_=function(){!zr||!this.connected_||(document.removeEventListener("transitionend",this.onTransitionEnd_),window.removeEventListener("resize",this.refresh),this.mutationsObserver_&&this.mutationsObserver_.disconnect(),this.mutationEventsAdded_&&document.removeEventListener("DOMSubtreeModified",this.refresh),this.mutationsObserver_=null,this.mutationEventsAdded_=!1,this.connected_=!1)},e.prototype.onTransitionEnd_=function(t){var r=t.propertyName,n=r===void 0?"":r,o=ya.some(function(i){return!!~n.indexOf(i)});o&&this.refresh()},e.getInstance=function(){return this.instance_||(this.instance_=new e),this.instance_},e.instance_=null,e}(),Jn=function(e,t){for(var r=0,n=Object.keys(t);r0},e}(),Zn=typeof WeakMap!="undefined"?new WeakMap:new Bn,eo=function(){function e(t){if(!(this instanceof e))throw new TypeError("Cannot call a class as a function.");if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");var r=Ea.getInstance(),n=new Ra(t,r,this);Zn.set(this,n)}return e}();["observe","unobserve","disconnect"].forEach(function(e){eo.prototype[e]=function(){var t;return(t=Zn.get(this))[e].apply(t,arguments)}});var ka=function(){return typeof nr.ResizeObserver!="undefined"?nr.ResizeObserver:eo}(),to=ka;var ro=new E,Ha=I(()=>H(new to(e=>{for(let t of e)ro.next(t)}))).pipe(x(e=>L(Te,H(e)).pipe(C(()=>e.disconnect()))),J(1));function de(e){return{width:e.offsetWidth,height:e.offsetHeight}}function ge(e){return Ha.pipe(S(t=>t.observe(e)),x(t=>ro.pipe(_(({target:r})=>r===e),C(()=>t.unobserve(e)),l(()=>de(e)))),N(de(e)))}function bt(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ar(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}var no=new E,Pa=I(()=>H(new IntersectionObserver(e=>{for(let t of e)no.next(t)},{threshold:0}))).pipe(x(e=>L(Te,H(e)).pipe(C(()=>e.disconnect()))),J(1));function sr(e){return Pa.pipe(S(t=>t.observe(e)),x(t=>no.pipe(_(({target:r})=>r===e),C(()=>t.unobserve(e)),l(({isIntersecting:r})=>r))))}function oo(e,t=16){return dt(e).pipe(l(({y:r})=>{let n=de(e),o=bt(e);return r>=o.height-n.height-t}),Y())}var cr={drawer:V("[data-md-toggle=drawer]"),search:V("[data-md-toggle=search]")};function io(e){return cr[e].checked}function qe(e,t){cr[e].checked!==t&&cr[e].click()}function je(e){let t=cr[e];return b(t,"change").pipe(l(()=>t.checked),N(t.checked))}function $a(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function Ia(){return L(b(window,"compositionstart").pipe(l(()=>!0)),b(window,"compositionend").pipe(l(()=>!1))).pipe(N(!1))}function ao(){let e=b(window,"keydown").pipe(_(t=>!(t.metaKey||t.ctrlKey)),l(t=>({mode:io("search")?"search":"global",type:t.key,claim(){t.preventDefault(),t.stopPropagation()}})),_(({mode:t,type:r})=>{if(t==="global"){let n=_e();if(typeof n!="undefined")return!$a(n,r)}return!0}),fe());return Ia().pipe(x(t=>t?R:e))}function Me(){return new URL(location.href)}function ot(e){location.href=e.href}function so(){return new E}function co(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)co(e,r)}function M(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)co(n,o);return n}function fr(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function fo(){return location.hash.substring(1)}function uo(e){let t=M("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function Fa(){return b(window,"hashchange").pipe(l(fo),N(fo()),_(e=>e.length>0),J(1))}function po(){return Fa().pipe(l(e=>se(`[id="${e}"]`)),_(e=>typeof e!="undefined"))}function Nr(e){let t=matchMedia(e);return Zt(r=>t.addListener(()=>r(t.matches))).pipe(N(t.matches))}function lo(){let e=matchMedia("print");return L(b(window,"beforeprint").pipe(l(()=>!0)),b(window,"afterprint").pipe(l(()=>!1))).pipe(N(e.matches))}function qr(e,t){return e.pipe(x(r=>r?t():R))}function ur(e,t={credentials:"same-origin"}){return ve(fetch(`${e}`,t)).pipe(ce(()=>R),x(r=>r.status!==200?Tt(()=>new Error(r.statusText)):H(r)))}function Ue(e,t){return ur(e,t).pipe(x(r=>r.json()),J(1))}function mo(e,t){let r=new DOMParser;return ur(e,t).pipe(x(n=>n.text()),l(n=>r.parseFromString(n,"text/xml")),J(1))}function pr(e){let t=M("script",{src:e});return I(()=>(document.head.appendChild(t),L(b(t,"load"),b(t,"error").pipe(x(()=>Tt(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(l(()=>{}),C(()=>document.head.removeChild(t)),Oe(1))))}function ho(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function bo(){return L(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(l(ho),N(ho()))}function vo(){return{width:innerWidth,height:innerHeight}}function go(){return b(window,"resize",{passive:!0}).pipe(l(vo),N(vo()))}function yo(){return Q([bo(),go()]).pipe(l(([e,t])=>({offset:e,size:t})),J(1))}function lr(e,{viewport$:t,header$:r}){let n=t.pipe(X("size")),o=Q([n,r]).pipe(l(()=>Be(e)));return Q([r,t,o]).pipe(l(([{height:i},{offset:a,size:s},{x:f,y:c}])=>({offset:{x:a.x-f,y:a.y-c+i},size:s})))}(()=>{function e(n,o){parent.postMessage(n,o||"*")}function t(...n){return n.reduce((o,i)=>o.then(()=>new Promise(a=>{let s=document.createElement("script");s.src=i,s.onload=a,document.body.appendChild(s)})),Promise.resolve())}var r=class{constructor(n){this.url=n,this.onerror=null,this.onmessage=null,this.onmessageerror=null,this.m=a=>{a.source===this.w&&(a.stopImmediatePropagation(),this.dispatchEvent(new MessageEvent("message",{data:a.data})),this.onmessage&&this.onmessage(a))},this.e=(a,s,f,c,u)=>{if(s===this.url.toString()){let p=new ErrorEvent("error",{message:a,filename:s,lineno:f,colno:c,error:u});this.dispatchEvent(p),this.onerror&&this.onerror(p)}};let o=new EventTarget;this.addEventListener=o.addEventListener.bind(o),this.removeEventListener=o.removeEventListener.bind(o),this.dispatchEvent=o.dispatchEvent.bind(o);let i=document.createElement("iframe");i.width=i.height=i.frameBorder="0",document.body.appendChild(this.iframe=i),this.w.document.open(),this.w.document.write(` + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'abi' Dialect

+

A vast ABI dialect. +Dialect provides operations to describe how arguments and return values +are transformed to better model target abi.

+
+ +
+

Operation definition

+

abi.call (::vast::abi::CallOp)

+

ABI call operation

+

Syntax:

+
operation ::= `abi.call` $callee `(` $args `)` attr-dict `:` functional-type( $args, $results )
+
+

ABI call operation +Interfaces: CallOpInterface

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
callee::mlir::FlatSymbolRefAttrflat symbol reference attribute
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

abi.call_args (::vast::abi::CallArgsOp)

+

Not implement yet.

+

Syntax:

+
operation ::= `abi.call_args` $body attr-dict `:` type($results)
+
+

WIP

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

abi.call_exec (::vast::abi::CallExecutionOp)

+

WIP

+

Syntax:

+
operation ::= `abi.call_exec` $callee `(` $args `)` $body attr-dict `:` functional-type($args, $result)
+
+

WIP +Interfaces: CallOpInterface

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
callee::mlir::FlatSymbolRefAttrflat symbol reference attribute
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

abi.call_rets (::vast::abi::CallRetsOp)

+

Not implement yet.

+

Syntax:

+
operation ::= `abi.call_rets` $body attr-dict `:` type($results)
+
+

WIP

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

abi.direct (::vast::abi::DirectOp)

+

Pass value directly - usually means by register

+

Syntax:

+
operation ::= `abi.direct` $value attr-dict `:` type($value) `->` type($result)
+
+

Pass value directly - usually means by register.

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

abi.epilogue (::vast::abi::EpilogueOp)

+

WIP

+

Syntax:

+
operation ::= `abi.epilogue` $body attr-dict `:` type($results)
+
+

WIP

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

abi.func (::vast::abi::FuncOp)

+

_ Function with transformed type. _

+

Syntax:

+
operation ::= `abi.func` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)
+
+

Placeholder.

+

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

+

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of function type
linkage::vast::core::GlobalLinkageKindAttrglobal linkage kind
sym_visibility::mlir::StringAttrstring attribute
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
+

abi.indirect (::vast::abi::IndirectOp)

+

Value is passed indirectly via memory

+

Syntax:

+
operation ::= `abi.indirect` $value attr-dict `:` type($value) `->` type($result)
+
+

Value is passed indirectly via memory

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

abi.prologue (::vast::abi::PrologueOp)

+

WIP

+

Syntax:

+
operation ::= `abi.prologue` $body attr-dict `:` type($results)
+
+

WIP

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

abi.ret_direct (::vast::abi::RetDirectOp)

+

Value is returned directly.

+

Syntax:

+
operation ::= `abi.ret_direct` $value attr-dict `:` type($value) `->` type($result)
+
+

Value is returned directly.

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

abi.todo (::vast::abi::TodoOp)

+

Not implement yet.

+

Syntax:

+
operation ::= `abi.todo` $value attr-dict `:` type($value) `->` type($result)
+
+

Not implemented yet

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

abi.wrap_fn (::vast::abi::WrapFuncOp)

+

_ Function that defines abi transformation of args. _

+

Syntax:

+
operation ::= `abi.wrap_fn` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)
+
+

Placeholder.

+

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

+

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of function type
linkage::vast::core::GlobalLinkageKindAttrglobal linkage kind
sym_visibility::mlir::StringAttrstring attribute
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
+

abi.yield (::vast::abi::YieldOp)

+

WIP

+

Syntax:

+
operation ::= `abi.yield` $values attr-dict `:` type($values) `->` type($result)
+
+

WIP +Traits: Terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valuesany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/Core/Core/index.html b/dialects/Core/Core/index.html new file mode 100644 index 0000000000..b34f16d583 --- /dev/null +++ b/dialects/Core/Core/index.html @@ -0,0 +1,2114 @@ + + + + + + + + + + + + + + + + + + + + + + Core - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'core' Dialect

+

Utility dialect to provide common features for other dialects. +Dialect providing features that may be used by other dialects. +These features can be used by including "vast/Dialect/Core/Utils.td" +It also provides lazy.op for lazy evaluation of expressions and +binary logical operations that make use of it.

+
+ +
+

Operation definition

+

core.bin.land (::vast::core::BinLAndOp)

+

VAST core dialect logical binary operation

+

Syntax:

+
operation ::= `core.bin.land` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

Core dialect logical binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : type

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

core.bin.lor (::vast::core::BinLOrOp)

+

VAST core dialect logical binary operation

+

Syntax:

+
operation ::= `core.bin.lor` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

Core dialect logical binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : type

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

core.implicit.return (::vast::core::ImplicitReturnOp)

+

VAST implicit return

+

Syntax:

+
operation ::= `core.implicit.return` $result `:` type($result) attr-dict
+
+

Op representing return that wasn't explicitely written in the source (e.g. in void fun(){}).

+

Traits: return_trait, soft_terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

core.lazy.op (::vast::core::LazyOp)

+

Lazily evaluate a region.

+

Syntax:

+
operation ::= `core.lazy.op` $lazy attr-dict `:` type(results)
+
+

The operation serves to encapsulate delayed evaluation in its region.

+

Traits: NoTerminator

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

core.scope (::vast::core::ScopeOp)

+

VAST scope declaration

+

Syntax:

+
operation ::= `core.scope` $body attr-dict
+
+

Scope operation servers to represent explicitly high-level code scope. +Other control flow operations represent scopes implicitly. It is a +single-region operation.

+

Traits: NoTerminator

+

Interfaces: RegionKindInterface

+

core.select (::vast::core::SelectOp)

+

Select a value based on condition.

+

Syntax:

+
operation ::= `core.select` $cond `,` $thenRegion `,` $elseRegion attr-dict `:` functional-type(operands, results)
+
+

Usual select operation. First operand is selected if predicate is true, second +otherwise (to mirror how ternary works in C).

+

%result = %cond %lhs, %rhs : type

+

Operands:

+ + + + + + + + + + + + + + + + + + + + + +
OperandDescription
condany type
thenRegionany type
elseRegionany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

Attribute definition

+

BooleanAttr

+

An Attribute containing a boolean value

+

Syntax:

+
#core.bool<
+  ::mlir::Type,   # type
+  bool   # value
+>
+
+

An boolean attribute is a literal attribute that represents a boolean value.

+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
type::mlir::Type
valuebool
+

GlobalLinkageKindAttr

+

Linkage type/kind

+

Syntax:

+
#core.global_linkage_kind<
+  ::vast::core::GlobalLinkageKind   # value
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
value::vast::core::GlobalLinkageKindan enum of type GlobalLinkageKind
+

FloatAttr

+

An Attribute containing a floating point value

+

Syntax:

+
#core.float<
+  ::mlir::Type,   # type
+  ::llvm::APFloat   # value
+>
+
+

A float attribute is a literal attribute that represents a floating point +value of the specified floating point type.

+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
type::mlir::Type
value::llvm::APFloat
+

IntegerAttr

+

An Attribute containing a integer value

+

Syntax:

+
#core.integer<
+  ::mlir::Type,   # type
+  ::llvm::APSInt   # value
+>
+
+

An integer attribute is a literal attribute that represents an integral +value of the specified integer type.

+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
type::mlir::Type
value::llvm::APSInt
+

SourceLanguageAttr

+

Module source language

+

Syntax:

+
#core.lang<
+  ::vast::core::SourceLanguage   # value
+>
+
+

Represents the source language used to generate the module.

+

Example:

+
// Module compiled from C.
+module attributes {vast.core.lang = vast.core.lang<c>} {}
+// Module compiled from C++.
+module attributes {vast.core.lang = vast.core.lang<cxx>} {}
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
value::vast::core::SourceLanguagean enum of type SourceLanguage
+

VoidAttr

+

Attribute to represent void value.

+

Syntax:

+
#core.void<
+  ::mlir::Type   # type
+>
+
+

The VoidAttr is used to return void from statements uniformly.

+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
type::mlir::Type
+

Type definition

+

FunctionType

+

Vast function type

+

Syntax:

+
!core.fn<
+  ::llvm::ArrayRef<Type>,   # inputs
+  ::llvm::ArrayRef<Type>,   # results
+  bool   # varArg
+>
+
+

The !core.fn is a function type. It consists of a variadic return type, +and list of parameter types and can optionally be variadic.

+

Example:

+
!core.fn<!hl.bool ()>
+!core.fn<!hl.int (!hl.char, !hl.char)>
+!core.fn<!i32 (!i32, ...)>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
inputs::llvm::ArrayRef<Type>
results::llvm::ArrayRef<Type>
varArgbool
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/HighLevel/HighLevel/index.html b/dialects/HighLevel/HighLevel/index.html new file mode 100644 index 0000000000..c534529429 --- /dev/null +++ b/dialects/HighLevel/HighLevel/index.html @@ -0,0 +1,13887 @@ + + + + + + + + + + + + + + + + + + + + + + High Level - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'hl' Dialect

+

A high-level verbose program analysis MLIR dialect. +This dialect intends capture highevel constructs of C/C++ +for further program analysis.

+
+ +
+

Operation definition

+

hl.access (::vast::hl::AccessSpecifierOp)

+

VAST C++ access specifier declaration

+

Syntax:

+
operation ::= `hl.access` attr-dict $spec
+
+

VAST C++ access specifier declaration

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
spec::vast::hl::AccessSpecifierAttrAccess specifier
+

hl.add (::vast::hl::AddIOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.add` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Traits: Commutative

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.addressof (::vast::hl::AddressOf)

+

VAST addressof operation

+

Syntax:

+
operation ::= `hl.addressof` $value attr-dict `:` type($value) `->` type($result)
+
+

VAST addressof operation

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valuelvalue to any type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.alignof.expr (::vast::hl::AlignOfExprOp)

+

VAST expr alignof operator

+

Syntax:

+
operation ::= `hl.alignof.expr` attr-dict `->` type($result) $expr
+
+

VAST expr alignof operator

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.alignof.type (::vast::hl::AlignOfTypeOp)

+

VAST type alignof operator

+

Syntax:

+
operation ::= `hl.alignof.type` $arg attr-dict `->` type($result)
+
+

VAST type alignof operator

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
arg::mlir::TypeAttrany type attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.asm (::vast::hl::AsmOp)

+

VAST operation for inline assembly

+

Syntax:

+
operation ::= `hl.asm` attr-dict $asm_template `(`($output_names $asm_outputs^ `:` $output_constraints)? `)` `(` (`ins` `:`$input_names $asm_inputs^ `:` $input_constraints)? `)` `(`( $clobbers^)?`)` `(`( $labels^)?`)` `:` functional-type(operands, results)
+
+

VAST operation mirroring the GCCAsmStmt in clang AST. It prints + a name for every operand (either its id or user-supplied string). +Traits: AttrSizedOperandSegments

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
asm_template::mlir::StringAttrstring attribute
is_volatile::mlir::UnitAttrunit attribute
has_goto::mlir::UnitAttrunit attribute
output_names::mlir::ArrayAttrarray attribute
input_names::mlir::ArrayAttrarray attribute
output_constraints::mlir::ArrayAttrarray attribute
input_constraints::mlir::ArrayAttrarray attribute
clobbers::mlir::ArrayAttrarray attribute
+

Operands:

+ + + + + + + + + + + + + + + + + + + + + +
OperandDescription
asm_outputsany type
asm_inputsany type
labelsany type
+

hl.assign (::vast::hl::AssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.add (::vast::hl::AddIAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.add` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.bin.and (::vast::hl::BinAndAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.and` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.bin.ashr (::vast::hl::BinAShrAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.ashr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to integer like type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.assign.bin.lshr (::vast::hl::BinLShrAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.lshr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to integer like type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.assign.bin.or (::vast::hl::BinOrAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.or` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.bin.shl (::vast::hl::BinShlAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.shl` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to integer like type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.assign.bin.xor (::vast::hl::BinXorAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.bin.xor` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.fadd (::vast::hl::AddFAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.fadd` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.fdiv (::vast::hl::DivFAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.fdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.fmul (::vast::hl::MulFAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.fmul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.frem (::vast::hl::RemFAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.frem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.fsub (::vast::hl::SubFAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.fsub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.mul (::vast::hl::MulIAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.mul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.sdiv (::vast::hl::DivSAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.sdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.srem (::vast::hl::RemSAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.srem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.sub (::vast::hl::SubIAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.sub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.udiv (::vast::hl::DivUAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.udiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.assign.urem (::vast::hl::RemUAssignOp)

+

VAST compound assign operation

+

Syntax:

+
operation ::= `hl.assign.urem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)
+
+

A compound assign operation represents an assignment operation joined +with an arithmetic operation. It requires the same types for both source +and destination arguments.

+

The custom assembly form of the operation is as follows:

+

%result = src to dst : functional-type(operands, results)

+

It represents C compound assignment statement:

+

dst = src;

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
srclvalue to any type
dstany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.base (::vast::hl::CxxBaseSpecifierOp)

+

VAST base class specifier

+

Syntax:

+
operation ::= `hl.base` $type attr-dict $access (`virtual` $is_virtual^)?
+
+

VAST base class specifier +Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
type::mlir::TypeAttrany type attribute
access::vast::hl::AccessSpecifierAttrAccess specifier
is_virtual::mlir::UnitAttrunit attribute
+

hl.bin.and (::vast::hl::BinAndOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.bin.and` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.bin.ashr (::vast::hl::BinAShrOp)

+

VAST binary shift operation

+

Syntax:

+
operation ::= `hl.bin.ashr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level binary shift operation. This operation takes two operands +and returns one result.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsinteger like type
rhsinteger like type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.bin.comma (::vast::hl::BinComma)

+

VAST binary operation

+

Syntax:

+
operation ::= `hl.bin.comma` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.bin.land (::vast::hl::BinLAndOp)

+

VAST logical binary operation

+

Syntax:

+
operation ::= `hl.bin.land` $lhs`,` $rhs attr-dict `:` type(results)
+
+

High-level logical binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : type

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.bin.lor (::vast::hl::BinLOrOp)

+

VAST logical binary operation

+

Syntax:

+
operation ::= `hl.bin.lor` $lhs`,` $rhs attr-dict `:` type(results)
+
+

High-level logical binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : type

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.bin.lshr (::vast::hl::BinLShrOp)

+

VAST binary shift operation

+

Syntax:

+
operation ::= `hl.bin.lshr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level binary shift operation. This operation takes two operands +and returns one result.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsinteger like type
rhsinteger like type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.bin.or (::vast::hl::BinOrOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.bin.or` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.bin.shl (::vast::hl::BinShlOp)

+

VAST binary shift operation

+

Syntax:

+
operation ::= `hl.bin.shl` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level binary shift operation. This operation takes two operands +and returns one result.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsinteger like type
rhsinteger like type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.bin.xor (::vast::hl::BinXorOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.bin.xor` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.break (::vast::hl::BreakOp)

+

VAST break statement

+

Syntax:

+
operation ::= `hl.break` attr-dict
+
+

VAST break statement +Traits: NoRegionArguments, NoTerminator, soft_terminator

+

Interfaces: RegionKindInterface

+

hl.builtin_bitcast (::vast::hl::BuiltinBitCastOp)

+

VAST cast operation

+

Syntax:

+
operation ::= `hl.builtin_bitcast` $value $kind attr-dict `:` type($value) `->` type($result)
+
+

VAST cast operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
kind::vast::hl::CastKindAttrcast kind
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.call (::vast::hl::CallOp)

+

VAST call operation

+

Syntax:

+
operation ::= `hl.call` $callee `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )
+
+

VAST call operation +Interfaces: CallOpInterface

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
callee::mlir::FlatSymbolRefAttrflat symbol reference attribute
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argOperandsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

hl.case (::vast::hl::CaseOp)

+

VAST case statement

+

Syntax:

+
operation ::= `hl.case` $lhs $body attr-dict
+
+

The operation represents a single case of a switch statement.

+

The generic form of the operation is as follows:

+

hl.case { + ... / lhs/check region / + hl.value.yield %val : !hl.type +} { + ... / body region / +}

+

It represents a C statement of form case lhs: body;.

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.class (::vast::hl::ClassDeclOp)

+

VAST C++ class declaration

+

Syntax:

+
operation ::= `hl.class` $name attr-dict `:` `bases` $bases $fields
+
+

VAST C++ class declaration +Traits: NoTerminator

+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

hl.cmp (::vast::hl::CmpOp)

+

VAST comparison operation

+

Syntax:

+
operation ::= `hl.cmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)
+
+

VAST comparison operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
predicate::vast::hl::PredicateAttrcomparison predicate
+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultbool or integer like type
+

hl.cond (::vast::hl::CondOp)

+

VAST conditional statement

+

Syntax:

+
operation ::= `hl.cond` $condRegion `?` $thenRegion `:` $elseRegion attr-dict `:` type(results)
+
+

The operation takes builders of three regions -- condition, true branch and false branch. +Builders, given the location, build a particular region.

+

The generic form of the operation is as follows:

+

hl.cond { + ... / condition region / + hl.cond.yield %cond : !hl.bool +} ? { + ... / true region / +} : { + ... / false region / +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.cond.yield (::vast::hl::CondYieldOp)

+

Condition yield operation

+

Syntax:

+
operation ::= `hl.cond.yield` attr-dict $result `:` type($result)
+
+

A condition yield operation is used to terminate the region representing +condition expression of control flow operations IfOp, WhileOp, ForOp +and DoOp. It yields a boolean value for the conditional branch.

+

The custom assembly form of the operation is as follows:

+

hl.cond.yield result : BoolType

+

Traits: HasParent, Terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

hl.const (::vast::hl::ConstantOp)

+

VAST value constant

+

Syntax:

+
operation ::= `hl.const` $value attr-dict
+
+

VAST value constant +Traits: ConstantLike

+

Interfaces: InferTypeOpInterface

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
value::mlir::TypedAttrTypedAttr instance
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.continue (::vast::hl::ContinueOp)

+

VAST continue statement

+

Syntax:

+
operation ::= `hl.continue` attr-dict
+
+

VAST continue statement +Traits: NoRegionArguments, NoTerminator, soft_terminator

+

Interfaces: RegionKindInterface

+

hl.cstyle_cast (::vast::hl::CStyleCastOp)

+

VAST cast operation

+

Syntax:

+
operation ::= `hl.cstyle_cast` $value $kind attr-dict `:` type($value) `->` type($result)
+
+

VAST cast operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
kind::vast::hl::CastKindAttrcast kind
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.cxxstruct (::vast::hl::CxxStructDeclOp)

+

VAST C++ struct declaration

+

Syntax:

+
operation ::= `hl.cxxstruct` $name attr-dict `:` `bases` $bases $fields
+
+

VAST C++ struct declaration +Traits: NoTerminator

+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

hl.default (::vast::hl::DefaultOp)

+

VAST default statement

+

Syntax:

+
operation ::= `hl.default` $body attr-dict
+
+

VAST default statement +Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.deref (::vast::hl::Deref)

+

VAST deref operation

+

Syntax:

+
operation ::= `hl.deref` $addr attr-dict `:` type($addr) `->` type($result)
+
+

VAST deref operation

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
addrany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultlvalue to any type
+

hl.do (::vast::hl::DoOp)

+

VAST do-while statement

+

Syntax:

+
operation ::= `hl.do` $bodyRegion `while` $condRegion attr-dict
+
+

The operation represents a do-while statement.

+

The generic form of the operation is as follows:

+

hl.do { + ... / body region / +} cond { + ... / cond region / + hl.cond.yield %cond : !hl.bool +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.empty.decl (::vast::hl::EmptyDeclOp)

+

Syntax:

+
operation ::= `hl.empty.decl` attr-dict
+
+

hl.enum (::vast::hl::EnumDeclOp)

+

VAST enum declaration

+

Syntax:

+
operation ::= `hl.enum` $name attr-dict `:` ($type^ $constants)?
+
+

Enum declaration serves to declare region for enum constant declarations. +It also defines an underlying type.

+

Traits: NoTerminator

+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
+

hl.enum.const (::vast::hl::EnumConstantOp)

+

VAST enum constant declaration

+

Syntax:

+
operation ::= `hl.enum.const` $name `=` $value attr-dict (`init` $init^)?
+
+

Enumeration constant servers to link name to an enum value. +It is required to be scoped in Enum operation. For example:

+
hl.enum.const "F" = 2 : !hl.int
+
+

A constant can have a constant expression initializer:

+
hl.enum.const "G" = #core.integer<12> : !hl.int init  {
+  %0 = hl.enumref "F" : !hl.int
+  %1 = hl.enumref "C" : !hl.int
+  %2 = hl.add %0, %1 : !hl.int
+  hl.value.yield %2 : !hl.int
+}
+
+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
value::mlir::TypedAttrTypedAttr instance
+

hl.enumref (::vast::hl::EnumRefOp)

+

VAST variable reference declaration

+

Syntax:

+
operation ::= `hl.enumref` $value attr-dict `:` type($result)
+
+

VAST variable reference declaration

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
value::mlir::StringAttrstring attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.expr (::vast::hl::ExprOp)

+

VAST expression

+

Syntax:

+
operation ::= `hl.expr` attr-dict `:` type($result) $subexpr
+
+

VAST expression +Traits: SingleBlock

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.fadd (::vast::hl::AddFOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.fadd` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.fcmp (::vast::hl::FCmpOp)

+

VAST flaoting point comparison operation

+

Syntax:

+
operation ::= `hl.fcmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)
+
+

VAST floating point comparison operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
predicate::vast::hl::FPredicateAttrfloating point comparison predicate
+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsfloat like type
rhsfloat like type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultbool or integer like type
+

hl.fdiv (::vast::hl::DivFOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.fdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.field (::vast::hl::FieldDeclOp)

+

VAST record field declaration

+

Syntax:

+
operation ::= `hl.field` $name attr-dict (`bw` $bits^)? `:` $type
+
+

VAST record field declaration +Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
bits::mlir::IntegerAttr32-bit signless integer attribute
+

hl.fmul (::vast::hl::MulFOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.fmul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.for (::vast::hl::ForOp)

+

VAST for statement

+

Syntax:

+
operation ::= `hl.for` $condRegion `incr` $incrRegion attr-dict `do` $bodyRegion
+
+

Operation represents a for-loop statement.

+

The generic form of the operation is as follows:

+

hl.for { + ... / cond region / + hl.cond.yield %cond : !hl.bool +} incr { + ... / increment/update region / +} do { + ... / body region / +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.frem (::vast::hl::RemFOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.frem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.fsub (::vast::hl::SubFOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.fsub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.func (::vast::hl::FuncOp)

+

VAST function template

+

Syntax:

+
operation ::= `hl.func` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)
+
+

Inspired by cir::FuncOp and mlir::func::FuncOp:

+
+

Operations within the function cannot implicitly capture values defined +outside of the function, i.e. Functions are IsolatedFromAbove. All +external references must use function arguments or attributes that establish +a symbolic connection (e.g. symbols referenced by name via a string +attribute like SymbolRefAttr). An external function declaration (used when +referring to a function declared in some other module) has no body.

+
+

The function linkage information is specified by linkage, as defined by +GlobalLinkageKind attribute.

+

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

+

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of function type
linkage::vast::core::GlobalLinkageKindAttrglobal linkage kind
sym_visibility::mlir::StringAttrstring attribute
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
+

hl.funcref (::vast::hl::FuncRefOp)

+

VAST function reference declaration

+

Syntax:

+
operation ::= `hl.funcref` $function attr-dict `:` type($result)
+
+

VAST function reference declaration

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
function::mlir::FlatSymbolRefAttrflat symbol reference attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.globref (::vast::hl::GlobalRefOp)

+

VAST global variable reference declaration

+

Syntax:

+
operation ::= `hl.globref` $global attr-dict `:` type($result)
+
+

VAST global variable reference declaration

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
global::mlir::StringAttrstring attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.gnu.extension (::vast::hl::ExtensionOp)

+

VAST extension (__extension__) keyword

+

Syntax:

+
operation ::= `hl.gnu.extension` $value attr-dict `:` type($value) `->` type($result)
+
+

VAST op corresponding to GNU extension keyword.

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.goto (::vast::hl::GotoStmt)

+

Syntax:

+
operation ::= `hl.goto` $label attr-dict
+
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
label
+

hl.if (::vast::hl::IfOp)

+

VAST if statement

+

The operation takes builders of two mandatory regions -- condition and then +region -- and one builder optional region representing else block of C if statement. +Builders, given the location, build a particular region.

+

The generic form of the operation is as follows:

+

hl.if { + ... / condition region / + hl.cond.yield %cond : !hl.bool +} then { + ... / then region / +} else { + ... / else region / +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.implicit_cast (::vast::hl::ImplicitCastOp)

+

VAST cast operation

+

Syntax:

+
operation ::= `hl.implicit_cast` $value $kind attr-dict `:` type($value) `->` type($result)
+
+

VAST cast operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
kind::vast::hl::CastKindAttrcast kind
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.indirect_call (::vast::hl::IndirectCallOp)

+

VAST call operation

+

Syntax:

+
operation ::= `hl.indirect_call` $callee `:` type($callee)  `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )
+
+

VAST call operation +Interfaces: CallOpInterface

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
calleeany type
argOperandsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultsany type
+

hl.initlist (::vast::hl::InitListExpr)

+

VAST initializer list expression

+

Syntax:

+
operation ::= `hl.initlist` $elements attr-dict `:` functional-type($elements, results)
+
+

VAST initializer list expression

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
elementsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
«unnamed»any type
+

hl.label (::vast::hl::LabelStmt)

+

VAST control flow operation

+

Syntax:

+
operation ::= `hl.label` $label $body attr-dict
+
+

VAST control flow operation +Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
label
+

hl.label.decl (::vast::hl::LabelDeclOp)

+

Syntax:

+
operation ::= `hl.label.decl` $name attr-dict `:` type($result)
+
+

Interfaces: InferTypeOpInterface

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
result
+

hl.labeladdr (::vast::hl::AddrLabelExpr)

+

VAST address of label extension

+

Syntax:

+
operation ::= `hl.labeladdr` $label attr-dict `:` type($result)
+
+

VAST address of label extension

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
label
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultlvalue to pointer like type
+

hl.lnot (::vast::hl::LNotOp)

+

VAST unary logical operation

+

Syntax:

+
operation ::= `hl.lnot` $arg attr-dict `:` type($arg) `->` type($res)
+
+

High-level unary logical operation assures that +result has the right type.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type -> ret_type

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resbool or integer like type
+

hl.member (::vast::hl::RecordMemberOp)

+

VAST record element access operation

+

Syntax:

+
operation ::= `hl.member` $record `at` $name attr-dict `:` type($record) `->` type($element)
+
+

VAST record element access operation

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
recordany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
elementlvalue to any type
+

hl.minus (::vast::hl::MinusOp)

+

VAST unary type preserving operation

+

Syntax:

+
operation ::= `hl.minus` $arg attr-dict `:` type($result)
+
+

Type preserving high-level unary operation assures that argument and +result has the same type.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Traits: SameOperandsAndResultType

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.mul (::vast::hl::MulIOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.mul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Traits: Commutative

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.not (::vast::hl::NotOp)

+

VAST unary type preserving operation

+

Syntax:

+
operation ::= `hl.not` $arg attr-dict `:` type($result)
+
+

Type preserving high-level unary operation assures that argument and +result has the same type.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Traits: SameOperandsAndResultType

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.plus (::vast::hl::PlusOp)

+

VAST unary type preserving operation

+

Syntax:

+
operation ::= `hl.plus` $arg attr-dict `:` type($result)
+
+

Type preserving high-level unary operation assures that argument and +result has the same type.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Traits: SameOperandsAndResultType

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.post.dec (::vast::hl::PostDecOp)

+

VAST unary inplace operation

+

Syntax:

+
operation ::= `hl.post.dec` $arg attr-dict `:` type($arg) `->` type($result)
+
+

Inplace high-level unary operation changes its single argument in place. +It does not produce a new value.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
arglvalue to any type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.post.inc (::vast::hl::PostIncOp)

+

VAST unary inplace operation

+

Syntax:

+
operation ::= `hl.post.inc` $arg attr-dict `:` type($arg) `->` type($result)
+
+

Inplace high-level unary operation changes its single argument in place. +It does not produce a new value.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
arglvalue to any type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.pre.dec (::vast::hl::PreDecOp)

+

VAST unary inplace operation

+

Syntax:

+
operation ::= `hl.pre.dec` $arg attr-dict `:` type($arg) `->` type($result)
+
+

Inplace high-level unary operation changes its single argument in place. +It does not produce a new value.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
arglvalue to any type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.pre.inc (::vast::hl::PreIncOp)

+

VAST unary inplace operation

+

Syntax:

+
operation ::= `hl.pre.inc` $arg attr-dict `:` type($arg) `->` type($result)
+
+

Inplace high-level unary operation changes its single argument in place. +It does not produce a new value.

+

The custom assembly form of the operation is as follows:

+

%result = %arg : type

+

Interfaces: InferTypeOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
arglvalue to any type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.predefined.expr (::vast::hl::PredefinedExpr)

+

VAT predefined expr ( such as __func__ )

+

Syntax:

+
operation ::= `hl.predefined.expr` $value $kind attr-dict `:` type($value) `->` type($result)
+
+

VAT predefined expr ( such as func )

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
kind::vast::hl::IdentKindAttrident kind
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
valueany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.ref (::vast::hl::DeclRefOp)

+

VAST variable reference declaration

+

Syntax:

+
operation ::= `hl.ref` $decl attr-dict `:` functional-type(operands, results)
+
+

VAST variable reference declaration

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
declany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultlvalue to any type
+

hl.return (::vast::hl::ReturnOp)

+

Syntax:

+
operation ::= `hl.return` ($result^ `:` type($result))? attr-dict
+
+

Traits: return_trait, soft_terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

hl.sdiv (::vast::hl::DivSOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.sdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.sizeof.expr (::vast::hl::SizeOfExprOp)

+

VAST expr sizeof operator

+

Syntax:

+
operation ::= `hl.sizeof.expr` attr-dict `->` type($result) $expr
+
+

VAST expr sizeof operator

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.sizeof.type (::vast::hl::SizeOfTypeOp)

+

VAST type sizeof operator

+

Syntax:

+
operation ::= `hl.sizeof.type` $arg attr-dict `->` type($result)
+
+

VAST type sizeof operator

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
arg::mlir::TypeAttrany type attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultinteger like type
+

hl.skip (::vast::hl::SkipStmt)

+

VAST skip statement

+

Syntax:

+
operation ::= `hl.skip` attr-dict
+
+

VAST skip statement

+

hl.srem (::vast::hl::RemSOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.srem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.stmt.expr (::vast::hl::StmtExprOp)

+

VAST statement expression

+

Syntax:

+
operation ::= `hl.stmt.expr` attr-dict `:` type($result) $substmt
+
+

VAST statement expression +Traits: SingleBlock

+

Interfaces: RegionKindInterface

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.struct (::vast::hl::StructDeclOp)

+

VAST struct declaration

+

Syntax:

+
operation ::= `hl.struct` $name attr-dict `:` $fields
+
+

VAST struct declaration +Traits: NoTerminator

+

Interfaces: AggregateTypeDefinitionInterface, VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

hl.sub (::vast::hl::SubIOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.sub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.subscript (::vast::hl::SubscriptOp)

+

VAST array subscript operator

+

Syntax:

+
operation ::= `hl.subscript` $array `at` ` ` `[` $index `:` type($index) `]` attr-dict
+              `:` type($array) `->` type($result)
+
+

VAST array subscript operator

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
arraylvalue to subscriptable type
indexinteger like type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultlvalue to any type
+

hl.switch (::vast::hl::SwitchOp)

+

VAST switch statement

+

Syntax:

+
operation ::= `hl.switch` $condRegion `cases` $cases attr-dict
+
+

The operation represents a switch statement.

+

The generic form of the operation is as follows:

+

hl.switch { + ... / cond region / + hl.value.yield %val : !hl.type +} cases { + ... / casesregion / +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

hl.this (::vast::hl::ThisOp)

+

VAST this operator

+

Syntax:

+
operation ::= `hl.this` attr-dict `:` type($result)
+
+

VAST this operator

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.translation_unit (::vast::hl::TranslationUnitOp)

+

VAST translation unit

+

Syntax:

+
operation ::= `hl.translation_unit` $body attr-dict
+
+

VAST tranaslation unit +Traits: IsolatedFromAbove, NoTerminator, SymbolTable

+

hl.type (::vast::hl::TypeDeclOp)

+

VAST type declaration

+

Syntax:

+
operation ::= `hl.type` $name attr-dict
+
+

VAST type declaration +Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

hl.type.yield (::vast::hl::TypeYieldOp)

+

Type yield operation

+

Syntax:

+
operation ::= `hl.type.yield` attr-dict $result `:` type($result)
+
+

A type yield operation is used to terminate the underlying expression +region of a typeof(expr) statement.

+

The custom assembly form of the operation is as follows:

+

hl.type.yield result : type

+

Traits: Terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

hl.typedef (::vast::hl::TypeDefOp)

+

VAST typedef operation

+

Syntax:

+
operation ::= `hl.typedef` $name attr-dict `:` $type
+
+

Typedef operation servers to declare named types. +It creates a new type symbol in the current scope to +be referenced as NamedType later.

+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
+

hl.typeof.expr (::vast::hl::TypeOfExprOp)

+

VAST typeof(expr) operation

+

Syntax:

+
operation ::= `hl.typeof.expr` $name $expr `:` $type attr-dict
+
+

The Typeof operation serves to declare a type using type introspection. +It evaluates its underlying expression, creates a new type symbol in the +current scope, assigns it to the type of the underlying expression, and +returns the type symbol to be referenced later

+

Traits: SingleBlock

+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
type::mlir::TypeAttrany type attribute
+

hl.typeof.type (::vast::hl::TypeOfTypeOp)

+

VAST typeof(type) operation

+

Syntax:

+
operation ::= `hl.typeof.type` attr-dict `:` $type
+
+

Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
type::mlir::TypeAttrany type attribute
+

hl.udiv (::vast::hl::DivUOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.udiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.union (::vast::hl::UnionDeclOp)

+

VAST record declaration

+

Syntax:

+
operation ::= `hl.union` $name attr-dict `:` $fields
+
+

VAST record declaration +Traits: NoTerminator

+

Interfaces: AggregateTypeDefinitionInterface, VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

hl.unreachable (::vast::hl::UnreachableOp)

+

VAST unreachable operation

+

Syntax:

+
operation ::= `hl.unreachable` attr-dict
+
+

VAST unreachable operation +Traits: Terminator

+

hl.urem (::vast::hl::RemUOp)

+

VAST arithmetic binary operation

+

Syntax:

+
operation ::= `hl.urem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)
+
+

High-level arithmetic binary operation. This operation takes two operands +and returns one result, each of these is required to be of the same +type.

+

The custom assembly form of the operation is as follows:

+

%result = %lhs, %rhs : functional-type(operands, results)

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
lhsany type
rhsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.value.yield (::vast::hl::ValueYieldOp)

+

Value yield operation

+

Syntax:

+
operation ::= `hl.value.yield` attr-dict $result `:` type($result)
+
+

A value yield operation is used to terminate the case region of a switch +statement. The yielded value triggers the parent case statement region.

+

The custom assembly form of the operation is as follows:

+

hl.value.yield result : type

+

Traits: Terminator

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

hl.var (::vast::hl::VarDeclOp)

+

VAST variable declaration

+

Syntax:

+
operation ::= `hl.var` $name attr-dict ($storageClass^)? ($threadStorageClass^)? `:` type($result)
+              (`=` $initializer^)?
+              (`allocation_size` $allocation_size^)?
+
+

VAST variable declaration +Interfaces: VastSymbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
storageClass::vast::hl::StorageClassAttrstorage class
threadStorageClass::vast::hl::TSClassAttrthread storage class
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

hl.while (::vast::hl::WhileOp)

+

VAST while statement

+

Syntax:

+
operation ::= `hl.while` $condRegion `do` $bodyRegion attr-dict
+
+

The operation takes builders of two mandatory regions -- condition and body +region. Builders, given the location, build a particular region.

+

The generic form of the operation is as follows:

+

hl.while { + ... / condition region / + hl.cond.yield %cond : !hl.bool +} do { + ... / body region / +}

+

Traits: NoRegionArguments, NoTerminator

+

Interfaces: RegionKindInterface

+

Attribute definition

+

AllocAlignAttr

+

Syntax:

+
#hl.alloc_align<
+  int   # alignment
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
alignmentint
+

AllocSizeAttr

+

Syntax:

+
#hl.alloc_size<
+  int,   # size_arg_pos
+  int   # num_arg_pos
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
size_arg_posint
num_arg_posint
+

AnnotationAttr

+

Syntax:

+
#hl.annotation<
+  ::mlir::StringAttr   # name
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::mlir::StringAttr
+

AsmLabelAttr

+

Syntax:

+
#hl.asm<
+  ::mlir::StringAttr,   # label
+  bool   # isLiteral
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
label::mlir::StringAttr
isLiteralbool
+

BuiltinAttr

+

Syntax:

+
#hl.builtin<
+  unsigned   # ID
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
IDunsigned
+

CVQualifiersAttr

+

Syntax:

+
#hl.quals<
+  bool,   # is_const
+  bool   # is_volatile
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
is_constboolconst qualifier
is_volatileboolvolatile qualifier
+

CVRQualifiersAttr

+

Syntax:

+
#hl.quals<
+  bool,   # is_const
+  bool,   # is_volatile
+  bool   # is_restrict
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
is_constboolconst qualifier
is_volatileboolvolatile qualifier
is_restrictboolrestrict qualifier
+

ConstAttr

+

Syntax: #hl.const

+

FormatAttr

+

Syntax:

+
#hl.format<
+  ::mlir::StringAttr   # name
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::mlir::StringAttr
+

LoaderUninitializedAttr

+

Syntax: #hl.loader_uninitialized

+

ModeAttr

+

Syntax:

+
#hl.mode<
+  ::mlir::StringAttr   # mode
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
mode::mlir::StringAttr
+

NoInstrumentFunctionAttr

+

Syntax: #hl.no_instrument_function

+

NoThrowAttr

+

Syntax: #hl.nothrow

+

NonNullAttr

+

Syntax: #hl.nonnull

+

PackedAttr

+

Syntax: #hl.packed

+

PureAttr

+

Syntax: #hl.pure

+

RestrictAttr

+

Syntax: #hl.restrict

+

SectionAttr

+

Syntax:

+
#hl.section<
+  ::mlir::StringAttr   # name
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::mlir::StringAttr
+

UCVQualifiersAttr

+

Syntax:

+
#hl.quals<
+  bool,   # is_unsigned
+  bool,   # is_const
+  bool   # is_volatile
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
is_unsignedboolunsigned qualifier
is_constboolconst qualifier
is_volatileboolvolatile qualifier
+

WarnUnusedResultAttr

+

Syntax: #hl.warn_unused_result

+

Type definition

+

AdjustedType

+

Syntax:

+
!hl.adjusted<
+  Type,   # original
+  Type   # adjusted
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
originalType
adjustedType
+

ArrayType

+

Syntax:

+
!hl.array<
+  SizeParam,   # size
+  Type,   # elementType
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
sizeSizeParamsize parameter for arrays
elementTypeType
qualsCVRQualifiersAttr
+

AttributedType

+

Syntax:

+
!hl.attributed<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

BFloat16Type

+

Syntax:

+
!hl.bfloat16<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

BoolType

+

Syntax:

+
!hl.bool<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

CharType

+

Syntax:

+
!hl.char<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

DecayedType

+

Syntax:

+
!hl.decayed<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

DoubleType

+

Syntax:

+
!hl.double<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

ElaboratedType

+

Syntax:

+
!hl.elaborated<
+  Type,   # elementType
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
qualsCVRQualifiersAttr
+

EnumType

+

Syntax:

+
!hl.enum<
+  ::llvm::StringRef,   # name
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::llvm::StringRef
qualsCVQualifiersAttr
+

Float128Type

+

Syntax:

+
!hl.float128<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

FloatType

+

Syntax:

+
!hl.float<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

HalfType

+

Syntax:

+
!hl.half<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

Int128Type

+

Syntax:

+
!hl.int128<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

IntType

+

Syntax:

+
!hl.int<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

LValueType

+

Syntax:

+
!hl.lvalue<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

LabelType

+

Syntax: !hl.label

+

LongDoubleType

+

Syntax:

+
!hl.longdouble<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+

LongLongType

+

Syntax:

+
!hl.longlong<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

LongType

+

Syntax:

+
!hl.long<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

ParenType

+

Syntax:

+
!hl.paren<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

PointerType

+

Syntax:

+
!hl.ptr<
+  Type,   # elementType
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
qualsCVRQualifiersAttr
+

RValueType

+

Syntax:

+
!hl.rvalue<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

RecordType

+

Syntax:

+
!hl.record<
+  ::llvm::StringRef,   # name
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::llvm::StringRef
qualsCVQualifiersAttr
+

ReferenceType

+

Syntax:

+
!hl.reference<
+  Type   # elementType
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
elementTypeType
+

ShortType

+

Syntax:

+
!hl.short<
+  UCVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsUCVQualifiersAttr
+

TypeOfExprType

+

Syntax:

+
!hl.typeof.expr<
+  ::llvm::StringRef,   # name
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::llvm::StringRef
qualsCVRQualifiersAttr
+

TypeOfTypeType

+

Syntax:

+
!hl.typeof.type<
+  Type,   # unmodifiedType
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
unmodifiedTypeType
qualsCVRQualifiersAttr
+

TypedefType

+

Syntax:

+
!hl.typedef<
+  ::llvm::StringRef,   # name
+  CVRQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + + + + + + +
ParameterC++ typeDescription
name::llvm::StringRef
qualsCVRQualifiersAttr
+

VoidType

+

Syntax:

+
!hl.void<
+  CVQualifiersAttr   # quals
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
qualsCVQualifiersAttr
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/HighLevelPasses/index.html b/dialects/HighLevelPasses/index.html new file mode 100644 index 0000000000..aeaf531305 --- /dev/null +++ b/dialects/HighLevelPasses/index.html @@ -0,0 +1,1134 @@ + + + + + + + + + + + + + + + + + + + + + + High Level - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

High Level

+ + +

-vast-export-fn-info

+

Create JSON that exports information about function arguments.

+

Lowers module into llvm IR and dumps it on stderr.

+

Options

+
-o : Output JSON file to be created.
+
+

-vast-hl-dce

+

Trim dead code

+

Removes unreachable code, such as code after return or break/continue.

+

-vast-hl-lower-typedefs

+

Replace hl::TypeDef type by its underlying aliased type.

+

Replaces hl::TypeDef types by its underlying aliased types. +The conversion resolves nested typedefs.

+

All hl::TypeDef are marked illegal and converted by this pass.

+

-vast-hl-lower-types

+

Lower high-level types to standard types

+

Lower high-level types into standard types which is usually required first step +by other passes in the pipeline.

+

Information about bit sizes of high level types is inferred from the data layout of +the module, which is derived from the information provided by clang and emitted +automatically by vast-cc.

+

TODO: Named types are not yet supported.

+

-vast-hl-splice-trailing-scopes

+

Remove trailing hl::Scopes.

+

Removes trailing scopes.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/LowLevel/LowLevel/index.html b/dialects/LowLevel/LowLevel/index.html new file mode 100644 index 0000000000..5f9bb7b92b --- /dev/null +++ b/dialects/LowLevel/LowLevel/index.html @@ -0,0 +1,2146 @@ + + + + + + + + + + + + + + + + + + + + + + Low Level - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'll' Dialect

+

A vast low-level dialect. +This dialect serves as a bottom layer in VAST dialect tower. +There should always exist a pass that lowers this dialect into LLVM Dialect.

+

Work in progress - new operations are still being added and existing can be changed +or removed.

+
+ +
+

Operation definition

+

ll.br (::vast::ll::Br)

+

Direct branch.

+

Syntax:

+
operation ::= `ll.br` $dest (`(` $operands^ `:` type($operands) `)`)? attr-dict
+
+

Direct branch +Traits: Terminator

+

Interfaces: BranchOpInterface

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
operandsany type
+

Successors:

+ + + + + + + + + + + + + +
SuccessorDescription
destany successor
+

ll.concat (::vast::ll::Concat)

+

Concat integers together

+

Syntax:

+
operation ::= `ll.concat` operands attr-dict `:` functional-type(operands, results)
+
+

Concat operands together, where first argument occupies lsb.

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

ll.cond_br (::vast::ll::CondBr)

+

Conditional branch.

+

Syntax:

+
operation ::= `ll.cond_br` $cond `:` type($cond) `,`
+              $trueDest (`(` $trueOperands^ `:` type($trueOperands) `)`)? `,`
+              $falseDest (`(` $falseOperands^ `:` type($falseOperands) `)`)?
+              attr-dict
+
+

Direct branch +Traits: AttrSizedOperandSegments, Terminator

+

Operands:

+ + + + + + + + + + + + + + + + + + + + + +
OperandDescription
condany type
trueOperandsany type
falseOperandsany type
+

Successors:

+ + + + + + + + + + + + + + + + + +
SuccessorDescription
trueDestany successor
falseDestany successor
+

ll.cond_scope_ret (::vast::ll::CondScopeRet)

+

Terminator of scope if condition is met, otherwise branch.

+

Syntax:

+
operation ::= `ll.cond_scope_ret` $cond `:` type($cond) `,`
+              $dest (`(` $dest_operands^ `:` type($dest_operands) `)`)? attr-dict
+
+

Terminate or branch. +Traits: Terminator

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
condany type
dest_operandsany type
+

Successors:

+ + + + + + + + + + + + + +
SuccessorDescription
destany successor
+

ll.extract (::vast::ll::Extract)

+

Extracts value

+

Syntax:

+
operation ::= `ll.extract` operands attr-dict `:` functional-type(operands, results)
+
+

0 is lsb, [inc, exc)

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
from::mlir::TypedAttrTypedAttr instance
to::mlir::TypedAttrTypedAttr instance
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
argany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

ll.func (::vast::ll::FuncOp)

+

VAST function template

+

Syntax:

+
operation ::= `ll.func` $linkage $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)
+
+

Inspired by cir::FuncOp and mlir::func::FuncOp:

+
+

Operations within the function cannot implicitly capture values defined +outside of the function, i.e. Functions are IsolatedFromAbove. All +external references must use function arguments or attributes that establish +a symbolic connection (e.g. symbols referenced by name via a string +attribute like SymbolRefAttr). An external function declaration (used when +referring to a function declared in some other module) has no body.

+
+

The function linkage information is specified by linkage, as defined by +GlobalLinkageKind attribute.

+

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

+

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of function type
linkage::vast::core::GlobalLinkageKindAttrglobal linkage kind
sym_visibility::mlir::StringAttrstring attribute
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
+

ll.gep (::vast::ll::StructGEPOp)

+

VAST struct gep operation

+

VAST struct gep operation

+

Attributes:

+ + + + + + + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
idx::mlir::IntegerAttr32-bit signless integer attribute
name::mlir::StringAttrstring attribute
+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
recordany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
elementany type
+

ll.initialize (::vast::ll::InitializeVar)

+

Initialize a variable.

+

Syntax:

+
operation ::= `ll.initialize` operands attr-dict `:` functional-type(operands, results)
+
+

Initialize a variable - for now this operation is a direct lowering from hl.var +initialization section. Later there will be need to discover how this ties +to constructors.

+

Operands:

+ + + + + + + + + + + + + + + + + +
OperandDescription
varany type
elementsany type
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

ll.inline_scope (::vast::ll::InlineScope)

+

Scope, that forwards (cond)scope return up.

+

Result of inlined if. +Traits: NoRegionArguments

+

ll.return (::vast::ll::ReturnOp)

+

Syntax:

+
operation ::= `ll.return` ($result^ `:` type($result))? attr-dict
+
+

Traits: Terminator, return_trait

+

Operands:

+ + + + + + + + + + + + + +
OperandDescription
resultany type
+

ll.scope (::vast::ll::Scope)

+

Scope, holds one region.

+

Syntax:

+
operation ::= `ll.scope` $body attr-dict
+
+

Scope that holds one region, each block should be terminated + with either branch, scope return or their conditional variants. +Traits: NoRegionArguments

+

ll.scope_recurse (::vast::ll::ScopeRecurse)

+

Jump to first block of scope.

+

Syntax:

+
operation ::= `ll.scope_recurse` attr-dict
+
+

Modelling continue. +Traits: Terminator

+

ll.scope_ret (::vast::ll::ScopeRet)

+

Terminator of scope.

+

Syntax:

+
operation ::= `ll.scope_ret` attr-dict
+
+

Terminator of scopes (for example during lowering of loops). +Traits: Terminator

+

ll.uninitialized_var (::vast::ll::UninitializedVar)

+

Declaration of variable that have not been initialized yet.

+

Syntax:

+
operation ::= `ll.uninitialized_var` attr-dict `:` type($result)
+
+

Declaration of variable that have not been initialized yet. +Interfaces: VastSymbol

+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/LowLevelPasses/index.html b/dialects/LowLevelPasses/index.html new file mode 100644 index 0000000000..d9cccb773f --- /dev/null +++ b/dialects/LowLevelPasses/index.html @@ -0,0 +1,1030 @@ + + + + + + + + + + + + + + + + + + + + + + Low Level - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

Low Level

+ + +

-vast-ll-to-llvm

+

Convert low level operations to LLVM dialect.

+

Work in progess.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/Meta/Meta/index.html b/dialects/Meta/Meta/index.html new file mode 100644 index 0000000000..660572ea2e --- /dev/null +++ b/dialects/Meta/Meta/index.html @@ -0,0 +1,1130 @@ + + + + + + + + + + + + + + + + + + + + + + Meta - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'meta' Dialect

+

A vast metadata dialect. +This dialect intends capture user metadata +that are kept accross transformations.

+
+ +
+

Attribute definition

+

IdentifierAttr

+

A metadata identifier.

+

Syntax:

+
#meta.id<
+  identifier_t   # value
+>
+
+

A metadata identifier can be used to relate operations +to external metadata storage.

+
#meta.id<"0x3A28213A">
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
valueidentifier_t
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/dialects/Unsupported/Unsupported/index.html b/dialects/Unsupported/Unsupported/index.html new file mode 100644 index 0000000000..34e8acf4bd --- /dev/null +++ b/dialects/Unsupported/Unsupported/index.html @@ -0,0 +1,1420 @@ + + + + + + + + + + + + + + + + + + + + + + Unsupported - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + + +

'unsup' Dialect

+

A vast unsupported dialect. +This dialect defines a set of generic unsupported +operation/types that can be used to lower AST Node +that are yet not supported and can't be lowered by +other dialects.

+
+ +
+

Operation definition

+

unsup.decl (::vast::unsup::UnsupportedDecl)

+

VAST unsupported decl

+

Syntax:

+
operation ::= `unsup.decl` $name attr-dict `:` $body
+
+

VAST unsupported decl +Traits: NoTerminator

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

unsup.stmt (::vast::unsup::UnsupportedStmt)

+

VAST unsupported statement

+

Syntax:

+
operation ::= `unsup.stmt` $name attr-dict `:` type($result) $children
+
+

VAST unsupported statement +Traits: NoTerminator

+

Attributes:

+ + + + + + + + + + + + + + + +
AttributeMLIR TypeDescription
name::mlir::StringAttrstring attribute
+

Results:

+ + + + + + + + + + + + + +
ResultDescription
resultany type
+

Attribute definition

+

UnsupportedAttr

+

Syntax:

+
#unsup.attr<
+  ::mlir::StringAttr   # spelling
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
spelling::mlir::StringAttr
+

Type definition

+

UnsupportedType

+

Syntax:

+
!unsup.type<
+  ::llvm::StringRef   # originName
+>
+
+

Parameters:

+ + + + + + + + + + + + + + + +
ParameterC++ typeDescription
originName::llvm::StringRef
+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000000..4a8f818439 --- /dev/null +++ b/index.html @@ -0,0 +1,1113 @@ + + + + + + + + + + + + + + + + + + + + VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST: MLIR for Program Analysis

+

VAST is a library for program analysis and instrumentation of C/C++ and related +languages. VAST provides a foundation for customizable program representation +for a broad spectrum of analyses. Using the MLIR infrastructure, VAST provides +a toolset to represent C/C++ program at various stages of the compilation and +to transform the representation to the best-fit program abstraction.

+

Whether static or dynamic, program analysis often requires a specific view +of the source code. The usual requirements for a representation is to be +easily analyzable, i.e., have a reasonably small set of operations, be truthful +to the semantics of the analyzed program, and the analysis must be relatable to +the source. It is also beneficial to access the source at various abstraction +levels.

+

The current state-of-the-art tools leverage compiler infrastructures to perform +program analysis. This approach is beneficial because it remains truthful to the +executed program semantics, whether AST or LLVM IR. However, these +representations come at a cost as they are designed for optimization and code +generation, rather than for program analysis.

+

The Clang AST is unoptimized and too complex for interpretation-based analysis. +Also, it lacks program features that Clang inserts during its LLVM code +generation process. On the other hand, LLVM is often too low-level and hard to +relate to high-level program constructs.

+

VAST is a new compiler front/middle-end designed for program analysis. It +transforms parsed C and C++ code, in the form of Clang ASTs, into a high-level +MLIR dialect. The high level dialect is then progressively lowered all the way +down to LLVM IR. This progression enables VAST to represent the code as a tower +of IRs in multiple MLIR dialects. The MLIR allows us to capture high-level +features from AST and interleave them with low-level dialects.

+

A Tower of IRs

+

The feature that differentiates our approach is that the program representation +can hold multiple representations simultaneously, the so-called tower of IRs. +One can imagine the tower as multiple MLIR modules side-by-side in various +dialects. Each layer of the tower represents a specific stage of compilation. At +the top is a high-level dialect relatable to AST, and at the bottom is a +low-level LLVM-like dialect. Layers are interlinked with location information. +Higher layers can also be seen as metadata for lower layers.

+

This feature simplifies analysis built on top of VAST IR in multiple ways. It +naturally provides provenance to higher levels dialects (and source code) +from the low levels. Similarly, one can reach for low-level representation from +the high-level source view. This can have multiple utilizations. One of them is +relating analysis results to the source. For a user, it is invaluable to +represent results in the language of what they see, that is, the high-level +representation of the source. For example, using provenance, one can link the +values in low-level registers to variable names in the source. Furthermore, +this streamlines communication from the user to the analysis backend and back in +the interactive tools and also allows the automatic analysis to query the +best-fit representation at any time.

+

The provenance is invaluable for static analysis too. It is often advantageous +to perform analysis as an abstract interpretation of the low-level +representation and relate it to high-level constructs. For example, when trying +to infer properties about control flow, like loop invariants, one can examine +high-level operations and relate the results to low-level analysis using +provenance links.

+

We expect to provide a DSL library for design of custom program representation +abstraction on top of our tower of IRs. The library will provide utilities to +link other dialects to the rest of the tower so that the provenance is usable +outside the main pipeline.

+

Dialects

+

As a foundation, VAST provides backbone dialects for the tower of IRs. +A high-level dialect hl is a faithful representation of Clang AST. While +intermediate dialects represent compilation artifacts like ABI lowering of macro +expansions. Whenever it is possible, we try to utilize standard dialects. At the +bottom of the tower, we have the llvm dialect. For features that are not +present in the llvm dialect, we utilize our low-level dialect ll. We +leverage a meta dialect to provide provenance utilities. The currently +supported features are documented in automatically generated dialect +docs.

+

For types, we provide high-level types from Clang AST enriched by value +categories. This allows referencing types as presented in the source. In the +rest of the tower, we utilize standard or llvm types, respectively.

+

One does not need to utilize the tower of IRs but can craft a specific +representation that interleaves multiple abstractions simultaneously.

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file diff --git a/search/search_index.json b/search/search_index.json new file mode 100644 index 0000000000..35b2a30ef0 --- /dev/null +++ b/search/search_index.json @@ -0,0 +1 @@ +{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"","title":"VAST: MLIR for Program Analysis","text":"

VAST is a library for program analysis and instrumentation of C/C++ and related languages. VAST provides a foundation for customizable program representation for a broad spectrum of analyses. Using the MLIR infrastructure, VAST provides a toolset to represent C/C++ program at various stages of the compilation and to transform the representation to the best-fit program abstraction.

Whether static or dynamic, program analysis often requires a specific view of the source code. The usual requirements for a representation is to be easily analyzable, i.e., have a reasonably small set of operations, be truthful to the semantics of the analyzed program, and the analysis must be relatable to the source. It is also beneficial to access the source at various abstraction levels.

The current state-of-the-art tools leverage compiler infrastructures to perform program analysis. This approach is beneficial because it remains truthful to the executed program semantics, whether AST or LLVM IR. However, these representations come at a cost as they are designed for optimization and code generation, rather than for program analysis.

The Clang AST is unoptimized and too complex for interpretation-based analysis. Also, it lacks program features that Clang inserts during its LLVM code generation process. On the other hand, LLVM is often too low-level and hard to relate to high-level program constructs.

VAST is a new compiler front/middle-end designed for program analysis. It transforms parsed C and C++ code, in the form of Clang ASTs, into a high-level MLIR dialect. The high level dialect is then progressively lowered all the way down to LLVM IR. This progression enables VAST to represent the code as a tower of IRs in multiple MLIR dialects. The MLIR allows us to capture high-level features from AST and interleave them with low-level dialects.

"},{"location":"#a-tower-of-irs","title":"A Tower of IRs","text":"

The feature that differentiates our approach is that the program representation can hold multiple representations simultaneously, the so-called tower of IRs. One can imagine the tower as multiple MLIR modules side-by-side in various dialects. Each layer of the tower represents a specific stage of compilation. At the top is a high-level dialect relatable to AST, and at the bottom is a low-level LLVM-like dialect. Layers are interlinked with location information. Higher layers can also be seen as metadata for lower layers.

This feature simplifies analysis built on top of VAST IR in multiple ways. It naturally provides provenance to higher levels dialects (and source code) from the low levels. Similarly, one can reach for low-level representation from the high-level source view. This can have multiple utilizations. One of them is relating analysis results to the source. For a user, it is invaluable to represent results in the language of what they see, that is, the high-level representation of the source. For example, using provenance, one can link the values in low-level registers to variable names in the source. Furthermore, this streamlines communication from the user to the analysis backend and back in the interactive tools and also allows the automatic analysis to query the best-fit representation at any time.

The provenance is invaluable for static analysis too. It is often advantageous to perform analysis as an abstract interpretation of the low-level representation and relate it to high-level constructs. For example, when trying to infer properties about control flow, like loop invariants, one can examine high-level operations and relate the results to low-level analysis using provenance links.

We expect to provide a DSL library for design of custom program representation abstraction on top of our tower of IRs. The library will provide utilities to link other dialects to the rest of the tower so that the provenance is usable outside the main pipeline.

"},{"location":"#dialects","title":"Dialects","text":"

As a foundation, VAST provides backbone dialects for the tower of IRs. A high-level dialect hl is a faithful representation of Clang AST. While intermediate dialects represent compilation artifacts like ABI lowering of macro expansions. Whenever it is possible, we try to utilize standard dialects. At the bottom of the tower, we have the llvm dialect. For features that are not present in the llvm dialect, we utilize our low-level dialect ll. We leverage a meta dialect to provide provenance utilities. The currently supported features are documented in automatically generated dialect docs.

For types, we provide high-level types from Clang AST enriched by value categories. This allows referencing types as presented in the source. In the rest of the tower, we utilize standard or llvm types, respectively.

One does not need to utilize the tower of IRs but can craft a specific representation that interleaves multiple abstractions simultaneously.

"},{"location":"CONTRIBUTING/","title":"Contributing to VAST","text":"

First, thanks for your interest in contributing to VAST! We welcome and appreciate all contributions, including bug reports, feature suggestions, tutorials/blog posts, and code improvements.

If you're unsure where to start, we recommend our good first issue issue label.

"},{"location":"CONTRIBUTING/#bug-reports-and-feature-suggestions","title":"Bug reports and feature suggestions","text":"

Bug reports and feature suggestions can be submitted to our issue tracker.

When reporting a bug please provide a minimal example with steps to reproduce the issue if possible. It helps us a lot, as we can get to the bottom of the issue much faster and can even use it as a test case to catch future regressions.

"},{"location":"CONTRIBUTING/#questions","title":"Questions","text":"

Questions can be submitted to the discussion page.

"},{"location":"CONTRIBUTING/#legal","title":"Legal","text":"

For legal reasons, we require contributors to sign our Contributor License Agreement. This will be automatically checked as part of our CI.

"},{"location":"CONTRIBUTING/#git-pull-requests","title":"Git & Pull Requests","text":"

VAST uses the pull request contribution model. Please make an account on Github, fork this repo, and submit code contributions via pull request. For more documentation, look here.

Since VAST does not squash commits in a pull request, it is important to uphold some culture when it comes to commits.

  • Commit should ideally be one simple change.
  • Commit messages follow a simple format: component: Simple sentence with a dot. with maximum of 80 chars and optional longer message.
  • When unsure what component commit modifies, run git log on the modified file(s).
  • Commits should modify only one component (as a result the project does not have to build with each separate commit)
  • If you are having troubles coming up with a simple sentence as a commit message, that is short enough, it may be a good indicator that the commit should be split.

Some pull request guidelines:

  • Minimize irrelevant changes (formatting, whitespace, etc) to code that would otherwise not be touched by this patch. Save formatting or style corrections for a separate pull request that does not make any semantic changes.
  • When possible, large changes should be split up into smaller focused pull requests.
  • Fill out the pull request description with a summary of what your patch does, key changes that have been made, and any further points of discussion, if applicable.
  • Title your pull request with a brief description of what it's changing. \"Fixes #123\" is a good comment to add to the description, but makes for an unclear title on its own.
  • CI must pass for the PR to be merged.
  • There must be a review from some maintainer that accepts changes for the PR to be merged.
"},{"location":"statement/","title":"License","text":"

VAST is licensed according to the Apache 2.0 license. VAST links against and uses Clang and LLVM APIs. Clang is also licensed under Apache 2.0, with LLVM exceptions.

This research was developed with funding from the Defense Advanced Research Projects Agency (DARPA). The views, opinions and/or findings expressed are those of the author and should not be interpreted as representing the official views or policies of the Department of Defense or the U.S. Government.

Distribution Statement A \u2013 Approved for Public Release, Distribution Unlimited

"},{"location":"Designs/abi/","title":"Abi","text":""},{"location":"Designs/abi/#abi","title":"ABI","text":"

VAST partially models ABI specifications for function types and therefore callsites. While the specification goes into details regarding registers, for now VAST only offers lowering similar to what clang codegen does - argument and return types are coerced to types that will easily fit their respective registers once that allocation takes place. There is nothing preventing inclusion of information about registers as well (for example as metadata or separate operations/dialect), however it is not yet implemented.

Similar to other transformation in VAST, ABI modelling tries to be as modular as possible and as such can be split into three distinct steps:

  • Compute classification of types
  • Encode computed classification into module
  • Lower transformed module into some \"executable\" dialect

Main goal for now is to lower function prototypes to match the types produced by clang, so that VAST emitted LLVM can be used as drop-in replacement for clang one.

When reading this document please keep in mind that implementation of this feature is still ongoing and therefore particular technical details could change drastically (although we hope that overall design will remain the same).

"},{"location":"Designs/abi/#classification","title":"Classification","text":"

Mirrors what clang does, but instead of locking the computed information away, we expose the API. In ideal world we would like to keep the algorithm(s, as there may be multiple per different ABIs) generic. This can be achieved by requiring users to implement & provide interface that specifies various details about used types; algorithm will be same when talking about hl or LLVM types after all.

"},{"location":"Designs/abi/#abi-dialect","title":"ABI Dialect","text":"

Once classification for a function is computed, we need to:

  • Change function prototype
  • Encode how new types match to the old types + some oddities such as sret.

To facilitate this, VAST contains abi dialect, which operations encode \"high-level\" descriptions of type transformations that can occur during ABI lowering as operations. This is not very different from what clang does, but VAST does it over multiple steps.

For functions, type change itself is easy and to mark that function is transformed, abi.func operation is used instead of original one to define the newly formed function. However, as arguments and return types are different, we introduce abi.prologue and abi.epilogue operations.

Consider following function we want to lower:

Disclaimer: Since abi dialect does not have nice formatting, therefore examples in this section contain some artistic liberty, but semantics (and operations) are preserved.

strut Point{ int; int; int; };\n\nint size( struct Point p ) { ... }\n

After running the classification, we discover that type of size should be ( i64, i32 ) -> i32 - both arguments and returned value are passed directly. Therefore we encode it as follows:

abi.func size(i64 %arg0_0, i32 %arg0_1 ) -> i32\n{\n    %arg = abi.prologue -> hl.lvalue< hl.struct< \"Point\" > >\n    {\n        %0 = abi.direct %arg0_0, %arg0_1: (i64, i32) -> hl.struct< \"Point\" >\n        abi.yield %0\n    }\n\n    // Computation can continue as before, because %arg has a correct type\n\n    %ret = ... value that was previously returned ... -> i32\n    %out = abi.epilogue\n    {\n        %0 = abi.direct %ret: i32 -> i32\n        abi.yield %0\n    }\n    hl.return %out\n}\n

In case, there were multiple function arguments, the abi.prologue would return more values.

\n%args = abi.prologue -> (hl.lvalue< hl.struct< \"Point\" > >, i32 )\n{\n    %0 = abi.direct %arg0_0, %arg0_1\n    %1 = abi.direct %arg1\n    abi.yield %0, %1\n}\n

TODO: Add extra examples, at least memory and sret.

This design allows easy analysis and subsequent rewrite (as each function has a prologue and epilogue and returned values are explicitly yielded).

Callsites are transformed in the same manner (unfortunately, they look more complicated due to nested regions):

\n%x = hl.call< \"size\" > %arg: hl.struct< \"Point\" > -> i32\n\n%x = abi.call< \"size\" >: () -> i32\n{\n    %arg0_0, %arg0_1 = abi.call_args: () -> (i64, i32)\n    {\n        %0, %1 = abi.direct %arg\n        abi.yield %0, %1\n    }\n    %x' = hl.call< \"size\" > %arg0_0, &arg0_1 : (i64, i32) -> i32\n    %0 = abi.call_rets : () -> i32\n    {\n        %0 = abi.direct %x' : i32 -> i32\n        abi.yield %0\n    }\n    abi.yield %0\n}\n\n

For now, same abi operations are used to encode transformation in callsite and function (although they change the value in a \"opposite direction\"), this may be later revisited, but for now it is enough to look at the parent operation to determine whether the transformation lies in a function or callsite.

"},{"location":"Designs/abi/#lowering-to-some-executable-dialect","title":"Lowering to some executable dialect","text":"

While abi dialect provides us with all the information required to do the transformation, it does not \"compute\" anything. Rather this lowering is left to a next pass. We hope by splitting the transformation into 2, we achieve the following:

  • We can implement multiple \"backends\" - whether back to hl, llvm or totally random dialect of user choice.
  • Re-use existing implementation of classification algorithm.
"},{"location":"Designs/cpp2-parameters/","title":"Cpp2 parameters","text":""},{"location":"Designs/cpp2-parameters/#lifting-parameter-passing-httpsgithubcomhsutter708blobmain708pdf","title":"Lifting parameter passing [https://github.com/hsutter/708/blob/main/708.pdf]","text":"

The proposed way of parameter passing for next-gen c++ is to use declarative style:

f(     in X x) // x can be read from\nf(  inout X x) // x can be used in read and write\nf(    out X x) // x can be writen to\nf(   move X x) // x will be moved from\nf(forward X x) // x will be passed along\n

Similar holds for return values:

auto f()    move X { /* ... */ } // move X to caller\nauto f()         X { /* ... */ } // possibly same\nauto f() forward X { /* ... */ } // pass along X to the caller\n

Using the semantics aware vast dialects, we can design a method to automatically modernize code to use a declarative style of parameter passing.

"},{"location":"Designs/cpp2-parameters/#examples","title":"Examples","text":"CPP CPP2 
\nvoid f(const X& x) {\n    g(x);\n}\n
\nvoid f(in X x) {\n    g(x);\n}\n
VAST high-level dialect Transformed to parameter dialect 
\nhl.func @f(%x: !hl.ref< !hl.lvalue< !hl.struct< \"X\" > >, const >) {\n    %0 = hl.call @g(%x) : (!hl.ref< !hl.lvalue< !hl.struct< \"X\" > >, const >) -> !hl.void\n}\n
\nhl.func @f(%x: !par.in< !hl.lvalue< !hl.struct< \"X\" > > >) {\n    %0 = hl.call @g(%x) : (!par.in< !hl.lvalue< !hl.struct< \"X\" > > >) -> !hl.void\n}\n

The transformation will be probably overapproximating, in cases when the analysis cannot determine the precise category, i.e., inout oveapproximates in and out parameters.

"},{"location":"Designs/cpp2-parameters/#dialect","title":"Dialect","text":"

The dialect will define type adaptors for each parameter category:

!par.in< T >\n!par.out< T >\n!par.inout< T >\n!par.move< T >\n!par.forward< T >\n

Parameter categories can also be present as type attributes not to mess up the rest of the type trait system. This needs further investigation.

The advantage of the type adaptors we can enforce the correct usage of values. For example, we can forbid usage of out parameter in other places than assignment.

"},{"location":"GettingStarted/build/","title":"Build & Run","text":""},{"location":"GettingStarted/build/#dependencies","title":"Dependencies","text":"

Currently, it is necessary to use clang (due to gcc bug) to build VAST. On Linux it is also necessary to use lld at the moment.

VAST uses llvm-17 which can be obtained from the repository provided by LLVM.

Before building (for Ubuntu) get all the necessary dependencies by running

apt-get install build-essential cmake ninja-build libstdc++-12-dev llvm-17 libmlir-17 libmlir-17-dev mlir-17-tools libclang-17-dev\n

or an equivalent command for your operating system of choice.

"},{"location":"GettingStarted/build/#instructions","title":"Instructions","text":"

To configure project run cmake with following default options. In case clang isn't your default compiler prefix the command with CC=clang CXX=clang++. If you want to use system installed llvm and mlir (on Ubuntu) use:

cmake --preset ninja-multi-default \\\n    --toolchain ./cmake/lld.toolchain.cmake \\\n    -DCMAKE_PREFIX_PATH=/usr/lib/llvm-17/\n

To use a specific llvm provide -DCMAKE_PREFIX_PATH=<llvm & mlir instalation paths> option, where CMAKE_PREFIX_PATH points to directory containing LLVMConfig.cmake and MLIRConfig.cmake.

Note: vast requires LLVM with RTTI enabled. Use LLVM_ENABLE_RTTI=ON if you build your own LLVM.

Finally, build the project:

cmake --build --preset ninja-rel\n

Use ninja-deb preset for debug build.

"},{"location":"GettingStarted/build/#run","title":"Run","text":"

To run mlir codegen of highlevel dialect use.

./builds/ninja-multi-default/tools/vast-front/Release/vast-front -vast-emit-mlir=<dialect> <input.c> -o <output.mlir>\n

Supported dialects are: hl, ll, llvm

"},{"location":"GettingStarted/build/#test","title":"Test","text":"
ctest --preset ninja-deb\n
"},{"location":"GettingStarted/debug/","title":"Debug","text":""},{"location":"GettingStarted/debug/#debugging","title":"Debugging","text":"

VAST makes use of the MLIR infrastructure to facilitate the reproduction of crashes within the pipeline. You can refer to the MLIR documentation on crash and failure reproduction for more details. We provide a similar set of options in vast-front to aid in debugging.

"},{"location":"GettingStarted/debug/#generating-crash-reproducers","title":"Generating Crash Reproducers","text":"

To generate a minimal reproducer for a crashed pipeline of vast-front, use the following option:

-vast-emit-crash-reproducer=\"reproducer.mlir\" \n

This option disables multithreading to ensure a comprehensive crash report. You can then load and examine the crash report using the following command:

vast-opt -run-reproducer reproducer.mlir\n
"},{"location":"GettingStarted/debug/#pipeline-information","title":"Pipeline Information","text":"

To obtain a detailed insight into the pipeline, you can use the following option of vast-front:

-vast-print-pipeline\n

This option dumps the pipeline string to the standard error stream. You can use this information for a more specific investigation of the pipeline. Execute the pipeline with the printed string using the following command:

vast-opt --pass-pipeline=\"pipeline-string\"\n
"},{"location":"GettingStarted/debug/#debug-pipeline","title":"Debug Pipeline","text":"

With the -vast-debug option, you get more detailed crash reports. It shows MLIR operations when there's an error and provides current stack traces.

"},{"location":"GettingStarted/extend/","title":"How to create a new dialect","text":""},{"location":"GettingStarted/extend/#how-to-start-extending-vast","title":"How to Start Extending VAST?","text":"

VAST offers a handy script to generate a variety of MLIR primitives. You can find the script at scripts/templater.py. This tool is designed to help you create dialects, passes, operations, types, and attributes interactively.

"},{"location":"GettingStarted/extend/#usage","title":"Usage","text":"

Just run the script. It has been designed to provide a guided process for generating the desired primitives. If you find anything confusing or unintuitive, please don't hesitate to open an issue so that we can address it.

When you run the script, it will generate the basic skeleton for your chosen primitive. It will list the generated files which you can freely modify to provide desired functionality.

"},{"location":"Projects/related/","title":"Related","text":""},{"location":"Projects/related/#related-projects","title":"Related Projects","text":""},{"location":"Projects/related/#llvm-test-suite","title":"LLVM Test Suite","text":"

Test suite extended to generate reports for VAST MLIR dialects.

"},{"location":"Projects/related/#benchamrks","title":"Benchamrks","text":"

C/C++ benchmarks for VAST.

"},{"location":"Projects/related/#miller","title":"Miller","text":"

VAST MLIR Abstract Interpreter

"},{"location":"Projects/related/#vast-checker","title":"VAST-Checker","text":"

VAST-based tool that scans C code for variants of the Sequoia bug.

"},{"location":"Projects/related/#macroni","title":"Macroni","text":"

Compiler frontend for C and C++ that utilizes PASTA for code parsing and VAST for representing the code as MLIR. Notably, it extends VAST MLIR to handle macro expansions in its dialects.

"},{"location":"Projects/related/#potato","title":"PoTATo","text":"

Dialect-based points-to analysis for MLIR.

"},{"location":"Tools/vast-front/","title":"VAST: Compiler Driver","text":"

WIP vast-front

"},{"location":"Tools/vast-lsp-server/","title":"VAST: Language Server Protocol","text":"

VAST provides an implementation of LSP language server in the form of the vast-lsp-server tool. This tool interacts with the MLIR C++ API to support rich language queries, such as \u201cFind Definition\u201d.

The tool easily integrates with VSCode extension MLIR. The user needs to point the extension to mlir-lsp-server. To do so, one can create a symbolic link named mlir-lsp-server to point to built vast-lsp-server.

"},{"location":"Tools/vast-lsp-server/#build","title":"Build","text":"

To build vast-lsp-server use:

cmake --build <build-dir> --target vast-lsp-server\n
"},{"location":"Tools/vast-opt/","title":"VAST: Optimizer","text":"

After mlir module from vast-cc is produced, we can leverage our optimisation pipeline to transform module in various ways. The lowest level we can do is LLVM dialect, from which we can dump LLVM IR if desired.

Overall design philosophy is that passes try to be really modular, self-contained and doing one thing properly - all while trying to preserve provenance metadata. Sometimes this does not exactly hold (transformation from HL into LL is huge) but it is what we strive for. Passes will more often than not have some dependencies between themselves - always consult documentation if unsure and report an issue if wiki is out of date on this.

"},{"location":"Tools/vast-opt/#metadata-and-passes","title":"Metadata and passes","text":"

TODO: Improve once we have examples

TL;DR: Vast provided passes always try to keep metadata (and they should do a good job), but for passes from other sources this does not hold and probably some heuristic will be used to re-compute them in best-effort.

"},{"location":"Tools/vast-opt/#passes","title":"Passes","text":"

Passes we have implemented can be roughly grouped into several categories. We also note some of the native mlir passes that are needed to continue with transformations to reach LLVM dialect.

"},{"location":"Tools/vast-opt/#type-lowering","title":"Type lowering","text":"

A common prerequisite for other passes is to lower HL types into standard types. This can be done in two steps: * --vast-hl-lower-types - Converts simple (non-struct) types according to provided data layout (embedded in the mlir module metadata). * --vast-hl-structs-to-tuples - Converts HL struct types into standard tuples

While these should be commutative, the preferred order is --vast-hl-lower-types --vast-hl-structs-to-tuples

"},{"location":"Tools/vast-opt/#hl-scf","title":"HL -> SCF","text":"
  • --vast-hl-to-scf
  • Requires:
    • Type lowering
  • Conversion of HL control flow ops (currently only hl.if and hl.while) into their scf equivalents. Since scf requires i1 in their conditions, additional casts may be inserted to satisfy this requirement (currently they are emitted in HL however this behaviour should customisable eventually.

To produce an LLVM following addition passes must be run --convert-scf-to-std --convert-std-to-llvm and possibly --vast-hl-to-ll as well (or some equivalent, depending on how conditions are coerced)

"},{"location":"Tools/vast-opt/#hl-ll","title":"HL -> LL","text":"
  • --vast-hl-to-ll
  • Requires:
    • Type lowering
    • Some form of control flow lowering
  • Lower all HL operation into their LLVM dialect equivalents - this is a rather huge pass, for details see its documentation.
"},{"location":"Tools/vast-opt/#llvm-dump","title":"LLVM Dump","text":"
  • --vast-llvm-dump
  • Requires:
    • Entire module must be in LLVM dialect (or have operation for which conversion hooks are provided)
  • LLVM bitcode is dumped to llvm::errs() in human readable form. Since passes can run in parallel, dump to file is non-trivial.
"},{"location":"Tools/vast-opt/#example-usage","title":"Example Usage","text":"

Let's say we have file main.c which we want to lower into some dialect. First let's have a look at some generic invocations we may find handy:

To get mlir module via vast-cc

vast-cc --ccopts -xc --from-source main.c\n

A quick remainder * --ccopts -xc says we are doing C not C++ * --from-source file says that source code comes from the file

Once we have the module, we can invoke vast-opt, with easiest way being a simple pipe

vast-cc --ccopts -xc --from-source main.c | vast-opt pass-we-want another-pass-we-want\n

If we want, we can also chain pipes

vast-cc --ccopts -xc --from-source main.c | vast-opt pass | vast-opt another-pass | ...\n

Now, let's say we want to lower into LLVM bitcode, therefore the invocation will look as follows

vast-cc --ccopts -xc --from-source main.c | vast-opt --vast-hl-lower-types --vast-hl-structs-to-tuples\n                                                     --vast-hl-to-scf --convert-scf-to-std --convert-std-to-llvm\n                                                     --vast-hl-to-ll\n
"},{"location":"Tools/vast-query/","title":"VAST: Query","text":"

vast-query is a command line tool to query symbols in the vast generated MLIR. Its primary purpose is to test symbols and their use edges in the produced MLIR. Example of usage:

vast-query [options] <input file>\n

Options:

  --scope=<function name>      - Show values from scope of a given function\n  --show-symbols=<value>       - Show MLIR symbols\n    =functions                 -   show function symbols\n    =types                     -   show type symbols\n    =records                   -   show record symbols\n    =vars                      -   show variable symbols\n    =globs                     -   show global variable symbols\n    =all                       -   show all symbols\n  --symbol-users=<symbol name> - Show users of a given symbol\n
"},{"location":"Tools/vast-repl/","title":"VAST: REPL","text":"

WIP vast-repl is an interactive MLIR query and modification tool.

Commands:

exit            - exits repl\n\nhelp            - prints help\nload <filename> - loads source from file\n\nshow <value>    - displays queried value\n    =source         - loaded source code\n    =ast            - clang ast\n    =module         - current VAST MLIR module\n    =symbols        - present symbols in the module\n\nmeta <action>   - operates on metadata for given symbol\n    =add <symbol> <id> - adds <id> meta to <symbol>\n    =get <id>          - gets symbol with <id> meta\n
"},{"location":"dialects/HighLevelPasses/","title":"High Level","text":""},{"location":"dialects/HighLevelPasses/#-vast-export-fn-info","title":"-vast-export-fn-info","text":"

Create JSON that exports information about function arguments.

Lowers module into llvm IR and dumps it on stderr.

"},{"location":"dialects/HighLevelPasses/#options","title":"Options","text":"
-o : Output JSON file to be created.\n
"},{"location":"dialects/HighLevelPasses/#-vast-hl-dce","title":"-vast-hl-dce","text":"

Trim dead code

Removes unreachable code, such as code after return or break/continue.

"},{"location":"dialects/HighLevelPasses/#-vast-hl-lower-typedefs","title":"-vast-hl-lower-typedefs","text":"

Replace hl::TypeDef type by its underlying aliased type.

Replaces hl::TypeDef types by its underlying aliased types. The conversion resolves nested typedefs.

All hl::TypeDef are marked illegal and converted by this pass.

"},{"location":"dialects/HighLevelPasses/#-vast-hl-lower-types","title":"-vast-hl-lower-types","text":"

Lower high-level types to standard types

Lower high-level types into standard types which is usually required first step by other passes in the pipeline.

Information about bit sizes of high level types is inferred from the data layout of the module, which is derived from the information provided by clang and emitted automatically by vast-cc.

TODO: Named types are not yet supported.

"},{"location":"dialects/HighLevelPasses/#-vast-hl-splice-trailing-scopes","title":"-vast-hl-splice-trailing-scopes","text":"

Remove trailing hl::Scopes.

Removes trailing scopes.

"},{"location":"dialects/LowLevelPasses/","title":"Low Level","text":""},{"location":"dialects/LowLevelPasses/#-vast-ll-to-llvm","title":"-vast-ll-to-llvm","text":"

Convert low level operations to LLVM dialect.

Work in progess.

"},{"location":"dialects/ABI/ABI/","title":"ABI","text":""},{"location":"dialects/ABI/ABI/#abi-dialect","title":"'abi' Dialect","text":"

A vast ABI dialect. Dialect provides operations to describe how arguments and return values are transformed to better model target abi.

  • 'abi' Dialect
    • Operation definition
      • abi.call (::vast::abi::CallOp)
        • Attributes:
        • Operands:
        • Results:
      • abi.call_args (::vast::abi::CallArgsOp)
        • Results:
      • abi.call_exec (::vast::abi::CallExecutionOp)
        • Attributes:
        • Operands:
        • Results:
      • abi.call_rets (::vast::abi::CallRetsOp)
        • Results:
      • abi.direct (::vast::abi::DirectOp)
        • Operands:
        • Results:
      • abi.epilogue (::vast::abi::EpilogueOp)
        • Results:
      • abi.func (::vast::abi::FuncOp)
        • Attributes:
      • abi.indirect (::vast::abi::IndirectOp)
        • Operands:
        • Results:
      • abi.prologue (::vast::abi::PrologueOp)
        • Results:
      • abi.ret_direct (::vast::abi::RetDirectOp)
        • Operands:
        • Results:
      • abi.todo (::vast::abi::TodoOp)
        • Operands:
        • Results:
      • abi.wrap_fn (::vast::abi::WrapFuncOp)
        • Attributes:
      • abi.yield (::vast::abi::YieldOp)
        • Operands:
        • Results:
"},{"location":"dialects/ABI/ABI/#operation-definition","title":"Operation definition","text":""},{"location":"dialects/ABI/ABI/#abicall-vastabicallop","title":"abi.call (::vast::abi::CallOp)","text":"

ABI call operation

Syntax:

operation ::= `abi.call` $callee `(` $args `)` attr-dict `:` functional-type( $args, $results )\n

ABI call operation Interfaces: CallOpInterface

"},{"location":"dialects/ABI/ABI/#attributes","title":"Attributes:","text":"Attribute MLIR Type Description callee ::mlir::FlatSymbolRefAttr flat symbol reference attribute"},{"location":"dialects/ABI/ABI/#operands","title":"Operands:","text":"Operand Description args any type"},{"location":"dialects/ABI/ABI/#results","title":"Results:","text":"Result Description results any type"},{"location":"dialects/ABI/ABI/#abicall_args-vastabicallargsop","title":"abi.call_args (::vast::abi::CallArgsOp)","text":"

Not implement yet.

Syntax:

operation ::= `abi.call_args` $body attr-dict `:` type($results)\n

WIP

"},{"location":"dialects/ABI/ABI/#results_1","title":"Results:","text":"Result Description results any type"},{"location":"dialects/ABI/ABI/#abicall_exec-vastabicallexecutionop","title":"abi.call_exec (::vast::abi::CallExecutionOp)","text":"

WIP

Syntax:

operation ::= `abi.call_exec` $callee `(` $args `)` $body attr-dict `:` functional-type($args, $result)\n

WIP Interfaces: CallOpInterface

"},{"location":"dialects/ABI/ABI/#attributes_1","title":"Attributes:","text":"Attribute MLIR Type Description callee ::mlir::FlatSymbolRefAttr flat symbol reference attribute"},{"location":"dialects/ABI/ABI/#operands_1","title":"Operands:","text":"Operand Description args any type"},{"location":"dialects/ABI/ABI/#results_2","title":"Results:","text":"Result Description result any type"},{"location":"dialects/ABI/ABI/#abicall_rets-vastabicallretsop","title":"abi.call_rets (::vast::abi::CallRetsOp)","text":"

Not implement yet.

Syntax:

operation ::= `abi.call_rets` $body attr-dict `:` type($results)\n

WIP

"},{"location":"dialects/ABI/ABI/#results_3","title":"Results:","text":"Result Description results any type"},{"location":"dialects/ABI/ABI/#abidirect-vastabidirectop","title":"abi.direct (::vast::abi::DirectOp)","text":"

Pass value directly - usually means by register

Syntax:

operation ::= `abi.direct` $value attr-dict `:` type($value) `->` type($result)\n

Pass value directly - usually means by register.

"},{"location":"dialects/ABI/ABI/#operands_2","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/ABI/ABI/#results_4","title":"Results:","text":"Result Description result any type"},{"location":"dialects/ABI/ABI/#abiepilogue-vastabiepilogueop","title":"abi.epilogue (::vast::abi::EpilogueOp)","text":"

WIP

Syntax:

operation ::= `abi.epilogue` $body attr-dict `:` type($results)\n

WIP

"},{"location":"dialects/ABI/ABI/#results_5","title":"Results:","text":"Result Description results any type"},{"location":"dialects/ABI/ABI/#abifunc-vastabifuncop","title":"abi.func (::vast::abi::FuncOp)","text":"

_ Function with transformed type. _

Syntax:

operation ::= `abi.func` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)\n

Placeholder.

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

"},{"location":"dialects/ABI/ABI/#attributes_2","title":"Attributes:","text":"Attribute MLIR Type Description sym_name ::mlir::StringAttr string attribute function_type ::mlir::TypeAttr type attribute of function type linkage ::vast::core::GlobalLinkageKindAttr global linkage kind sym_visibility ::mlir::StringAttr string attribute arg_attrs ::mlir::ArrayAttr Array of dictionary attributes res_attrs ::mlir::ArrayAttr Array of dictionary attributes"},{"location":"dialects/ABI/ABI/#abiindirect-vastabiindirectop","title":"abi.indirect (::vast::abi::IndirectOp)","text":"

Value is passed indirectly via memory

Syntax:

operation ::= `abi.indirect` $value attr-dict `:` type($value) `->` type($result)\n

Value is passed indirectly via memory

"},{"location":"dialects/ABI/ABI/#operands_3","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/ABI/ABI/#results_6","title":"Results:","text":"Result Description result any type"},{"location":"dialects/ABI/ABI/#abiprologue-vastabiprologueop","title":"abi.prologue (::vast::abi::PrologueOp)","text":"

WIP

Syntax:

operation ::= `abi.prologue` $body attr-dict `:` type($results)\n

WIP

"},{"location":"dialects/ABI/ABI/#results_7","title":"Results:","text":"Result Description results any type"},{"location":"dialects/ABI/ABI/#abiret_direct-vastabiretdirectop","title":"abi.ret_direct (::vast::abi::RetDirectOp)","text":"

Value is returned directly.

Syntax:

operation ::= `abi.ret_direct` $value attr-dict `:` type($value) `->` type($result)\n

Value is returned directly.

"},{"location":"dialects/ABI/ABI/#operands_4","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/ABI/ABI/#results_8","title":"Results:","text":"Result Description result any type"},{"location":"dialects/ABI/ABI/#abitodo-vastabitodoop","title":"abi.todo (::vast::abi::TodoOp)","text":"

Not implement yet.

Syntax:

operation ::= `abi.todo` $value attr-dict `:` type($value) `->` type($result)\n

Not implemented yet

"},{"location":"dialects/ABI/ABI/#operands_5","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/ABI/ABI/#results_9","title":"Results:","text":"Result Description result any type"},{"location":"dialects/ABI/ABI/#abiwrap_fn-vastabiwrapfuncop","title":"abi.wrap_fn (::vast::abi::WrapFuncOp)","text":"

_ Function that defines abi transformation of args. _

Syntax:

operation ::= `abi.wrap_fn` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)\n

Placeholder.

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

"},{"location":"dialects/ABI/ABI/#attributes_3","title":"Attributes:","text":"Attribute MLIR Type Description sym_name ::mlir::StringAttr string attribute function_type ::mlir::TypeAttr type attribute of function type linkage ::vast::core::GlobalLinkageKindAttr global linkage kind sym_visibility ::mlir::StringAttr string attribute arg_attrs ::mlir::ArrayAttr Array of dictionary attributes res_attrs ::mlir::ArrayAttr Array of dictionary attributes"},{"location":"dialects/ABI/ABI/#abiyield-vastabiyieldop","title":"abi.yield (::vast::abi::YieldOp)","text":"

WIP

Syntax:

operation ::= `abi.yield` $values attr-dict `:` type($values) `->` type($result)\n

WIP Traits: Terminator

"},{"location":"dialects/ABI/ABI/#operands_6","title":"Operands:","text":"Operand Description values any type"},{"location":"dialects/ABI/ABI/#results_10","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Core/Core/","title":"Core","text":""},{"location":"dialects/Core/Core/#core-dialect","title":"'core' Dialect","text":"

Utility dialect to provide common features for other dialects. Dialect providing features that may be used by other dialects. These features can be used by including \"vast/Dialect/Core/Utils.td\" It also provides lazy.op for lazy evaluation of expressions and binary logical operations that make use of it.

  • 'core' Dialect
    • Operation definition
      • core.bin.land (::vast::core::BinLAndOp)
        • Operands:
        • Results:
      • core.bin.lor (::vast::core::BinLOrOp)
        • Operands:
        • Results:
      • core.implicit.return (::vast::core::ImplicitReturnOp)
        • Operands:
      • core.lazy.op (::vast::core::LazyOp)
        • Results:
      • core.scope (::vast::core::ScopeOp)
      • core.select (::vast::core::SelectOp)
        • Operands:
        • Results:
    • Attribute definition
      • BooleanAttr
        • Parameters:
      • GlobalLinkageKindAttr
        • Parameters:
      • FloatAttr
        • Parameters:
      • IntegerAttr
        • Parameters:
      • SourceLanguageAttr
        • Parameters:
      • VoidAttr
        • Parameters:
    • Type definition
      • FunctionType
        • Parameters:
"},{"location":"dialects/Core/Core/#operation-definition","title":"Operation definition","text":""},{"location":"dialects/Core/Core/#corebinland-vastcorebinlandop","title":"core.bin.land (::vast::core::BinLAndOp)","text":"

VAST core dialect logical binary operation

Syntax:

operation ::= `core.bin.land` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

Core dialect logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type"},{"location":"dialects/Core/Core/#operands","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/Core/Core/#results","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Core/Core/#corebinlor-vastcorebinlorop","title":"core.bin.lor (::vast::core::BinLOrOp)","text":"

VAST core dialect logical binary operation

Syntax:

operation ::= `core.bin.lor` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

Core dialect logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type"},{"location":"dialects/Core/Core/#operands_1","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/Core/Core/#results_1","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Core/Core/#coreimplicitreturn-vastcoreimplicitreturnop","title":"core.implicit.return (::vast::core::ImplicitReturnOp)","text":"

VAST implicit return

Syntax:

operation ::= `core.implicit.return` $result `:` type($result) attr-dict\n

Op representing return that wasn't explicitely written in the source (e.g. in void fun(){}).

Traits: return_trait, soft_terminator

"},{"location":"dialects/Core/Core/#operands_2","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/Core/Core/#corelazyop-vastcorelazyop","title":"core.lazy.op (::vast::core::LazyOp)","text":"

Lazily evaluate a region.

Syntax:

operation ::= `core.lazy.op` $lazy attr-dict `:` type(results)\n

The operation serves to encapsulate delayed evaluation in its region.

Traits: NoTerminator

"},{"location":"dialects/Core/Core/#results_2","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Core/Core/#corescope-vastcorescopeop","title":"core.scope (::vast::core::ScopeOp)","text":"

VAST scope declaration

Syntax:

operation ::= `core.scope` $body attr-dict\n

Scope operation servers to represent explicitly high-level code scope. Other control flow operations represent scopes implicitly. It is a single-region operation.

Traits: NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/Core/Core/#coreselect-vastcoreselectop","title":"core.select (::vast::core::SelectOp)","text":"

Select a value based on condition.

Syntax:

operation ::= `core.select` $cond `,` $thenRegion `,` $elseRegion attr-dict `:` functional-type(operands, results)\n

Usual select operation. First operand is selected if predicate is true, second otherwise (to mirror how ternary works in C).

%result = %cond %lhs, %rhs : type"},{"location":"dialects/Core/Core/#operands_3","title":"Operands:","text":"Operand Description cond any type thenRegion any type elseRegion any type"},{"location":"dialects/Core/Core/#results_3","title":"Results:","text":"Result Description results any type"},{"location":"dialects/Core/Core/#attribute-definition","title":"Attribute definition","text":""},{"location":"dialects/Core/Core/#booleanattr","title":"BooleanAttr","text":"

An Attribute containing a boolean value

Syntax:

#core.bool<\n  ::mlir::Type,   # type\n  bool   # value\n>\n

An boolean attribute is a literal attribute that represents a boolean value.

"},{"location":"dialects/Core/Core/#parameters","title":"Parameters:","text":"Parameter C++ type Description type ::mlir::Type value bool"},{"location":"dialects/Core/Core/#globallinkagekindattr","title":"GlobalLinkageKindAttr","text":"

Linkage type/kind

Syntax:

#core.global_linkage_kind<\n  ::vast::core::GlobalLinkageKind   # value\n>\n
"},{"location":"dialects/Core/Core/#parameters_1","title":"Parameters:","text":"Parameter C++ type Description value ::vast::core::GlobalLinkageKind an enum of type GlobalLinkageKind"},{"location":"dialects/Core/Core/#floatattr","title":"FloatAttr","text":"

An Attribute containing a floating point value

Syntax:

#core.float<\n  ::mlir::Type,   # type\n  ::llvm::APFloat   # value\n>\n

A float attribute is a literal attribute that represents a floating point value of the specified floating point type.

"},{"location":"dialects/Core/Core/#parameters_2","title":"Parameters:","text":"Parameter C++ type Description type ::mlir::Type value ::llvm::APFloat"},{"location":"dialects/Core/Core/#integerattr","title":"IntegerAttr","text":"

An Attribute containing a integer value

Syntax:

#core.integer<\n  ::mlir::Type,   # type\n  ::llvm::APSInt   # value\n>\n

An integer attribute is a literal attribute that represents an integral value of the specified integer type.

"},{"location":"dialects/Core/Core/#parameters_3","title":"Parameters:","text":"Parameter C++ type Description type ::mlir::Type value ::llvm::APSInt"},{"location":"dialects/Core/Core/#sourcelanguageattr","title":"SourceLanguageAttr","text":"

Module source language

Syntax:

#core.lang<\n  ::vast::core::SourceLanguage   # value\n>\n

Represents the source language used to generate the module.

Example:

// Module compiled from C.\nmodule attributes {vast.core.lang = vast.core.lang<c>} {}\n// Module compiled from C++.\nmodule attributes {vast.core.lang = vast.core.lang<cxx>} {}\n
"},{"location":"dialects/Core/Core/#parameters_4","title":"Parameters:","text":"Parameter C++ type Description value ::vast::core::SourceLanguage an enum of type SourceLanguage"},{"location":"dialects/Core/Core/#voidattr","title":"VoidAttr","text":"

Attribute to represent void value.

Syntax:

#core.void<\n  ::mlir::Type   # type\n>\n

The VoidAttr is used to return void from statements uniformly.

"},{"location":"dialects/Core/Core/#parameters_5","title":"Parameters:","text":"Parameter C++ type Description type ::mlir::Type"},{"location":"dialects/Core/Core/#type-definition","title":"Type definition","text":""},{"location":"dialects/Core/Core/#functiontype","title":"FunctionType","text":"

Vast function type

Syntax:

!core.fn<\n  ::llvm::ArrayRef<Type>,   # inputs\n  ::llvm::ArrayRef<Type>,   # results\n  bool   # varArg\n>\n

The !core.fn is a function type. It consists of a variadic return type, and list of parameter types and can optionally be variadic.

Example:

!core.fn<!hl.bool ()>\n!core.fn<!hl.int (!hl.char, !hl.char)>\n!core.fn<!i32 (!i32, ...)>\n
"},{"location":"dialects/Core/Core/#parameters_6","title":"Parameters:","text":"Parameter C++ type Description inputs ::llvm::ArrayRef<Type> results ::llvm::ArrayRef<Type> varArg bool"},{"location":"dialects/HighLevel/HighLevel/","title":"High Level","text":""},{"location":"dialects/HighLevel/HighLevel/#hl-dialect","title":"'hl' Dialect","text":"

A high-level verbose program analysis MLIR dialect. This dialect intends capture highevel constructs of C/C++ for further program analysis.

  • 'hl' Dialect
    • Operation definition
      • hl.access (::vast::hl::AccessSpecifierOp)
        • Attributes:
      • hl.add (::vast::hl::AddIOp)
        • Operands:
        • Results:
      • hl.addressof (::vast::hl::AddressOf)
        • Operands:
        • Results:
      • hl.alignof.expr (::vast::hl::AlignOfExprOp)
        • Results:
      • hl.alignof.type (::vast::hl::AlignOfTypeOp)
        • Attributes:
        • Results:
      • hl.asm (::vast::hl::AsmOp)
        • Attributes:
        • Operands:
      • hl.assign (::vast::hl::AssignOp)
        • Operands:
        • Results:
      • hl.assign.add (::vast::hl::AddIAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.and (::vast::hl::BinAndAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.ashr (::vast::hl::BinAShrAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.lshr (::vast::hl::BinLShrAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.or (::vast::hl::BinOrAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.shl (::vast::hl::BinShlAssignOp)
        • Operands:
        • Results:
      • hl.assign.bin.xor (::vast::hl::BinXorAssignOp)
        • Operands:
        • Results:
      • hl.assign.fadd (::vast::hl::AddFAssignOp)
        • Operands:
        • Results:
      • hl.assign.fdiv (::vast::hl::DivFAssignOp)
        • Operands:
        • Results:
      • hl.assign.fmul (::vast::hl::MulFAssignOp)
        • Operands:
        • Results:
      • hl.assign.frem (::vast::hl::RemFAssignOp)
        • Operands:
        • Results:
      • hl.assign.fsub (::vast::hl::SubFAssignOp)
        • Operands:
        • Results:
      • hl.assign.mul (::vast::hl::MulIAssignOp)
        • Operands:
        • Results:
      • hl.assign.sdiv (::vast::hl::DivSAssignOp)
        • Operands:
        • Results:
      • hl.assign.srem (::vast::hl::RemSAssignOp)
        • Operands:
        • Results:
      • hl.assign.sub (::vast::hl::SubIAssignOp)
        • Operands:
        • Results:
      • hl.assign.udiv (::vast::hl::DivUAssignOp)
        • Operands:
        • Results:
      • hl.assign.urem (::vast::hl::RemUAssignOp)
        • Operands:
        • Results:
      • hl.base (::vast::hl::CxxBaseSpecifierOp)
        • Attributes:
      • hl.bin.and (::vast::hl::BinAndOp)
        • Operands:
        • Results:
      • hl.bin.ashr (::vast::hl::BinAShrOp)
        • Operands:
        • Results:
      • hl.bin.comma (::vast::hl::BinComma)
        • Operands:
        • Results:
      • hl.bin.land (::vast::hl::BinLAndOp)
        • Results:
      • hl.bin.lor (::vast::hl::BinLOrOp)
        • Results:
      • hl.bin.lshr (::vast::hl::BinLShrOp)
        • Operands:
        • Results:
      • hl.bin.or (::vast::hl::BinOrOp)
        • Operands:
        • Results:
      • hl.bin.shl (::vast::hl::BinShlOp)
        • Operands:
        • Results:
      • hl.bin.xor (::vast::hl::BinXorOp)
        • Operands:
        • Results:
      • hl.break (::vast::hl::BreakOp)
      • hl.builtin_bitcast (::vast::hl::BuiltinBitCastOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.call (::vast::hl::CallOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.case (::vast::hl::CaseOp)
      • hl.class (::vast::hl::ClassDeclOp)
        • Attributes:
      • hl.cmp (::vast::hl::CmpOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.cond (::vast::hl::CondOp)
        • Results:
      • hl.cond.yield (::vast::hl::CondYieldOp)
        • Operands:
      • hl.const (::vast::hl::ConstantOp)
        • Attributes:
        • Results:
      • hl.continue (::vast::hl::ContinueOp)
      • hl.cstyle_cast (::vast::hl::CStyleCastOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.cxxstruct (::vast::hl::CxxStructDeclOp)
        • Attributes:
      • hl.default (::vast::hl::DefaultOp)
      • hl.deref (::vast::hl::Deref)
        • Operands:
        • Results:
      • hl.do (::vast::hl::DoOp)
      • hl.empty.decl (::vast::hl::EmptyDeclOp)
      • hl.enum (::vast::hl::EnumDeclOp)
        • Attributes:
      • hl.enum.const (::vast::hl::EnumConstantOp)
        • Attributes:
      • hl.enumref (::vast::hl::EnumRefOp)
        • Attributes:
        • Results:
      • hl.expr (::vast::hl::ExprOp)
        • Results:
      • hl.fadd (::vast::hl::AddFOp)
        • Operands:
        • Results:
      • hl.fcmp (::vast::hl::FCmpOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.fdiv (::vast::hl::DivFOp)
        • Operands:
        • Results:
      • hl.field (::vast::hl::FieldDeclOp)
        • Attributes:
      • hl.fmul (::vast::hl::MulFOp)
        • Operands:
        • Results:
      • hl.for (::vast::hl::ForOp)
      • hl.frem (::vast::hl::RemFOp)
        • Operands:
        • Results:
      • hl.fsub (::vast::hl::SubFOp)
        • Operands:
        • Results:
      • hl.func (::vast::hl::FuncOp)
        • Attributes:
      • hl.funcref (::vast::hl::FuncRefOp)
        • Attributes:
        • Results:
      • hl.globref (::vast::hl::GlobalRefOp)
        • Attributes:
        • Results:
      • hl.gnu.extension (::vast::hl::ExtensionOp)
        • Operands:
        • Results:
      • hl.goto (::vast::hl::GotoStmt)
        • Operands:
      • hl.if (::vast::hl::IfOp)
      • hl.implicit_cast (::vast::hl::ImplicitCastOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.indirect_call (::vast::hl::IndirectCallOp)
        • Operands:
        • Results:
      • hl.initlist (::vast::hl::InitListExpr)
        • Operands:
        • Results:
      • hl.label (::vast::hl::LabelStmt)
        • Operands:
      • hl.label.decl (::vast::hl::LabelDeclOp)
        • Attributes:
        • Results:
      • hl.labeladdr (::vast::hl::AddrLabelExpr)
        • Operands:
        • Results:
      • hl.lnot (::vast::hl::LNotOp)
        • Operands:
        • Results:
      • hl.member (::vast::hl::RecordMemberOp)
        • Attributes:
        • Operands:
        • Results:
      • hl.minus (::vast::hl::MinusOp)
        • Operands:
        • Results:
      • hl.mul (::vast::hl::MulIOp)
        • Operands:
        • Results:
      • hl.not (::vast::hl::NotOp)
        • Operands:
        • Results:
      • hl.plus (::vast::hl::PlusOp)
        • Operands:
        • Results:
      • hl.post.dec (::vast::hl::PostDecOp)
        • Operands:
        • Results:
      • hl.post.inc (::vast::hl::PostIncOp)
        • Operands:
        • Results:
      • hl.pre.dec (::vast::hl::PreDecOp)
        • Operands:
        • Results:
      • hl.pre.inc (::vast::hl::PreIncOp)
        • Operands:
        • Results:
      • hl.predefined.expr (::vast::hl::PredefinedExpr)
        • Attributes:
        • Operands:
        • Results:
      • hl.ref (::vast::hl::DeclRefOp)
        • Operands:
        • Results:
      • hl.return (::vast::hl::ReturnOp)
        • Operands:
      • hl.sdiv (::vast::hl::DivSOp)
        • Operands:
        • Results:
      • hl.sizeof.expr (::vast::hl::SizeOfExprOp)
        • Results:
      • hl.sizeof.type (::vast::hl::SizeOfTypeOp)
        • Attributes:
        • Results:
      • hl.skip (::vast::hl::SkipStmt)
      • hl.srem (::vast::hl::RemSOp)
        • Operands:
        • Results:
      • hl.stmt.expr (::vast::hl::StmtExprOp)
        • Results:
      • hl.struct (::vast::hl::StructDeclOp)
        • Attributes:
      • hl.sub (::vast::hl::SubIOp)
        • Operands:
        • Results:
      • hl.subscript (::vast::hl::SubscriptOp)
        • Operands:
        • Results:
      • hl.switch (::vast::hl::SwitchOp)
      • hl.this (::vast::hl::ThisOp)
        • Results:
      • hl.translation_unit (::vast::hl::TranslationUnitOp)
      • hl.type (::vast::hl::TypeDeclOp)
        • Attributes:
      • hl.type.yield (::vast::hl::TypeYieldOp)
        • Operands:
      • hl.typedef (::vast::hl::TypeDefOp)
        • Attributes:
      • hl.typeof.expr (::vast::hl::TypeOfExprOp)
        • Attributes:
      • hl.typeof.type (::vast::hl::TypeOfTypeOp)
        • Attributes:
      • hl.udiv (::vast::hl::DivUOp)
        • Operands:
        • Results:
      • hl.union (::vast::hl::UnionDeclOp)
        • Attributes:
      • hl.unreachable (::vast::hl::UnreachableOp)
      • hl.urem (::vast::hl::RemUOp)
        • Operands:
        • Results:
      • hl.value.yield (::vast::hl::ValueYieldOp)
        • Operands:
      • hl.var (::vast::hl::VarDeclOp)
        • Attributes:
        • Results:
      • hl.while (::vast::hl::WhileOp)
    • Attribute definition
      • AllocAlignAttr
        • Parameters:
      • AllocSizeAttr
        • Parameters:
      • AnnotationAttr
        • Parameters:
      • AsmLabelAttr
        • Parameters:
      • BuiltinAttr
        • Parameters:
      • CVQualifiersAttr
        • Parameters:
      • CVRQualifiersAttr
        • Parameters:
      • ConstAttr
      • FormatAttr
        • Parameters:
      • LoaderUninitializedAttr
      • ModeAttr
        • Parameters:
      • NoInstrumentFunctionAttr
      • NoThrowAttr
      • NonNullAttr
      • PackedAttr
      • PureAttr
      • RestrictAttr
      • SectionAttr
        • Parameters:
      • UCVQualifiersAttr
        • Parameters:
      • WarnUnusedResultAttr
    • Type definition
      • AdjustedType
        • Parameters:
      • ArrayType
        • Parameters:
      • AttributedType
        • Parameters:
      • BFloat16Type
        • Parameters:
      • BoolType
        • Parameters:
      • CharType
        • Parameters:
      • DecayedType
        • Parameters:
      • DoubleType
        • Parameters:
      • ElaboratedType
        • Parameters:
      • EnumType
        • Parameters:
      • Float128Type
        • Parameters:
      • FloatType
        • Parameters:
      • HalfType
        • Parameters:
      • Int128Type
        • Parameters:
      • IntType
        • Parameters:
      • LValueType
        • Parameters:
      • LabelType
      • LongDoubleType
        • Parameters:
      • LongLongType
        • Parameters:
      • LongType
        • Parameters:
      • ParenType
        • Parameters:
      • PointerType
        • Parameters:
      • RValueType
        • Parameters:
      • RecordType
        • Parameters:
      • ReferenceType
        • Parameters:
      • ShortType
        • Parameters:
      • TypeOfExprType
        • Parameters:
      • TypeOfTypeType
        • Parameters:
      • TypedefType
        • Parameters:
      • VoidType
        • Parameters:
"},{"location":"dialects/HighLevel/HighLevel/#operation-definition","title":"Operation definition","text":""},{"location":"dialects/HighLevel/HighLevel/#hlaccess-vasthlaccessspecifierop","title":"hl.access (::vast::hl::AccessSpecifierOp)","text":"

VAST C++ access specifier declaration

Syntax:

operation ::= `hl.access` attr-dict $spec\n

VAST C++ access specifier declaration

"},{"location":"dialects/HighLevel/HighLevel/#attributes","title":"Attributes:","text":"Attribute MLIR Type Description spec ::vast::hl::AccessSpecifierAttr Access specifier"},{"location":"dialects/HighLevel/HighLevel/#hladd-vasthladdiop","title":"hl.add (::vast::hl::AddIOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.add` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Traits: Commutative

"},{"location":"dialects/HighLevel/HighLevel/#operands","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hladdressof-vasthladdressof","title":"hl.addressof (::vast::hl::AddressOf)","text":"

VAST addressof operation

Syntax:

operation ::= `hl.addressof` $value attr-dict `:` type($value) `->` type($result)\n

VAST addressof operation

"},{"location":"dialects/HighLevel/HighLevel/#operands_1","title":"Operands:","text":"Operand Description value lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#results_1","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlalignofexpr-vasthlalignofexprop","title":"hl.alignof.expr (::vast::hl::AlignOfExprOp)","text":"

VAST expr alignof operator

Syntax:

operation ::= `hl.alignof.expr` attr-dict `->` type($result) $expr\n

VAST expr alignof operator

"},{"location":"dialects/HighLevel/HighLevel/#results_2","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlalignoftype-vasthlalignoftypeop","title":"hl.alignof.type (::vast::hl::AlignOfTypeOp)","text":"

VAST type alignof operator

Syntax:

operation ::= `hl.alignof.type` $arg attr-dict `->` type($result)\n

VAST type alignof operator

"},{"location":"dialects/HighLevel/HighLevel/#attributes_1","title":"Attributes:","text":"Attribute MLIR Type Description arg ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#results_3","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlasm-vasthlasmop","title":"hl.asm (::vast::hl::AsmOp)","text":"

VAST operation for inline assembly

Syntax:

operation ::= `hl.asm` attr-dict $asm_template `(`($output_names $asm_outputs^ `:` $output_constraints)? `)` `(` (`ins` `:`$input_names $asm_inputs^ `:` $input_constraints)? `)` `(`( $clobbers^)?`)` `(`( $labels^)?`)` `:` functional-type(operands, results)\n

VAST operation mirroring the GCCAsmStmt in clang AST. It prints a name for every operand (either its id or user-supplied string). Traits: AttrSizedOperandSegments

"},{"location":"dialects/HighLevel/HighLevel/#attributes_2","title":"Attributes:","text":"Attribute MLIR Type Description asm_template ::mlir::StringAttr string attribute is_volatile ::mlir::UnitAttr unit attribute has_goto ::mlir::UnitAttr unit attribute output_names ::mlir::ArrayAttr array attribute input_names ::mlir::ArrayAttr array attribute output_constraints ::mlir::ArrayAttr array attribute input_constraints ::mlir::ArrayAttr array attribute clobbers ::mlir::ArrayAttr array attribute"},{"location":"dialects/HighLevel/HighLevel/#operands_2","title":"Operands:","text":"Operand Description asm_outputs any type asm_inputs any type labels any type"},{"location":"dialects/HighLevel/HighLevel/#hlassign-vasthlassignop","title":"hl.assign (::vast::hl::AssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_3","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_4","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignadd-vasthladdiassignop","title":"hl.assign.add (::vast::hl::AddIAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.add` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_4","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_5","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinand-vasthlbinandassignop","title":"hl.assign.bin.and (::vast::hl::BinAndAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.and` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_5","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_6","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinashr-vasthlbinashrassignop","title":"hl.assign.bin.ashr (::vast::hl::BinAShrAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.ashr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_6","title":"Operands:","text":"Operand Description src lvalue to integer like type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_7","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinlshr-vasthlbinlshrassignop","title":"hl.assign.bin.lshr (::vast::hl::BinLShrAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.lshr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_7","title":"Operands:","text":"Operand Description src lvalue to integer like type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_8","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinor-vasthlbinorassignop","title":"hl.assign.bin.or (::vast::hl::BinOrAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.or` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_8","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_9","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinshl-vasthlbinshlassignop","title":"hl.assign.bin.shl (::vast::hl::BinShlAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.shl` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_9","title":"Operands:","text":"Operand Description src lvalue to integer like type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_10","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlassignbinxor-vasthlbinxorassignop","title":"hl.assign.bin.xor (::vast::hl::BinXorAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.xor` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_10","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_11","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignfadd-vasthladdfassignop","title":"hl.assign.fadd (::vast::hl::AddFAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fadd` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_11","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_12","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignfdiv-vasthldivfassignop","title":"hl.assign.fdiv (::vast::hl::DivFAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_12","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_13","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignfmul-vasthlmulfassignop","title":"hl.assign.fmul (::vast::hl::MulFAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fmul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_13","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_14","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignfrem-vasthlremfassignop","title":"hl.assign.frem (::vast::hl::RemFAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.frem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_14","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_15","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignfsub-vasthlsubfassignop","title":"hl.assign.fsub (::vast::hl::SubFAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fsub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_15","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_16","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignmul-vasthlmuliassignop","title":"hl.assign.mul (::vast::hl::MulIAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.mul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_16","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_17","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignsdiv-vasthldivsassignop","title":"hl.assign.sdiv (::vast::hl::DivSAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.sdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_17","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_18","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignsrem-vasthlremsassignop","title":"hl.assign.srem (::vast::hl::RemSAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.srem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_18","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_19","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignsub-vasthlsubiassignop","title":"hl.assign.sub (::vast::hl::SubIAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.sub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_19","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_20","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignudiv-vasthldivuassignop","title":"hl.assign.udiv (::vast::hl::DivUAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.udiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_20","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_21","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlassignurem-vasthlremuassignop","title":"hl.assign.urem (::vast::hl::RemUAssignOp)","text":"

VAST compound assign operation

Syntax:

operation ::= `hl.assign.urem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)\n

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_21","title":"Operands:","text":"Operand Description src lvalue to any type dst any type"},{"location":"dialects/HighLevel/HighLevel/#results_22","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbase-vasthlcxxbasespecifierop","title":"hl.base (::vast::hl::CxxBaseSpecifierOp)","text":"

VAST base class specifier

Syntax:

operation ::= `hl.base` $type attr-dict $access (`virtual` $is_virtual^)?\n

VAST base class specifier Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_3","title":"Attributes:","text":"Attribute MLIR Type Description type ::mlir::TypeAttr any type attribute access ::vast::hl::AccessSpecifierAttr Access specifier is_virtual ::mlir::UnitAttr unit attribute"},{"location":"dialects/HighLevel/HighLevel/#hlbinand-vasthlbinandop","title":"hl.bin.and (::vast::hl::BinAndOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.and` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_22","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_23","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbinashr-vasthlbinashrop","title":"hl.bin.ashr (::vast::hl::BinAShrOp)","text":"

VAST binary shift operation

Syntax:

operation ::= `hl.bin.ashr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_23","title":"Operands:","text":"Operand Description lhs integer like type rhs integer like type"},{"location":"dialects/HighLevel/HighLevel/#results_24","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlbincomma-vasthlbincomma","title":"hl.bin.comma (::vast::hl::BinComma)","text":"

VAST binary operation

Syntax:

operation ::= `hl.bin.comma` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n
"},{"location":"dialects/HighLevel/HighLevel/#operands_24","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_25","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbinland-vasthlbinlandop","title":"hl.bin.land (::vast::hl::BinLAndOp)","text":"

VAST logical binary operation

Syntax:

operation ::= `hl.bin.land` $lhs`,` $rhs attr-dict `:` type(results)\n

High-level logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type"},{"location":"dialects/HighLevel/HighLevel/#results_26","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbinlor-vasthlbinlorop","title":"hl.bin.lor (::vast::hl::BinLOrOp)","text":"

VAST logical binary operation

Syntax:

operation ::= `hl.bin.lor` $lhs`,` $rhs attr-dict `:` type(results)\n

High-level logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type"},{"location":"dialects/HighLevel/HighLevel/#results_27","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbinlshr-vasthlbinlshrop","title":"hl.bin.lshr (::vast::hl::BinLShrOp)","text":"

VAST binary shift operation

Syntax:

operation ::= `hl.bin.lshr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_25","title":"Operands:","text":"Operand Description lhs integer like type rhs integer like type"},{"location":"dialects/HighLevel/HighLevel/#results_28","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlbinor-vasthlbinorop","title":"hl.bin.or (::vast::hl::BinOrOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.or` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_26","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_29","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbinshl-vasthlbinshlop","title":"hl.bin.shl (::vast::hl::BinShlOp)","text":"

VAST binary shift operation

Syntax:

operation ::= `hl.bin.shl` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_27","title":"Operands:","text":"Operand Description lhs integer like type rhs integer like type"},{"location":"dialects/HighLevel/HighLevel/#results_30","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlbinxor-vasthlbinxorop","title":"hl.bin.xor (::vast::hl::BinXorOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.xor` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_28","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_31","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlbreak-vasthlbreakop","title":"hl.break (::vast::hl::BreakOp)","text":"

VAST break statement

Syntax:

operation ::= `hl.break` attr-dict\n

VAST break statement Traits: NoRegionArguments, NoTerminator, soft_terminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlbuiltin_bitcast-vasthlbuiltinbitcastop","title":"hl.builtin_bitcast (::vast::hl::BuiltinBitCastOp)","text":"

VAST cast operation

Syntax:

operation ::= `hl.builtin_bitcast` $value $kind attr-dict `:` type($value) `->` type($result)\n

VAST cast operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_4","title":"Attributes:","text":"Attribute MLIR Type Description kind ::vast::hl::CastKindAttr cast kind"},{"location":"dialects/HighLevel/HighLevel/#operands_29","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/HighLevel/HighLevel/#results_32","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlcall-vasthlcallop","title":"hl.call (::vast::hl::CallOp)","text":"

VAST call operation

Syntax:

operation ::= `hl.call` $callee `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )\n

VAST call operation Interfaces: CallOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#attributes_5","title":"Attributes:","text":"Attribute MLIR Type Description callee ::mlir::FlatSymbolRefAttr flat symbol reference attribute"},{"location":"dialects/HighLevel/HighLevel/#operands_30","title":"Operands:","text":"Operand Description argOperands any type"},{"location":"dialects/HighLevel/HighLevel/#results_33","title":"Results:","text":"Result Description results any type"},{"location":"dialects/HighLevel/HighLevel/#hlcase-vasthlcaseop","title":"hl.case (::vast::hl::CaseOp)","text":"

VAST case statement

Syntax:

operation ::= `hl.case` $lhs $body attr-dict\n

The operation represents a single case of a switch statement.

The generic form of the operation is as follows:

hl.case { ... / lhs/check region / hl.value.yield %val : !hl.type } { ... / body region / }

It represents a C statement of form case lhs: body;.

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlclass-vasthlclassdeclop","title":"hl.class (::vast::hl::ClassDeclOp)","text":"

VAST C++ class declaration

Syntax:

operation ::= `hl.class` $name attr-dict `:` `bases` $bases $fields\n

VAST C++ class declaration Traits: NoTerminator

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_6","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#hlcmp-vasthlcmpop","title":"hl.cmp (::vast::hl::CmpOp)","text":"

VAST comparison operation

Syntax:

operation ::= `hl.cmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)\n

VAST comparison operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_7","title":"Attributes:","text":"Attribute MLIR Type Description predicate ::vast::hl::PredicateAttr comparison predicate"},{"location":"dialects/HighLevel/HighLevel/#operands_31","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_34","title":"Results:","text":"Result Description result bool or integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlcond-vasthlcondop","title":"hl.cond (::vast::hl::CondOp)","text":"

VAST conditional statement

Syntax:

operation ::= `hl.cond` $condRegion `?` $thenRegion `:` $elseRegion attr-dict `:` type(results)\n

The operation takes builders of three regions -- condition, true branch and false branch. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.cond { ... / condition region / hl.cond.yield %cond : !hl.bool } ? { ... / true region / } : { ... / false region / }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#results_35","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlcondyield-vasthlcondyieldop","title":"hl.cond.yield (::vast::hl::CondYieldOp)","text":"

Condition yield operation

Syntax:

operation ::= `hl.cond.yield` attr-dict $result `:` type($result)\n

A condition yield operation is used to terminate the region representing condition expression of control flow operations IfOp, WhileOp, ForOp and DoOp. It yields a boolean value for the conditional branch.

The custom assembly form of the operation is as follows:

hl.cond.yield result : BoolType

Traits: HasParent, Terminator"},{"location":"dialects/HighLevel/HighLevel/#operands_32","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlconst-vasthlconstantop","title":"hl.const (::vast::hl::ConstantOp)","text":"

VAST value constant

Syntax:

operation ::= `hl.const` $value attr-dict\n

VAST value constant Traits: ConstantLike

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#attributes_8","title":"Attributes:","text":"Attribute MLIR Type Description value ::mlir::TypedAttr TypedAttr instance"},{"location":"dialects/HighLevel/HighLevel/#results_36","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlcontinue-vasthlcontinueop","title":"hl.continue (::vast::hl::ContinueOp)","text":"

VAST continue statement

Syntax:

operation ::= `hl.continue` attr-dict\n

VAST continue statement Traits: NoRegionArguments, NoTerminator, soft_terminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlcstyle_cast-vasthlcstylecastop","title":"hl.cstyle_cast (::vast::hl::CStyleCastOp)","text":"

VAST cast operation

Syntax:

operation ::= `hl.cstyle_cast` $value $kind attr-dict `:` type($value) `->` type($result)\n

VAST cast operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_9","title":"Attributes:","text":"Attribute MLIR Type Description kind ::vast::hl::CastKindAttr cast kind"},{"location":"dialects/HighLevel/HighLevel/#operands_33","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/HighLevel/HighLevel/#results_37","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlcxxstruct-vasthlcxxstructdeclop","title":"hl.cxxstruct (::vast::hl::CxxStructDeclOp)","text":"

VAST C++ struct declaration

Syntax:

operation ::= `hl.cxxstruct` $name attr-dict `:` `bases` $bases $fields\n

VAST C++ struct declaration Traits: NoTerminator

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_10","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#hldefault-vasthldefaultop","title":"hl.default (::vast::hl::DefaultOp)","text":"

VAST default statement

Syntax:

operation ::= `hl.default` $body attr-dict\n

VAST default statement Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlderef-vasthlderef","title":"hl.deref (::vast::hl::Deref)","text":"

VAST deref operation

Syntax:

operation ::= `hl.deref` $addr attr-dict `:` type($addr) `->` type($result)\n

VAST deref operation

"},{"location":"dialects/HighLevel/HighLevel/#operands_34","title":"Operands:","text":"Operand Description addr any type"},{"location":"dialects/HighLevel/HighLevel/#results_38","title":"Results:","text":"Result Description result lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#hldo-vasthldoop","title":"hl.do (::vast::hl::DoOp)","text":"

VAST do-while statement

Syntax:

operation ::= `hl.do` $bodyRegion `while` $condRegion attr-dict\n

The operation represents a do-while statement.

The generic form of the operation is as follows:

hl.do { ... / body region / } cond { ... / cond region / hl.cond.yield %cond : !hl.bool }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlemptydecl-vasthlemptydeclop","title":"hl.empty.decl (::vast::hl::EmptyDeclOp)","text":"

Syntax:

operation ::= `hl.empty.decl` attr-dict\n
"},{"location":"dialects/HighLevel/HighLevel/#hlenum-vasthlenumdeclop","title":"hl.enum (::vast::hl::EnumDeclOp)","text":"

VAST enum declaration

Syntax:

operation ::= `hl.enum` $name attr-dict `:` ($type^ $constants)?\n

Enum declaration serves to declare region for enum constant declarations. It also defines an underlying type.

Traits: NoTerminator

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_11","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute type ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#hlenumconst-vasthlenumconstantop","title":"hl.enum.const (::vast::hl::EnumConstantOp)","text":"

VAST enum constant declaration

Syntax:

operation ::= `hl.enum.const` $name `=` $value attr-dict (`init` $init^)?\n

Enumeration constant servers to link name to an enum value. It is required to be scoped in Enum operation. For example:

hl.enum.const \"F\" = 2 : !hl.int\n

A constant can have a constant expression initializer:

hl.enum.const \"G\" = #core.integer<12> : !hl.int init  {\n  %0 = hl.enumref \"F\" : !hl.int\n  %1 = hl.enumref \"C\" : !hl.int\n  %2 = hl.add %0, %1 : !hl.int\n  hl.value.yield %2 : !hl.int\n}\n
"},{"location":"dialects/HighLevel/HighLevel/#attributes_12","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute value ::mlir::TypedAttr TypedAttr instance"},{"location":"dialects/HighLevel/HighLevel/#hlenumref-vasthlenumrefop","title":"hl.enumref (::vast::hl::EnumRefOp)","text":"

VAST variable reference declaration

Syntax:

operation ::= `hl.enumref` $value attr-dict `:` type($result)\n

VAST variable reference declaration

"},{"location":"dialects/HighLevel/HighLevel/#attributes_13","title":"Attributes:","text":"Attribute MLIR Type Description value ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#results_39","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlexpr-vasthlexprop","title":"hl.expr (::vast::hl::ExprOp)","text":"

VAST expression

Syntax:

operation ::= `hl.expr` attr-dict `:` type($result) $subexpr\n

VAST expression Traits: SingleBlock

"},{"location":"dialects/HighLevel/HighLevel/#results_40","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfadd-vasthladdfop","title":"hl.fadd (::vast::hl::AddFOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fadd` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_35","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_41","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfcmp-vasthlfcmpop","title":"hl.fcmp (::vast::hl::FCmpOp)","text":"

VAST flaoting point comparison operation

Syntax:

operation ::= `hl.fcmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)\n

VAST floating point comparison operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_14","title":"Attributes:","text":"Attribute MLIR Type Description predicate ::vast::hl::FPredicateAttr floating point comparison predicate"},{"location":"dialects/HighLevel/HighLevel/#operands_36","title":"Operands:","text":"Operand Description lhs float like type rhs float like type"},{"location":"dialects/HighLevel/HighLevel/#results_42","title":"Results:","text":"Result Description result bool or integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlfdiv-vasthldivfop","title":"hl.fdiv (::vast::hl::DivFOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_37","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_43","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfield-vasthlfielddeclop","title":"hl.field (::vast::hl::FieldDeclOp)","text":"

VAST record field declaration

Syntax:

operation ::= `hl.field` $name attr-dict (`bw` $bits^)? `:` $type\n

VAST record field declaration Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_15","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute type ::mlir::TypeAttr any type attribute bits ::mlir::IntegerAttr 32-bit signless integer attribute"},{"location":"dialects/HighLevel/HighLevel/#hlfmul-vasthlmulfop","title":"hl.fmul (::vast::hl::MulFOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fmul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_38","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_44","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfor-vasthlforop","title":"hl.for (::vast::hl::ForOp)","text":"

VAST for statement

Syntax:

operation ::= `hl.for` $condRegion `incr` $incrRegion attr-dict `do` $bodyRegion\n

Operation represents a for-loop statement.

The generic form of the operation is as follows:

hl.for { ... / cond region / hl.cond.yield %cond : !hl.bool } incr { ... / increment/update region / } do { ... / body region / }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlfrem-vasthlremfop","title":"hl.frem (::vast::hl::RemFOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.frem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_39","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_45","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfsub-vasthlsubfop","title":"hl.fsub (::vast::hl::SubFOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fsub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_40","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_46","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlfunc-vasthlfuncop","title":"hl.func (::vast::hl::FuncOp)","text":"

VAST function template

Syntax:

operation ::= `hl.func` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)\n

Inspired by cir::FuncOp and mlir::func::FuncOp:

Operations within the function cannot implicitly capture values defined outside of the function, i.e. Functions are IsolatedFromAbove. All external references must use function arguments or attributes that establish a symbolic connection (e.g. symbols referenced by name via a string attribute like SymbolRefAttr). An external function declaration (used when referring to a function declared in some other module) has no body.

The function linkage information is specified by linkage, as defined by GlobalLinkageKind attribute.

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_16","title":"Attributes:","text":"Attribute MLIR Type Description sym_name ::mlir::StringAttr string attribute function_type ::mlir::TypeAttr type attribute of function type linkage ::vast::core::GlobalLinkageKindAttr global linkage kind sym_visibility ::mlir::StringAttr string attribute arg_attrs ::mlir::ArrayAttr Array of dictionary attributes res_attrs ::mlir::ArrayAttr Array of dictionary attributes"},{"location":"dialects/HighLevel/HighLevel/#hlfuncref-vasthlfuncrefop","title":"hl.funcref (::vast::hl::FuncRefOp)","text":"

VAST function reference declaration

Syntax:

operation ::= `hl.funcref` $function attr-dict `:` type($result)\n

VAST function reference declaration

"},{"location":"dialects/HighLevel/HighLevel/#attributes_17","title":"Attributes:","text":"Attribute MLIR Type Description function ::mlir::FlatSymbolRefAttr flat symbol reference attribute"},{"location":"dialects/HighLevel/HighLevel/#results_47","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlglobref-vasthlglobalrefop","title":"hl.globref (::vast::hl::GlobalRefOp)","text":"

VAST global variable reference declaration

Syntax:

operation ::= `hl.globref` $global attr-dict `:` type($result)\n

VAST global variable reference declaration

"},{"location":"dialects/HighLevel/HighLevel/#attributes_18","title":"Attributes:","text":"Attribute MLIR Type Description global ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#results_48","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlgnuextension-vasthlextensionop","title":"hl.gnu.extension (::vast::hl::ExtensionOp)","text":"

VAST extension (__extension__) keyword

Syntax:

operation ::= `hl.gnu.extension` $value attr-dict `:` type($value) `->` type($result)\n

VAST op corresponding to GNU extension keyword.

"},{"location":"dialects/HighLevel/HighLevel/#operands_41","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/HighLevel/HighLevel/#results_49","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlgoto-vasthlgotostmt","title":"hl.goto (::vast::hl::GotoStmt)","text":"

Syntax:

operation ::= `hl.goto` $label attr-dict\n
"},{"location":"dialects/HighLevel/HighLevel/#operands_42","title":"Operands:","text":"Operand Description label"},{"location":"dialects/HighLevel/HighLevel/#hlif-vasthlifop","title":"hl.if (::vast::hl::IfOp)","text":"

VAST if statement

The operation takes builders of two mandatory regions -- condition and then region -- and one builder optional region representing else block of C if statement. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.if { ... / condition region / hl.cond.yield %cond : !hl.bool } then { ... / then region / } else { ... / else region / }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlimplicit_cast-vasthlimplicitcastop","title":"hl.implicit_cast (::vast::hl::ImplicitCastOp)","text":"

VAST cast operation

Syntax:

operation ::= `hl.implicit_cast` $value $kind attr-dict `:` type($value) `->` type($result)\n

VAST cast operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_19","title":"Attributes:","text":"Attribute MLIR Type Description kind ::vast::hl::CastKindAttr cast kind"},{"location":"dialects/HighLevel/HighLevel/#operands_43","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/HighLevel/HighLevel/#results_50","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlindirect_call-vasthlindirectcallop","title":"hl.indirect_call (::vast::hl::IndirectCallOp)","text":"

VAST call operation

Syntax:

operation ::= `hl.indirect_call` $callee `:` type($callee)  `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )\n

VAST call operation Interfaces: CallOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_44","title":"Operands:","text":"Operand Description callee any type argOperands any type"},{"location":"dialects/HighLevel/HighLevel/#results_51","title":"Results:","text":"Result Description results any type"},{"location":"dialects/HighLevel/HighLevel/#hlinitlist-vasthlinitlistexpr","title":"hl.initlist (::vast::hl::InitListExpr)","text":"

VAST initializer list expression

Syntax:

operation ::= `hl.initlist` $elements attr-dict `:` functional-type($elements, results)\n

VAST initializer list expression

"},{"location":"dialects/HighLevel/HighLevel/#operands_45","title":"Operands:","text":"Operand Description elements any type"},{"location":"dialects/HighLevel/HighLevel/#results_52","title":"Results:","text":"Result Description \u00abunnamed\u00bb any type"},{"location":"dialects/HighLevel/HighLevel/#hllabel-vasthllabelstmt","title":"hl.label (::vast::hl::LabelStmt)","text":"

VAST control flow operation

Syntax:

operation ::= `hl.label` $label $body attr-dict\n

VAST control flow operation Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_46","title":"Operands:","text":"Operand Description label"},{"location":"dialects/HighLevel/HighLevel/#hllabeldecl-vasthllabeldeclop","title":"hl.label.decl (::vast::hl::LabelDeclOp)","text":"

Syntax:

operation ::= `hl.label.decl` $name attr-dict `:` type($result)\n

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#attributes_20","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#results_53","title":"Results:","text":"Result Description result"},{"location":"dialects/HighLevel/HighLevel/#hllabeladdr-vasthladdrlabelexpr","title":"hl.labeladdr (::vast::hl::AddrLabelExpr)","text":"

VAST address of label extension

Syntax:

operation ::= `hl.labeladdr` $label attr-dict `:` type($result)\n

VAST address of label extension

"},{"location":"dialects/HighLevel/HighLevel/#operands_47","title":"Operands:","text":"Operand Description label"},{"location":"dialects/HighLevel/HighLevel/#results_54","title":"Results:","text":"Result Description result lvalue to pointer like type"},{"location":"dialects/HighLevel/HighLevel/#hllnot-vasthllnotop","title":"hl.lnot (::vast::hl::LNotOp)","text":"

VAST unary logical operation

Syntax:

operation ::= `hl.lnot` $arg attr-dict `:` type($arg) `->` type($res)\n

High-level unary logical operation assures that result has the right type.

The custom assembly form of the operation is as follows:

%result = %arg : type -> ret_type"},{"location":"dialects/HighLevel/HighLevel/#operands_48","title":"Operands:","text":"Operand Description arg any type"},{"location":"dialects/HighLevel/HighLevel/#results_55","title":"Results:","text":"Result Description res bool or integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlmember-vasthlrecordmemberop","title":"hl.member (::vast::hl::RecordMemberOp)","text":"

VAST record element access operation

Syntax:

operation ::= `hl.member` $record `at` $name attr-dict `:` type($record) `->` type($element)\n

VAST record element access operation

"},{"location":"dialects/HighLevel/HighLevel/#attributes_21","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#operands_49","title":"Operands:","text":"Operand Description record any type"},{"location":"dialects/HighLevel/HighLevel/#results_56","title":"Results:","text":"Result Description element lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#hlminus-vasthlminusop","title":"hl.minus (::vast::hl::MinusOp)","text":"

VAST unary type preserving operation

Syntax:

operation ::= `hl.minus` $arg attr-dict `:` type($result)\n

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_50","title":"Operands:","text":"Operand Description arg any type"},{"location":"dialects/HighLevel/HighLevel/#results_57","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlmul-vasthlmuliop","title":"hl.mul (::vast::hl::MulIOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.mul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Traits: Commutative

"},{"location":"dialects/HighLevel/HighLevel/#operands_51","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_58","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlnot-vasthlnotop","title":"hl.not (::vast::hl::NotOp)","text":"

VAST unary type preserving operation

Syntax:

operation ::= `hl.not` $arg attr-dict `:` type($result)\n

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_52","title":"Operands:","text":"Operand Description arg any type"},{"location":"dialects/HighLevel/HighLevel/#results_59","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlplus-vasthlplusop","title":"hl.plus (::vast::hl::PlusOp)","text":"

VAST unary type preserving operation

Syntax:

operation ::= `hl.plus` $arg attr-dict `:` type($result)\n

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_53","title":"Operands:","text":"Operand Description arg any type"},{"location":"dialects/HighLevel/HighLevel/#results_60","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlpostdec-vasthlpostdecop","title":"hl.post.dec (::vast::hl::PostDecOp)","text":"

VAST unary inplace operation

Syntax:

operation ::= `hl.post.dec` $arg attr-dict `:` type($arg) `->` type($result)\n

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_54","title":"Operands:","text":"Operand Description arg lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#results_61","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlpostinc-vasthlpostincop","title":"hl.post.inc (::vast::hl::PostIncOp)","text":"

VAST unary inplace operation

Syntax:

operation ::= `hl.post.inc` $arg attr-dict `:` type($arg) `->` type($result)\n

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_55","title":"Operands:","text":"Operand Description arg lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#results_62","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlpredec-vasthlpredecop","title":"hl.pre.dec (::vast::hl::PreDecOp)","text":"

VAST unary inplace operation

Syntax:

operation ::= `hl.pre.dec` $arg attr-dict `:` type($arg) `->` type($result)\n

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_56","title":"Operands:","text":"Operand Description arg lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#results_63","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlpreinc-vasthlpreincop","title":"hl.pre.inc (::vast::hl::PreIncOp)","text":"

VAST unary inplace operation

Syntax:

operation ::= `hl.pre.inc` $arg attr-dict `:` type($arg) `->` type($result)\n

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

"},{"location":"dialects/HighLevel/HighLevel/#operands_57","title":"Operands:","text":"Operand Description arg lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#results_64","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlpredefinedexpr-vasthlpredefinedexpr","title":"hl.predefined.expr (::vast::hl::PredefinedExpr)","text":"

VAT predefined expr ( such as __func__ )

Syntax:

operation ::= `hl.predefined.expr` $value $kind attr-dict `:` type($value) `->` type($result)\n

VAT predefined expr ( such as func )

"},{"location":"dialects/HighLevel/HighLevel/#attributes_22","title":"Attributes:","text":"Attribute MLIR Type Description kind ::vast::hl::IdentKindAttr ident kind"},{"location":"dialects/HighLevel/HighLevel/#operands_58","title":"Operands:","text":"Operand Description value any type"},{"location":"dialects/HighLevel/HighLevel/#results_65","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlref-vasthldeclrefop","title":"hl.ref (::vast::hl::DeclRefOp)","text":"

VAST variable reference declaration

Syntax:

operation ::= `hl.ref` $decl attr-dict `:` functional-type(operands, results)\n

VAST variable reference declaration

"},{"location":"dialects/HighLevel/HighLevel/#operands_59","title":"Operands:","text":"Operand Description decl any type"},{"location":"dialects/HighLevel/HighLevel/#results_66","title":"Results:","text":"Result Description result lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#hlreturn-vasthlreturnop","title":"hl.return (::vast::hl::ReturnOp)","text":"

Syntax:

operation ::= `hl.return` ($result^ `:` type($result))? attr-dict\n

Traits: return_trait, soft_terminator

"},{"location":"dialects/HighLevel/HighLevel/#operands_60","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlsdiv-vasthldivsop","title":"hl.sdiv (::vast::hl::DivSOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.sdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_61","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_67","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlsizeofexpr-vasthlsizeofexprop","title":"hl.sizeof.expr (::vast::hl::SizeOfExprOp)","text":"

VAST expr sizeof operator

Syntax:

operation ::= `hl.sizeof.expr` attr-dict `->` type($result) $expr\n

VAST expr sizeof operator

"},{"location":"dialects/HighLevel/HighLevel/#results_68","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlsizeoftype-vasthlsizeoftypeop","title":"hl.sizeof.type (::vast::hl::SizeOfTypeOp)","text":"

VAST type sizeof operator

Syntax:

operation ::= `hl.sizeof.type` $arg attr-dict `->` type($result)\n

VAST type sizeof operator

"},{"location":"dialects/HighLevel/HighLevel/#attributes_23","title":"Attributes:","text":"Attribute MLIR Type Description arg ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#results_69","title":"Results:","text":"Result Description result integer like type"},{"location":"dialects/HighLevel/HighLevel/#hlskip-vasthlskipstmt","title":"hl.skip (::vast::hl::SkipStmt)","text":"

VAST skip statement

Syntax:

operation ::= `hl.skip` attr-dict\n

VAST skip statement

"},{"location":"dialects/HighLevel/HighLevel/#hlsrem-vasthlremsop","title":"hl.srem (::vast::hl::RemSOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.srem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_62","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_70","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlstmtexpr-vasthlstmtexprop","title":"hl.stmt.expr (::vast::hl::StmtExprOp)","text":"

VAST statement expression

Syntax:

operation ::= `hl.stmt.expr` attr-dict `:` type($result) $substmt\n

VAST statement expression Traits: SingleBlock

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#results_71","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlstruct-vasthlstructdeclop","title":"hl.struct (::vast::hl::StructDeclOp)","text":"

VAST struct declaration

Syntax:

operation ::= `hl.struct` $name attr-dict `:` $fields\n

VAST struct declaration Traits: NoTerminator

Interfaces: AggregateTypeDefinitionInterface, VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_24","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#hlsub-vasthlsubiop","title":"hl.sub (::vast::hl::SubIOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.sub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_63","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_72","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlsubscript-vasthlsubscriptop","title":"hl.subscript (::vast::hl::SubscriptOp)","text":"

VAST array subscript operator

Syntax:

operation ::= `hl.subscript` $array `at` ` ` `[` $index `:` type($index) `]` attr-dict\n              `:` type($array) `->` type($result)\n

VAST array subscript operator

"},{"location":"dialects/HighLevel/HighLevel/#operands_64","title":"Operands:","text":"Operand Description array lvalue to subscriptable type index integer like type"},{"location":"dialects/HighLevel/HighLevel/#results_73","title":"Results:","text":"Result Description result lvalue to any type"},{"location":"dialects/HighLevel/HighLevel/#hlswitch-vasthlswitchop","title":"hl.switch (::vast::hl::SwitchOp)","text":"

VAST switch statement

Syntax:

operation ::= `hl.switch` $condRegion `cases` $cases attr-dict\n

The operation represents a switch statement.

The generic form of the operation is as follows:

hl.switch { ... / cond region / hl.value.yield %val : !hl.type } cases { ... / casesregion / }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#hlthis-vasthlthisop","title":"hl.this (::vast::hl::ThisOp)","text":"

VAST this operator

Syntax:

operation ::= `hl.this` attr-dict `:` type($result)\n

VAST this operator

"},{"location":"dialects/HighLevel/HighLevel/#results_74","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hltranslation_unit-vasthltranslationunitop","title":"hl.translation_unit (::vast::hl::TranslationUnitOp)","text":"

VAST translation unit

Syntax:

operation ::= `hl.translation_unit` $body attr-dict\n

VAST tranaslation unit Traits: IsolatedFromAbove, NoTerminator, SymbolTable

"},{"location":"dialects/HighLevel/HighLevel/#hltype-vasthltypedeclop","title":"hl.type (::vast::hl::TypeDeclOp)","text":"

VAST type declaration

Syntax:

operation ::= `hl.type` $name attr-dict\n

VAST type declaration Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_25","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#hltypeyield-vasthltypeyieldop","title":"hl.type.yield (::vast::hl::TypeYieldOp)","text":"

Type yield operation

Syntax:

operation ::= `hl.type.yield` attr-dict $result `:` type($result)\n

A type yield operation is used to terminate the underlying expression region of a typeof(expr) statement.

The custom assembly form of the operation is as follows:

hl.type.yield result : type

Traits: Terminator

"},{"location":"dialects/HighLevel/HighLevel/#operands_65","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hltypedef-vasthltypedefop","title":"hl.typedef (::vast::hl::TypeDefOp)","text":"

VAST typedef operation

Syntax:

operation ::= `hl.typedef` $name attr-dict `:` $type\n

Typedef operation servers to declare named types. It creates a new type symbol in the current scope to be referenced as NamedType later.

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_26","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute type ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#hltypeofexpr-vasthltypeofexprop","title":"hl.typeof.expr (::vast::hl::TypeOfExprOp)","text":"

VAST typeof(expr) operation

Syntax:

operation ::= `hl.typeof.expr` $name $expr `:` $type attr-dict\n

The Typeof operation serves to declare a type using type introspection. It evaluates its underlying expression, creates a new type symbol in the current scope, assigns it to the type of the underlying expression, and returns the type symbol to be referenced later

Traits: SingleBlock

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_27","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute type ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#hltypeoftype-vasthltypeoftypeop","title":"hl.typeof.type (::vast::hl::TypeOfTypeOp)","text":"

VAST typeof(type) operation

Syntax:

operation ::= `hl.typeof.type` attr-dict `:` $type\n

Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_28","title":"Attributes:","text":"Attribute MLIR Type Description type ::mlir::TypeAttr any type attribute"},{"location":"dialects/HighLevel/HighLevel/#hludiv-vasthldivuop","title":"hl.udiv (::vast::hl::DivUOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.udiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_66","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_75","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlunion-vasthluniondeclop","title":"hl.union (::vast::hl::UnionDeclOp)","text":"

VAST record declaration

Syntax:

operation ::= `hl.union` $name attr-dict `:` $fields\n

VAST record declaration Traits: NoTerminator

Interfaces: AggregateTypeDefinitionInterface, VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_29","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/HighLevel/HighLevel/#hlunreachable-vasthlunreachableop","title":"hl.unreachable (::vast::hl::UnreachableOp)","text":"

VAST unreachable operation

Syntax:

operation ::= `hl.unreachable` attr-dict\n

VAST unreachable operation Traits: Terminator

"},{"location":"dialects/HighLevel/HighLevel/#hlurem-vasthlremuop","title":"hl.urem (::vast::hl::RemUOp)","text":"

VAST arithmetic binary operation

Syntax:

operation ::= `hl.urem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)\n

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)"},{"location":"dialects/HighLevel/HighLevel/#operands_67","title":"Operands:","text":"Operand Description lhs any type rhs any type"},{"location":"dialects/HighLevel/HighLevel/#results_76","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlvalueyield-vasthlvalueyieldop","title":"hl.value.yield (::vast::hl::ValueYieldOp)","text":"

Value yield operation

Syntax:

operation ::= `hl.value.yield` attr-dict $result `:` type($result)\n

A value yield operation is used to terminate the case region of a switch statement. The yielded value triggers the parent case statement region.

The custom assembly form of the operation is as follows:

hl.value.yield result : type

Traits: Terminator

"},{"location":"dialects/HighLevel/HighLevel/#operands_68","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlvar-vasthlvardeclop","title":"hl.var (::vast::hl::VarDeclOp)","text":"

VAST variable declaration

Syntax:

operation ::= `hl.var` $name attr-dict ($storageClass^)? ($threadStorageClass^)? `:` type($result)\n              (`=` $initializer^)?\n              (`allocation_size` $allocation_size^)?\n

VAST variable declaration Interfaces: VastSymbol

"},{"location":"dialects/HighLevel/HighLevel/#attributes_30","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute storageClass ::vast::hl::StorageClassAttr storage class threadStorageClass ::vast::hl::TSClassAttr thread storage class"},{"location":"dialects/HighLevel/HighLevel/#results_77","title":"Results:","text":"Result Description result any type"},{"location":"dialects/HighLevel/HighLevel/#hlwhile-vasthlwhileop","title":"hl.while (::vast::hl::WhileOp)","text":"

VAST while statement

Syntax:

operation ::= `hl.while` $condRegion `do` $bodyRegion attr-dict\n

The operation takes builders of two mandatory regions -- condition and body region. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.while { ... / condition region / hl.cond.yield %cond : !hl.bool } do { ... / body region / }

Traits: NoRegionArguments, NoTerminator

Interfaces: RegionKindInterface

"},{"location":"dialects/HighLevel/HighLevel/#attribute-definition","title":"Attribute definition","text":""},{"location":"dialects/HighLevel/HighLevel/#allocalignattr","title":"AllocAlignAttr","text":"

Syntax:

#hl.alloc_align<\n  int   # alignment\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters","title":"Parameters:","text":"Parameter C++ type Description alignment int"},{"location":"dialects/HighLevel/HighLevel/#allocsizeattr","title":"AllocSizeAttr","text":"

Syntax:

#hl.alloc_size<\n  int,   # size_arg_pos\n  int   # num_arg_pos\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_1","title":"Parameters:","text":"Parameter C++ type Description size_arg_pos int num_arg_pos int"},{"location":"dialects/HighLevel/HighLevel/#annotationattr","title":"AnnotationAttr","text":"

Syntax:

#hl.annotation<\n  ::mlir::StringAttr   # name\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_2","title":"Parameters:","text":"Parameter C++ type Description name ::mlir::StringAttr"},{"location":"dialects/HighLevel/HighLevel/#asmlabelattr","title":"AsmLabelAttr","text":"

Syntax:

#hl.asm<\n  ::mlir::StringAttr,   # label\n  bool   # isLiteral\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_3","title":"Parameters:","text":"Parameter C++ type Description label ::mlir::StringAttr isLiteral bool"},{"location":"dialects/HighLevel/HighLevel/#builtinattr","title":"BuiltinAttr","text":"

Syntax:

#hl.builtin<\n  unsigned   # ID\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_4","title":"Parameters:","text":"Parameter C++ type Description ID unsigned"},{"location":"dialects/HighLevel/HighLevel/#cvqualifiersattr","title":"CVQualifiersAttr","text":"

Syntax:

#hl.quals<\n  bool,   # is_const\n  bool   # is_volatile\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_5","title":"Parameters:","text":"Parameter C++ type Description is_const bool const qualifier is_volatile bool volatile qualifier"},{"location":"dialects/HighLevel/HighLevel/#cvrqualifiersattr","title":"CVRQualifiersAttr","text":"

Syntax:

#hl.quals<\n  bool,   # is_const\n  bool,   # is_volatile\n  bool   # is_restrict\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_6","title":"Parameters:","text":"Parameter C++ type Description is_const bool const qualifier is_volatile bool volatile qualifier is_restrict bool restrict qualifier"},{"location":"dialects/HighLevel/HighLevel/#constattr","title":"ConstAttr","text":"

Syntax: #hl.const

"},{"location":"dialects/HighLevel/HighLevel/#formatattr","title":"FormatAttr","text":"

Syntax:

#hl.format<\n  ::mlir::StringAttr   # name\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_7","title":"Parameters:","text":"Parameter C++ type Description name ::mlir::StringAttr"},{"location":"dialects/HighLevel/HighLevel/#loaderuninitializedattr","title":"LoaderUninitializedAttr","text":"

Syntax: #hl.loader_uninitialized

"},{"location":"dialects/HighLevel/HighLevel/#modeattr","title":"ModeAttr","text":"

Syntax:

#hl.mode<\n  ::mlir::StringAttr   # mode\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_8","title":"Parameters:","text":"Parameter C++ type Description mode ::mlir::StringAttr"},{"location":"dialects/HighLevel/HighLevel/#noinstrumentfunctionattr","title":"NoInstrumentFunctionAttr","text":"

Syntax: #hl.no_instrument_function

"},{"location":"dialects/HighLevel/HighLevel/#nothrowattr","title":"NoThrowAttr","text":"

Syntax: #hl.nothrow

"},{"location":"dialects/HighLevel/HighLevel/#nonnullattr","title":"NonNullAttr","text":"

Syntax: #hl.nonnull

"},{"location":"dialects/HighLevel/HighLevel/#packedattr","title":"PackedAttr","text":"

Syntax: #hl.packed

"},{"location":"dialects/HighLevel/HighLevel/#pureattr","title":"PureAttr","text":"

Syntax: #hl.pure

"},{"location":"dialects/HighLevel/HighLevel/#restrictattr","title":"RestrictAttr","text":"

Syntax: #hl.restrict

"},{"location":"dialects/HighLevel/HighLevel/#sectionattr","title":"SectionAttr","text":"

Syntax:

#hl.section<\n  ::mlir::StringAttr   # name\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_9","title":"Parameters:","text":"Parameter C++ type Description name ::mlir::StringAttr"},{"location":"dialects/HighLevel/HighLevel/#ucvqualifiersattr","title":"UCVQualifiersAttr","text":"

Syntax:

#hl.quals<\n  bool,   # is_unsigned\n  bool,   # is_const\n  bool   # is_volatile\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_10","title":"Parameters:","text":"Parameter C++ type Description is_unsigned bool unsigned qualifier is_const bool const qualifier is_volatile bool volatile qualifier"},{"location":"dialects/HighLevel/HighLevel/#warnunusedresultattr","title":"WarnUnusedResultAttr","text":"

Syntax: #hl.warn_unused_result

"},{"location":"dialects/HighLevel/HighLevel/#type-definition","title":"Type definition","text":""},{"location":"dialects/HighLevel/HighLevel/#adjustedtype","title":"AdjustedType","text":"

Syntax:

!hl.adjusted<\n  Type,   # original\n  Type   # adjusted\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_11","title":"Parameters:","text":"Parameter C++ type Description original Type adjusted Type"},{"location":"dialects/HighLevel/HighLevel/#arraytype","title":"ArrayType","text":"

Syntax:

!hl.array<\n  SizeParam,   # size\n  Type,   # elementType\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_12","title":"Parameters:","text":"Parameter C++ type Description size SizeParam size parameter for arrays elementType Type quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#attributedtype","title":"AttributedType","text":"

Syntax:

!hl.attributed<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_13","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#bfloat16type","title":"BFloat16Type","text":"

Syntax:

!hl.bfloat16<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_14","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#booltype","title":"BoolType","text":"

Syntax:

!hl.bool<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_15","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#chartype","title":"CharType","text":"

Syntax:

!hl.char<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_16","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#decayedtype","title":"DecayedType","text":"

Syntax:

!hl.decayed<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_17","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#doubletype","title":"DoubleType","text":"

Syntax:

!hl.double<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_18","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#elaboratedtype","title":"ElaboratedType","text":"

Syntax:

!hl.elaborated<\n  Type,   # elementType\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_19","title":"Parameters:","text":"Parameter C++ type Description elementType Type quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#enumtype","title":"EnumType","text":"

Syntax:

!hl.enum<\n  ::llvm::StringRef,   # name\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_20","title":"Parameters:","text":"Parameter C++ type Description name ::llvm::StringRef quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#float128type","title":"Float128Type","text":"

Syntax:

!hl.float128<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_21","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#floattype","title":"FloatType","text":"

Syntax:

!hl.float<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_22","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#halftype","title":"HalfType","text":"

Syntax:

!hl.half<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_23","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#int128type","title":"Int128Type","text":"

Syntax:

!hl.int128<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_24","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#inttype","title":"IntType","text":"

Syntax:

!hl.int<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_25","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#lvaluetype","title":"LValueType","text":"

Syntax:

!hl.lvalue<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_26","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#labeltype","title":"LabelType","text":"

Syntax: !hl.label

"},{"location":"dialects/HighLevel/HighLevel/#longdoubletype","title":"LongDoubleType","text":"

Syntax:

!hl.longdouble<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_27","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#longlongtype","title":"LongLongType","text":"

Syntax:

!hl.longlong<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_28","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#longtype","title":"LongType","text":"

Syntax:

!hl.long<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_29","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#parentype","title":"ParenType","text":"

Syntax:

!hl.paren<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_30","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#pointertype","title":"PointerType","text":"

Syntax:

!hl.ptr<\n  Type,   # elementType\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_31","title":"Parameters:","text":"Parameter C++ type Description elementType Type quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#rvaluetype","title":"RValueType","text":"

Syntax:

!hl.rvalue<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_32","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#recordtype","title":"RecordType","text":"

Syntax:

!hl.record<\n  ::llvm::StringRef,   # name\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_33","title":"Parameters:","text":"Parameter C++ type Description name ::llvm::StringRef quals CVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#referencetype","title":"ReferenceType","text":"

Syntax:

!hl.reference<\n  Type   # elementType\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_34","title":"Parameters:","text":"Parameter C++ type Description elementType Type"},{"location":"dialects/HighLevel/HighLevel/#shorttype","title":"ShortType","text":"

Syntax:

!hl.short<\n  UCVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_35","title":"Parameters:","text":"Parameter C++ type Description quals UCVQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#typeofexprtype","title":"TypeOfExprType","text":"

Syntax:

!hl.typeof.expr<\n  ::llvm::StringRef,   # name\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_36","title":"Parameters:","text":"Parameter C++ type Description name ::llvm::StringRef quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#typeoftypetype","title":"TypeOfTypeType","text":"

Syntax:

!hl.typeof.type<\n  Type,   # unmodifiedType\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_37","title":"Parameters:","text":"Parameter C++ type Description unmodifiedType Type quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#typedeftype","title":"TypedefType","text":"

Syntax:

!hl.typedef<\n  ::llvm::StringRef,   # name\n  CVRQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_38","title":"Parameters:","text":"Parameter C++ type Description name ::llvm::StringRef quals CVRQualifiersAttr"},{"location":"dialects/HighLevel/HighLevel/#voidtype","title":"VoidType","text":"

Syntax:

!hl.void<\n  CVQualifiersAttr   # quals\n>\n
"},{"location":"dialects/HighLevel/HighLevel/#parameters_39","title":"Parameters:","text":"Parameter C++ type Description quals CVQualifiersAttr"},{"location":"dialects/LowLevel/LowLevel/","title":"Low Level","text":""},{"location":"dialects/LowLevel/LowLevel/#ll-dialect","title":"'ll' Dialect","text":"

A vast low-level dialect. This dialect serves as a bottom layer in VAST dialect tower. There should always exist a pass that lowers this dialect into LLVM Dialect.

Work in progress - new operations are still being added and existing can be changed or removed.

  • 'll' Dialect
    • Operation definition
      • ll.br (::vast::ll::Br)
        • Operands:
        • Successors:
      • ll.concat (::vast::ll::Concat)
        • Operands:
        • Results:
      • ll.cond_br (::vast::ll::CondBr)
        • Operands:
        • Successors:
      • ll.cond_scope_ret (::vast::ll::CondScopeRet)
        • Operands:
        • Successors:
      • ll.extract (::vast::ll::Extract)
        • Attributes:
        • Operands:
        • Results:
      • ll.func (::vast::ll::FuncOp)
        • Attributes:
      • ll.gep (::vast::ll::StructGEPOp)
        • Attributes:
        • Operands:
        • Results:
      • ll.initialize (::vast::ll::InitializeVar)
        • Operands:
        • Results:
      • ll.inline_scope (::vast::ll::InlineScope)
      • ll.return (::vast::ll::ReturnOp)
        • Operands:
      • ll.scope (::vast::ll::Scope)
      • ll.scope_recurse (::vast::ll::ScopeRecurse)
      • ll.scope_ret (::vast::ll::ScopeRet)
      • ll.uninitialized_var (::vast::ll::UninitializedVar)
        • Results:
"},{"location":"dialects/LowLevel/LowLevel/#operation-definition","title":"Operation definition","text":""},{"location":"dialects/LowLevel/LowLevel/#llbr-vastllbr","title":"ll.br (::vast::ll::Br)","text":"

Direct branch.

Syntax:

operation ::= `ll.br` $dest (`(` $operands^ `:` type($operands) `)`)? attr-dict\n

Direct branch Traits: Terminator

Interfaces: BranchOpInterface

"},{"location":"dialects/LowLevel/LowLevel/#operands","title":"Operands:","text":"Operand Description operands any type"},{"location":"dialects/LowLevel/LowLevel/#successors","title":"Successors:","text":"Successor Description dest any successor"},{"location":"dialects/LowLevel/LowLevel/#llconcat-vastllconcat","title":"ll.concat (::vast::ll::Concat)","text":"

Concat integers together

Syntax:

operation ::= `ll.concat` operands attr-dict `:` functional-type(operands, results)\n

Concat operands together, where first argument occupies lsb.

"},{"location":"dialects/LowLevel/LowLevel/#operands_1","title":"Operands:","text":"Operand Description args any type"},{"location":"dialects/LowLevel/LowLevel/#results","title":"Results:","text":"Result Description result any type"},{"location":"dialects/LowLevel/LowLevel/#llcond_br-vastllcondbr","title":"ll.cond_br (::vast::ll::CondBr)","text":"

Conditional branch.

Syntax:

operation ::= `ll.cond_br` $cond `:` type($cond) `,`\n              $trueDest (`(` $trueOperands^ `:` type($trueOperands) `)`)? `,`\n              $falseDest (`(` $falseOperands^ `:` type($falseOperands) `)`)?\n              attr-dict\n

Direct branch Traits: AttrSizedOperandSegments, Terminator

"},{"location":"dialects/LowLevel/LowLevel/#operands_2","title":"Operands:","text":"Operand Description cond any type trueOperands any type falseOperands any type"},{"location":"dialects/LowLevel/LowLevel/#successors_1","title":"Successors:","text":"Successor Description trueDest any successor falseDest any successor"},{"location":"dialects/LowLevel/LowLevel/#llcond_scope_ret-vastllcondscoperet","title":"ll.cond_scope_ret (::vast::ll::CondScopeRet)","text":"

Terminator of scope if condition is met, otherwise branch.

Syntax:

operation ::= `ll.cond_scope_ret` $cond `:` type($cond) `,`\n              $dest (`(` $dest_operands^ `:` type($dest_operands) `)`)? attr-dict\n

Terminate or branch. Traits: Terminator

"},{"location":"dialects/LowLevel/LowLevel/#operands_3","title":"Operands:","text":"Operand Description cond any type dest_operands any type"},{"location":"dialects/LowLevel/LowLevel/#successors_2","title":"Successors:","text":"Successor Description dest any successor"},{"location":"dialects/LowLevel/LowLevel/#llextract-vastllextract","title":"ll.extract (::vast::ll::Extract)","text":"

Extracts value

Syntax:

operation ::= `ll.extract` operands attr-dict `:` functional-type(operands, results)\n

0 is lsb, [inc, exc)

"},{"location":"dialects/LowLevel/LowLevel/#attributes","title":"Attributes:","text":"Attribute MLIR Type Description from ::mlir::TypedAttr TypedAttr instance to ::mlir::TypedAttr TypedAttr instance"},{"location":"dialects/LowLevel/LowLevel/#operands_4","title":"Operands:","text":"Operand Description arg any type"},{"location":"dialects/LowLevel/LowLevel/#results_1","title":"Results:","text":"Result Description result any type"},{"location":"dialects/LowLevel/LowLevel/#llfunc-vastllfuncop","title":"ll.func (::vast::ll::FuncOp)","text":"

VAST function template

Syntax:

operation ::= `ll.func` $linkage $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)\n

Inspired by cir::FuncOp and mlir::func::FuncOp:

Operations within the function cannot implicitly capture values defined outside of the function, i.e. Functions are IsolatedFromAbove. All external references must use function arguments or attributes that establish a symbolic connection (e.g. symbols referenced by name via a string attribute like SymbolRefAttr). An external function declaration (used when referring to a function declared in some other module) has no body.

The function linkage information is specified by linkage, as defined by GlobalLinkageKind attribute.

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator

Interfaces: CallableOpInterface, FunctionOpInterface, RegionKindInterface, Symbol

"},{"location":"dialects/LowLevel/LowLevel/#attributes_1","title":"Attributes:","text":"Attribute MLIR Type Description sym_name ::mlir::StringAttr string attribute function_type ::mlir::TypeAttr type attribute of function type linkage ::vast::core::GlobalLinkageKindAttr global linkage kind sym_visibility ::mlir::StringAttr string attribute arg_attrs ::mlir::ArrayAttr Array of dictionary attributes res_attrs ::mlir::ArrayAttr Array of dictionary attributes"},{"location":"dialects/LowLevel/LowLevel/#llgep-vastllstructgepop","title":"ll.gep (::vast::ll::StructGEPOp)","text":"

VAST struct gep operation

VAST struct gep operation

"},{"location":"dialects/LowLevel/LowLevel/#attributes_2","title":"Attributes:","text":"Attribute MLIR Type Description idx ::mlir::IntegerAttr 32-bit signless integer attribute name ::mlir::StringAttr string attribute"},{"location":"dialects/LowLevel/LowLevel/#operands_5","title":"Operands:","text":"Operand Description record any type"},{"location":"dialects/LowLevel/LowLevel/#results_2","title":"Results:","text":"Result Description element any type"},{"location":"dialects/LowLevel/LowLevel/#llinitialize-vastllinitializevar","title":"ll.initialize (::vast::ll::InitializeVar)","text":"

Initialize a variable.

Syntax:

operation ::= `ll.initialize` operands attr-dict `:` functional-type(operands, results)\n

Initialize a variable - for now this operation is a direct lowering from hl.var initialization section. Later there will be need to discover how this ties to constructors.

"},{"location":"dialects/LowLevel/LowLevel/#operands_6","title":"Operands:","text":"Operand Description var any type elements any type"},{"location":"dialects/LowLevel/LowLevel/#results_3","title":"Results:","text":"Result Description result any type"},{"location":"dialects/LowLevel/LowLevel/#llinline_scope-vastllinlinescope","title":"ll.inline_scope (::vast::ll::InlineScope)","text":"

Scope, that forwards (cond)scope return up.

Result of inlined if. Traits: NoRegionArguments

"},{"location":"dialects/LowLevel/LowLevel/#llreturn-vastllreturnop","title":"ll.return (::vast::ll::ReturnOp)","text":"

Syntax:

operation ::= `ll.return` ($result^ `:` type($result))? attr-dict\n

Traits: Terminator, return_trait

"},{"location":"dialects/LowLevel/LowLevel/#operands_7","title":"Operands:","text":"Operand Description result any type"},{"location":"dialects/LowLevel/LowLevel/#llscope-vastllscope","title":"ll.scope (::vast::ll::Scope)","text":"

Scope, holds one region.

Syntax:

operation ::= `ll.scope` $body attr-dict\n

Scope that holds one region, each block should be terminated with either branch, scope return or their conditional variants. Traits: NoRegionArguments

"},{"location":"dialects/LowLevel/LowLevel/#llscope_recurse-vastllscoperecurse","title":"ll.scope_recurse (::vast::ll::ScopeRecurse)","text":"

Jump to first block of scope.

Syntax:

operation ::= `ll.scope_recurse` attr-dict\n

Modelling continue. Traits: Terminator

"},{"location":"dialects/LowLevel/LowLevel/#llscope_ret-vastllscoperet","title":"ll.scope_ret (::vast::ll::ScopeRet)","text":"

Terminator of scope.

Syntax:

operation ::= `ll.scope_ret` attr-dict\n

Terminator of scopes (for example during lowering of loops). Traits: Terminator

"},{"location":"dialects/LowLevel/LowLevel/#lluninitialized_var-vastlluninitializedvar","title":"ll.uninitialized_var (::vast::ll::UninitializedVar)","text":"

Declaration of variable that have not been initialized yet.

Syntax:

operation ::= `ll.uninitialized_var` attr-dict `:` type($result)\n

Declaration of variable that have not been initialized yet. Interfaces: VastSymbol

"},{"location":"dialects/LowLevel/LowLevel/#results_4","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Meta/Meta/","title":"Meta","text":""},{"location":"dialects/Meta/Meta/#meta-dialect","title":"'meta' Dialect","text":"

A vast metadata dialect. This dialect intends capture user metadata that are kept accross transformations.

  • 'meta' Dialect
    • Attribute definition
      • IdentifierAttr
        • Parameters:
"},{"location":"dialects/Meta/Meta/#attribute-definition","title":"Attribute definition","text":""},{"location":"dialects/Meta/Meta/#identifierattr","title":"IdentifierAttr","text":"

A metadata identifier.

Syntax:

#meta.id<\n  identifier_t   # value\n>\n

A metadata identifier can be used to relate operations to external metadata storage.

#meta.id<\"0x3A28213A\">\n
"},{"location":"dialects/Meta/Meta/#parameters","title":"Parameters:","text":"Parameter C++ type Description value identifier_t"},{"location":"dialects/Unsupported/Unsupported/","title":"Unsupported","text":""},{"location":"dialects/Unsupported/Unsupported/#unsup-dialect","title":"'unsup' Dialect","text":"

A vast unsupported dialect. This dialect defines a set of generic unsupported operation/types that can be used to lower AST Node that are yet not supported and can't be lowered by other dialects.

  • 'unsup' Dialect
    • Operation definition
      • unsup.decl (::vast::unsup::UnsupportedDecl)
        • Attributes:
      • unsup.stmt (::vast::unsup::UnsupportedStmt)
        • Attributes:
        • Results:
    • Attribute definition
      • UnsupportedAttr
        • Parameters:
    • Type definition
      • UnsupportedType
        • Parameters:
"},{"location":"dialects/Unsupported/Unsupported/#operation-definition","title":"Operation definition","text":""},{"location":"dialects/Unsupported/Unsupported/#unsupdecl-vastunsupunsupporteddecl","title":"unsup.decl (::vast::unsup::UnsupportedDecl)","text":"

VAST unsupported decl

Syntax:

operation ::= `unsup.decl` $name attr-dict `:` $body\n

VAST unsupported decl Traits: NoTerminator

"},{"location":"dialects/Unsupported/Unsupported/#attributes","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/Unsupported/Unsupported/#unsupstmt-vastunsupunsupportedstmt","title":"unsup.stmt (::vast::unsup::UnsupportedStmt)","text":"

VAST unsupported statement

Syntax:

operation ::= `unsup.stmt` $name attr-dict `:` type($result) $children\n

VAST unsupported statement Traits: NoTerminator

"},{"location":"dialects/Unsupported/Unsupported/#attributes_1","title":"Attributes:","text":"Attribute MLIR Type Description name ::mlir::StringAttr string attribute"},{"location":"dialects/Unsupported/Unsupported/#results","title":"Results:","text":"Result Description result any type"},{"location":"dialects/Unsupported/Unsupported/#attribute-definition","title":"Attribute definition","text":""},{"location":"dialects/Unsupported/Unsupported/#unsupportedattr","title":"UnsupportedAttr","text":"

Syntax:

#unsup.attr<\n  ::mlir::StringAttr   # spelling\n>\n
"},{"location":"dialects/Unsupported/Unsupported/#parameters","title":"Parameters:","text":"Parameter C++ type Description spelling ::mlir::StringAttr"},{"location":"dialects/Unsupported/Unsupported/#type-definition","title":"Type definition","text":""},{"location":"dialects/Unsupported/Unsupported/#unsupportedtype","title":"UnsupportedType","text":"

Syntax:

!unsup.type<\n  ::llvm::StringRef   # originName\n>\n
"},{"location":"dialects/Unsupported/Unsupported/#parameters_1","title":"Parameters:","text":"Parameter C++ type Description originName ::llvm::StringRef"}]} \ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml new file mode 100644 index 0000000000..8a2b4fa9cb --- /dev/null +++ b/sitemap.xml @@ -0,0 +1,113 @@ + + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + + None + 2024-02-28 + daily + + \ No newline at end of file diff --git a/sitemap.xml.gz b/sitemap.xml.gz new file mode 100644 index 0000000000..9ef70a7862 Binary files /dev/null and b/sitemap.xml.gz differ diff --git a/statement/index.html b/statement/index.html new file mode 100644 index 0000000000..111cb7900a --- /dev/null +++ b/statement/index.html @@ -0,0 +1,976 @@ + + + + + + + + + + + + + + + + + + + + License - VAST: MLIR for Program Analysis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+ +
+ + + + +
+ + +
+ +
+ + + + + + +
+
+ + + +
+
+
+ + + + +
+
+
+ + + +
+
+
+ + + +
+
+
+ + + +
+
+ + + + + + + + +

VAST is licensed according to the Apache 2.0 license. VAST links against and uses Clang and LLVM APIs. Clang is also licensed under Apache 2.0, with LLVM exceptions.

+

This research was developed with funding from the Defense Advanced Research Projects Agency (DARPA). The views, opinions and/or findings expressed are those of the author and should not be interpreted as representing the official views or policies of the Department of Defense or the U.S. Government.

+

Distribution Statement A – Approved for Public Release, Distribution Unlimited

+ + + + + + +
+
+ + +
+ +
+ + + +
+
+
+
+ + + + + + + + + + + + \ No newline at end of file