[mlir] LLVM dialect: Generate conversions between EnumAttrCase and LLVM API

[ftynse]

Summary

MLIR materializes various enumeration-based LLVM IR operands as enumeration
attributes using ODS. This requires bidirectional conversion between different
but very similar enums, currently hardcoded. Extend the ODS modeling of
LLVM-specific enumeration attributes to include the name of the corresponding
enum in the LLVM C++ API as well as the names of specific enumerants. Use this
new information to automatically generate the conversion functions between enum
attributes and LLVM API enums in the two-way conversion between the LLVM
dialect and LLVM IR proper.

Use the generated conversion functions for Linkage attributes as an example.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[antiagainst]

This should be deprecated in favor of https://reviews.llvm.org/D73362?

[ftynse]

This is a follow-up to that.

[ftynse]

rebase

[flaub]

Great, once this lands I can go add the missing volatile attribute to the new atomic ops.

[merge_guards_bot]

Unit tests: fail. 62346 tests passed, 1 failed and 839 were skipped.

failed: libc++.std/containers/sequences/array/array_creation/to_array.fail.cpp

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[antiagainst]

In D73468#1849667, @ftynse wrote:

This is a follow-up to that.

Oh, sorry, wasn't checking carefully. :)

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

66–67

We've have quite a few *Sym here. What about adding some documentation for them (potentially with a good example)?

83–91

Same here.

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

292

"to LLVM IR" to be specific. LLVM can mean both the C++ API and the IR.

[ftynse]

Split "from" and "to" conversion generation and added more doc as requested.

Without the splitting, it would generate functions that eneded up being unused
by the respective conversions, leading to warnings.

[merge_guards_bot]

Unit tests: fail. 62354 tests passed, 1 failed and 839 were skipped.

failed: libc++.std/containers/sequences/array/array_creation/to_array.fail.cpp

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMOps.h.inc -gen-op-decls)
 mlir_tablegen(LLVMOps.cpp.inc -gen-op-defs)
 mlir_tablegen(LLVMOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(LLVMOpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRLLVMOpsIncGen)
 
 add_mlir_dialect(NVVMOps NVVMOps)
 add_mlir_dialect(ROCDLOps ROCDLOps)
 
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMConversions.inc -gen-llvmir-conversions)
+mlir_tablegen(LLVMConversionEnumsToLLVM.inc -gen-enum-to-llvmir-conversions)
+mlir_tablegen(LLVMConversionEnumsFromLLVM.inc -gen-enum-from-llvmir-conversions)
 add_public_tablegen_target(MLIRLLVMConversionsIncGen)
 set(LLVM_TARGET_DEFINITIONS NVVMOps.td)
 mlir_tablegen(NVVMConversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRNVVMConversionsIncGen)
 set(LLVM_TARGET_DEFINITIONS ROCDLOps.td)
 mlir_tablegen(ROCDLConversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRROCDLConversionsIncGen)

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 
 // Base class for LLVM intrinsics operation. It is the same as an LLVM_Op
 // but the operation has a ".intr." element in the prefix becoming
 // "llvm.intr.*".
 class LLVM_IntrOp<string mnemonic, list<OpTrait> traits = []> :
     LLVM_Op<"intr."#mnemonic, traits>;
 
 // Case of the LLVM enum attribute backed by I64Attr with customized string
 // representation that corresponds to what is visible in the textual IR form.
-class LLVM_EnumAttrCase<string cppSym, string irSym, int val> :
-    I64EnumAttrCase<cppSym, val, irSym>;
+// The parameters are as follows:
+//   - `cppSym`: name of the C++ enumerant for this case in MLIR API;
+//   - `irSym`: keyword used in the custom form of MLIR operation;
+//   - `llvmSym`: name of the C++ enumerant for this case in LLVM API.
+// For example, `LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage">` is usable
+// as `<MlirEnumName>::Weak` in MLIR API, `WeakAnyLinkage` in LLVM API and
+// is printed/parsed as `weak` in MLIR custom textual format.
+class LLVM_EnumAttrCase<string cppSym, string irSym, string llvmSym, int val> :
+    I64EnumAttrCase<cppSym, val, irSym> {
+
+  // The name of the equivalent enumerant in LLVM.
+  string llvmEnumerant = llvmSym;
+}
 
 // LLVM enum attribute backed by I64Attr with string representation
 // corresponding to what is visible in the textual IR form.
