1//===- Archive.cpp --------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Archive.h"
10#include "llvm/ObjCopy/CommonConfig.h"
11#include "llvm/ObjCopy/MultiFormatConfig.h"
12#include "llvm/ObjCopy/ObjCopy.h"
13#include "llvm/Object/Error.h"
14#include "llvm/Support/FileOutputBuffer.h"
15#include "llvm/Support/SmallVectorMemoryBuffer.h"
16
17using namespace llvm;
18using namespace llvm::objcopy;
19using namespace llvm::object;
20
21Expected<std::vector<NewArchiveMember>>
22objcopy::createNewArchiveMembers(const MultiFormatConfig &Config,
23 const Archive &Ar) {
24 std::vector<NewArchiveMember> NewArchiveMembers;
25 Error Err = Error::success();
26 for (const Archive::Child &Child : Ar.children(Err)) {
27 Expected<StringRef> ChildNameOrErr = Child.getName();
28 if (!ChildNameOrErr)
29 return createFileError(F: Ar.getFileName(), E: ChildNameOrErr.takeError());
30
31 Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
32 if (!ChildOrErr)
33 return createFileError(F: Ar.getFileName() + "(" + *ChildNameOrErr + ")",
34 E: ChildOrErr.takeError());
35
36 SmallVector<char, 0> Buffer;
37 raw_svector_ostream MemStream(Buffer);
38
39 if (Error E = executeObjcopyOnBinary(Config, In&: *ChildOrErr->get(), Out&: MemStream))
40 return std::move(E);
41
42 Expected<NewArchiveMember> Member = NewArchiveMember::getOldMember(
43 OldMember: Child, Deterministic: Config.getCommonConfig().DeterministicArchives);
44 if (!Member)
45 return createFileError(F: Ar.getFileName(), E: Member.takeError());
46
47 Member->Buf = std::make_unique<SmallVectorMemoryBuffer>(
48 args: std::move(Buffer), args&: ChildNameOrErr.get());
49 Member->MemberName = Member->Buf->getBufferIdentifier();
50 NewArchiveMembers.push_back(x: std::move(*Member));
51 }
52 if (Err)
53 return createFileError(F: Config.getCommonConfig().InputFilename,
54 E: std::move(Err));
55 return std::move(NewArchiveMembers);
56}
57
58// For regular archives this function simply calls llvm::writeArchive,
59// For thin archives it writes the archive file itself as well as its members.
60static Error deepWriteArchive(StringRef ArcName,
61 ArrayRef<NewArchiveMember> NewMembers,
62 SymtabWritingMode WriteSymtab,
63 object::Archive::Kind Kind, bool Deterministic,
64 bool Thin) {
65 if (Kind == object::Archive::K_BSD && !NewMembers.empty() &&
66 NewMembers.front().detectKindFromObject() == object::Archive::K_DARWIN)
67 Kind = object::Archive::K_DARWIN;
68
69 if (Error E = writeArchive(ArcName, NewMembers, WriteSymtab, Kind,
70 Deterministic, Thin))
71 return createFileError(F: ArcName, E: std::move(E));
72
73 if (!Thin)
74 return Error::success();
75
76 for (const NewArchiveMember &Member : NewMembers) {
77 // For regular files (as is the case for deepWriteArchive),
78 // FileOutputBuffer::create will return OnDiskBuffer.
79 // OnDiskBuffer uses a temporary file and then renames it. So in reality
80 // there is no inefficiency / duplicated in-memory buffers in this case. For
81 // now in-memory buffers can not be completely avoided since
82 // NewArchiveMember still requires them even though writeArchive does not
83 // write them on disk.
84 Expected<std::unique_ptr<FileOutputBuffer>> FB =
85 FileOutputBuffer::create(FilePath: Member.MemberName, Size: Member.Buf->getBufferSize(),
86 Flags: FileOutputBuffer::F_executable);
87 if (!FB)
88 return FB.takeError();
89 std::copy(first: Member.Buf->getBufferStart(), last: Member.Buf->getBufferEnd(),
90 result: (*FB)->getBufferStart());
91 if (Error E = (*FB)->commit())
92 return E;
93 }
94 return Error::success();
95}
96
97Error objcopy::executeObjcopyOnArchive(const MultiFormatConfig &Config,
98 const object::Archive &Ar) {
99 Expected<std::vector<NewArchiveMember>> NewArchiveMembersOrErr =
100 createNewArchiveMembers(Config, Ar);
101 if (!NewArchiveMembersOrErr)
102 return NewArchiveMembersOrErr.takeError();
103 const CommonConfig &CommonConfig = Config.getCommonConfig();
104 return deepWriteArchive(ArcName: CommonConfig.OutputFilename, NewMembers: *NewArchiveMembersOrErr,
105 WriteSymtab: Ar.hasSymbolTable() ? SymtabWritingMode::NormalSymtab
106 : SymtabWritingMode::NoSymtab,
107 Kind: Ar.kind(), Deterministic: CommonConfig.DeterministicArchives,
108 Thin: Ar.isThin());
109}
110