[MLIR][LLVM] Expose type translator from LLVM to MLIR Type

[wsmoses]

Summary

This commit moves the type translator from LLVM to MLIR to a public header for use by external projects or other code.

Unlike a previous attempt (https://reviews.llvm.org/D104726), this patch moves the type conversion into separate files which remedies the linker error which was only caught by CI.

[wsmoses]

Fix cmake and spacing

[ftynse]

Try building with shared libraries (-DBUILD_SHARED_LIBS=On).

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

 
 #ifndef MLIR_TARGET_LLVMIR_MODULETRANSLATION_H
 #define MLIR_TARGET_LLVMIR_MODULETRANSLATION_H
 
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Target/LLVMIR/Export.h"
 #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h"
-#include "mlir/Target/LLVMIR/TypeTranslation.h"
+#include "mlir/Target/LLVMIR/TypeToLLVM.h"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 
 namespace llvm {
 class BasicBlock;
 class IRBuilderBase;
 class Function;

mlir/include/mlir/Target/LLVMIR/TypeFromLLVM.h

+//===- TypeFromLLVM.h - Translate types from LLVM to MLIR --*- C++ -*-===//
+//
+// 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 declares the type translation function going from MLIR LLVM dialect
+// to LLVM IR and back.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_LLVMIR_TYPEFROMLLVM_H
+#define MLIR_TARGET_LLVMIR_TYPEFROMLLVM_H
+
+#include <memory>
+
+namespace llvm {
+class DataLayout;
+class LLVMContext;
+class Type;
+} // namespace llvm
+
+namespace mlir {
+
+class Type;
+class MLIRContext;
+
+namespace LLVM {
+
+namespace detail {
+class TypeFromLLVMIRTranslatorImpl;
+} // namespace detail
+
+/// Utility class to translate LLVM IR types to the MLIR LLVM dialect. Stores
+/// the translation state, in particular any identified structure types that are
+/// reused across translations.
+class TypeFromLLVMIRTranslator {
+public:
+  TypeFromLLVMIRTranslator(MLIRContext &context);
+  ~TypeFromLLVMIRTranslator();
+
+  /// Translates the given LLVM IR type to the MLIR LLVM dialect.
+  Type translateType(llvm::Type *type);
+
+private:
+  /// Private implementation.
+  std::unique_ptr<detail::TypeFromLLVMIRTranslatorImpl> impl;
+};
+
+} // namespace LLVM
+} // namespace mlir
+
+#endif // MLIR_TARGET_LLVMIR_TYPEFROMLLVM_H

mlir/include/mlir/Target/LLVMIR/TypeToLLVM.h

-//===- TypeTranslation.h - Translate types between MLIR & LLVM --*- C++ -*-===//
+//===- TypeToLLVM.h - Translate types from MLIR to LLVM --*- C++ -*-===//
 //
 // 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 declares the type translation function going from MLIR LLVM dialect
 // to LLVM IR and back.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TARGET_LLVMIR_TYPETRANSLATION_H
-#define MLIR_TARGET_LLVMIR_TYPETRANSLATION_H
+#ifndef MLIR_TARGET_LLVMIR_TYPETOLLVM_H
+#define MLIR_TARGET_LLVMIR_TYPETOLLVM_H
 
 #include <memory>
 
 namespace llvm {
 class DataLayout;
 class LLVMContext;
 class Type;
 } // namespace llvm

 private:
   /// Private implementation.
   std::unique_ptr<detail::TypeToLLVMIRTranslatorImpl> impl;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
-#endif // MLIR_TARGET_LLVMIR_TYPETRANSLATION_H
+#endif // MLIR_TARGET_LLVMIR_TYPETOLLVM_H

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Support/MathExtras.h"
-#include "mlir/Target/LLVMIR/TypeTranslation.h"
+#include "mlir/Target/LLVMIR/TypeToLLVM.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace mlir::vector;
 
 // Helper to reduce vector type by one rank at front.
 static VectorType reducedVectorTypeFront(VectorType tp) {
   assert((tp.getRank() > 1) && "unlowerable vector type");

mlir/lib/Target/LLVMIR/CMakeLists.txt

 add_subdirectory(Dialect)
 
 set(LLVM_OPTIONAL_SOURCES
   ConvertFromLLVMIR.cpp
   ConvertToLLVMIR.cpp
   DebugTranslation.cpp
   ModuleTranslation.cpp
-  TypeTranslation.cpp
+  TypeToLLVM.cpp
+  TypeFromLLVM.cpp
   )
 
 
 add_mlir_translation_library(MLIRTargetLLVMIRExport
   DebugTranslation.cpp
   ModuleTranslation.cpp
-  TypeTranslation.cpp
+  TypeToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   Core
   FrontendOpenMP
   TransformUtils
 
   LINK_LIBS PUBLIC
   MLIRLLVMIR
   MLIROpenACC
   MLIROpenMP
   MLIRLLVMIRTransforms
   MLIRTranslation
   )
 
 add_mlir_translation_library(MLIRToLLVMIRTranslationRegistration
   ConvertToLLVMIR.cpp
+  TypeToLLVM.cpp
 
   LINK_LIBS PUBLIC
   MLIRArmNeonToLLVMIRTranslation
   MLIRArmSVEToLLVMIRTranslation
   MLIRAMXToLLVMIRTranslation
   MLIRX86VectorToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRNVVMToLLVMIRTranslation
   MLIROpenACCToLLVMIRTranslation
   MLIROpenMPToLLVMIRTranslation
   MLIRROCDLToLLVMIRTranslation
   )
 
 add_mlir_translation_library(MLIRTargetLLVMIRImport
   ConvertFromLLVMIR.cpp
+  TypeFromLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
 
   LINK_COMPONENTS
   Core
   IRReader
 
   LINK_LIBS PUBLIC
   MLIRLLVMIR
   MLIRTranslation
+  MLIRTargetLLVMIRExport
   )

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Target/LLVMIR/Import.h"
+#include "mlir/Target/LLVMIR/TypeFromLLVM.h"
 #include "mlir/Translation.h"
 
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"

 // 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();
 }
 
-namespace mlir {
-namespace LLVM {
-namespace detail {
-/// Support for translating LLVM IR types to MLIR LLVM dialect types.
-class TypeFromLLVMIRTranslatorImpl {
-public:
-  /// Constructs a class creating types in the given MLIR context.
-  TypeFromLLVMIRTranslatorImpl(MLIRContext &context) : context(context) {}
-
-  /// Translates the given type.
-  Type translateType(llvm::Type *type) {
-    if (knownTranslations.count(type))
-      return knownTranslations.lookup(type);
-
-    Type translated =
-        llvm::TypeSwitch<llvm::Type *, Type>(type)
-            .Case<llvm::ArrayType, llvm::FunctionType, llvm::IntegerType,
-                  llvm::PointerType, llvm::StructType, llvm::FixedVectorType,
-                  llvm::ScalableVectorType>(
-                [this](auto *type) { return this->translate(type); })
-            .Default([this](llvm::Type *type) {
-              return translatePrimitiveType(type);
-            });
-    knownTranslations.try_emplace(type, translated);
-    return translated;
-  }
-
-private:
-  /// Translates the given primitive, i.e. non-parametric in MLIR nomenclature,
-  /// type.
-  Type translatePrimitiveType(llvm::Type *type) {
-    if (type->isVoidTy())
-      return LLVM::LLVMVoidType::get(&context);
-    if (type->isHalfTy())
-      return Float16Type::get(&context);
-    if (type->isBFloatTy())
-      return BFloat16Type::get(&context);
-    if (type->isFloatTy())
-      return Float32Type::get(&context);
-    if (type->isDoubleTy())
-      return Float64Type::get(&context);
-    if (type->isFP128Ty())
-      return Float128Type::get(&context);
-    if (type->isX86_FP80Ty())
-      return Float80Type::get(&context);
-    if (type->isPPC_FP128Ty())
-      return LLVM::LLVMPPCFP128Type::get(&context);
-    if (type->isX86_MMXTy())
-      return LLVM::LLVMX86MMXType::get(&context);
-    if (type->isLabelTy())
-      return LLVM::LLVMLabelType::get(&context);
-    if (type->isMetadataTy())
-      return LLVM::LLVMMetadataType::get(&context);
-    llvm_unreachable("not a primitive type");
-  }
-
-  /// Translates the given array type.
-  Type translate(llvm::ArrayType *type) {
-    return LLVM::LLVMArrayType::get(translateType(type->getElementType()),
-                                    type->getNumElements());
-  }
-
-  /// Translates the given function type.
-  Type translate(llvm::FunctionType *type) {
-    SmallVector<Type, 8> paramTypes;
-    translateTypes(type->params(), paramTypes);
-    return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()),
-                                       paramTypes, type->isVarArg());
-  }
-
-  /// Translates the given integer type.
-  Type translate(llvm::IntegerType *type) {
-    return IntegerType::get(&context, type->getBitWidth());
-  }
-
-  /// Translates the given pointer type.
-  Type translate(llvm::PointerType *type) {
-    return LLVM::LLVMPointerType::get(translateType(type->getElementType()),
-                                      type->getAddressSpace());
-  }
-
-  /// Translates the given structure type.
-  Type translate(llvm::StructType *type) {
-    SmallVector<Type, 8> subtypes;
-    if (type->isLiteral()) {
-      translateTypes(type->subtypes(), subtypes);
-      return LLVM::LLVMStructType::getLiteral(&context, subtypes,
-                                              type->isPacked());
-    }
-
-    if (type->isOpaque())
-      return LLVM::LLVMStructType::getOpaque(type->getName(), &context);
-
-    LLVM::LLVMStructType translated =
-        LLVM::LLVMStructType::getIdentified(&context, type->getName());
-    knownTranslations.try_emplace(type, translated);
-    translateTypes(type->subtypes(), subtypes);
-    LogicalResult bodySet = translated.setBody(subtypes, type->isPacked());
-    assert(succeeded(bodySet) &&
-           "could not set the body of an identified struct");
-    (void)bodySet;
-    return translated;
-  }
-
-  /// Translates the given fixed-vector type.
-  Type translate(llvm::FixedVectorType *type) {
-    return LLVM::getFixedVectorType(translateType(type->getElementType()),
-                                    type->getNumElements());
-  }
-
-  /// Translates the given scalable-vector type.
-  Type translate(llvm::ScalableVectorType *type) {
-    return LLVM::LLVMScalableVectorType::get(
-        translateType(type->getElementType()), type->getMinNumElements());
-  }
-
-  /// Translates a list of types.
-  void translateTypes(ArrayRef<llvm::Type *> types,
-                      SmallVectorImpl<Type> &result) {
-    result.reserve(result.size() + types.size());
-    for (llvm::Type *type : types)
-      result.push_back(translateType(type));
-  }
-
-  /// Map of known translations. Serves as a cache and as recursion stopper for
-  /// translating recursive structs.
-  llvm::DenseMap<llvm::Type *, Type> knownTranslations;
-
-  /// The context in which MLIR types are created.
-  MLIRContext &context;
-};
-} // end namespace detail
-
-/// Utility class to translate LLVM IR types to the MLIR LLVM dialect. Stores
-/// the translation state, in particular any identified structure types that are
-/// reused across translations.
-class TypeFromLLVMIRTranslator {
-public:
-  TypeFromLLVMIRTranslator(MLIRContext &context);
-  ~TypeFromLLVMIRTranslator();
-
-  /// Translates the given LLVM IR type to the MLIR LLVM dialect.
-  Type translateType(llvm::Type *type);
-
-private:
-  /// Private implementation.
-  std::unique_ptr<detail::TypeFromLLVMIRTranslatorImpl> impl;
-};
-
-} // end namespace LLVM
-} // end namespace mlir
-
-LLVM::TypeFromLLVMIRTranslator::TypeFromLLVMIRTranslator(MLIRContext &context)
-    : impl(new detail::TypeFromLLVMIRTranslatorImpl(context)) {}
-
-LLVM::TypeFromLLVMIRTranslator::~TypeFromLLVMIRTranslator() {}
-
-Type LLVM::TypeFromLLVMIRTranslator::translateType(llvm::Type *type) {
-  return impl->translateType(type);
-}
-
 // Handles importing globals and functions from an LLVM module.
 namespace {
 class Importer {
 public:
   Importer(MLIRContext *context, ModuleOp module)
       : b(context), context(context), module(module),
         unknownLoc(FileLineColLoc::get(context, "imported-bitcode", 0, 0)),
         typeTranslator(*context) {

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h"
-#include "mlir/Target/LLVMIR/TypeTranslation.h"
+#include "mlir/Target/LLVMIR/TypeToLLVM.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"

mlir/lib/Target/LLVMIR/TypeFromLLVM.cpp

+//===- TypeFromLLVM.cpp - type translation from LLVM to MLIR IR -===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Target/LLVMIR/TypeFromLLVM.h"
+#include "mlir/Dialect/LLVMIR/LLVMTypes.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/MLIRContext.h"
+
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Type.h"
+
+using namespace mlir;
+
+namespace mlir {
+namespace LLVM {
+namespace detail {
+/// Support for translating LLVM IR types to MLIR LLVM dialect types.
+class TypeFromLLVMIRTranslatorImpl {
+public:
+  /// Constructs a class creating types in the given MLIR context.
+  TypeFromLLVMIRTranslatorImpl(MLIRContext &context) : context(context) {}
+
+  /// Translates the given type.
+  Type translateType(llvm::Type *type) {
+    if (knownTranslations.count(type))
+      return knownTranslations.lookup(type);
+
+    Type translated =
+        llvm::TypeSwitch<llvm::Type *, Type>(type)
+            .Case<llvm::ArrayType, llvm::FunctionType, llvm::IntegerType,
+                  llvm::PointerType, llvm::StructType, llvm::FixedVectorType,
+                  llvm::ScalableVectorType>(
+                [this](auto *type) { return this->translate(type); })
+            .Default([this](llvm::Type *type) {
+              return translatePrimitiveType(type);
+            });
+    knownTranslations.try_emplace(type, translated);
+    return translated;
+  }
+
+private:
+  /// Translates the given primitive, i.e. non-parametric in MLIR nomenclature,
+  /// type.
+  Type translatePrimitiveType(llvm::Type *type) {
+    if (type->isVoidTy())
+      return LLVM::LLVMVoidType::get(&context);
+    if (type->isHalfTy())
+      return Float16Type::get(&context);
+    if (type->isBFloatTy())
+      return BFloat16Type::get(&context);
+    if (type->isFloatTy())
+      return Float32Type::get(&context);
+    if (type->isDoubleTy())
+      return Float64Type::get(&context);
+    if (type->isFP128Ty())
+      return Float128Type::get(&context);
+    if (type->isX86_FP80Ty())
+      return Float80Type::get(&context);
+    if (type->isPPC_FP128Ty())
+      return LLVM::LLVMPPCFP128Type::get(&context);
+    if (type->isX86_MMXTy())
+      return LLVM::LLVMX86MMXType::get(&context);
+    if (type->isLabelTy())
+      return LLVM::LLVMLabelType::get(&context);
+    if (type->isMetadataTy())
+      return LLVM::LLVMMetadataType::get(&context);
+    llvm_unreachable("not a primitive type");
+  }
+
+  /// Translates the given array type.
+  Type translate(llvm::ArrayType *type) {
+    return LLVM::LLVMArrayType::get(translateType(type->getElementType()),
+                                    type->getNumElements());
+  }
+
+  /// Translates the given function type.
+  Type translate(llvm::FunctionType *type) {
+    SmallVector<Type, 8> paramTypes;
+    translateTypes(type->params(), paramTypes);
+    return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()),
+                                       paramTypes, type->isVarArg());
+  }
+
+  /// Translates the given integer type.
+  Type translate(llvm::IntegerType *type) {
+    return IntegerType::get(&context, type->getBitWidth());
+  }
+
+  /// Translates the given pointer type.
+  Type translate(llvm::PointerType *type) {
+    return LLVM::LLVMPointerType::get(translateType(type->getElementType()),
+                                      type->getAddressSpace());
+  }
+
+  /// Translates the given structure type.
+  Type translate(llvm::StructType *type) {
+    SmallVector<Type, 8> subtypes;
+    if (type->isLiteral()) {
+      translateTypes(type->subtypes(), subtypes);
+      return LLVM::LLVMStructType::getLiteral(&context, subtypes,
+                                              type->isPacked());
+    }
+
+    if (type->isOpaque())
+      return LLVM::LLVMStructType::getOpaque(type->getName(), &context);
+
+    LLVM::LLVMStructType translated =
+        LLVM::LLVMStructType::getIdentified(&context, type->getName());
+    knownTranslations.try_emplace(type, translated);
+    translateTypes(type->subtypes(), subtypes);
+    LogicalResult bodySet = translated.setBody(subtypes, type->isPacked());
+    assert(succeeded(bodySet) &&
+           "could not set the body of an identified struct");
+    (void)bodySet;
+    return translated;
+  }
+
+  /// Translates the given fixed-vector type.
+  Type translate(llvm::FixedVectorType *type) {
+    return LLVM::getFixedVectorType(translateType(type->getElementType()),
+                                    type->getNumElements());
+  }
+
+  /// Translates the given scalable-vector type.
+  Type translate(llvm::ScalableVectorType *type) {
+    return LLVM::LLVMScalableVectorType::get(
+        translateType(type->getElementType()), type->getMinNumElements());
+  }
+
+  /// Translates a list of types.
+  void translateTypes(ArrayRef<llvm::Type *> types,
+                      SmallVectorImpl<Type> &result) {
+    result.reserve(result.size() + types.size());
+    for (llvm::Type *type : types)
+      result.push_back(translateType(type));
+  }
+
+  /// Map of known translations. Serves as a cache and as recursion stopper for
+  /// translating recursive structs.
+  llvm::DenseMap<llvm::Type *, Type> knownTranslations;
+
+  /// The context in which MLIR types are created.
+  MLIRContext &context;
+};
+
+} // end namespace detail
+} // end namespace LLVM
+} // end namespace mlir
+
+LLVM::TypeFromLLVMIRTranslator::TypeFromLLVMIRTranslator(MLIRContext &context)
+    : impl(new detail::TypeFromLLVMIRTranslatorImpl(context)) {}
+
+LLVM::TypeFromLLVMIRTranslator::~TypeFromLLVMIRTranslator() {}
+
+Type LLVM::TypeFromLLVMIRTranslator::translateType(llvm::Type *type) {
+  return impl->translateType(type);
+}

mlir/lib/Target/LLVMIR/TypeToLLVM.cpp

-//===- TypeTranslation.cpp - type translation between MLIR LLVM & LLVM IR -===//
+//===- TypeToLLVM.cpp - type translation from MLIR to LLVM IR -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Target/LLVMIR/TypeTranslation.h"
+#include "mlir/Target/LLVMIR/TypeToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
private:
   llvm::LLVMContext &context;
 
   /// Map of known translation. This serves a double purpose: caches translation
   /// results to avoid repeated recursive calls and makes sure identified
   /// structs with the same name (that is, equal) are resolved to an existing
   /// type instead of creating a new type.
   llvm::DenseMap<Type, llvm::Type *> knownTranslations;
 };
+
 } // end namespace detail
 } // end namespace LLVM
 } // end namespace mlir
 
 LLVM::TypeToLLVMIRTranslator::TypeToLLVMIRTranslator(llvm::LLVMContext &context)
     : impl(new detail::TypeToLLVMIRTranslatorImpl(context)) {}
 
 LLVM::TypeToLLVMIRTranslator::~TypeToLLVMIRTranslator() {}