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