fork/rust
git clone https://git.julia.blue/fork/rust
b8cedc00407
1.42.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#if LLVM_VERSION_GE(10, 0) 93 std::unique_ptr<Error> Err = std::make_unique<Error>(Error::success()); 94#else 95 std::unique_ptr<Error> Err = llvm::make_unique<Error>(Error::success()); 96#endif 97 auto Cur = Archive->child_begin(*Err); 98 if (*Err) { 99 LLVMRustSetLastError(toString(std::move(*Err)).c_str()); 100 return nullptr; 101 } 102 auto End = Archive->child_end(); 103 return new RustArchiveIterator(Cur, End, std::move(Err)); 104} 105 106extern "C" LLVMRustArchiveChildConstRef 107LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef RAI) { 108 if (RAI->Cur == RAI->End) 109 return nullptr; 110 111 // Advancing the iterator validates the next child, and this can 112 // uncover an error. LLVM requires that we check all Errors, 113 // so we only advance the iterator if we actually need to fetch 114 // the next child. 115 // This means we must not advance the iterator in the *first* call, 116 // but instead advance it *before* fetching the child in all later calls. 117 if (!RAI->First) { 118 ++RAI->Cur; 119 if (*RAI->Err) { 120 LLVMRustSetLastError(toString(std::move(*RAI->Err)).c_str()); 121 return nullptr; 122 } 123 } else { 124 RAI->First = false; 125 } 126 127 if (RAI->Cur == RAI->End) 128 return nullptr; 129 130 const Archive::Child &Child = *RAI->Cur.operator->(); 131 Archive::Child *Ret = new Archive::Child(Child); 132 133 return Ret; 134} 135 136extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef Child) { 137 delete Child; 138} 139 140extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef RAI) { 141 delete RAI; 142} 143 144extern "C" const char * 145LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef Child, size_t *Size) { 146 Expected<StringRef> NameOrErr = Child->getName(); 147 if (!NameOrErr) { 148 // rustc_codegen_llvm currently doesn't use this error string, but it might be 149 // useful in the future, and in the mean time this tells LLVM that the 150 // error was not ignored and that it shouldn't abort the process. 151 LLVMRustSetLastError(toString(NameOrErr.takeError()).c_str()); 152 return nullptr; 153 } 154 StringRef Name = NameOrErr.get(); 155 *Size = Name.size(); 156 return Name.data(); 157} 158 159extern "C" const char *LLVMRustArchiveChildData(LLVMRustArchiveChildRef Child, 160 size_t *Size) { 161 StringRef Buf; 162 Expected<StringRef> BufOrErr = Child->getBuffer(); 163 if (!BufOrErr) { 164 LLVMRustSetLastError(toString(BufOrErr.takeError()).c_str()); 165 return nullptr; 166 } 167 Buf = BufOrErr.get(); 168 *Size = Buf.size(); 169 return Buf.data(); 170} 171 172extern "C" LLVMRustArchiveMemberRef 173LLVMRustArchiveMemberNew(char *Filename, char *Name, 174 LLVMRustArchiveChildRef Child) { 175 RustArchiveMember *Member = new RustArchiveMember; 176 Member->Filename = Filename; 177 Member->Name = Name; 178 if (Child) 179 Member->Child = *Child; 180 return Member; 181} 182 183extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) { 184 delete Member; 185} 186 187extern "C" LLVMRustResult 188LLVMRustWriteArchive(char *Dst, size_t NumMembers, 189 const LLVMRustArchiveMemberRef *NewMembers, 190 bool WriteSymbtab, LLVMRustArchiveKind RustKind) { 191 192 std::vector<NewArchiveMember> Members; 193 auto Kind = fromRust(RustKind); 194 195 for (size_t I = 0; I < NumMembers; I++) { 196 auto Member = NewMembers[I]; 197 assert(Member->Name); 198 if (Member->Filename) { 199 Expected<NewArchiveMember> MOrErr = 200 NewArchiveMember::getFile(Member->Filename, true); 201 if (!MOrErr) { 202 LLVMRustSetLastError(toString(MOrErr.takeError()).c_str()); 203 return LLVMRustResult::Failure; 204 } 205 MOrErr->MemberName = sys::path::filename(MOrErr->MemberName); 206 Members.push_back(std::move(*MOrErr)); 207 } else { 208 Expected<NewArchiveMember> MOrErr = 209 NewArchiveMember::getOldMember(Member->Child, true); 210 if (!MOrErr) { 211 LLVMRustSetLastError(toString(MOrErr.takeError()).c_str()); 212 return LLVMRustResult::Failure; 213 } 214 Members.push_back(std::move(*MOrErr)); 215 } 216 } 217 218 auto Result = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false); 219 if (!Result) 220 return LLVMRustResult::Success; 221 LLVMRustSetLastError(toString(std::move(Result)).c_str()); 222 223 return LLVMRustResult::Failure; 224}