-class LLVM_EnumAttr<string name, string description,
+// The parameters are as follows:
+//   - `name`: name of the C++ enum class in MLIR API;
+//   - `llvmName`: name of the C++ enum in LLVM API;
+//   - `description`: textual description for documentation purposes;
+//   - `cases`: list of enum cases.
+// For example, `LLVM_EnumAttr<Linkage, "::llvm::GlobalValue::LinkageTypes`
+// produces `mlir::LLVM::Linkage` enum class in MLIR API that corresponds to (a
+// subset of) values in the `llvm::GlobalValue::LinkageTypes` in LLVM API.
+class LLVM_EnumAttr<string name, string llvmName, string description,
                     list<LLVM_EnumAttrCase> cases> :
-    I64EnumAttr<name, description, cases>;
+    I64EnumAttr<name, description, cases> {
+
+  // The equivalent enum class name in LLVM.
+  string llvmClassName = llvmName;
+}
 
 #endif  // LLVMIR_OP_BASE

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 // Auxiliary operations (do not appear in LLVM IR but necessary for the dialect
 // to work correctly).
 ////////////////////////////////////////////////////////////////////////////////
 
 // Linkage attribute is used on functions and globals. The order follows that of
 // https://llvm.org/docs/LangRef.html#linkage-types. The names are equivalent to
 // visible names in the IR rather than to enum values names in llvm::GlobalValue
 // since the latter is easier to change.
-def LinkagePrivate             : LLVM_EnumAttrCase<"Private", "private", 0>;
-def LinkageInternal            : LLVM_EnumAttrCase<"Internal", "internal", 1>;
-def LinkageAvailableExternally : LLVM_EnumAttrCase<"AvailableExternally",
-                                                   "available_externally", 2>;
-def LinkageLinkonce            : LLVM_EnumAttrCase<"Linkonce", "linkonce", 3>;
-def LinkageWeak                : LLVM_EnumAttrCase<"Weak", "weak", 4>;
-def LinkageCommon              : LLVM_EnumAttrCase<"Common", "common", 5>;
-def LinkageAppending           : LLVM_EnumAttrCase<"Appending", "appending", 6>;
-def LinkageExternWeak          : LLVM_EnumAttrCase<"ExternWeak",
-                                                   "extern_weak", 7>;
-def LinkageLinkonceODR         : LLVM_EnumAttrCase<"LinkonceODR",
-                                                   "linkonce_odr", 8>;
-def LinkageWeakODR             : LLVM_EnumAttrCase<"WeakODR", "weak_odr", 9>;
-def LinkageExternal            : LLVM_EnumAttrCase<"External", "external", 10>;
+def LinkagePrivate
+    : LLVM_EnumAttrCase<"Private", "private", "PrivateLinkage", 0>;
+def LinkageInternal
+    : LLVM_EnumAttrCase<"Internal", "internal", "InternalLinkage", 1>;
+def LinkageAvailableExternally
+    : LLVM_EnumAttrCase<"AvailableExternally", "available_externally",
+                        "AvailableExternallyLinkage", 2>;
+def LinkageLinkonce
+    : LLVM_EnumAttrCase<"Linkonce", "linkonce", "LinkOnceAnyLinkage", 3>;
+def LinkageWeak
+    : LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage", 4>;
+def LinkageCommon
+    : LLVM_EnumAttrCase<"Common", "common", "CommonLinkage", 5>;
+def LinkageAppending
+    : LLVM_EnumAttrCase<"Appending", "appending", "AppendingLinkage", 6>;
+def LinkageExternWeak
+   : LLVM_EnumAttrCase<"ExternWeak", "extern_weak", "ExternalWeakLinkage", 7>;
+def LinkageLinkonceODR
+    : LLVM_EnumAttrCase<"LinkonceODR", "linkonce_odr", "LinkOnceODRLinkage", 8>;
+def LinkageWeakODR
+    : LLVM_EnumAttrCase<"WeakODR", "weak_odr", "WeakODRLinkage", 9>;
+def LinkageExternal
+    : LLVM_EnumAttrCase<"External", "external", "ExternalLinkage", 10>;
+
 def Linkage : LLVM_EnumAttr<
     "Linkage",
