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 24 namespace llvm { 25 namespace objcopy { 26 namespace coff { 27 28 using namespace object; 29 using namespace COFF; 30 31 static bool isDebugSection(const Section &Sec) { 32 return Sec.Name.startswith(".debug"); 33 } 34 35 static uint64_t getNextRVA(const Object &Obj) { 36 if (Obj.getSections().empty()) 37 return 0; 38 const Section &Last = Obj.getSections().back(); 39 return alignTo(Last.Header.VirtualAddress + Last.Header.VirtualSize, 40 Obj.IsPE ? Obj.PeHeader.SectionAlignment : 1); 41 } 42 43 static Expected<std::vector<uint8_t>> 44 createGnuDebugLinkSectionContents(StringRef File) { 45 ErrorOr<std::unique_ptr<MemoryBuffer>> LinkTargetOrErr = 46 MemoryBuffer::getFile(File); 47 if (!LinkTargetOrErr) 48 return createFileError(File, LinkTargetOrErr.getError()); 49 auto LinkTarget = std::move(*LinkTargetOrErr); 50 uint32_t CRC32 = llvm::crc32(arrayRefFromStringRef(LinkTarget->getBuffer())); 51 52 StringRef FileName = sys::path::filename(File); 53 size_t CRCPos = alignTo(FileName.size() + 1, 4); 54 std::vector<uint8_t> Data(CRCPos + 4); 55 memcpy(Data.data(), FileName.data(), FileName.size()); 56 support::endian::write32le(Data.data() + CRCPos, CRC32); 57 return Data; 58 } 59 60 // Adds named section with given contents to the object. 61 static 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(Sec.Header.VirtualSize, 73 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(Sec); 83 } 84 85 static Error addGnuDebugLink(Object &Obj, StringRef DebugLinkFile) { 86 Expected<std::vector<uint8_t>> Contents = 87 createGnuDebugLinkSectionContents(DebugLinkFile); 88 if (!Contents) 89 return Contents.takeError(); 90 91 addSection(Obj, ".gnu_debuglink", *Contents, 92 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | 93 IMAGE_SCN_MEM_DISCARDABLE); 94 95 return Error::success(); 96 } 97 98 static 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 134 static 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(FileName, Contents.size())) 143 Buffer = std::move(*B); 144 else 145 return B.takeError(); 146 147 llvm::copy(Contents, Buffer->getBufferStart()); 148 if (Error E = Buffer->commit()) 149 return E; 150 151 return Error::success(); 152 } 153 return createStringError(object_error::parse_failed, "section '%s' not found", 154 SectionName.str().c_str()); 155 } 156 157 static Error handleArgs(const CommonConfig &Config, 158 const COFFConfig &COFFConfig, Object &Obj) { 159 for (StringRef Op : Config.DumpSection) { 160 auto [Section, File] = Op.split('='); 161 if (Error E = dumpSection(Obj, Section, File)) 162 return E; 163 } 164 165 // Perform the actual section removals. 166 Obj.removeSections([&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(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(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([](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(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(Sym.Name)) { 219 // Explicitly removing a referenced symbol is an error. 220 if (Sym.Referenced) 221 return createStringError( 222 llvm::errc::invalid_argument, 223 "'" + 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(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(Sec.Name); 258 if (It != Config.SetSectionFlags.end()) 259 Sec.Header.Characteristics = flagsToCharacteristics( 260 It->second.NewFlags, Sec.Header.Characteristics); 261 } 262 263 for (const NewSectionInfo &NewSection : Config.AddSection) { 264 uint32_t Characteristics; 265 const auto It = Config.SetSectionFlags.find(NewSection.SectionName); 266 if (It != Config.SetSectionFlags.end()) 267 Characteristics = flagsToCharacteristics(It->second.NewFlags, 0); 268 else 269 Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES; 270 271 addSection(Obj, NewSection.SectionName, 272 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(Obj.getMutableSections(), [&](auto &Sec) { 280 return Sec.Name == NewSection.SectionName; 281 }); 282 if (It == Obj.getMutableSections().end()) 283 return createStringError(errc::invalid_argument, 284 "could not find section with name '%s'", 285 NewSection.SectionName.str().c_str()); 286 size_t ContentSize = It->getContents().size(); 287 if (!ContentSize) 288 return createStringError( 289 errc::invalid_argument, 290 "section '%s' cannot be updated because it does not have contents", 291 NewSection.SectionName.str().c_str()); 292 if (ContentSize < NewSection.SectionData->getBufferSize()) 293 return createStringError( 294 errc::invalid_argument, 295 "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, Config.AddGnuDebugLink)) 302 return E; 303 304 if (COFFConfig.Subsystem || COFFConfig.MajorSubsystemVersion || 305 COFFConfig.MinorSubsystemVersion) { 306 if (!Obj.IsPE) 307 return createStringError( 308 errc::invalid_argument, 309 "'" + 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 322 Error 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(Config.InputFilename, ObjOrErr.takeError()); 329 Object *Obj = ObjOrErr->get(); 330 assert(Obj && "Unable to deserialize COFF object"); 331 if (Error E = handleArgs(Config, COFFConfig, *Obj)) 332 return createFileError(Config.InputFilename, std::move(E)); 333 COFFWriter Writer(*Obj, Out); 334 if (Error E = Writer.write()) 335 return createFileError(Config.OutputFilename, std::move(E)); 336 return Error::success(); 337 } 338 339 } // end namespace coff 340 } // end namespace objcopy 341 } // end namespace llvm 342