fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #66089 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum4560ea788cb

1.39.0
6.2 KiB220 linesraw
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}