Auto merge of #38701 - karpinski:rustllvm-style, r=brson
Making code style consistent for src/rustllvm (#38688) Part of #38688 r? @brson
This commit is contained in:
bors
commit
6dcf51aae6
4 changed files with 1326 additions and 1592 deletions
|
|
@ -21,52 +21,51 @@ struct RustArchiveMember {
|
||||||
const char *name;
|
const char *name;
|
||||||
Archive::Child child;
|
Archive::Child child;
|
||||||
|
|
||||||
RustArchiveMember(): filename(NULL), name(NULL),
|
RustArchiveMember()
|
||||||
|
: filename(nullptr), name(nullptr),
|
||||||
#if LLVM_VERSION_GE(3, 8)
|
#if LLVM_VERSION_GE(3, 8)
|
||||||
child(NULL, NULL, NULL)
|
child(nullptr, nullptr, nullptr)
|
||||||
#else
|
#else
|
||||||
child(NULL, NULL)
|
child(nullptr, nullptr)
|
||||||
#endif
|
#endif
|
||||||
{}
|
{
|
||||||
|
}
|
||||||
~RustArchiveMember() {}
|
~RustArchiveMember() {}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
||||||
struct RustArchiveIterator {
|
struct RustArchiveIterator {
|
||||||
bool first;
|
bool first;
|
||||||
Archive::child_iterator cur;
|
Archive::child_iterator cur;
|
||||||
Archive::child_iterator end;
|
Archive::child_iterator end;
|
||||||
#if LLVM_VERSION_GE(3, 9)
|
#if LLVM_VERSION_GE(3, 9)
|
||||||
Error err;
|
Error err;
|
||||||
|
|
||||||
RustArchiveIterator() : first(true), err(Error::success()) { }
|
RustArchiveIterator() : first(true), err(Error::success()) {}
|
||||||
#else
|
#else
|
||||||
RustArchiveIterator() : first(true) { }
|
RustArchiveIterator() : first(true) {}
|
||||||
#endif
|
#endif
|
||||||
};
|
};
|
||||||
|
|
||||||
enum class LLVMRustArchiveKind {
|
enum class LLVMRustArchiveKind {
|
||||||
Other,
|
Other,
|
||||||
GNU,
|
GNU,
|
||||||
MIPS64,
|
MIPS64,
|
||||||
BSD,
|
BSD,
|
||||||
COFF,
|
COFF,
|
||||||
};
|
};
|
||||||
|
|
||||||
static Archive::Kind
|
static Archive::Kind from_rust(LLVMRustArchiveKind kind) {
|
||||||
from_rust(LLVMRustArchiveKind kind)
|
switch (kind) {
|
||||||
{
|
case LLVMRustArchiveKind::GNU:
|
||||||
switch (kind) {
|
return Archive::K_GNU;
|
||||||
case LLVMRustArchiveKind::GNU:
|
case LLVMRustArchiveKind::MIPS64:
|
||||||
return Archive::K_GNU;
|
return Archive::K_MIPS64;
|
||||||
case LLVMRustArchiveKind::MIPS64:
|
case LLVMRustArchiveKind::BSD:
|
||||||
return Archive::K_MIPS64;
|
return Archive::K_BSD;
|
||||||
case LLVMRustArchiveKind::BSD:
|
case LLVMRustArchiveKind::COFF:
|
||||||
return Archive::K_BSD;
|
return Archive::K_COFF;
|
||||||
case LLVMRustArchiveKind::COFF:
|
default:
|
||||||
return Archive::K_COFF;
|
llvm_unreachable("Bad ArchiveKind.");
|
||||||
default:
|
|
||||||
llvm_unreachable("Bad ArchiveKind.");
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -76,174 +75,166 @@ typedef Archive::Child *LLVMRustArchiveChildRef;
|
||||||
typedef Archive::Child const *LLVMRustArchiveChildConstRef;
|
typedef Archive::Child const *LLVMRustArchiveChildConstRef;
|
||||||
typedef RustArchiveIterator *LLVMRustArchiveIteratorRef;
|
typedef RustArchiveIterator *LLVMRustArchiveIteratorRef;
|
||||||
|
|
||||||
extern "C" LLVMRustArchiveRef
|
extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *path) {
|
||||||
LLVMRustOpenArchive(char *path) {
|
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or =
|
||||||
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or = MemoryBuffer::getFile(path,
|
MemoryBuffer::getFile(path, -1, false);
|
||||||
-1,
|
if (!buf_or) {
|
||||||
false);
|
LLVMRustSetLastError(buf_or.getError().message().c_str());
|
||||||
if (!buf_or) {
|
return nullptr;
|
||||||
LLVMRustSetLastError(buf_or.getError().message().c_str());
|
}
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
ErrorOr<std::unique_ptr<Archive>> archive_or =
|
ErrorOr<std::unique_ptr<Archive>> archive_or =
|
||||||
#else
|
#else
|
||||||
Expected<std::unique_ptr<Archive>> archive_or =
|
Expected<std::unique_ptr<Archive>> archive_or =
|
||||||
#endif
|
#endif
|
||||||
Archive::create(buf_or.get()->getMemBufferRef());
|
Archive::create(buf_or.get()->getMemBufferRef());
|
||||||
|
|
||||||
if (!archive_or) {
|
if (!archive_or) {
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
LLVMRustSetLastError(archive_or.getError().message().c_str());
|
LLVMRustSetLastError(archive_or.getError().message().c_str());
|
||||||
#else
|
#else
|
||||||
LLVMRustSetLastError(toString(archive_or.takeError()).c_str());
|
LLVMRustSetLastError(toString(archive_or.takeError()).c_str());
|
||||||
#endif
|
#endif
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
OwningBinary<Archive> *ret = new OwningBinary<Archive>(
|
OwningBinary<Archive> *ret = new OwningBinary<Archive>(
|
||||||
std::move(archive_or.get()), std::move(buf_or.get()));
|
std::move(archive_or.get()), std::move(buf_or.get()));
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef ar) { delete ar; }
|
||||||
LLVMRustDestroyArchive(LLVMRustArchiveRef ar) {
|
|
||||||
delete ar;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" LLVMRustArchiveIteratorRef
|
extern "C" LLVMRustArchiveIteratorRef
|
||||||
LLVMRustArchiveIteratorNew(LLVMRustArchiveRef ra) {
|
LLVMRustArchiveIteratorNew(LLVMRustArchiveRef ra) {
|
||||||
Archive *ar = ra->getBinary();
|
Archive *ar = ra->getBinary();
|
||||||
RustArchiveIterator *rai = new RustArchiveIterator();
|
RustArchiveIterator *rai = new RustArchiveIterator();
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
rai->cur = ar->child_begin();
|
rai->cur = ar->child_begin();
|
||||||
#else
|
#else
|
||||||
rai->cur = ar->child_begin(rai->err);
|
rai->cur = ar->child_begin(rai->err);
|
||||||
if (rai->err) {
|
if (rai->err) {
|
||||||
LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
|
LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
|
||||||
delete rai;
|
delete rai;
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
rai->end = ar->child_end();
|
rai->end = ar->child_end();
|
||||||
return rai;
|
return rai;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMRustArchiveChildConstRef
|
extern "C" LLVMRustArchiveChildConstRef
|
||||||
LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) {
|
LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) {
|
||||||
if (rai->cur == rai->end) return nullptr;
|
if (rai->cur == rai->end)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
// Advancing the iterator validates the next child, and this can
|
// Advancing the iterator validates the next child, and this can
|
||||||
// uncover an error. LLVM requires that we check all Errors,
|
// uncover an error. LLVM requires that we check all Errors,
|
||||||
// so we only advance the iterator if we actually need to fetch
|
// so we only advance the iterator if we actually need to fetch
|
||||||
// the next child.
|
// the next child.
|
||||||
// This means we must not advance the iterator in the *first* call,
|
// This means we must not advance the iterator in the *first* call,
|
||||||
// but instead advance it *before* fetching the child in all later calls.
|
// but instead advance it *before* fetching the child in all later calls.
|
||||||
if (!rai->first) {
|
if (!rai->first) {
|
||||||
++rai->cur;
|
++rai->cur;
|
||||||
#if LLVM_VERSION_GE(3, 9)
|
#if LLVM_VERSION_GE(3, 9)
|
||||||
if (rai->err) {
|
if (rai->err) {
|
||||||
LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
|
LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
|
||||||
#endif
|
|
||||||
} else {
|
|
||||||
rai->first = false;
|
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
} else {
|
||||||
|
rai->first = false;
|
||||||
|
}
|
||||||
|
|
||||||
if (rai->cur == rai->end) return nullptr;
|
if (rai->cur == rai->end)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
#if LLVM_VERSION_EQ(3, 8)
|
#if LLVM_VERSION_EQ(3, 8)
|
||||||
const ErrorOr<Archive::Child>* cur = rai->cur.operator->();
|
const ErrorOr<Archive::Child> *cur = rai->cur.operator->();
|
||||||
if (!*cur) {
|
if (!*cur) {
|
||||||
LLVMRustSetLastError(cur->getError().message().c_str());
|
LLVMRustSetLastError(cur->getError().message().c_str());
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
const Archive::Child &child = cur->get();
|
const Archive::Child &child = cur->get();
|
||||||
#else
|
#else
|
||||||
const Archive::Child &child = *rai->cur.operator->();
|
const Archive::Child &child = *rai->cur.operator->();
|
||||||
#endif
|
#endif
|
||||||
Archive::Child *ret = new Archive::Child(child);
|
Archive::Child *ret = new Archive::Child(child);
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef child) {
|
||||||
LLVMRustArchiveChildFree(LLVMRustArchiveChildRef child) {
|
delete child;
|
||||||
delete child;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef rai) {
|
||||||
LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef rai) {
|
delete rai;
|
||||||
delete rai;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" const char*
|
extern "C" const char *
|
||||||
LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef child, size_t *size) {
|
LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef child, size_t *size) {
|
||||||
#if LLVM_VERSION_GE(4, 0)
|
#if LLVM_VERSION_GE(4, 0)
|
||||||
Expected<StringRef> name_or_err = child->getName();
|
Expected<StringRef> name_or_err = child->getName();
|
||||||
if (!name_or_err) {
|
if (!name_or_err) {
|
||||||
// rustc_llvm currently doesn't use this error string, but it might be useful
|
// rustc_llvm currently doesn't use this error string, but it might be useful
|
||||||
// in the future, and in the mean time this tells LLVM that the error was
|
// in the future, and in the mean time this tells LLVM that the error was
|
||||||
// not ignored and that it shouldn't abort the process.
|
// not ignored and that it shouldn't abort the process.
|
||||||
LLVMRustSetLastError(toString(name_or_err.takeError()).c_str());
|
LLVMRustSetLastError(toString(name_or_err.takeError()).c_str());
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
ErrorOr<StringRef> name_or_err = child->getName();
|
ErrorOr<StringRef> name_or_err = child->getName();
|
||||||
if (name_or_err.getError())
|
if (name_or_err.getError())
|
||||||
return NULL;
|
return nullptr;
|
||||||
#endif
|
#endif
|
||||||
StringRef name = name_or_err.get();
|
StringRef name = name_or_err.get();
|
||||||
*size = name.size();
|
*size = name.size();
|
||||||
return name.data();
|
return name.data();
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" const char*
|
extern "C" const char *LLVMRustArchiveChildData(LLVMRustArchiveChildRef child,
|
||||||
LLVMRustArchiveChildData(LLVMRustArchiveChildRef child, size_t *size) {
|
size_t *size) {
|
||||||
StringRef buf;
|
StringRef buf;
|
||||||
#if LLVM_VERSION_GE(4, 0)
|
#if LLVM_VERSION_GE(4, 0)
|
||||||
Expected<StringRef> buf_or_err = child->getBuffer();
|
Expected<StringRef> buf_or_err = child->getBuffer();
|
||||||
if (!buf_or_err) {
|
if (!buf_or_err) {
|
||||||
LLVMRustSetLastError(toString(buf_or_err.takeError()).c_str());
|
LLVMRustSetLastError(toString(buf_or_err.takeError()).c_str());
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
ErrorOr<StringRef> buf_or_err = child->getBuffer();
|
ErrorOr<StringRef> buf_or_err = child->getBuffer();
|
||||||
if (buf_or_err.getError()) {
|
if (buf_or_err.getError()) {
|
||||||
LLVMRustSetLastError(buf_or_err.getError().message().c_str());
|
LLVMRustSetLastError(buf_or_err.getError().message().c_str());
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
buf = buf_or_err.get();
|
buf = buf_or_err.get();
|
||||||
*size = buf.size();
|
*size = buf.size();
|
||||||
return buf.data();
|
return buf.data();
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMRustArchiveMemberRef
|
extern "C" LLVMRustArchiveMemberRef
|
||||||
LLVMRustArchiveMemberNew(char *Filename, char *Name,
|
LLVMRustArchiveMemberNew(char *Filename, char *Name,
|
||||||
LLVMRustArchiveChildRef child) {
|
LLVMRustArchiveChildRef child) {
|
||||||
RustArchiveMember *Member = new RustArchiveMember;
|
RustArchiveMember *Member = new RustArchiveMember;
|
||||||
Member->filename = Filename;
|
Member->filename = Filename;
|
||||||
Member->name = Name;
|
Member->name = Name;
|
||||||
if (child)
|
if (child)
|
||||||
Member->child = *child;
|
Member->child = *child;
|
||||||
return Member;
|
return Member;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) {
|
||||||
LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) {
|
delete Member;
|
||||||
delete Member;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMRustResult
|
extern "C" LLVMRustResult
|
||||||
LLVMRustWriteArchive(char *Dst,
|
LLVMRustWriteArchive(char *Dst, size_t NumMembers,
|
||||||
size_t NumMembers,
|
|
||||||
const LLVMRustArchiveMemberRef *NewMembers,
|
const LLVMRustArchiveMemberRef *NewMembers,
|
||||||
bool WriteSymbtab,
|
bool WriteSymbtab, LLVMRustArchiveKind rust_kind) {
|
||||||
LLVMRustArchiveKind rust_kind) {
|
|
||||||
|
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
std::vector<NewArchiveIterator> Members;
|
std::vector<NewArchiveIterator> Members;
|
||||||
|
|
@ -257,7 +248,8 @@ LLVMRustWriteArchive(char *Dst,
|
||||||
assert(Member->name);
|
assert(Member->name);
|
||||||
if (Member->filename) {
|
if (Member->filename) {
|
||||||
#if LLVM_VERSION_GE(3, 9)
|
#if LLVM_VERSION_GE(3, 9)
|
||||||
Expected<NewArchiveMember> MOrErr = NewArchiveMember::getFile(Member->filename, true);
|
Expected<NewArchiveMember> MOrErr =
|
||||||
|
NewArchiveMember::getFile(Member->filename, true);
|
||||||
if (!MOrErr) {
|
if (!MOrErr) {
|
||||||
LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
|
LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
|
||||||
return LLVMRustResult::Failure;
|
return LLVMRustResult::Failure;
|
||||||
|
|
@ -272,7 +264,8 @@ LLVMRustWriteArchive(char *Dst,
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
Members.push_back(NewArchiveIterator(Member->child, Member->name));
|
Members.push_back(NewArchiveIterator(Member->child, Member->name));
|
||||||
#else
|
#else
|
||||||
Expected<NewArchiveMember> MOrErr = NewArchiveMember::getOldMember(Member->child, true);
|
Expected<NewArchiveMember> MOrErr =
|
||||||
|
NewArchiveMember::getOldMember(Member->child, true);
|
||||||
if (!MOrErr) {
|
if (!MOrErr) {
|
||||||
LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
|
LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
|
||||||
return LLVMRustResult::Failure;
|
return LLVMRustResult::Failure;
|
||||||
|
|
|
||||||
|
|
@ -12,12 +12,12 @@
|
||||||
|
|
||||||
#include "rustllvm.h"
|
#include "rustllvm.h"
|
||||||
|
|
||||||
#include "llvm/Support/CBindingWrapping.h"
|
|
||||||
#include "llvm/Support/FileSystem.h"
|
|
||||||
#include "llvm/Support/Host.h"
|
|
||||||
#include "llvm/Analysis/TargetLibraryInfo.h"
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
||||||
#include "llvm/Analysis/TargetTransformInfo.h"
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
||||||
#include "llvm/IR/AutoUpgrade.h"
|
#include "llvm/IR/AutoUpgrade.h"
|
||||||
|
#include "llvm/Support/CBindingWrapping.h"
|
||||||
|
#include "llvm/Support/FileSystem.h"
|
||||||
|
#include "llvm/Support/Host.h"
|
||||||
#include "llvm/Target/TargetMachine.h"
|
#include "llvm/Target/TargetMachine.h"
|
||||||
#include "llvm/Target/TargetSubtargetInfo.h"
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
||||||
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
|
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
|
||||||
|
|
@ -38,10 +38,10 @@ typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
|
||||||
|
|
||||||
DEFINE_STDCXX_CONVERSION_FUNCTIONS(Pass, LLVMPassRef)
|
DEFINE_STDCXX_CONVERSION_FUNCTIONS(Pass, LLVMPassRef)
|
||||||
DEFINE_STDCXX_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
|
DEFINE_STDCXX_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
|
||||||
DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBuilder, LLVMPassManagerBuilderRef)
|
DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBuilder,
|
||||||
|
LLVMPassManagerBuilderRef)
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMInitializePasses() {
|
||||||
LLVMInitializePasses() {
|
|
||||||
PassRegistry &Registry = *PassRegistry::getPassRegistry();
|
PassRegistry &Registry = *PassRegistry::getPassRegistry();
|
||||||
initializeCore(Registry);
|
initializeCore(Registry);
|
||||||
initializeCodeGen(Registry);
|
initializeCodeGen(Registry);
|
||||||
|
|
@ -64,44 +64,39 @@ enum class LLVMRustPassKind {
|
||||||
Module,
|
Module,
|
||||||
};
|
};
|
||||||
|
|
||||||
static LLVMRustPassKind
|
static LLVMRustPassKind to_rust(PassKind kind) {
|
||||||
to_rust(PassKind kind)
|
|
||||||
{
|
|
||||||
switch (kind) {
|
switch (kind) {
|
||||||
case PT_Function:
|
case PT_Function:
|
||||||
return LLVMRustPassKind::Function;
|
return LLVMRustPassKind::Function;
|
||||||
case PT_Module:
|
case PT_Module:
|
||||||
return LLVMRustPassKind::Module;
|
return LLVMRustPassKind::Module;
|
||||||
default:
|
default:
|
||||||
return LLVMRustPassKind::Other;
|
return LLVMRustPassKind::Other;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMPassRef
|
extern "C" LLVMPassRef LLVMRustFindAndCreatePass(const char *PassName) {
|
||||||
LLVMRustFindAndCreatePass(const char *PassName) {
|
StringRef SR(PassName);
|
||||||
StringRef SR(PassName);
|
PassRegistry *PR = PassRegistry::getPassRegistry();
|
||||||
PassRegistry *PR = PassRegistry::getPassRegistry();
|
|
||||||
|
|
||||||
const PassInfo *PI = PR->getPassInfo(SR);
|
const PassInfo *PI = PR->getPassInfo(SR);
|
||||||
if (PI) {
|
if (PI) {
|
||||||
return wrap(PI->createPass());
|
return wrap(PI->createPass());
|
||||||
}
|
}
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMRustPassKind
|
extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef rust_pass) {
|
||||||
LLVMRustPassKind(LLVMPassRef rust_pass) {
|
assert(rust_pass);
|
||||||
assert(rust_pass);
|
Pass *pass = unwrap(rust_pass);
|
||||||
Pass *pass = unwrap(rust_pass);
|
return to_rust(pass->getPassKind());
|
||||||
return to_rust(pass->getPassKind());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustAddPass(LLVMPassManagerRef PM, LLVMPassRef rust_pass) {
|
||||||
LLVMRustAddPass(LLVMPassManagerRef PM, LLVMPassRef rust_pass) {
|
assert(rust_pass);
|
||||||
assert(rust_pass);
|
Pass *pass = unwrap(rust_pass);
|
||||||
Pass *pass = unwrap(rust_pass);
|
PassManagerBase *pm = unwrap(PM);
|
||||||
PassManagerBase *pm = unwrap(PM);
|
pm->add(pass);
|
||||||
pm->add(pass);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef LLVM_COMPONENT_X86
|
#ifdef LLVM_COMPONENT_X86
|
||||||
|
|
@ -146,100 +141,94 @@ LLVMRustAddPass(LLVMPassManagerRef PM, LLVMPassRef rust_pass) {
|
||||||
#define SUBTARGET_MSP430
|
#define SUBTARGET_MSP430
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define GEN_SUBTARGETS \
|
#define GEN_SUBTARGETS \
|
||||||
SUBTARGET_X86 \
|
SUBTARGET_X86 \
|
||||||
SUBTARGET_ARM \
|
SUBTARGET_ARM \
|
||||||
SUBTARGET_AARCH64 \
|
SUBTARGET_AARCH64 \
|
||||||
SUBTARGET_MIPS \
|
SUBTARGET_MIPS \
|
||||||
SUBTARGET_PPC \
|
SUBTARGET_PPC \
|
||||||
SUBTARGET_SYSTEMZ \
|
SUBTARGET_SYSTEMZ \
|
||||||
SUBTARGET_MSP430
|
SUBTARGET_MSP430
|
||||||
|
|
||||||
#define SUBTARGET(x) namespace llvm { \
|
#define SUBTARGET(x) \
|
||||||
extern const SubtargetFeatureKV x##FeatureKV[]; \
|
namespace llvm { \
|
||||||
extern const SubtargetFeatureKV x##SubTypeKV[]; \
|
extern const SubtargetFeatureKV x##FeatureKV[]; \
|
||||||
|
extern const SubtargetFeatureKV x##SubTypeKV[]; \
|
||||||
}
|
}
|
||||||
|
|
||||||
GEN_SUBTARGETS
|
GEN_SUBTARGETS
|
||||||
#undef SUBTARGET
|
#undef SUBTARGET
|
||||||
|
|
||||||
extern "C" bool
|
extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
|
||||||
LLVMRustHasFeature(LLVMTargetMachineRef TM,
|
const char *feature) {
|
||||||
const char *feature) {
|
TargetMachine *Target = unwrap(TM);
|
||||||
TargetMachine *Target = unwrap(TM);
|
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
||||||
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
const FeatureBitset &Bits = MCInfo->getFeatureBits();
|
||||||
const FeatureBitset &Bits = MCInfo->getFeatureBits();
|
const llvm::SubtargetFeatureKV *FeatureEntry;
|
||||||
const llvm::SubtargetFeatureKV *FeatureEntry;
|
|
||||||
|
|
||||||
#define SUBTARGET(x) \
|
#define SUBTARGET(x) \
|
||||||
if (MCInfo->isCPUStringValid(x##SubTypeKV[0].Key)) { \
|
if (MCInfo->isCPUStringValid(x##SubTypeKV[0].Key)) { \
|
||||||
FeatureEntry = x##FeatureKV; \
|
FeatureEntry = x##FeatureKV; \
|
||||||
} else
|
} else
|
||||||
|
|
||||||
GEN_SUBTARGETS {
|
GEN_SUBTARGETS { return false; }
|
||||||
return false;
|
|
||||||
}
|
|
||||||
#undef SUBTARGET
|
#undef SUBTARGET
|
||||||
|
|
||||||
while (strcmp(feature, FeatureEntry->Key) != 0)
|
while (strcmp(feature, FeatureEntry->Key) != 0)
|
||||||
FeatureEntry++;
|
FeatureEntry++;
|
||||||
|
|
||||||
return (Bits & FeatureEntry->Value) == FeatureEntry->Value;
|
return (Bits & FeatureEntry->Value) == FeatureEntry->Value;
|
||||||
}
|
}
|
||||||
|
|
||||||
enum class LLVMRustCodeModel {
|
enum class LLVMRustCodeModel {
|
||||||
Other,
|
Other,
|
||||||
Default,
|
Default,
|
||||||
JITDefault,
|
JITDefault,
|
||||||
Small,
|
Small,
|
||||||
Kernel,
|
Kernel,
|
||||||
Medium,
|
Medium,
|
||||||
Large,
|
Large,
|
||||||
};
|
};
|
||||||
|
|
||||||
static CodeModel::Model
|
static CodeModel::Model from_rust(LLVMRustCodeModel model) {
|
||||||
from_rust(LLVMRustCodeModel model)
|
switch (model) {
|
||||||
{
|
case LLVMRustCodeModel::Default:
|
||||||
switch (model) {
|
return CodeModel::Default;
|
||||||
case LLVMRustCodeModel::Default:
|
case LLVMRustCodeModel::JITDefault:
|
||||||
return CodeModel::Default;
|
return CodeModel::JITDefault;
|
||||||
case LLVMRustCodeModel::JITDefault:
|
case LLVMRustCodeModel::Small:
|
||||||
return CodeModel::JITDefault;
|
return CodeModel::Small;
|
||||||
case LLVMRustCodeModel::Small:
|
case LLVMRustCodeModel::Kernel:
|
||||||
return CodeModel::Small;
|
return CodeModel::Kernel;
|
||||||
case LLVMRustCodeModel::Kernel:
|
case LLVMRustCodeModel::Medium:
|
||||||
return CodeModel::Kernel;
|
return CodeModel::Medium;
|
||||||
case LLVMRustCodeModel::Medium:
|
case LLVMRustCodeModel::Large:
|
||||||
return CodeModel::Medium;
|
return CodeModel::Large;
|
||||||
case LLVMRustCodeModel::Large:
|
default:
|
||||||
return CodeModel::Large;
|
llvm_unreachable("Bad CodeModel.");
|
||||||
default:
|
|
||||||
llvm_unreachable("Bad CodeModel.");
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
enum class LLVMRustCodeGenOptLevel {
|
enum class LLVMRustCodeGenOptLevel {
|
||||||
Other,
|
Other,
|
||||||
None,
|
None,
|
||||||
Less,
|
Less,
|
||||||
Default,
|
Default,
|
||||||
Aggressive,
|
Aggressive,
|
||||||
};
|
};
|
||||||
|
|
||||||
static CodeGenOpt::Level
|
static CodeGenOpt::Level from_rust(LLVMRustCodeGenOptLevel level) {
|
||||||
from_rust(LLVMRustCodeGenOptLevel level)
|
switch (level) {
|
||||||
{
|
case LLVMRustCodeGenOptLevel::None:
|
||||||
switch (level) {
|
return CodeGenOpt::None;
|
||||||
case LLVMRustCodeGenOptLevel::None:
|
case LLVMRustCodeGenOptLevel::Less:
|
||||||
return CodeGenOpt::None;
|
return CodeGenOpt::Less;
|
||||||
case LLVMRustCodeGenOptLevel::Less:
|
case LLVMRustCodeGenOptLevel::Default:
|
||||||
return CodeGenOpt::Less;
|
return CodeGenOpt::Default;
|
||||||
case LLVMRustCodeGenOptLevel::Default:
|
case LLVMRustCodeGenOptLevel::Aggressive:
|
||||||
return CodeGenOpt::Default;
|
return CodeGenOpt::Aggressive;
|
||||||
case LLVMRustCodeGenOptLevel::Aggressive:
|
default:
|
||||||
return CodeGenOpt::Aggressive;
|
llvm_unreachable("Bad CodeGenOptLevel.");
|
||||||
default:
|
|
||||||
llvm_unreachable("Bad CodeGenOptLevel.");
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -253,234 +242,209 @@ static size_t getLongestEntryLength(ArrayRef<SubtargetFeatureKV> Table) {
|
||||||
return MaxLen;
|
return MaxLen;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM) {
|
||||||
LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM) {
|
const TargetMachine *Target = unwrap(TM);
|
||||||
const TargetMachine *Target = unwrap(TM);
|
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
||||||
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
const ArrayRef<SubtargetFeatureKV> CPUTable = MCInfo->getCPUTable();
|
||||||
const ArrayRef<SubtargetFeatureKV> CPUTable = MCInfo->getCPUTable();
|
unsigned MaxCPULen = getLongestEntryLength(CPUTable);
|
||||||
unsigned MaxCPULen = getLongestEntryLength(CPUTable);
|
|
||||||
|
|
||||||
printf("Available CPUs for this target:\n");
|
printf("Available CPUs for this target:\n");
|
||||||
for (auto &CPU : CPUTable)
|
for (auto &CPU : CPUTable)
|
||||||
printf(" %-*s - %s.\n", MaxCPULen, CPU.Key, CPU.Desc);
|
printf(" %-*s - %s.\n", MaxCPULen, CPU.Key, CPU.Desc);
|
||||||
printf("\n");
|
printf("\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef TM) {
|
||||||
LLVMRustPrintTargetFeatures(LLVMTargetMachineRef TM) {
|
const TargetMachine *Target = unwrap(TM);
|
||||||
const TargetMachine *Target = unwrap(TM);
|
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
||||||
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
|
const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getFeatureTable();
|
||||||
const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getFeatureTable();
|
unsigned MaxFeatLen = getLongestEntryLength(FeatTable);
|
||||||
unsigned MaxFeatLen = getLongestEntryLength(FeatTable);
|
|
||||||
|
|
||||||
printf("Available features for this target:\n");
|
printf("Available features for this target:\n");
|
||||||
for (auto &Feature : FeatTable)
|
for (auto &Feature : FeatTable)
|
||||||
printf(" %-*s - %s.\n", MaxFeatLen, Feature.Key, Feature.Desc);
|
printf(" %-*s - %s.\n", MaxFeatLen, Feature.Key, Feature.Desc);
|
||||||
printf("\n");
|
printf("\n");
|
||||||
|
|
||||||
printf("Use +feature to enable a feature, or -feature to disable it.\n"
|
printf("Use +feature to enable a feature, or -feature to disable it.\n"
|
||||||
"For example, rustc -C -target-cpu=mycpu -C target-feature=+feature1,-feature2\n\n");
|
"For example, rustc -C -target-cpu=mycpu -C "
|
||||||
|
"target-feature=+feature1,-feature2\n\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef) {
|
||||||
LLVMRustPrintTargetCPUs(LLVMTargetMachineRef) {
|
printf("Target CPU help is not supported by this LLVM version.\n\n");
|
||||||
printf("Target CPU help is not supported by this LLVM version.\n\n");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef) {
|
||||||
LLVMRustPrintTargetFeatures(LLVMTargetMachineRef) {
|
printf("Target features help is not supported by this LLVM version.\n\n");
|
||||||
printf("Target features help is not supported by this LLVM version.\n\n");
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
extern "C" LLVMTargetMachineRef
|
extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
|
||||||
LLVMRustCreateTargetMachine(const char *triple,
|
const char *triple, const char *cpu, const char *feature,
|
||||||
const char *cpu,
|
LLVMRustCodeModel rust_CM, LLVMRelocMode Reloc,
|
||||||
const char *feature,
|
LLVMRustCodeGenOptLevel rust_OptLevel, bool UseSoftFloat,
|
||||||
LLVMRustCodeModel rust_CM,
|
bool PositionIndependentExecutable, bool FunctionSections,
|
||||||
LLVMRelocMode Reloc,
|
bool DataSections) {
|
||||||
LLVMRustCodeGenOptLevel rust_OptLevel,
|
|
||||||
bool UseSoftFloat,
|
|
||||||
bool PositionIndependentExecutable,
|
|
||||||
bool FunctionSections,
|
|
||||||
bool DataSections) {
|
|
||||||
|
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
Reloc::Model RM;
|
Reloc::Model RM;
|
||||||
#else
|
#else
|
||||||
Optional<Reloc::Model> RM;
|
Optional<Reloc::Model> RM;
|
||||||
#endif
|
#endif
|
||||||
auto CM = from_rust(rust_CM);
|
auto CM = from_rust(rust_CM);
|
||||||
auto OptLevel = from_rust(rust_OptLevel);
|
auto OptLevel = from_rust(rust_OptLevel);
|
||||||
|
|
||||||
switch (Reloc){
|
switch (Reloc) {
|
||||||
case LLVMRelocStatic:
|
case LLVMRelocStatic:
|
||||||
RM = Reloc::Static;
|
RM = Reloc::Static;
|
||||||
break;
|
break;
|
||||||
case LLVMRelocPIC:
|
case LLVMRelocPIC:
|
||||||
RM = Reloc::PIC_;
|
RM = Reloc::PIC_;
|
||||||
break;
|
break;
|
||||||
case LLVMRelocDynamicNoPic:
|
case LLVMRelocDynamicNoPic:
|
||||||
RM = Reloc::DynamicNoPIC;
|
RM = Reloc::DynamicNoPIC;
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
RM = Reloc::Default;
|
RM = Reloc::Default;
|
||||||
#endif
|
#endif
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::string Error;
|
std::string Error;
|
||||||
Triple Trip(Triple::normalize(triple));
|
Triple Trip(Triple::normalize(triple));
|
||||||
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Trip.getTriple(),
|
const llvm::Target *TheTarget =
|
||||||
Error);
|
TargetRegistry::lookupTarget(Trip.getTriple(), Error);
|
||||||
if (TheTarget == NULL) {
|
if (TheTarget == nullptr) {
|
||||||
LLVMRustSetLastError(Error.c_str());
|
LLVMRustSetLastError(Error.c_str());
|
||||||
return NULL;
|
return nullptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
StringRef real_cpu = cpu;
|
StringRef real_cpu = cpu;
|
||||||
if (real_cpu == "native") {
|
if (real_cpu == "native") {
|
||||||
real_cpu = sys::getHostCPUName();
|
real_cpu = sys::getHostCPUName();
|
||||||
}
|
}
|
||||||
|
|
||||||
TargetOptions Options;
|
TargetOptions Options;
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
Options.PositionIndependentExecutable = PositionIndependentExecutable;
|
Options.PositionIndependentExecutable = PositionIndependentExecutable;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
Options.FloatABIType = FloatABI::Default;
|
Options.FloatABIType = FloatABI::Default;
|
||||||
if (UseSoftFloat) {
|
if (UseSoftFloat) {
|
||||||
Options.FloatABIType = FloatABI::Soft;
|
Options.FloatABIType = FloatABI::Soft;
|
||||||
}
|
}
|
||||||
Options.DataSections = DataSections;
|
Options.DataSections = DataSections;
|
||||||
Options.FunctionSections = FunctionSections;
|
Options.FunctionSections = FunctionSections;
|
||||||
|
|
||||||
TargetMachine *TM = TheTarget->createTargetMachine(Trip.getTriple(),
|
TargetMachine *TM = TheTarget->createTargetMachine(
|
||||||
real_cpu,
|
Trip.getTriple(), real_cpu, feature, Options, RM, CM, OptLevel);
|
||||||
feature,
|
return wrap(TM);
|
||||||
Options,
|
|
||||||
RM,
|
|
||||||
CM,
|
|
||||||
OptLevel);
|
|
||||||
return wrap(TM);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
|
||||||
LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
|
delete unwrap(TM);
|
||||||
delete unwrap(TM);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Unfortunately, LLVM doesn't expose a C API to add the corresponding analysis
|
// Unfortunately, LLVM doesn't expose a C API to add the corresponding analysis
|
||||||
// passes for a target to a pass manager. We export that functionality through
|
// passes for a target to a pass manager. We export that functionality through
|
||||||
// this function.
|
// this function.
|
||||||
extern "C" void
|
extern "C" void LLVMRustAddAnalysisPasses(LLVMTargetMachineRef TM,
|
||||||
LLVMRustAddAnalysisPasses(LLVMTargetMachineRef TM,
|
LLVMPassManagerRef PMR,
|
||||||
LLVMPassManagerRef PMR,
|
LLVMModuleRef M) {
|
||||||
LLVMModuleRef M) {
|
PassManagerBase *PM = unwrap(PMR);
|
||||||
PassManagerBase *PM = unwrap(PMR);
|
PM->add(
|
||||||
PM->add(createTargetTransformInfoWrapperPass(
|
createTargetTransformInfoWrapperPass(unwrap(TM)->getTargetIRAnalysis()));
|
||||||
unwrap(TM)->getTargetIRAnalysis()));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustConfigurePassManagerBuilder(
|
||||||
LLVMRustConfigurePassManagerBuilder(LLVMPassManagerBuilderRef PMB,
|
LLVMPassManagerBuilderRef PMB, LLVMRustCodeGenOptLevel OptLevel,
|
||||||
LLVMRustCodeGenOptLevel OptLevel,
|
bool MergeFunctions, bool SLPVectorize, bool LoopVectorize) {
|
||||||
bool MergeFunctions,
|
// Ignore mergefunc for now as enabling it causes crashes.
|
||||||
bool SLPVectorize,
|
// unwrap(PMB)->MergeFunctions = MergeFunctions;
|
||||||
bool LoopVectorize) {
|
unwrap(PMB)->SLPVectorize = SLPVectorize;
|
||||||
// Ignore mergefunc for now as enabling it causes crashes.
|
unwrap(PMB)->OptLevel = from_rust(OptLevel);
|
||||||
//unwrap(PMB)->MergeFunctions = MergeFunctions;
|
unwrap(PMB)->LoopVectorize = LoopVectorize;
|
||||||
unwrap(PMB)->SLPVectorize = SLPVectorize;
|
|
||||||
unwrap(PMB)->OptLevel = from_rust(OptLevel);
|
|
||||||
unwrap(PMB)->LoopVectorize = LoopVectorize;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Unfortunately, the LLVM C API doesn't provide a way to set the `LibraryInfo`
|
// Unfortunately, the LLVM C API doesn't provide a way to set the `LibraryInfo`
|
||||||
// field of a PassManagerBuilder, we expose our own method of doing so.
|
// field of a PassManagerBuilder, we expose our own method of doing so.
|
||||||
extern "C" void
|
extern "C" void LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMB,
|
||||||
LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMB,
|
LLVMModuleRef M,
|
||||||
LLVMModuleRef M,
|
bool DisableSimplifyLibCalls) {
|
||||||
bool DisableSimplifyLibCalls) {
|
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
||||||
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
TargetLibraryInfoImpl *TLI = new TargetLibraryInfoImpl(TargetTriple);
|
||||||
TargetLibraryInfoImpl *TLI = new TargetLibraryInfoImpl(TargetTriple);
|
if (DisableSimplifyLibCalls)
|
||||||
if (DisableSimplifyLibCalls)
|
TLI->disableAllFunctions();
|
||||||
TLI->disableAllFunctions();
|
unwrap(PMB)->LibraryInfo = TLI;
|
||||||
unwrap(PMB)->LibraryInfo = TLI;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Unfortunately, the LLVM C API doesn't provide a way to create the
|
// Unfortunately, the LLVM C API doesn't provide a way to create the
|
||||||
// TargetLibraryInfo pass, so we use this method to do so.
|
// TargetLibraryInfo pass, so we use this method to do so.
|
||||||
extern "C" void
|
extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMB, LLVMModuleRef M,
|
||||||
LLVMRustAddLibraryInfo(LLVMPassManagerRef PMB,
|
bool DisableSimplifyLibCalls) {
|
||||||
LLVMModuleRef M,
|
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
||||||
bool DisableSimplifyLibCalls) {
|
TargetLibraryInfoImpl TLII(TargetTriple);
|
||||||
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
if (DisableSimplifyLibCalls)
|
||||||
TargetLibraryInfoImpl TLII(TargetTriple);
|
TLII.disableAllFunctions();
|
||||||
if (DisableSimplifyLibCalls)
|
unwrap(PMB)->add(new TargetLibraryInfoWrapperPass(TLII));
|
||||||
TLII.disableAllFunctions();
|
|
||||||
unwrap(PMB)->add(new TargetLibraryInfoWrapperPass(TLII));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Unfortunately, the LLVM C API doesn't provide an easy way of iterating over
|
// Unfortunately, the LLVM C API doesn't provide an easy way of iterating over
|
||||||
// all the functions in a module, so we do that manually here. You'll find
|
// all the functions in a module, so we do that manually here. You'll find
|
||||||
// similar code in clang's BackendUtil.cpp file.
|
// similar code in clang's BackendUtil.cpp file.
|
||||||
extern "C" void
|
extern "C" void LLVMRustRunFunctionPassManager(LLVMPassManagerRef PM,
|
||||||
LLVMRustRunFunctionPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
|
LLVMModuleRef M) {
|
||||||
llvm::legacy::FunctionPassManager *P = unwrap<llvm::legacy::FunctionPassManager>(PM);
|
llvm::legacy::FunctionPassManager *P =
|
||||||
P->doInitialization();
|
unwrap<llvm::legacy::FunctionPassManager>(PM);
|
||||||
|
P->doInitialization();
|
||||||
|
|
||||||
// Upgrade all calls to old intrinsics first.
|
// Upgrade all calls to old intrinsics first.
|
||||||
for (Module::iterator I = unwrap(M)->begin(),
|
for (Module::iterator I = unwrap(M)->begin(), E = unwrap(M)->end(); I != E;)
|
||||||
E = unwrap(M)->end(); I != E;)
|
UpgradeCallsToIntrinsic(&*I++); // must be post-increment, as we remove
|
||||||
UpgradeCallsToIntrinsic(&*I++); // must be post-increment, as we remove
|
|
||||||
|
|
||||||
for (Module::iterator I = unwrap(M)->begin(),
|
for (Module::iterator I = unwrap(M)->begin(), E = unwrap(M)->end(); I != E;
|
||||||
E = unwrap(M)->end(); I != E; ++I)
|
++I)
|
||||||
if (!I->isDeclaration())
|
if (!I->isDeclaration())
|
||||||
P->run(*I);
|
P->run(*I);
|
||||||
|
|
||||||
P->doFinalization();
|
P->doFinalization();
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) {
|
||||||
LLVMRustSetLLVMOptions(int Argc, char **Argv) {
|
// Initializing the command-line options more than once is not allowed. So,
|
||||||
// Initializing the command-line options more than once is not allowed. So,
|
// check if they've already been initialized. (This could happen if we're
|
||||||
// check if they've already been initialized. (This could happen if we're
|
// being called from rustpkg, for example). If the arguments change, then
|
||||||
// being called from rustpkg, for example). If the arguments change, then
|
// that's just kinda unfortunate.
|
||||||
// that's just kinda unfortunate.
|
static bool initialized = false;
|
||||||
static bool initialized = false;
|
if (initialized)
|
||||||
if (initialized) return;
|
return;
|
||||||
initialized = true;
|
initialized = true;
|
||||||
cl::ParseCommandLineOptions(Argc, Argv);
|
cl::ParseCommandLineOptions(Argc, Argv);
|
||||||
}
|
}
|
||||||
|
|
||||||
enum class LLVMRustFileType {
|
enum class LLVMRustFileType {
|
||||||
Other,
|
Other,
|
||||||
AssemblyFile,
|
AssemblyFile,
|
||||||
ObjectFile,
|
ObjectFile,
|
||||||
};
|
};
|
||||||
|
|
||||||
static TargetMachine::CodeGenFileType
|
static TargetMachine::CodeGenFileType from_rust(LLVMRustFileType type) {
|
||||||
from_rust(LLVMRustFileType type)
|
switch (type) {
|
||||||
{
|
case LLVMRustFileType::AssemblyFile:
|
||||||
switch (type) {
|
return TargetMachine::CGFT_AssemblyFile;
|
||||||
case LLVMRustFileType::AssemblyFile:
|
case LLVMRustFileType::ObjectFile:
|
||||||
return TargetMachine::CGFT_AssemblyFile;
|
return TargetMachine::CGFT_ObjectFile;
|
||||||
case LLVMRustFileType::ObjectFile:
|
default:
|
||||||
return TargetMachine::CGFT_ObjectFile;
|
llvm_unreachable("Bad FileType.");
|
||||||
default:
|
|
||||||
llvm_unreachable("Bad FileType.");
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMRustResult
|
extern "C" LLVMRustResult
|
||||||
LLVMRustWriteOutputFile(LLVMTargetMachineRef Target,
|
LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
|
||||||
LLVMPassManagerRef PMR,
|
LLVMModuleRef M, const char *path,
|
||||||
LLVMModuleRef M,
|
|
||||||
const char *path,
|
|
||||||
LLVMRustFileType rust_FileType) {
|
LLVMRustFileType rust_FileType) {
|
||||||
llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
|
llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
|
||||||
auto FileType = from_rust(rust_FileType);
|
auto FileType = from_rust(rust_FileType);
|
||||||
|
|
@ -505,10 +469,8 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target,
|
||||||
return LLVMRustResult::Success;
|
return LLVMRustResult::Success;
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
|
||||||
LLVMRustPrintModule(LLVMPassManagerRef PMR,
|
const char *path) {
|
||||||
LLVMModuleRef M,
|
|
||||||
const char* path) {
|
|
||||||
llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
|
llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
|
||||||
std::string ErrorInfo;
|
std::string ErrorInfo;
|
||||||
|
|
||||||
|
|
@ -524,102 +486,96 @@ LLVMRustPrintModule(LLVMPassManagerRef PMR,
|
||||||
PM->run(*unwrap(M));
|
PM->run(*unwrap(M));
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustPrintPasses() {
|
||||||
LLVMRustPrintPasses() {
|
LLVMInitializePasses();
|
||||||
LLVMInitializePasses();
|
struct MyListener : PassRegistrationListener {
|
||||||
struct MyListener : PassRegistrationListener {
|
void passEnumerate(const PassInfo *info) {
|
||||||
void passEnumerate(const PassInfo *info) {
|
|
||||||
#if LLVM_VERSION_GE(4, 0)
|
#if LLVM_VERSION_GE(4, 0)
|
||||||
StringRef PassArg = info->getPassArgument();
|
StringRef PassArg = info->getPassArgument();
|
||||||
StringRef PassName = info->getPassName();
|
StringRef PassName = info->getPassName();
|
||||||
if (!PassArg.empty()) {
|
if (!PassArg.empty()) {
|
||||||
// These unsigned->signed casts could theoretically overflow, but
|
// These unsigned->signed casts could theoretically overflow, but
|
||||||
// realistically never will (and even if, the result is implementation
|
// realistically never will (and even if, the result is implementation
|
||||||
// defined rather plain UB).
|
// defined rather plain UB).
|
||||||
printf("%15.*s - %.*s\n", (int)PassArg.size(), PassArg.data(),
|
printf("%15.*s - %.*s\n", (int)PassArg.size(), PassArg.data(),
|
||||||
(int)PassName.size(), PassName.data());
|
(int)PassName.size(), PassName.data());
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
if (info->getPassArgument() && *info->getPassArgument()) {
|
if (info->getPassArgument() && *info->getPassArgument()) {
|
||||||
printf("%15s - %s\n", info->getPassArgument(),
|
printf("%15s - %s\n", info->getPassArgument(), info->getPassName());
|
||||||
info->getPassName());
|
}
|
||||||
}
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
} listener;
|
} listener;
|
||||||
|
|
||||||
PassRegistry *PR = PassRegistry::getPassRegistry();
|
PassRegistry *PR = PassRegistry::getPassRegistry();
|
||||||
PR->enumerateWith(&listener);
|
PR->enumerateWith(&listener);
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMB,
|
||||||
LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMB, bool AddLifetimes) {
|
bool AddLifetimes) {
|
||||||
#if LLVM_VERSION_GE(4, 0)
|
#if LLVM_VERSION_GE(4, 0)
|
||||||
unwrap(PMB)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
|
unwrap(PMB)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
|
||||||
#else
|
#else
|
||||||
unwrap(PMB)->Inliner = createAlwaysInlinerPass(AddLifetimes);
|
unwrap(PMB)->Inliner = createAlwaysInlinerPass(AddLifetimes);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **symbols,
|
||||||
LLVMRustRunRestrictionPass(LLVMModuleRef M, char **symbols, size_t len) {
|
size_t len) {
|
||||||
llvm::legacy::PassManager passes;
|
llvm::legacy::PassManager passes;
|
||||||
|
|
||||||
#if LLVM_VERSION_LE(3, 8)
|
#if LLVM_VERSION_LE(3, 8)
|
||||||
ArrayRef<const char*> ref(symbols, len);
|
ArrayRef<const char *> ref(symbols, len);
|
||||||
passes.add(llvm::createInternalizePass(ref));
|
passes.add(llvm::createInternalizePass(ref));
|
||||||
#else
|
#else
|
||||||
auto PreserveFunctions = [=](const GlobalValue &GV) {
|
auto PreserveFunctions = [=](const GlobalValue &GV) {
|
||||||
for (size_t i=0; i<len; i++) {
|
for (size_t i = 0; i < len; i++) {
|
||||||
if (GV.getName() == symbols[i]) {
|
if (GV.getName() == symbols[i]) {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
};
|
};
|
||||||
|
|
||||||
passes.add(llvm::createInternalizePass(PreserveFunctions));
|
passes.add(llvm::createInternalizePass(PreserveFunctions));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
passes.run(*unwrap(M));
|
passes.run(*unwrap(M));
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustMarkAllFunctionsNounwind(LLVMModuleRef M) {
|
||||||
LLVMRustMarkAllFunctionsNounwind(LLVMModuleRef M) {
|
for (Module::iterator GV = unwrap(M)->begin(), E = unwrap(M)->end(); GV != E;
|
||||||
for (Module::iterator GV = unwrap(M)->begin(),
|
++GV) {
|
||||||
E = unwrap(M)->end(); GV != E; ++GV) {
|
GV->setDoesNotThrow();
|
||||||
GV->setDoesNotThrow();
|
Function *F = dyn_cast<Function>(GV);
|
||||||
Function *F = dyn_cast<Function>(GV);
|
if (F == nullptr)
|
||||||
if (F == NULL)
|
continue;
|
||||||
continue;
|
|
||||||
|
|
||||||
for (Function::iterator B = F->begin(), BE = F->end(); B != BE; ++B) {
|
for (Function::iterator B = F->begin(), BE = F->end(); B != BE; ++B) {
|
||||||
for (BasicBlock::iterator I = B->begin(), IE = B->end();
|
for (BasicBlock::iterator I = B->begin(), IE = B->end(); I != IE; ++I) {
|
||||||
I != IE; ++I) {
|
if (isa<InvokeInst>(I)) {
|
||||||
if (isa<InvokeInst>(I)) {
|
InvokeInst *CI = cast<InvokeInst>(I);
|
||||||
InvokeInst *CI = cast<InvokeInst>(I);
|
CI->setDoesNotThrow();
|
||||||
CI->setDoesNotThrow();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void
|
||||||
LLVMRustSetDataLayoutFromTargetMachine(LLVMModuleRef Module,
|
LLVMRustSetDataLayoutFromTargetMachine(LLVMModuleRef Module,
|
||||||
LLVMTargetMachineRef TMR) {
|
LLVMTargetMachineRef TMR) {
|
||||||
TargetMachine *Target = unwrap(TMR);
|
TargetMachine *Target = unwrap(TMR);
|
||||||
unwrap(Module)->setDataLayout(Target->createDataLayout());
|
unwrap(Module)->setDataLayout(Target->createDataLayout());
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" LLVMTargetDataRef
|
extern "C" LLVMTargetDataRef LLVMRustGetModuleDataLayout(LLVMModuleRef M) {
|
||||||
LLVMRustGetModuleDataLayout(LLVMModuleRef M) {
|
return wrap(&unwrap(M)->getDataLayout());
|
||||||
return wrap(&unwrap(M)->getDataLayout());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void LLVMRustSetModulePIELevel(LLVMModuleRef M) {
|
||||||
LLVMRustSetModulePIELevel(LLVMModuleRef M) {
|
|
||||||
#if LLVM_VERSION_GE(3, 9)
|
#if LLVM_VERSION_GE(3, 9)
|
||||||
unwrap(M)->setPIELevel(PIELevel::Level::Large);
|
unwrap(M)->setPIELevel(PIELevel::Level::Large);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -8,50 +8,52 @@
|
||||||
// option. This file may not be copied, modified, or distributed
|
// option. This file may not be copied, modified, or distributed
|
||||||
// except according to those terms.
|
// except according to those terms.
|
||||||
|
|
||||||
#include "llvm/IR/IRBuilder.h"
|
|
||||||
#include "llvm/IR/InlineAsm.h"
|
|
||||||
#include "llvm/IR/LLVMContext.h"
|
|
||||||
#include "llvm/IR/Module.h"
|
|
||||||
#include "llvm/IR/InlineAsm.h"
|
|
||||||
#include "llvm/IR/LLVMContext.h"
|
|
||||||
#include "llvm/Analysis/Passes.h"
|
|
||||||
#include "llvm/Analysis/Lint.h"
|
|
||||||
#include "llvm/ADT/ArrayRef.h"
|
|
||||||
#include "llvm/ADT/Triple.h"
|
|
||||||
#include "llvm/ADT/DenseSet.h"
|
|
||||||
#include "llvm/Support/CommandLine.h"
|
|
||||||
#include "llvm/Support/FormattedStream.h"
|
|
||||||
#include "llvm/Support/Timer.h"
|
|
||||||
#include "llvm/Support/raw_ostream.h"
|
|
||||||
#include "llvm/Support/TargetSelect.h"
|
|
||||||
#include "llvm/Support/TargetRegistry.h"
|
|
||||||
#include "llvm/Support/SourceMgr.h"
|
|
||||||
#include "llvm/Support/Host.h"
|
|
||||||
#include "llvm/Support/Debug.h"
|
|
||||||
#include "llvm/Support/DynamicLibrary.h"
|
|
||||||
#include "llvm/Support/Memory.h"
|
|
||||||
#include "llvm/ExecutionEngine/ExecutionEngine.h"
|
|
||||||
#include "llvm/ExecutionEngine/MCJIT.h"
|
|
||||||
#include "llvm/ExecutionEngine/Interpreter.h"
|
|
||||||
#include "llvm/Target/TargetMachine.h"
|
|
||||||
#include "llvm/Target/TargetOptions.h"
|
|
||||||
#include "llvm/Transforms/Scalar.h"
|
|
||||||
#include "llvm/Transforms/IPO.h"
|
|
||||||
#include "llvm/Transforms/Instrumentation.h"
|
|
||||||
#include "llvm/Transforms/Vectorize.h"
|
|
||||||
#include "llvm-c/Core.h"
|
|
||||||
#include "llvm-c/BitReader.h"
|
#include "llvm-c/BitReader.h"
|
||||||
|
#include "llvm-c/Core.h"
|
||||||
#include "llvm-c/ExecutionEngine.h"
|
#include "llvm-c/ExecutionEngine.h"
|
||||||
#include "llvm-c/Object.h"
|
#include "llvm-c/Object.h"
|
||||||
|
#include "llvm/ADT/ArrayRef.h"
|
||||||
|
#include "llvm/ADT/DenseSet.h"
|
||||||
|
#include "llvm/ADT/Triple.h"
|
||||||
|
#include "llvm/Analysis/Lint.h"
|
||||||
|
#include "llvm/Analysis/Passes.h"
|
||||||
|
#include "llvm/ExecutionEngine/ExecutionEngine.h"
|
||||||
|
#include "llvm/ExecutionEngine/Interpreter.h"
|
||||||
|
#include "llvm/ExecutionEngine/MCJIT.h"
|
||||||
|
#include "llvm/IR/IRBuilder.h"
|
||||||
|
#include "llvm/IR/InlineAsm.h"
|
||||||
|
#include "llvm/IR/InlineAsm.h"
|
||||||
|
#include "llvm/IR/LLVMContext.h"
|
||||||
|
#include "llvm/IR/LLVMContext.h"
|
||||||
|
#include "llvm/IR/Module.h"
|
||||||
|
#include "llvm/Support/CommandLine.h"
|
||||||
|
#include "llvm/Support/Debug.h"
|
||||||
|
#include "llvm/Support/DynamicLibrary.h"
|
||||||
|
#include "llvm/Support/FormattedStream.h"
|
||||||
|
#include "llvm/Support/Host.h"
|
||||||
|
#include "llvm/Support/Memory.h"
|
||||||
|
#include "llvm/Support/SourceMgr.h"
|
||||||
|
#include "llvm/Support/TargetRegistry.h"
|
||||||
|
#include "llvm/Support/TargetSelect.h"
|
||||||
|
#include "llvm/Support/Timer.h"
|
||||||
|
#include "llvm/Support/raw_ostream.h"
|
||||||
|
#include "llvm/Target/TargetMachine.h"
|
||||||
|
#include "llvm/Target/TargetOptions.h"
|
||||||
|
#include "llvm/Transforms/IPO.h"
|
||||||
|
#include "llvm/Transforms/Instrumentation.h"
|
||||||
|
#include "llvm/Transforms/Scalar.h"
|
||||||
|
#include "llvm/Transforms/Vectorize.h"
|
||||||
|
|
||||||
#define LLVM_VERSION_GE(major, minor) \
|
#define LLVM_VERSION_GE(major, minor) \
|
||||||
(LLVM_VERSION_MAJOR > (major) || LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR >= (minor))
|
(LLVM_VERSION_MAJOR > (major) || \
|
||||||
|
LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR >= (minor))
|
||||||
|
|
||||||
#define LLVM_VERSION_EQ(major, minor) \
|
#define LLVM_VERSION_EQ(major, minor) \
|
||||||
(LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR == (minor))
|
(LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR == (minor))
|
||||||
|
|
||||||
#define LLVM_VERSION_LE(major, minor) \
|
#define LLVM_VERSION_LE(major, minor) \
|
||||||
(LLVM_VERSION_MAJOR < (major) || LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR <= (minor))
|
(LLVM_VERSION_MAJOR < (major) || \
|
||||||
|
LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR <= (minor))
|
||||||
|
|
||||||
#if LLVM_VERSION_GE(3, 7)
|
#if LLVM_VERSION_GE(3, 7)
|
||||||
#include "llvm/IR/LegacyPassManager.h"
|
#include "llvm/IR/LegacyPassManager.h"
|
||||||
|
|
@ -66,39 +68,36 @@
|
||||||
#include "llvm/Bitcode/ReaderWriter.h"
|
#include "llvm/Bitcode/ReaderWriter.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#include "llvm/IR/IRPrintingPasses.h"
|
|
||||||
#include "llvm/IR/DebugInfo.h"
|
|
||||||
#include "llvm/IR/DIBuilder.h"
|
#include "llvm/IR/DIBuilder.h"
|
||||||
|
#include "llvm/IR/DebugInfo.h"
|
||||||
|
#include "llvm/IR/IRPrintingPasses.h"
|
||||||
#include "llvm/Linker/Linker.h"
|
#include "llvm/Linker/Linker.h"
|
||||||
|
|
||||||
void LLVMRustSetLastError(const char*);
|
void LLVMRustSetLastError(const char *);
|
||||||
|
|
||||||
enum class LLVMRustResult {
|
enum class LLVMRustResult { Success, Failure };
|
||||||
Success,
|
|
||||||
Failure
|
|
||||||
};
|
|
||||||
|
|
||||||
enum LLVMRustAttribute {
|
enum LLVMRustAttribute {
|
||||||
AlwaysInline = 0,
|
AlwaysInline = 0,
|
||||||
ByVal = 1,
|
ByVal = 1,
|
||||||
Cold = 2,
|
Cold = 2,
|
||||||
InlineHint = 3,
|
InlineHint = 3,
|
||||||
MinSize = 4,
|
MinSize = 4,
|
||||||
Naked = 5,
|
Naked = 5,
|
||||||
NoAlias = 6,
|
NoAlias = 6,
|
||||||
NoCapture = 7,
|
NoCapture = 7,
|
||||||
NoInline = 8,
|
NoInline = 8,
|
||||||
NonNull = 9,
|
NonNull = 9,
|
||||||
NoRedZone = 10,
|
NoRedZone = 10,
|
||||||
NoReturn = 11,
|
NoReturn = 11,
|
||||||
NoUnwind = 12,
|
NoUnwind = 12,
|
||||||
OptimizeForSize = 13,
|
OptimizeForSize = 13,
|
||||||
ReadOnly = 14,
|
ReadOnly = 14,
|
||||||
SExt = 15,
|
SExt = 15,
|
||||||
StructRet = 16,
|
StructRet = 16,
|
||||||
UWTable = 17,
|
UWTable = 17,
|
||||||
ZExt = 18,
|
ZExt = 18,
|
||||||
InReg = 19,
|
InReg = 19,
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef struct OpaqueRustString *RustStringRef;
|
typedef struct OpaqueRustString *RustStringRef;
|
||||||
|
|
@ -107,28 +106,25 @@ typedef struct LLVMOpaqueDebugLoc *LLVMDebugLocRef;
|
||||||
typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
|
typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
|
||||||
typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef;
|
typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef;
|
||||||
|
|
||||||
extern "C" void
|
extern "C" void rust_llvm_string_write_impl(RustStringRef str, const char *ptr,
|
||||||
rust_llvm_string_write_impl(RustStringRef str, const char *ptr, size_t size);
|
size_t size);
|
||||||
|
|
||||||
class raw_rust_string_ostream : public llvm::raw_ostream {
|
class raw_rust_string_ostream : public llvm::raw_ostream {
|
||||||
RustStringRef str;
|
RustStringRef str;
|
||||||
uint64_t pos;
|
uint64_t pos;
|
||||||
|
|
||||||
void write_impl(const char *ptr, size_t size) override {
|
void write_impl(const char *ptr, size_t size) override {
|
||||||
rust_llvm_string_write_impl(str, ptr, size);
|
rust_llvm_string_write_impl(str, ptr, size);
|
||||||
pos += size;
|
pos += size;
|
||||||
}
|
}
|
||||||
|
|
||||||
uint64_t current_pos() const override {
|
uint64_t current_pos() const override { return pos; }
|
||||||
return pos;
|
|
||||||
}
|
|
||||||
|
|
||||||
public:
|
public:
|
||||||
explicit raw_rust_string_ostream(RustStringRef str)
|
explicit raw_rust_string_ostream(RustStringRef str) : str(str), pos(0) {}
|
||||||
: str(str), pos(0) { }
|
|
||||||
|
|
||||||
~raw_rust_string_ostream() {
|
~raw_rust_string_ostream() {
|
||||||
// LLVM requires this.
|
// LLVM requires this.
|
||||||
flush();
|
flush();
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue