bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Improve naming style in rustllvm.

Browse source 
As per the LLVM style guide, use CamelCase for all locals and classes,
and camelCase for all non-FFI functions.
Also, make names of variables of commonly used types more consistent.

Fixes #38688.
This commit is contained in:
Ian Kerins 2016-12-31 12:01:23 -05:00
parent 6dcf51aae6
commit e6f97114ca
5 changed files with 446 additions and 443 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/librustc_llvm/lib.rs
View file

@ -126,11 +126,11 @@ pub enum RustString_opaque {}
pub type RustStringRef = *mut RustString_opaque; pub type RustStringRef = *mut RustString_opaque;
type RustStringRepr = *mut RefCell<Vec<u8>>; type RustStringRepr = *mut RefCell<Vec<u8>>;
/// Appending to a Rust string -- used by raw_rust_string_ostream. /// Appending to a Rust string -- used by RawRustStringOstream.
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef, pub unsafe extern "C" fn LLVMRustStringWriteImpl(sr: RustStringRef,
ptr: *const c_char, ptr: *const c_char,
size: size_t) { size: size_t) {
let slice = slice::from_raw_parts(ptr as *const u8, size as usize); let slice = slice::from_raw_parts(ptr as *const u8, size as usize);
let sr = sr as RustStringRepr; let sr = sr as RustStringRepr;

206
src/rustllvm/ArchiveWrapper.cpp
View file

@ -17,16 +17,16 @@ using namespace llvm;
using namespace llvm::object; using namespace llvm::object;
struct RustArchiveMember { struct RustArchiveMember {
const char *filename; const char *Filename;
const char *name; const char *Name;
Archive::Child child; Archive::Child Child;
RustArchiveMember() RustArchiveMember()
: filename(nullptr), name(nullptr), : Filename(nullptr), Name(nullptr),
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
child(nullptr, nullptr, nullptr) Child(nullptr, nullptr, nullptr)
#else #else
child(nullptr, nullptr) Child(nullptr, nullptr)
#endif #endif
{ {
} }
@ -34,15 +34,15 @@ struct 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
}; };
@ -54,8 +54,8 @@ enum class LLVMRustArchiveKind {
COFF, COFF,
}; };
static Archive::Kind from_rust(LLVMRustArchiveKind kind) { static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {
switch (kind) { switch (Kind) {
case LLVMRustArchiveKind::GNU: case LLVMRustArchiveKind::GNU:
return Archive::K_GNU; return Archive::K_GNU;
case LLVMRustArchiveKind::MIPS64: case LLVMRustArchiveKind::MIPS64:
@ -75,59 +75,61 @@ typedef Archive::Child *LLVMRustArchiveChildRef;
typedef Archive::Child const *LLVMRustArchiveChildConstRef; typedef Archive::Child const *LLVMRustArchiveChildConstRef;
typedef RustArchiveIterator *LLVMRustArchiveIteratorRef; typedef RustArchiveIterator *LLVMRustArchiveIteratorRef;
extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *path) { extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *Path) {
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or = ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
MemoryBuffer::getFile(path, -1, false); MemoryBuffer::getFile(Path, -1, false);
if (!buf_or) { if (!BufOr) {
LLVMRustSetLastError(buf_or.getError().message().c_str()); LLVMRustSetLastError(BufOr.getError().message().c_str());
return nullptr; 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>> ArchiveOr =
#else #else
Expected<std::unique_ptr<Archive>> archive_or = Expected<std::unique_ptr<Archive>> ArchiveOr =
#endif #endif
Archive::create(buf_or.get()->getMemBufferRef()); Archive::create(BufOr.get()->getMemBufferRef());
if (!archive_or) { if (!ArchiveOr) {
#if LLVM_VERSION_LE(3, 8) #if LLVM_VERSION_LE(3, 8)
LLVMRustSetLastError(archive_or.getError().message().c_str()); LLVMRustSetLastError(ArchiveOr.getError().message().c_str());
#else #else
LLVMRustSetLastError(toString(archive_or.takeError()).c_str()); LLVMRustSetLastError(toString(ArchiveOr.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(ArchiveOr.get()), std::move(BufOr.get()));
return ret; return Ret;
} }
extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef ar) { delete ar; } extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef RustArchive) {
delete RustArchive;
}
extern "C" LLVMRustArchiveIteratorRef extern "C" LLVMRustArchiveIteratorRef
LLVMRustArchiveIteratorNew(LLVMRustArchiveRef ra) { LLVMRustArchiveIteratorNew(LLVMRustArchiveRef RustArchive) {
Archive *ar = ra->getBinary(); Archive *Archive = RustArchive->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 = Archive->child_begin();
#else #else
rai->cur = ar->child_begin(rai->err); RAI->Cur = Archive->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 nullptr; return nullptr;
} }
#endif #endif
rai->end = ar->child_end(); RAI->End = Archive->child_end();
return rai; return RAI;
} }
extern "C" LLVMRustArchiveChildConstRef extern "C" LLVMRustArchiveChildConstRef
LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) { LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef RAI) {
if (rai->cur == rai->end) if (RAI->Cur == RAI->End)
return nullptr; return nullptr;
// Advancing the iterator validates the next child, and this can // Advancing the iterator validates the next child, and this can
@ -136,94 +138,94 @@ LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) {
// 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 #endif
} else { } else {
rai->first = false; RAI->First = false;
} }
if (rai->cur == rai->end) if (RAI->Cur == RAI->End)
return nullptr; 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 LLVMRustArchiveChildFree(LLVMRustArchiveChildRef child) { extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef Child) {
delete child; delete Child;
} }
extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef rai) { extern "C" void 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> NameOrErr = Child->getName();
if (!name_or_err) { if (!NameOrErr) {
// 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
// in the future, and in the mean time this tells LLVM that the error was // useful in the future, and in the mean time this tells LLVM that the
// not ignored and that it shouldn't abort the process. // error was not ignored and that it shouldn't abort the process.
LLVMRustSetLastError(toString(name_or_err.takeError()).c_str()); LLVMRustSetLastError(toString(NameOrErr.takeError()).c_str());
return nullptr; return nullptr;
} }
#else #else
ErrorOr<StringRef> name_or_err = child->getName(); ErrorOr<StringRef> NameOrErr = Child->getName();
if (name_or_err.getError()) if (NameOrErr.getError())
return nullptr; return nullptr;
#endif #endif
StringRef name = name_or_err.get(); StringRef Name = NameOrErr.get();
*size = name.size(); *Size = Name.size();
return name.data(); return Name.data();
} }
extern "C" const char *LLVMRustArchiveChildData(LLVMRustArchiveChildRef child, extern "C" const char *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> BufOrErr = Child->getBuffer();
if (!buf_or_err) { if (!BufOrErr) {
LLVMRustSetLastError(toString(buf_or_err.takeError()).c_str()); LLVMRustSetLastError(toString(BufOrErr.takeError()).c_str());
return nullptr; return nullptr;
} }
#else #else
ErrorOr<StringRef> buf_or_err = child->getBuffer(); ErrorOr<StringRef> BufOrErr = Child->getBuffer();
if (buf_or_err.getError()) { if (BufOrErr.getError()) {
LLVMRustSetLastError(buf_or_err.getError().message().c_str()); LLVMRustSetLastError(BufOrErr.getError().message().c_str());
return nullptr; return nullptr;
} }
#endif #endif
buf = buf_or_err.get(); Buf = BufOrErr.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;
} }
@ -234,38 +236,38 @@ extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) {
extern "C" LLVMRustResult extern "C" LLVMRustResult
LLVMRustWriteArchive(char *Dst, size_t NumMembers, LLVMRustWriteArchive(char *Dst, size_t NumMembers,
const LLVMRustArchiveMemberRef *NewMembers, const LLVMRustArchiveMemberRef *NewMembers,
bool WriteSymbtab, LLVMRustArchiveKind rust_kind) { bool WriteSymbtab, LLVMRustArchiveKind RustKind) {
#if LLVM_VERSION_LE(3, 8) #if LLVM_VERSION_LE(3, 8)
std::vector<NewArchiveIterator> Members; std::vector<NewArchiveIterator> Members;
#else #else
std::vector<NewArchiveMember> Members; std::vector<NewArchiveMember> Members;
#endif #endif
auto Kind = from_rust(rust_kind); auto Kind = fromRust(RustKind);
for (size_t i = 0; i < NumMembers; i++) { for (size_t I = 0; I < NumMembers; I++) {
auto Member = NewMembers[i]; auto Member = NewMembers[I];
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 = Expected<NewArchiveMember> MOrErr =
NewArchiveMember::getFile(Member->filename, true); 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;
} }
Members.push_back(std::move(*MOrErr)); Members.push_back(std::move(*MOrErr));
#elif LLVM_VERSION_EQ(3, 8) #elif LLVM_VERSION_EQ(3, 8)
Members.push_back(NewArchiveIterator(Member->filename)); Members.push_back(NewArchiveIterator(Member->Filename));
#else #else
Members.push_back(NewArchiveIterator(Member->filename, Member->name)); Members.push_back(NewArchiveIterator(Member->Filename, Member->Name));
#endif #endif
} else { } else {
#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 = Expected<NewArchiveMember> MOrErr =
NewArchiveMember::getOldMember(Member->child, true); 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;
@ -275,12 +277,12 @@ LLVMRustWriteArchive(char *Dst, size_t NumMembers,
} }
} }
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
auto pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false); auto Pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false);
#else #else
auto pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true); auto Pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true);
#endif #endif
if (!pair.second) if (!Pair.second)
return LLVMRustResult::Success; return LLVMRustResult::Success;
LLVMRustSetLastError(pair.second.message().c_str()); LLVMRustSetLastError(Pair.second.message().c_str());
return LLVMRustResult::Failure; return LLVMRustResult::Failure;
} }

