3249de8c4f
This pull request fixes #11083. The problem was that recursive type definitions were not properly handled for enum types, leading to problems with LLVM's metadata "uniquing". This bug has already been fixed for struct types some time ago (#9658) but I seem to have forgotten about enums back then. I added the offending code from issue #11083 as a test case.
581 lines
16 KiB
C++
581 lines
16 KiB
C++
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
#include "rustllvm.h"
|
|
#include "llvm/Object/Archive.h"
|
|
|
|
//===----------------------------------------------------------------------===
|
|
//
|
|
// This file defines alternate interfaces to core functions that are more
|
|
// readily callable by Rust's FFI.
|
|
//
|
|
//===----------------------------------------------------------------------===
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::sys;
|
|
using namespace llvm::object;
|
|
|
|
const char *LLVMRustError;
|
|
|
|
extern "C" LLVMMemoryBufferRef
|
|
LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
|
|
LLVMMemoryBufferRef MemBuf = NULL;
|
|
LLVMCreateMemoryBufferWithContentsOfFile(Path, &MemBuf,
|
|
const_cast<char **>(&LLVMRustError));
|
|
return MemBuf;
|
|
}
|
|
|
|
extern "C" const char *LLVMRustGetLastError(void) {
|
|
return LLVMRustError;
|
|
}
|
|
|
|
extern "C" void
|
|
LLVMRustSetNormalizedTarget(LLVMModuleRef M, const char *triple) {
|
|
unwrap(M)->setTargetTriple(Triple::normalize(triple));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMRustConstSmallInt(LLVMTypeRef IntTy, unsigned N,
|
|
LLVMBool SignExtend) {
|
|
return LLVMConstInt(IntTy, (unsigned long long)N, SignExtend);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMRustConstInt(LLVMTypeRef IntTy,
|
|
unsigned N_hi,
|
|
unsigned N_lo,
|
|
LLVMBool SignExtend) {
|
|
unsigned long long N = N_hi;
|
|
N <<= 32;
|
|
N |= N_lo;
|
|
return LLVMConstInt(IntTy, N, SignExtend);
|
|
}
|
|
|
|
extern "C" void LLVMRustPrintPassTimings() {
|
|
raw_fd_ostream OS (2, false); // stderr.
|
|
TimerGroup::printAll(OS);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M,
|
|
const char* Name,
|
|
LLVMTypeRef FunctionTy) {
|
|
return wrap(unwrap(M)->getOrInsertFunction(Name,
|
|
unwrap<FunctionType>(FunctionTy)));
|
|
}
|
|
|
|
extern "C" LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) {
|
|
return wrap(Type::getMetadataTy(*unwrap(C)));
|
|
}
|
|
|
|
extern "C" void LLVMAddFunctionAttrString(LLVMValueRef fn, const char *Name) {
|
|
unwrap<Function>(fn)->addFnAttr(Name);
|
|
}
|
|
|
|
|
|
extern "C" void LLVMAddReturnAttribute(LLVMValueRef Fn, LLVMAttribute PA) {
|
|
Function *A = unwrap<Function>(Fn);
|
|
AttrBuilder B(PA);
|
|
A->addAttributes(AttributeSet::ReturnIndex,
|
|
AttributeSet::get(A->getContext(), AttributeSet::ReturnIndex, B));
|
|
}
|
|
|
|
extern "C" void LLVMRemoveReturnAttribute(LLVMValueRef Fn, LLVMAttribute PA) {
|
|
Function *A = unwrap<Function>(Fn);
|
|
AttrBuilder B(PA);
|
|
A->removeAttributes(AttributeSet::ReturnIndex,
|
|
AttributeSet::get(A->getContext(), AttributeSet::ReturnIndex, B));
|
|
}
|
|
|
|
extern "C" void LLVMAddColdAttribute(LLVMValueRef Fn) {
|
|
Function *A = unwrap<Function>(Fn);
|
|
A->addAttribute(AttributeSet::FunctionIndex, Attribute::Cold);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicLoad(LLVMBuilderRef B,
|
|
LLVMValueRef source,
|
|
const char* Name,
|
|
AtomicOrdering order,
|
|
unsigned alignment) {
|
|
LoadInst* li = new LoadInst(unwrap(source),0);
|
|
li->setVolatile(true);
|
|
li->setAtomic(order);
|
|
li->setAlignment(alignment);
|
|
return wrap(unwrap(B)->Insert(li, Name));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicStore(LLVMBuilderRef B,
|
|
LLVMValueRef val,
|
|
LLVMValueRef target,
|
|
AtomicOrdering order,
|
|
unsigned alignment) {
|
|
StoreInst* si = new StoreInst(unwrap(val),unwrap(target));
|
|
si->setVolatile(true);
|
|
si->setAtomic(order);
|
|
si->setAlignment(alignment);
|
|
return wrap(unwrap(B)->Insert(si));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B,
|
|
LLVMValueRef target,
|
|
LLVMValueRef old,
|
|
LLVMValueRef source,
|
|
AtomicOrdering order) {
|
|
return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(target), unwrap(old),
|
|
unwrap(source), order));
|
|
}
|
|
extern "C" LLVMValueRef LLVMBuildAtomicFence(LLVMBuilderRef B, AtomicOrdering order) {
|
|
return wrap(unwrap(B)->CreateFence(order));
|
|
}
|
|
|
|
extern "C" void LLVMSetDebug(int Enabled) {
|
|
#ifndef NDEBUG
|
|
DebugFlag = Enabled;
|
|
#endif
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMInlineAsm(LLVMTypeRef Ty,
|
|
char *AsmString,
|
|
char *Constraints,
|
|
LLVMBool HasSideEffects,
|
|
LLVMBool IsAlignStack,
|
|
unsigned Dialect) {
|
|
return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString,
|
|
Constraints, HasSideEffects,
|
|
IsAlignStack, (InlineAsm::AsmDialect) Dialect));
|
|
}
|
|
|
|
typedef DIBuilder* DIBuilderRef;
|
|
|
|
template<typename DIT>
|
|
DIT unwrapDI(LLVMValueRef ref) {
|
|
return DIT(ref ? unwrap<MDNode>(ref) : NULL);
|
|
}
|
|
|
|
extern "C" DIBuilderRef LLVMDIBuilderCreate(LLVMModuleRef M) {
|
|
return new DIBuilder(*unwrap(M));
|
|
}
|
|
|
|
extern "C" void LLVMDIBuilderDispose(DIBuilderRef Builder) {
|
|
delete Builder;
|
|
}
|
|
|
|
extern "C" void LLVMDIBuilderFinalize(DIBuilderRef Builder) {
|
|
Builder->finalize();
|
|
}
|
|
|
|
extern "C" void LLVMDIBuilderCreateCompileUnit(
|
|
DIBuilderRef Builder,
|
|
unsigned Lang,
|
|
const char* File,
|
|
const char* Dir,
|
|
const char* Producer,
|
|
bool isOptimized,
|
|
const char* Flags,
|
|
unsigned RuntimeVer,
|
|
const char* SplitName) {
|
|
Builder->createCompileUnit(Lang, File, Dir, Producer, isOptimized,
|
|
Flags, RuntimeVer, SplitName);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateFile(
|
|
DIBuilderRef Builder,
|
|
const char* Filename,
|
|
const char* Directory) {
|
|
return wrap(Builder->createFile(Filename, Directory));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateSubroutineType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef File,
|
|
LLVMValueRef ParameterTypes) {
|
|
return wrap(Builder->createSubroutineType(
|
|
unwrapDI<DIFile>(File),
|
|
unwrapDI<DIArray>(ParameterTypes)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateFunction(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
const char* LinkageName,
|
|
LLVMValueRef File,
|
|
unsigned LineNo,
|
|
LLVMValueRef Ty,
|
|
bool isLocalToUnit,
|
|
bool isDefinition,
|
|
unsigned ScopeLine,
|
|
unsigned Flags,
|
|
bool isOptimized,
|
|
LLVMValueRef Fn,
|
|
LLVMValueRef TParam,
|
|
LLVMValueRef Decl) {
|
|
return wrap(Builder->createFunction(
|
|
unwrapDI<DIScope>(Scope), Name, LinkageName,
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
unwrapDI<DICompositeType>(Ty), isLocalToUnit, isDefinition, ScopeLine,
|
|
Flags, isOptimized,
|
|
unwrap<Function>(Fn),
|
|
unwrapDI<MDNode*>(TParam),
|
|
unwrapDI<MDNode*>(Decl)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateBasicType(
|
|
DIBuilderRef Builder,
|
|
const char* Name,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
unsigned Encoding) {
|
|
return wrap(Builder->createBasicType(
|
|
Name, SizeInBits,
|
|
AlignInBits, Encoding));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreatePointerType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef PointeeTy,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
const char* Name) {
|
|
return wrap(Builder->createPointerType(
|
|
unwrapDI<DIType>(PointeeTy), SizeInBits, AlignInBits, Name));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateStructType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
unsigned Flags,
|
|
LLVMValueRef DerivedFrom,
|
|
LLVMValueRef Elements,
|
|
unsigned RunTimeLang,
|
|
LLVMValueRef VTableHolder,
|
|
const char *UniqueId) {
|
|
return wrap(Builder->createStructType(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNumber,
|
|
SizeInBits,
|
|
AlignInBits,
|
|
Flags,
|
|
unwrapDI<DIType>(DerivedFrom),
|
|
unwrapDI<DIArray>(Elements),
|
|
RunTimeLang,
|
|
unwrapDI<DIType>(VTableHolder),
|
|
UniqueId));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateMemberType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNo,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
uint64_t OffsetInBits,
|
|
unsigned Flags,
|
|
LLVMValueRef Ty) {
|
|
return wrap(Builder->createMemberType(
|
|
unwrapDI<DIDescriptor>(Scope), Name,
|
|
unwrapDI<DIFile>(File), LineNo,
|
|
SizeInBits, AlignInBits, OffsetInBits, Flags,
|
|
unwrapDI<DIType>(Ty)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateLexicalBlock(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
LLVMValueRef File,
|
|
unsigned Line,
|
|
unsigned Col) {
|
|
return wrap(Builder->createLexicalBlock(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
unwrapDI<DIFile>(File), Line, Col));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateLocalVariable(
|
|
DIBuilderRef Builder,
|
|
unsigned Tag,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNo,
|
|
LLVMValueRef Ty,
|
|
bool AlwaysPreserve,
|
|
unsigned Flags,
|
|
unsigned ArgNo) {
|
|
return wrap(Builder->createLocalVariable(Tag,
|
|
unwrapDI<DIDescriptor>(Scope), Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNo,
|
|
unwrapDI<DIType>(Ty), AlwaysPreserve, Flags, ArgNo));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateArrayType(
|
|
DIBuilderRef Builder,
|
|
uint64_t Size,
|
|
uint64_t AlignInBits,
|
|
LLVMValueRef Ty,
|
|
LLVMValueRef Subscripts) {
|
|
return wrap(Builder->createArrayType(Size, AlignInBits,
|
|
unwrapDI<DIType>(Ty),
|
|
unwrapDI<DIArray>(Subscripts)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateVectorType(
|
|
DIBuilderRef Builder,
|
|
uint64_t Size,
|
|
uint64_t AlignInBits,
|
|
LLVMValueRef Ty,
|
|
LLVMValueRef Subscripts) {
|
|
return wrap(Builder->createVectorType(Size, AlignInBits,
|
|
unwrapDI<DIType>(Ty),
|
|
unwrapDI<DIArray>(Subscripts)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderGetOrCreateSubrange(
|
|
DIBuilderRef Builder,
|
|
int64_t Lo,
|
|
int64_t Count) {
|
|
return wrap(Builder->getOrCreateSubrange(Lo, Count));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderGetOrCreateArray(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef* Ptr,
|
|
unsigned Count) {
|
|
return wrap(Builder->getOrCreateArray(
|
|
ArrayRef<Value*>(reinterpret_cast<Value**>(Ptr), Count)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Val,
|
|
LLVMValueRef VarInfo,
|
|
LLVMBasicBlockRef InsertAtEnd) {
|
|
return wrap(Builder->insertDeclare(
|
|
unwrap(Val),
|
|
unwrapDI<DIVariable>(VarInfo),
|
|
unwrap(InsertAtEnd)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderInsertDeclareBefore(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Val,
|
|
LLVMValueRef VarInfo,
|
|
LLVMValueRef InsertBefore) {
|
|
return wrap(Builder->insertDeclare(
|
|
unwrap(Val),
|
|
unwrapDI<DIVariable>(VarInfo),
|
|
unwrap<Instruction>(InsertBefore)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateEnumerator(
|
|
DIBuilderRef Builder,
|
|
const char* Name,
|
|
uint64_t Val)
|
|
{
|
|
return wrap(Builder->createEnumerator(Name, Val));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateEnumerationType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
LLVMValueRef Elements,
|
|
LLVMValueRef ClassType)
|
|
{
|
|
return wrap(Builder->createEnumerationType(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNumber,
|
|
SizeInBits,
|
|
AlignInBits,
|
|
unwrapDI<DIArray>(Elements),
|
|
unwrapDI<DIType>(ClassType)));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateUnionType(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
unsigned Flags,
|
|
LLVMValueRef Elements,
|
|
unsigned RunTimeLang,
|
|
const char* UniqueId)
|
|
{
|
|
return wrap(Builder->createUnionType(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNumber,
|
|
SizeInBits,
|
|
AlignInBits,
|
|
Flags,
|
|
unwrapDI<DIArray>(Elements),
|
|
RunTimeLang,
|
|
UniqueId));
|
|
}
|
|
|
|
extern "C" void LLVMSetUnnamedAddr(LLVMValueRef Value, LLVMBool Unnamed) {
|
|
unwrap<GlobalValue>(Value)->setUnnamedAddr(Unnamed);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateTemplateTypeParameter(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef Ty,
|
|
LLVMValueRef File,
|
|
unsigned LineNo,
|
|
unsigned ColumnNo)
|
|
{
|
|
return wrap(Builder->createTemplateTypeParameter(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIType>(Ty),
|
|
unwrapDI<MDNode*>(File),
|
|
LineNo,
|
|
ColumnNo));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateOpDeref(LLVMTypeRef IntTy)
|
|
{
|
|
return LLVMConstInt(IntTy, DIBuilder::OpDeref, true);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateOpPlus(LLVMTypeRef IntTy)
|
|
{
|
|
return LLVMConstInt(IntTy, DIBuilder::OpPlus, true);
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateComplexVariable(
|
|
DIBuilderRef Builder,
|
|
unsigned Tag,
|
|
LLVMValueRef Scope,
|
|
const char *Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNo,
|
|
LLVMValueRef Ty,
|
|
LLVMValueRef* AddrOps,
|
|
unsigned AddrOpsCount,
|
|
unsigned ArgNo)
|
|
{
|
|
llvm::ArrayRef<llvm::Value*> addr_ops((llvm::Value**)AddrOps, AddrOpsCount);
|
|
|
|
return wrap(Builder->createComplexVariable(
|
|
Tag,
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNo,
|
|
unwrapDI<DIType>(Ty),
|
|
addr_ops,
|
|
ArgNo
|
|
));
|
|
}
|
|
|
|
extern "C" LLVMValueRef LLVMDIBuilderCreateNameSpace(
|
|
DIBuilderRef Builder,
|
|
LLVMValueRef Scope,
|
|
const char* Name,
|
|
LLVMValueRef File,
|
|
unsigned LineNo)
|
|
{
|
|
return wrap(Builder->createNameSpace(
|
|
unwrapDI<DIDescriptor>(Scope),
|
|
Name,
|
|
unwrapDI<DIFile>(File),
|
|
LineNo));
|
|
}
|
|
|
|
extern "C" void LLVMDICompositeTypeSetTypeArray(
|
|
LLVMValueRef CompositeType,
|
|
LLVMValueRef TypeArray)
|
|
{
|
|
unwrapDI<DICompositeType>(CompositeType).setTypeArray(unwrapDI<DIArray>(TypeArray));
|
|
}
|
|
|
|
extern "C" char *LLVMTypeToString(LLVMTypeRef Type) {
|
|
std::string s;
|
|
llvm::raw_string_ostream os(s);
|
|
unwrap<llvm::Type>(Type)->print(os);
|
|
return strdup(os.str().data());
|
|
}
|
|
|
|
extern "C" bool
|
|
LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc, size_t len) {
|
|
Module *Dst = unwrap(dst);
|
|
MemoryBuffer* buf = MemoryBuffer::getMemBufferCopy(StringRef(bc, len));
|
|
std::string Err;
|
|
Module *Src = llvm::getLazyBitcodeModule(buf, Dst->getContext(), &Err);
|
|
if (Src == NULL) {
|
|
LLVMRustError = Err.c_str();
|
|
delete buf;
|
|
return false;
|
|
}
|
|
|
|
if (Linker::LinkModules(Dst, Src, Linker::DestroySource, &Err)) {
|
|
LLVMRustError = Err.c_str();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
extern "C" void*
|
|
LLVMRustOpenArchive(char *path) {
|
|
OwningPtr<MemoryBuffer> buf;
|
|
error_code err = MemoryBuffer::getFile(path, buf);
|
|
if (err) {
|
|
LLVMRustError = err.message().c_str();
|
|
return NULL;
|
|
}
|
|
Archive *ret = new Archive(buf.take(), err);
|
|
if (err) {
|
|
LLVMRustError = err.message().c_str();
|
|
return NULL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
extern "C" const char*
|
|
LLVMRustArchiveReadSection(Archive *ar, char *name, size_t *size) {
|
|
for (Archive::child_iterator child = ar->begin_children(),
|
|
end = ar->end_children();
|
|
child != end; ++child) {
|
|
StringRef sect_name;
|
|
error_code err = child->getName(sect_name);
|
|
if (err) continue;
|
|
if (sect_name.trim(" ") == name) {
|
|
StringRef buf = child->getBuffer();
|
|
*size = buf.size();
|
|
return buf.data();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
extern "C" void
|
|
LLVMRustDestroyArchive(Archive *ar) {
|
|
delete ar;
|
|
}
|