llvm/lib/ObjCopy/COFF/COFFWriter.cpp

   1 //===- COFFWriter.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 "COFFWriter.h"
  10 #include "COFFObject.h"
  11 #include "llvm/ADT/ArrayRef.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/BinaryFormat/COFF.h"
  14 #include "llvm/Object/COFF.h"
  15 #include "llvm/Support/Errc.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17 #include <cstddef>
  18 #include <cstdint>
  19
  20 namespace llvm {
  21 namespace objcopy {
  22 namespace coff {
  23
  24 using namespace object;
  25 using namespace COFF;
  26
  27 Error COFFWriter::finalizeRelocTargets() {
  28   for (Section &Sec : Obj.getMutableSections()) {
  29     for (Relocation &R : Sec.Relocs) {
  30       const Symbol *Sym = Obj.findSymbol(R.Target);
  31       if (Sym == nullptr)
  32         return createStringError(object_error::invalid_symbol_index,
  33                                  "relocation target '%s' (%zu) not found",
  34                                  R.TargetName.str().c_str(), R.Target);
  35       R.Reloc.SymbolTableIndex = Sym->RawIndex;
  36     }
  37   }
  38   return Error::success();
  39 }
  40
  41 Error COFFWriter::finalizeSymbolContents() {
  42   for (Symbol &Sym : Obj.getMutableSymbols()) {
  43     if (Sym.TargetSectionId <= 0) {
  44       // Undefined, or a special kind of symbol. These negative values
  45       // are stored in the SectionNumber field which is unsigned.
  46       Sym.Sym.SectionNumber = static_cast<uint32_t>(Sym.TargetSectionId);
  47     } else {
  48       const Section *Sec = Obj.findSection(Sym.TargetSectionId);
  49       if (Sec == nullptr)
  50         return createStringError(object_error::invalid_symbol_index,
  51                                  "symbol '%s' points to a removed section",
  52                                  Sym.Name.str().c_str());
  53       Sym.Sym.SectionNumber = Sec->Index;
  54
  55       if (Sym.Sym.NumberOfAuxSymbols == 1 &&
  56           Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC) {
  57         coff_aux_section_definition *SD =
  58             reinterpret_cast<coff_aux_section_definition *>(
  59                 Sym.AuxData[0].Opaque);
  60         uint32_t SDSectionNumber;
  61         if (Sym.AssociativeComdatTargetSectionId == 0) {
  62           // Not a comdat associative section; just set the Number field to
  63           // the number of the section itself.
  64           SDSectionNumber = Sec->Index;
  65         } else {
  66           Sec = Obj.findSection(Sym.AssociativeComdatTargetSectionId);
  67           if (Sec == nullptr)
  68             return createStringError(
  69                 object_error::invalid_symbol_index,
  70                 "symbol '%s' is associative to a removed section",
  71                 Sym.Name.str().c_str());
  72           SDSectionNumber = Sec->Index;
  73         }
  74         // Update the section definition with the new section number.
  75         SD->NumberLowPart = static_cast<uint16_t>(SDSectionNumber);
  76         SD->NumberHighPart = static_cast<uint16_t>(SDSectionNumber >> 16);
  77       }
  78     }
  79     // Check that we actually have got AuxData to match the weak symbol target
  80     // we want to set. Only >= 1 would be required, but only == 1 makes sense.
  81     if (Sym.WeakTargetSymbolId && Sym.Sym.NumberOfAuxSymbols == 1) {
  82       coff_aux_weak_external *WE =
  83           reinterpret_cast<coff_aux_weak_external *>(Sym.AuxData[0].Opaque);
  84       const Symbol *Target = Obj.findSymbol(*Sym.WeakTargetSymbolId);
  85       if (Target == nullptr)
  86         return createStringError(object_error::invalid_symbol_index,
  87                                  "symbol '%s' is missing its weak target",
  88                                  Sym.Name.str().c_str());
  89       WE->TagIndex = Target->RawIndex;
  90     }
  91   }
  92   return Error::success();
  93 }
  94
  95 void COFFWriter::layoutSections() {
  96   for (auto &S : Obj.getMutableSections()) {
  97     if (S.Header.SizeOfRawData > 0)
  98       S.Header.PointerToRawData = FileSize;
  99     else
 100       S.Header.PointerToRawData = 0;
 101     FileSize += S.Header.SizeOfRawData; // For executables, this is already
 102                                         // aligned to FileAlignment.
 103     if (S.Relocs.size() >= 0xffff) {
 104       S.Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
 105       S.Header.NumberOfRelocations = 0xffff;
 106       S.Header.PointerToRelocations = FileSize;
 107       FileSize += sizeof(coff_relocation);
 108     } else {
 109       S.Header.NumberOfRelocations = S.Relocs.size();
 110       S.Header.PointerToRelocations = S.Relocs.size() ? FileSize : 0;
 111     }
 112
 113     FileSize += S.Relocs.size() * sizeof(coff_relocation);
 114     FileSize = alignTo(FileSize, FileAlignment);
 115
 116     if (S.Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
 117       SizeOfInitializedData += S.Header.SizeOfRawData;
 118   }
 119 }
 120
 121 Expected<size_t> COFFWriter::finalizeStringTable() {
 122   for (const auto &S : Obj.getSections())
 123     if (S.Name.size() > COFF::NameSize)
 124       StrTabBuilder.add(S.Name);
 125
 126   for (const auto &S : Obj.getSymbols())
 127     if (S.Name.size() > COFF::NameSize)
 128       StrTabBuilder.add(S.Name);
 129
 130   StrTabBuilder.finalize();
 131
 132   for (auto &S : Obj.getMutableSections()) {
 133     memset(S.Header.Name, 0, sizeof(S.Header.Name));
 134     if (S.Name.size() <= COFF::NameSize) {
 135       // Short names can go in the field directly.
 136       memcpy(S.Header.Name, S.Name.data(), S.Name.size());
 137     } else {
 138       // Offset of the section name in the string table.
 139       size_t Offset = StrTabBuilder.getOffset(S.Name);
 140       if (!COFF::encodeSectionName(S.Header.Name, Offset))
 141         return createStringError(object_error::invalid_section_index,
 142                                  "COFF string table is greater than 64GB, "
 143                                  "unable to encode section name offset");
 144     }
 145   }
 146   for (auto &S : Obj.getMutableSymbols()) {
 147     if (S.Name.size() > COFF::NameSize) {
 148       S.Sym.Name.Offset.Zeroes = 0;
 149       S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
 150     } else {
 151       strncpy(S.Sym.Name.ShortName, S.Name.data(), COFF::NameSize);
 152     }
 153   }
 154   return StrTabBuilder.getSize();
 155 }
 156
 157 template <class SymbolTy>
 158 std::pair<size_t, size_t> COFFWriter::finalizeSymbolTable() {
 159   size_t RawSymIndex = 0;
 160   for (auto &S : Obj.getMutableSymbols()) {
 161     // Symbols normally have NumberOfAuxSymbols set correctly all the time.
 162     // For file symbols, we need to know the output file's symbol size to be
 163     // able to calculate the number of slots it occupies.
 164     if (!S.AuxFile.empty())
 165       S.Sym.NumberOfAuxSymbols =
 166           alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);
 167     S.RawIndex = RawSymIndex;
 168     RawSymIndex += 1 + S.Sym.NumberOfAuxSymbols;
 169   }
 170   return std::make_pair(RawSymIndex * sizeof(SymbolTy), sizeof(SymbolTy));
 171 }
 172
 173 Error COFFWriter::finalize(bool IsBigObj) {
 174   size_t SymTabSize, SymbolSize;
 175   std::tie(SymTabSize, SymbolSize) = IsBigObj
 176                                          ? finalizeSymbolTable<coff_symbol32>()
 177                                          : finalizeSymbolTable<coff_symbol16>();
 178
 179   if (Error E = finalizeRelocTargets())
 180     return E;
 181   if (Error E = finalizeSymbolContents())
 182     return E;
 183
 184   size_t SizeOfHeaders = 0;
 185   FileAlignment = 1;
 186   size_t PeHeaderSize = 0;
 187   if (Obj.IsPE) {
 188     Obj.DosHeader.AddressOfNewExeHeader =
 189         sizeof(Obj.DosHeader) + Obj.DosStub.size();
 190     SizeOfHeaders += Obj.DosHeader.AddressOfNewExeHeader + sizeof(PEMagic);
 191
 192     FileAlignment = Obj.PeHeader.FileAlignment;
 193     Obj.PeHeader.NumberOfRvaAndSize = Obj.DataDirectories.size();
 194
 195     PeHeaderSize = Obj.Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
 196     SizeOfHeaders +=
 197         PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
 198   }
 199   Obj.CoffFileHeader.NumberOfSections = Obj.getSections().size();
 200   SizeOfHeaders +=
 201       IsBigObj ? sizeof(coff_bigobj_file_header) : sizeof(coff_file_header);
 202   SizeOfHeaders += sizeof(coff_section) * Obj.getSections().size();
 203   SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
 204
 205   Obj.CoffFileHeader.SizeOfOptionalHeader =
 206       PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
 207
 208   FileSize = SizeOfHeaders;
 209   SizeOfInitializedData = 0;
 210
 211   layoutSections();
 212
 213   if (Obj.IsPE) {
 214     Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
 215     Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
 216
 217     if (!Obj.getSections().empty()) {
 218       const Section &S = Obj.getSections().back();
 219       Obj.PeHeader.SizeOfImage =
 220           alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
 221                   Obj.PeHeader.SectionAlignment);
 222     }
 223
 224     // If the PE header had a checksum, clear it, since it isn't valid
 225     // any longer. (We don't calculate a new one.)
 226     Obj.PeHeader.CheckSum = 0;
 227   }
 228
 229   Expected<size_t> StrTabSizeOrErr = finalizeStringTable();
 230   if (!StrTabSizeOrErr)
 231     return StrTabSizeOrErr.takeError();
 232
 233   size_t StrTabSize = *StrTabSizeOrErr;
 234
 235   size_t PointerToSymbolTable = FileSize;
 236   // StrTabSize <= 4 is the size of an empty string table, only consisting
 237   // of the length field.
 238   if (SymTabSize == 0 && StrTabSize <= 4 && Obj.IsPE) {
 239     // For executables, don't point to the symbol table and skip writing
 240     // the length field, if both the symbol and string tables are empty.
 241     PointerToSymbolTable = 0;
 242     StrTabSize = 0;
 243   }
 244
 245   size_t NumRawSymbols = SymTabSize / SymbolSize;
 246   Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
 247   Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
 248   FileSize += SymTabSize + StrTabSize;
 249   FileSize = alignTo(FileSize, FileAlignment);
 250
 251   return Error::success();
 252 }
 253
 254 void COFFWriter::writeHeaders(bool IsBigObj) {
 255   uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
 256   if (Obj.IsPE) {
 257     memcpy(Ptr, &Obj.DosHeader, sizeof(Obj.DosHeader));
 258     Ptr += sizeof(Obj.DosHeader);
 259     memcpy(Ptr, Obj.DosStub.data(), Obj.DosStub.size());
 260     Ptr += Obj.DosStub.size();
 261     memcpy(Ptr, PEMagic, sizeof(PEMagic));
 262     Ptr += sizeof(PEMagic);
 263   }
 264   if (!IsBigObj) {
 265     memcpy(Ptr, &Obj.CoffFileHeader, sizeof(Obj.CoffFileHeader));
 266     Ptr += sizeof(Obj.CoffFileHeader);
 267   } else {
 268     // Generate a coff_bigobj_file_header, filling it in with the values
 269     // from Obj.CoffFileHeader. All extra fields that don't exist in
 270     // coff_file_header can be set to hardcoded values.
 271     coff_bigobj_file_header BigObjHeader;
 272     BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
 273     BigObjHeader.Sig2 = 0xffff;
 274     BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
 275     BigObjHeader.Machine = Obj.CoffFileHeader.Machine;
 276     BigObjHeader.TimeDateStamp = Obj.CoffFileHeader.TimeDateStamp;
 277     memcpy(BigObjHeader.UUID, BigObjMagic, sizeof(BigObjMagic));
 278     BigObjHeader.unused1 = 0;
 279     BigObjHeader.unused2 = 0;
 280     BigObjHeader.unused3 = 0;
 281     BigObjHeader.unused4 = 0;
 282     // The value in Obj.CoffFileHeader.NumberOfSections is truncated, thus
 283     // get the original one instead.
 284     BigObjHeader.NumberOfSections = Obj.getSections().size();
 285     BigObjHeader.PointerToSymbolTable = Obj.CoffFileHeader.PointerToSymbolTable;
 286     BigObjHeader.NumberOfSymbols = Obj.CoffFileHeader.NumberOfSymbols;
 287
 288     memcpy(Ptr, &BigObjHeader, sizeof(BigObjHeader));
 289     Ptr += sizeof(BigObjHeader);
 290   }
 291   if (Obj.IsPE) {
 292     if (Obj.Is64) {
 293       memcpy(Ptr, &Obj.PeHeader, sizeof(Obj.PeHeader));
 294       Ptr += sizeof(Obj.PeHeader);
 295     } else {
 296       pe32_header PeHeader;
 297       copyPeHeader(PeHeader, Obj.PeHeader);
 298       // The pe32plus_header (stored in Object) lacks the BaseOfData field.
 299       PeHeader.BaseOfData = Obj.BaseOfData;
 300
 301       memcpy(Ptr, &PeHeader, sizeof(PeHeader));
 302       Ptr += sizeof(PeHeader);
 303     }
 304     for (const auto &DD : Obj.DataDirectories) {
 305       memcpy(Ptr, &DD, sizeof(DD));
 306       Ptr += sizeof(DD);
 307     }
 308   }
 309   for (const auto &S : Obj.getSections()) {
 310     memcpy(Ptr, &S.Header, sizeof(S.Header));
 311     Ptr += sizeof(S.Header);
 312   }
 313 }
 314
 315 void COFFWriter::writeSections() {
 316   for (const auto &S : Obj.getSections()) {
 317     uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
 318                    S.Header.PointerToRawData;
 319     ArrayRef<uint8_t> Contents = S.getContents();
 320     std::copy(Contents.begin(), Contents.end(), Ptr);
 321
 322     // For executable sections, pad the remainder of the raw data size with
 323     // 0xcc, which is int3 on x86.
 324     if ((S.Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
 325         S.Header.SizeOfRawData > Contents.size())
 326       memset(Ptr + Contents.size(), 0xcc,
 327              S.Header.SizeOfRawData - Contents.size());
 328
 329     Ptr += S.Header.SizeOfRawData;
 330
 331     if (S.Relocs.size() >= 0xffff) {
 332       object::coff_relocation R;
 333       R.VirtualAddress = S.Relocs.size() + 1;
 334       R.SymbolTableIndex = 0;
 335       R.Type = 0;
 336       memcpy(Ptr, &R, sizeof(R));
 337       Ptr += sizeof(R);
 338     }
 339     for (const auto &R : S.Relocs) {
 340       memcpy(Ptr, &R.Reloc, sizeof(R.Reloc));
 341       Ptr += sizeof(R.Reloc);
 342     }
 343   }
 344 }
 345
 346 template <class SymbolTy> void COFFWriter::writeSymbolStringTables() {
 347   uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
 348                  Obj.CoffFileHeader.PointerToSymbolTable;
 349   for (const auto &S : Obj.getSymbols()) {
 350     // Convert symbols back to the right size, from coff_symbol32.
 351     copySymbol<SymbolTy, coff_symbol32>(*reinterpret_cast<SymbolTy *>(Ptr),
 352                                         S.Sym);
 353     Ptr += sizeof(SymbolTy);
 354     if (!S.AuxFile.empty()) {
 355       // For file symbols, just write the string into the aux symbol slots,
 356       // assuming that the unwritten parts are initialized to zero in the memory
 357       // mapped file.
 358       std::copy(S.AuxFile.begin(), S.AuxFile.end(), Ptr);
 359       Ptr += S.Sym.NumberOfAuxSymbols * sizeof(SymbolTy);
 360     } else {
 361       // For other auxillary symbols, write their opaque payload into one symbol
 362       // table slot each. For big object files, the symbols are larger than the
 363       // opaque auxillary symbol struct and we leave padding at the end of each
 364       // entry.
 365       for (const AuxSymbol &AuxSym : S.AuxData) {
 366         ArrayRef<uint8_t> Ref = AuxSym.getRef();
 367         std::copy(Ref.begin(), Ref.end(), Ptr);
 368         Ptr += sizeof(SymbolTy);
 369       }
 370     }
 371   }
 372   if (StrTabBuilder.getSize() > 4 || !Obj.IsPE) {
 373     // Always write a string table in object files, even an empty one.
 374     StrTabBuilder.write(Ptr);
 375     Ptr += StrTabBuilder.getSize();
 376   }
 377 }
 378
 379 Error COFFWriter::write(bool IsBigObj) {
 380   if (Error E = finalize(IsBigObj))
 381     return E;
 382
 383   Buf = WritableMemoryBuffer::getNewMemBuffer(FileSize);
 384   if (!Buf)
 385     return createStringError(llvm::errc::not_enough_memory,
 386                              "failed to allocate memory buffer of " +
 387                                  Twine::utohexstr(FileSize) + " bytes.");
 388
 389   writeHeaders(IsBigObj);
 390   writeSections();
 391   if (IsBigObj)
 392     writeSymbolStringTables<coff_symbol32>();
 393   else
 394     writeSymbolStringTables<coff_symbol16>();
 395
 396   if (Obj.IsPE)
 397     if (Error E = patchDebugDirectory())
 398       return E;
 399
 400   // TODO: Implement direct writing to the output stream (without intermediate
 401   // memory buffer Buf).
 402   Out.write(Buf->getBufferStart(), Buf->getBufferSize());
 403   return Error::success();
 404 }
 405
 406 Expected<uint32_t> COFFWriter::virtualAddressToFileAddress(uint32_t RVA) {
 407   for (const auto &S : Obj.getSections()) {
 408     if (RVA >= S.Header.VirtualAddress &&
 409         RVA < S.Header.VirtualAddress + S.Header.SizeOfRawData)
 410       return S.Header.PointerToRawData + RVA - S.Header.VirtualAddress;
 411   }
 412   return createStringError(object_error::parse_failed,
 413                            "debug directory payload not found");
 414 }
 415
 416 // Locate which sections contain the debug directories, iterate over all
 417 // the debug_directory structs in there, and set the PointerToRawData field
 418 // in all of them, according to their new physical location in the file.
 419 Error COFFWriter::patchDebugDirectory() {
 420   if (Obj.DataDirectories.size() <= DEBUG_DIRECTORY)
 421     return Error::success();
 422   const data_directory *Dir = &Obj.DataDirectories[DEBUG_DIRECTORY];
 423   if (Dir->Size <= 0)
 424     return Error::success();
 425   for (const auto &S : Obj.getSections()) {
 426     if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
 427         Dir->RelativeVirtualAddress <
 428             S.Header.VirtualAddress + S.Header.SizeOfRawData) {
 429       if (Dir->RelativeVirtualAddress + Dir->Size >
 430           S.Header.VirtualAddress + S.Header.SizeOfRawData)
 431         return createStringError(object_error::parse_failed,
 432                                  "debug directory extends past end of section");
 433
 434       size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
 435       uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
 436                      S.Header.PointerToRawData + Offset;
 437       uint8_t *End = Ptr + Dir->Size;
 438       while (Ptr < End) {
 439         debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
 440         if (Debug->PointerToRawData) {
 441           if (Expected<uint32_t> FilePosOrErr =
 442                   virtualAddressToFileAddress(Debug->AddressOfRawData))
 443             Debug->PointerToRawData = *FilePosOrErr;
 444           else
 445             return FilePosOrErr.takeError();
 446         }
 447         Ptr += sizeof(debug_directory);
 448         Offset += sizeof(debug_directory);
 449       }
 450       // Debug directory found and patched, all done.
 451       return Error::success();
 452     }
 453   }
 454   return createStringError(object_error::parse_failed,
 455                            "debug directory not found");
 456 }
 457
 458 Error COFFWriter::write() {
 459   bool IsBigObj = Obj.getSections().size() > MaxNumberOfSections16;
 460   if (IsBigObj && Obj.IsPE)
 461     return createStringError(object_error::parse_failed,
 462                              "too many sections for executable");
 463   return write(IsBigObj);
 464 }
 465
 466 } // end namespace coff
 467 } // end namespace objcopy
 468 } // end namespace llvm