1 //===- llvm-objcopy.cpp ---------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm-objcopy.h" 11 #include "Object.h" 12 #include "llvm/ADT/STLExtras.h" 13 #include "llvm/ADT/StringRef.h" 14 #include "llvm/ADT/Twine.h" 15 #include "llvm/BinaryFormat/ELF.h" 16 #include "llvm/Object/Binary.h" 17 #include "llvm/Object/ELFObjectFile.h" 18 #include "llvm/Object/ELFTypes.h" 19 #include "llvm/Object/Error.h" 20 #include "llvm/Option/Arg.h" 21 #include "llvm/Option/ArgList.h" 22 #include "llvm/Option/Option.h" 23 #include "llvm/Support/Casting.h" 24 #include "llvm/Support/CommandLine.h" 25 #include "llvm/Support/Compiler.h" 26 #include "llvm/Support/Error.h" 27 #include "llvm/Support/ErrorHandling.h" 28 #include "llvm/Support/ErrorOr.h" 29 #include "llvm/Support/FileOutputBuffer.h" 30 #include "llvm/Support/ManagedStatic.h" 31 #include "llvm/Support/PrettyStackTrace.h" 32 #include "llvm/Support/Signals.h" 33 #include "llvm/Support/raw_ostream.h" 34 #include <algorithm> 35 #include <cassert> 36 #include <cstdlib> 37 #include <functional> 38 #include <iterator> 39 #include <memory> 40 #include <string> 41 #include <system_error> 42 #include <utility> 43 44 using namespace llvm; 45 using namespace object; 46 using namespace ELF; 47 48 namespace { 49 50 enum ID { 51 OBJCOPY_INVALID = 0, // This is not an option ID. 52 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 53 HELPTEXT, METAVAR, VALUES) \ 54 OBJCOPY_##ID, 55 #include "Opts.inc" 56 #undef OPTION 57 }; 58 59 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; 60 #include "Opts.inc" 61 #undef PREFIX 62 63 static constexpr opt::OptTable::Info ObjcopyInfoTable[] = { 64 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 65 HELPTEXT, METAVAR, VALUES) \ 66 {PREFIX, NAME, HELPTEXT, \ 67 METAVAR, OBJCOPY_##ID, opt::Option::KIND##Class, \ 68 PARAM, FLAGS, OBJCOPY_##GROUP, \ 69 OBJCOPY_##ALIAS, ALIASARGS, VALUES}, 70 #include "Opts.inc" 71 #undef OPTION 72 }; 73 74 class ObjcopyOptTable : public opt::OptTable { 75 public: 76 ObjcopyOptTable() : OptTable(ObjcopyInfoTable, true) {} 77 }; 78 79 } // namespace 80 81 // The name this program was invoked as. 82 static StringRef ToolName; 83 84 namespace llvm { 85 86 LLVM_ATTRIBUTE_NORETURN void error(Twine Message) { 87 errs() << ToolName << ": " << Message << ".\n"; 88 errs().flush(); 89 exit(1); 90 } 91 92 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, std::error_code EC) { 93 assert(EC); 94 errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n"; 95 exit(1); 96 } 97 98 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, Error E) { 99 assert(E); 100 std::string Buf; 101 raw_string_ostream OS(Buf); 102 logAllUnhandledErrors(std::move(E), OS, ""); 103 OS.flush(); 104 errs() << ToolName << ": '" << File << "': " << Buf; 105 exit(1); 106 } 107 108 } // end namespace llvm 109 110 struct CopyConfig { 111 StringRef OutputFilename; 112 StringRef InputFilename; 113 StringRef OutputFormat; 114 StringRef InputFormat; 115 StringRef BinaryArch; 116 117 StringRef SplitDWO; 118 StringRef AddGnuDebugLink; 119 std::vector<StringRef> ToRemove; 120 std::vector<StringRef> Keep; 121 std::vector<StringRef> OnlyKeep; 122 std::vector<StringRef> AddSection; 123 bool StripAll; 124 bool StripAllGNU; 125 bool StripDebug; 126 bool StripSections; 127 bool StripNonAlloc; 128 bool StripDWO; 129 bool ExtractDWO; 130 bool LocalizeHidden; 131 }; 132 133 using SectionPred = std::function<bool(const SectionBase &Sec)>; 134 135 bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); } 136 137 bool OnlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) { 138 // We can't remove the section header string table. 139 if (&Sec == Obj.SectionNames) 140 return false; 141 // Short of keeping the string table we want to keep everything that is a DWO 142 // section and remove everything else. 143 return !IsDWOSection(Sec); 144 } 145 146 std::unique_ptr<Writer> CreateWriter(const CopyConfig &Config, Object &Obj, 147 StringRef File, ElfType OutputElfType) { 148 if (Config.OutputFormat == "binary") { 149 return llvm::make_unique<BinaryWriter>(File, Obj); 150 } 151 // Depending on the initial ELFT and OutputFormat we need a different Writer. 152 switch (OutputElfType) { 153 case ELFT_ELF32LE: 154 return llvm::make_unique<ELFWriter<ELF32LE>>(File, Obj, 155 !Config.StripSections); 156 case ELFT_ELF64LE: 157 return llvm::make_unique<ELFWriter<ELF64LE>>(File, Obj, 158 !Config.StripSections); 159 case ELFT_ELF32BE: 160 return llvm::make_unique<ELFWriter<ELF32BE>>(File, Obj, 161 !Config.StripSections); 162 case ELFT_ELF64BE: 163 return llvm::make_unique<ELFWriter<ELF64BE>>(File, Obj, 164 !Config.StripSections); 165 } 166 llvm_unreachable("Invalid output format"); 167 } 168 169 void SplitDWOToFile(const CopyConfig &Config, const Reader &Reader, 170 StringRef File, ElfType OutputElfType) { 171 auto DWOFile = Reader.create(); 172 DWOFile->removeSections( 173 [&](const SectionBase &Sec) { return OnlyKeepDWOPred(*DWOFile, Sec); }); 174 auto Writer = CreateWriter(Config, *DWOFile, File, OutputElfType); 175 Writer->finalize(); 176 Writer->write(); 177 } 178 179 // This function handles the high level operations of GNU objcopy including 180 // handling command line options. It's important to outline certain properties 181 // we expect to hold of the command line operations. Any operation that "keeps" 182 // should keep regardless of a remove. Additionally any removal should respect 183 // any previous removals. Lastly whether or not something is removed shouldn't 184 // depend a) on the order the options occur in or b) on some opaque priority 185 // system. The only priority is that keeps/copies overrule removes. 186 void HandleArgs(const CopyConfig &Config, Object &Obj, const Reader &Reader, 187 ElfType OutputElfType) { 188 189 if (!Config.SplitDWO.empty()) { 190 SplitDWOToFile(Config, Reader, Config.SplitDWO, OutputElfType); 191 } 192 193 // Localize: 194 195 if (Config.LocalizeHidden) { 196 Obj.SymbolTable->localize([](const Symbol &Sym) { 197 return Sym.Visibility == STV_HIDDEN || Sym.Visibility == STV_INTERNAL; 198 }); 199 } 200 201 SectionPred RemovePred = [](const SectionBase &) { return false; }; 202 203 // Removes: 204 205 if (!Config.ToRemove.empty()) { 206 RemovePred = [&Config](const SectionBase &Sec) { 207 return std::find(std::begin(Config.ToRemove), std::end(Config.ToRemove), 208 Sec.Name) != std::end(Config.ToRemove); 209 }; 210 } 211 212 if (Config.StripDWO || !Config.SplitDWO.empty()) 213 RemovePred = [RemovePred](const SectionBase &Sec) { 214 return IsDWOSection(Sec) || RemovePred(Sec); 215 }; 216 217 if (Config.ExtractDWO) 218 RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { 219 return OnlyKeepDWOPred(Obj, Sec) || RemovePred(Sec); 220 }; 221 222 if (Config.StripAllGNU) 223 RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { 224 if (RemovePred(Sec)) 225 return true; 226 if ((Sec.Flags & SHF_ALLOC) != 0) 227 return false; 228 if (&Sec == Obj.SectionNames) 229 return false; 230 switch (Sec.Type) { 231 case SHT_SYMTAB: 232 case SHT_REL: 233 case SHT_RELA: 234 case SHT_STRTAB: 235 return true; 236 } 237 return Sec.Name.startswith(".debug"); 238 }; 239 240 if (Config.StripSections) { 241 RemovePred = [RemovePred](const SectionBase &Sec) { 242 return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0; 243 }; 244 } 245 246 if (Config.StripDebug) { 247 RemovePred = [RemovePred](const SectionBase &Sec) { 248 return RemovePred(Sec) || Sec.Name.startswith(".debug"); 249 }; 250 } 251 252 if (Config.StripNonAlloc) 253 RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { 254 if (RemovePred(Sec)) 255 return true; 256 if (&Sec == Obj.SectionNames) 257 return false; 258 return (Sec.Flags & SHF_ALLOC) == 0; 259 }; 260 261 if (Config.StripAll) 262 RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { 263 if (RemovePred(Sec)) 264 return true; 265 if (&Sec == Obj.SectionNames) 266 return false; 267 if (Sec.Name.startswith(".gnu.warning")) 268 return false; 269 return (Sec.Flags & SHF_ALLOC) == 0; 270 }; 271 272 // Explicit copies: 273 274 if (!Config.OnlyKeep.empty()) { 275 RemovePred = [&Config, RemovePred, &Obj](const SectionBase &Sec) { 276 // Explicitly keep these sections regardless of previous removes. 277 if (std::find(std::begin(Config.OnlyKeep), std::end(Config.OnlyKeep), 278 Sec.Name) != std::end(Config.OnlyKeep)) 279 return false; 280 281 // Allow all implicit removes. 282 if (RemovePred(Sec)) 283 return true; 284 285 // Keep special sections. 286 if (Obj.SectionNames == &Sec) 287 return false; 288 if (Obj.SymbolTable == &Sec || Obj.SymbolTable->getStrTab() == &Sec) 289 return false; 290 291 // Remove everything else. 292 return true; 293 }; 294 } 295 296 if (!Config.Keep.empty()) { 297 RemovePred = [Config, RemovePred](const SectionBase &Sec) { 298 // Explicitly keep these sections regardless of previous removes. 299 if (std::find(std::begin(Config.Keep), std::end(Config.Keep), Sec.Name) != 300 std::end(Config.Keep)) 301 return false; 302 // Otherwise defer to RemovePred. 303 return RemovePred(Sec); 304 }; 305 } 306 307 Obj.removeSections(RemovePred); 308 309 if (!Config.AddSection.empty()) { 310 for (const auto &Flag : Config.AddSection) { 311 auto SecPair = Flag.split("="); 312 auto SecName = SecPair.first; 313 auto File = SecPair.second; 314 auto BufOrErr = MemoryBuffer::getFile(File); 315 if (!BufOrErr) 316 reportError(File, BufOrErr.getError()); 317 auto Buf = std::move(*BufOrErr); 318 auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart()); 319 auto BufSize = Buf->getBufferSize(); 320 Obj.addSection<OwnedDataSection>(SecName, 321 ArrayRef<uint8_t>(BufPtr, BufSize)); 322 } 323 } 324 325 if (!Config.AddGnuDebugLink.empty()) { 326 Obj.addSection<GnuDebugLinkSection>(Config.AddGnuDebugLink); 327 } 328 } 329 330 std::unique_ptr<Reader> CreateReader(StringRef InputFilename, 331 ElfType &OutputElfType) { 332 // Right now we can only read ELF files so there's only one reader; 333 auto Out = llvm::make_unique<ELFReader>(InputFilename); 334 // We need to set the default ElfType for output. 335 OutputElfType = Out->getElfType(); 336 return std::move(Out); 337 } 338 339 void ExecuteElfObjcopy(const CopyConfig &Config) { 340 ElfType OutputElfType; 341 auto Reader = CreateReader(Config.InputFilename, OutputElfType); 342 auto Obj = Reader->create(); 343 auto Writer = 344 CreateWriter(Config, *Obj, Config.OutputFilename, OutputElfType); 345 HandleArgs(Config, *Obj, *Reader, OutputElfType); 346 Writer->finalize(); 347 Writer->write(); 348 } 349 350 // ParseObjcopyOptions returns the config and sets the input arguments. If a 351 // help flag is set then ParseObjcopyOptions will print the help messege and 352 // exit. 353 CopyConfig ParseObjcopyOptions(ArrayRef<const char *> ArgsArr) { 354 ObjcopyOptTable T; 355 unsigned MissingArgumentIndex, MissingArgumentCount; 356 llvm::opt::InputArgList InputArgs = 357 T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount); 358 359 if (InputArgs.size() == 0 || InputArgs.hasArg(OBJCOPY_help)) { 360 T.PrintHelp(outs(), "llvm-objcopy <input> [ <output> ]", "objcopy tool"); 361 exit(0); 362 } 363 364 SmallVector<const char *, 2> Positional; 365 366 for (auto Arg : InputArgs.filtered(OBJCOPY_UNKNOWN)) 367 error("unknown argument '" + Arg->getAsString(InputArgs) + "'"); 368 369 for (auto Arg : InputArgs.filtered(OBJCOPY_INPUT)) 370 Positional.push_back(Arg->getValue()); 371 372 if (Positional.empty()) 373 error("No input file specified"); 374 375 if (Positional.size() > 2) 376 error("Too many positional arguments"); 377 378 CopyConfig Config; 379 Config.InputFilename = Positional[0]; 380 Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1]; 381 Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target); 382 Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target); 383 Config.BinaryArch = InputArgs.getLastArgValue(OBJCOPY_binary_architecture); 384 385 Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo); 386 Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink); 387 for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section)) 388 Config.ToRemove.push_back(Arg->getValue()); 389 for (auto Arg : InputArgs.filtered(OBJCOPY_keep)) 390 Config.Keep.push_back(Arg->getValue()); 391 for (auto Arg : InputArgs.filtered(OBJCOPY_only_keep)) 392 Config.OnlyKeep.push_back(Arg->getValue()); 393 for (auto Arg : InputArgs.filtered(OBJCOPY_add_section)) 394 Config.AddSection.push_back(Arg->getValue()); 395 Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all); 396 Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu); 397 Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug); 398 Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo); 399 Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections); 400 Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc); 401 Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo); 402 Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden); 403 404 return Config; 405 } 406 407 int main(int argc, char **argv) { 408 // Print a stack trace if we signal out. 409 sys::PrintStackTraceOnErrorSignal(argv[0]); 410 PrettyStackTraceProgram X(argc, argv); 411 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 412 ToolName = argv[0]; 413 414 CopyConfig Config = ParseObjcopyOptions(makeArrayRef(argv + 1, argc)); 415 ExecuteElfObjcopy(Config); 416 } 417