1//===- COFFObjcopy.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 "llvm/ObjCopy/COFF/COFFObjcopy.h"
10#include "COFFObject.h"
11#include "COFFReader.h"
12#include "COFFWriter.h"
13#include "llvm/ObjCopy/COFF/COFFConfig.h"
14#include "llvm/ObjCopy/CommonConfig.h"
15
16#include "llvm/ADT/StringExtras.h"
17#include "llvm/Object/Binary.h"
18#include "llvm/Object/COFF.h"
19#include "llvm/Support/CRC.h"
20#include "llvm/Support/Errc.h"
21#include "llvm/Support/Path.h"
22#include <cassert>
23
24namespace llvm {
25namespace objcopy {
26namespace coff {
27
28using namespace object;
29using namespace COFF;
30
31static bool isDebugSection(const Section &Sec) {
32 return Sec.Name.starts_with(Prefix: ".debug");
33}
34
35static uint64_t getNextRVA(const Object &Obj) {
36 if (Obj.getSections().empty())
37 return 0;
38 const Section &Last = Obj.getSections().back();
39 return alignTo(Value: Last.Header.VirtualAddress + Last.Header.VirtualSize,
40 Align: Obj.IsPE ? Obj.PeHeader.SectionAlignment : 1);
41}
42
43static Expected<std::vector<uint8_t>>
44createGnuDebugLinkSectionContents(StringRef File) {
45 ErrorOr<std::unique_ptr<MemoryBuffer>> LinkTargetOrErr =
46 MemoryBuffer::getFile(Filename: File);
47 if (!LinkTargetOrErr)
48 return createFileError(F: File, EC: LinkTargetOrErr.getError());
49 auto LinkTarget = std::move(*LinkTargetOrErr);
50 uint32_t CRC32 = llvm::crc32(Data: arrayRefFromStringRef(Input: LinkTarget->getBuffer()));
51
52 StringRef FileName = sys::path::filename(path: File);
53 size_t CRCPos = alignTo(Value: FileName.size() + 1, Align: 4);
54 std::vector<uint8_t> Data(CRCPos + 4);
55 memcpy(dest: Data.data(), src: FileName.data(), n: FileName.size());
56 support::endian::write32le(P: Data.data() + CRCPos, V: CRC32);
57 return Data;
58}
59
60// Adds named section with given contents to the object.
61static void addSection(Object &Obj, StringRef Name, ArrayRef<uint8_t> Contents,
62 uint32_t Characteristics) {
63 bool NeedVA = Characteristics & (IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ |
64 IMAGE_SCN_MEM_WRITE);
65
66 Section Sec;
67 Sec.setOwnedContents(Contents);
68 Sec.Name = Name;
69 Sec.Header.VirtualSize = NeedVA ? Sec.getContents().size() : 0u;
70 Sec.Header.VirtualAddress = NeedVA ? getNextRVA(Obj) : 0u;
71 Sec.Header.SizeOfRawData =
72 NeedVA ? alignTo(Value: Sec.Header.VirtualSize,
73 Align: Obj.IsPE ? Obj.PeHeader.FileAlignment : 1)
74 : Sec.getContents().size();
75 // Sec.Header.PointerToRawData is filled in by the writer.
76 Sec.Header.PointerToRelocations = 0;
77 Sec.Header.PointerToLinenumbers = 0;
78 // Sec.Header.NumberOfRelocations is filled in by the writer.
79 Sec.Header.NumberOfLinenumbers = 0;
80 Sec.Header.Characteristics = Characteristics;
81
82 Obj.addSections(NewSections: Sec);
83}
84
85static Error addGnuDebugLink(Object &Obj, StringRef DebugLinkFile) {
86 Expected<std::vector<uint8_t>> Contents =
87 createGnuDebugLinkSectionContents(File: DebugLinkFile);
88 if (!Contents)
89 return Contents.takeError();
90
91 addSection(Obj, Name: ".gnu_debuglink", Contents: *Contents,
92 Characteristics: IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
93 IMAGE_SCN_MEM_DISCARDABLE);
94
95 return Error::success();
96}
97
98static uint32_t flagsToCharacteristics(SectionFlag AllFlags, uint32_t OldChar) {
99 // Need to preserve alignment flags.
100 const uint32_t PreserveMask =
101 IMAGE_SCN_ALIGN_1BYTES | IMAGE_SCN_ALIGN_2BYTES | IMAGE_SCN_ALIGN_4BYTES |
102 IMAGE_SCN_ALIGN_8BYTES | IMAGE_SCN_ALIGN_16BYTES |
103 IMAGE_SCN_ALIGN_32BYTES | IMAGE_SCN_ALIGN_64BYTES |
104 IMAGE_SCN_ALIGN_128BYTES | IMAGE_SCN_ALIGN_256BYTES |
105 IMAGE_SCN_ALIGN_512BYTES | IMAGE_SCN_ALIGN_1024BYTES |
106 IMAGE_SCN_ALIGN_2048BYTES | IMAGE_SCN_ALIGN_4096BYTES |
107 IMAGE_SCN_ALIGN_8192BYTES;
108
109 // Setup new section characteristics based on the flags provided in command
110 // line.
111 uint32_t NewCharacteristics = (OldChar & PreserveMask) | IMAGE_SCN_MEM_READ;
112
113 if ((AllFlags & SectionFlag::SecAlloc) && !(AllFlags & SectionFlag::SecLoad))
114 NewCharacteristics |= IMAGE_SCN_CNT_UNINITIALIZED_DATA;
115 if (AllFlags & SectionFlag::SecNoload)
116 NewCharacteristics |= IMAGE_SCN_LNK_REMOVE;
117 if (!(AllFlags & SectionFlag::SecReadonly))
118 NewCharacteristics |= IMAGE_SCN_MEM_WRITE;
119 if (AllFlags & SectionFlag::SecDebug)
120 NewCharacteristics |=
121 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE;
122 if (AllFlags & SectionFlag::SecCode)
123 NewCharacteristics |= IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE;
124 if (AllFlags & SectionFlag::SecData)
125 NewCharacteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
126 if (AllFlags & SectionFlag::SecShare)
127 NewCharacteristics |= IMAGE_SCN_MEM_SHARED;
128 if (AllFlags & SectionFlag::SecExclude)
129 NewCharacteristics |= IMAGE_SCN_LNK_REMOVE;
130
131 return NewCharacteristics;
132}
133
134static Error dumpSection(Object &O, StringRef SectionName, StringRef FileName) {
135 for (const coff::Section &Section : O.getSections()) {
136 if (Section.Name != SectionName)
137 continue;
138
139 ArrayRef<uint8_t> Contents = Section.getContents();
140
141 std::unique_ptr<FileOutputBuffer> Buffer;
142 if (auto B = FileOutputBuffer::create(FilePath: FileName, Size: Contents.size()))
143 Buffer = std::move(*B);
144 else
145 return B.takeError();
146
147 llvm::copy(Range&: Contents, Out: Buffer->getBufferStart());
148 if (Error E = Buffer->commit())
149 return E;
150
151 return Error::success();
152 }
153 return createStringError(EC: object_error::parse_failed, Fmt: "section '%s' not found",
154 Vals: SectionName.str().c_str());
155}
156
157static Error handleArgs(const CommonConfig &Config,
158 const COFFConfig &COFFConfig, Object &Obj) {
159 for (StringRef Op : Config.DumpSection) {
160 auto [Section, File] = Op.split(Separator: '=');
161 if (Error E = dumpSection(O&: Obj, SectionName: Section, FileName: File))
162 return E;
163 }
164
165 // Perform the actual section removals.
166 Obj.removeSections(ToRemove: [&Config](const Section &Sec) {
167 // Contrary to --only-keep-debug, --only-section fully removes sections that
168 // aren't mentioned.
169 if (!Config.OnlySection.empty() && !Config.OnlySection.matches(S: Sec.Name))
170 return true;
171
172 if (Config.StripDebug || Config.StripAll || Config.StripAllGNU ||
173 Config.DiscardMode == DiscardType::All || Config.StripUnneeded) {
174 if (isDebugSection(Sec) &&
175 (Sec.Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) != 0)
176 return true;
177 }
178
179 if (Config.ToRemove.matches(S: Sec.Name))
180 return true;
181
182 return false;
183 });
184
185 if (Config.OnlyKeepDebug) {
186 // For --only-keep-debug, we keep all other sections, but remove their
187 // content. The VirtualSize field in the section header is kept intact.
188 Obj.truncateSections(ToTruncate: [](const Section &Sec) {
189 return !isDebugSection(Sec) && Sec.Name != ".buildid" &&
190 ((Sec.Header.Characteristics &
191 (IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA)) != 0);
192 });
193 }
194
195 // StripAll removes all symbols and thus also removes all relocations.
196 if (Config.StripAll || Config.StripAllGNU)
197 for (Section &Sec : Obj.getMutableSections())
198 Sec.Relocs.clear();
199
200 // If we need to do per-symbol removals, initialize the Referenced field.
201 if (Config.StripUnneeded || Config.DiscardMode == DiscardType::All ||
202 !Config.SymbolsToRemove.empty())
203 if (Error E = Obj.markSymbols())
204 return E;
205
206 for (Symbol &Sym : Obj.getMutableSymbols()) {
207 auto I = Config.SymbolsToRename.find(Key: Sym.Name);
208 if (I != Config.SymbolsToRename.end())
209 Sym.Name = I->getValue();
210 }
211
212 auto ToRemove = [&](const Symbol &Sym) -> Expected<bool> {
213 // For StripAll, all relocations have been stripped and we remove all
214 // symbols.
215 if (Config.StripAll || Config.StripAllGNU)
216 return true;
217
218 if (Config.SymbolsToRemove.matches(S: Sym.Name)) {
219 // Explicitly removing a referenced symbol is an error.
220 if (Sym.Referenced)
221 return createStringError(
222 EC: llvm::errc::invalid_argument,
223 S: "'" + Config.OutputFilename + "': not stripping symbol '" +
224 Sym.Name.str() + "' because it is named in a relocation");
225 return true;
226 }
227
228 if (!Sym.Referenced) {
229 // With --strip-unneeded, GNU objcopy removes all unreferenced local
230 // symbols, and any unreferenced undefined external.
231 // With --strip-unneeded-symbol we strip only specific unreferenced
232 // local symbol instead of removing all of such.
233 if (Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC ||
234 Sym.Sym.SectionNumber == 0)
235 if (Config.StripUnneeded ||
236 Config.UnneededSymbolsToRemove.matches(S: Sym.Name))
237 return true;
238
239 // GNU objcopy keeps referenced local symbols and external symbols
240 // if --discard-all is set, similar to what --strip-unneeded does,
241 // but undefined local symbols are kept when --discard-all is set.
242 if (Config.DiscardMode == DiscardType::All &&
243 Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC &&
244 Sym.Sym.SectionNumber != 0)
245 return true;
246 }
247
248 return false;
249 };
250
251 // Actually do removals of symbols.
252 if (Error Err = Obj.removeSymbols(ToRemove))
253 return Err;
254
255 if (!Config.SetSectionFlags.empty())
256 for (Section &Sec : Obj.getMutableSections()) {
257 const auto It = Config.SetSectionFlags.find(Key: Sec.Name);
258 if (It != Config.SetSectionFlags.end())
259 Sec.Header.Characteristics = flagsToCharacteristics(
260 AllFlags: It->second.NewFlags, OldChar: Sec.Header.Characteristics);
261 }
262
263 for (const NewSectionInfo &NewSection : Config.AddSection) {
264 uint32_t Characteristics;
265 const auto It = Config.SetSectionFlags.find(Key: NewSection.SectionName);
266 if (It != Config.SetSectionFlags.end())
267 Characteristics = flagsToCharacteristics(AllFlags: It->second.NewFlags, OldChar: 0);
268 else
269 Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES;
270
271 addSection(Obj, Name: NewSection.SectionName,
272 Contents: ArrayRef(reinterpret_cast<const uint8_t *>(
273 NewSection.SectionData->getBufferStart()),
274 NewSection.SectionData->getBufferSize()),
275 Characteristics);
276 }
277
278 for (const NewSectionInfo &NewSection : Config.UpdateSection) {
279 auto It = llvm::find_if(Range: Obj.getMutableSections(), P: [&](auto &Sec) {
280 return Sec.Name == NewSection.SectionName;
281 });
282 if (It == Obj.getMutableSections().end())
283 return createStringError(EC: errc::invalid_argument,
284 Fmt: "could not find section with name '%s'",
285 Vals: NewSection.SectionName.str().c_str());
286 size_t ContentSize = It->getContents().size();
287 if (!ContentSize)
288 return createStringError(
289 EC: errc::invalid_argument,
290 Fmt: "section '%s' cannot be updated because it does not have contents",
291 Vals: NewSection.SectionName.str().c_str());
292 if (ContentSize < NewSection.SectionData->getBufferSize())
293 return createStringError(
294 EC: errc::invalid_argument,
295 S: "new section cannot be larger than previous section");
296 It->setOwnedContents({NewSection.SectionData->getBufferStart(),
297 NewSection.SectionData->getBufferEnd()});
298 }
299
300 if (!Config.AddGnuDebugLink.empty())
301 if (Error E = addGnuDebugLink(Obj, DebugLinkFile: Config.AddGnuDebugLink))
302 return E;
303
304 if (COFFConfig.Subsystem || COFFConfig.MajorSubsystemVersion ||
305 COFFConfig.MinorSubsystemVersion) {
306 if (!Obj.IsPE)
307 return createStringError(
308 EC: errc::invalid_argument,
309 S: "'" + Config.OutputFilename +
310 "': unable to set subsystem on a relocatable object file");
311 if (COFFConfig.Subsystem)
312 Obj.PeHeader.Subsystem = *COFFConfig.Subsystem;
313 if (COFFConfig.MajorSubsystemVersion)
314 Obj.PeHeader.MajorSubsystemVersion = *COFFConfig.MajorSubsystemVersion;
315 if (COFFConfig.MinorSubsystemVersion)
316 Obj.PeHeader.MinorSubsystemVersion = *COFFConfig.MinorSubsystemVersion;
317 }
318
319 return Error::success();
320}
321
322Error executeObjcopyOnBinary(const CommonConfig &Config,
323 const COFFConfig &COFFConfig, COFFObjectFile &In,
324 raw_ostream &Out) {
325 COFFReader Reader(In);
326 Expected<std::unique_ptr<Object>> ObjOrErr = Reader.create();
327 if (!ObjOrErr)
328 return createFileError(F: Config.InputFilename, E: ObjOrErr.takeError());
329 Object *Obj = ObjOrErr->get();
330 assert(Obj && "Unable to deserialize COFF object");
331 if (Error E = handleArgs(Config, COFFConfig, Obj&: *Obj))
332 return createFileError(F: Config.InputFilename, E: std::move(E));
333 COFFWriter Writer(*Obj, Out);
334 if (Error E = Writer.write())
335 return createFileError(F: Config.OutputFilename, E: std::move(E));
336 return Error::success();
337}
338
339} // end namespace coff
340} // end namespace objcopy
341} // end namespace llvm
342