+    "::llvm::GlobalValue::LinkageTypes",
     "LLVM linkage types",
     [LinkagePrivate, LinkageInternal, LinkageAvailableExternally,
      LinkageLinkonce, LinkageWeak, LinkageCommon, LinkageAppending,
      LinkageExternWeak, LinkageLinkonceODR, LinkageWeakODR, LinkageExternal]> {
   let cppNamespace = "::mlir::LLVM";
 }
 
 

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 #include "llvm/IR/Type.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
+#include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
+
 // Utility to print an LLVM value as a string for passing to emitError().
 // FIXME: Diagnostic should be able to natively handle types that have
 // operator << (raw_ostream&) defined.
 static std::string diag(llvm::Value &v) {
   std::string s;
   llvm::raw_string_ostream os(s);
   os << v;
   return os.str();
if (auto *ca = dyn_cast<llvm::ConstantAggregate>(value)) {
     }
 
     return DenseElementsAttr::get(outerType, values);
   }
 
   return nullptr;
 }
 
-/// Converts LLVM global variable linkage type into the LLVM dialect predicate.
-static LLVM::Linkage
-processLinkage(llvm::GlobalVariable::LinkageTypes linkage) {
-  switch (linkage) {
-  case llvm::GlobalValue::PrivateLinkage:
-    return LLVM::Linkage::Private;
-  case llvm::GlobalValue::InternalLinkage:
-    return LLVM::Linkage::Internal;
-  case llvm::GlobalValue::AvailableExternallyLinkage:
-    return LLVM::Linkage::AvailableExternally;
-  case llvm::GlobalValue::LinkOnceAnyLinkage:
-    return LLVM::Linkage::Linkonce;
-  case llvm::GlobalValue::WeakAnyLinkage:
-    return LLVM::Linkage::Weak;
-  case llvm::GlobalValue::CommonLinkage:
-    return LLVM::Linkage::Common;
-  case llvm::GlobalValue::AppendingLinkage:
-    return LLVM::Linkage::Appending;
-  case llvm::GlobalValue::ExternalWeakLinkage:
-    return LLVM::Linkage::ExternWeak;
-  case llvm::GlobalValue::LinkOnceODRLinkage:
-    return LLVM::Linkage::LinkonceODR;
-  case llvm::GlobalValue::WeakODRLinkage:
-    return LLVM::Linkage::WeakODR;
-  case llvm::GlobalValue::ExternalLinkage:
-    return LLVM::Linkage::External;
-  }
-
-  llvm_unreachable("unhandled linkage type");
-}
-
 GlobalOp Importer::processGlobal(llvm::GlobalVariable *GV) {
   auto it = globals.find(GV);
   if (it != globals.end())
     return it->second;
 
   OpBuilder b(module.getBody(), getGlobalInsertPt());
   Attribute valueAttr;
   if (GV->hasInitializer())
     valueAttr = getConstantAsAttr(GV->getInitializer());
   LLVMType type = processType(GV->getValueType());
   if (!type)
     return nullptr;
   GlobalOp op = b.create<GlobalOp>(
       UnknownLoc::get(context), type, GV->isConstant(),
-      processLinkage(GV->getLinkage()), GV->getName(), valueAttr);
+      convertLinkageFromLLVM(GV->getLinkage()), GV->getName(), valueAttr);
   if (GV->hasInitializer() && !valueAttr) {
     Region &r = op.getInitializerRegion();
     currentEntryBlock = b.createBlock(&r);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     Value v = processConstant(GV->getInitializer());
     if (!v)
       return nullptr;
     b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
+#include "mlir/Dialect/LLVMIR/LLVMConversionEnumsToLLVM.inc"
+
 /// Builds a constant of a sequential LLVM type `type`, potentially containing
 /// other sequential types recursively, from the individual constant values
 /// provided in `constants`. `shape` contains the number of elements in nested
 /// sequential types. Reports errors at `loc` and returns nullptr on error.
 static llvm::Constant *
 buildSequentialConstant(ArrayRef<llvm::Constant *> &constants,
                         ArrayRef<int64_t> shape, llvm::Type *type,
                         Location loc) {
LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
   for (auto &op : bb) {
     if (failed(convertOperation(op, builder)))
       return failure();
   }
 
   return success();
 }
 
-/// Convert the LLVM dialect linkage type to LLVM IR linkage type.
-llvm::GlobalVariable::LinkageTypes convertLinkageType(LLVM::Linkage linkage) {
-  switch (linkage) {
-  case LLVM::Linkage::Private:
-    return llvm::GlobalValue::PrivateLinkage;
-  case LLVM::Linkage::Internal:
-    return llvm::GlobalValue::InternalLinkage;
-  case LLVM::Linkage::AvailableExternally:
-    return llvm::GlobalValue::AvailableExternallyLinkage;
-  case LLVM::Linkage::Linkonce:
-    return llvm::GlobalValue::LinkOnceAnyLinkage;
-  case LLVM::Linkage::Weak:
-    return llvm::GlobalValue::WeakAnyLinkage;
-  case LLVM::Linkage::Common:
-    return llvm::GlobalValue::CommonLinkage;
-  case LLVM::Linkage::Appending:
-    return llvm::GlobalValue::AppendingLinkage;
-  case LLVM::Linkage::ExternWeak:
-    return llvm::GlobalValue::ExternalWeakLinkage;
-  case LLVM::Linkage::LinkonceODR:
-    return llvm::GlobalValue::LinkOnceODRLinkage;
-  case LLVM::Linkage::WeakODR:
-    return llvm::GlobalValue::WeakODRLinkage;
-  case LLVM::Linkage::External:
-    return llvm::GlobalValue::ExternalLinkage;
-  }
-  llvm_unreachable("unknown linkage type");
-}
-
 /// Create named global variables that correspond to llvm.mlir.global
 /// definitions.
 void ModuleTranslation::convertGlobals() {
   for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>()) {
     llvm::Type *type = op.getType().getUnderlyingType();
     llvm::Constant *cst = llvm::UndefValue::get(type);
     if (op.getValueOrNull()) {
       // String attributes are treated separately because they cannot appear as
if (op.getValueOrNull()) {
           emitError(op.getLoc(), "unemittable constant value");
           return;
         }
       }
       ReturnOp ret = cast<ReturnOp>(initializer->getTerminator());
       cst = cast<llvm::Constant>(valueMapping.lookup(ret.getOperand(0)));
     }
 
-    auto linkage = convertLinkageType(op.linkage());
+    auto linkage = convertLinkageToLLVM(op.linkage());
     bool anyExternalLinkage =
         (linkage == llvm::GlobalVariable::ExternalLinkage ||
          linkage == llvm::GlobalVariable::ExternalWeakLinkage);
     auto addrSpace = op.addr_space().getLimitedValue();
     auto *var = new llvm::GlobalVariable(
         *llvmModule, type, op.constant(), linkage,
         anyExternalLinkage ? nullptr : cst, op.sym_name(),
         /*InsertBefore=*/nullptr, llvm::GlobalValue::NotThreadLocal, addrSpace);

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

 //===- LLVMIRConversionGen.cpp - MLIR LLVM IR builder generator -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file uses tablegen definitions of the LLVM IR Dialect operations to
 // generate the code building the LLVM IR from it.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Support/LogicalResult.h"
+#include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"

 static bool emitBuilders(const RecordKeeper &recordKeeper, raw_ostream &os) {
   for (const auto *def : recordKeeper.getAllDerivedDefinitions("LLVM_OpBase")) {
     if (!emitOneBuilder(*def, os))
       return true;
   }
   return false;
 }
 
+namespace {
+// Wrapper class around a Tablegen definition of an LLVM enum attribute case.
+class LLVMEnumAttrCase : public tblgen::EnumAttrCase {
+public:
+  using tblgen::EnumAttrCase::EnumAttrCase;
+
+  // Constructs a case from a non LLVM-specific enum attribute case.
+  explicit LLVMEnumAttrCase(const tblgen::EnumAttrCase &other)
+      : tblgen::EnumAttrCase(&other.getDef()) {}
+
+  // Returns the C++ enumerant for the LLVM API.
+  StringRef getLLVMEnumerant() const {
+    return def->getValueAsString("llvmEnumerant");
+  }
+};
+
+// Wraper class around a Tablegen definition of an LLVM enum attribute.
+class LLVMEnumAttr : public tblgen::EnumAttr {
+public:
+  using tblgen::EnumAttr::EnumAttr;
+
+  // Returns the C++ enum name for the LLVM API.
+  StringRef getLLVMClassName() const {
+    return def->getValueAsString("llvmClassName");
+  }
+
+  // Returns all associated cases viewed as LLVM-specific enum cases.
+  std::vector<LLVMEnumAttrCase> getAllCases() const {
+    std::vector<LLVMEnumAttrCase> cases;
+
+    for (auto &c : tblgen::EnumAttr::getAllCases())
+      cases.push_back(LLVMEnumAttrCase(c));
+
+    return cases;
+  }
+};
+} // namespace
+
+// Emits conversion function "LLVMClass convertEnumToLLVM(Enum)" and containing
+// switch-based logic to convert from the MLIR LLVM dialect enum attribute case
+// (Enum) to the corresponding LLVM API enumerant
+static void emitOneEnumToConversion(const llvm::Record *record,
+                                    raw_ostream &os) {
+  LLVMEnumAttr enumAttr(record);
+  StringRef llvmClass = enumAttr.getLLVMClassName();
+  StringRef cppClassName = enumAttr.getEnumClassName();
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+
+  // Emit the function converting the enum attribute to its LLVM counterpart.
+  os << formatv("static {0} convert{1}ToLLVM({2}::{1} value) {{\n", llvmClass,
+                cppClassName, cppNamespace);
+  os << "  switch (value) {\n";
+
+  for (const auto &enumerant : enumAttr.getAllCases()) {
+    StringRef llvmEnumerant = enumerant.getLLVMEnumerant();
+    StringRef cppEnumerant = enumerant.getSymbol();
+    os << formatv("  case {0}::{1}::{2}:\n", cppNamespace, cppClassName,
+                  cppEnumerant);
+    os << formatv("    return {0}::{1};\n", llvmClass, llvmEnumerant);
+  }
+
+  os << "  }\n";
+  os << formatv("  llvm_unreachable(\"unknown {0} type\");\n",
+                enumAttr.getEnumClassName());
+  os << "}\n\n";
+}
+
+// Emits conversion function "Enum convertEnumFromLLVM(LLVMClass)" and
+// containing switch-based logic to convert from the LLVM API enumerant to MLIR
+// LLVM dialect enum attribute (Enum).
+static void emitOneEnumFromConversion(const llvm::Record *record,
+                                      raw_ostream &os) {
+  LLVMEnumAttr enumAttr(record);
+  StringRef llvmClass = enumAttr.getLLVMClassName();
+  StringRef cppClassName = enumAttr.getEnumClassName();
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+
+  // Emit the function converting the enum attribute from its LLVM counterpart.
+  os << formatv("static {0}::{1} convert{1}FromLLVM({2} value) {{\n",
+                cppNamespace, cppClassName, llvmClass);
+  os << "  switch (value) {\n";
+
+  for (const auto &enumerant : enumAttr.getAllCases()) {
+    StringRef llvmEnumerant = enumerant.getLLVMEnumerant();
+    StringRef cppEnumerant = enumerant.getSymbol();
+    os << formatv("  case {0}::{1}:\n", llvmClass, llvmEnumerant);
+    os << formatv("    return {0}::{1}::{2};\n", cppNamespace, cppClassName,
+                  cppEnumerant);
+  }
+
+  os << "  }\n";
+  os << formatv("  llvm_unreachable(\"unknown {0} type\");",
+                enumAttr.getLLVMClassName());
+  os << "}\n\n";
+}
+
+// Emits conversion functions between MLIR enum attribute case and corresponding
+// LLVM API enumerants for all registered LLVM dialect enum attributes.
+template <bool ConvertTo>
+static bool emitEnumConversionDefs(const RecordKeeper &recordKeeper,
+                                   raw_ostream &os) {
+  for (const auto *def : recordKeeper.getAllDerivedDefinitions("LLVM_EnumAttr"))
+    if (ConvertTo)
+      emitOneEnumToConversion(def, os);
+    else
+      emitOneEnumFromConversion(def, os);
+
+  return false;
+}
+
 static mlir::GenRegistration
     genLLVMIRConversions("gen-llvmir-conversions",
                          "Generate LLVM IR conversions", emitBuilders);
+
+static mlir::GenRegistration
+    genEnumToLLVMConversion("gen-enum-to-llvmir-conversions",
+                            "Generate conversions of EnumAttrs to LLVM IR",
+                            emitEnumConversionDefs</*ConvertTo=*/true>);
+
+static mlir::GenRegistration
+    genEnumFromLLVMConversion("gen-enum-from-llvmir-conversions",
+                              "Generate conversions of EnumAttrs from LLVM IR",
+                              emitEnumConversionDefs</*ConvertTo=*/false>);