130
src/rustllvm/PassWrapper.cpp
View file

@ -64,8 +64,8 @@ enum class LLVMRustPassKind {
Module, Module,
}; };
static LLVMRustPassKind to_rust(PassKind kind) { static LLVMRustPassKind toRust(PassKind Kind) {
switch (kind) { switch (Kind) {
case PT_Function: case PT_Function:
return LLVMRustPassKind::Function; return LLVMRustPassKind::Function;
case PT_Module: case PT_Module:
@ -86,17 +86,17 @@ extern "C" LLVMPassRef LLVMRustFindAndCreatePass(const char *PassName) {
return nullptr; return nullptr;
} }
extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef rust_pass) { extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef RustPass) {
assert(rust_pass); assert(RustPass);
Pass *pass = unwrap(rust_pass); Pass *Pass = unwrap(RustPass);
return to_rust(pass->getPassKind()); return toRust(Pass->getPassKind());
} }
extern "C" void LLVMRustAddPass(LLVMPassManagerRef PM, LLVMPassRef rust_pass) { extern "C" void LLVMRustAddPass(LLVMPassManagerRef PMR, LLVMPassRef RustPass) {
assert(rust_pass); assert(RustPass);
Pass *pass = unwrap(rust_pass); Pass *Pass = unwrap(RustPass);
PassManagerBase *pm = unwrap(PM); PassManagerBase *PMB = unwrap(PMR);
pm->add(pass); PMB->add(Pass);
} }
#ifdef LLVM_COMPONENT_X86 #ifdef LLVM_COMPONENT_X86
@ -160,7 +160,7 @@ GEN_SUBTARGETS
#undef SUBTARGET #undef SUBTARGET
extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM, extern "C" bool 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();
@ -174,7 +174,7 @@ extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
GEN_SUBTARGETS { return false; } GEN_SUBTARGETS { 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;
@ -190,8 +190,8 @@ enum class LLVMRustCodeModel {
Large, Large,
}; };
static CodeModel::Model from_rust(LLVMRustCodeModel model) { static CodeModel::Model fromRust(LLVMRustCodeModel Model) {
switch (model) { switch (Model) {
case LLVMRustCodeModel::Default: case LLVMRustCodeModel::Default:
return CodeModel::Default; return CodeModel::Default;
case LLVMRustCodeModel::JITDefault: case LLVMRustCodeModel::JITDefault:
@ -217,8 +217,8 @@ enum class LLVMRustCodeGenOptLevel {
Aggressive, Aggressive,
}; };
static CodeGenOpt::Level from_rust(LLVMRustCodeGenOptLevel level) { static CodeGenOpt::Level fromRust(LLVMRustCodeGenOptLevel Level) {
switch (level) { switch (Level) {
case LLVMRustCodeGenOptLevel::None: case LLVMRustCodeGenOptLevel::None:
return CodeGenOpt::None; return CodeGenOpt::None;
case LLVMRustCodeGenOptLevel::Less: case LLVMRustCodeGenOptLevel::Less:
@ -282,9 +282,9 @@ extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef) {
#endif #endif
extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine( extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
const char *triple, const char *cpu, const char *feature, const char *TripleStr, const char *CPU, const char *Feature,
LLVMRustCodeModel rust_CM, LLVMRelocMode Reloc, LLVMRustCodeModel RustCM, LLVMRelocMode Reloc,
LLVMRustCodeGenOptLevel rust_OptLevel, bool UseSoftFloat, LLVMRustCodeGenOptLevel RustOptLevel, bool UseSoftFloat,
bool PositionIndependentExecutable, bool FunctionSections, bool PositionIndependentExecutable, bool FunctionSections,
bool DataSections) { bool DataSections) {
@ -293,8 +293,8 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
#else #else
Optional<Reloc::Model> RM; Optional<Reloc::Model> RM;
#endif #endif
auto CM = from_rust(rust_CM); auto CM = fromRust(RustCM);
auto OptLevel = from_rust(rust_OptLevel); auto OptLevel = fromRust(RustOptLevel);
switch (Reloc) { switch (Reloc) {
case LLVMRelocStatic: case LLVMRelocStatic:
@ -314,7 +314,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
} }
std::string Error; std::string Error;
Triple Trip(Triple::normalize(triple)); Triple Trip(Triple::normalize(TripleStr));
const llvm::Target *TheTarget = const llvm::Target *TheTarget =
TargetRegistry::lookupTarget(Trip.getTriple(), Error); TargetRegistry::lookupTarget(Trip.getTriple(), Error);
if (TheTarget == nullptr) { if (TheTarget == nullptr) {
@ -322,9 +322,9 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
return nullptr; return nullptr;
} }
StringRef real_cpu = cpu; StringRef RealCPU = CPU;
if (real_cpu == "native") { if (RealCPU == "native") {
real_cpu = sys::getHostCPUName(); RealCPU = sys::getHostCPUName();
} }
TargetOptions Options; TargetOptions Options;
@ -340,7 +340,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
Options.FunctionSections = FunctionSections; Options.FunctionSections = FunctionSections;
TargetMachine *TM = TheTarget->createTargetMachine( TargetMachine *TM = TheTarget->createTargetMachine(
Trip.getTriple(), real_cpu, feature, Options, RM, CM, OptLevel); Trip.getTriple(), RealCPU, Feature, Options, RM, CM, OptLevel);
return wrap(TM); return wrap(TM);
} }
@ -360,45 +360,45 @@ extern "C" void LLVMRustAddAnalysisPasses(LLVMTargetMachineRef TM,
} }
extern "C" void LLVMRustConfigurePassManagerBuilder( extern "C" void LLVMRustConfigurePassManagerBuilder(
LLVMPassManagerBuilderRef PMB, LLVMRustCodeGenOptLevel OptLevel, LLVMPassManagerBuilderRef PMBR, LLVMRustCodeGenOptLevel OptLevel,
bool MergeFunctions, bool SLPVectorize, bool LoopVectorize) { bool MergeFunctions, bool SLPVectorize, bool LoopVectorize) {
// Ignore mergefunc for now as enabling it causes crashes. // Ignore mergefunc for now as enabling it causes crashes.
// unwrap(PMB)->MergeFunctions = MergeFunctions; // unwrap(PMBR)->MergeFunctions = MergeFunctions;
unwrap(PMB)->SLPVectorize = SLPVectorize; unwrap(PMBR)->SLPVectorize = SLPVectorize;
unwrap(PMB)->OptLevel = from_rust(OptLevel); unwrap(PMBR)->OptLevel = fromRust(OptLevel);
unwrap(PMB)->LoopVectorize = LoopVectorize; unwrap(PMBR)->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 LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMB, extern "C" void LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMBR,
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(PMBR)->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 LLVMRustAddLibraryInfo(LLVMPassManagerRef PMB, LLVMModuleRef M, extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMR, LLVMModuleRef M,
bool DisableSimplifyLibCalls) { bool DisableSimplifyLibCalls) {
Triple TargetTriple(unwrap(M)->getTargetTriple()); Triple TargetTriple(unwrap(M)->getTargetTriple());
TargetLibraryInfoImpl TLII(TargetTriple); TargetLibraryInfoImpl TLII(TargetTriple);
if (DisableSimplifyLibCalls) if (DisableSimplifyLibCalls)
TLII.disableAllFunctions(); TLII.disableAllFunctions();
unwrap(PMB)->add(new TargetLibraryInfoWrapperPass(TLII)); unwrap(PMR)->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 LLVMRustRunFunctionPassManager(LLVMPassManagerRef PM, extern "C" void LLVMRustRunFunctionPassManager(LLVMPassManagerRef PMR,
LLVMModuleRef M) { LLVMModuleRef M) {
llvm::legacy::FunctionPassManager *P = llvm::legacy::FunctionPassManager *P =
unwrap<llvm::legacy::FunctionPassManager>(PM); unwrap<llvm::legacy::FunctionPassManager>(PMR);
P->doInitialization(); P->doInitialization();
// Upgrade all calls to old intrinsics first. // Upgrade all calls to old intrinsics first.
@ -418,10 +418,10 @@ extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) {
// 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);
} }
@ -431,8 +431,8 @@ enum class LLVMRustFileType {
ObjectFile, ObjectFile,
}; };
static TargetMachine::CodeGenFileType from_rust(LLVMRustFileType type) { static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) {
switch (type) { switch (Type) {
case LLVMRustFileType::AssemblyFile: case LLVMRustFileType::AssemblyFile:
return TargetMachine::CGFT_AssemblyFile; return TargetMachine::CGFT_AssemblyFile;
case LLVMRustFileType::ObjectFile: case LLVMRustFileType::ObjectFile:
@ -444,14 +444,14 @@ static TargetMachine::CodeGenFileType from_rust(LLVMRustFileType type) {
extern "C" LLVMRustResult extern "C" LLVMRustResult
LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR, LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
LLVMModuleRef M, const char *path, LLVMModuleRef M, const char *Path,
LLVMRustFileType rust_FileType) { LLVMRustFileType RustFileType) {
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 = fromRust(RustFileType);
std::string ErrorInfo; std::string ErrorInfo;
std::error_code EC; std::error_code EC;
raw_fd_ostream OS(path, EC, sys::fs::F_None); raw_fd_ostream OS(Path, EC, sys::fs::F_None);
if (EC) if (EC)
ErrorInfo = EC.message(); ErrorInfo = EC.message();
if (ErrorInfo != "") { if (ErrorInfo != "") {
@ -470,12 +470,12 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
} }
extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M, extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
const char *path) { 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;
std::error_code EC; std::error_code EC;
raw_fd_ostream OS(path, EC, sys::fs::F_None); raw_fd_ostream OS(Path, EC, sys::fs::F_None);
if (EC) if (EC)
ErrorInfo = EC.message(); ErrorInfo = EC.message();
@ -489,10 +489,10 @@ extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
extern "C" void LLVMRustPrintPasses() { extern "C" void 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
@ -501,37 +501,37 @@ extern "C" void LLVMRustPrintPasses() {
(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(), info->getPassName()); printf("%15s - %s\n", Info->getPassArgument(), Info->getPassName());
} }
#endif #endif
} }
} listener; } Listener;
PassRegistry *PR = PassRegistry::getPassRegistry(); PassRegistry *PR = PassRegistry::getPassRegistry();
PR->enumerateWith(&listener); PR->enumerateWith(&Listener);
} }
extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMB, extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMBR,
bool AddLifetimes) { bool AddLifetimes) {
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
unwrap(PMB)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes); unwrap(PMBR)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
#else #else
unwrap(PMB)->Inliner = createAlwaysInlinerPass(AddLifetimes); unwrap(PMBR)->Inliner = createAlwaysInlinerPass(AddLifetimes);
#endif #endif
} }
extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **symbols, extern "C" void 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;
} }
} }

