[EmitC] Remove the forked emitter and generate all the code in the conversion pass (#16357)
This resolves the longstanding painpoint of having a custom fork of the
EmitC dialect to C emitter infrastructure in IREE. This is done by
generating `emitc.verbatim` ops for the missing pieces in the
conversion.
Things that need to be addressed:
- Move `createModuleStructure` into a separate file. Skipped for now as
it introduces hundreds lines of diff noise
- The creation of the descriptor arrays are a 1:1 copy from the old
CModuleTarget. Helper structs/functions around these would help
readability.
- Convert the `vm.module` to a `builtin.module` in the conversion.
(Would need to make the conversion pass run on the outer
`builtin.module` and nest the pass manager correctly, I think?)
- The `FuncAnalysis` became kind of a sink where different pieces of
information are mashed together with subtle bugs around uninitialized
variables from the different constructos.
---------
Co-authored-by: Marius Brehler <marius.brehler@iml.fraunhofer.de>
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/ConvertVMToEmitC.cpp b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/ConvertVMToEmitC.cpp
index ca276f5..a4cb660 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/ConvertVMToEmitC.cpp
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/ConvertVMToEmitC.cpp
@@ -14,11 +14,9 @@
#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h"
#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/VMAnalysis.h"
#include "iree/compiler/Dialect/VM/IR/VMOps.h"
-#include "iree/compiler/Dialect/VM/Utils/CallingConvention.h"
#include "llvm/ADT/TypeSwitch.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinDialect.h"
#include "mlir/IR/BuiltinOps.h"
@@ -46,15 +44,6 @@
CCONV_ARGUMENT_MODULE_STATE,
};
-/// The EmitC dialect is currently missing operations to cleanly represent some
-/// constructs we need for the C target. This includes storage class specifiers
-/// on functions, forward declarations of functions, globals and arrays.
-/// As a workaround the conversion currently adds bits of information via
-/// attributes that later get used by the CModuleTarget.
-void attachAttribute(Operation *op, StringRef name, Attribute value) {
- op->setAttr(name, value);
-}
-
/// Create a call to memset to clear a struct
LogicalResult clearStruct(OpBuilder builder, Value structValue) {
auto loc = structValue.getLoc();
@@ -82,10 +71,11 @@
auto moduleOp = funcOp.getOperation()->getParentOfType<IREE::VM::ModuleOp>();
FunctionType funcType = funcOp.getFunctionType();
- std::string name =
- std::string(moduleOp.getName()) + "_" + std::string(funcOp.getName());
- std::string moduleTypeName = (moduleOp.getName() + "_t").str();
- std::string moduleStateTypeName = (moduleOp.getName() + "_state_t").str();
+ std::string name = moduleOp.getName().str() + "_" + funcOp.getName().str();
+ std::string moduleTypeName =
+ std::string("struct ") + moduleOp.getName().str() + "_t";
+ std::string moduleStateTypeName =
+ std::string("struct ") + moduleOp.getName().str() + "_state_t";
Type stackType =
emitc::PointerType::get(emitc::OpaqueType::get(ctx, "iree_vm_stack_t"));
@@ -113,17 +103,10 @@
auto newFuncType = mlir::FunctionType::get(
ctx, {inputTypes}, {emitc::OpaqueType::get(ctx, "iree_status_t")});
- auto newFuncOp = builder.create<mlir::func::FuncOp>(loc, name, newFuncType);
-
- attachAttribute(newFuncOp, "emitc.static", UnitAttr::get(ctx));
-
- std::optional<std::string> callingConvention =
- makeCallingConventionString(funcOp);
-
- // Annotate new function with calling convention string which gets used in
- // the CModuleTarget.
- attachAttribute(newFuncOp, "vm.calling_convention",
- StringAttr::get(ctx, callingConvention.value()));
+ auto newFuncOp = builder.create<mlir::emitc::FuncOp>(loc, name, newFuncType);
+ newFuncOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ newFuncOp.setPrivate();
// This call shold be equivalent to rewriter.inlineRegionBefore()
newFuncOp.getFunctionBody().getBlocks().splice(
@@ -373,20 +356,23 @@
/// Releases refs which are local to the function as well as ref arguments.
void releaseRefs(OpBuilder &builder, Location location,
- mlir::func::FuncOp funcOp,
+ mlir::emitc::FuncOp funcOp,
IREE::VM::ModuleAnalysis &moduleAnalysis) {
auto ctx = builder.getContext();
auto &funcAnalysis = moduleAnalysis.lookupFunction(funcOp);
- for (auto pair : funcAnalysis.localRefs()) {
- Operation *op = pair.second;
+ if (funcAnalysis.hasLocalRefs()) {
- assert(isa<emitc::ApplyOp>(op));
+ for (auto pair : funcAnalysis.localRefs()) {
+ Operation *op = pair.second;
- Value localRef = cast<emitc::ApplyOp>(op).getResult();
+ assert(isa<emitc::ApplyOp>(op));
- emitc_builders::ireeVmRefRelease(builder, location, localRef);
+ Value localRef = cast<emitc::ApplyOp>(op).getResult();
+
+ emitc_builders::ireeVmRefRelease(builder, location, localRef);
+ }
}
// We only release the original arguments not the results which were appended
@@ -403,8 +389,8 @@
}
}
-/// Generate an emitc.call op with one result and split the current block into a
-/// continuation and failure block based on the truthiness of the result
+/// Generate an emitc.call_opaque op with one result and split the current block
+/// into a continuation and failure block based on the truthiness of the result
/// value, i.e. a truthy value branches to the continuation block when
/// `negateCondition` is false.
emitc::CallOpaqueOp failableCall(
@@ -444,7 +430,7 @@
}
builder.setInsertionPointToEnd(condBlock);
- builder.create<IREE::VM::CondBranchOp>(
+ builder.create<mlir::cf::CondBranchOp>(
location, conditionI1.getResult(),
negateCondition ? failureBlock : continuationBlock,
negateCondition ? continuationBlock : failureBlock);
@@ -461,11 +447,12 @@
auto blockBuilder = [&builder, &location,
&moduleAnalysis](emitc::CallOpaqueOp &callOp) {
Block *block = builder.getBlock();
- mlir::func::FuncOp funcOp = cast<mlir::func::FuncOp>(block->getParentOp());
+ mlir::emitc::FuncOp funcOp =
+ cast<mlir::emitc::FuncOp>(block->getParentOp());
releaseRefs(builder, location, funcOp, moduleAnalysis);
- builder.create<mlir::func::ReturnOp>(location, callOp.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(location, callOp.getResult(0));
};
auto ctx = builder.getContext();
@@ -483,7 +470,8 @@
auto ctx = builder.getContext();
Block *block = builder.getBlock();
- mlir::func::FuncOp funcOp = cast<mlir::func::FuncOp>(block->getParentOp());
+ mlir::emitc::FuncOp funcOp =
+ cast<mlir::emitc::FuncOp>(block->getParentOp());
releaseRefs(builder, location, funcOp, moduleAnalysis);
@@ -497,23 +485,23 @@
/*templateArgs=*/ArrayAttr{},
/*operands=*/ArrayRef<Value>{});
- builder.create<mlir::func::ReturnOp>(location, statusOp.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(location, statusOp.getResult(0));
};
return failableCall(builder, location, type, callee, args, operands,
blockBuilder);
}
-/// Generate a mlir.call op with one result and split the current block into a
+/// Generate a emitc.call op with one result and split the current block into a
/// continuation and failure block based on the truthiness of the result
/// value, i.e. a truthy value branches to the continuation block when
/// `negateCondition` is false.
-mlir::func::CallOp failableCall(
- OpBuilder &builder, Location location, mlir::func::FuncOp &callee,
+mlir::emitc::CallOp failableCall(
+ OpBuilder &builder, Location location, mlir::emitc::FuncOp &callee,
ArrayRef<Value> operands,
- const std::function<void(mlir::func::CallOp &)> &failureBlockBuilder,
+ const std::function<void(mlir::emitc::CallOp &)> &failureBlockBuilder,
bool negateCondition = false) {
- auto callOp = builder.create<mlir::func::CallOp>(
+ auto callOp = builder.create<mlir::emitc::CallOp>(
/*location=*/location,
/*callee=*/callee,
/*operands=*/operands);
@@ -542,7 +530,7 @@
}
builder.setInsertionPointToEnd(condBlock);
- builder.create<IREE::VM::CondBranchOp>(
+ builder.create<mlir::cf::CondBranchOp>(
location, conditionI1.getResult(),
negateCondition ? failureBlock : continuationBlock,
negateCondition ? continuationBlock : failureBlock);
@@ -552,18 +540,19 @@
return callOp;
}
-mlir::func::CallOp returnIfError(OpBuilder &builder, Location location,
- mlir::func::FuncOp &callee,
- ArrayRef<Value> operands,
- IREE::VM::ModuleAnalysis &moduleAnalysis) {
+mlir::emitc::CallOp returnIfError(OpBuilder &builder, Location location,
+ mlir::emitc::FuncOp &callee,
+ ArrayRef<Value> operands,
+ IREE::VM::ModuleAnalysis &moduleAnalysis) {
auto blockBuilder = [&builder, &location,
- &moduleAnalysis](mlir::func::CallOp &callOp) {
+ &moduleAnalysis](mlir::emitc::CallOp &callOp) {
Block *block = builder.getBlock();
- mlir::func::FuncOp funcOp = cast<mlir::func::FuncOp>(block->getParentOp());
+ mlir::emitc::FuncOp funcOp =
+ cast<mlir::emitc::FuncOp>(block->getParentOp());
releaseRefs(builder, location, funcOp, moduleAnalysis);
- builder.create<mlir::func::ReturnOp>(location, callOp.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(location, callOp.getResult(0));
};
return failableCall(builder, location, callee, operands, blockBuilder,
@@ -590,19 +579,20 @@
ctx, {emitc::PointerType::get(emitc::OpaqueType::get(ctx, "void"))},
{});
- auto funcOp = builder.create<mlir::func::FuncOp>(
+ auto funcOp = builder.create<mlir::emitc::FuncOp>(
loc, moduleName + "_destroy", funcType);
+ funcOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ funcOp.setPrivate();
- moduleAnalysis.addDummy(funcOp);
-
- attachAttribute(funcOp, "emitc.static", UnitAttr::get(ctx));
+ moduleAnalysis.addDummy(funcOp, /*emitAtEnd=*/false);
Block *entryBlock = funcOp.addEntryBlock();
const BlockArgument moduleArg = funcOp.getArgument(moduleArgIndex);
builder.setInsertionPointToStart(entryBlock);
- std::string moduleTypeName = moduleName + "_t";
+ std::string moduleTypeName = std::string("struct ") + moduleName + "_t";
auto castedModuleOp = builder.create<emitc::CastOp>(
/*location=*/loc,
@@ -624,7 +614,7 @@
/*templateArgs=*/ArrayAttr{},
/*operands=*/ArrayRef<Value>{allocatorOp, castedModuleOp.getResult()});
- builder.create<mlir::func::ReturnOp>(loc);
+ builder.create<mlir::emitc::ReturnOp>(loc, nullptr);
}
// iree_status_t alloc_state(void*, iree_allocator_t,
@@ -643,12 +633,13 @@
emitc::OpaqueType::get(ctx, "iree_vm_module_state_t")))},
{emitc::OpaqueType::get(ctx, "iree_status_t")});
- auto funcOp = builder.create<mlir::func::FuncOp>(
+ auto funcOp = builder.create<mlir::emitc::FuncOp>(
loc, moduleName + "_alloc_state", funcType);
+ funcOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ funcOp.setPrivate();
- moduleAnalysis.addDummy(funcOp);
-
- attachAttribute(funcOp, "emitc.static", UnitAttr::get(ctx));
+ moduleAnalysis.addDummy(funcOp, /*emitAtEnd=*/false);
Block *entryBlock = funcOp.addEntryBlock();
@@ -658,7 +649,8 @@
builder.setInsertionPointToStart(entryBlock);
- std::string moduleStateTypeName = moduleName + "_state_t";
+ std::string moduleStateTypeName =
+ std::string("struct ") + moduleName + "_state_t";
Value state = emitc_builders::allocateVariable(
builder, loc,
@@ -807,7 +799,7 @@
auto status = emitc_builders::ireeOkStatus(builder, loc);
- builder.create<mlir::func::ReturnOp>(loc, status);
+ builder.create<mlir::emitc::ReturnOp>(loc, status);
}
// void free_state(void*, iree_vm_module_state_t*)
@@ -823,12 +815,13 @@
emitc::OpaqueType::get(ctx, "iree_vm_module_state_t"))},
{});
- auto funcOp = builder.create<mlir::func::FuncOp>(
+ auto funcOp = builder.create<mlir::emitc::FuncOp>(
loc, moduleName + "_free_state", funcType);
+ funcOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ funcOp.setPrivate();
- moduleAnalysis.addDummy(funcOp);
-
- attachAttribute(funcOp, "emitc.static", UnitAttr::get(ctx));
+ moduleAnalysis.addDummy(funcOp, /*emitAtEnd=*/false);
Block *entryBlock = funcOp.addEntryBlock();
@@ -837,7 +830,8 @@
builder.setInsertionPointToStart(entryBlock);
- std::string moduleStateTypeName = moduleName + "_state_t";
+ std::string moduleStateTypeName =
+ std::string("struct ") + moduleName + "_state_t";
auto stateOp = builder.create<emitc::CastOp>(
/*location=*/loc,
@@ -891,7 +885,7 @@
/*operands=*/
ArrayRef<Value>{allocatorOp, stateOp.getResult()});
- builder.create<mlir::func::ReturnOp>(loc);
+ builder.create<mlir::emitc::ReturnOp>(loc, nullptr);
}
// iree_status_t resolve_import(
@@ -922,12 +916,13 @@
},
{emitc::OpaqueType::get(ctx, "iree_status_t")});
- auto funcOp = builder.create<mlir::func::FuncOp>(
+ auto funcOp = builder.create<mlir::emitc::FuncOp>(
loc, moduleName + "_resolve_import", funcType);
+ funcOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ funcOp.setPrivate();
- moduleAnalysis.addDummy(funcOp);
-
- attachAttribute(funcOp, "emitc.static", UnitAttr::get(ctx));
+ moduleAnalysis.addDummy(funcOp, /*emitAtEnd=*/false);
Block *entryBlock = funcOp.addEntryBlock();
@@ -938,7 +933,8 @@
builder.setInsertionPointToStart(entryBlock);
- std::string moduleStateTypeName = moduleName + "_state_t";
+ std::string moduleStateTypeName =
+ std::string("struct ") + moduleName + "_state_t";
auto stateOp = builder.create<emitc::CastOp>(
/*location=*/loc,
@@ -972,7 +968,7 @@
auto status = emitc_builders::ireeOkStatus(builder, loc);
- builder.create<mlir::func::ReturnOp>(loc, status);
+ builder.create<mlir::emitc::ReturnOp>(loc, status);
}
// iree_status_t create(
@@ -1000,19 +996,14 @@
emitc::OpaqueType::get(ctx, "iree_status_t"),
});
- auto funcOp = builder.create<mlir::func::FuncOp>(
+ auto funcOp = builder.create<mlir::emitc::FuncOp>(
loc, moduleName + "_create", funcType);
-
- moduleAnalysis.addDummy(funcOp);
+ funcOp.setPublic();
// This function needs an iree_vm_native_module_descriptor_t that is emitted
// by the CModuleTarget at the moment. So we add a marker to this function
// and delay the printing of it.
- attachAttribute(funcOp, "vm.emit_at_end", UnitAttr::get(ctx));
-
- // This functions is the only one users need and it is therefore declared
- // separatly from all other functions.
- attachAttribute(funcOp, "vm.module.constructor", UnitAttr::get(ctx));
+ moduleAnalysis.addDummy(funcOp, /*emitAtEnd=*/true);
Block *entryBlock = funcOp.addEntryBlock();
@@ -1022,7 +1013,7 @@
builder.setInsertionPointToStart(entryBlock);
- std::string moduleTypeName = moduleName + "_t";
+ std::string moduleTypeName = std::string("struct ") + moduleName + "_t";
Value module = emitc_builders::allocateVariable(
builder, loc,
@@ -1051,9 +1042,8 @@
/*memberName=*/"allocator",
/*operand=*/module,
/*value=*/allocatorArg);
+
auto &typeTable = moduleAnalysis.typeTable;
- attachAttribute(moduleOp, "vm.num_types",
- builder.getI32IntegerAttr(typeTable.size()));
if (!typeTable.empty()) {
Type typeRefType = emitc::OpaqueType::get(ctx, "iree_vm_ref_type_t");
Type typeRefArrayType = emitc::PointerType::get(typeRefType);
@@ -1063,7 +1053,6 @@
std::string listType = "!vm.list";
for (auto [index, typeDef] : llvm::enumerate(typeTable)) {
std::string typeName = typeDef.full_name;
- moduleAnalysis.mapType(typeDef.type, index);
std::string listPrefix = typeName.substr(0, listType.size());
if (listType == listPrefix) {
typeName = listPrefix;
@@ -1131,13 +1120,13 @@
/*operands=*/
ArrayRef<Value>{allocatorArg, module});
- builder.create<mlir::func::ReturnOp>(loc,
- vmInitializeStatus.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(loc,
+ vmInitializeStatus.getResult(0));
}
builder.setInsertionPointToEnd(condBlock);
- builder.create<IREE::VM::CondBranchOp>(loc, vmInitializeIsOk.getResult(0),
+ builder.create<mlir::cf::CondBranchOp>(loc, vmInitializeIsOk.getResult(0),
continuationBlock, failureBlock);
builder.setInsertionPointToStart(continuationBlock);
@@ -1166,7 +1155,331 @@
/*operands=*/
ArrayRef<Value>{vmModulePtr, instanceArg, allocatorArg, moduleArg});
- builder.create<mlir::func::ReturnOp>(loc, status.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(loc, status.getResult(0));
+ }
+
+ return success();
+}
+
+/// Generate boilerplate code like includes for the IREE C API, include guards,
+/// structures to hold the module state, functions and global variables to
+/// create a module instance etc.
+LogicalResult
+createModuleStructure(IREE::VM::ModuleOp moduleOp,
+ IREE::VM::EmitCTypeConverter &typeConverter) {
+ if (failed(createAPIFunctions(moduleOp, typeConverter.analysis))) {
+ return failure();
+ }
+
+ auto loc = moduleOp.getLoc();
+
+ OpBuilder builder(moduleOp);
+
+ SmallVector<Operation *> opsToRemove;
+ {
+ OpBuilder::InsertionGuard guard(builder);
+ builder.setInsertionPointToStart(&moduleOp.getBlock());
+
+ std::string includeGuard = moduleOp.getName().upper() + "_H_";
+
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::IFNDEF,
+ includeGuard);
+
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::DEFINE,
+ includeGuard);
+
+ builder.create<emitc::IncludeOp>(loc, "iree/vm/api.h");
+
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::IFDEF,
+ "__cplusplus");
+ builder.create<emitc::VerbatimOp>(loc, "extern \"C\" {");
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::ENDIF,
+ "// __cplusplus");
+
+ // Emit declarations for public functions.
+ for (auto funcOp : moduleOp.getOps<mlir::emitc::FuncOp>()) {
+ if (funcOp.isPublic()) {
+ builder.create<emitc::DeclareFuncOp>(loc, funcOp.getName());
+ }
+ }
+
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::IFDEF,
+ "__cplusplus");
+ builder.create<emitc::VerbatimOp>(loc, "} // extern \"C\"");
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::ENDIF,
+ "// __cplusplus");
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::ENDIF,
+ std::string("// ") + includeGuard);
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::IF,
+ "defined(EMITC_IMPLEMENTATION)");
+ builder.create<emitc::IncludeOp>(loc, "iree/vm/ops.h");
+ builder.create<emitc::IncludeOp>(loc, "iree/vm/ops_emitc.h");
+ builder.create<emitc::IncludeOp>(loc, "iree/vm/shims_emitc.h");
+
+ // Rodata ops.
+ for (auto rodataOp : moduleOp.getOps<IREE::VM::RodataOp>()) {
+ auto value = llvm::dyn_cast<IREE::Util::SerializableAttrInterface>(
+ rodataOp.getValue());
+ assert(value && "expected a serializable rodata value");
+ SmallVector<char> byteBuffer;
+ if (failed(value.serializeToVector(
+ rodataOp.getLoc(), llvm::endianness::little, byteBuffer))) {
+ return rodataOp.emitError() << "error during serialization";
+ }
+
+ constexpr size_t kDefaultRodataAlignment = 16;
+ size_t alignment =
+ rodataOp.getAlignment()
+ ? static_cast<size_t>(rodataOp.getAlignment().value())
+ : 0;
+ if (alignment == 0)
+ alignment = kDefaultRodataAlignment;
+
+ std::string bufferName =
+ moduleOp.getName().str() + "_" + rodataOp.getName().str();
+
+ std::string stmt = "iree_alignas(" + std::to_string(alignment) +
+ ") static const uint8_t " + bufferName + "[] = {";
+ size_t index = 0;
+ for (char value : byteBuffer) {
+ if (index++ > 0)
+ stmt += ", ";
+ stmt += std::to_string(
+ static_cast<unsigned int>(static_cast<unsigned char>(value)));
+ }
+ stmt += "};";
+ builder.create<emitc::VerbatimOp>(loc, stmt);
+ opsToRemove.push_back(rodataOp.getOperation());
+ }
+
+ // structs
+ // Returns |count| or 1 if |count| == 0.
+ // Some compilers (MSVC) don't support zero-length struct fields on the
+ // interior of structs (just VLA at the tail).
+ auto countOrEmpty = [](uint32_t count) { return count ? count : 1; };
+
+ const int64_t numTypes = typeConverter.analysis.typeTable.size();
+
+ std::string moduleStructName = moduleOp.getName().str() + "_t";
+ SmallVector<emitc_builders::StructField> moduleStructFields{
+ {"iree_allocator_t", "allocator"},
+ {"iree_vm_ref_type_t", "types", countOrEmpty(numTypes)}};
+
+ emitc_builders::structDefinition(builder, loc, moduleStructName,
+ moduleStructFields);
+
+ auto ordinalCounts = moduleOp.getOrdinalCountsAttr();
+
+ std::string moduleStructStateName = moduleOp.getName().str() + "_state_t";
+ SmallVector<emitc_builders::StructField> moduleStructStateFields{
+ {"iree_allocator_t", "allocator"},
+ {"uint8_t", "rwdata", countOrEmpty(ordinalCounts.getGlobalBytes())},
+ {"iree_vm_ref_t", "refs", countOrEmpty(ordinalCounts.getGlobalRefs())},
+ {"iree_vm_buffer_t", "rodata_buffers",
+ countOrEmpty(ordinalCounts.getRodatas())},
+ {"iree_vm_function_t", "imports",
+ countOrEmpty(ordinalCounts.getImportFuncs())},
+ };
+
+ emitc_builders::structDefinition(builder, loc, moduleStructStateName,
+ moduleStructStateFields);
+
+ // Emit declarations for private functions.
+ for (auto funcOp : moduleOp.getOps<mlir::emitc::FuncOp>()) {
+ if (funcOp.isPrivate()) {
+ builder.create<emitc::DeclareFuncOp>(loc, funcOp.getName());
+ }
+ }
+
+ // TODO(simon-camp): Move these to a structured helper
+ // global descriptors
+ // - define structs for each entity etc.
+ auto printStringView = [](StringRef s) -> std::string {
+ // We can't use iree_make_string_view because function calls are not
+ // allowed for constant expressions in C.
+ // TODO(#7605): Switch to IREE_SVL. We can't use IREE_SVL today because it
+ // uses designated initializers, which cause issues when compiled as C++.
+ return ("{\"" + s + "\", " + std::to_string(s.size()) + "}").str();
+ };
+
+ // dependencies
+ std::string dependenciesName = moduleOp.getName().str() + "_dependencies_";
+ std::string deps;
+ deps += "static const iree_vm_module_dependency_t " + dependenciesName +
+ "[] = {";
+ auto dependencies = moduleOp.getDependencies();
+ if (dependencies.empty()) {
+ // Empty list placeholder.
+ deps += "{{0}},";
+ } else {
+ for (auto &dependency : dependencies) {
+ deps += "{" + printStringView(dependency.name) + ", " +
+ std::to_string(dependency.minimumVersion) + ", " +
+ (dependency.isOptional
+ ? "IREE_VM_MODULE_DEPENDENCY_FLAG_OPTIONAL"
+ : "IREE_VM_MODULE_DEPENDENCY_FLAG_REQUIRED") +
+ "},";
+ }
+ }
+ deps += "};";
+ builder.create<emitc::VerbatimOp>(loc, deps);
+
+ // Imports.
+ SmallVector<IREE::VM::ImportOp> importOps(
+ moduleOp.getOps<IREE::VM::ImportOp>());
+ std::string importName = moduleOp.getName().str() + "_imports_";
+ std::string imports;
+ imports += "static const iree_vm_native_import_descriptor_t " + importName +
+ "[] = {";
+ if (importOps.empty()) {
+ // Empty list placeholder.
+ imports += "{0},";
+ } else {
+ // Sort import ops by ordinal.
+ llvm::sort(importOps, [](auto &lhs, auto &rhs) {
+ return lhs.getOrdinal()->getZExtValue() <
+ rhs.getOrdinal()->getZExtValue();
+ });
+ for (auto importOp : importOps) {
+ imports +=
+ std::string("{") +
+ (importOp.getIsOptional() ? "IREE_VM_NATIVE_IMPORT_OPTIONAL"
+ : "IREE_VM_NATIVE_IMPORT_REQUIRED") +
+ ", " + printStringView(importOp.getName()) + "},";
+ }
+ }
+ imports += "};";
+ builder.create<emitc::VerbatimOp>(loc, imports);
+
+ for (auto op : moduleOp.getOps<IREE::VM::ImportOp>()) {
+ opsToRemove.push_back(op);
+ }
+
+ // Exports.
+ SmallVector<emitc::FuncOp> exportedFunctions;
+ for (auto func : moduleOp.getOps<emitc::FuncOp>()) {
+ if (typeConverter.analysis.lookupFunction(func).isExported()) {
+ exportedFunctions.push_back(func);
+ }
+ }
+ auto extractExportName = [&typeConverter](emitc::FuncOp funcOp) {
+ return typeConverter.analysis.lookupFunction(funcOp).getExportName();
+ };
+ std::string exportName = moduleOp.getName().str() + "_exports_";
+ std::string exports;
+ exports += "static const iree_vm_native_export_descriptor_t " + exportName +
+ "[] = {";
+ if (exportedFunctions.empty()) {
+ // Empty list placeholder.
+ exports += "{{0}},";
+ } else {
+ // Sort export ops.
+ llvm::sort(exportedFunctions, [&extractExportName](auto &lhs, auto &rhs) {
+ return extractExportName(lhs).compare(extractExportName(rhs)) < 0;
+ });
+ for (auto funcOp : exportedFunctions) {
+ StringRef exportName = extractExportName(funcOp);
+ StringRef callingConvention =
+ typeConverter.analysis.lookupFunction(funcOp)
+ .getCallingConvention();
+
+ // TODO(simon-camp): support function-level reflection attributes
+ exports += "{" + printStringView(exportName) + ", " +
+ printStringView(callingConvention) + ", 0, NULL},";
+ }
+ }
+ exports += "};";
+ builder.create<emitc::VerbatimOp>(loc, exports);
+
+ // Functions.
+ std::string functionName = moduleOp.getName().str() + "_funcs_";
+ std::string functions;
+ functions +=
+ "static const iree_vm_native_function_ptr_t " + functionName + "[] = {";
+ if (exportedFunctions.empty()) {
+ // Empty list placeholder.
+ functions += "{0},";
+ } else {
+ // We only add exported functions to the table, as calls to internal
+ // functions are directly mapped to C function calls of the generated
+ // implementation.
+ for (auto funcOp : exportedFunctions) {
+ auto funcName = funcOp.getName();
+ functions += std::string("{") +
+ "(iree_vm_native_function_shim_t)iree_emitc_shim, " +
+ "(iree_vm_native_function_target_t)" + funcName.str() +
+ "},";
+ }
+ }
+ functions += "};";
+ builder.create<emitc::VerbatimOp>(loc, functions);
+
+ // Module descriptor.
+ // TODO(simon-camp): support module-level reflection attributes
+ std::string descriptorName = moduleOp.getName().str() + "_descriptor_";
+ std::string descriptor;
+ descriptor +=
+ "static const iree_vm_native_module_descriptor_t " + descriptorName +
+ " = {"
+ // name:
+ + printStringView(moduleOp.getName()) +
+ ","
+ // version:
+ + std::to_string(moduleOp.getVersion().value_or(0u)) +
+ ","
+ // attrs:
+ + "0," +
+ "NULL,"
+ // dependencies:
+ + std::to_string(dependencies.size()) + "," + dependenciesName +
+ ","
+ // imports:
+ + std::to_string(importOps.size()) + "," + importName +
+ ","
+ // exports:
+ + std::to_string(exportedFunctions.size()) + "," + exportName +
+ ","
+ // functions:
+ + std::to_string(exportedFunctions.size()) + "," + functionName + "," +
+ "};";
+
+ builder.create<emitc::VerbatimOp>(loc, descriptor);
+
+ // Move functions marked as `emitAtEnd` to the end of the module.
+ auto funcs =
+ SmallVector<emitc::FuncOp>(moduleOp.getOps<mlir::emitc::FuncOp>());
+ for (auto func : funcs) {
+ if (typeConverter.analysis.lookupFunction(func).shouldEmitAtEnd()) {
+ func->moveBefore(moduleOp.getBlock().getTerminator());
+ }
+ }
+
+ builder.setInsertionPoint(moduleOp.getBlock().getTerminator());
+ emitc_builders::preprocessorDirective(builder, loc, emitc_builders::ENDIF,
+ " // EMITC_IMPLEMENTATION");
+ }
+
+ for (auto op : opsToRemove) {
+ op->erase();
+ }
+
+ // TODO(simon-camp): The Cpp Emitter expects a builtin.module as the
+ // outer container of the supported operations. Instead of nesting a
+ // builtin.module inside the vm.module as in the current implementation,
+ // the conversion pass should be changed to replace the vm.module
+ // with a builtin.module.
+ builder.setInsertionPointToStart(&moduleOp.getBlock());
+ auto innerModule = builder.create<mlir::ModuleOp>(loc);
+
+ IRRewriter rewriter(moduleOp.getContext());
+
+ for (Operation &op : llvm::make_early_inc_range(moduleOp.getBlock())) {
+ if (isa<IREE::VM::ModuleTerminatorOp>(op) ||
+ &op == innerModule.getOperation()) {
+ continue;
+ }
+ rewriter.moveOpBefore(&op, innerModule.getBody(),
+ innerModule.getBody()->end());
}
return success();
@@ -1216,8 +1529,8 @@
}
};
-// Convert vm operations to emitc calls. The resultiong call has the ops
-// operands as arguments followed by an argument for every attribute.
+// Convert vm operations to emitc opaque_calls. The resultiong opaque_call has
+// the ops operands as arguments followed by an argument for every attribute.
template <typename OpTy>
class GenericOpConversion : public EmitCConversionPattern<OpTy> {
using Adaptor = typename OpTy::Adaptor;
@@ -1244,8 +1557,8 @@
ArrayAttr templateArgs;
// If the operation has attributes, we need to explicitely build the args
- // attribute of the emitc call op. This consists of index attributes for
- // the operands, followed by the source op attributes themselves.
+ // attribute of the emitc opaque_call op. This consists of index attributes
+ // for the operands, followed by the source op attributes themselves.
if (op->getAttrs().size() > 0) {
SmallVector<Attribute> args_ =
indexSequence(adaptor.getOperands().size(), op.getContext());
@@ -1279,12 +1592,12 @@
}
};
-class FuncOpConversion : public EmitCConversionPattern<mlir::func::FuncOp> {
- using Adaptor = mlir::func::FuncOp::Adaptor;
- using EmitCConversionPattern<mlir::func::FuncOp>::EmitCConversionPattern;
+class FuncOpConversion : public EmitCConversionPattern<mlir::emitc::FuncOp> {
+ using Adaptor = mlir::emitc::FuncOp::Adaptor;
+ using EmitCConversionPattern<mlir::emitc::FuncOp>::EmitCConversionPattern;
LogicalResult
- matchAndRewrite(mlir::func::FuncOp funcOp, Adaptor adaptor,
+ matchAndRewrite(mlir::emitc::FuncOp funcOp, Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
TypeConverter::SignatureConversion signatureConverter(
funcOp.getFunctionType().getNumInputs());
@@ -1323,12 +1636,10 @@
auto ctx = exportOp.getContext();
auto loc = exportOp.getLoc();
- mlir::func::FuncOp funcOp = lookupSymbolRef<mlir::func::FuncOp>(
+ mlir::emitc::FuncOp funcOp = lookupSymbolRef<mlir::emitc::FuncOp>(
exportOp.getOperation(), "function_ref");
- auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
-
- std::string newFuncName = (funcOp.getName() + "_export_shim").str();
+ std::string newFuncName = funcOp.getName().str() + "_export_shim";
Type stackType =
emitc::PointerType::get(emitc::OpaqueType::get(ctx, "iree_vm_stack_t"));
@@ -1352,16 +1663,12 @@
ctx, {inputTypes}, {emitc::OpaqueType::get(ctx, "iree_status_t")});
auto newFuncOp =
- rewriter.create<mlir::func::FuncOp>(loc, newFuncName, newFuncType);
+ rewriter.create<mlir::emitc::FuncOp>(loc, newFuncName, newFuncType);
+ newFuncOp.setSpecifiersAttr(
+ rewriter.getArrayAttr({rewriter.getStringAttr("static")}));
+ newFuncOp.setPrivate();
- FunctionType functionType = funcAnalysis.getFunctionType();
-
- getModuleAnalysis().add(newFuncOp, functionType);
-
- attachAttribute(newFuncOp, "emitc.static", UnitAttr::get(ctx));
- attachAttribute(newFuncOp, "vm.calling_convention",
- funcOp.getOperation()->getAttr("vm.calling_convention"));
- attachAttribute(newFuncOp, "vm.export_name", exportOp.getExportNameAttr());
+ getModuleAnalysis().addFromExport(newFuncOp, exportOp);
// Populate newly generated function.
{
@@ -1438,7 +1745,7 @@
auto status = emitc_builders::ireeOkStatus(rewriter, loc);
- rewriter.create<mlir::func::ReturnOp>(loc, status);
+ rewriter.create<mlir::emitc::ReturnOp>(loc, status);
}
rewriter.eraseOp(exportOp);
@@ -1449,7 +1756,7 @@
FailureOr<std::pair<Value, Value>>
castModuleAndStateStructs(ConversionPatternRewriter &rewriter,
IREE::VM::ExportOp &exportOp,
- mlir::func::FuncOp &newFuncOp) const {
+ mlir::emitc::FuncOp &newFuncOp) const {
auto ctx = exportOp.getContext();
auto loc = exportOp.getLoc();
@@ -1459,8 +1766,10 @@
auto moduleOp =
newFuncOp.getOperation()->getParentOfType<IREE::VM::ModuleOp>();
- std::string moduleTypeName = (moduleOp.getName() + "_t").str();
- std::string moduleStateTypeName = (moduleOp.getName() + "_state_t").str();
+ std::string moduleTypeName =
+ std::string("struct ") + moduleOp.getName().str() + "_t";
+ std::string moduleStateTypeName =
+ std::string("struct ") + moduleOp.getName().str() + "_state_t";
auto moduleCasted = rewriter.create<emitc::CastOp>(
/*location=*/loc,
@@ -1481,10 +1790,10 @@
FailureOr<std::pair<GeneratedStruct, GeneratedStruct>>
typedefArgumentAndResultStructs(ConversionPatternRewriter &rewriter,
IREE::VM::ExportOp &exportOp,
- mlir::func::FuncOp &newFuncOp) const {
+ mlir::emitc::FuncOp &newFuncOp) const {
auto loc = exportOp.getLoc();
- mlir::func::FuncOp funcOp = lookupSymbolRef<mlir::func::FuncOp>(
+ mlir::emitc::FuncOp funcOp = lookupSymbolRef<mlir::emitc::FuncOp>(
exportOp.getOperation(), "function_ref");
auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
@@ -1540,7 +1849,7 @@
<< "failed to emit C type for struct definition";
}
- std::string structName = (funcOp.getName() + "_args_t").str();
+ std::string structName = funcOp.getName().str() + "_args_t";
argumentStruct.name = structName;
typedefStruct(structName, structBody.value());
}
@@ -1554,7 +1863,7 @@
return failure();
}
- std::string structName = (funcOp.getName() + "_result_t").str();
+ std::string structName = funcOp.getName().str() + "_result_t";
resultStruct.name = structName;
typedefStruct(structName, structBody.value());
}
@@ -1564,7 +1873,7 @@
void castArgumentAndResultStructs(ConversionPatternRewriter &rewriter,
IREE::VM::ExportOp &exportOp,
- mlir::func::FuncOp &newFuncOp,
+ mlir::emitc::FuncOp &newFuncOp,
GeneratedStruct &argumentStruct,
GeneratedStruct &resultStruct) const {
auto ctx = exportOp.getContext();
@@ -1583,7 +1892,8 @@
/*operand=*/newFuncOp.getArgument(SHIM_ARGUMENT_ARGS_STORAGE));
// cast
- std::string argumentsType = argumentStruct.name.value();
+ std::string argumentsType =
+ std::string("struct ") + argumentStruct.name.value();
auto arguments = rewriter.create<emitc::CastOp>(
/*location=*/loc,
/*type=*/
@@ -1605,7 +1915,8 @@
/*operand=*/newFuncOp.getArgument(SHIM_ARGUMENT_RETS_STORAGE));
// cast
- std::string resultType = resultStruct.name.value();
+ std::string resultType =
+ std::string("struct ") + resultStruct.name.value();
auto results = rewriter.create<emitc::CastOp>(
/*location=*/loc,
/*type=*/
@@ -1627,7 +1938,7 @@
return success();
}
- mlir::func::FuncOp funcOp = lookupSymbolRef<mlir::func::FuncOp>(
+ mlir::emitc::FuncOp funcOp = lookupSymbolRef<mlir::emitc::FuncOp>(
exportOp.getOperation(), "function_ref");
auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
@@ -1687,7 +1998,7 @@
const auto typeConverter = getTypeConverter<IREE::VM::EmitCTypeConverter>();
- mlir::func::FuncOp funcOp = lookupSymbolRef<mlir::func::FuncOp>(
+ mlir::emitc::FuncOp funcOp = lookupSymbolRef<mlir::emitc::FuncOp>(
exportOp.getOperation(), "function_ref");
auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
@@ -1799,8 +2110,8 @@
Region *parentRegion = condBlock->getParent();
failureBlock = builder.createBlock(parentRegion, parentRegion->end());
- mlir::func::FuncOp funcOp =
- cast<mlir::func::FuncOp>(failureBlock->getParentOp());
+ mlir::emitc::FuncOp funcOp =
+ cast<mlir::emitc::FuncOp>(failureBlock->getParentOp());
releaseRefs(builder, location, funcOp, typeConverter.analysis);
auto statusOp = builder.create<emitc::CallOpaqueOp>(
@@ -1812,7 +2123,7 @@
ctx, {emitc::OpaqueAttr::get(ctx, "IREE_STATUS_NOT_FOUND")}),
/*templateArgs=*/ArrayAttr{},
/*operands=*/ArrayRef<Value>{});
- builder.create<mlir::func::ReturnOp>(location, statusOp.getResult(0));
+ builder.create<mlir::emitc::ReturnOp>(location, statusOp.getResult(0));
}
builder.setInsertionPointToEnd(condBlock);
@@ -1825,7 +2136,6 @@
LogicalResult createImportShim(IREE::VM::ImportOp &importOp,
DenseIntElementsAttr segmentSizes,
OpBuilder &builder) const {
- auto ctx = importOp.getContext();
auto loc = importOp.getLoc();
auto moduleOp =
@@ -1847,12 +2157,13 @@
<< "Failed to build function type for wrapper";
}
- auto newFuncOp = builder.create<mlir::func::FuncOp>(
+ auto newFuncOp = builder.create<mlir::emitc::FuncOp>(
loc, newFuncName.value(), newFuncType.value());
+ newFuncOp.setSpecifiersAttr(
+ builder.getArrayAttr({builder.getStringAttr("static")}));
+ newFuncOp.setPrivate();
- typeConverter.analysis.add(newFuncOp, importOp.getFunctionType());
-
- attachAttribute(newFuncOp, "emitc.static", UnitAttr::get(ctx));
+ typeConverter.analysis.addFromImport(newFuncOp, importOp);
// Populate newly generated function.
{
@@ -1906,7 +2217,7 @@
auto status = emitc_builders::ireeOkStatus(builder, loc);
- builder.create<mlir::func::ReturnOp>(loc, status);
+ builder.create<mlir::emitc::ReturnOp>(loc, status);
}
return success();
@@ -2060,7 +2371,7 @@
}
LogicalResult packArgumentBuffer(ArrayRef<Type> inputTypes,
- mlir::func::FuncOp &funcOp, Value call,
+ mlir::emitc::FuncOp &funcOp, Value call,
OpBuilder &builder, Location loc) const {
if (inputTypes.empty()) {
return success();
@@ -2130,7 +2441,7 @@
}
LogicalResult unpackResultBuffer(ArrayRef<Type> resultTypes,
- mlir::func::FuncOp &funcOp, Value call,
+ mlir::emitc::FuncOp &funcOp, Value call,
OpBuilder &builder, Location loc) const {
if (resultTypes.empty()) {
return success();
@@ -2301,8 +2612,8 @@
LogicalResult
matchAndRewrite(OpTy op, Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- mlir::func::FuncOp funcOp =
- lookupSymbolRef<mlir::func::FuncOp>(op.getOperation(), "callee");
+ mlir::emitc::FuncOp funcOp =
+ lookupSymbolRef<mlir::emitc::FuncOp>(op.getOperation(), "callee");
IREE::VM::ImportOp importOp =
lookupSymbolRef<IREE::VM::ImportOp>(op.getOperation(), "callee");
@@ -2322,13 +2633,13 @@
LogicalResult rewriteInternalCall(Operation *op, Adaptor adaptor,
ConversionPatternRewriter &rewriter,
- mlir::func::FuncOp funcOp) const {
+ mlir::emitc::FuncOp funcOp) const {
auto loc = op->getLoc();
SmallVector<Value> updatedOperands;
SmallVector<Value> resultOperands;
- auto parentFuncOp = op->getParentOfType<mlir::func::FuncOp>();
+ auto parentFuncOp = op->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stackArg =
parentFuncOp.getArgument(CCONV_ARGUMENT_STACK);
@@ -2369,7 +2680,7 @@
int importOrdinal = importOp.getOrdinal()->getZExtValue();
- auto funcOp = op->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stackArg = funcOp.getArgument(CCONV_ARGUMENT_STACK);
const BlockArgument stateArg =
@@ -2409,7 +2720,7 @@
if (!funcName.has_value())
return op->emitError() << "Couldn't build name to imported function";
- auto callee = moduleOp.lookupSymbol<mlir::func::FuncOp>(funcName.value());
+ auto callee = moduleOp.lookupSymbol<mlir::emitc::FuncOp>(funcName.value());
if (callee == nullptr) {
return op->emitError()
<< "Couldn't find function with name `" << funcName.value() << "`";
@@ -2551,7 +2862,7 @@
auto loc = cmpOp.getLoc();
auto funcOp =
- cmpOp.getOperation()->template getParentOfType<mlir::func::FuncOp>();
+ cmpOp.getOperation()->template getParentOfType<mlir::emitc::FuncOp>();
const auto typeConverter =
this->template getTypeConverter<IREE::VM::EmitCTypeConverter>();
@@ -2604,7 +2915,7 @@
auto ctx = cmpOp.getContext();
auto loc = cmpOp.getLoc();
- auto funcOp = cmpOp.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = cmpOp.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
@@ -2699,7 +3010,7 @@
}
auto funcOp =
- constRefRodataOp.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ constRefRodataOp.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stateArg =
funcOp.getArgument(CCONV_ARGUMENT_MODULE_STATE);
@@ -2954,7 +3265,7 @@
auto ctx = op.getContext();
auto loc = op.getLoc();
- auto funcOp = op.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
// The result variables are the last N arguments of the function.
unsigned int firstOutputArgumentIndex =
@@ -2994,7 +3305,7 @@
auto status = emitc_builders::ireeOkStatus(rewriter, loc);
- rewriter.replaceOpWithNewOp<mlir::func::ReturnOp>(op, status);
+ rewriter.replaceOpWithNewOp<mlir::emitc::ReturnOp>(op, status);
return success();
}
@@ -3017,7 +3328,7 @@
lookupSymbolRef<IREE::VM::ImportOp>(op.getOperation(), "import");
int importOrdinal = importOp.getOrdinal()->getZExtValue();
- auto funcOp = op->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stateArg =
funcOp.getArgument(CCONV_ARGUMENT_MODULE_STATE);
@@ -3085,20 +3396,20 @@
passthroughBlock =
rewriter.createBlock(parentRegion, parentRegion->end());
- auto funcOp = op.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
releaseRefs(rewriter, loc, funcOp, getModuleAnalysis());
auto status = emitc_builders::ireeOkStatus(rewriter, loc);
- rewriter.create<mlir::func::ReturnOp>(loc, status);
+ rewriter.create<mlir::emitc::ReturnOp>(loc, status);
}
Block *failureBlock;
{
OpBuilder::InsertionGuard guard(rewriter);
failureBlock = rewriter.createBlock(parentRegion, parentRegion->end());
- auto funcOp = op.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
releaseRefs(rewriter, loc, funcOp, getModuleAnalysis());
@@ -3143,7 +3454,7 @@
/*operands=*/
ArrayRef<Value>{messageSizeIntOp.getResult(), messageDataOp});
- rewriter.create<mlir::func::ReturnOp>(loc, status.getResult(0));
+ rewriter.create<mlir::emitc::ReturnOp>(loc, status.getResult(0));
}
Type boolType = rewriter.getIntegerType(1);
@@ -3184,7 +3495,7 @@
}
auto funcOp =
- loadOp.getOperation()->template getParentOfType<mlir::func::FuncOp>();
+ loadOp.getOperation()->template getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stateArg =
funcOp.getArgument(CCONV_ARGUMENT_MODULE_STATE);
@@ -3245,7 +3556,7 @@
auto globalOrdinal = globalOp.getOrdinal()->getZExtValue();
- auto funcOp = op->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = op->getParentOfType<mlir::emitc::FuncOp>();
auto &funcAnalysis = this->getModuleAnalysis().lookupFunction(funcOp);
@@ -3271,7 +3582,7 @@
/*operand=*/refs);
auto moduleOp = op->getParentOfType<IREE::VM::ModuleOp>();
- auto parentFuncOp = op->getParentOfType<mlir::func::FuncOp>();
+ auto parentFuncOp = op->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument moduleArg =
parentFuncOp.getArgument(CCONV_ARGUMENT_MODULE);
Type elementType = localValue.getType();
@@ -3345,7 +3656,7 @@
}
auto funcOp =
- storeOp.getOperation()->template getParentOfType<mlir::func::FuncOp>();
+ storeOp.getOperation()->template getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stateArg =
funcOp.getArgument(CCONV_ARGUMENT_MODULE_STATE);
@@ -3376,9 +3687,9 @@
StringRef funcName;
};
-// Convert vm operations with wrapped containers to multiple emitc calls. The
-// wrapping ref pointers are first dereferenced and the results are used as the
-// arguments of the specified function name.
+// Convert vm operations with wrapped containers to multiple emitc opaque_calls.
+// The wrapping ref pointers are first dereferenced and the results are used as
+// the arguments of the specified function name.
template <typename OpTy>
class ContainerOpConversion : public EmitCConversionPattern<OpTy> {
using Adaptor = typename OpTy::Adaptor;
@@ -3559,7 +3870,7 @@
Value containerPtr = emitc_builders::addressOf(rewriter, loc, container);
auto funcOp =
- op.getOperation()->template getParentOfType<mlir::func::FuncOp>();
+ op.getOperation()->template getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument stateArg =
funcOp.getArgument(CCONV_ARGUMENT_MODULE_STATE);
@@ -3642,7 +3953,7 @@
auto moduleOp = op.getOperation()->getParentOfType<IREE::VM::ModuleOp>();
auto parentFuncOp =
- op.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ op.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument moduleArg =
parentFuncOp.getArgument(CCONV_ARGUMENT_MODULE);
auto elementTypePtr =
@@ -3858,7 +4169,7 @@
auto moduleOp = getOp.getOperation()->getParentOfType<IREE::VM::ModuleOp>();
auto parentFuncOp =
- getOp.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ getOp.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
const BlockArgument moduleArg =
parentFuncOp.getArgument(CCONV_ARGUMENT_MODULE);
@@ -4052,7 +4363,7 @@
/*args=*/ArrayAttr{},
/*operands=*/ArrayRef<Value>{refValue}, getModuleAnalysis());
- auto funcOp = setOp.getOperation()->getParentOfType<mlir::func::FuncOp>();
+ auto funcOp = setOp.getOperation()->getParentOfType<mlir::emitc::FuncOp>();
auto &funcAnalysis = getModuleAnalysis().lookupFunction(funcOp);
@@ -4333,7 +4644,7 @@
namespace {
// A pass converting IREE VM operations into the EmitC dialect.
-// vm.func ops get converted to std.func with the calling convention used by
+// vm.func ops get converted to emitc.func with the calling convention used by
// EmitC. Each function gets three additional arguments a `iree_vm_stack_t*` as
// well as two module specific struct pointers (`{module_name}_t*` and
// `{module_name}_state_t`). These are followed by the original function
@@ -4362,8 +4673,8 @@
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ConvertVMToEmitCPass)
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<mlir::emitc::EmitCDialect, mlir::BuiltinDialect,
- mlir::func::FuncDialect, IREE::Util::UtilDialect>();
+ registry.insert<mlir::BuiltinDialect, mlir::cf::ControlFlowDialect,
+ mlir::emitc::EmitCDialect, IREE::Util::UtilDialect>();
}
StringRef getArgument() const override { return "iree-convert-vm-to-emitc"; }
@@ -4378,9 +4689,9 @@
ConversionTarget target(getContext());
EmitCTypeConverter typeConverter(module);
- // Convert vm.func ops to std.func with the calling convention used by
+ // Convert vm.func ops to emitc.func with the calling convention used by
// EmitC. We convert these upfront to make sure vm.call ops always
- // reference std.func ops with the correct calling convention during the
+ // reference emitc.func ops with the correct calling convention during the
// conversion.
SmallVector<IREE::VM::FuncOp> funcsToRemove;
SmallVector<BlockArgument> blockArgsToRemove;
@@ -4395,11 +4706,6 @@
funcOp.erase();
}
- // Generate func ops that implement the C API.
- if (failed(createAPIFunctions(module, typeConverter.analysis))) {
- return signalPassFailure();
- }
-
SmallVector<std::string> importShims;
// The conversion of `call/call.variadic` ops on imported functions expects
@@ -4416,11 +4722,10 @@
populateVMToEmitCPatterns(target, typeConverter, patterns);
target.addLegalDialect<emitc::EmitCDialect, mlir::BuiltinDialect,
- mlir::cf::ControlFlowDialect,
- mlir::func::FuncDialect>();
+ mlir::cf::ControlFlowDialect>();
- target.addDynamicallyLegalOp<mlir::func::FuncOp>(
- [&](mlir::func::FuncOp op) {
+ target.addDynamicallyLegalOp<mlir::emitc::FuncOp>(
+ [&](mlir::emitc::FuncOp op) {
return typeConverter.isSignatureLegal(op.getFunctionType());
});
@@ -4455,6 +4760,10 @@
return;
}
});
+
+ if (failed(createModuleStructure(module, typeConverter))) {
+ return signalPassFailure();
+ }
}
};
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.cpp b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.cpp
index f8b770d..84babe5 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.cpp
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.cpp
@@ -7,11 +7,42 @@
#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h"
#include "llvm/ADT/ArrayRef.h"
-#include "mlir/Dialect/EmitC/IR/EmitC.h"
namespace mlir::iree_compiler::emitc_builders {
namespace {
+std::string mapPreprocessorDirective(PreprocessorDirective directive) {
+ switch (directive) {
+ case PreprocessorDirective::DEFINE:
+ return "#define";
+ case PreprocessorDirective::UNDEF:
+ return "#undef";
+ case PreprocessorDirective::IFDEF:
+ return "#ifdef";
+ case PreprocessorDirective::IFNDEF:
+ return "#ifndef";
+ case PreprocessorDirective::IF:
+ return "#if";
+ case PreprocessorDirective::ENDIF:
+ return "#endif";
+ case PreprocessorDirective::ELSE:
+ return "#else";
+ case PreprocessorDirective::ELIF:
+ return "#elif";
+ case PreprocessorDirective::LINE:
+ return "#line";
+ case PreprocessorDirective::ERROR:
+ return "#error";
+ case PreprocessorDirective::INCLUDE:
+ return "#include";
+ case PreprocessorDirective::PRAGMA:
+ return "#pragma";
+ default:
+ llvm_unreachable("unsupported unary operator");
+ return "XXX";
+ }
+}
+
std::string mapUnaryOperator(UnaryOperator op) {
switch (op) {
case UnaryOperator::PLUS:
@@ -272,20 +303,17 @@
void structDefinition(OpBuilder builder, Location location,
StringRef structName, ArrayRef<StructField> fields) {
- std::string structBody;
-
- for (auto &field : fields) {
- structBody += field.type + " " + field.name + ";";
- }
-
auto ctx = builder.getContext();
+ std::string decl = std::string("struct ") + structName.str() + " {";
+ for (auto &field : fields) {
+ decl += field.type + " " + field.name;
+ if (field.isArray())
+ decl += "[" + std::to_string(field.arraySize.value()) + "]";
+ decl += ";";
+ }
+ decl += "};";
- builder.create<emitc::CallOpaqueOp>(
- /*location=*/location, /*type=*/TypeRange{},
- /*callee=*/StringAttr::get(ctx, "EMITC_TYPEDEF_STRUCT"), /*args=*/
- ArrayAttr::get(ctx, {emitc::OpaqueAttr::get(ctx, structName),
- emitc::OpaqueAttr::get(ctx, structBody)}),
- /*templateArgs=*/ArrayAttr{}, /*operands=*/ArrayRef<Value>{});
+ builder.create<emitc::VerbatimOp>(location, StringAttr::get(ctx, decl));
}
Value structMember(OpBuilder builder, Location location, Type type,
@@ -419,4 +447,17 @@
/*operands=*/ArrayRef<Value>{operand});
}
+emitc::VerbatimOp preprocessorDirective(OpBuilder builder, Location location,
+ PreprocessorDirective directive,
+ StringRef value) {
+
+ auto t = mapPreprocessorDirective(directive);
+ if (!value.empty()) {
+ t += " ";
+ t += value;
+ }
+
+ return builder.create<emitc::VerbatimOp>(location, t);
+}
+
} // namespace mlir::iree_compiler::emitc_builders
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h
index cc8ec72..ab107bc 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCBuilders.h
@@ -11,17 +11,38 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/Location.h"
#include "mlir/IR/Types.h"
#include "mlir/IR/Value.h"
+#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCTypeConverter.h"
+
namespace mlir::iree_compiler::emitc_builders {
struct StructField {
std::string type;
std::string name;
+ std::optional<size_t> arraySize = std::nullopt;
+
+ bool isArray() const { return arraySize.has_value(); }
+};
+
+enum PreprocessorDirective {
+ DEFINE = 0,
+ UNDEF,
+ IFDEF,
+ IFNDEF,
+ IF,
+ ENDIF,
+ ELSE,
+ ELIF,
+ LINE,
+ ERROR,
+ INCLUDE,
+ PRAGMA
};
enum UnaryOperator {
@@ -123,6 +144,10 @@
void ireeVmRefRelease(OpBuilder builder, Location location, Value operand);
+emitc::VerbatimOp preprocessorDirective(OpBuilder builder, Location location,
+ PreprocessorDirective directive,
+ StringRef value);
+
} // namespace mlir::iree_compiler::emitc_builders
#endif // IREE_COMPILER_DIALECT_VM_CONVERSION_VMTOEMITC_EMITCBUILDERS_H_
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCTypeConverter.cpp b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCTypeConverter.cpp
index ca29cb1..b2ae62b 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCTypeConverter.cpp
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/EmitCTypeConverter.cpp
@@ -108,7 +108,6 @@
}
return emitc::OpaqueType::get(type.getContext(), typeLiteral);
}
-
return {};
}
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/VMAnalysis.h b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/VMAnalysis.h
index 0230ab8..e905920 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/VMAnalysis.h
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/VMAnalysis.h
@@ -7,26 +7,48 @@
#ifndef IREE_COMPILER_DIALECT_VM_CONVERSION_VMTOEMITC_VMANALYSIS_H_
#define IREE_COMPILER_DIALECT_VM_CONVERSION_VMTOEMITC_VMANALYSIS_H_
+#include <optional>
+
#include "iree/compiler/Dialect/VM/Analysis/RegisterAllocation.h"
#include "iree/compiler/Dialect/VM/Analysis/ValueLiveness.h"
#include "iree/compiler/Dialect/VM/IR/VMTypes.h"
+#include "iree/compiler/Dialect/VM/Utils/CallingConvention.h"
#include "iree/compiler/Dialect/VM/Utils/TypeTable.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
namespace mlir::iree_compiler::IREE::VM {
+/// TODO(simon-camp): This struct grew from being a wrapper around the
+/// RegisterAllocation and ValueLiveness analyses to also cache other things
+/// needed throughout the conversion. This led to hard to locate failures
+/// when only part of this struct was correctly initialized. This
+/// should be split into multiple structs each with a single responsibility.
struct FuncAnalysis {
-public:
FuncAnalysis() = default;
+ FuncAnalysis(bool emitAtEnd) : emitAtEnd(emitAtEnd) {}
FuncAnalysis(IREE::VM::FuncOp funcOp) {
Operation *op = funcOp.getOperation();
registerAllocation = RegisterAllocation(op);
valueLiveness = ValueLiveness(op);
originalFunctionType = funcOp.getFunctionType();
+ callingConvention = makeCallingConventionString(funcOp).value();
+ refs = DenseMap<int64_t, Operation *>{};
}
- FuncAnalysis(FunctionType functionType) {
+ FuncAnalysis(mlir::emitc::FuncOp funcOp) {
+ originalFunctionType = funcOp.getFunctionType();
+ }
+ FuncAnalysis(IREE::VM::ImportOp importOp) {
+ originalFunctionType = importOp.getFunctionType();
+ callingConvention = makeImportCallingConventionString(importOp).value();
+ }
+ FuncAnalysis(FunctionType functionType, StringRef cconv) {
originalFunctionType = functionType;
+ callingConvention = cconv.str();
+ }
+ FuncAnalysis(FuncAnalysis &analysis, StringRef exportName_) {
+ originalFunctionType = analysis.getFunctionType();
+ callingConvention = analysis.getCallingConvention().str();
+ exportName = exportName_.str();
}
FuncAnalysis(FuncAnalysis &&) = default;
@@ -34,57 +56,94 @@
FuncAnalysis(const FuncAnalysis &) = delete;
FuncAnalysis &operator=(const FuncAnalysis &) = delete;
- FunctionType getFunctionType() { return originalFunctionType; }
+ StringRef getCallingConvention() {
+ assert(callingConvention.has_value());
+ return callingConvention.value();
+ }
+
+ StringRef getExportName() {
+ assert(exportName.has_value());
+ return exportName.value();
+ }
+
+ bool isExported() { return exportName.has_value(); }
+
+ bool shouldEmitAtEnd() { return emitAtEnd.value_or(false); }
+
+ FunctionType getFunctionType() {
+ assert(originalFunctionType.has_value());
+ return originalFunctionType.value();
+ }
int getNumRefRegisters() {
- return registerAllocation.getMaxRefRegisterOrdinal() + 1;
+ assert(registerAllocation.has_value());
+ return registerAllocation.value().getMaxRefRegisterOrdinal() + 1;
}
int getNumRefArguments() {
- assert(originalFunctionType);
- return llvm::count_if(originalFunctionType.getInputs(), [](Type inputType) {
- return isa<IREE::VM::RefType>(inputType);
- });
+ assert(originalFunctionType.has_value());
+ return llvm::count_if(
+ originalFunctionType.value().getInputs(),
+ [](Type inputType) { return isa<IREE::VM::RefType>(inputType); });
}
int getNumLocalRefs() { return getNumRefRegisters() - getNumRefArguments(); }
uint16_t getRefRegisterOrdinal(TypedValue<IREE::VM::RefType> ref) {
- return registerAllocation.mapToRegister(ref).ordinal();
+ assert(registerAllocation.has_value());
+ return registerAllocation.value().mapToRegister(ref).ordinal();
}
bool isMove(Value ref, Operation *op) {
assert(isa<IREE::VM::RefType>(ref.getType()));
- bool lastUse = valueLiveness.isLastValueUse(ref, op);
+ assert(valueLiveness.has_value());
+ bool lastUse = valueLiveness.value().isLastValueUse(ref, op);
return lastUse && false;
}
void cacheLocalRef(int64_t ordinal, emitc::ApplyOp applyOp) {
- assert(!refs.count(ordinal) && "ref was already cached");
- refs[ordinal] = applyOp.getOperation();
+ assert(refs.has_value());
+ assert(!refs.value().count(ordinal) && "ref was already cached");
+ refs.value()[ordinal] = applyOp.getOperation();
}
emitc::ApplyOp lookupLocalRef(int64_t ordinal) {
- assert(refs.count(ordinal) && "ref not found in cache");
- Operation *op = refs[ordinal];
+ assert(refs.has_value());
+ assert(refs.value().count(ordinal) && "ref not found in cache");
+ Operation *op = refs.value()[ordinal];
return cast<emitc::ApplyOp>(op);
}
- DenseMap<int64_t, Operation *> &localRefs() { return refs; }
+ bool hasLocalRefs() { return refs.has_value(); }
+
+ DenseMap<int64_t, Operation *> &localRefs() {
+ assert(refs.has_value());
+ return refs.value();
+ }
private:
- RegisterAllocation registerAllocation;
- ValueLiveness valueLiveness;
- DenseMap<int64_t, Operation *> refs;
- FunctionType originalFunctionType;
+ std::optional<RegisterAllocation> registerAllocation;
+ std::optional<ValueLiveness> valueLiveness;
+ std::optional<DenseMap<int64_t, Operation *>> refs;
+ std::optional<FunctionType> originalFunctionType;
+ std::optional<std::string> callingConvention;
+ std::optional<std::string> exportName;
+ std::optional<bool> emitAtEnd;
};
struct ModuleAnalysis {
ModuleAnalysis(IREE::VM::ModuleOp module) {
typeTable = buildTypeTable(module);
+ for (auto [index, typeDef] : llvm::enumerate(typeTable)) {
+ mapType(typeDef.type, index);
+ }
+
for (auto func : module.getOps<IREE::VM::FuncOp>()) {
functions[func.getOperation()] = FuncAnalysis(func);
}
+ for (auto func : module.getOps<mlir::emitc::FuncOp>()) {
+ functions[func.getOperation()] = FuncAnalysis(func);
+ }
}
ModuleAnalysis(ModuleAnalysis &&) = default;
@@ -92,15 +151,25 @@
ModuleAnalysis(const ModuleAnalysis &) = delete;
ModuleAnalysis &operator=(const ModuleAnalysis &) = delete;
- void addDummy(mlir::func::FuncOp func) {
- functions[func.getOperation()] = FuncAnalysis();
+ void addDummy(mlir::emitc::FuncOp func, bool emitAtEnd) {
+ functions[func.getOperation()] = FuncAnalysis(emitAtEnd);
}
- void add(mlir::func::FuncOp func, FunctionType type) {
- functions[func.getOperation()] = FuncAnalysis(type);
+ void addFromExport(mlir::emitc::FuncOp func, IREE::VM::ExportOp exportOp) {
+ mlir::emitc::FuncOp funcOp =
+ exportOp->getParentOfType<IREE::VM::ModuleOp>()
+ .lookupSymbol<mlir::emitc::FuncOp>(exportOp.getFunctionRefAttr());
+
+ auto &funcAnalysis = lookupFunction(funcOp);
+ functions[func.getOperation()] =
+ FuncAnalysis(funcAnalysis, exportOp.getExportName());
}
- void move(mlir::func::FuncOp newFunc, IREE::VM::FuncOp oldFunc) {
+ void addFromImport(mlir::emitc::FuncOp func, IREE::VM::ImportOp import) {
+ functions[func.getOperation()] = FuncAnalysis(import);
+ }
+
+ void move(mlir::emitc::FuncOp newFunc, IREE::VM::FuncOp oldFunc) {
auto &analysis = lookupFunction(oldFunc.getOperation());
functions[newFunc.getOperation()] = std::move(analysis);
@@ -125,12 +194,12 @@
Value lookupRef(Value ref) {
auto refValue = cast<TypedValue<IREE::VM::RefType>>(ref);
- mlir::func::FuncOp funcOp;
+ mlir::emitc::FuncOp funcOp;
if (auto definingOp = ref.getDefiningOp()) {
- funcOp = definingOp->getParentOfType<mlir::func::FuncOp>();
+ funcOp = definingOp->getParentOfType<mlir::emitc::FuncOp>();
} else {
Operation *op = llvm::cast<BlockArgument>(ref).getOwner()->getParentOp();
- funcOp = cast<mlir::func::FuncOp>(op);
+ funcOp = cast<mlir::emitc::FuncOp>(op);
}
auto &analysis = lookupFunction(funcOp);
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops.mlir
index 48dd304..3f0bdda 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_add_i32
+// CHECK-LABEL: emitc.func private @my_module_add_i32
vm.module @my_module {
vm.func @add_i32(%arg0: i32, %arg1: i32) {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_add_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_sub_i32
+// CHECK-LABEL: emitc.func private @my_module_sub_i32
vm.module @my_module {
vm.func @sub_i32(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_sub_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -22,7 +22,7 @@
// -----
-// CHECK-LABEL: @my_module_mul_i32
+// CHECK-LABEL: emitc.func private @my_module_mul_i32
vm.module @my_module {
vm.func @mul_i32(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_mul_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -33,7 +33,7 @@
// -----
-// CHECK-LABEL: @my_module_div_i32_s
+// CHECK-LABEL: emitc.func private @my_module_div_i32_s
vm.module @my_module {
vm.func @div_i32_s(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_div_i32s"(%arg3, %arg4) : (i32, i32) -> i32
@@ -44,7 +44,7 @@
// -----
-// CHECK-LABEL: @my_module_div_i32_u
+// CHECK-LABEL: emitc.func private @my_module_div_i32_u
vm.module @my_module {
vm.func @div_i32_u(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_div_i32u"(%arg3, %arg4) : (i32, i32) -> i32
@@ -55,7 +55,7 @@
// -----
-// CHECK-LABEL: @my_module_rem_i32_s
+// CHECK-LABEL: emitc.func private @my_module_rem_i32_s
vm.module @my_module {
vm.func @rem_i32_s(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_rem_i32s"(%arg3, %arg4) : (i32, i32) -> i32
@@ -66,7 +66,7 @@
// -----
-// CHECK-LABEL: @my_module_rem_i32_u
+// CHECK-LABEL: emitc.func private @my_module_rem_i32_u
vm.module @my_module {
vm.func @rem_i32_u(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_rem_i32u"(%arg3, %arg4) : (i32, i32) -> i32
@@ -77,7 +77,7 @@
// -----
-// CHECK-LABEL: @my_module_fma_i32
+// CHECK-LABEL: emitc.func private @my_module_fma_i32
vm.module @my_module {
vm.func @fma_i32(%arg0: i32, %arg1: i32, %arg2: i32) {
// CHECK: %0 = emitc.call_opaque "vm_fma_i32"(%arg3, %arg4, %arg5) : (i32, i32, i32) -> i32
@@ -88,7 +88,7 @@
// -----
-// CHECK-LABEL: @my_module_abs_i32
+// CHECK-LABEL: emitc.func private @my_module_abs_i32
vm.module @my_module {
vm.func @abs_i32(%arg0 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_abs_i32"(%arg3) : (i32) -> i32
@@ -99,7 +99,7 @@
// -----
-// CHECK-LABEL: @my_module_min_i32_s
+// CHECK-LABEL: emitc.func private @my_module_min_i32_s
vm.module @my_module {
vm.func @min_i32_s(%arg0: i32, %arg1: i32) {
// CHECK: %0 = emitc.call_opaque "vm_min_i32s"(%arg3, %arg4) : (i32, i32) -> i32
@@ -110,7 +110,7 @@
// -----
-// CHECK-LABEL: @my_module_not_i32
+// CHECK-LABEL: emitc.func private @my_module_not_i32
vm.module @my_module {
vm.func @not_i32(%arg0 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_not_i32"(%arg3) : (i32) -> i32
@@ -121,7 +121,7 @@
// -----
-// CHECK-LABEL: @my_module_and_i32
+// CHECK-LABEL: emitc.func private @my_module_and_i32
vm.module @my_module {
vm.func @and_i32(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_and_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -132,7 +132,7 @@
// -----
-// CHECK-LABEL: @my_module_or_i32
+// CHECK-LABEL: emitc.func private @my_module_or_i32
vm.module @my_module {
vm.func @or_i32(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_or_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -143,7 +143,7 @@
// -----
-// CHECK-LABEL: @my_module_xor_i32
+// CHECK-LABEL: emitc.func private @my_module_xor_i32
vm.module @my_module {
vm.func @xor_i32(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_xor_i32"(%arg3, %arg4) : (i32, i32) -> i32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_f32.mlir
index 9518a2b..ce95840 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_f32.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_add_f32
+// CHECK-LABEL: emitc.func private @my_module_add_f32
vm.module @my_module {
vm.func @add_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_add_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_sub_f32
+// CHECK-LABEL: emitc.func private @my_module_sub_f32
vm.module @my_module {
vm.func @sub_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_sub_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -22,7 +22,7 @@
// -----
-// CHECK-LABEL: @my_module_mul_f32
+// CHECK-LABEL: emitc.func private @my_module_mul_f32
vm.module @my_module {
vm.func @mul_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_mul_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -33,7 +33,7 @@
// -----
-// CHECK-LABEL: @my_module_div_f32
+// CHECK-LABEL: emitc.func private @my_module_div_f32
vm.module @my_module {
vm.func @div_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_div_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -44,7 +44,7 @@
// -----
-// CHECK-LABEL: @my_module_rem_f32
+// CHECK-LABEL: emitc.func private @my_module_rem_f32
vm.module @my_module {
vm.func @rem_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_rem_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -55,7 +55,7 @@
// -----
-// CHECK-LABEL: @my_module_fma_f32
+// CHECK-LABEL: emitc.func private @my_module_fma_f32
vm.module @my_module {
vm.func @fma_f32(%arg0: f32, %arg1: f32, %arg2: f32) {
// CHECK: %0 = emitc.call_opaque "vm_fma_f32"(%arg3, %arg4, %arg5) : (f32, f32, f32) -> f32
@@ -66,7 +66,7 @@
// -----
-// CHECK-LABEL: @my_module_abs_f32
+// CHECK-LABEL: emitc.func private @my_module_abs_f32
vm.module @my_module {
vm.func @abs_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_abs_f32"(%arg3) : (f32) -> f32
@@ -77,7 +77,7 @@
// -----
-// CHECK-LABEL: @my_module_neg_f32
+// CHECK-LABEL: emitc.func private @my_module_neg_f32
vm.module @my_module {
vm.func @neg_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_neg_f32"(%arg3) : (f32) -> f32
@@ -88,7 +88,7 @@
// -----
-// CHECK-LABEL: @my_module_ceil_f32
+// CHECK-LABEL: emitc.func private @my_module_ceil_f32
vm.module @my_module {
vm.func @ceil_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_ceil_f32"(%arg3) : (f32) -> f32
@@ -99,7 +99,7 @@
// -----
-// CHECK-LABEL: @my_module_floor_f32
+// CHECK-LABEL: emitc.func private @my_module_floor_f32
vm.module @my_module {
vm.func @floor_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_floor_f32"(%arg3) : (f32) -> f32
@@ -110,7 +110,7 @@
// -----
-// CHECK-LABEL: @my_module_min_f32
+// CHECK-LABEL: emitc.func private @my_module_min_f32
vm.module @my_module {
vm.func @min_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_min_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -121,7 +121,7 @@
// -----
-// CHECK-LABEL: @my_module_max_f32
+// CHECK-LABEL: emitc.func private @my_module_max_f32
vm.module @my_module {
vm.func @max_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_max_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -132,7 +132,7 @@
// -----
-// CHECK-LABEL: @my_module_atan_f32
+// CHECK-LABEL: emitc.func private @my_module_atan_f32
vm.module @my_module {
vm.func @atan_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_atan_f32"(%arg3) : (f32) -> f32
@@ -143,7 +143,7 @@
// -----
-// CHECK-LABEL: @my_module_atan2_f32
+// CHECK-LABEL: emitc.func private @my_module_atan2_f32
vm.module @my_module {
vm.func @atan2_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_atan2_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -154,7 +154,7 @@
// -----
-// CHECK-LABEL: @my_module_cos_f32
+// CHECK-LABEL: emitc.func private @my_module_cos_f32
vm.module @my_module {
vm.func @cos_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cos_f32"(%arg3) : (f32) -> f32
@@ -165,7 +165,7 @@
// -----
-// CHECK-LABEL: @my_module_sin_f32
+// CHECK-LABEL: emitc.func private @my_module_sin_f32
vm.module @my_module {
vm.func @sin_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_sin_f32"(%arg3) : (f32) -> f32
@@ -176,7 +176,7 @@
// -----
-// CHECK-LABEL: @my_module_exp_f32
+// CHECK-LABEL: emitc.func private @my_module_exp_f32
vm.module @my_module {
vm.func @exp_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_exp_f32"(%arg3) : (f32) -> f32
@@ -187,7 +187,7 @@
// -----
-// CHECK-LABEL: @my_module_exp2_f32
+// CHECK-LABEL: emitc.func private @my_module_exp2_f32
vm.module @my_module {
vm.func @exp2_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_exp2_f32"(%arg3) : (f32) -> f32
@@ -198,7 +198,7 @@
// -----
-// CHECK-LABEL: @my_module_expm1_f32
+// CHECK-LABEL: emitc.func private @my_module_expm1_f32
vm.module @my_module {
vm.func @expm1_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_expm1_f32"(%arg3) : (f32) -> f32
@@ -209,7 +209,7 @@
// -----
-// CHECK-LABEL: @my_module_log_f32
+// CHECK-LABEL: emitc.func private @my_module_log_f32
vm.module @my_module {
vm.func @log_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_log_f32"(%arg3) : (f32) -> f32
@@ -220,7 +220,7 @@
// -----
-// CHECK-LABEL: @my_module_log10_f32
+// CHECK-LABEL: emitc.func private @my_module_log10_f32
vm.module @my_module {
vm.func @log10_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_log10_f32"(%arg3) : (f32) -> f32
@@ -231,7 +231,7 @@
// -----
-// CHECK-LABEL: @my_module_log1p_f32
+// CHECK-LABEL: emitc.func private @my_module_log1p_f32
vm.module @my_module {
vm.func @log1p_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_log1p_f32"(%arg3) : (f32) -> f32
@@ -242,7 +242,7 @@
// -----
-// CHECK-LABEL: @my_module_log2_f32
+// CHECK-LABEL: emitc.func private @my_module_log2_f32
vm.module @my_module {
vm.func @log2_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_log2_f32"(%arg3) : (f32) -> f32
@@ -253,7 +253,7 @@
// -----
-// CHECK-LABEL: @my_module_pow_f32
+// CHECK-LABEL: emitc.func private @my_module_pow_f32
vm.module @my_module {
vm.func @pow_f32(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_pow_f32"(%arg3, %arg4) : (f32, f32) -> f32
@@ -264,7 +264,7 @@
// -----
-// CHECK-LABEL: @my_module_rsqrt_f32
+// CHECK-LABEL: emitc.func private @my_module_rsqrt_f32
vm.module @my_module {
vm.func @rsqrt_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_rsqrt_f32"(%arg3) : (f32) -> f32
@@ -275,7 +275,7 @@
// -----
-// CHECK-LABEL: @my_module_sqrt_f32
+// CHECK-LABEL: emitc.func private @my_module_sqrt_f32
vm.module @my_module {
vm.func @sqrt_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_sqrt_f32"(%arg3) : (f32) -> f32
@@ -286,7 +286,7 @@
// -----
-// CHECK-LABEL: @my_module_tanh_f32
+// CHECK-LABEL: emitc.func private @my_module_tanh_f32
vm.module @my_module {
vm.func @tanh_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_tanh_f32"(%arg3) : (f32) -> f32
@@ -297,7 +297,7 @@
// -----
-// CHECK-LABEL: @my_module_erf_f32
+// CHECK-LABEL: emitc.func private @my_module_erf_f32
vm.module @my_module {
vm.func @erf_f32(%arg0 : f32) -> f32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_erf_f32"(%arg3) : (f32) -> f32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_i64.mlir
index 63f6546..a5bb597 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/arithmetic_ops_i64.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_add_i64
+// CHECK-LABEL: emitc.func private @my_module_add_i64
vm.module @my_module {
vm.func @add_i64(%arg0: i64, %arg1: i64) {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_add_i64"(%arg3, %arg4) : (i64, i64) -> i64
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_sub_i64
+// CHECK-LABEL: emitc.func private @my_module_sub_i64
vm.module @my_module {
vm.func @sub_i64(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_sub_i64"(%arg3, %arg4) : (i64, i64) -> i64
@@ -22,7 +22,7 @@
// -----
-// CHECK-LABEL: @my_module_mul_i64
+// CHECK-LABEL: emitc.func private @my_module_mul_i64
vm.module @my_module {
vm.func @mul_i64(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_mul_i64"(%arg3, %arg4) : (i64, i64) -> i64
@@ -33,7 +33,7 @@
// -----
-// CHECK-LABEL: @my_module_div_i64_s
+// CHECK-LABEL: emitc.func private @my_module_div_i64_s
vm.module @my_module {
vm.func @div_i64_s(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_div_i64s"(%arg3, %arg4) : (i64, i64) -> i64
@@ -44,7 +44,7 @@
// -----
-// CHECK-LABEL: @my_module_div_i64_u
+// CHECK-LABEL: emitc.func private @my_module_div_i64_u
vm.module @my_module {
vm.func @div_i64_u(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_div_i64u"(%arg3, %arg4) : (i64, i64) -> i64
@@ -55,7 +55,7 @@
// -----
-// CHECK-LABEL: @my_module_rem_i64_s
+// CHECK-LABEL: emitc.func private @my_module_rem_i64_s
vm.module @my_module {
vm.func @rem_i64_s(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_rem_i64s"(%arg3, %arg4) : (i64, i64) -> i64
@@ -66,7 +66,7 @@
// -----
-// CHECK-LABEL: @my_module_rem_i64_u
+// CHECK-LABEL: emitc.func private @my_module_rem_i64_u
vm.module @my_module {
vm.func @rem_i64_u(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_rem_i64u"(%arg3, %arg4) : (i64, i64) -> i64
@@ -77,7 +77,7 @@
// -----
-// CHECK-LABEL: @my_module_fma_i64
+// CHECK-LABEL: emitc.func private @my_module_fma_i64
vm.module @my_module {
vm.func @fma_i64(%arg0: i64, %arg1: i64, %arg2: i64) {
// CHECK: %0 = emitc.call_opaque "vm_fma_i64"(%arg3, %arg4, %arg5) : (i64, i64, i64) -> i64
@@ -88,7 +88,7 @@
// -----
-// CHECK-LABEL: @my_module_abs_i64
+// CHECK-LABEL: emitc.func private @my_module_abs_i64
vm.module @my_module {
vm.func @abs_i64(%arg0 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_abs_i64"(%arg3) : (i64) -> i64
@@ -99,7 +99,7 @@
// -----
-// CHECK-LABEL: @my_module_min_i64_s
+// CHECK-LABEL: emitc.func private @my_module_min_i64_s
vm.module @my_module {
vm.func @min_i64_s(%arg0: i64, %arg1: i64) {
// CHECK: %0 = emitc.call_opaque "vm_min_i64s"(%arg3, %arg4) : (i64, i64) -> i64
@@ -110,7 +110,7 @@
// -----
-// CHECK-LABEL: @my_module_not_i64
+// CHECK-LABEL: emitc.func private @my_module_not_i64
vm.module @my_module {
vm.func @not_i64(%arg0 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_not_i64"(%arg3) : (i64) -> i64
@@ -121,7 +121,7 @@
// -----
-// CHECK-LABEL: @my_module_and_i64
+// CHECK-LABEL: emitc.func private @my_module_and_i64
vm.module @my_module {
vm.func @and_i64(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_and_i64"(%arg3, %arg4) : (i64, i64) -> i64
@@ -132,7 +132,7 @@
// -----
-// CHECK-LABEL: @my_module_or_i64
+// CHECK-LABEL: emitc.func private @my_module_or_i64
vm.module @my_module {
vm.func @or_i64(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_or_i64"(%arg3, %arg4) : (i64, i64) -> i64
@@ -143,7 +143,7 @@
// -----
-// CHECK-LABEL: @my_module_xor_i64
+// CHECK-LABEL: emitc.func private @my_module_xor_i64
vm.module @my_module {
vm.func @xor_i64(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_xor_i64"(%arg3, %arg4) : (i64, i64) -> i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops.mlir
index 32ce78c..2dc2274 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_select_i32
+// CHECK-LABEL: emitc.func private @my_module_select_i32
vm.module @my_module {
vm.func @select_i32(%arg0 : i32, %arg1 : i32, %arg2 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_select_i32"(%arg3, %arg4, %arg5) : (i32, i32, i32) -> i32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_f32.mlir
index 4d279e6..4c63698 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_f32.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_select_f32
+// CHECK-LABEL: emitc.func private @my_module_select_f32
vm.module @my_module {
vm.func @select_f32(%arg0 : i32, %arg1 : f32, %arg2 : f32) -> f32 {
// CHECK: %0 = emitc.call_opaque "vm_select_f32"(%arg3, %arg4, %arg5) : (i32, f32, f32) -> f32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_i64.mlir
index ba1a5db..a1afb27 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/assignment_ops_i64.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_select_i64
+// CHECK-LABEL: emitc.func private @my_module_select_i64
vm.module @my_module {
vm.func @select_i64(%arg0 : i32, %arg1 : i64, %arg2 : i64) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_select_i64"(%arg3, %arg4, %arg5) : (i32, i64, i64) -> i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops.mlir
index 0517fe0..33a7db8 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops.mlir
@@ -1,13 +1,13 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_buffer_alloc
+// CHECK-LABEL: emitc.func private @my_module_buffer_alloc
vm.module @my_module {
vm.func @buffer_alloc() {
// CHECK: %[[SIZE:.+]] = "emitc.constant"() <{value = 128 : i64}> : () -> i64
// CHECK-DAG: %[[ALIGNMENT:.+]] = "emitc.constant"() <{value = 32 : i32}> : () -> i32
// CHECK-DAG: %[[BUFFER:.+]] = "emitc.variable"() <{value = #emitc.opaque<"NULL">}> : () -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK-DAG: %[[BUFFER_PTR:.+]] = emitc.apply "&"(%[[BUFFER]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>) -> !emitc.ptr<!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>>
- // CHECK-DAG: %[[ALLOCTOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
+ // CHECK-DAG: %[[ALLOCTOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
// CHECK-DAG: %[[BUFFER_ACCESS:.+]] = "emitc.constant"() <{value = #emitc.opaque<"IREE_VM_BUFFER_ACCESS_MUTABLE | IREE_VM_BUFFER_ACCESS_ORIGIN_GUEST">}> : () -> !emitc.opaque<"iree_vm_buffer_access_t">
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "iree_vm_buffer_create"(%[[BUFFER_ACCESS]], %[[SIZE]], %[[ALIGNMENT]], %[[ALLOCTOR]], %[[BUFFER_PTR]]) : (!emitc.opaque<"iree_vm_buffer_access_t">, i64, i32, !emitc.opaque<"iree_allocator_t">, !emitc.ptr<!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>>) -> !emitc.opaque<"iree_status_t">
@@ -23,7 +23,7 @@
// -----
-// CHECK-LABEL: @my_module_buffer_clone
+// CHECK-LABEL: emitc.func private @my_module_buffer_clone
vm.module @my_module {
vm.func @buffer_clone(%buf : !vm.buffer) {
// CHECK-DAG: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -32,7 +32,7 @@
// CHECK: %[[BUFFER:.+]] = "emitc.variable"() <{value = #emitc.opaque<"NULL">}> : () -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK-DAG: %[[BUFFER_PTR:.+]] = emitc.apply "&"(%[[BUFFER]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>) -> !emitc.ptr<!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>>
- // CHECK-DAG: %[[ALLOCATOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
+ // CHECK-DAG: %[[ALLOCATOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
// CHECK-DAG: %[[BUFFER_ACCESS:.+]] = "emitc.constant"() <{value = #emitc.opaque<"IREE_VM_BUFFER_ACCESS_MUTABLE | IREE_VM_BUFFER_ACCESS_ORIGIN_GUEST">}> : () -> !emitc.opaque<"iree_vm_buffer_access_t">
// CHECK-DAG: %[[BUFFER_REF2:.+]] = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-DAG: %[[BUFFER_PTR2:.+]] = emitc.call_opaque "iree_vm_buffer_deref"(%[[BUFFER_REF2]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
@@ -48,7 +48,7 @@
// -----
-// CHECK-LABEL: @my_module_buffer_length
+// CHECK-LABEL: emitc.func private @my_module_buffer_length
vm.module @my_module {
vm.func @buffer_length(%buf : !vm.buffer) {
// CHECK: %[[BUFFER_REF:.+]] = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
@@ -63,7 +63,7 @@
// -----
-// CHECK-LABEL: @my_module_buffer_compare
+// CHECK-LABEL: emitc.func private @my_module_buffer_compare
vm.module @my_module {
vm.func @buffer_compare(%buf : !vm.buffer, %buf2 : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -87,7 +87,7 @@
// -----
-// CHECK-LABEL: @my_module_buffer_copy
+// CHECK-LABEL: emitc.func private @my_module_buffer_copy
vm.module @my_module {
vm.func @buffer_copy(%buf : !vm.buffer, %buf2 : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -110,7 +110,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_fill_i8
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_i8
vm.func @buffer_fill_i8(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C16:.+]] = "emitc.constant"() <{value = 16 : i64}> : () -> i64
@@ -127,7 +127,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_fill_i16
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_i16
vm.func @buffer_fill_i16(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_fill_i16"
%c0 = vm.const.i64 0
@@ -137,7 +137,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_fill_i32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_i32
vm.func @buffer_fill_i32(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_fill_i32"
%c0 = vm.const.i64 0
@@ -151,7 +151,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_load_i8s
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i8s
vm.func @buffer_load_i8s(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -159,7 +159,7 @@
// CHECK-NEXT: %[[BUFFER_PTR:.+]] = emitc.call_opaque "iree_vm_buffer_deref"(%[[BUFFER_REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK: %[[RESULT:.+]] = "emitc.variable"() <{value = 0 : i32}> : () -> i32
- // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%6) : (i32) -> !emitc.ptr<i32>
+ // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i8s"(%[[BUFFER_PTR]], %[[C0]], %[[RESULT_PTR]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>, i64, !emitc.ptr<i32>) -> !emitc.opaque<"iree_status_t">
%c0 = vm.const.i64 0
@@ -167,7 +167,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_load_i8u
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i8u
vm.func @buffer_load_i8u(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i8u"
%c0 = vm.const.i64 0
@@ -175,7 +175,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_load_i16s
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i16s
vm.func @buffer_load_i16s(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i16s"
%c0 = vm.const.i64 0
@@ -183,7 +183,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_load_i16u
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i16u
vm.func @buffer_load_i16u(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i16u"
%c0 = vm.const.i64 0
@@ -191,7 +191,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_load_i32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i32
vm.func @buffer_load_i32(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i32"
%c0 = vm.const.i64 0
@@ -203,7 +203,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_store_i8
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_i8
vm.func @buffer_store_i8(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C102:.+]] = "emitc.constant"() <{value = 102 : i32}> : () -> i32
@@ -218,7 +218,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_store_i16
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_i16
vm.func @buffer_store_i16(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_store_i16"
%c0 = vm.const.i64 0
@@ -227,7 +227,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_buffer_store_i32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_i32
vm.func @buffer_store_i32(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_store_i32"
%c0 = vm.const.i64 0
@@ -240,7 +240,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_hash
+ // CHECK-LABEL: emitc.func private @my_module_buffer_hash
vm.func @buffer_hash(%buf : !vm.buffer) {
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "iree_vm_buffer_hash"
%c0 = vm.const.i64 0
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f32.mlir
index 1ada44e..4b598ac 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f32.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_fill_f32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_f32
vm.func @buffer_fill_f32(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C16:.+]] = "emitc.constant"() <{value = 16 : i64}> : () -> i64
@@ -22,7 +22,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_load_f32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_f32
vm.func @buffer_load_f32(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -30,7 +30,7 @@
// CHECK-NEXT: %[[BUFFER_PTR:.+]] = emitc.call_opaque "iree_vm_buffer_deref"(%[[BUFFER_REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK: %[[RESULT:.+]] = "emitc.variable"() <{value = 0.000000e+00 : f32}> : () -> f32
- // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%6) : (f32) -> !emitc.ptr<f32>
+ // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (f32) -> !emitc.ptr<f32>
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_f32"(%[[BUFFER_PTR]], %[[C0]], %[[RESULT_PTR]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>, i64, !emitc.ptr<f32>) -> !emitc.opaque<"iree_status_t">
%c0 = vm.const.i64 0
@@ -42,7 +42,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_store_f32
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_f32
vm.func @buffer_store_f32(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C102:.+]] = "emitc.constant"() <{value = 1.020000e+02 : f32}> : () -> f32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f64.mlir
index 697cc66..2184c8c 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_f64.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_fill_f64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_f64
vm.func @buffer_fill_f64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C16:.+]] = "emitc.constant"() <{value = 16 : i64}> : () -> i64
@@ -22,7 +22,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_load_f64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_f64
vm.func @buffer_load_f64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -30,7 +30,7 @@
// CHECK-NEXT: %[[BUFFER_PTR:.+]] = emitc.call_opaque "iree_vm_buffer_deref"(%[[BUFFER_REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK: %[[RESULT:.+]] = "emitc.variable"() <{value = 0.000000e+00 : f64}> : () -> f64
- // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%6) : (f64) -> !emitc.ptr<f64>
+ // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (f64) -> !emitc.ptr<f64>
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_f64"(%[[BUFFER_PTR]], %[[C0]], %[[RESULT_PTR]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>, i64, !emitc.ptr<f64>) -> !emitc.opaque<"iree_status_t">
%c0 = vm.const.i64 0
@@ -42,7 +42,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_store_f64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_f64
vm.func @buffer_store_f64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C102:.+]] = "emitc.constant"() <{value = 1.020000e+02 : f64}> : () -> f64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_i64.mlir
index 431dced..394f414 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/buffer_ops_i64.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_fill_i64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_fill_i64
vm.func @buffer_fill_i64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C16:.+]] = "emitc.constant"() <{value = 16 : i64}> : () -> i64
@@ -22,7 +22,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_load_i64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_load_i64
vm.func @buffer_load_i64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
@@ -30,7 +30,7 @@
// CHECK-NEXT: %[[BUFFER_PTR:.+]] = emitc.call_opaque "iree_vm_buffer_deref"(%[[BUFFER_REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>
// CHECK: %[[RESULT:.+]] = "emitc.variable"() <{value = 0 : i64}> : () -> i64
- // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%6) : (i64) -> !emitc.ptr<i64>
+ // CHECK-NEXT: %[[RESULT_PTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i64) -> !emitc.ptr<i64>
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "vm_buffer_load_i64"(%[[BUFFER_PTR]], %[[C0]], %[[RESULT_PTR]]) : (!emitc.ptr<!emitc.opaque<"iree_vm_buffer_t">>, i64, !emitc.ptr<i64>) -> !emitc.opaque<"iree_status_t">
%c0 = vm.const.i64 0
@@ -42,7 +42,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_buffer_store_i64
+ // CHECK-LABEL: emitc.func private @my_module_buffer_store_i64
vm.func @buffer_store_i64(%buf : !vm.buffer) {
// CHECK: %[[C0:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
// CHECK: %[[C102:.+]] = "emitc.constant"() <{value = 102 : i64}> : () -> i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops.mlir
index 244c37e..31c5ece 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @module {
- // CHECK-LABEL: @module_cmp_eq_i32
+ // CHECK-LABEL: emitc.func private @module_cmp_eq_i32
vm.func @cmp_eq_i32(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_eq_i32"(%arg3, %arg4) : (i32, i32) -> i32
%0 = vm.cmp.eq.i32 %arg0, %arg1 : i32
@@ -12,7 +12,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_ne_i32
+ // CHECK-LABEL: emitc.func private @module_cmp_ne_i32
vm.func @cmp_ne_i32(%arg0 : i32, %arg1 : i32) {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_ne_i32"(%arg3, %arg4) : (i32, i32) -> i32
%0 = vm.cmp.ne.i32 %arg0, %arg1 : i32
@@ -23,7 +23,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_i32_s
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_i32_s
vm.func @cmp_lt_i32_s(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_i32s"(%arg3, %arg4) : (i32, i32) -> i32
%0 = vm.cmp.lt.i32.s %arg0, %arg1 : i32
@@ -34,7 +34,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_i32_u
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_i32_u
vm.func @cmp_lt_i32_u(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_i32u"(%arg3, %arg4) : (i32, i32) -> i32
%0 = vm.cmp.lt.i32.u %arg0, %arg1 : i32
@@ -45,7 +45,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_nz_i32
+ // CHECK-LABEL: emitc.func private @module_cmp_nz_i32
vm.func @cmp_nz_i32(%arg0 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_nz_i32"(%arg3) : (i32) -> i32
%0 = vm.cmp.nz.i32 %arg0 : i32
@@ -56,7 +56,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_eq_ref
+ // CHECK-LABEL: emitc.func private @module_cmp_eq_ref
vm.func @cmp_eq_ref(%arg0 : !vm.ref<?>, %arg1 : !vm.ref<?>) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_eq_ref"(%arg3, %arg4) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> i32
%0 = vm.cmp.eq.ref %arg0, %arg1 : !vm.ref<?>
@@ -67,7 +67,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_ne_ref
+ // CHECK-LABEL: emitc.func private @module_cmp_ne_ref
vm.func @cmp_ne_ref(%arg0 : !vm.ref<?>, %arg1 : !vm.ref<?>) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_ne_ref"(%arg3, %arg4) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> i32
%0 = vm.cmp.ne.ref %arg0, %arg1 : !vm.ref<?>
@@ -78,7 +78,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_nz_ref
+ // CHECK-LABEL: emitc.func private @module_cmp_nz_ref
vm.func @cmp_nz_ref(%arg0 : !vm.ref<?>) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_nz_ref"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> i32
%0 = vm.cmp.nz.ref %arg0 : !vm.ref<?>
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_f32.mlir
index 2755935..825fe8b 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_f32.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @module {
- // CHECK-LABEL: @module_cmp_eq_f32o
+ // CHECK-LABEL: emitc.func private @module_cmp_eq_f32o
vm.func @cmp_eq_f32o(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_eq_f32o"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.eq.f32.o %arg0, %arg1 : f32
@@ -12,7 +12,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_eq_f32u
+ // CHECK-LABEL: emitc.func private @module_cmp_eq_f32u
vm.func @cmp_eq_f32u(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_eq_f32u"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.eq.f32.u %arg0, %arg1 : f32
@@ -23,7 +23,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_ne_f32o
+ // CHECK-LABEL: emitc.func private @module_cmp_ne_f32o
vm.func @cmp_ne_f32o(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_ne_f32o"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.ne.f32.o %arg0, %arg1 : f32
@@ -34,7 +34,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_ne_f32u
+ // CHECK-LABEL: emitc.func private @module_cmp_ne_f32u
vm.func @cmp_ne_f32u(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_ne_f32u"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.ne.f32.u %arg0, %arg1 : f32
@@ -45,7 +45,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_f32o
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_f32o
vm.func @cmp_lt_f32o(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_f32o"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.lt.f32.o %arg0, %arg1 : f32
@@ -56,7 +56,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_f32u
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_f32u
vm.func @cmp_lt_f32u(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_f32u"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.lt.f32.u %arg0, %arg1 : f32
@@ -67,7 +67,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lte_f32o
+ // CHECK-LABEL: emitc.func private @module_cmp_lte_f32o
vm.func @cmp_lte_f32o(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lte_f32o"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.lte.f32.o %arg0, %arg1 : f32
@@ -78,7 +78,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lte_f32u
+ // CHECK-LABEL: emitc.func private @module_cmp_lte_f32u
vm.func @cmp_lte_f32u(%arg0 : f32, %arg1 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lte_f32u"(%arg3, %arg4) : (f32, f32) -> i32
%0 = vm.cmp.lte.f32.u %arg0, %arg1 : f32
@@ -89,7 +89,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_nan_f32
+ // CHECK-LABEL: emitc.func private @module_cmp_nan_f32
vm.func @cmp_nan_f32(%arg0 : f32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_nan_f32"(%arg3) : (f32) -> i32
%0 = vm.cmp.nan.f32 %arg0 : f32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_i64.mlir
index 357efcb..dcf6ee3 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/comparison_ops_i64.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @module {
- // CHECK-LABEL: @module_cmp_eq_i64
+ // CHECK-LABEL: emitc.func private @module_cmp_eq_i64
vm.func @cmp_eq_i64(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_eq_i64"(%arg3, %arg4) : (i64, i64) -> i32
%0 = vm.cmp.eq.i64 %arg0, %arg1 : i64
@@ -12,7 +12,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_ne_i64
+ // CHECK-LABEL: emitc.func private @module_cmp_ne_i64
vm.func @cmp_ne_i64(%arg0 : i64, %arg1 : i64) {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_ne_i64"(%arg3, %arg4) : (i64, i64) -> i32
%0 = vm.cmp.ne.i64 %arg0, %arg1 : i64
@@ -23,7 +23,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_i64_s
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_i64_s
vm.func @cmp_lt_i64_s(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_i64s"(%arg3, %arg4) : (i64, i64) -> i32
%0 = vm.cmp.lt.i64.s %arg0, %arg1 : i64
@@ -34,7 +34,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_lt_i64_u
+ // CHECK-LABEL: emitc.func private @module_cmp_lt_i64_u
vm.func @cmp_lt_i64_u(%arg0 : i64, %arg1 : i64) -> i64 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_lt_i64u"(%arg3, %arg4) : (i64, i64) -> i32
%0 = vm.cmp.lt.i64.u %arg0, %arg1 : i64
@@ -45,7 +45,7 @@
// -----
vm.module @module {
- // CHECK-LABEL: @module_cmp_nz_i64
+ // CHECK-LABEL: emitc.func private @module_cmp_nz_i64
vm.func @cmp_nz_i64(%arg0 : i64) -> i64 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cmp_nz_i64"(%arg3) : (i64) -> i32
%0 = vm.cmp.nz.i64 %arg0 : i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops.mlir
index 0a28e03..eaf8656 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops.mlir
@@ -2,7 +2,7 @@
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_i32_zero
+ // CHECK-LABEL: emitc.func private @my_module_const_i32_zero
vm.func @const_i32_zero() -> i32 {
// CHECK: %[[ZERO:.+]] = "emitc.constant"() <{value = 0 : i32}> : () -> i32
%zero = vm.const.i32.zero
@@ -13,7 +13,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_i32
+ // CHECK-LABEL: emitc.func private @my_module_const_i32
vm.func @const_i32() {
// CHECK-NEXT: %0 = "emitc.constant"() <{value = 0 : i32}> : () -> i32
%0 = vm.const.i32 0
@@ -28,7 +28,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_ref_zero
+ // CHECK-LABEL: emitc.func private @my_module_const_ref_zero
vm.func @const_ref_zero() {
// CHECK: %[[REF:.+]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %[[REFPTR:.+]] = emitc.apply "&"(%[[REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_f32.mlir
index 8dcd455..7622fd1 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_f32.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_f32_zero
+ // CHECK-LABEL: emitc.func private @my_module_const_f32_zero
vm.func @const_f32_zero() -> f32 {
// CHECK: %[[ZERO:.+]] = "emitc.constant"() <{value = 0.000000e+00 : f32}> : () -> f32
%zero = vm.const.f32.zero
@@ -12,7 +12,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_f32
+ // CHECK-LABEL: emitc.func private @my_module_const_f32
vm.func @const_f32() {
// CHECK-NEXT: %0 = "emitc.constant"() <{value = 5.000000e-01 : f32}> : () -> f32
%0 = vm.const.f32 0.5
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_i64.mlir
index 5b4ede3..f0c689b 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/const_ops_i64.mlir
@@ -2,7 +2,7 @@
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_i64_zero
+ // CHECK-LABEL: emitc.func private @my_module_const_i64_zero
vm.func @const_i64_zero() -> i64 {
// CHECK: %[[ZERO:.+]] = "emitc.constant"() <{value = 0 : i64}> : () -> i64
%zero = vm.const.i64.zero
@@ -13,7 +13,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_const_i64
+ // CHECK-LABEL: emitc.func private @my_module_const_i64
vm.func @const_i64() {
// CHECK-NEXT: %0 = "emitc.constant"() <{value = 0 : i64}> : () -> i64
%0 = vm.const.i64 0
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/control_flow_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/control_flow_ops.mlir
index fb58ef9..2f4b938 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/control_flow_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/control_flow_ops.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_branch_empty
+ // CHECK-LABEL: emitc.func private @my_module_branch_empty
vm.func @branch_empty() {
// CHECK: cf.br ^bb1
vm.br ^bb1
@@ -15,7 +15,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_branch_int_args
+ // CHECK-LABEL: emitc.func private @my_module_branch_int_args
vm.func @branch_int_args(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: cf.br ^bb1(%arg3, %arg4 : i32, i32)
vm.br ^bb1(%arg0, %arg1 : i32, i32)
@@ -29,7 +29,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_branch_ref_args
+ // CHECK-LABEL: emitc.func private @my_module_branch_ref_args
vm.func @branch_ref_args(%arg0 : !vm.ref<?>) -> !vm.ref<?> {
// CHECK: cf.br ^bb1
// CHECK: cf.br ^bb2
@@ -44,7 +44,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_branch_mixed_args
+ // CHECK-LABEL: emitc.func private @my_module_branch_mixed_args
vm.func @branch_mixed_args(%arg0 : !vm.ref<?>, %arg1: i32, %arg2 : !vm.ref<?>, %arg3: i32) -> !vm.ref<?> {
// CHECK: cf.br ^bb1
// CHECK: cf.br ^bb2(%arg4, %arg6 : i32, i32)
@@ -60,15 +60,15 @@
// Test vm.call conversion on an imported function.
vm.module @my_module {
- // CHECK: func.func @my_module_call_[[IMPORTFN:[^\(]+]]
+ // CHECK: emitc.func private @my_module_call_[[IMPORTFN:[^\(]+]]
vm.import private @imported_fn(%arg0 : i32) -> i32
- // CHECK: func.func @my_module_call_imported_fn
+ // CHECK: emitc.func private @my_module_call_imported_fn
vm.func @call_imported_fn(%arg0 : i32) -> i32 {
// Lookup import from module struct.
// CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[IMPORT:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[IMPORTS]]) {args = [0 : index, 0 : ui32]}
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
@@ -77,7 +77,7 @@
// CHECK-NEXT: %[[RESPTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// Call the function created by the vm.import conversion.
- // CHECK-NEXT: %{{.+}} = call @my_module_call_[[IMPORTFN]](%arg0, %[[IMPORT]], %arg3, %[[RESPTR]])
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_call_[[IMPORTFN]](%arg0, %[[IMPORT]], %arg3, %[[RESPTR]])
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>, i32, !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
%0 = vm.call @imported_fn(%arg0) : (i32) -> i32
@@ -89,12 +89,12 @@
// Test that the order of imports and calls doesn't matter.
vm.module @my_module {
- // CHECK: func.func @my_module_call_imported_fn
+ // CHECK: emitc.func private @my_module_call_imported_fn
vm.func @call_imported_fn(%arg0 : i32) -> i32 {
// Lookup import from module struct.
// CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[IMPORT:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[IMPORTS]]) {args = [0 : index, 0 : ui32]}
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
@@ -103,14 +103,14 @@
// CHECK-NEXT: %[[RESPTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// Call the function created by the vm.import conversion.
- // CHECK-NEXT: %{{.+}} = call @my_module_call_[[IMPORTFN:[^\(]+]](%arg0, %[[IMPORT]], %arg3, %[[RESPTR]])
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_call_[[IMPORTFN:[^\(]+]](%arg0, %[[IMPORT]], %arg3, %[[RESPTR]])
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>, i32, !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
%0 = vm.call @imported_fn(%arg0) : (i32) -> i32
vm.return %0 : i32
}
- // CHECK: func.func @my_module_call_[[IMPORTFN]]
+ // CHECK: emitc.func private @my_module_call_[[IMPORTFN]]
vm.import private @imported_fn(%arg0 : i32) -> i32
}
@@ -122,7 +122,7 @@
vm.return %arg0 : i32
}
- // CHECK-LABEL: @my_module_call_internal_fn
+ // CHECK-LABEL: emitc.func private @my_module_call_internal_fn
vm.func @call_internal_fn(%arg0 : i32) -> i32 {
// Create a variable for the result.
@@ -130,9 +130,9 @@
// CHECK-NEXT: %[[RESPTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// Call the function created by the vm.import conversion.
- // CHECK-NEXT: %{{.+}} = call @my_module_internal_fn(%arg0, %arg1, %arg2, %arg3, %[[RESPTR]])
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"my_module_t">>,
- // CHECK-SAME: !emitc.ptr<!emitc.opaque<"my_module_state_t">>, i32, !emitc.ptr<i32>)
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_internal_fn(%arg0, %arg1, %arg2, %arg3, %[[RESPTR]])
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"struct my_module_t">>,
+ // CHECK-SAME: !emitc.ptr<!emitc.opaque<"struct my_module_state_t">>, i32, !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
%0 = vm.call @internal_fn(%arg0) : (i32) -> i32
vm.return %0 : i32
@@ -143,15 +143,15 @@
// Test vm.call.variadic conversion on an imported function.
vm.module @my_module {
- // CHECK: func.func @my_module_call_[[VARIADICFN:[^\(]+]]
+ // CHECK: emitc.func private @my_module_call_[[VARIADICFN:[^\(]+]]
vm.import private @variadic_fn(%arg0 : i32 ...) -> i32
- // CHECK: func.func @my_module_call_variadic
+ // CHECK: emitc.func private @my_module_call_variadic
vm.func @call_variadic(%arg0 : i32, %arg1 : i32) -> i32 {
// Lookup import from module struct.
// CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[IMPORT:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[IMPORTS]]) {args = [0 : index, 0 : ui32]}
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
@@ -163,7 +163,7 @@
// CHECK-NEXT: %[[RESPTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// Call the function created by the vm.import conversion.
- // CHECK-NEXT: %{{.+}} = call @my_module_call_[[VARIADICFN]](%arg0, %[[IMPORT]], %[[NARGS]], %arg3, %arg4, %[[RESPTR]])
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_call_[[VARIADICFN]](%arg0, %[[IMPORT]], %[[NARGS]], %arg3, %arg4, %[[RESPTR]])
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
// CHECK-SAME: i32, i32, i32, !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
@@ -176,15 +176,15 @@
// Test vm.call.variadic with zero arguments.
vm.module @my_module {
- // CHECK: func.func @my_module_call_[[VARIADICFN:[^\(]+]]
+ // CHECK: emitc.func private @my_module_call_[[VARIADICFN:[^\(]+]]
vm.import private @variadic_fn(%arg0 : i32 ...) -> i32
- // CHECK: func.func @my_module_call_variadic
+ // CHECK: emitc.func private @my_module_call_variadic
vm.func @call_variadic() -> i32 {
// Lookup import from module struct.
// CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[IMPORT:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[IMPORTS]]) {args = [0 : index, 0 : ui32]}
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
@@ -196,7 +196,7 @@
// CHECK-NEXT: %[[RESPTR:.+]] = emitc.apply "&"(%[[RESULT]]) : (i32) -> !emitc.ptr<i32>
// Call the function created by the vm.import conversion.
- // CHECK-NEXT: %{{.+}} = call @my_module_call_[[VARIADICFN]](%arg0, %[[IMPORT]], %[[NARGS]], %[[RESPTR]])
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_call_[[VARIADICFN]](%arg0, %[[IMPORT]], %[[NARGS]], %[[RESPTR]])
// CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
// CHECK-SAME: i32, !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
@@ -210,10 +210,10 @@
// TODO(simon-camp): add check statements
// Test vm.call.variadic with multiple variadic packs.
vm.module @my_module {
- // CHECK: func.func @my_module_call_[[VARIADICFN:[^\(]+]]
+ // CHECK: emitc.func private @my_module_call_[[VARIADICFN:[^\(]+]]
vm.import private @variadic_fn(%is : i32 ..., %fs : f32 ...) -> i32
- // CHECK: func.func @my_module_call_variadic
+ // CHECK: emitc.func private @my_module_call_variadic
vm.func @call_variadic(%i : i32, %f : f32) -> i32 {
%0 = vm.call.variadic @variadic_fn([%i, %i], [%f, %f, %f]) : (i32 ..., f32 ...) -> i32
@@ -224,7 +224,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_cond_branch_empty
+ // CHECK-LABEL: emitc.func private @my_module_cond_branch_empty
vm.func @cond_branch_empty(%arg0 : i32, %arg1 : i32, %arg2 : i32) -> i32 {
// CHECK: cf.cond_br %{{.}}, ^bb1, ^bb2
vm.cond_br %arg0, ^bb1, ^bb2
@@ -242,7 +242,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_cond_branch_int_args
+ // CHECK-LABEL: emitc.func private @my_module_cond_branch_int_args
vm.func @cond_branch_int_args(%arg0 : i32, %arg1 : i32, %arg2 : i32) -> i32 {
// CHECK: cf.cond_br {{%.}}, ^bb1(%arg4 : i32), ^bb2(%arg5 : i32)
vm.cond_br %arg0, ^bb1(%arg1 : i32), ^bb2(%arg2 : i32)
@@ -260,7 +260,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_cond_branch_ref_args
+ // CHECK-LABEL: emitc.func private @my_module_cond_branch_ref_args
vm.func @cond_branch_ref_args(%arg0 : i32, %arg1 : !vm.ref<?>, %arg2 : !vm.ref<?>) -> !vm.ref<?> {
// CHECK: cf.cond_br {{%.}}, ^bb1, ^bb4
// CHECK: cf.br ^bb2
@@ -279,7 +279,7 @@
// -----
-// CHECK-LABEL: @my_module_br_table_empty
+// CHECK-LABEL: emitc.func private @my_module_br_table_empty
vm.module @my_module {
vm.func @br_table_empty(%arg0: i32, %arg1: i32) -> i32 {
// CHECK-NOT: vm.br_table
@@ -300,7 +300,7 @@
// -----
-// CHECK-LABEL: @my_module_br_table
+// CHECK-LABEL: emitc.func private @my_module_br_table
vm.module @my_module {
vm.func @br_table(%arg0: i32, %arg1: i32, %arg2: i32) -> i32 {
// CHECK-NOT: vm.br_table
@@ -330,7 +330,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_fail
+ // CHECK-LABEL: emitc.func private @my_module_fail
vm.func @fail(%arg0 : i32) {
// Typecast the argument to fail and branch respectively.
@@ -364,8 +364,8 @@
// Test vm.import conversion on a void function.
vm.module @my_module {
- // CHECK-LABEL: func.func @my_module_call_0v_v_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>)
- // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {emitc.static} {
+ // CHECK-LABEL: emitc.func private @my_module_call_0v_v_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>)
+ // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {specifiers = ["static"]} {
// Calculate the size of the arguments. To avoid empty structs we insert a dummy value.
// CHECK-NEXT: %[[ARGSIZE:.+]] = "emitc.constant"() <{value = #emitc.opaque<"0">}> : () -> !emitc.opaque<"iree_host_size_t">
@@ -426,9 +426,9 @@
// Test vm.import conversion on a variadic function.
vm.module @my_module {
- // CHECK-LABEL: func.func @my_module_call_0iCiD_i_2_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
+ // CHECK-LABEL: emitc.func private @my_module_call_0iCiD_i_2_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
// CHECK-SAME: %arg2: i32, %arg3: i32, %arg4: i32, %arg5: i32, %arg6: !emitc.ptr<i32>)
- // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {emitc.static} {
+ // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {specifiers = ["static"]} {
// Calculate the size of the arguments.
// CHECK-NEXT: %[[ARGSIZE0:.+]] = "emitc.constant"() <{value = #emitc.opaque<"0">}> : () -> !emitc.opaque<"iree_host_size_t">
@@ -529,9 +529,9 @@
// Test vm.call.variadic with zero variadic arguments.
vm.module @my_module {
- // CHECK-LABEL: func.func @my_module_call_0iCiD_i_0_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
+ // CHECK-LABEL: emitc.func private @my_module_call_0iCiD_i_0_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
// CHECK-SAME: %arg2: i32, %arg3: i32, %arg4: !emitc.ptr<i32>)
- // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {emitc.static} {
+ // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {specifiers = ["static"]} {
// Calculate the size of the arguments.
// CHECK-NEXT: %[[ARGSIZE0:.+]] = "emitc.constant"() <{value = #emitc.opaque<"0">}> : () -> !emitc.opaque<"iree_host_size_t">
@@ -616,9 +616,9 @@
// Test vm.import conversion on a function with vm.ref arguments.
vm.module @my_module {
- // CHECK-LABEL: func.func @my_module_call_0r_r_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
+ // CHECK-LABEL: emitc.func private @my_module_call_0r_r_import_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>,
// CHECK-SAME: %arg2: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, %arg3: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>)
- // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {emitc.static} {
+ // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {specifiers = ["static"]} {
// Calculate the size of the arguments.
// CHECK-NEXT: %[[ARGSIZE0:.+]] = "emitc.constant"() <{value = #emitc.opaque<"0">}> : () -> !emitc.opaque<"iree_host_size_t">
@@ -690,39 +690,39 @@
vm.module @my_module {
- // Typedef structs for arguments and results
- // CHECK: emitc.call_opaque "EMITC_TYPEDEF_STRUCT"() {args = [#emitc.opaque<"my_module_fn_args_t">, #emitc.opaque<"int32_t arg0;">]} : () -> ()
- // CHECK: emitc.call_opaque "EMITC_TYPEDEF_STRUCT"() {args = [#emitc.opaque<"my_module_fn_result_t">, #emitc.opaque<"int32_t res0;">]} : () -> ()
-
+ // Define structs for arguments and results
+ // CHECK: emitc.verbatim "struct my_module_fn_args_t {int32_t arg0;};"
+ // CHECK-NEXT: emitc.verbatim "struct my_module_fn_result_t {int32_t res0;};"
+
// Create a new function to export with the adapted signature.
- // CHECK: func.func @my_module_fn_export_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.opaque<"uint32_t">, %arg2: !emitc.opaque<"iree_byte_span_t">, %arg3: !emitc.opaque<"iree_byte_span_t">,
+ // CHECK: emitc.func private @my_module_fn_export_shim(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, %arg1: !emitc.opaque<"uint32_t">, %arg2: !emitc.opaque<"iree_byte_span_t">, %arg3: !emitc.opaque<"iree_byte_span_t">,
// CHECK-SAME: %arg4: !emitc.ptr<!emitc.opaque<"void">>, %arg5: !emitc.ptr<!emitc.opaque<"void">>)
- // CHECK-SAME: -> !emitc.opaque<"iree_status_t"> attributes {emitc.static, vm.calling_convention = "0i_i", vm.export_name = "fn"}
+ // CHECK-SAME: -> !emitc.opaque<"iree_status_t">
// Cast module and module state structs.
- // CHECK-NEXT: %[[MODULECASTED:.+]] = emitc.cast %arg4 : !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<!emitc.opaque<"my_module_t">>
- // CHECK-NEXT: %[[MODSTATECASTED:.+]] = emitc.cast %arg5 : !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<!emitc.opaque<"my_module_state_t">>
+ // CHECK-NEXT: %[[MODULECASTED:.+]] = emitc.cast %arg4 : !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<!emitc.opaque<"struct my_module_t">>
+ // CHECK-NEXT: %[[MODSTATECASTED:.+]] = emitc.cast %arg5 : !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<!emitc.opaque<"struct my_module_state_t">>
// Cast argument and result structs.
// CHECK-NEXT: %[[ARGDATA:.+]] = emitc.call_opaque "EMITC_STRUCT_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"data">]}
// CHECK-SAME: : (!emitc.opaque<"iree_byte_span_t">) -> !emitc.ptr<ui8>
- // CHECK-NEXT: %[[ARGS:.+]] = emitc.cast %[[ARGDATA]] : !emitc.ptr<ui8> to !emitc.ptr<!emitc.opaque<"my_module_fn_args_t">>
+ // CHECK-NEXT: %[[ARGS:.+]] = emitc.cast %[[ARGDATA]] : !emitc.ptr<ui8> to !emitc.ptr<!emitc.opaque<"struct my_module_fn_args_t">>
// CHECK-NEXT: %[[RESULTDATA:.+]] = emitc.call_opaque "EMITC_STRUCT_MEMBER"(%arg3) {args = [0 : index, #emitc.opaque<"data">]}
// CHECK-SAME: : (!emitc.opaque<"iree_byte_span_t">) -> !emitc.ptr<ui8>
- // CHECK-NEXT: %[[RESULTS:.+]] = emitc.cast %[[RESULTDATA]] : !emitc.ptr<ui8> to !emitc.ptr<!emitc.opaque<"my_module_fn_result_t">>
+ // CHECK-NEXT: %[[RESULTS:.+]] = emitc.cast %[[RESULTDATA]] : !emitc.ptr<ui8> to !emitc.ptr<!emitc.opaque<"struct my_module_fn_result_t">>
// Unpack the argument from the struct.
// CHECK-NEXT: %[[MARG:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%[[ARGS]]) {args = [0 : index, #emitc.opaque<"arg0">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_fn_args_t">>) -> i32
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_fn_args_t">>) -> i32
// Unpack the result pointer from the struct.
// CHECK-NEXT: %[[MRES:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER_ADDRESS"(%[[RESULTS]]) {args = [0 : index, #emitc.opaque<"res0">]}
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"my_module_fn_result_t">>) -> !emitc.ptr<i32>
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"struct my_module_fn_result_t">>) -> !emitc.ptr<i32>
// Call the internal function.
- // CHECK-NEXT: %{{.+}} = call @my_module_fn(%arg0, %[[MODULECASTED]], %[[MODSTATECASTED]], %[[MARG]], %[[MRES]])
- // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"my_module_t">>,
- // CHECK-SAME: !emitc.ptr<!emitc.opaque<"my_module_state_t">>, i32, !emitc.ptr<i32>) -> !emitc.opaque<"iree_status_t">
+ // CHECK-NEXT: %{{.+}} = emitc.call @my_module_fn(%arg0, %[[MODULECASTED]], %[[MODSTATECASTED]], %[[MARG]], %[[MRES]])
+ // CHECK-SAME: : (!emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>, !emitc.ptr<!emitc.opaque<"struct my_module_t">>,
+ // CHECK-SAME: !emitc.ptr<!emitc.opaque<"struct my_module_state_t">>, i32, !emitc.ptr<i32>) -> !emitc.opaque<"iree_status_t">
// Return ok status.
// CHECK: %[[STATUS:.+]] = emitc.call_opaque "iree_ok_status"() : () -> !emitc.opaque<"iree_status_t">
@@ -738,7 +738,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_return
+ // CHECK-LABEL: emitc.func private @my_module_return
vm.func @return(%arg0 : i32, %arg1 : !vm.ref<?>) -> (i32, !vm.ref<?>) {
// Move the i32 value and ref into the result function arguments.
@@ -766,9 +766,9 @@
vm.module @my_module {
vm.import private optional @optional_import_fn(%arg0 : i32) -> i32
- // CHECK-LABEL: @my_module_call_fn
+ // CHECK-LABEL: emitc.func private @my_module_call_fn
vm.func @call_fn() -> i32 {
- // CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
+ // CHECK-NEXT: %[[IMPORTS:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"imports">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[IMPORT:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[IMPORTS]]) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_function_t">>
// CHECK-NEXT: %[[MODULE:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%[[IMPORT]]) {args = [0 : index, #emitc.opaque<"module">]} : (!emitc.ptr<!emitc.opaque<"iree_vm_function_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_module_t">>
// CHECK-NEXT: %[[CONDITION0:.+]] = emitc.call_opaque "EMITC_UNARY"(%[[MODULE]]) {args = [#emitc.opaque<"!">, 0 : index]} : (!emitc.ptr<!emitc.opaque<"iree_vm_module_t">>) -> i1
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops.mlir
index 7c6409a..871cb09 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_trunc
+// CHECK-LABEL: emitc.func private @my_module_trunc
vm.module @my_module {
vm.func @trunc(%arg0 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_trunc_i32i8"(%arg3) : (i32) -> i32
@@ -13,7 +13,7 @@
// -----
-// CHECK-LABEL: @my_module_ext
+// CHECK-LABEL: emitc.func private @my_module_ext
vm.module @my_module {
vm.func @ext(%arg0 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_ext_i8i32s"(%arg3) : (i32) -> i32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_f32.mlir
index e4bea00..2c1c11e 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_f32.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_bitcast
+// CHECK-LABEL: emitc.func private @my_module_bitcast
vm.module @my_module {
vm.func @bitcast(%arg0 : i32) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_bitcast_i32f32"(%arg3) : (i32) -> f32
@@ -13,7 +13,7 @@
// -----
-// CHECK-LABEL: @my_module_cast
+// CHECK-LABEL: emitc.func private @my_module_cast
vm.module @my_module {
vm.func @cast(%arg0 : i32) -> (i32, i32) {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_cast_si32f32"(%arg3) : (i32) -> f32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_i64.mlir
index b4c1ed1..6d17f59 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/conversion_ops_i64.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_trunc_i64
+// CHECK-LABEL: emitc.func private @my_module_trunc_i64
vm.module @my_module {
vm.func @trunc_i64(%arg0 : i64) -> i32 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_trunc_i64i32"(%arg3) : (i64) -> i32
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_ext_i64
+// CHECK-LABEL: emitc.func private @my_module_ext_i64
vm.module @my_module {
vm.func @ext_i64(%arg0 : i32) -> i64 {
// CHECK-NEXT: %0 = emitc.call_opaque "vm_ext_i32i64s"(%arg3) : (i32) -> i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/func_op.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/func_op.mlir
index 47a06db..85295045 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/func_op.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/func_op.mlir
@@ -4,15 +4,14 @@
// some arguments are getting added. For more details see comments on the
// `ConvertVMToEmitCPass` class in ConvertVMToEmitC.cpp.
vm.module @my_module {
- // CHECK: func.func @my_module_fn(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>
- // CHECK-SAME: %arg1: !emitc.ptr<!emitc.opaque<"my_module_t">>,
- // CHECK-SAME: %arg2: !emitc.ptr<!emitc.opaque<"my_module_state_t">>,
+ // CHECK: emitc.func private @my_module_fn(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_stack_t">>
+ // CHECK-SAME: %arg1: !emitc.ptr<!emitc.opaque<"struct my_module_t">>,
+ // CHECK-SAME: %arg2: !emitc.ptr<!emitc.opaque<"struct my_module_state_t">>,
// CHECK-SAME: %arg3: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>,
// CHECK-SAME: %arg4: i32,
// CHECK-SAME: %arg5: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>,
// CHECK-SAME: %arg6: !emitc.ptr<i32>)
// CHECK-SAME: -> !emitc.opaque<"iree_status_t">
- // CHECK-SAME: attributes {emitc.static, vm.calling_convention = "0ri_ri"}
vm.func @fn(%arg0 : !vm.ref<?>, %arg1 : i32) -> (!vm.ref<?>, i32) {
vm.return %arg0, %arg1 : !vm.ref<?>, i32
}
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops.mlir
index 3dc77e0..2bc89b7 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops.mlir
@@ -3,9 +3,9 @@
vm.module @my_module {
vm.global.i32 private @c42 = 42 : i32
- // CHECK-LABEL: @my_module_global_load_i32
+ // CHECK-LABEL: emitc.func private @my_module_global_load_i32
vm.func @global_load_i32() -> i32 {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: %1 = emitc.call_opaque "vm_global_load_i32"(%0) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<ui8>) -> i32
%0 = vm.global.load.i32 @c42 : i32
vm.return %0 : i32
@@ -17,9 +17,9 @@
vm.module @my_module {
vm.global.i32 private mutable @c107_mut = 107 : i32
- // CHECK-LABEL: @my_module_global_store_i32
+ // CHECK-LABEL: emitc.func private @my_module_global_store_i32
vm.func @global_store_i32(%arg0 : i32) {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: emitc.call_opaque "vm_global_store_i32"(%0, %arg3) {args = [0 : index, 0 : ui32, 1 : index]} : (!emitc.ptr<ui8>, i32) -> ()
vm.global.store.i32 %arg0, @c107_mut : i32
vm.return
@@ -31,9 +31,9 @@
vm.module @my_module {
vm.global.ref private @g0 : !vm.buffer
- // CHECK-LABEL: @my_module_global_load_ref
+ // CHECK-LABEL: emitc.func private @my_module_global_load_ref
vm.func @global_load_ref() -> !vm.buffer {
- // CHECK: %[[A:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"refs">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
+ // CHECK: %[[A:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"refs">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
// CHECK: %[[B:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[A]]) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
// CHECK: %[[C:.+]] = emitc.call_opaque "iree_vm_type_def_as_ref"(%{{.+}}) : (!emitc.opaque<"iree_vm_type_def_t">) -> !emitc.opaque<"iree_vm_ref_type_t">
// CHECK: %{{.+}} = emitc.call_opaque "iree_vm_ref_retain_or_move_checked"(%[[B]], %[[C]], %arg3) {args = [false, 0 : index, 1 : index, 2 : index]} : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, !emitc.opaque<"iree_vm_ref_type_t">, !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_status_t">
@@ -47,9 +47,9 @@
vm.module @my_module {
vm.global.ref private mutable @g0_mut : !vm.buffer
- // CHECK-LABEL: @my_module_global_store_ref
+ // CHECK-LABEL: emitc.func private @my_module_global_store_ref
vm.func @global_store_ref(%arg0 : !vm.buffer) {
- // CHECK: %[[A:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"refs">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
+ // CHECK: %[[A:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"refs">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
// CHECK: %[[B:.+]] = emitc.call_opaque "EMITC_ARRAY_ELEMENT_ADDRESS"(%[[A]]) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
// CHECK: %[[C:.+]] = emitc.call_opaque "iree_vm_type_def_as_ref"(%{{.+}}) : (!emitc.opaque<"iree_vm_type_def_t">) -> !emitc.opaque<"iree_vm_ref_type_t">
// CHECK: %{{.+}} = emitc.call_opaque "iree_vm_ref_retain_or_move_checked"(%arg3, %[[C]], %[[B]]) {args = [false, 0 : index, 1 : index, 2 : index]} : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, !emitc.opaque<"iree_vm_ref_type_t">, !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_status_t">
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_f32.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_f32.mlir
index 5a0b6cc..cdfef0d 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_f32.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_f32.mlir
@@ -3,9 +3,9 @@
vm.module @my_module {
vm.global.f32 private @c42 = 42.5 : f32
- // CHECK-LABEL: @my_module_global_load_f32
+ // CHECK-LABEL: emitc.func private @my_module_global_load_f32
vm.func @global_load_f32() -> f32 {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: %1 = emitc.call_opaque "vm_global_load_f32"(%0) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<ui8>) -> f32
%0 = vm.global.load.f32 @c42 : f32
vm.return %0 : f32
@@ -17,9 +17,9 @@
vm.module @my_module {
vm.global.f32 private mutable @c107_mut = 107.5 : f32
- // CHECK-LABEL: @my_module_global_store_f32
+ // CHECK-LABEL: emitc.func private @my_module_global_store_f32
vm.func @global_store_f32(%arg0 : f32) {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: emitc.call_opaque "vm_global_store_f32"(%0, %arg3) {args = [0 : index, 0 : ui32, 1 : index]} : (!emitc.ptr<ui8>, f32) -> ()
vm.global.store.f32 %arg0, @c107_mut : f32
vm.return
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_i64.mlir
index 49ada1d..16b6199 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/global_ops_i64.mlir
@@ -3,9 +3,9 @@
vm.module @my_module {
vm.global.i64 private @c42 = 42 : i64
- // CHECK-LABEL: @my_module_global_load_i64
+ // CHECK-LABEL: emitc.func private @my_module_global_load_i64
vm.func @global_load_i64() -> i64 {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: %1 = emitc.call_opaque "vm_global_load_i64"(%0) {args = [0 : index, 0 : ui32]} : (!emitc.ptr<ui8>) -> i64
%0 = vm.global.load.i64 @c42 : i64
vm.return %0 : i64
@@ -17,9 +17,9 @@
vm.module @my_module {
vm.global.i64 private mutable @c107_mut = 107 : i64
- // CHECK-LABEL: @my_module_global_store_i64
+ // CHECK-LABEL: emitc.func private @my_module_global_store_i64
vm.func @global_store_i64(%arg0 : i64) {
- // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.ptr<ui8>
+ // CHECK-NEXT: %0 = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"rwdata">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.ptr<ui8>
// CHECK-NEXT: emitc.call_opaque "vm_global_store_i64"(%0, %arg3) {args = [0 : index, 0 : ui32, 1 : index]} : (!emitc.ptr<ui8>, i64) -> ()
vm.global.store.i64 %arg0, @c107_mut : i64
vm.return
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops.mlir
index 07f3440..92526fd 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops.mlir
@@ -1,11 +1,11 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_alloc
+ // CHECK-LABEL: emitc.func private @my_module_list_alloc
vm.func @list_alloc(%arg0: i32) -> !vm.list<i32> {
// CHECK: %[[LIST:.+]] = "emitc.variable"() <{value = #emitc.opaque<"NULL">}> : () -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
// CHECK: %[[LIST_PTR:.+]] = emitc.apply "&"(%3) : (!emitc.ptr<!emitc.opaque<"iree_vm_list_t">>) -> !emitc.ptr<!emitc.ptr<!emitc.opaque<"iree_vm_list_t">>>
- // CHECK: %[[ALLOCATOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
+ // CHECK: %[[ALLOCATOR:.+]] = emitc.call_opaque "EMITC_STRUCT_PTR_MEMBER"(%arg2) {args = [0 : index, #emitc.opaque<"allocator">]} : (!emitc.ptr<!emitc.opaque<"struct my_module_state_t">>) -> !emitc.opaque<"iree_allocator_t">
// CHECK: %[[TYPE_DEF:.+]] = emitc.call_opaque "iree_vm_make_value_type_def"() {args = [#emitc.opaque<"IREE_VM_VALUE_TYPE_I32">]} : () -> !emitc.opaque<"iree_vm_type_def_t">
// CHECK-NEXT: %[[STATUS:.+]] = emitc.call_opaque "iree_vm_list_create"(%[[TYPE_DEF]], %arg3, %[[ALLOCATOR]], %[[LIST_PTR]]) : (!emitc.opaque<"iree_vm_type_def_t">, i32, !emitc.opaque<"iree_allocator_t">, !emitc.ptr<!emitc.ptr<!emitc.opaque<"iree_vm_list_t">>>) -> !emitc.opaque<"iree_status_t">
@@ -21,7 +21,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_reserve
+ // CHECK-LABEL: emitc.func private @my_module_list_reserve
vm.func @list_reserve(%arg0: !vm.list<i32>, %arg1: i32) {
// CHECK-NEXT: %0 = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %1 = emitc.call_opaque "iree_vm_list_deref"(%0) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
@@ -34,7 +34,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_resize
+ // CHECK-LABEL: emitc.func private @my_module_list_resize
vm.func @list_resize(%arg0: !vm.list<i32>, %arg1: i32) {
// CHECK-NEXT: %0 = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %1 = emitc.call_opaque "iree_vm_list_deref"(%0) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
@@ -47,7 +47,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_size
+ // CHECK-LABEL: emitc.func private @my_module_list_size
vm.func @list_size(%arg0: !vm.list<i32>) -> i32 {
// CHECK-NEXT: %0 = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %1 = emitc.call_opaque "iree_vm_list_deref"(%0) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
@@ -60,7 +60,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_get_i32
+ // CHECK-LABEL: emitc.func private @my_module_list_get_i32
vm.func @list_get_i32(%arg0: !vm.list<i32>, %arg1: i32) -> i32 {
// CHECK-NEXT: %0 = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_value_t">
// CHECK-NEXT: %1 = emitc.apply "&"(%0) : (!emitc.opaque<"iree_vm_value_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_value_t">>
@@ -75,7 +75,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_get_ref
+ // CHECK-LABEL: emitc.func private @my_module_list_get_ref
vm.func @list_get_ref(%arg0: !vm.list<!vm.ref<?>>, %arg1: i32) -> !vm.buffer {
// CHECK-NEXT: %0 = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %1 = emitc.call_opaque "iree_vm_list_deref"(%0) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
@@ -100,7 +100,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_set_i32
+ // CHECK-LABEL: emitc.func private @my_module_list_set_i32
vm.func @list_set_i32(%arg0: !vm.list<i32>, %arg1: i32, %arg2: i32) {
// CHECK-NEXT: %0 = emitc.call_opaque "iree_vm_value_make_i32"(%arg5) : (i32) -> !emitc.opaque<"iree_vm_value_t">
// CHECK-NEXT: %1 = emitc.apply "&"(%0) : (!emitc.opaque<"iree_vm_value_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_value_t">>
@@ -115,7 +115,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_set_ref
+ // CHECK-LABEL: emitc.func private @my_module_list_set_ref
vm.func @list_set_ref(%arg0: !vm.list<!vm.ref<?>>, %arg1: i32, %arg2: !vm.buffer) {
// CHECK-NEXT: %0 = emitc.apply "*"(%arg3) : (!emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>) -> !emitc.opaque<"iree_vm_ref_t">
// CHECK-NEXT: %1 = emitc.call_opaque "iree_vm_list_deref"(%0) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_list_t">>
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops_i64.mlir
index 2dc4997..37847f5 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/list_ops_i64.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_get_i64
+ // CHECK-LABEL: emitc.func private @my_module_list_get_i64
vm.func @list_get_i64(%arg0: !vm.list<i64>, %arg1: i32) -> i64 {
// CHECK-NEXT: %0 = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_value_t">
// CHECK-NEXT: %1 = emitc.apply "&"(%0) : (!emitc.opaque<"iree_vm_value_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_value_t">>
@@ -16,7 +16,7 @@
// -----
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_set_i64
+ // CHECK-LABEL: emitc.func private @my_module_list_set_i64
vm.func @list_set_i64(%arg0: !vm.list<i64>, %arg1: i32, %arg2: i64) {
// CHECK-NEXT: %0 = emitc.call_opaque "iree_vm_value_make_i64"(%arg5) : (i64) -> !emitc.opaque<"iree_vm_value_t">
// CHECK-NEXT: %1 = emitc.apply "&"(%0) : (!emitc.opaque<"iree_vm_value_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_value_t">>
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops.mlir
index fb0c42d..ae54f6e 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_shl_i32
+// CHECK-LABEL: emitc.func private @my_module_shl_i32
vm.module @my_module {
vm.func @shl_i32(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_shl_i32"(%arg3, %arg4) : (i32, i32) -> i32
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_shr_i32_s
+// CHECK-LABEL: emitc.func private @my_module_shr_i32_s
vm.module @my_module {
vm.func @shr_i32_s(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_shr_i32s"(%arg3, %arg4) : (i32, i32) -> i32
@@ -22,7 +22,7 @@
// -----
-// CHECK-LABEL: @my_module_shr_i32_u
+// CHECK-LABEL: emitc.func private @my_module_shr_i32_u
vm.module @my_module {
vm.func @shr_i32_u(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %0 = emitc.call_opaque "vm_shr_i32u"(%arg3, %arg4) : (i32, i32) -> i32
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops_i64.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops_i64.mlir
index ed130dc..75192f2 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops_i64.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/shift_ops_i64.mlir
@@ -1,6 +1,6 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
-// CHECK-LABEL: @my_module_shl_i64
+// CHECK-LABEL: emitc.func private @my_module_shl_i64
vm.module @my_module {
vm.func @shl_i64(%arg0 : i64, %arg1 : i32) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_shl_i64"(%arg3, %arg4) : (i64, i32) -> i64
@@ -11,7 +11,7 @@
// -----
-// CHECK-LABEL: @my_module_shr_i64_s
+// CHECK-LABEL: emitc.func private @my_module_shr_i64_s
vm.module @my_module {
vm.func @shr_i64_s(%arg0 : i64, %arg1 : i32) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_shr_i64s"(%arg3, %arg4) : (i64, i32) -> i64
@@ -22,7 +22,7 @@
// -----
-// CHECK-LABEL: @my_module_shr_i64_u
+// CHECK-LABEL: emitc.func private @my_module_shr_i64_u
vm.module @my_module {
vm.func @shr_i64_u(%arg0 : i64, %arg1 : i32) -> i64 {
// CHECK: %0 = emitc.call_opaque "vm_shr_i64u"(%arg3, %arg4) : (i64, i32) -> i64
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/type_conversion.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/type_conversion.mlir
index d63b717..2329053 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/type_conversion.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/test/type_conversion.mlir
@@ -1,7 +1,7 @@
// RUN: iree-opt --split-input-file --pass-pipeline="builtin.module(vm.module(iree-vm-ordinal-allocation),vm.module(iree-convert-vm-to-emitc))" %s | FileCheck %s
vm.module @my_module {
- // CHECK-LABEL: @my_module_list_alloc
+ // CHECK-LABEL: emitc.func private @my_module_list_alloc
vm.func @list_alloc(%arg0: i32) {
// CHECK: %[[REF:.+]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_ref_t">
// CHECK: %[[REFPTR:.+]] = emitc.apply "&"(%[[REF]]) : (!emitc.opaque<"iree_vm_ref_t">) -> !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>
@@ -11,7 +11,7 @@
vm.return
}
- // CHECK-LABEL: @my_module_list_size
+ // CHECK-LABEL: emitc.func private @my_module_list_size
vm.func @list_size(%arg0: i32) {
%list = vm.list.alloc %arg0 : (i32) -> !vm.list<i32>
// CHECK: %[[REF:.+]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_ref_t">
@@ -28,7 +28,7 @@
vm.module @my_module {
vm.rodata private @byte_buffer dense<[1, 2, 3]> : tensor<3xi32>
- // CHECK-LABEL: @my_module_ref
+ // CHECK-LABEL: emitc.func private @my_module_ref
vm.export @ref
vm.func @ref(%arg0: i32) {
// CHECK: %[[REF:.+]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.opaque<"iree_vm_ref_t">
@@ -42,12 +42,12 @@
// -----
-// Test the func.func conversion, which is needed as a second step after the
+// Test the emitc.func conversion, which is needed as a second step after the
// vm.func conversion. All references in the signature should be converted to
// emitc pointers.
vm.module @my_module {
- // CHECK: func.func @fn(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, %arg1: i32)
- func.func @fn(%arg0 : !vm.ref<?>, %arg1 : i32) -> () {
- return
+ // CHECK: emitc.func @fn(%arg0: !emitc.ptr<!emitc.opaque<"iree_vm_ref_t">>, %arg1: i32)
+ emitc.func @fn(%arg0 : !vm.ref<?>, %arg1 : i32) -> () {
+ emitc.return
}
}
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/BUILD.bazel b/compiler/src/iree/compiler/Dialect/VM/Target/C/BUILD.bazel
index 264974f..071ff09 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/BUILD.bazel
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/BUILD.bazel
@@ -13,29 +13,6 @@
)
iree_compiler_cc_library(
- name = "TranslateToCpp",
- srcs = [
- "TranslateToCpp.cpp",
- ],
- hdrs = [
- "CppEmitter.h",
- ],
- defines = [
- "IREE_HAVE_C_OUTPUT_FORMAT",
- ],
- deps = [
- "@llvm-project//llvm:Support",
- "@llvm-project//mlir:ControlFlowDialect",
- "@llvm-project//mlir:EmitCDialect",
- "@llvm-project//mlir:FuncDialect",
- "@llvm-project//mlir:FunctionInterfaces",
- "@llvm-project//mlir:IR",
- "@llvm-project//mlir:SCFDialect",
- "@llvm-project//mlir:Support",
- ],
-)
-
-iree_compiler_cc_library(
name = "C",
srcs = [
"CModuleTarget.cpp",
@@ -46,8 +23,10 @@
"CModuleTarget.h",
"TranslationFlags.h",
],
+ defines = [
+ "IREE_HAVE_C_OUTPUT_FORMAT",
+ ],
deps = [
- ":TranslateToCpp",
"//compiler/src/iree/compiler/Dialect/Util/IR",
"//compiler/src/iree/compiler/Dialect/Util/Transforms",
"//compiler/src/iree/compiler/Dialect/VM/Analysis",
@@ -55,9 +34,11 @@
"//compiler/src/iree/compiler/Dialect/VM/IR",
"//compiler/src/iree/compiler/Dialect/VM/Transforms",
"@llvm-project//llvm:Support",
+ "@llvm-project//mlir:ControlFlowDialect",
"@llvm-project//mlir:IR",
"@llvm-project//mlir:Pass",
"@llvm-project//mlir:Support",
+ "@llvm-project//mlir:TargetCpp",
"@llvm-project//mlir:Transforms",
"@llvm-project//mlir:TranslateLib",
],
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/CMakeLists.txt b/compiler/src/iree/compiler/Dialect/VM/Target/C/CMakeLists.txt
index 98dd734..695de19 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/CMakeLists.txt
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/CMakeLists.txt
@@ -25,27 +25,6 @@
iree_cc_library(
NAME
- TranslateToCpp
- HDRS
- "CppEmitter.h"
- SRCS
- "TranslateToCpp.cpp"
- DEPS
- LLVMSupport
- MLIRControlFlowDialect
- MLIREmitCDialect
- MLIRFuncDialect
- MLIRFunctionInterfaces
- MLIRIR
- MLIRSCFDialect
- MLIRSupport
- DEFINES
- "IREE_HAVE_C_OUTPUT_FORMAT"
- PUBLIC
-)
-
-iree_cc_library(
- NAME
C
HDRS
"CModuleTarget.h"
@@ -55,11 +34,12 @@
"TranslationFlags.cpp"
"TranslationRegistration.cpp"
DEPS
- ::TranslateToCpp
LLVMSupport
+ MLIRControlFlowDialect
MLIRIR
MLIRPass
MLIRSupport
+ MLIRTargetCpp
MLIRTransforms
MLIRTranslateLib
iree::compiler::Dialect::Util::IR
@@ -68,6 +48,8 @@
iree::compiler::Dialect::VM::Conversion::VMToEmitC
iree::compiler::Dialect::VM::IR
iree::compiler::Dialect::VM::Transforms
+ DEFINES
+ "IREE_HAVE_C_OUTPUT_FORMAT"
PUBLIC
)
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/CModuleTarget.cpp b/compiler/src/iree/compiler/Dialect/VM/Target/C/CModuleTarget.cpp
index 0617e80..1f01cd0 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/CModuleTarget.cpp
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/CModuleTarget.cpp
@@ -12,291 +12,15 @@
#include "iree/compiler/Dialect/VM/Analysis/RegisterAllocation.h"
#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/ConvertVMToEmitC.h"
#include "iree/compiler/Dialect/VM/Conversion/VMToEmitC/DropExcludedExports.h"
-#include "iree/compiler/Dialect/VM/Target/C/CppEmitter.h"
#include "iree/compiler/Dialect/VM/Transforms/Passes.h"
#include "llvm/ADT/TypeSwitch.h"
+#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Pass/PassManager.h"
+#include "mlir/Target/Cpp/CppEmitter.h"
#include "mlir/Transforms/Passes.h"
namespace mlir::iree_compiler::IREE::VM {
-static void printCompilerConfigurationBlock(llvm::raw_ostream &output) {
- output << "//" << std::string(77, '=') << "\n"
- << "// compiler configuration\n"
- << "//" << std::string(77, '=') << "\n\n";
-}
-
-static void printModuleComment(IREE::VM::ModuleOp &moduleOp,
- llvm::raw_ostream &output) {
- output << "//" << std::string(77, '=') << "\n"
- << "// module \"" << moduleOp.getName()
- << "\"\n"
- "//"
- << std::string(77, '=') << "\n";
-}
-
-static LogicalResult
-printFunctionDeclaration(mlir::func::FuncOp funcOp, llvm::raw_ostream &output,
- mlir::emitc::CppEmitter &emitter) {
- Operation *op = funcOp.getOperation();
- if (op->hasAttr("emitc.static"))
- output << "static ";
-
- if (failed(emitter.emitTypes(funcOp.getLoc(),
- funcOp.getFunctionType().getResults())))
- return failure();
- output << " " << funcOp.getName();
-
- output << "(";
-
- bool error = false;
- llvm::interleaveComma(funcOp.getArguments(), output, [&](BlockArgument arg) {
- if (failed(emitter.emitType(funcOp.getLoc(), arg.getType())))
- error = true;
- });
- if (error)
- return failure();
- output << ");\n";
-
- return success();
-}
-
-static LogicalResult printRodataBuffers(IREE::VM::ModuleOp &moduleOp,
- mlir::emitc::CppEmitter &emitter) {
- llvm::raw_ostream &output = emitter.ostream();
- std::string moduleName = moduleOp.getName().str();
-
- for (auto rodataOp : moduleOp.getOps<IREE::VM::RodataOp>()) {
- auto value = llvm::dyn_cast<IREE::Util::SerializableAttrInterface>(
- rodataOp.getValue());
- assert(value && "expected a serializable rodata value");
- SmallVector<char> byteBuffer;
- if (failed(value.serializeToVector(rodataOp.getLoc(),
- llvm::endianness::little, byteBuffer))) {
- return rodataOp.emitError() << "error during serialization";
- }
-
- constexpr size_t kDefaultRodataAlignment = 16;
- size_t alignment =
- rodataOp.getAlignment()
- ? static_cast<size_t>(rodataOp.getAlignment().value())
- : 0;
- if (alignment == 0)
- alignment = kDefaultRodataAlignment;
-
- std::string bufferName =
- moduleOp.getName().str() + "_" + rodataOp.getName().str();
-
- output << "iree_alignas(" << alignment << ") static const uint8_t "
- << bufferName << "[] = {";
- llvm::interleaveComma(byteBuffer, output, [&](char value) {
- output << static_cast<unsigned int>(static_cast<unsigned char>(value));
- });
- output << "};\n";
- }
-
- output << "\n";
-
- return success();
-}
-
-static LogicalResult printStructDefinitions(IREE::VM::ModuleOp &moduleOp,
- mlir::emitc::CppEmitter &emitter) {
- llvm::raw_ostream &output = emitter.ostream();
- std::string moduleName = moduleOp.getName().str();
-
- // Returns |count| or 1 if |count| == 0.
- // Some compilers (MSVC) don't support zero-length struct fields on the
- // interior of structs (just VLA at the tail).
- auto countOrEmpty = [](uint32_t count) { return count ? count : 1; };
-
- const int64_t numTypes =
- llvm::cast<IntegerAttr>(moduleOp.getOperation()->getAttr("vm.num_types"))
- .getInt();
-
- output << "struct " << moduleName << "_t {\n";
- output << "iree_allocator_t allocator;\n";
- output << "iree_vm_ref_type_t types[" << countOrEmpty(numTypes) << "];\n";
- output << "};\n";
-
- output << "struct " << moduleName << "_state_t {\n";
-
- auto ordinalCounts = moduleOp.getOrdinalCountsAttr();
- output << "iree_allocator_t allocator;\n";
- output << "uint8_t rwdata[" << countOrEmpty(ordinalCounts.getGlobalBytes())
- << "];\n";
- output << "iree_vm_ref_t refs[" << countOrEmpty(ordinalCounts.getGlobalRefs())
- << "];\n";
- output << "iree_vm_buffer_t rodata_buffers["
- << countOrEmpty(ordinalCounts.getRodatas()) << "];\n";
- output << "iree_vm_function_t imports["
- << countOrEmpty(ordinalCounts.getImportFuncs()) << "];\n";
- output << "};\n";
-
- output << "typedef struct " << moduleName << "_t " << moduleName << "_t;\n";
- output << "typedef struct " << moduleName << "_state_t " << moduleName
- << "_state_t;\n";
-
- output << "\n";
-
- return success();
-}
-
-static LogicalResult buildModuleDescriptors(IREE::VM::ModuleOp &moduleOp,
- mlir::emitc::CppEmitter &emitter) {
- SymbolTable symbolTable(moduleOp);
- std::string moduleName = moduleOp.getName().str();
- llvm::raw_ostream &output = emitter.ostream();
-
- auto printStringView = [](StringRef s) -> std::string {
- // We can't use iree_make_string_view because function calls are not allowed
- // for constant expressions in C.
- // TODO(#7605): Switch to IREE_SVL. We can't use IREE_SVL today because it
- // uses designated initializers, which cause issues when compiled as C++.
- return ("{\"" + s + "\", " + std::to_string(s.size()) + "}").str();
- };
-
- // dependencies
- std::string dependenciesName = moduleName + "_dependencies_";
- output << "static const iree_vm_module_dependency_t " << dependenciesName
- << "[] = {\n";
- auto dependencies = moduleOp.getDependencies();
- if (dependencies.empty()) {
- // Empty list placeholder.
- output << " {{0}},\n";
- } else {
- for (auto &dependency : dependencies) {
- output << "{" << printStringView(dependency.name) << ", "
- << dependency.minimumVersion << ", "
- << (dependency.isOptional
- ? "IREE_VM_MODULE_DEPENDENCY_FLAG_OPTIONAL"
- : "IREE_VM_MODULE_DEPENDENCY_FLAG_REQUIRED")
- << "},\n";
- }
- }
- output << "};\n";
- output << "\n";
-
- // imports
- SmallVector<IREE::VM::ImportOp> importOps(
- moduleOp.getOps<IREE::VM::ImportOp>());
- std::string importName = moduleName + "_imports_";
- output << "static const iree_vm_native_import_descriptor_t " << importName
- << "[] = {\n";
- if (importOps.empty()) {
- // Empty list placeholder.
- output << " {0},\n";
- } else {
- // sort import ops by ordinal
- llvm::sort(importOps, [](auto &lhs, auto &rhs) {
- return lhs.getOrdinal()->getZExtValue() <
- rhs.getOrdinal()->getZExtValue();
- });
- for (auto importOp : importOps) {
- output << "{"
- << (importOp.getIsOptional() ? "IREE_VM_NATIVE_IMPORT_OPTIONAL"
- : "IREE_VM_NATIVE_IMPORT_REQUIRED")
- << ", " << printStringView(importOp.getName()) << "},\n";
- }
- }
- output << "};\n";
- output << "\n";
-
- // exports
- SmallVector<func::FuncOp> exportedFunctions;
- for (auto func : moduleOp.getOps<func::FuncOp>()) {
- if (func.getOperation()->hasAttr("vm.export_name")) {
- exportedFunctions.push_back(func);
- }
- }
- auto extractExportName = [](func::FuncOp funcOp) {
- return llvm::cast<StringAttr>(
- funcOp.getOperation()->getAttr("vm.export_name"));
- };
- std::string exportName = moduleName + "_exports_";
- output << "static const iree_vm_native_export_descriptor_t " << exportName
- << "[] = {\n";
- if (exportedFunctions.empty()) {
- // Empty list placeholder.
- output << " {{0}},\n";
- } else {
- // sort export ops
- llvm::sort(exportedFunctions, [&extractExportName](auto &lhs, auto &rhs) {
- return extractExportName(lhs).compare(extractExportName(rhs)) < 0;
- });
- for (auto funcOp : exportedFunctions) {
- StringAttr exportName = extractExportName(funcOp);
- StringAttr callingConvention = llvm::cast<StringAttr>(
- funcOp.getOperation()->getAttr("vm.calling_convention"));
- if (!callingConvention) {
- return funcOp.emitError("Couldn't find calling convention attribute");
- }
-
- // TODO(simon-camp): support function-level reflection attributes
- output << "{" << printStringView(exportName) << ", "
- << printStringView(callingConvention.getValue())
- << ", 0, NULL},\n";
- }
- }
- output << "};\n";
- output << "\n";
-
- // functions
- std::string functionName = moduleName + "_funcs_";
- output << "static const iree_vm_native_function_ptr_t " << functionName
- << "[] = {\n";
- if (exportedFunctions.empty()) {
- // Empty list placeholder.
- output << " {0},\n";
- } else {
- // We only add exported functions to the table, as calls to internal
- // functions are directly mapped to C function calls of the generated
- // implementation.
- for (auto funcOp : exportedFunctions) {
- auto funcName = funcOp.getName();
- output << "{"
- << "(iree_vm_native_function_shim_t)iree_emitc_shim, "
- << "(iree_vm_native_function_target_t)" << funcName << "},\n";
- }
- }
- output << "};\n";
- output << "\n";
-
- // module descriptor
- // TODO(simon-camp): support module-level reflection attributes
- std::string descriptorName = moduleName + "_descriptor_";
- output << "static const iree_vm_native_module_descriptor_t " << descriptorName
- << " = {\n"
- // name:
- << printStringView(moduleName)
- << ",\n"
- // version:
- << moduleOp.getVersion().value_or(0u)
- << ",\n"
- // attrs:
- << "0,\n"
- << "NULL,\n"
- // dependencies:
- << dependencies.size() << ",\n"
- << dependenciesName
- << ",\n"
- // imports:
- << importOps.size() << ",\n"
- << importName
- << ",\n"
- // exports:
- << exportedFunctions.size() << ",\n"
- << exportName
- << ",\n"
- // functions:
- << exportedFunctions.size() << ",\n"
- << functionName << ",\n"
- << "};\n";
-
- output << "\n";
- return success();
-}
-
/// Adapted from BytecodeModuleTarget and extended by C specific passes
static LogicalResult
canonicalizeModule(IREE::VM::ModuleOp moduleOp,
@@ -385,126 +109,28 @@
LogicalResult translateModuleToC(IREE::VM::ModuleOp moduleOp,
CTargetOptions targetOptions,
llvm::raw_ostream &output) {
- moduleOp.getContext()->getOrLoadDialect<IREE::Util::UtilDialect>();
+ moduleOp.getContext()
+ ->loadDialect<IREE::Util::UtilDialect, mlir::cf::ControlFlowDialect>();
if (failed(canonicalizeModule(moduleOp, targetOptions))) {
return moduleOp.emitError()
<< "failed to canonicalize vm.module to a serializable form";
}
+ auto innerModules = moduleOp.getOps<mlir::ModuleOp>();
+ if (innerModules.empty()) {
+ return moduleOp.emitError()
+ << "vm module does not contain an inner builtin.module op";
+ }
+ mlir::ModuleOp mlirModule = *innerModules.begin();
if (targetOptions.outputFormat == COutputFormat::kMlirText) {
// Use the standard MLIR text printer.
- moduleOp.getOperation()->print(output);
+ mlirModule.getOperation()->print(output);
output << "\n";
return success();
}
- std::string includeGuard = moduleOp.getName().upper();
- output << "#ifndef " << includeGuard << "_H_\n";
- output << "#define " << includeGuard << "_H_\n";
-
- auto printInclude = [&output](std::string include) {
- output << "#include \"" << include << "\"\n";
- };
-
- printInclude("iree/vm/api.h");
- output << "\n";
-
- output << "#ifdef __cplusplus\n";
- output << "extern \"C\" {\n";
- output << "#endif // __cplusplus\n";
- output << "\n";
-
- mlir::emitc::CppEmitter emitter(output, /*declareVariablesAtTop=*/true);
- for (auto funcOp : moduleOp.getOps<mlir::func::FuncOp>()) {
- Operation *op = funcOp.getOperation();
- if (!op->hasAttr("vm.module.constructor"))
- continue;
- if (failed(printFunctionDeclaration(funcOp, output, emitter)))
- return failure();
- }
-
- output << "\n";
- output << "#ifdef __cplusplus\n";
- output << "} // extern \"C\"\n";
- output << "#endif // __cplusplus\n";
- output << "\n";
-
- output << "#endif // " << includeGuard << "_H_\n\n";
- output << "#if defined(EMITC_IMPLEMENTATION)\n";
-
- printInclude("iree/vm/ops.h");
- printInclude("iree/vm/ops_emitc.h");
- printInclude("iree/vm/shims_emitc.h");
- output << "\n";
-
- printCompilerConfigurationBlock(output);
- output << "\n";
-
- printModuleComment(moduleOp, output);
- output << "\n";
-
- mlir::emitc::CppEmitter::Scope scope(emitter);
-
- if (failed(printRodataBuffers(moduleOp, emitter))) {
- return failure();
- }
-
- // build struct definitions
- if (failed(printStructDefinitions(moduleOp, emitter))) {
- return failure();
- }
-
- // translate functions
- output << "// DECLARE FUNCTIONS\n";
-
- for (auto funcOp : moduleOp.getOps<mlir::func::FuncOp>()) {
- Operation *op = funcOp.getOperation();
- if (op->hasAttr("vm.module.constructor"))
- continue;
- if (failed(printFunctionDeclaration(funcOp, output, emitter)))
- return failure();
- }
-
- output << "// DEFINE FUNCTIONS\n";
-
- // Emit code for functions skipping those marked with `vm.emit_at_end`.
- for (Operation &op : moduleOp.getOps()) {
- // TODO(simon-camp): Clean up. We generate calls to a macro that defines a
- // struct. As we declare all variables at the start of the function, the
- // macro call cannot be inlined into the function.
- if (!isa<mlir::func::FuncOp, emitc::CallOpaqueOp>(op))
- continue;
- if (op.hasAttr("vm.emit_at_end"))
- continue;
- if (op.hasAttr("emitc.static"))
- output << "static ";
- if (failed(emitter.emitOperation(op,
- /*trailingSemicolon=*/false)))
- return failure();
- }
-
- output << "\n";
-
- // generate module descriptors
- if (failed(buildModuleDescriptors(moduleOp, emitter))) {
- return failure();
- }
-
- // Emit code for functions marked with `vm.emit_at_end`.
- for (auto funcOp : moduleOp.getOps<mlir::func::FuncOp>()) {
- Operation *op = funcOp.getOperation();
- if (!op->hasAttr("vm.emit_at_end"))
- continue;
- if (op->hasAttr("emitc.static"))
- output << "static ";
- if (failed(emitter.emitOperation(*funcOp.getOperation(),
- /*trailingSemicolon=*/false)))
- return failure();
- }
-
- output << "#endif // EMITC_IMPLEMENTATION\n";
- return success();
+ return mlir::emitc::translateToCpp(mlirModule.getOperation(), output, true);
}
LogicalResult translateModuleToC(mlir::ModuleOp outerModuleOp,
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/TranslateToCpp.cpp b/compiler/src/iree/compiler/Dialect/VM/Target/C/TranslateToCpp.cpp
deleted file mode 100644
index a5163c2..0000000
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/TranslateToCpp.cpp
+++ /dev/null
@@ -1,861 +0,0 @@
-// Copyright 2020 The IREE Authors
-//
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// Formated in LLVM style. Avoid reformatting for upcoming upstreaming.
-// clang-format off
-
-#include "iree/compiler/Dialect/VM/Target/C/CppEmitter.h"
-
-#include "mlir/Dialect/EmitC/IR/EmitC.h"
-#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/BuiltinTypes.h"
-#include "mlir/IR/Dialect.h"
-#include "mlir/IR/Operation.h"
-#include "mlir/Support/IndentedOstream.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/TypeSwitch.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/FormatVariadic.h"
-
-#define DEBUG_TYPE "translate-to-cpp"
-
-using namespace mlir;
-using namespace mlir::emitc;
-using llvm::formatv;
-
-static LogicalResult printConstantOp(CppEmitter &emitter, Operation *operation,
- Attribute value) {
- OpResult result = operation->getResult(0);
-
- // Only emit an assignment as the variable was already declared when printing
- // the FuncOp.
- if (emitter.shouldDeclareVariablesAtTop()) {
- // Skip the assignment if the emitc.constant has no value.
- if (auto oAttr = llvm::dyn_cast<emitc::OpaqueAttr>(value)) {
- if (oAttr.getValue().empty())
- return success();
- }
-
- if (failed(emitter.emitVariableAssignment(result)))
- return failure();
- return emitter.emitAttribute(operation->getLoc(), value);
- }
-
- // Emit a variable declaration for an emitc.constant op without value.
- if (auto oAttr = llvm::dyn_cast<emitc::OpaqueAttr>(value)) {
- if (oAttr.getValue().empty())
- // The semicolon gets printed by the emitOperation function.
- return emitter.emitVariableDeclaration(result,
- /*trailingSemicolon=*/false);
- }
-
- // Emit a variable declaration.
- if (failed(emitter.emitAssignPrefix(*operation)))
- return failure();
- return emitter.emitAttribute(operation->getLoc(), value);
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- emitc::ConstantOp constantOp) {
- Operation *operation = constantOp.getOperation();
- Attribute value = constantOp.getValue();
-
- return printConstantOp(emitter, operation, value);
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- emitc::VariableOp variableOp) {
- Operation *operation = variableOp.getOperation();
- Attribute value = variableOp.getValue();
-
- return printConstantOp(emitter, operation, value);
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- mlir::func::ConstantOp constantOp) {
- Operation *operation = constantOp.getOperation();
- Attribute value = constantOp.getValueAttr();
-
- return printConstantOp(emitter, operation, value);
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- cf::BranchOp branchOp) {
- raw_ostream &os = emitter.ostream();
- Block &successor = *branchOp.getSuccessor();
-
- for (auto [operand, arg] :
- llvm::zip_equal(branchOp.getOperands(), successor.getArguments())) {
- os << emitter.getOrCreateName(arg) << " = "
- << emitter.getOrCreateName(operand) << ";\n";
- }
-
- os << "goto ";
- if (!(emitter.hasBlockLabel(successor)))
- return branchOp.emitOpError("unable to find label for successor block");
- os << emitter.getOrCreateName(successor);
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- cf::CondBranchOp condBranchOp) {
- raw_ostream &os = emitter.ostream();
- Block &trueSuccessor = *condBranchOp.getTrueDest();
- Block &falseSuccessor = *condBranchOp.getFalseDest();
-
- os << "if (" << emitter.getOrCreateName(condBranchOp.getCondition())
- << ") {\n";
-
- // If condition is true.
- for (auto [operand, arg] : llvm::zip_equal(condBranchOp.getTrueOperands(),
- trueSuccessor.getArguments())) {
- os << emitter.getOrCreateName(arg) << " = "
- << emitter.getOrCreateName(operand) << ";\n";
- }
-
- os << "goto ";
- if (!(emitter.hasBlockLabel(trueSuccessor))) {
- return condBranchOp.emitOpError("unable to find label for successor block");
- }
- os << emitter.getOrCreateName(trueSuccessor) << ";\n";
- os << "} else {\n";
- // If condition is false.
- for (auto [operand, arg] : llvm::zip_equal(condBranchOp.getFalseOperands(),
- falseSuccessor.getArguments())) {
- os << emitter.getOrCreateName(arg) << " = "
- << emitter.getOrCreateName(operand) << ";\n";
- }
-
- os << "goto ";
- if (!(emitter.hasBlockLabel(falseSuccessor))) {
- return condBranchOp.emitOpError()
- << "unable to find label for successor block";
- }
- os << emitter.getOrCreateName(falseSuccessor) << ";\n";
- os << "}";
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, mlir::func::CallOp callOp) {
- if (failed(emitter.emitAssignPrefix(*callOp.getOperation())))
- return failure();
-
- raw_ostream &os = emitter.ostream();
- os << callOp.getCallee() << "(";
- if (failed(emitter.emitOperands(*callOp.getOperation())))
- return failure();
- os << ")";
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, emitc::CallOpaqueOp callOp) {
- raw_ostream &os = emitter.ostream();
- Operation &op = *callOp.getOperation();
-
- if (failed(emitter.emitAssignPrefix(op)))
- return failure();
- os << callOp.getCallee();
-
- auto emitArgs = [&](Attribute attr) -> LogicalResult {
- if (auto t = llvm::dyn_cast<IntegerAttr>(attr)) {
- // Index attributes are treated specially as operand index.
- if (t.getType().isIndex()) {
- int64_t idx = t.getInt();
- if ((idx < 0) || (idx >= op.getNumOperands()))
- return op.emitOpError("invalid operand index");
- if (!emitter.hasValueInScope(op.getOperand(idx)))
- return op.emitOpError("operand ")
- << idx << "'s value not defined in scope";
- os << emitter.getOrCreateName(op.getOperand(idx));
- return success();
- }
- }
- if (failed(emitter.emitAttribute(op.getLoc(), attr)))
- return failure();
-
- return success();
- };
-
- if (callOp.getTemplateArgs()) {
- os << "<";
- if (failed(interleaveCommaWithError(*callOp.getTemplateArgs(), os, emitArgs)))
- return failure();
- os << ">";
- }
-
- os << "(";
-
- LogicalResult emittedArgs =
- callOp.getArgs() ? interleaveCommaWithError(*callOp.getArgs(), os, emitArgs)
- : emitter.emitOperands(op);
- if (failed(emittedArgs))
- return failure();
- os << ")";
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- emitc::ApplyOp applyOp) {
- raw_ostream &os = emitter.ostream();
- Operation &op = *applyOp.getOperation();
-
- if (failed(emitter.emitAssignPrefix(op)))
- return failure();
- os << applyOp.getApplicableOperator();
- os << emitter.getOrCreateName(applyOp.getOperand());
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, emitc::CastOp castOp) {
- raw_ostream &os = emitter.ostream();
- Operation &op = *castOp.getOperation();
-
- if (failed(emitter.emitAssignPrefix(op)))
- return failure();
- os << "(";
- if (failed(emitter.emitType(op.getLoc(), op.getResult(0).getType())))
- return failure();
- os << ") ";
- os << emitter.getOrCreateName(castOp.getOperand());
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter,
- emitc::IncludeOp includeOp) {
- raw_ostream &os = emitter.ostream();
-
- os << "#include ";
- if (includeOp.getIsStandardInclude())
- os << "<" << includeOp.getInclude() << ">";
- else
- os << "\"" << includeOp.getInclude() << "\"";
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, scf::ForOp forOp) {
-
- raw_indented_ostream &os = emitter.ostream();
-
- OperandRange operands = forOp.getInitArgs();
- Block::BlockArgListType iterArgs = forOp.getRegionIterArgs();
- Operation::result_range results = forOp.getResults();
-
- if (!emitter.shouldDeclareVariablesAtTop()) {
- for (OpResult result : results) {
- if (failed(emitter.emitVariableDeclaration(result,
- /*trailingSemicolon=*/true)))
- return failure();
- }
- }
-
- for (auto [iterArg, operand] : llvm::zip_equal(iterArgs, operands)) {
- if (failed(emitter.emitType(forOp.getLoc(), iterArg.getType())))
- return failure();
- os << " " << emitter.getOrCreateName(iterArg) << " = ";
- os << emitter.getOrCreateName(operand) << ";";
- os << "\n";
- }
-
- os << "for (";
- if (failed(
- emitter.emitType(forOp.getLoc(), forOp.getInductionVar().getType())))
- return failure();
- os << " ";
- os << emitter.getOrCreateName(forOp.getInductionVar());
- os << " = ";
- os << emitter.getOrCreateName(forOp.getLowerBound());
- os << "; ";
- os << emitter.getOrCreateName(forOp.getInductionVar());
- os << " < ";
- os << emitter.getOrCreateName(forOp.getUpperBound());
- os << "; ";
- os << emitter.getOrCreateName(forOp.getInductionVar());
- os << " += ";
- os << emitter.getOrCreateName(forOp.getStep());
- os << ") {\n";
- os.indent();
-
- Region &forRegion = forOp.getRegion();
- auto regionOps = forRegion.getOps();
-
- // We skip the trailing yield op because this updates the result variables
- // of the for op in the generated code. Instead we update the iterArgs at
- // the end of a loop iteration and set the result variables after the for
- // loop.
- for (auto it = regionOps.begin(); std::next(it) != regionOps.end(); ++it) {
- if (failed(emitter.emitOperation(*it, /*trailingSemicolon=*/true)))
- return failure();
- }
-
- Operation *yieldOp = forRegion.getBlocks().front().getTerminator();
- // Copy yield operands into iterArgs at the end of a loop iteration.
- for (auto [iterArg, operand] : llvm::zip_equal(iterArgs, yieldOp->getOperands())) {
- os << emitter.getOrCreateName(iterArg) << " = "
- << emitter.getOrCreateName(operand) << ";\n";
- }
-
- os.unindent() << "}";
-
- // Copy iterArgs into results after the for loop.
- for (auto [result, iterArg] : llvm::zip_equal(results, iterArgs)) {
- os << "\n"
- << emitter.getOrCreateName(result) << " = "
- << emitter.getOrCreateName(iterArg) << ";";
- }
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, scf::IfOp ifOp) {
- raw_indented_ostream &os = emitter.ostream();
-
- if (!emitter.shouldDeclareVariablesAtTop()) {
- for (OpResult result : ifOp.getResults()) {
- if (failed(emitter.emitVariableDeclaration(result,
- /*trailingSemicolon=*/true)))
- return failure();
- }
- }
-
- os << "if (";
- if (failed(emitter.emitOperands(*ifOp.getOperation())))
- return failure();
- os << ") {\n";
- os.indent();
-
- Region &thenRegion = ifOp.getThenRegion();
- for (Operation &op : thenRegion.getOps()) {
- // Note: This prints a superfluous semicolon if the terminating yield op has
- // zero results.
- if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/true)))
- return failure();
- }
-
- os.unindent() << "}";
-
- Region &elseRegion = ifOp.getElseRegion();
- if (!elseRegion.empty()) {
- os << " else {\n";
- os.indent();
-
- for (Operation &op : elseRegion.getOps()) {
- // Note: This prints a superfluous semicolon if the terminating yield op
- // has zero results.
- if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/true)))
- return failure();
- }
-
- os.unindent() << "}";
- }
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, scf::YieldOp yieldOp) {
- raw_ostream &os = emitter.ostream();
- Operation &parentOp = *yieldOp.getOperation()->getParentOp();
-
- if (yieldOp.getNumOperands() != parentOp.getNumResults()) {
- return yieldOp.emitError("number of operands does not to match the number "
- "of the parent op's results");
- }
-
- if (failed(interleaveWithError(
- llvm::zip_equal(parentOp.getResults(), yieldOp.getOperands()),
- [&](auto pair) -> LogicalResult {
- auto result = std::get<0>(pair);
- auto operand = std::get<1>(pair);
- os << emitter.getOrCreateName(result) << " = ";
-
- if (!emitter.hasValueInScope(operand))
- return yieldOp.emitError("operand value not in scope");
- os << emitter.getOrCreateName(operand);
- return success();
- },
- [&]() { os << ";\n"; })))
- return failure();
-
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, func::ReturnOp returnOp) {
- raw_ostream &os = emitter.ostream();
- os << "return";
- switch (returnOp.getNumOperands()) {
- case 0:
- return success();
- case 1:
- os << " " << emitter.getOrCreateName(returnOp.getOperand(0));
- return success(emitter.hasValueInScope(returnOp.getOperand(0)));
- default:
- os << " std::make_tuple(";
- if (failed(emitter.emitOperandsAndAttributes(*returnOp.getOperation())))
- return failure();
- os << ")";
- return success();
- }
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, ModuleOp moduleOp) {
- CppEmitter::Scope scope(emitter);
-
- for (Operation &op : moduleOp) {
- if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/false)))
- return failure();
- }
- return success();
-}
-
-static LogicalResult printOperation(CppEmitter &emitter, func::FuncOp functionOp) {
- // We need to declare variables at top if the function has multiple blocks.
- if (!emitter.shouldDeclareVariablesAtTop() &&
- functionOp.getBlocks().size() > 1) {
- return functionOp.emitOpError(
- "with multiple blocks needs variables declared at top");
- }
-
- CppEmitter::Scope scope(emitter);
- raw_indented_ostream &os = emitter.ostream();
- if (failed(emitter.emitTypes(functionOp.getLoc(),
- functionOp.getFunctionType().getResults())))
- return failure();
- os << " " << functionOp.getName();
-
- os << "(";
- if (failed(interleaveCommaWithError(
- functionOp.getArguments(), os,
- [&](BlockArgument arg) -> LogicalResult {
- if (failed(emitter.emitType(functionOp.getLoc(), arg.getType())))
- return failure();
- os << " " << emitter.getOrCreateName(arg);
- return success();
- })))
- return failure();
- os << ") {\n";
- os.indent();
- if (emitter.shouldDeclareVariablesAtTop()) {
- // Declare all variables that hold op results including those from nested
- // regions.
- WalkResult result =
- functionOp.walk<WalkOrder::PreOrder>([&](Operation *op) -> WalkResult {
- for (OpResult result : op->getResults()) {
- if (failed(emitter.emitVariableDeclaration(
- result, /*trailingSemicolon=*/true))) {
- return WalkResult(
- op->emitError("unable to declare result variable for op"));
- }
- }
- return WalkResult::advance();
- });
- if (result.wasInterrupted())
- return failure();
- }
-
- Region::BlockListType &blocks = functionOp.getBlocks();
- // Create label names for basic blocks.
- for (Block &block : blocks) {
- emitter.getOrCreateName(block);
- }
-
- // Declare variables for basic block arguments.
- for (auto it = std::next(blocks.begin()); it != blocks.end(); ++it) {
- Block &block = *it;
- for (BlockArgument &arg : block.getArguments()) {
- if (emitter.hasValueInScope(arg))
- return functionOp.emitOpError(" block argument #")
- << arg.getArgNumber() << " is out of scope";
- if (failed(
- emitter.emitType(block.getParentOp()->getLoc(), arg.getType()))) {
- return failure();
- }
- os << " " << emitter.getOrCreateName(arg) << ";\n";
- }
- }
-
- for (Block &block : blocks) {
- // Only print a label if there is more than one block.
- if (blocks.size() > 1 && !block.hasNoPredecessors()) {
- if (failed(emitter.emitLabel(block)))
- return failure();
- }
- for (Operation &op : block.getOperations()) {
- // When generating code for an scf.if or cf.cond_br op no semicolon needs
- // to be printed after the closing brace.
- // When generating code for an scf.for op, printing a trailing semicolon
- // is handled within the printOperation function.
- bool trailingSemicolon = !isa<scf::IfOp, scf::ForOp, cf::CondBranchOp>(op);
-
- if (failed(emitter.emitOperation(
- op, /*trailingSemicolon=*/trailingSemicolon)))
- return failure();
- }
- }
- os.unindent() << "}\n";
- return success();
-}
-
-CppEmitter::CppEmitter(raw_ostream &os, bool declareVariablesAtTop)
- : os(os), declareVariablesAtTop(declareVariablesAtTop) {
- valueInScopeCount.push(0);
- labelInScopeCount.push(0);
-}
-
-/// Return the existing or a new name for a Value.
-StringRef CppEmitter::getOrCreateName(Value val) {
- if (!valueMapper.count(val))
- valueMapper.insert(val, formatv("v{0}", ++valueInScopeCount.top()));
- return *valueMapper.begin(val);
-}
-
-/// Return the existing or a new label for a Block.
-StringRef CppEmitter::getOrCreateName(Block &block) {
- if (!blockMapper.count(&block))
- blockMapper.insert(&block, formatv("label{0}", ++labelInScopeCount.top()));
- return *blockMapper.begin(&block);
-}
-
-bool CppEmitter::shouldMapToUnsigned(IntegerType::SignednessSemantics val) {
- switch (val) {
- case IntegerType::Signless:
- return false;
- case IntegerType::Signed:
- return false;
- case IntegerType::Unsigned:
- return true;
- default:
- assert(false && "unsupported IntegerType");
- return false;
- }
-}
-
-bool CppEmitter::hasValueInScope(Value val) { return valueMapper.count(val); }
-
-bool CppEmitter::hasBlockLabel(Block &block) {
- return blockMapper.count(&block);
-}
-
-LogicalResult CppEmitter::emitAttribute(Location loc, Attribute attr) {
- auto printInt = [&](APInt val, bool isUnsigned) {
- if (val.getBitWidth() == 1) {
- if (val.getBoolValue())
- os << "true";
- else
- os << "false";
- } else {
- SmallString<128> strValue;
- val.toString(strValue, 10, !isUnsigned, false);
- os << strValue;
- }
- };
-
- auto printFloat = [&](APFloat val) {
- if (val.isFinite()) {
- SmallString<128> strValue;
- // Use default values of toString except don't truncate zeros.
- val.toString(strValue, 0, 0, false);
- switch (llvm::APFloatBase::SemanticsToEnum(val.getSemantics())) {
- case llvm::APFloatBase::S_IEEEsingle:
- os << "(float)";
- break;
- case llvm::APFloatBase::S_IEEEdouble:
- os << "(double)";
- break;
- default:
- break;
- };
- os << strValue;
- } else if (val.isNaN()) {
- os << "NAN";
- } else if (val.isInfinity()) {
- if (val.isNegative())
- os << "-";
- os << "INFINITY";
- }
- };
-
- // Print floating point attributes.
- if (auto fAttr = llvm::dyn_cast<FloatAttr>(attr)) {
- printFloat(fAttr.getValue());
- return success();
- }
- if (auto dense = llvm::dyn_cast<DenseFPElementsAttr>(attr)) {
- os << '{';
- interleaveComma(dense, os, [&](APFloat val) { printFloat(val); });
- os << '}';
- return success();
- }
-
- // Print integer attributes.
- if (auto iAttr = llvm::dyn_cast<IntegerAttr>(attr)) {
- if (auto iType = llvm::dyn_cast<IntegerType>(iAttr.getType())) {
- printInt(iAttr.getValue(), shouldMapToUnsigned(iType.getSignedness()));
- return success();
- }
- if (auto iType = llvm::dyn_cast<IndexType>(iAttr.getType())) {
- printInt(iAttr.getValue(), false);
- return success();
- }
- }
- if (auto dense = llvm::dyn_cast<DenseIntElementsAttr>(attr)) {
- if (auto iType = llvm::dyn_cast<IntegerType>(dense.getType()
- .cast<TensorType>()
- .getElementType()
- )) {
- os << '{';
- interleaveComma(dense, os, [&](APInt val) {
- printInt(val, shouldMapToUnsigned(iType.getSignedness()));
- });
- os << '}';
- return success();
- }
- if (auto iType = llvm::dyn_cast<IndexType>(dense.getType()
- .cast<TensorType>()
- .getElementType()
- )) {
- os << '{';
- interleaveComma(dense, os, [&](APInt val) { printInt(val, false); });
- os << '}';
- return success();
- }
- }
-
- // Print opaque attributes.
- if (auto oAttr = llvm::dyn_cast<emitc::OpaqueAttr>(attr)) {
- os << oAttr.getValue();
- return success();
- }
-
- // Print symbolic reference attributes.
- if (auto sAttr = llvm::dyn_cast<SymbolRefAttr>(attr)) {
- if (sAttr.getNestedReferences().size() > 1)
- return emitError(loc, "attribute has more than 1 nested reference");
- os << sAttr.getRootReference().getValue();
- return success();
- }
-
- // Print type attributes.
- if (auto type = llvm::dyn_cast<TypeAttr>(attr))
- return emitType(loc, type.getValue());
-
- return emitError(loc, "cannot emit attribute: ") << attr;
-}
-
-LogicalResult CppEmitter::emitOperands(Operation &op) {
- auto emitOperandName = [&](Value result) -> LogicalResult {
- if (!hasValueInScope(result))
- return op.emitOpError() << "operand value not in scope";
- os << getOrCreateName(result);
- return success();
- };
- return interleaveCommaWithError(op.getOperands(), os, emitOperandName);
-}
-
-LogicalResult
-CppEmitter::emitOperandsAndAttributes(Operation &op,
- ArrayRef<StringRef> exclude) {
- if (failed(emitOperands(op)))
- return failure();
- // Insert comma in between operands and non-filtered attributes if needed.
- if (op.getNumOperands() > 0) {
- for (NamedAttribute attr : op.getAttrs()) {
- if (!llvm::is_contained(exclude, attr.getName().strref())) {
- os << ", ";
- break;
- }
- }
- }
- // Emit attributes.
- auto emitNamedAttribute = [&](NamedAttribute attr) -> LogicalResult {
- if (llvm::is_contained(exclude, attr.getName().strref()))
- return success();
- os << "/* " << attr.getName() << " */";
- if (failed(emitAttribute(op.getLoc(), attr.getValue())))
- return failure();
- return success();
- };
- return interleaveCommaWithError(op.getAttrs(), os, emitNamedAttribute);
-}
-
-LogicalResult CppEmitter::emitVariableAssignment(OpResult result) {
- if (!hasValueInScope(result)) {
- return result.getDefiningOp()->emitOpError(
- "result variable for the operation has not been declared");
- }
- os << getOrCreateName(result) << " = ";
- return success();
-}
-
-LogicalResult CppEmitter::emitVariableDeclaration(OpResult result,
- bool trailingSemicolon) {
- if (hasValueInScope(result)) {
- return result.getDefiningOp()->emitError(
- "result variable for the operation already declared");
- }
- if (failed(emitType(result.getOwner()->getLoc(), result.getType())))
- return failure();
- os << " " << getOrCreateName(result);
- if (trailingSemicolon)
- os << ";\n";
- return success();
-}
-
-LogicalResult CppEmitter::emitAssignPrefix(Operation &op) {
- switch (op.getNumResults()) {
- case 0:
- break;
- case 1: {
- OpResult result = op.getResult(0);
- if (shouldDeclareVariablesAtTop()) {
- if (failed(emitVariableAssignment(result)))
- return failure();
- } else {
- if (failed(emitVariableDeclaration(result, /*trailingSemicolon=*/false)))
- return failure();
- os << " = ";
- }
- break;
- }
- default:
- if (!shouldDeclareVariablesAtTop()) {
- for (OpResult result : op.getResults()) {
- if (failed(emitVariableDeclaration(result, /*trailingSemicolon=*/true)))
- return failure();
- }
- }
- os << "std::tie(";
- interleaveComma(op.getResults(), os,
- [&](Value result) { os << getOrCreateName(result); });
- os << ") = ";
- }
- return success();
-}
-
-LogicalResult CppEmitter::emitLabel(Block &block) {
- if (!hasBlockLabel(block))
- return block.getParentOp()->emitError("label for block not found");
- os << getOrCreateName(block) << ":\n";
- return success();
-}
-
-LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
- LogicalResult status =
- llvm::TypeSwitch<Operation *, LogicalResult>(&op)
- // EmitC ops.
- .Case<emitc::ApplyOp, emitc::CallOpaqueOp, emitc::CastOp, emitc::ConstantOp,
- emitc::IncludeOp, emitc::VariableOp>(
- [&](auto op) { return printOperation(*this, op); })
- // SCF ops.
- .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
- [&](auto op) { return printOperation(*this, op); })
- // Standard ops.
- .Case<cf::BranchOp, mlir::func::CallOp, cf::CondBranchOp, mlir::func::ConstantOp,
- func::FuncOp, ModuleOp, func::ReturnOp>(
- [&](auto op) { return printOperation(*this, op); })
- .Default([&](Operation *) {
- return op.emitOpError("unable to find printer for op");
- });
-
- if (failed(status))
- return failure();
- os << (trailingSemicolon ? ";\n" : "\n");
- return success();
-}
-
-LogicalResult CppEmitter::emitType(Location loc, Type type) {
- if (auto iType = llvm::dyn_cast<IntegerType>(type)) {
- switch (iType.getWidth()) {
- case 1:
- return (os << "bool"), success();
- case 8:
- case 16:
- case 32:
- case 64:
- if (shouldMapToUnsigned(iType.getSignedness()))
- return (os << "uint" << iType.getWidth() << "_t"), success();
- else
- return (os << "int" << iType.getWidth() << "_t"), success();
- default:
- return emitError(loc, "cannot emit integer type ") << type;
- }
- }
- if (auto fType = llvm::dyn_cast<FloatType>(type)) {
- switch (fType.getWidth()) {
- case 32:
- return (os << "float"), success();
- case 64:
- return (os << "double"), success();
- default:
- return emitError(loc, "cannot emit float type ") << type;
- }
- }
- if (auto iType = llvm::dyn_cast<IndexType>(type))
- return (os << "size_t"), success();
- if (auto tType = llvm::dyn_cast<TensorType>(type)) {
- if (!tType.hasRank())
- return emitError(loc, "cannot emit unranked tensor type");
- if (!tType.hasStaticShape())
- return emitError(loc, "cannot emit tensor type with non static shape");
- os << "Tensor<";
- if (failed(emitType(loc, tType.getElementType())))
- return failure();
- auto shape = tType.getShape();
- for (auto dimSize : shape) {
- os << ", ";
- os << dimSize;
- }
- os << ">";
- return success();
- }
- if (auto tType = llvm::dyn_cast<TupleType>(type))
- return emitTupleType(loc, tType.getTypes());
- if (auto oType = llvm::dyn_cast<emitc::OpaqueType>(type)) {
- os << oType.getValue();
- return success();
- }
- if (auto pType = llvm::dyn_cast<emitc::PointerType>(type)) {
- if (failed(emitType(loc, pType.getPointee())))
- return failure();
- os << "*";
- return success();
- }
- return emitError(loc, "cannot emit type ") << type;
-}
-
-LogicalResult CppEmitter::emitTypes(Location loc, ArrayRef<Type> types) {
- switch (types.size()) {
- case 0:
- os << "void";
- return success();
- case 1:
- return emitType(loc, types.front());
- default:
- return emitTupleType(loc, types);
- }
-}
-
-LogicalResult CppEmitter::emitTupleType(Location loc, ArrayRef<Type> types) {
- os << "std::tuple<";
- if (failed(interleaveCommaWithError(
- types, os, [&](Type type) { return emitType(loc, type); })))
- return failure();
- os << ">";
- return success();
-}
-
-LogicalResult emitc::translateToCpp(Operation *op, raw_ostream &os,
- bool declareVariablesAtTop) {
- CppEmitter emitter(os, declareVariablesAtTop);
- return emitter.emitOperation(*op, /*trailingSemicolon=*/false);
-}
-// clang-format on
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/add.mlir b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/add.mlir
index d70a583..20aa594 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/add.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/add.mlir
@@ -2,7 +2,8 @@
// CHECK: #include "iree/vm/ops.h"
vm.module @add_module {
- // CHECK: static iree_status_t add_module_add_1(iree_vm_stack_t* v1, add_module_t* v2, add_module_state_t* v3, int32_t v4, int32_t v5, int32_t* v6, int32_t* v7) {
+ // TODO(simon-camp): Add back check for static modifier
+ // CHECK: iree_status_t add_module_add_1(iree_vm_stack_t* v1, struct add_module_t* v2, struct add_module_state_t* v3, int32_t v4, int32_t v5, int32_t* v6, int32_t* v7) {
vm.func @add_1(%arg0 : i32, %arg1 : i32) -> (i32, i32) {
// CHECK-NEXT: int32_t v8;
// CHECK-NEXT: int32_t v9;
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/calling_convention.mlir b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/calling_convention.mlir
index 54881da..d8e8861 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/calling_convention.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/calling_convention.mlir
@@ -1,8 +1,10 @@
// RUN: iree-compile --compile-mode=vm --output-format=vm-c %s | FileCheck %s
+// TODO(simon-camp): Add back check for static modifiers
+
// CHECK: #include "iree/vm/ops.h"
vm.module @calling_convention_test {
- // CHECK: static iree_status_t calling_convention_test_no_in_no_return(iree_vm_stack_t* v1, calling_convention_test_t* v2, calling_convention_test_state_t* v3) {
+ // CHECK: iree_status_t calling_convention_test_no_in_no_return(iree_vm_stack_t* v1, struct calling_convention_test_t* v2, struct calling_convention_test_state_t* v3) {
vm.func @no_in_no_return() -> () {
// CHECK-NEXT: iree_status_t v4;
// CHECK-NEXT: v4 = iree_ok_status();
@@ -10,7 +12,7 @@
vm.return
}
- // CHECK: static iree_status_t calling_convention_test_i32_in_no_return(iree_vm_stack_t* v1, calling_convention_test_t* v2, calling_convention_test_state_t* v3, int32_t v4) {
+ // CHECK: iree_status_t calling_convention_test_i32_in_no_return(iree_vm_stack_t* v1, struct calling_convention_test_t* v2, struct calling_convention_test_state_t* v3, int32_t v4) {
vm.func @i32_in_no_return(%arg0 : i32) -> () {
// CHECK-NEXT: iree_status_t v5;
// CHECK-NEXT: v5 = iree_ok_status();
@@ -18,7 +20,7 @@
vm.return
}
- // CHECK: static iree_status_t calling_convention_test_no_in_i32_return(iree_vm_stack_t* v1, calling_convention_test_t* v2, calling_convention_test_state_t* v3, int32_t* v4) {
+ // CHECK: iree_status_t calling_convention_test_no_in_i32_return(iree_vm_stack_t* v1, struct calling_convention_test_t* v2, struct calling_convention_test_state_t* v3, int32_t* v4) {
vm.func @no_in_i32_return() -> (i32) {
// CHECK-NEXT: int32_t v5;
// CHECK-NEXT: iree_status_t v6;
@@ -30,7 +32,7 @@
vm.return %0 : i32
}
- // CHECK: static iree_status_t calling_convention_test_i32_in_i32_return(iree_vm_stack_t* v1, calling_convention_test_t* v2, calling_convention_test_state_t* v3, int32_t v4, int32_t* v5) {
+ // CHECK: iree_status_t calling_convention_test_i32_in_i32_return(iree_vm_stack_t* v1, struct calling_convention_test_t* v2, struct calling_convention_test_state_t* v3, int32_t v4, int32_t* v5) {
vm.func @i32_in_i32_return(%arg0 : i32) -> (i32) {
// CHECK-NEXT: int32_t v6;
// CHECK-NEXT: iree_status_t v7;
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/constant_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/constant_ops.mlir
index f79cf0c..3f58fe8 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/constant_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/constant_ops.mlir
@@ -8,12 +8,12 @@
// Check the generated state struct
// CHECK-LABEL: struct rodata_ops_state_t {
- // CHECK-NEXT: iree_allocator_t allocator;
- // CHECK-NEXT: uint8_t rwdata[1];
- // CHECK-NEXT: iree_vm_ref_t refs[1];
- // CHECK-NEXT: iree_vm_buffer_t rodata_buffers[2];
- // CHECK-NEXT: iree_vm_function_t imports[1];
- // CHECK-NEXT: };
+ // CHECK-SAME: iree_allocator_t allocator;
+ // CHECK-SAME: uint8_t rwdata[1];
+ // CHECK-SAME: iree_vm_ref_t refs[1];
+ // CHECK-SAME: iree_vm_buffer_t rodata_buffers[2];
+ // CHECK-SAME: iree_vm_function_t imports[1];
+ // CHECK-SAME: };
// We mark the rodata ops public in this test to explicitly prevent DCE from
// deleting them.
@@ -46,7 +46,7 @@
// -----
vm.module @constant_ops {
- // CHECK-LABEL: constant_ops_neg_constant
+ // CHECK: constant_ops_neg_constant([[ARGS:[^)]*]]) {
vm.func @neg_constant() -> i32 {
// CHECK: int32_t [[CONST:[^ ]*]];
// CHECK-NOT: [[CONST]] = 4294967292;
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/control_flow.mlir b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/control_flow.mlir
index 3e76198..c00e50d 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/control_flow.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/control_flow.mlir
@@ -11,7 +11,8 @@
vm.return %e : i32
}
}
-// CHECK: static iree_status_t control_flow_module_control_flow_test(iree_vm_stack_t* v1, control_flow_module_t* v2, control_flow_module_state_t* v3, int32_t [[A:[^ ]*]], int32_t [[COND:[^ ]*]], int32_t* [[RESULT:[^ ]*]]) {
+// TODO(simon-camp): Add back check for static modifier
+// CHECK: iree_status_t control_flow_module_control_flow_test(iree_vm_stack_t* v1, struct control_flow_module_t* v2, struct control_flow_module_state_t* v3, int32_t [[A:[^ ]*]], int32_t [[COND:[^ ]*]], int32_t* [[RESULT:[^ ]*]]) {
// CHECK-NEXT: int32_t [[COND_NZ:[^ ]*]];
// CHECK-NEXT: bool [[COND_BOOL:[^ ]*]];
// CHECK-NEXT: int32_t [[B:[^ ]*]];
diff --git a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/global_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/global_ops.mlir
index ddb731d..fd56741 100644
--- a/compiler/src/iree/compiler/Dialect/VM/Target/C/test/global_ops.mlir
+++ b/compiler/src/iree/compiler/Dialect/VM/Target/C/test/global_ops.mlir
@@ -1,23 +1,22 @@
// RUN: iree-compile --compile-mode=vm --output-format=vm-c --iree-vm-c-module-optimize=false %s | FileCheck %s
+// TODO(simon-camp): Add back check for static modifiers
+
vm.module @global_ops {
// check the generated state struct
// CHECK-LABEL: struct global_ops_state_t {
- // CHECK-NEXT: iree_allocator_t allocator;
- // CHECK-NEXT: uint8_t rwdata[8];
- // CHECK-NEXT: iree_vm_ref_t refs[1];
- // CHECK-NEXT: iree_vm_buffer_t rodata_buffers[1];
- // CHECK-NEXT: iree_vm_function_t imports[1];
- // CHECK-NEXT: };
+ // CHECK-SAME: iree_allocator_t allocator;
+ // CHECK-SAME: uint8_t rwdata[8];
+ // CHECK-SAME: iree_vm_ref_t refs[1];
+ // CHECK-SAME: iree_vm_buffer_t rodata_buffers[1];
+ // CHECK-SAME: iree_vm_function_t imports[1];
+ // CHECK-SAME: };
vm.global.i32 mutable @c42 = 42 : i32
vm.global.i32 mutable @c107_mut = 107 : i32
- // Skip forward declarations
- // CHECK: DEFINE FUNCTIONS
-
vm.export @test_global_load_i32
- // CHECK: static iree_status_t global_ops_test_global_load_i32(
+ // CHECK: iree_status_t global_ops_test_global_load_i32([[ARGS:[^)]*]]) {
vm.func @test_global_load_i32() -> i32 {
// CHECK-NEXT: uint8_t* v5;
// CHECK-NEXT: int32_t v6;
@@ -29,7 +28,7 @@
}
vm.export @test_global_store_i32
- // CHECK: static iree_status_t global_ops_test_global_store_i32(
+ // CHECK: iree_status_t global_ops_test_global_store_i32([[ARGS:[^)]*]]) {
vm.func @test_global_store_i32() -> i32 {
// CHECK-NEXT: int32_t v5;
// CHECK-NEXT: uint8_t* v6;
diff --git a/runtime/src/iree/vm/ops_emitc.h b/runtime/src/iree/vm/ops_emitc.h
index 4ae8c8e..1bacddd 100644
--- a/runtime/src/iree/vm/ops_emitc.h
+++ b/runtime/src/iree/vm/ops_emitc.h
@@ -40,12 +40,6 @@
#define EMITC_STRUCT_PTR_MEMBER_ASSIGN(struct, member, value) \
(struct)->member = (value)
-// Create a typdef struct
-#define EMITC_TYPEDEF_STRUCT(typename, body) \
- typedef struct { \
- body \
- } typename;
-
// Get an array element
#define EMITC_ARRAY_ELEMENT(array, index) (array)[index]
