fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
1#include "LLVMWrapper.h" 2 3#include "llvm/Object/Archive.h" 4#include "llvm/Object/ArchiveWriter.h" 5#include "llvm/Support/Path.h" 6 7using namespace llvm; 8using namespace llvm::object; 9 10struct RustArchiveMember { 11 const char *Filename; 12 const char *Name; 13 Archive::Child Child; 14 15 RustArchiveMember() 16 : Filename(nullptr), Name(nullptr), 17 Child(nullptr, nullptr, nullptr) 18 { 19 } 20 ~RustArchiveMember() {} 21}; 22 23struct RustArchiveIterator { 24 bool First; 25 Archive::child_iterator Cur; 26 Archive::child_iterator End; 27 std::unique_ptr<Error> Err; 28 29 RustArchiveIterator(Archive::child_iterator Cur, Archive::child_iterator End, 30 std::unique_ptr<Error> Err) 31 : First(true), 32 Cur(Cur), 33 End(End), 34 Err(std::move(Err)) {} 35}; 36 37enum class LLVMRustArchiveKind { 38 GNU, 39 BSD, 40 DARWIN, 41 COFF, 42 AIX_BIG, 43}; 44 45static Archive::Kind fromRust(LLVMRustArchiveKind Kind) { 46 switch (Kind) { 47 case LLVMRustArchiveKind::GNU: 48 return Archive::K_GNU; 49 case LLVMRustArchiveKind::BSD: 50 return Archive::K_BSD; 51 case LLVMRustArchiveKind::DARWIN: 52 return Archive::K_DARWIN; 53 case LLVMRustArchiveKind::COFF: 54 return Archive::K_COFF; 55 case LLVMRustArchiveKind::AIX_BIG: 56 return Archive::K_AIXBIG; 57 default: 58 report_fatal_error("Bad ArchiveKind."); 59 } 60} 61 62typedef OwningBinary<Archive> *LLVMRustArchiveRef; 63typedef RustArchiveMember *LLVMRustArchiveMemberRef; 64typedef Archive::Child *LLVMRustArchiveChildRef; 65typedef Archive::Child const *LLVMRustArchiveChildConstRef; 66typedef RustArchiveIterator *LLVMRustArchiveIteratorRef; 67 68extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *Path) { 69 ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr = 70 MemoryBuffer::getFile(Path, -1, false); 71 if (!BufOr) { 72 LLVMRustSetLastError(BufOr.getError().message().c_str()); 73 return nullptr; 74 } 75 76 Expected<std::unique_ptr<Archive>> ArchiveOr = 77 Archive::create(BufOr.get()->getMemBufferRef()); 78 79 if (!ArchiveOr) { 80 LLVMRustSetLastError(toString(ArchiveOr.takeError()).c_str()); 81 return nullptr; 82 } 83 84 OwningBinary<Archive> *Ret = new OwningBinary<Archive>( 85 std::move(ArchiveOr.get()), std::move(BufOr.get())); 86 87 return Ret; 88} 89 90extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef RustArchive) { 91 delete RustArchive; 92} 93 94extern "C" LLVMRustArchiveIteratorRef 95LLVMRustArchiveIteratorNew(LLVMRustArchiveRef RustArchive) { 96 Archive *Archive = RustArchive->getBinary(); 97 std::unique_ptr<Error> Err = std::make_unique<Error>(Error::success()); 98 auto Cur = Archive->child_begin(*Err); 99 if (*Err) { 100 LLVMRustSetLastError(toString(std::move(*Err)).c_str()); 101 return nullptr; 102 } 103 auto End = Archive->child_end(); 104 return new RustArchiveIterator(Cur, End, std::move(Err)); 105} 106 107extern "C" LLVMRustArchiveChildConstRef 108LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef RAI) { 109 if (RAI->Cur == RAI->End) 110 return nullptr; 111 112 // Advancing the iterator validates the next child, and this can 113 // uncover an error. LLVM requires that we check all Errors, 114 // so we only advance the iterator if we actually need to fetch 115 // the next child. 116 // This means we must not advance the iterator in the *first* call, 117 // but instead advance it *before* fetching the child in all later calls. 118 if (!RAI->First) { 119 ++RAI->Cur; 120 if (*RAI->Err) { 121 LLVMRustSetLastError(toString(std::move(*RAI->Err)).c_str()); 122 return nullptr; 123 } 124 } else { 125 RAI->First = false; 126 } 127 128 if (RAI->Cur == RAI->End) 129 return nullptr; 130 131 const Archive::Child &Child = *RAI->Cur.operator->(); 132 Archive::Child *Ret = new Archive::Child(Child); 133 134 return Ret; 135} 136 137extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef Child) { 138 delete Child; 139} 140 141extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef RAI) { 142 delete RAI; 143} 144 145extern "C" const char * 146LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef Child, size_t *Size) { 147 Expected<StringRef> NameOrErr = Child->getName(); 148 if (!NameOrErr) { 149 // rustc_codegen_llvm currently doesn't use this error string, but it might be 150 // useful in the future, and in the mean time this tells LLVM that the 151 // error was not ignored and that it shouldn't abort the process. 152 LLVMRustSetLastError(toString(NameOrErr.takeError()).c_str()); 153 return nullptr; 154 } 155 StringRef Name = NameOrErr.get(); 156 *Size = Name.size(); 157 return Name.data(); 158} 159 160extern "C" LLVMRustArchiveMemberRef 161LLVMRustArchiveMemberNew(char *Filename, char *Name, 162 LLVMRustArchiveChildRef Child) { 163 RustArchiveMember *Member = new RustArchiveMember; 164 Member->Filename = Filename; 165 Member->Name = Name; 166 if (Child) 167 Member->Child = *Child; 168 return Member; 169} 170 171extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) { 172 delete Member; 173} 174 175extern "C" LLVMRustResult 176LLVMRustWriteArchive(char *Dst, size_t NumMembers, 177 const LLVMRustArchiveMemberRef *NewMembers, 178 bool WriteSymbtab, LLVMRustArchiveKind RustKind) { 179 180 std::vector<NewArchiveMember> Members; 181 auto Kind = fromRust(RustKind); 182 183 for (size_t I = 0; I < NumMembers; I++) { 184 auto Member = NewMembers[I]; 185 assert(Member->Name); 186 if (Member->Filename) { 187 Expected<NewArchiveMember> MOrErr = 188 NewArchiveMember::getFile(Member->Filename, true); 189 if (!MOrErr) { 190 LLVMRustSetLastError(toString(MOrErr.takeError()).c_str()); 191 return LLVMRustResult::Failure; 192 } 193 MOrErr->MemberName = sys::path::filename(MOrErr->MemberName); 194 Members.push_back(std::move(*MOrErr)); 195 } else { 196 Expected<NewArchiveMember> MOrErr = 197 NewArchiveMember::getOldMember(Member->Child, true); 198 if (!MOrErr) { 199 LLVMRustSetLastError(toString(MOrErr.takeError()).c_str()); 200 return LLVMRustResult::Failure; 201 } 202 Members.push_back(std::move(*MOrErr)); 203 } 204 } 205 206#if LLVM_VERSION_LT(18, 0) 207 auto Result = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false); 208#else 209 auto SymtabMode = WriteSymbtab ? SymtabWritingMode::NormalSymtab : SymtabWritingMode::NoSymtab; 210 auto Result = writeArchive(Dst, Members, SymtabMode, Kind, true, false); 211#endif 212 if (!Result) 213 return LLVMRustResult::Success; 214 LLVMRustSetLastError(toString(std::move(Result)).c_str()); 215 216 return LLVMRustResult::Failure; 217}