tools/llvm-objcopy/ELF/ELFObjcopy.cpp

   1 //===- ELFObjcopy.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 "ELFObjcopy.h"
  10 #include "Buffer.h"
  11 #include "CopyConfig.h"
  12 #include "Object.h"
  13 #include "llvm-objcopy.h"
  14
  15 #include "llvm/ADT/BitmaskEnum.h"
  16 #include "llvm/ADT/Optional.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Twine.h"
  21 #include "llvm/BinaryFormat/ELF.h"
  22 #include "llvm/MC/MCTargetOptions.h"
  23 #include "llvm/Object/Binary.h"
  24 #include "llvm/Object/ELFObjectFile.h"
  25 #include "llvm/Object/ELFTypes.h"
  26 #include "llvm/Object/Error.h"
  27 #include "llvm/Option/Option.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Compression.h"
  30 #include "llvm/Support/Errc.h"
  31 #include "llvm/Support/Error.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/ErrorOr.h"
  34 #include "llvm/Support/Memory.h"
  35 #include "llvm/Support/Path.h"
  36 #include "llvm/Support/raw_ostream.h"
  37 #include <algorithm>
  38 #include <cassert>
  39 #include <cstdlib>
  40 #include <functional>
  41 #include <iterator>
  42 #include <memory>
  43 #include <string>
  44 #include <system_error>
  45 #include <utility>
  46
  47 namespace llvm {
  48 namespace objcopy {
  49 namespace elf {
  50
  51 using namespace object;
  52 using namespace ELF;
  53 using SectionPred = std::function<bool(const SectionBase &Sec)>;
  54
  55 static bool isDebugSection(const SectionBase &Sec) {
  56   return StringRef(Sec.Name).startswith(".debug") ||
  57          StringRef(Sec.Name).startswith(".zdebug") || Sec.Name == ".gdb_index";
  58 }
  59
  60 static bool isDWOSection(const SectionBase &Sec) {
  61   return StringRef(Sec.Name).endswith(".dwo");
  62 }
  63
  64 static bool onlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) {
  65   // We can't remove the section header string table.
  66   if (&Sec == Obj.SectionNames)
  67     return false;
  68   // Short of keeping the string table we want to keep everything that is a DWO
  69   // section and remove everything else.
  70   return !isDWOSection(Sec);
  71 }
  72
  73 static uint64_t setSectionFlagsPreserveMask(uint64_t OldFlags,
  74                                             uint64_t NewFlags) {
  75   // Preserve some flags which should not be dropped when setting flags.
  76   // Also, preserve anything OS/processor dependant.
  77   const uint64_t PreserveMask = ELF::SHF_COMPRESSED | ELF::SHF_EXCLUDE |
  78                                 ELF::SHF_GROUP | ELF::SHF_LINK_ORDER |
  79                                 ELF::SHF_MASKOS | ELF::SHF_MASKPROC |
  80                                 ELF::SHF_TLS | ELF::SHF_INFO_LINK;
  81   return (OldFlags & PreserveMask) | (NewFlags & ~PreserveMask);
  82 }
  83
  84 static ElfType getOutputElfType(const Binary &Bin) {
  85   // Infer output ELF type from the input ELF object
  86   if (isa<ELFObjectFile<ELF32LE>>(Bin))
  87     return ELFT_ELF32LE;
  88   if (isa<ELFObjectFile<ELF64LE>>(Bin))
  89     return ELFT_ELF64LE;
  90   if (isa<ELFObjectFile<ELF32BE>>(Bin))
  91     return ELFT_ELF32BE;
  92   if (isa<ELFObjectFile<ELF64BE>>(Bin))
  93     return ELFT_ELF64BE;
  94   llvm_unreachable("Invalid ELFType");
  95 }
  96
  97 static ElfType getOutputElfType(const MachineInfo &MI) {
  98   // Infer output ELF type from the binary arch specified
  99   if (MI.Is64Bit)
 100     return MI.IsLittleEndian ? ELFT_ELF64LE : ELFT_ELF64BE;
 101   else
 102     return MI.IsLittleEndian ? ELFT_ELF32LE : ELFT_ELF32BE;
 103 }
 104
 105 static std::unique_ptr<Writer> createWriter(const CopyConfig &Config,
 106                                             Object &Obj, Buffer &Buf,
 107                                             ElfType OutputElfType) {
 108   if (Config.OutputFormat == "binary") {
 109     return llvm::make_unique<BinaryWriter>(Obj, Buf);
 110   }
 111   // Depending on the initial ELFT and OutputFormat we need a different Writer.
 112   switch (OutputElfType) {
 113   case ELFT_ELF32LE:
 114     return llvm::make_unique<ELFWriter<ELF32LE>>(Obj, Buf,
 115                                                  !Config.StripSections);
 116   case ELFT_ELF64LE:
 117     return llvm::make_unique<ELFWriter<ELF64LE>>(Obj, Buf,
 118                                                  !Config.StripSections);
 119   case ELFT_ELF32BE:
 120     return llvm::make_unique<ELFWriter<ELF32BE>>(Obj, Buf,
 121                                                  !Config.StripSections);
 122   case ELFT_ELF64BE:
 123     return llvm::make_unique<ELFWriter<ELF64BE>>(Obj, Buf,
 124                                                  !Config.StripSections);
 125   }
 126   llvm_unreachable("Invalid output format");
 127 }
 128
 129 template <class ELFT>
 130 static Expected<ArrayRef<uint8_t>>
 131 findBuildID(const object::ELFFile<ELFT> &In) {
 132   for (const auto &Phdr : unwrapOrError(In.program_headers())) {
 133     if (Phdr.p_type != PT_NOTE)
 134       continue;
 135     Error Err = Error::success();
 136     for (const auto &Note : In.notes(Phdr, Err))
 137       if (Note.getType() == NT_GNU_BUILD_ID && Note.getName() == ELF_NOTE_GNU)
 138         return Note.getDesc();
 139     if (Err)
 140       return std::move(Err);
 141   }
 142   return createStringError(llvm::errc::invalid_argument,
 143                            "Could not find build ID.");
 144 }
 145
 146 static Expected<ArrayRef<uint8_t>>
 147 findBuildID(const object::ELFObjectFileBase &In) {
 148   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(&In))
 149     return findBuildID(*O->getELFFile());
 150   else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(&In))
 151     return findBuildID(*O->getELFFile());
 152   else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(&In))
 153     return findBuildID(*O->getELFFile());
 154   else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(&In))
 155     return findBuildID(*O->getELFFile());
 156
 157   llvm_unreachable("Bad file format");
 158 }
 159
 160 template <class... Ts>
 161 static Error makeStringError(std::error_code EC, const Twine &Msg, Ts&&... Args) {
 162   std::string FullMsg = (EC.message() + ": " + Msg).str();
 163   return createStringError(EC, FullMsg.c_str(), std::forward<Ts>(Args)...);
 164 }
 165
 166 #define MODEL_8 "%%%%%%%%"
 167 #define MODEL_16 MODEL_8 MODEL_8
 168 #define MODEL_32 (MODEL_16 MODEL_16)
 169
 170 static Error linkToBuildIdDir(const CopyConfig &Config, StringRef ToLink,
 171                               StringRef Suffix,
 172                               ArrayRef<uint8_t> BuildIdBytes) {
 173   SmallString<128> Path = Config.BuildIdLinkDir;
 174   sys::path::append(Path, llvm::toHex(BuildIdBytes[0], /*LowerCase*/ true));
 175   if (auto EC = sys::fs::create_directories(Path))
 176     return createFileError(
 177         Path.str(),
 178         makeStringError(EC, "cannot create build ID link directory"));
 179
 180   sys::path::append(Path,
 181                     llvm::toHex(BuildIdBytes.slice(1), /*LowerCase*/ true));
 182   Path += Suffix;
 183   SmallString<128> TmpPath;
 184   // create_hard_link races so we need to link to a temporary path but
 185   // we want to make sure that we choose a filename that does not exist.
 186   // By using 32 model characters we get 128-bits of entropy. It is
 187   // unlikely that this string has ever existed before much less exists
 188   // on this disk or in the current working directory.
 189   // Additionally we prepend the original Path for debugging but also
 190   // because it ensures that we're linking within a directory on the same
 191   // partition on the same device which is critical. It has the added
 192   // win of yet further decreasing the odds of a conflict.
 193   sys::fs::createUniquePath(Twine(Path) + "-" + MODEL_32 + ".tmp", TmpPath,
 194                             /*MakeAbsolute*/ false);
 195   if (auto EC = sys::fs::create_hard_link(ToLink, TmpPath)) {
 196     Path.push_back('\0');
 197     return makeStringError(EC, "cannot link %s to %s", ToLink.data(),
 198                              Path.data());
 199   }
 200   // We then atomically rename the link into place which will just move the
 201   // link. If rename fails something is more seriously wrong so just return
 202   // an error.
 203   if (auto EC = sys::fs::rename(TmpPath, Path)) {
 204     Path.push_back('\0');
 205     return makeStringError(EC, "cannot link %s to %s", ToLink.data(),
 206                              Path.data());
 207   }
 208   // If `Path` was already a hard-link to the same underlying file then the
 209   // temp file will be left so we need to remove it. Remove will not cause
 210   // an error by default if the file is already gone so just blindly remove
 211   // it rather than checking.
 212   if (auto EC = sys::fs::remove(TmpPath)) {
 213     TmpPath.push_back('\0');
 214     return makeStringError(EC, "could not remove %s", TmpPath.data());
 215   }
 216   return Error::success();
 217 }
 218
 219 static Error splitDWOToFile(const CopyConfig &Config, const Reader &Reader,
 220                             StringRef File, ElfType OutputElfType) {
 221   auto DWOFile = Reader.create();
 222   auto OnlyKeepDWOPred = [&DWOFile](const SectionBase &Sec) {
 223     return onlyKeepDWOPred(*DWOFile, Sec);
 224   };
 225   if (Error E = DWOFile->removeSections(OnlyKeepDWOPred))
 226     return E;
 227   if (Config.OutputArch)
 228     DWOFile->Machine = Config.OutputArch.getValue().EMachine;
 229   FileBuffer FB(File);
 230   auto Writer = createWriter(Config, *DWOFile, FB, OutputElfType);
 231   if (Error E = Writer->finalize())
 232     return E;
 233   return Writer->write();
 234 }
 235
 236 static Error dumpSectionToFile(StringRef SecName, StringRef Filename,
 237                                Object &Obj) {
 238   for (auto &Sec : Obj.sections()) {
 239     if (Sec.Name == SecName) {
 240       if (Sec.OriginalData.empty())
 241         return createStringError(
 242             object_error::parse_failed,
 243             "Can't dump section \"%s\": it has no contents",
 244             SecName.str().c_str());
 245       Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
 246           FileOutputBuffer::create(Filename, Sec.OriginalData.size());
 247       if (!BufferOrErr)
 248         return BufferOrErr.takeError();
 249       std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
 250       std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(),
 251                 Buf->getBufferStart());
 252       if (Error E = Buf->commit())
 253         return E;
 254       return Error::success();
 255     }
 256   }
 257   return createStringError(object_error::parse_failed, "Section not found");
 258 }
 259
 260 static bool isCompressable(const SectionBase &Section) {
 261   return !(Section.Flags & ELF::SHF_COMPRESSED) &&
 262          StringRef(Section.Name).startswith(".debug");
 263 }
 264
 265 static void replaceDebugSections(
 266     Object &Obj, SectionPred &RemovePred,
 267     function_ref<bool(const SectionBase &)> shouldReplace,
 268     function_ref<SectionBase *(const SectionBase *)> addSection) {
 269   // Build a list of the debug sections we are going to replace.
 270   // We can't call `addSection` while iterating over sections,
 271   // because it would mutate the sections array.
 272   SmallVector<SectionBase *, 13> ToReplace;
 273   for (auto &Sec : Obj.sections())
 274     if (shouldReplace(Sec))
 275       ToReplace.push_back(&Sec);
 276
 277   // Build a mapping from original section to a new one.
 278   DenseMap<SectionBase *, SectionBase *> FromTo;
 279   for (SectionBase *S : ToReplace)
 280     FromTo[S] = addSection(S);
 281
 282   // Now we want to update the target sections of relocation
 283   // sections. Also we will update the relocations themselves
 284   // to update the symbol references.
 285   for (auto &Sec : Obj.sections())
 286     Sec.replaceSectionReferences(FromTo);
 287
 288   RemovePred = [shouldReplace, RemovePred](const SectionBase &Sec) {
 289     return shouldReplace(Sec) || RemovePred(Sec);
 290   };
 291 }
 292
 293 static bool isUnneededSymbol(const Symbol &Sym) {
 294   return !Sym.Referenced &&
 295          (Sym.Binding == STB_LOCAL || Sym.getShndx() == SHN_UNDEF) &&
 296          Sym.Type != STT_FILE && Sym.Type != STT_SECTION;
 297 }
 298
 299 // This function handles the high level operations of GNU objcopy including
 300 // handling command line options. It's important to outline certain properties
 301 // we expect to hold of the command line operations. Any operation that "keeps"
 302 // should keep regardless of a remove. Additionally any removal should respect
 303 // any previous removals. Lastly whether or not something is removed shouldn't
 304 // depend a) on the order the options occur in or b) on some opaque priority
 305 // system. The only priority is that keeps/copies overrule removes.
 306 static Error handleArgs(const CopyConfig &Config, Object &Obj,
 307                         const Reader &Reader, ElfType OutputElfType) {
 308
 309   if (!Config.SplitDWO.empty())
 310     if (Error E =
 311             splitDWOToFile(Config, Reader, Config.SplitDWO, OutputElfType))
 312       return E;
 313
 314   if (Config.OutputArch)
 315     Obj.Machine = Config.OutputArch.getValue().EMachine;
 316
 317   // TODO: update or remove symbols only if there is an option that affects
 318   // them.
 319   if (Obj.SymbolTable) {
 320     Obj.SymbolTable->updateSymbols([&](Symbol &Sym) {
 321       // Common and undefined symbols don't make sense as local symbols, and can
 322       // even cause crashes if we localize those, so skip them.
 323       if (!Sym.isCommon() && Sym.getShndx() != SHN_UNDEF &&
 324           ((Config.LocalizeHidden &&
 325             (Sym.Visibility == STV_HIDDEN || Sym.Visibility == STV_INTERNAL)) ||
 326            is_contained(Config.SymbolsToLocalize, Sym.Name)))
 327         Sym.Binding = STB_LOCAL;
 328
 329       // Note: these two globalize flags have very similar names but different
 330       // meanings:
 331       //
 332       // --globalize-symbol: promote a symbol to global
 333       // --keep-global-symbol: all symbols except for these should be made local
 334       //
 335       // If --globalize-symbol is specified for a given symbol, it will be
 336       // global in the output file even if it is not included via
 337       // --keep-global-symbol. Because of that, make sure to check
 338       // --globalize-symbol second.
 339       if (!Config.SymbolsToKeepGlobal.empty() &&
 340           !is_contained(Config.SymbolsToKeepGlobal, Sym.Name) &&
 341           Sym.getShndx() != SHN_UNDEF)
 342         Sym.Binding = STB_LOCAL;
 343
 344       if (is_contained(Config.SymbolsToGlobalize, Sym.Name) &&
 345           Sym.getShndx() != SHN_UNDEF)
 346         Sym.Binding = STB_GLOBAL;
 347
 348       if (is_contained(Config.SymbolsToWeaken, Sym.Name) &&
 349           Sym.Binding == STB_GLOBAL)
 350         Sym.Binding = STB_WEAK;
 351
 352       if (Config.Weaken && Sym.Binding == STB_GLOBAL &&
 353           Sym.getShndx() != SHN_UNDEF)
 354         Sym.Binding = STB_WEAK;
 355
 356       const auto I = Config.SymbolsToRename.find(Sym.Name);
 357       if (I != Config.SymbolsToRename.end())
 358         Sym.Name = I->getValue();
 359
 360       if (!Config.SymbolsPrefix.empty() && Sym.Type != STT_SECTION)
 361         Sym.Name = (Config.SymbolsPrefix + Sym.Name).str();
 362     });
 363
 364     // The purpose of this loop is to mark symbols referenced by sections
 365     // (like GroupSection or RelocationSection). This way, we know which
 366     // symbols are still 'needed' and which are not.
 367     if (Config.StripUnneeded || !Config.UnneededSymbolsToRemove.empty()) {
 368       for (auto &Section : Obj.sections())
 369         Section.markSymbols();
 370     }
 371
 372     auto RemoveSymbolsPred = [&](const Symbol &Sym) {
 373       if (is_contained(Config.SymbolsToKeep, Sym.Name) ||
 374           (Config.KeepFileSymbols && Sym.Type == STT_FILE))
 375         return false;
 376
 377       if ((Config.DiscardMode == DiscardType::All ||
 378            (Config.DiscardMode == DiscardType::Locals &&
 379             StringRef(Sym.Name).startswith(".L"))) &&
 380           Sym.Binding == STB_LOCAL && Sym.getShndx() != SHN_UNDEF &&
 381           Sym.Type != STT_FILE && Sym.Type != STT_SECTION)
 382         return true;
 383
 384       if (Config.StripAll || Config.StripAllGNU)
 385         return true;
 386
 387       if (is_contained(Config.SymbolsToRemove, Sym.Name))
 388         return true;
 389
 390       if ((Config.StripUnneeded ||
 391            is_contained(Config.UnneededSymbolsToRemove, Sym.Name)) &&
 392           isUnneededSymbol(Sym))
 393         return true;
 394
 395       return false;
 396     };
 397     if (Error E = Obj.removeSymbols(RemoveSymbolsPred))
 398       return E;
 399   }
 400
 401   SectionPred RemovePred = [](const SectionBase &) { return false; };
 402
 403   // Removes:
 404   if (!Config.ToRemove.empty()) {
 405     RemovePred = [&Config](const SectionBase &Sec) {
 406       return is_contained(Config.ToRemove, Sec.Name);
 407     };
 408   }
 409
 410   if (Config.StripDWO || !Config.SplitDWO.empty())
 411     RemovePred = [RemovePred](const SectionBase &Sec) {
 412       return isDWOSection(Sec) || RemovePred(Sec);
 413     };
 414
 415   if (Config.ExtractDWO)
 416     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
 417       return onlyKeepDWOPred(Obj, Sec) || RemovePred(Sec);
 418     };
 419
 420   if (Config.StripAllGNU)
 421     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
 422       if (RemovePred(Sec))
 423         return true;
 424       if ((Sec.Flags & SHF_ALLOC) != 0)
 425         return false;
 426       if (&Sec == Obj.SectionNames)
 427         return false;
 428       switch (Sec.Type) {
 429       case SHT_SYMTAB:
 430       case SHT_REL:
 431       case SHT_RELA:
 432       case SHT_STRTAB:
 433         return true;
 434       }
 435       return isDebugSection(Sec);
 436     };
 437
 438   if (Config.StripSections) {
 439     RemovePred = [RemovePred](const SectionBase &Sec) {
 440       return RemovePred(Sec) || Sec.ParentSegment == nullptr;
 441     };
 442   }
 443
 444   if (Config.StripDebug) {
 445     RemovePred = [RemovePred](const SectionBase &Sec) {
 446       return RemovePred(Sec) || isDebugSection(Sec);
 447     };
 448   }
 449
 450   if (Config.StripNonAlloc)
 451     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
 452       if (RemovePred(Sec))
 453         return true;
 454       if (&Sec == Obj.SectionNames)
 455         return false;
 456       return (Sec.Flags & SHF_ALLOC) == 0 && Sec.ParentSegment == nullptr;
 457     };
 458
 459   if (Config.StripAll)
 460     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
 461       if (RemovePred(Sec))
 462         return true;
 463       if (&Sec == Obj.SectionNames)
 464         return false;
 465       if (StringRef(Sec.Name).startswith(".gnu.warning"))
 466         return false;
 467       if (Sec.ParentSegment != nullptr)
 468         return false;
 469       return (Sec.Flags & SHF_ALLOC) == 0;
 470     };
 471
 472   // Explicit copies:
 473   if (!Config.OnlySection.empty()) {
 474     RemovePred = [&Config, RemovePred, &Obj](const SectionBase &Sec) {
 475       // Explicitly keep these sections regardless of previous removes.
 476       if (is_contained(Config.OnlySection, Sec.Name))
 477         return false;
 478
 479       // Allow all implicit removes.
 480       if (RemovePred(Sec))
 481         return true;
 482
 483       // Keep special sections.
 484       if (Obj.SectionNames == &Sec)
 485         return false;
 486       if (Obj.SymbolTable == &Sec ||
 487           (Obj.SymbolTable && Obj.SymbolTable->getStrTab() == &Sec))
 488         return false;
 489
 490       // Remove everything else.
 491       return true;
 492     };
 493   }
 494
 495   if (!Config.KeepSection.empty()) {
 496     RemovePred = [&Config, RemovePred](const SectionBase &Sec) {
 497       // Explicitly keep these sections regardless of previous removes.
 498       if (is_contained(Config.KeepSection, Sec.Name))
 499         return false;
 500       // Otherwise defer to RemovePred.
 501       return RemovePred(Sec);
 502     };
 503   }
 504
 505   // This has to be the last predicate assignment.
 506   // If the option --keep-symbol has been specified
 507   // and at least one of those symbols is present
 508   // (equivalently, the updated symbol table is not empty)
 509   // the symbol table and the string table should not be removed.
 510   if ((!Config.SymbolsToKeep.empty() || Config.KeepFileSymbols) &&
 511       Obj.SymbolTable && !Obj.SymbolTable->empty()) {
 512     RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
 513       if (&Sec == Obj.SymbolTable || &Sec == Obj.SymbolTable->getStrTab())
 514         return false;
 515       return RemovePred(Sec);
 516     };
 517   }
 518
 519   if (Config.CompressionType != DebugCompressionType::None)
 520     replaceDebugSections(Obj, RemovePred, isCompressable,
 521                          [&Config, &Obj](const SectionBase *S) {
 522                            return &Obj.addSection<CompressedSection>(
 523                                *S, Config.CompressionType);
 524                          });
 525   else if (Config.DecompressDebugSections)
 526     replaceDebugSections(
 527         Obj, RemovePred,
 528         [](const SectionBase &S) { return isa<CompressedSection>(&S); },
 529         [&Obj](const SectionBase *S) {
 530           auto CS = cast<CompressedSection>(S);
 531           return &Obj.addSection<DecompressedSection>(*CS);
 532         });
 533
 534   if (Error E = Obj.removeSections(RemovePred))
 535     return E;
 536
 537   if (!Config.SectionsToRename.empty()) {
 538     for (auto &Sec : Obj.sections()) {
 539       const auto Iter = Config.SectionsToRename.find(Sec.Name);
 540       if (Iter != Config.SectionsToRename.end()) {
 541         const SectionRename &SR = Iter->second;
 542         Sec.Name = SR.NewName;
 543         if (SR.NewFlags.hasValue())
 544           Sec.Flags =
 545               setSectionFlagsPreserveMask(Sec.Flags, SR.NewFlags.getValue());
 546       }
 547     }
 548   }
 549
 550   if (!Config.SetSectionFlags.empty()) {
 551     for (auto &Sec : Obj.sections()) {
 552       const auto Iter = Config.SetSectionFlags.find(Sec.Name);
 553       if (Iter != Config.SetSectionFlags.end()) {
 554         const SectionFlagsUpdate &SFU = Iter->second;
 555         Sec.Flags = setSectionFlagsPreserveMask(Sec.Flags, SFU.NewFlags);
 556       }
 557     }
 558   }
 559
 560   for (const auto &Flag : Config.AddSection) {
 561     std::pair<StringRef, StringRef> SecPair = Flag.split("=");
 562     StringRef SecName = SecPair.first;
 563     StringRef File = SecPair.second;
 564     ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 565         MemoryBuffer::getFile(File);
 566     if (!BufOrErr)
 567       return createFileError(File, errorCodeToError(BufOrErr.getError()));
 568     std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
 569     ArrayRef<uint8_t> Data(
 570         reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
 571         Buf->getBufferSize());
 572     OwnedDataSection &NewSection =
 573         Obj.addSection<OwnedDataSection>(SecName, Data);
 574     if (SecName.startswith(".note") && SecName != ".note.GNU-stack")
 575       NewSection.Type = SHT_NOTE;
 576   }
 577
 578   for (const auto &Flag : Config.DumpSection) {
 579     std::pair<StringRef, StringRef> SecPair = Flag.split("=");
 580     StringRef SecName = SecPair.first;
 581     StringRef File = SecPair.second;
 582     if (Error E = dumpSectionToFile(SecName, File, Obj))
 583       return createFileError(Config.InputFilename, std::move(E));
 584   }
 585
 586   if (!Config.AddGnuDebugLink.empty())
 587     Obj.addSection<GnuDebugLinkSection>(Config.AddGnuDebugLink);
 588
 589   for (const NewSymbolInfo &SI : Config.SymbolsToAdd) {
 590     SectionBase *Sec = Obj.findSection(SI.SectionName);
 591     uint64_t Value = Sec ? Sec->Addr + SI.Value : SI.Value;
 592     Obj.SymbolTable->addSymbol(
 593         SI.SymbolName, SI.Bind, SI.Type, Sec, Value, SI.Visibility,
 594         Sec ? (uint16_t)SYMBOL_SIMPLE_INDEX : (uint16_t)SHN_ABS, 0);
 595   }
 596
 597   if (Config.EntryExpr)
 598     Obj.Entry = Config.EntryExpr(Obj.Entry);
 599   return Error::success();
 600 }
 601
 602 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
 603                                 Buffer &Out) {
 604   BinaryReader Reader(Config.BinaryArch, &In);
 605   std::unique_ptr<Object> Obj = Reader.create();
 606
 607   // Prefer OutputArch (-O<format>) if set, otherwise fallback to BinaryArch
 608   // (-B<arch>).
 609   const ElfType OutputElfType = getOutputElfType(
 610       Config.OutputArch ? Config.OutputArch.getValue() : Config.BinaryArch);
 611   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
 612     return E;
 613   std::unique_ptr<Writer> Writer =
 614       createWriter(Config, *Obj, Out, OutputElfType);
 615   if (Error E = Writer->finalize())
 616     return E;
 617   return Writer->write();
 618 }
 619
 620 Error executeObjcopyOnBinary(const CopyConfig &Config,
 621                              object::ELFObjectFileBase &In, Buffer &Out) {
 622   ELFReader Reader(&In);
 623   std::unique_ptr<Object> Obj = Reader.create();
 624   // Prefer OutputArch (-O<format>) if set, otherwise infer it from the input.
 625   const ElfType OutputElfType =
 626       Config.OutputArch ? getOutputElfType(Config.OutputArch.getValue())
 627                         : getOutputElfType(In);
 628   ArrayRef<uint8_t> BuildIdBytes;
 629
 630   if (!Config.BuildIdLinkDir.empty()) {
 631     BuildIdBytes = unwrapOrError(findBuildID(In));
 632     if (BuildIdBytes.size() < 2)
 633       return createFileError(
 634           Config.InputFilename,
 635           createStringError(object_error::parse_failed,
 636                             "build ID is smaller than two bytes."));
 637   }
 638
 639   if (!Config.BuildIdLinkDir.empty() && Config.BuildIdLinkInput)
 640     if (Error E =
 641             linkToBuildIdDir(Config, Config.InputFilename,
 642                              Config.BuildIdLinkInput.getValue(), BuildIdBytes))
 643       return E;
 644
 645   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
 646     return E;
 647   std::unique_ptr<Writer> Writer =
 648       createWriter(Config, *Obj, Out, OutputElfType);
 649   if (Error E = Writer->finalize())
 650     return E;
 651   if (Error E = Writer->write())
 652     return E;
 653   if (!Config.BuildIdLinkDir.empty() && Config.BuildIdLinkOutput)
 654     if (Error E =
 655             linkToBuildIdDir(Config, Config.OutputFilename,
 656                              Config.BuildIdLinkOutput.getValue(), BuildIdBytes))
 657       return E;
 658
 659   return Error::success();
 660 }
 661
 662 } // end namespace elf
 663 } // end namespace objcopy
 664 } // end namespace llvm