523
src/rustllvm/RustWrapper.cpp
View file

@ -30,7 +30,7 @@ using namespace llvm::object;
// LLVMAtomicOrdering is already an enum - don't create another // LLVMAtomicOrdering is already an enum - don't create another
// one. // one.
static AtomicOrdering from_rust(LLVMAtomicOrdering Ordering) { static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
switch (Ordering) { switch (Ordering) {
case LLVMAtomicOrderingNotAtomic: case LLVMAtomicOrderingNotAtomic:
return AtomicOrdering::NotAtomic; return AtomicOrdering::NotAtomic;
@ -55,29 +55,29 @@ static char *LastError;
extern "C" LLVMMemoryBufferRef extern "C" LLVMMemoryBufferRef
LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) { LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or = ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
MemoryBuffer::getFile(Path, -1, false); MemoryBuffer::getFile(Path, -1, false);
if (!buf_or) { if (!BufOr) {
LLVMRustSetLastError(buf_or.getError().message().c_str()); LLVMRustSetLastError(BufOr.getError().message().c_str());
return nullptr; return nullptr;
} }
return wrap(buf_or.get().release()); return wrap(BufOr.get().release());
} }
extern "C" char *LLVMRustGetLastError(void) { extern "C" char *LLVMRustGetLastError(void) {
char *ret = LastError; char *Ret = LastError;
LastError = nullptr; LastError = nullptr;
return ret; return Ret;
} }
void LLVMRustSetLastError(const char *err) { void LLVMRustSetLastError(const char *Err) {
free((void *)LastError); free((void *)LastError);
LastError = strdup(err); LastError = strdup(Err);
} }
extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M, extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
const char *triple) { const char *Triple) {
unwrap(M)->setTargetTriple(Triple::normalize(triple)); unwrap(M)->setTargetTriple(Triple::normalize(Triple));
} }
extern "C" void LLVMRustPrintPassTimings() { extern "C" void LLVMRustPrintPassTimings() {
@ -106,8 +106,8 @@ extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C) {
return wrap(Type::getMetadataTy(*unwrap(C))); return wrap(Type::getMetadataTy(*unwrap(C)));
} }
static Attribute::AttrKind from_rust(LLVMRustAttribute kind) { static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
switch (kind) { switch (Kind) {
case AlwaysInline: case AlwaysInline:
return Attribute::AlwaysInline; return Attribute::AlwaysInline;
case ByVal: case ByVal:
@ -153,63 +153,63 @@ static Attribute::AttrKind from_rust(LLVMRustAttribute kind) {
} }
} }
extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned index, extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,
LLVMRustAttribute attr) { LLVMRustAttribute RustAttr) {
CallSite Call = CallSite(unwrap<Instruction>(Instr)); CallSite Call = CallSite(unwrap<Instruction>(Instr));
Attribute Attr = Attribute::get(Call->getContext(), from_rust(attr)); Attribute Attr = Attribute::get(Call->getContext(), fromRust(RustAttr));
AttrBuilder B(Attr); AttrBuilder B(Attr);
Call.setAttributes(Call.getAttributes().addAttributes( Call.setAttributes(Call.getAttributes().addAttributes(
Call->getContext(), index, Call->getContext(), Index,
AttributeSet::get(Call->getContext(), index, B))); AttributeSet::get(Call->getContext(), Index, B)));
} }
extern "C" void LLVMRustAddDereferenceableCallSiteAttr(LLVMValueRef Instr, extern "C" void LLVMRustAddDereferenceableCallSiteAttr(LLVMValueRef Instr,
unsigned index, unsigned Index,
uint64_t bytes) { uint64_t Bytes) {
CallSite Call = CallSite(unwrap<Instruction>(Instr)); CallSite Call = CallSite(unwrap<Instruction>(Instr));
AttrBuilder B; AttrBuilder B;
B.addDereferenceableAttr(bytes); B.addDereferenceableAttr(Bytes);
Call.setAttributes(Call.getAttributes().addAttributes( Call.setAttributes(Call.getAttributes().addAttributes(
Call->getContext(), index, Call->getContext(), Index,
AttributeSet::get(Call->getContext(), index, B))); AttributeSet::get(Call->getContext(), Index, B)));
} }
extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned index, extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned Index,
LLVMRustAttribute attr) { LLVMRustAttribute RustAttr) {
Function *A = unwrap<Function>(Fn); Function *A = unwrap<Function>(Fn);
Attribute Attr = Attribute::get(A->getContext(), from_rust(attr)); Attribute Attr = Attribute::get(A->getContext(), fromRust(RustAttr));
AttrBuilder B(Attr); AttrBuilder B(Attr);
A->addAttributes(index, AttributeSet::get(A->getContext(), index, B)); A->addAttributes(Index, AttributeSet::get(A->getContext(), Index, B));
} }
extern "C" void LLVMRustAddDereferenceableAttr(LLVMValueRef Fn, unsigned index, extern "C" void LLVMRustAddDereferenceableAttr(LLVMValueRef Fn, unsigned Index,
uint64_t bytes) { uint64_t Bytes) {
Function *A = unwrap<Function>(Fn); Function *A = unwrap<Function>(Fn);
AttrBuilder B; AttrBuilder B;
B.addDereferenceableAttr(bytes); B.addDereferenceableAttr(Bytes);
A->addAttributes(index, AttributeSet::get(A->getContext(), index, B)); A->addAttributes(Index, AttributeSet::get(A->getContext(), Index, B));
} }
extern "C" void LLVMRustAddFunctionAttrStringValue(LLVMValueRef Fn, extern "C" void LLVMRustAddFunctionAttrStringValue(LLVMValueRef Fn,
unsigned index, unsigned Index,
const char *Name, const char *Name,
const char *Value) { const char *Value) {
Function *F = unwrap<Function>(Fn); Function *F = unwrap<Function>(Fn);
AttrBuilder B; AttrBuilder B;
B.addAttribute(Name, Value); B.addAttribute(Name, Value);
F->addAttributes(index, AttributeSet::get(F->getContext(), index, B)); F->addAttributes(Index, AttributeSet::get(F->getContext(), Index, B));
} }
extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn, extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn,
unsigned index, unsigned Index,
LLVMRustAttribute attr) { LLVMRustAttribute RustAttr) {
Function *F = unwrap<Function>(Fn); Function *F = unwrap<Function>(Fn);
const AttributeSet PAL = F->getAttributes(); const AttributeSet PAL = F->getAttributes();
Attribute Attr = Attribute::get(F->getContext(), from_rust(attr)); Attribute Attr = Attribute::get(F->getContext(), fromRust(RustAttr));
AttrBuilder B(Attr); AttrBuilder B(Attr);
const AttributeSet PALnew = PAL.removeAttributes( const AttributeSet PALNew = PAL.removeAttributes(
F->getContext(), index, AttributeSet::get(F->getContext(), index, B)); F->getContext(), Index, AttributeSet::get(F->getContext(), Index, B));
F->setAttributes(PALnew); F->setAttributes(PALNew);
} }
// enable fpmath flag UnsafeAlgebra // enable fpmath flag UnsafeAlgebra
@ -220,35 +220,35 @@ extern "C" void LLVMRustSetHasUnsafeAlgebra(LLVMValueRef V) {
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMValueRef source, const char *Name, LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMValueRef Source, const char *Name,
LLVMAtomicOrdering order, unsigned alignment) { LLVMAtomicOrdering Order, unsigned Alignment) {
LoadInst *li = new LoadInst(unwrap(source), 0); LoadInst *LI = new LoadInst(unwrap(Source), 0);
li->setAtomic(from_rust(order)); LI->setAtomic(fromRust(Order));
li->setAlignment(alignment); LI->setAlignment(Alignment);
return wrap(unwrap(B)->Insert(li, Name)); return wrap(unwrap(B)->Insert(LI, Name));
} }
extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B, extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
LLVMValueRef val, LLVMValueRef V,
LLVMValueRef target, LLVMValueRef Target,
LLVMAtomicOrdering order, LLVMAtomicOrdering Order,
unsigned alignment) { unsigned Alignment) {
StoreInst *si = new StoreInst(unwrap(val), unwrap(target)); StoreInst *SI = new StoreInst(unwrap(V), unwrap(Target));
si->setAtomic(from_rust(order)); SI->setAtomic(fromRust(Order));
si->setAlignment(alignment); SI->setAlignment(Alignment);
return wrap(unwrap(B)->Insert(si)); return wrap(unwrap(B)->Insert(SI));
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef target, LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Target,
LLVMValueRef old, LLVMValueRef source, LLVMValueRef Old, LLVMValueRef Source,
LLVMAtomicOrdering order, LLVMAtomicOrdering Order,
LLVMAtomicOrdering failure_order, LLVMBool weak) { LLVMAtomicOrdering FailureOrder, LLVMBool Weak) {
AtomicCmpXchgInst *acxi = unwrap(B)->CreateAtomicCmpXchg( AtomicCmpXchgInst *ACXI = unwrap(B)->CreateAtomicCmpXchg(
unwrap(target), unwrap(old), unwrap(source), from_rust(order), unwrap(Target), unwrap(Old), unwrap(Source), fromRust(Order),
from_rust(failure_order)); fromRust(FailureOrder));
acxi->setWeak(weak); ACXI->setWeak(Weak);
return wrap(acxi); return wrap(ACXI);
} }
enum class LLVMRustSynchronizationScope { enum class LLVMRustSynchronizationScope {
@ -257,8 +257,8 @@ enum class LLVMRustSynchronizationScope {
CrossThread, CrossThread,
}; };
static SynchronizationScope from_rust(LLVMRustSynchronizationScope scope) { static SynchronizationScope fromRust(LLVMRustSynchronizationScope Scope) {
switch (scope) { switch (Scope) {
case LLVMRustSynchronizationScope::SingleThread: case LLVMRustSynchronizationScope::SingleThread:
return SingleThread; return SingleThread;
case LLVMRustSynchronizationScope::CrossThread: case LLVMRustSynchronizationScope::CrossThread:
@ -269,9 +269,9 @@ static SynchronizationScope from_rust(LLVMRustSynchronizationScope scope) {
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering order, LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order,
LLVMRustSynchronizationScope scope) { LLVMRustSynchronizationScope Scope) {
return wrap(unwrap(B)->CreateFence(from_rust(order), from_rust(scope))); return wrap(unwrap(B)->CreateFence(fromRust(Order), fromRust(Scope)));
} }
extern "C" void LLVMRustSetDebug(int Enabled) { extern "C" void LLVMRustSetDebug(int Enabled) {
@ -286,8 +286,8 @@ enum class LLVMRustAsmDialect {
Intel, Intel,
}; };
static InlineAsm::AsmDialect from_rust(LLVMRustAsmDialect dialect) { static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
switch (dialect) { switch (Dialect) {
case LLVMRustAsmDialect::Att: case LLVMRustAsmDialect::Att:
return InlineAsm::AD_ATT; return InlineAsm::AD_ATT;
case LLVMRustAsmDialect::Intel: case LLVMRustAsmDialect::Intel:
@ -303,7 +303,7 @@ extern "C" LLVMValueRef LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString,
LLVMBool IsAlignStack, LLVMBool IsAlignStack,
LLVMRustAsmDialect Dialect) { LLVMRustAsmDialect Dialect) {
return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString, Constraints, return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString, Constraints,
HasSideEffects, IsAlignStack, from_rust(Dialect))); HasSideEffects, IsAlignStack, fromRust(Dialect)));
} }
typedef DIBuilder *LLVMRustDIBuilderRef; typedef DIBuilder *LLVMRustDIBuilderRef;
@ -318,13 +318,13 @@ inline Metadata **unwrap(LLVMRustMetadataRef *Vals) {
} }
} }
template <typename DIT> DIT *unwrapDIptr(LLVMRustMetadataRef ref) { template <typename DIT> DIT *unwrapDIPtr(LLVMRustMetadataRef Ref) {
return (DIT *)(ref ? unwrap<MDNode>(ref) : nullptr); return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
} }
#define DIDescriptor DIScope #define DIDescriptor DIScope
#define DIArray DINodeArray #define DIArray DINodeArray
#define unwrapDI unwrapDIptr #define unwrapDI unwrapDIPtr
// These values **must** match debuginfo::DIFlags! They also *happen* // These values **must** match debuginfo::DIFlags! They also *happen*
// to match LLVM, but that isn't required as we do giant sets of // to match LLVM, but that isn't required as we do giant sets of
@ -351,90 +351,90 @@ enum class LLVMRustDIFlags : uint32_t {
// version we support! // version we support!
}; };
inline LLVMRustDIFlags operator&(LLVMRustDIFlags a, LLVMRustDIFlags b) { inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) {
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(a) & return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) &
static_cast<uint32_t>(b)); static_cast<uint32_t>(B));
} }
inline LLVMRustDIFlags operator|(LLVMRustDIFlags a, LLVMRustDIFlags b) { inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) {
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(a) | return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) |
static_cast<uint32_t>(b)); static_cast<uint32_t>(B));
} }
inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &a, LLVMRustDIFlags b) { inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
return a = a | b; return A = A | B;
} }
inline bool is_set(LLVMRustDIFlags f) { return f != LLVMRustDIFlags::FlagZero; } inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
inline LLVMRustDIFlags visibility(LLVMRustDIFlags f) { inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(f) & 0x3); return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
} }
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
static DINode::DIFlags from_rust(LLVMRustDIFlags flags) { static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
DINode::DIFlags result = DINode::DIFlags::FlagZero; DINode::DIFlags Result = DINode::DIFlags::FlagZero;
#else #else
static unsigned from_rust(LLVMRustDIFlags flags) { static unsigned fromRust(LLVMRustDIFlags Flags) {
unsigned result = 0; unsigned Result = 0;
#endif #endif
switch (visibility(flags)) { switch (visibility(Flags)) {
case LLVMRustDIFlags::FlagPrivate: case LLVMRustDIFlags::FlagPrivate:
result |= DINode::DIFlags::FlagPrivate; Result |= DINode::DIFlags::FlagPrivate;
break; break;
case LLVMRustDIFlags::FlagProtected: case LLVMRustDIFlags::FlagProtected:
result |= DINode::DIFlags::FlagProtected; Result |= DINode::DIFlags::FlagProtected;
break; break;
case LLVMRustDIFlags::FlagPublic: case LLVMRustDIFlags::FlagPublic:
result |= DINode::DIFlags::FlagPublic; Result |= DINode::DIFlags::FlagPublic;
break; break;
default: default:
// The rest are handled below // The rest are handled below
break; break;
} }
if (is_set(flags & LLVMRustDIFlags::FlagFwdDecl)) { if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
result |= DINode::DIFlags::FlagFwdDecl; Result |= DINode::DIFlags::FlagFwdDecl;
} }
if (is_set(flags & LLVMRustDIFlags::FlagAppleBlock)) { if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
result |= DINode::DIFlags::FlagAppleBlock; Result |= DINode::DIFlags::FlagAppleBlock;
} }
if (is_set(flags & LLVMRustDIFlags::FlagBlockByrefStruct)) { if (isSet(Flags & LLVMRustDIFlags::FlagBlockByrefStruct)) {
result |= DINode::DIFlags::FlagBlockByrefStruct; Result |= DINode::DIFlags::FlagBlockByrefStruct;
} }
if (is_set(flags & LLVMRustDIFlags::FlagVirtual)) { if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
result |= DINode::DIFlags::FlagVirtual; Result |= DINode::DIFlags::FlagVirtual;
} }
if (is_set(flags & LLVMRustDIFlags::FlagArtificial)) { if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
result |= DINode::DIFlags::FlagArtificial; Result |= DINode::DIFlags::FlagArtificial;
} }
if (is_set(flags & LLVMRustDIFlags::FlagExplicit)) { if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
result |= DINode::DIFlags::FlagExplicit; Result |= DINode::DIFlags::FlagExplicit;
} }
if (is_set(flags & LLVMRustDIFlags::FlagPrototyped)) { if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
result |= DINode::DIFlags::FlagPrototyped; Result |= DINode::DIFlags::FlagPrototyped;
} }
if (is_set(flags & LLVMRustDIFlags::FlagObjcClassComplete)) { if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
result |= DINode::DIFlags::FlagObjcClassComplete; Result |= DINode::DIFlags::FlagObjcClassComplete;
} }
if (is_set(flags & LLVMRustDIFlags::FlagObjectPointer)) { if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
result |= DINode::DIFlags::FlagObjectPointer; Result |= DINode::DIFlags::FlagObjectPointer;
} }
if (is_set(flags & LLVMRustDIFlags::FlagVector)) { if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
result |= DINode::DIFlags::FlagVector; Result |= DINode::DIFlags::FlagVector;
} }
if (is_set(flags & LLVMRustDIFlags::FlagStaticMember)) { if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
result |= DINode::DIFlags::FlagStaticMember; Result |= DINode::DIFlags::FlagStaticMember;
} }
if (is_set(flags & LLVMRustDIFlags::FlagLValueReference)) { if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
result |= DINode::DIFlags::FlagLValueReference; Result |= DINode::DIFlags::FlagLValueReference;
} }
if (is_set(flags & LLVMRustDIFlags::FlagRValueReference)) { if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
result |= DINode::DIFlags::FlagRValueReference; Result |= DINode::DIFlags::FlagRValueReference;
} }
return result; return Result;
} }
extern "C" uint32_t LLVMRustDebugMetadataVersion() { extern "C" uint32_t LLVMRustDebugMetadataVersion() {
@ -445,9 +445,9 @@ extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; } extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M, const char *name, extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M, const char *Name,
uint32_t value) { uint32_t Value) {
unwrap(M)->addModuleFlag(Module::Warning, name, value); unwrap(M)->addModuleFlag(Module::Warning, Name, Value);
} }
extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) { extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
@ -490,25 +490,25 @@ LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateFunction( extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateFunction(
LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Scope, const char *Name, LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Scope, const char *Name,
const char *LinkageName, LLVMRustMetadataRef File, unsigned LineNo, const char *LinkageName, LLVMRustMetadataRef File, unsigned LineNo,
LLVMRustMetadataRef Ty, bool isLocalToUnit, bool isDefinition, LLVMRustMetadataRef Ty, bool IsLocalToUnit, bool IsDefinition,
unsigned ScopeLine, LLVMRustDIFlags Flags, bool isOptimized, unsigned ScopeLine, LLVMRustDIFlags Flags, bool IsOptimized,
LLVMValueRef Fn, LLVMRustMetadataRef TParam, LLVMRustMetadataRef Decl) { LLVMValueRef Fn, LLVMRustMetadataRef TParam, LLVMRustMetadataRef Decl) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
DITemplateParameterArray TParams = DITemplateParameterArray TParams =
DITemplateParameterArray(unwrap<MDTuple>(TParam)); DITemplateParameterArray(unwrap<MDTuple>(TParam));
DISubprogram *Sub = Builder->createFunction( DISubprogram *Sub = Builder->createFunction(
unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File), unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
LineNo, unwrapDI<DISubroutineType>(Ty), isLocalToUnit, isDefinition, LineNo, unwrapDI<DISubroutineType>(Ty), IsLocalToUnit, IsDefinition,
ScopeLine, from_rust(Flags), isOptimized, TParams, ScopeLine, fromRust(Flags), IsOptimized, TParams,
unwrapDIptr<DISubprogram>(Decl)); unwrapDIPtr<DISubprogram>(Decl));
unwrap<Function>(Fn)->setSubprogram(Sub); unwrap<Function>(Fn)->setSubprogram(Sub);
return wrap(Sub); return wrap(Sub);
#else #else
return wrap(Builder->createFunction( return wrap(Builder->createFunction(
unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File), unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
LineNo, unwrapDI<DISubroutineType>(Ty), isLocalToUnit, isDefinition, LineNo, unwrapDI<DISubroutineType>(Ty), IsLocalToUnit, IsDefinition,
ScopeLine, from_rust(Flags), isOptimized, unwrap<Function>(Fn), ScopeLine, fromRust(Flags), IsOptimized, unwrap<Function>(Fn),
unwrapDIptr<MDNode>(TParam), unwrapDIptr<MDNode>(Decl))); unwrapDIPtr<MDNode>(TParam), unwrapDIPtr<MDNode>(Decl)));
#endif #endif
} }
@ -539,7 +539,7 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateStructType(
const char *UniqueId) { const char *UniqueId) {
return wrap(Builder->createStructType( return wrap(Builder->createStructType(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
SizeInBits, AlignInBits, from_rust(Flags), unwrapDI<DIType>(DerivedFrom), SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
unwrapDI<DIType>(VTableHolder), UniqueId)); unwrapDI<DIType>(VTableHolder), UniqueId));
} }
@ -549,10 +549,10 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateMemberType(
LLVMRustMetadataRef File, unsigned LineNo, uint64_t SizeInBits, LLVMRustMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
uint64_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags, uint64_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
LLVMRustMetadataRef Ty) { LLVMRustMetadataRef Ty) {
return wrap(Builder->createMemberType( return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), Name,
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo, unwrapDI<DIFile>(File), LineNo,
SizeInBits, AlignInBits, OffsetInBits, from_rust(Flags), SizeInBits, AlignInBits, OffsetInBits,
unwrapDI<DIType>(Ty))); fromRust(Flags), unwrapDI<DIType>(Ty)));
} }
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateLexicalBlock( extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
@ -573,9 +573,9 @@ LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateStaticVariable( extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateStaticVariable(
LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Context, const char *Name, LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Context, const char *Name,
const char *LinkageName, LLVMRustMetadataRef File, unsigned LineNo, const char *LinkageName, LLVMRustMetadataRef File, unsigned LineNo,
LLVMRustMetadataRef Ty, bool isLocalToUnit, LLVMValueRef Val, LLVMRustMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
LLVMRustMetadataRef Decl = nullptr, uint64_t AlignInBits = 0) { LLVMRustMetadataRef Decl = nullptr, uint64_t AlignInBits = 0) {
Constant *InitVal = cast<Constant>(unwrap(Val)); Constant *InitVal = cast<Constant>(unwrap(V));
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
llvm::DIExpression *InitExpr = nullptr; llvm::DIExpression *InitExpr = nullptr;
@ -591,15 +591,15 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateStaticVariable(
return wrap(Builder->createGlobalVariable( return wrap(Builder->createGlobalVariable(
unwrapDI<DIDescriptor>(Context), Name, LinkageName, unwrapDI<DIDescriptor>(Context), Name, LinkageName,
unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), isLocalToUnit, unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
InitExpr, InitExpr,
#else #else
InitVal, InitVal,
#endif #endif
unwrapDIptr<MDNode>(Decl) unwrapDIPtr<MDNode>(Decl)
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
, ,
AlignInBits AlignInBits
#endif #endif
)); ));
@ -614,21 +614,21 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateVariable(
if (Tag == 0x100) { // DW_TAG_auto_variable if (Tag == 0x100) { // DW_TAG_auto_variable
return wrap(Builder->createAutoVariable( return wrap(Builder->createAutoVariable(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo,
unwrapDI<DIType>(Ty), AlwaysPreserve, from_rust(Flags) unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
, ,
AlignInBits AlignInBits
#endif #endif
)); ));
} else { } else {
return wrap(Builder->createParameterVariable( return wrap(Builder->createParameterVariable(
unwrapDI<DIDescriptor>(Scope), Name, ArgNo, unwrapDI<DIFile>(File), unwrapDI<DIDescriptor>(Scope), Name, ArgNo, unwrapDI<DIFile>(File),
LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve, from_rust(Flags))); LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
} }
#else #else
return wrap(Builder->createLocalVariable( return wrap(Builder->createLocalVariable(
Tag, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo, Tag, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo,
unwrapDI<DIType>(Ty), AlwaysPreserve, from_rust(Flags), ArgNo)); unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), ArgNo));
#endif #endif
} }
@ -665,11 +665,11 @@ LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
} }
extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd( extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
LLVMRustDIBuilderRef Builder, LLVMValueRef Val, LLVMRustMetadataRef VarInfo, LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMRustMetadataRef VarInfo,
int64_t *AddrOps, unsigned AddrOpsCount, LLVMValueRef DL, int64_t *AddrOps, unsigned AddrOpsCount, LLVMValueRef DL,
LLVMBasicBlockRef InsertAtEnd) { LLVMBasicBlockRef InsertAtEnd) {
return wrap(Builder->insertDeclare( return wrap(Builder->insertDeclare(
unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap(V), unwrap<DILocalVariable>(VarInfo),
Builder->createExpression(llvm::ArrayRef<int64_t>(AddrOps, AddrOpsCount)), Builder->createExpression(llvm::ArrayRef<int64_t>(AddrOps, AddrOpsCount)),
DebugLoc(cast<MDNode>(unwrap<MetadataAsValue>(DL)->getMetadata())), DebugLoc(cast<MDNode>(unwrap<MetadataAsValue>(DL)->getMetadata())),
unwrap(InsertAtEnd))); unwrap(InsertAtEnd)));
@ -685,11 +685,11 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateEnumerationType(
LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Scope, const char *Name, LLVMRustDIBuilderRef Builder, LLVMRustMetadataRef Scope, const char *Name,
LLVMRustMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, LLVMRustMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
uint64_t AlignInBits, LLVMRustMetadataRef Elements, uint64_t AlignInBits, LLVMRustMetadataRef Elements,
LLVMRustMetadataRef ClassType) { LLVMRustMetadataRef ClassTy) {
return wrap(Builder->createEnumerationType( return wrap(Builder->createEnumerationType(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)), SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
unwrapDI<DIType>(ClassType))); unwrapDI<DIType>(ClassTy)));
} }
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateUnionType( extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateUnionType(
@ -699,7 +699,7 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateUnionType(
unsigned RunTimeLang, const char *UniqueId) { unsigned RunTimeLang, const char *UniqueId) {
return wrap(Builder->createUnionType( return wrap(Builder->createUnionType(
unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
SizeInBits, AlignInBits, from_rust(Flags), SizeInBits, AlignInBits, fromRust(Flags),
DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, UniqueId)); DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, UniqueId));
} }
@ -726,22 +726,22 @@ LLVMRustDIBuilderCreateNameSpace(LLVMRustDIBuilderRef Builder,
extern "C" void extern "C" void
LLVMRustDICompositeTypeSetTypeArray(LLVMRustDIBuilderRef Builder, LLVMRustDICompositeTypeSetTypeArray(LLVMRustDIBuilderRef Builder,
LLVMRustMetadataRef CompositeType, LLVMRustMetadataRef CompositeTy,
LLVMRustMetadataRef TypeArray) { LLVMRustMetadataRef TyArray) {
DICompositeType *tmp = unwrapDI<DICompositeType>(CompositeType); DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
Builder->replaceArrays(tmp, DINodeArray(unwrap<MDTuple>(TypeArray))); Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(TyArray)));
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustDIBuilderCreateDebugLocation(LLVMContextRef Context, unsigned Line, LLVMRustDIBuilderCreateDebugLocation(LLVMContextRef ContextRef, unsigned Line,
unsigned Column, LLVMRustMetadataRef Scope, unsigned Column, LLVMRustMetadataRef Scope,
LLVMRustMetadataRef InlinedAt) { LLVMRustMetadataRef InlinedAt) {
LLVMContext &context = *unwrap(Context); LLVMContext &Context = *unwrap(ContextRef);
DebugLoc debug_loc = DebugLoc::get(Line, Column, unwrapDIptr<MDNode>(Scope), DebugLoc debug_loc = DebugLoc::get(Line, Column, unwrapDIPtr<MDNode>(Scope),
unwrapDIptr<MDNode>(InlinedAt)); unwrapDIPtr<MDNode>(InlinedAt));
return wrap(MetadataAsValue::get(context, debug_loc.getAsMDNode())); return wrap(MetadataAsValue::get(Context, debug_loc.getAsMDNode()));
} }
extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() { extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() {
@ -750,31 +750,31 @@ extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() {
extern "C" int64_t LLVMRustDIBuilderCreateOpPlus() { return dwarf::DW_OP_plus; } extern "C" int64_t LLVMRustDIBuilderCreateOpPlus() { return dwarf::DW_OP_plus; }
extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Type, RustStringRef str) { extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
unwrap<llvm::Type>(Type)->print(os); unwrap<llvm::Type>(Ty)->print(OS);
} }
extern "C" void LLVMRustWriteValueToString(LLVMValueRef Value, extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
RustStringRef str) { RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
os << "("; OS << "(";
unwrap<llvm::Value>(Value)->getType()->print(os); unwrap<llvm::Value>(V)->getType()->print(OS);
os << ":"; OS << ":";
unwrap<llvm::Value>(Value)->print(os); unwrap<llvm::Value>(V)->print(OS);
os << ")"; OS << ")";
} }
extern "C" bool LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc, extern "C" bool LLVMRustLinkInExternalBitcode(LLVMModuleRef DstRef, char *BC,
size_t len) { size_t Len) {
Module *Dst = unwrap(dst); Module *Dst = unwrap(DstRef);
std::unique_ptr<MemoryBuffer> buf = std::unique_ptr<MemoryBuffer> Buf =
MemoryBuffer::getMemBufferCopy(StringRef(bc, len)); MemoryBuffer::getMemBufferCopy(StringRef(BC, Len));
#if LLVM_VERSION_GE(4, 0) #if LLVM_VERSION_GE(4, 0)
Expected<std::unique_ptr<Module>> SrcOrError = Expected<std::unique_ptr<Module>> SrcOrError =
llvm::getLazyBitcodeModule(buf->getMemBufferRef(), Dst->getContext()); llvm::getLazyBitcodeModule(Buf->getMemBufferRef(), Dst->getContext());
if (!SrcOrError) { if (!SrcOrError) {
LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str()); LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str());
return false; return false;
@ -783,7 +783,7 @@ extern "C" bool LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc,
auto Src = std::move(*SrcOrError); auto Src = std::move(*SrcOrError);
#else #else
ErrorOr<std::unique_ptr<Module>> Src = ErrorOr<std::unique_ptr<Module>> Src =
llvm::getLazyBitcodeModule(std::move(buf), Dst->getContext()); llvm::getLazyBitcodeModule(std::move(Buf), Dst->getContext());
if (!Src) { if (!Src) {
LLVMRustSetLastError(Src.getError().message().c_str()); LLVMRustSetLastError(Src.getError().message().c_str());
return false; return false;
@ -824,61 +824,62 @@ inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
} }
extern "C" size_t LLVMRustGetSectionName(LLVMSectionIteratorRef SI, extern "C" size_t LLVMRustGetSectionName(LLVMSectionIteratorRef SI,
const char **ptr) { const char **Ptr) {
StringRef ret; StringRef Ret;
if (std::error_code ec = (*unwrap(SI))->getName(ret)) if (std::error_code EC = (*unwrap(SI))->getName(Ret))
report_fatal_error(ec.message()); report_fatal_error(EC.message());
*ptr = ret.data(); *Ptr = Ret.data();
return ret.size(); return Ret.size();
} }
// LLVMArrayType function does not support 64-bit ElementCount // LLVMArrayType function does not support 64-bit ElementCount
extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementType, extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
uint64_t ElementCount) { uint64_t ElementCount) {
return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
} }
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DebugLoc, LLVMDebugLocRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DebugLoc, LLVMDebugLocRef)
extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef str) { extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
unwrap(T)->print(os); unwrap(T)->print(OS);
} }
extern "C" void LLVMRustUnpackOptimizationDiagnostic( extern "C" void LLVMRustUnpackOptimizationDiagnostic(
LLVMDiagnosticInfoRef di, RustStringRef pass_name_out, LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
LLVMValueRef *function_out, LLVMDebugLocRef *debugloc_out, LLVMValueRef *FunctionOut, LLVMDebugLocRef *DebugLocOut,
RustStringRef message_out) { RustStringRef MessageOut) {
// Undefined to call this not on an optimization diagnostic! // Undefined to call this not on an optimization diagnostic!
llvm::DiagnosticInfoOptimizationBase *opt = llvm::DiagnosticInfoOptimizationBase *Opt =
static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(di)); static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
raw_rust_string_ostream pass_name_os(pass_name_out); RawRustStringOstream PassNameOS(PassNameOut);
pass_name_os << opt->getPassName(); PassNameOS << Opt->getPassName();
*function_out = wrap(&opt->getFunction()); *FunctionOut = wrap(&Opt->getFunction());
*debugloc_out = wrap(&opt->getDebugLoc()); *DebugLocOut = wrap(&Opt->getDebugLoc());
raw_rust_string_ostream message_os(message_out); RawRustStringOstream MessageOS(MessageOut);
message_os << opt->getMsg(); MessageOS << Opt->getMsg();
} }
extern "C" void LLVMRustUnpackInlineAsmDiagnostic( extern "C" void
LLVMDiagnosticInfoRef di, unsigned *cookie_out, LLVMTwineRef *message_out, LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI, unsigned *CookieOut,
LLVMValueRef *instruction_out) { LLVMTwineRef *MessageOut,
LLVMValueRef *InstructionOut) {
// Undefined to call this not on an inline assembly diagnostic! // Undefined to call this not on an inline assembly diagnostic!
llvm::DiagnosticInfoInlineAsm *ia = llvm::DiagnosticInfoInlineAsm *IA =
static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(di)); static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
*cookie_out = ia->getLocCookie(); *CookieOut = IA->getLocCookie();
*message_out = wrap(&ia->getMsgStr()); *MessageOut = wrap(&IA->getMsgStr());
*instruction_out = wrap(ia->getInstruction()); *InstructionOut = wrap(IA->getInstruction());
} }
extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef di, extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI,
RustStringRef str) { RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
DiagnosticPrinterRawOStream dp(os); DiagnosticPrinterRawOStream DP(OS);
unwrap(di)->print(dp); unwrap(DI)->print(DP);
} }
enum class LLVMRustDiagnosticKind { enum class LLVMRustDiagnosticKind {
@ -896,8 +897,8 @@ enum class LLVMRustDiagnosticKind {
OptimizationFailure, OptimizationFailure,
}; };
static LLVMRustDiagnosticKind to_rust(DiagnosticKind kind) { static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
switch (kind) { switch (Kind) {
case DK_InlineAsm: case DK_InlineAsm:
return LLVMRustDiagnosticKind::InlineAsm; return LLVMRustDiagnosticKind::InlineAsm;
case DK_StackSize: case DK_StackSize:
@ -920,7 +921,7 @@ static LLVMRustDiagnosticKind to_rust(DiagnosticKind kind) {
#endif #endif
default: default:
#if LLVM_VERSION_GE(3, 9) #if LLVM_VERSION_GE(3, 9)
return (kind >= DK_FirstRemark && kind <= DK_LastRemark) return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
? LLVMRustDiagnosticKind::OptimizationRemarkOther ? LLVMRustDiagnosticKind::OptimizationRemarkOther
: LLVMRustDiagnosticKind::Other; : LLVMRustDiagnosticKind::Other;
#else #else
@ -930,8 +931,8 @@ static LLVMRustDiagnosticKind to_rust(DiagnosticKind kind) {
} }
extern "C" LLVMRustDiagnosticKind extern "C" LLVMRustDiagnosticKind
LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef di) { LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
return to_rust((DiagnosticKind)unwrap(di)->getKind()); return toRust((DiagnosticKind)unwrap(DI)->getKind());
} }
// This is kept distinct from LLVMGetTypeKind, because when // This is kept distinct from LLVMGetTypeKind, because when
// a new type kind is added, the Rust-side enum must be // a new type kind is added, the Rust-side enum must be
@ -979,10 +980,10 @@ extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
} }
extern "C" void LLVMRustWriteDebugLocToString(LLVMContextRef C, extern "C" void LLVMRustWriteDebugLocToString(LLVMContextRef C,
LLVMDebugLocRef dl, LLVMDebugLocRef DL,
RustStringRef str) { RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
unwrap(dl)->print(os); unwrap(DL)->print(OS);
} }
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
@ -992,82 +993,82 @@ extern "C" void LLVMRustSetInlineAsmDiagnosticHandler(
unwrap(C)->setInlineAsmDiagnosticHandler(H, CX); unwrap(C)->setInlineAsmDiagnosticHandler(H, CX);
} }
extern "C" void LLVMRustWriteSMDiagnosticToString(LLVMSMDiagnosticRef d, extern "C" void LLVMRustWriteSMDiagnosticToString(LLVMSMDiagnosticRef D,
RustStringRef str) { RustStringRef Str) {
raw_rust_string_ostream os(str); RawRustStringOstream OS(Str);
unwrap(d)->print("", os); unwrap(D)->print("", OS);
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustBuildLandingPad(LLVMBuilderRef Builder, LLVMTypeRef Ty, LLVMRustBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
LLVMValueRef PersFn, unsigned NumClauses, LLVMValueRef PersFn, unsigned NumClauses,
const char *Name, LLVMValueRef F) { const char *Name, LLVMValueRef F) {
return LLVMBuildLandingPad(Builder, Ty, PersFn, NumClauses, Name); return LLVMBuildLandingPad(B, Ty, PersFn, NumClauses, Name);
} }
extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef Builder, extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef B,
LLVMValueRef ParentPad, LLVMValueRef ParentPad,
unsigned ArgCnt, unsigned ArgCount,
LLVMValueRef *LLArgs, LLVMValueRef *LLArgs,
const char *Name) { const char *Name) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
Value **Args = unwrap(LLArgs); Value **Args = unwrap(LLArgs);
if (ParentPad == nullptr) { if (ParentPad == nullptr) {
Type *Ty = Type::getTokenTy(unwrap(Builder)->getContext()); Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
ParentPad = wrap(Constant::getNullValue(Ty)); ParentPad = wrap(Constant::getNullValue(Ty));
} }
return wrap(unwrap(Builder)->CreateCleanupPad( return wrap(unwrap(B)->CreateCleanupPad(
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCnt), Name)); unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
#else #else
return nullptr; return nullptr;
#endif #endif
} }
extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef Builder, extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef B,
LLVMValueRef CleanupPad, LLVMValueRef CleanupPad,
LLVMBasicBlockRef UnwindBB) { LLVMBasicBlockRef UnwindBB) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad)); CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad));
return wrap(unwrap(Builder)->CreateCleanupRet(Inst, unwrap(UnwindBB))); return wrap(unwrap(B)->CreateCleanupRet(Inst, unwrap(UnwindBB)));
#else #else
return nullptr; return nullptr;
#endif #endif
} }
extern "C" LLVMValueRef extern "C" LLVMValueRef
LLVMRustBuildCatchPad(LLVMBuilderRef Builder, LLVMValueRef ParentPad, LLVMRustBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
unsigned ArgCnt, LLVMValueRef *LLArgs, const char *Name) { unsigned ArgCount, LLVMValueRef *LLArgs, const char *Name) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
Value **Args = unwrap(LLArgs); Value **Args = unwrap(LLArgs);
return wrap(unwrap(Builder)->CreateCatchPad( return wrap(unwrap(B)->CreateCatchPad(
unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCnt), Name)); unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
#else #else
return nullptr; return nullptr;
#endif #endif
} }
extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef Builder, extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef B,
LLVMValueRef Pad, LLVMValueRef Pad,
LLVMBasicBlockRef BB) { LLVMBasicBlockRef BB) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
return wrap(unwrap(Builder)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)), return wrap(unwrap(B)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)),
unwrap(BB))); unwrap(BB)));
#else #else
return nullptr; return nullptr;
#endif #endif
} }
extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef Builder, extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef B,
LLVMValueRef ParentPad, LLVMValueRef ParentPad,
LLVMBasicBlockRef BB, LLVMBasicBlockRef BB,
unsigned NumHandlers, unsigned NumHandlers,
const char *Name) { const char *Name) {
#if LLVM_VERSION_GE(3, 8) #if LLVM_VERSION_GE(3, 8)
if (ParentPad == nullptr) { if (ParentPad == nullptr) {
Type *Ty = Type::getTokenTy(unwrap(Builder)->getContext()); Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
ParentPad = wrap(Constant::getNullValue(Ty)); ParentPad = wrap(Constant::getNullValue(Ty));
} }
return wrap(unwrap(Builder)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB), return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB),
NumHandlers, Name)); NumHandlers, Name));
#else #else
return nullptr; return nullptr;
@ -1105,8 +1106,8 @@ extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
LLVMValueRef *Args, unsigned NumArgs, LLVMValueRef *Args, unsigned NumArgs,
OperandBundleDef *Bundle, OperandBundleDef *Bundle,
const char *Name) { const char *Name) {
unsigned len = Bundle ? 1 : 0; unsigned Len = Bundle ? 1 : 0;
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, len); ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
return wrap(unwrap(B)->CreateCall( return wrap(unwrap(B)->CreateCall(
unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Bundles, Name)); unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Bundles, Name));
} }
@ -1116,8 +1117,8 @@ LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
unsigned NumArgs, LLVMBasicBlockRef Then, unsigned NumArgs, LLVMBasicBlockRef Then,
LLVMBasicBlockRef Catch, OperandBundleDef *Bundle, LLVMBasicBlockRef Catch, OperandBundleDef *Bundle,
const char *Name) { const char *Name) {
unsigned len = Bundle ? 1 : 0; unsigned Len = Bundle ? 1 : 0;
ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, len); ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch), return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
makeArrayRef(unwrap(Args), NumArgs), makeArrayRef(unwrap(Args), NumArgs),
Bundles, Name)); Bundles, Name));
@ -1147,8 +1148,8 @@ LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B, extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
LLVMBasicBlockRef BB) { LLVMBasicBlockRef BB) {
auto point = unwrap(BB)->getFirstInsertionPt(); auto Point = unwrap(BB)->getFirstInsertionPt();
unwrap(B)->SetInsertPoint(unwrap(BB), point); unwrap(B)->SetInsertPoint(unwrap(BB), Point);
} }
extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V, extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
@ -1179,8 +1180,8 @@ enum class LLVMRustLinkage {
CommonLinkage = 10, CommonLinkage = 10,
}; };
static LLVMRustLinkage to_rust(LLVMLinkage linkage) { static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
switch (linkage) { switch (Linkage) {
case LLVMExternalLinkage: case LLVMExternalLinkage:
return LLVMRustLinkage::ExternalLinkage; return LLVMRustLinkage::ExternalLinkage;
case LLVMAvailableExternallyLinkage: case LLVMAvailableExternallyLinkage:
@ -1208,8 +1209,8 @@ static LLVMRustLinkage to_rust(LLVMLinkage linkage) {
} }
} }
static LLVMLinkage from_rust(LLVMRustLinkage linkage) { static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
switch (linkage) { switch (Linkage) {
case LLVMRustLinkage::ExternalLinkage: case LLVMRustLinkage::ExternalLinkage:
return LLVMExternalLinkage; return LLVMExternalLinkage;
case LLVMRustLinkage::AvailableExternallyLinkage: case LLVMRustLinkage::AvailableExternallyLinkage:
@ -1238,12 +1239,12 @@ static LLVMLinkage from_rust(LLVMRustLinkage linkage) {
} }
extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) { extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
return to_rust(LLVMGetLinkage(V)); return toRust(LLVMGetLinkage(V));
} }
extern "C" void LLVMRustSetLinkage(LLVMValueRef V, extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
LLVMRustLinkage RustLinkage) { LLVMRustLinkage RustLinkage) {
LLVMSetLinkage(V, from_rust(RustLinkage)); LLVMSetLinkage(V, fromRust(RustLinkage));
} }
extern "C" LLVMContextRef LLVMRustGetValueContext(LLVMValueRef V) { extern "C" LLVMContextRef LLVMRustGetValueContext(LLVMValueRef V) {
@ -1256,8 +1257,8 @@ enum class LLVMRustVisibility {
Protected = 2, Protected = 2,
}; };
static LLVMRustVisibility to_rust(LLVMVisibility vis) { static LLVMRustVisibility toRust(LLVMVisibility Vis) {
switch (vis) { switch (Vis) {
case LLVMDefaultVisibility: case LLVMDefaultVisibility:
return LLVMRustVisibility::Default; return LLVMRustVisibility::Default;
case LLVMHiddenVisibility: case LLVMHiddenVisibility:
@ -1270,8 +1271,8 @@ static LLVMRustVisibility to_rust(LLVMVisibility vis) {
} }
} }
static LLVMVisibility from_rust(LLVMRustVisibility vis) { static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
switch (vis) { switch (Vis) {
case LLVMRustVisibility::Default: case LLVMRustVisibility::Default:
return LLVMDefaultVisibility; return LLVMDefaultVisibility;
case LLVMRustVisibility::Hidden: case LLVMRustVisibility::Hidden:
@ -1285,10 +1286,10 @@ static LLVMVisibility from_rust(LLVMRustVisibility vis) {
} }
extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) { extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
return to_rust(LLVMGetVisibility(V)); return toRust(LLVMGetVisibility(V));
} }
extern "C" void LLVMRustSetVisibility(LLVMValueRef V, extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
LLVMRustVisibility RustVisibility) { LLVMRustVisibility RustVisibility) {
LLVMSetVisibility(V, from_rust(RustVisibility)); LLVMSetVisibility(V, fromRust(RustVisibility));
} }

22
src/rustllvm/rustllvm.h
View file

@ -106,24 +106,24 @@ typedef struct LLVMOpaqueDebugLoc *LLVMDebugLocRef;
typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef; typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef; typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef;
extern "C" void rust_llvm_string_write_impl(RustStringRef str, const char *ptr, extern "C" void LLVMRustStringWriteImpl(RustStringRef Str, const char *Ptr,
size_t size); size_t Size);
class raw_rust_string_ostream : public llvm::raw_ostream { class RawRustStringOstream : 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); LLVMRustStringWriteImpl(Str, Ptr, Size);
pos += size; Pos += Size;
} }
uint64_t current_pos() const override { return pos; } uint64_t current_pos() const override { return Pos; }
public: public:
explicit raw_rust_string_ostream(RustStringRef str) : str(str), pos(0) {} explicit RawRustStringOstream(RustStringRef Str) : Str(Str), Pos(0) {}
~raw_rust_string_ostream() { ~RawRustStringOstream() {
// LLVM requires this. // LLVM requires this.
flush(); flush();
} }