1 //===-- llvm-size.cpp - Print the size of each object section -------------===// 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 // This program is a utility that works like traditional Unix "size", 11 // that is, it prints out the size of each section, and the total size of all 12 // sections. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/ADT/APInt.h" 17 #include "llvm/Object/Archive.h" 18 #include "llvm/Object/ObjectFile.h" 19 #include "llvm/Object/MachO.h" 20 #include "llvm/Object/MachOUniversal.h" 21 #include "llvm/Support/Casting.h" 22 #include "llvm/Support/CommandLine.h" 23 #include "llvm/Support/FileSystem.h" 24 #include "llvm/Support/Format.h" 25 #include "llvm/Support/ManagedStatic.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 #include "llvm/Support/PrettyStackTrace.h" 28 #include "llvm/Support/Signals.h" 29 #include "llvm/Support/raw_ostream.h" 30 #include <algorithm> 31 #include <string> 32 #include <system_error> 33 using namespace llvm; 34 using namespace object; 35 36 enum OutputFormatTy { berkeley, sysv, darwin }; 37 static cl::opt<OutputFormatTy> 38 OutputFormat("format", cl::desc("Specify output format"), 39 cl::values(clEnumVal(sysv, "System V format"), 40 clEnumVal(berkeley, "Berkeley format"), 41 clEnumVal(darwin, "Darwin -m format"), clEnumValEnd), 42 cl::init(berkeley)); 43 44 static cl::opt<OutputFormatTy> OutputFormatShort( 45 cl::desc("Specify output format"), 46 cl::values(clEnumValN(sysv, "A", "System V format"), 47 clEnumValN(berkeley, "B", "Berkeley format"), 48 clEnumValN(darwin, "m", "Darwin -m format"), clEnumValEnd), 49 cl::init(berkeley)); 50 51 static bool berkeleyHeaderPrinted = false; 52 static bool moreThanOneFile = false; 53 54 cl::opt<bool> 55 DarwinLongFormat("l", cl::desc("When format is darwin, use long format " 56 "to include addresses and offsets.")); 57 58 static cl::list<std::string> 59 ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"), 60 cl::ZeroOrMore); 61 bool ArchAll = false; 62 63 enum RadixTy { octal = 8, decimal = 10, hexadecimal = 16 }; 64 static cl::opt<unsigned int> 65 Radix("-radix", cl::desc("Print size in radix. Only 8, 10, and 16 are valid"), 66 cl::init(decimal)); 67 68 static cl::opt<RadixTy> 69 RadixShort(cl::desc("Print size in radix:"), 70 cl::values(clEnumValN(octal, "o", "Print size in octal"), 71 clEnumValN(decimal, "d", "Print size in decimal"), 72 clEnumValN(hexadecimal, "x", "Print size in hexadecimal"), 73 clEnumValEnd), 74 cl::init(decimal)); 75 76 static cl::list<std::string> 77 InputFilenames(cl::Positional, cl::desc("<input files>"), cl::ZeroOrMore); 78 79 static std::string ToolName; 80 81 /// @brief If ec is not success, print the error and return true. 82 static bool error(std::error_code ec) { 83 if (!ec) 84 return false; 85 86 outs() << ToolName << ": error reading file: " << ec.message() << ".\n"; 87 outs().flush(); 88 return true; 89 } 90 91 /// @brief Get the length of the string that represents @p num in Radix 92 /// including the leading 0x or 0 for hexadecimal and octal respectively. 93 static size_t getNumLengthAsString(uint64_t num) { 94 APInt conv(64, num); 95 SmallString<32> result; 96 conv.toString(result, Radix, false, true); 97 return result.size(); 98 } 99 100 /// @brief Return the the printing format for the Radix. 101 static const char *getRadixFmt(void) { 102 switch (Radix) { 103 case octal: 104 return PRIo64; 105 case decimal: 106 return PRIu64; 107 case hexadecimal: 108 return PRIx64; 109 } 110 return nullptr; 111 } 112 113 /// @brief Print the size of each Mach-O segment and section in @p MachO. 114 /// 115 /// This is when used when @c OutputFormat is darwin and produces the same 116 /// output as darwin's size(1) -m output. 117 static void PrintDarwinSectionSizes(MachOObjectFile *MachO) { 118 std::string fmtbuf; 119 raw_string_ostream fmt(fmtbuf); 120 const char *radix_fmt = getRadixFmt(); 121 if (Radix == hexadecimal) 122 fmt << "0x"; 123 fmt << "%" << radix_fmt; 124 125 uint32_t LoadCommandCount = MachO->getHeader().ncmds; 126 uint32_t Filetype = MachO->getHeader().filetype; 127 MachOObjectFile::LoadCommandInfo Load = MachO->getFirstLoadCommandInfo(); 128 129 uint64_t total = 0; 130 for (unsigned I = 0;; ++I) { 131 if (Load.C.cmd == MachO::LC_SEGMENT_64) { 132 MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load); 133 outs() << "Segment " << Seg.segname << ": " 134 << format(fmt.str().c_str(), Seg.vmsize); 135 if (DarwinLongFormat) 136 outs() << " (vmaddr 0x" << format("%" PRIx64, Seg.vmaddr) << " fileoff " 137 << Seg.fileoff << ")"; 138 outs() << "\n"; 139 total += Seg.vmsize; 140 uint64_t sec_total = 0; 141 for (unsigned J = 0; J < Seg.nsects; ++J) { 142 MachO::section_64 Sec = MachO->getSection64(Load, J); 143 if (Filetype == MachO::MH_OBJECT) 144 outs() << "\tSection (" << format("%.16s", &Sec.segname) << ", " 145 << format("%.16s", &Sec.sectname) << "): "; 146 else 147 outs() << "\tSection " << format("%.16s", &Sec.sectname) << ": "; 148 outs() << format(fmt.str().c_str(), Sec.size); 149 if (DarwinLongFormat) 150 outs() << " (addr 0x" << format("%" PRIx64, Sec.addr) << " offset " 151 << Sec.offset << ")"; 152 outs() << "\n"; 153 sec_total += Sec.size; 154 } 155 if (Seg.nsects != 0) 156 outs() << "\ttotal " << format(fmt.str().c_str(), sec_total) << "\n"; 157 } else if (Load.C.cmd == MachO::LC_SEGMENT) { 158 MachO::segment_command Seg = MachO->getSegmentLoadCommand(Load); 159 outs() << "Segment " << Seg.segname << ": " 160 << format(fmt.str().c_str(), Seg.vmsize); 161 if (DarwinLongFormat) 162 outs() << " (vmaddr 0x" << format("%" PRIx64, Seg.vmaddr) << " fileoff " 163 << Seg.fileoff << ")"; 164 outs() << "\n"; 165 total += Seg.vmsize; 166 uint64_t sec_total = 0; 167 for (unsigned J = 0; J < Seg.nsects; ++J) { 168 MachO::section Sec = MachO->getSection(Load, J); 169 if (Filetype == MachO::MH_OBJECT) 170 outs() << "\tSection (" << format("%.16s", &Sec.segname) << ", " 171 << format("%.16s", &Sec.sectname) << "): "; 172 else 173 outs() << "\tSection " << format("%.16s", &Sec.sectname) << ": "; 174 outs() << format(fmt.str().c_str(), Sec.size); 175 if (DarwinLongFormat) 176 outs() << " (addr 0x" << format("%" PRIx64, Sec.addr) << " offset " 177 << Sec.offset << ")"; 178 outs() << "\n"; 179 sec_total += Sec.size; 180 } 181 if (Seg.nsects != 0) 182 outs() << "\ttotal " << format(fmt.str().c_str(), sec_total) << "\n"; 183 } 184 if (I == LoadCommandCount - 1) 185 break; 186 else 187 Load = MachO->getNextLoadCommandInfo(Load); 188 } 189 outs() << "total " << format(fmt.str().c_str(), total) << "\n"; 190 } 191 192 /// @brief Print the summary sizes of the standard Mach-O segments in @p MachO. 193 /// 194 /// This is when used when @c OutputFormat is berkeley with a Mach-O file and 195 /// produces the same output as darwin's size(1) default output. 196 static void PrintDarwinSegmentSizes(MachOObjectFile *MachO) { 197 uint32_t LoadCommandCount = MachO->getHeader().ncmds; 198 MachOObjectFile::LoadCommandInfo Load = MachO->getFirstLoadCommandInfo(); 199 200 uint64_t total_text = 0; 201 uint64_t total_data = 0; 202 uint64_t total_objc = 0; 203 uint64_t total_others = 0; 204 for (unsigned I = 0;; ++I) { 205 if (Load.C.cmd == MachO::LC_SEGMENT_64) { 206 MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load); 207 if (MachO->getHeader().filetype == MachO::MH_OBJECT) { 208 for (unsigned J = 0; J < Seg.nsects; ++J) { 209 MachO::section_64 Sec = MachO->getSection64(Load, J); 210 StringRef SegmentName = StringRef(Sec.segname); 211 if (SegmentName == "__TEXT") 212 total_text += Sec.size; 213 else if (SegmentName == "__DATA") 214 total_data += Sec.size; 215 else if (SegmentName == "__OBJC") 216 total_objc += Sec.size; 217 else 218 total_others += Sec.size; 219 } 220 } else { 221 StringRef SegmentName = StringRef(Seg.segname); 222 if (SegmentName == "__TEXT") 223 total_text += Seg.vmsize; 224 else if (SegmentName == "__DATA") 225 total_data += Seg.vmsize; 226 else if (SegmentName == "__OBJC") 227 total_objc += Seg.vmsize; 228 else 229 total_others += Seg.vmsize; 230 } 231 } else if (Load.C.cmd == MachO::LC_SEGMENT) { 232 MachO::segment_command Seg = MachO->getSegmentLoadCommand(Load); 233 if (MachO->getHeader().filetype == MachO::MH_OBJECT) { 234 for (unsigned J = 0; J < Seg.nsects; ++J) { 235 MachO::section Sec = MachO->getSection(Load, J); 236 StringRef SegmentName = StringRef(Sec.segname); 237 if (SegmentName == "__TEXT") 238 total_text += Sec.size; 239 else if (SegmentName == "__DATA") 240 total_data += Sec.size; 241 else if (SegmentName == "__OBJC") 242 total_objc += Sec.size; 243 else 244 total_others += Sec.size; 245 } 246 } else { 247 StringRef SegmentName = StringRef(Seg.segname); 248 if (SegmentName == "__TEXT") 249 total_text += Seg.vmsize; 250 else if (SegmentName == "__DATA") 251 total_data += Seg.vmsize; 252 else if (SegmentName == "__OBJC") 253 total_objc += Seg.vmsize; 254 else 255 total_others += Seg.vmsize; 256 } 257 } 258 if (I == LoadCommandCount - 1) 259 break; 260 else 261 Load = MachO->getNextLoadCommandInfo(Load); 262 } 263 uint64_t total = total_text + total_data + total_objc + total_others; 264 265 if (!berkeleyHeaderPrinted) { 266 outs() << "__TEXT\t__DATA\t__OBJC\tothers\tdec\thex\n"; 267 berkeleyHeaderPrinted = true; 268 } 269 outs() << total_text << "\t" << total_data << "\t" << total_objc << "\t" 270 << total_others << "\t" << total << "\t" << format("%" PRIx64, total) 271 << "\t"; 272 } 273 274 /// @brief Print the size of each section in @p Obj. 275 /// 276 /// The format used is determined by @c OutputFormat and @c Radix. 277 static void PrintObjectSectionSizes(ObjectFile *Obj) { 278 uint64_t total = 0; 279 std::string fmtbuf; 280 raw_string_ostream fmt(fmtbuf); 281 const char *radix_fmt = getRadixFmt(); 282 283 // If OutputFormat is darwin and we have a MachOObjectFile print as darwin's 284 // size(1) -m output, else if OutputFormat is darwin and not a Mach-O object 285 // let it fall through to OutputFormat berkeley. 286 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(Obj); 287 if (OutputFormat == darwin && MachO) 288 PrintDarwinSectionSizes(MachO); 289 // If we have a MachOObjectFile and the OutputFormat is berkeley print as 290 // darwin's default berkeley format for Mach-O files. 291 else if (MachO && OutputFormat == berkeley) 292 PrintDarwinSegmentSizes(MachO); 293 else if (OutputFormat == sysv) { 294 // Run two passes over all sections. The first gets the lengths needed for 295 // formatting the output. The second actually does the output. 296 std::size_t max_name_len = strlen("section"); 297 std::size_t max_size_len = strlen("size"); 298 std::size_t max_addr_len = strlen("addr"); 299 for (const SectionRef &Section : Obj->sections()) { 300 uint64_t size = 0; 301 if (error(Section.getSize(size))) 302 return; 303 total += size; 304 305 StringRef name; 306 uint64_t addr = 0; 307 if (error(Section.getName(name))) 308 return; 309 if (error(Section.getAddress(addr))) 310 return; 311 max_name_len = std::max(max_name_len, name.size()); 312 max_size_len = std::max(max_size_len, getNumLengthAsString(size)); 313 max_addr_len = std::max(max_addr_len, getNumLengthAsString(addr)); 314 } 315 316 // Add extra padding. 317 max_name_len += 2; 318 max_size_len += 2; 319 max_addr_len += 2; 320 321 // Setup header format. 322 fmt << "%-" << max_name_len << "s " 323 << "%" << max_size_len << "s " 324 << "%" << max_addr_len << "s\n"; 325 326 // Print header 327 outs() << format(fmt.str().c_str(), static_cast<const char *>("section"), 328 static_cast<const char *>("size"), 329 static_cast<const char *>("addr")); 330 fmtbuf.clear(); 331 332 // Setup per section format. 333 fmt << "%-" << max_name_len << "s " 334 << "%#" << max_size_len << radix_fmt << " " 335 << "%#" << max_addr_len << radix_fmt << "\n"; 336 337 // Print each section. 338 for (const SectionRef &Section : Obj->sections()) { 339 StringRef name; 340 uint64_t size = 0; 341 uint64_t addr = 0; 342 if (error(Section.getName(name))) 343 return; 344 if (error(Section.getSize(size))) 345 return; 346 if (error(Section.getAddress(addr))) 347 return; 348 std::string namestr = name; 349 350 outs() << format(fmt.str().c_str(), namestr.c_str(), size, addr); 351 } 352 353 // Print total. 354 fmtbuf.clear(); 355 fmt << "%-" << max_name_len << "s " 356 << "%#" << max_size_len << radix_fmt << "\n"; 357 outs() << format(fmt.str().c_str(), static_cast<const char *>("Total"), 358 total); 359 } else { 360 // The Berkeley format does not display individual section sizes. It 361 // displays the cumulative size for each section type. 362 uint64_t total_text = 0; 363 uint64_t total_data = 0; 364 uint64_t total_bss = 0; 365 366 // Make one pass over the section table to calculate sizes. 367 for (const SectionRef &Section : Obj->sections()) { 368 uint64_t size = 0; 369 bool isText = false; 370 bool isData = false; 371 bool isBSS = false; 372 if (error(Section.getSize(size))) 373 return; 374 if (error(Section.isText(isText))) 375 return; 376 if (error(Section.isData(isData))) 377 return; 378 if (error(Section.isBSS(isBSS))) 379 return; 380 if (isText) 381 total_text += size; 382 else if (isData) 383 total_data += size; 384 else if (isBSS) 385 total_bss += size; 386 } 387 388 total = total_text + total_data + total_bss; 389 390 if (!berkeleyHeaderPrinted) { 391 outs() << " text data bss " 392 << (Radix == octal ? "oct" : "dec") << " hex filename\n"; 393 berkeleyHeaderPrinted = true; 394 } 395 396 // Print result. 397 fmt << "%#7" << radix_fmt << " " 398 << "%#7" << radix_fmt << " " 399 << "%#7" << radix_fmt << " "; 400 outs() << format(fmt.str().c_str(), total_text, total_data, total_bss); 401 fmtbuf.clear(); 402 fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << " " 403 << "%7" PRIx64 " "; 404 outs() << format(fmt.str().c_str(), total, total); 405 } 406 } 407 408 /// @brief Checks to see if the @p o ObjectFile is a Mach-O file and if it is 409 /// and there is a list of architecture flags specified then check to 410 /// make sure this Mach-O file is one of those architectures or all 411 /// architectures was specificed. If not then an error is generated and 412 /// this routine returns false. Else it returns true. 413 static bool checkMachOAndArchFlags(ObjectFile *o, StringRef file) { 414 if (isa<MachOObjectFile>(o) && !ArchAll && ArchFlags.size() != 0) { 415 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 416 bool ArchFound = false; 417 MachO::mach_header H; 418 MachO::mach_header_64 H_64; 419 Triple T; 420 if (MachO->is64Bit()) { 421 H_64 = MachO->MachOObjectFile::getHeader64(); 422 T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype); 423 } else { 424 H = MachO->MachOObjectFile::getHeader(); 425 T = MachOObjectFile::getArch(H.cputype, H.cpusubtype); 426 } 427 unsigned i; 428 for (i = 0; i < ArchFlags.size(); ++i) { 429 if (ArchFlags[i] == T.getArchName()) 430 ArchFound = true; 431 break; 432 } 433 if (!ArchFound) { 434 errs() << ToolName << ": file: " << file 435 << " does not contain architecture: " << ArchFlags[i] << ".\n"; 436 return false; 437 } 438 } 439 return true; 440 } 441 442 /// @brief Print the section sizes for @p file. If @p file is an archive, print 443 /// the section sizes for each archive member. 444 static void PrintFileSectionSizes(StringRef file) { 445 // If file is not stdin, check that it exists. 446 if (file != "-") { 447 if (!sys::fs::exists(file)) { 448 errs() << ToolName << ": '" << file << "': " 449 << "No such file\n"; 450 return; 451 } 452 } 453 454 // Attempt to open the binary. 455 ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(file); 456 if (std::error_code EC = BinaryOrErr.getError()) { 457 errs() << ToolName << ": " << file << ": " << EC.message() << ".\n"; 458 return; 459 } 460 Binary &Bin = *BinaryOrErr.get().getBinary(); 461 462 if (Archive *a = dyn_cast<Archive>(&Bin)) { 463 // This is an archive. Iterate over each member and display its sizes. 464 for (object::Archive::child_iterator i = a->child_begin(), 465 e = a->child_end(); 466 i != e; ++i) { 467 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary(); 468 if (std::error_code EC = ChildOrErr.getError()) { 469 errs() << ToolName << ": " << file << ": " << EC.message() << ".\n"; 470 continue; 471 } 472 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) { 473 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 474 if (!checkMachOAndArchFlags(o, file)) 475 return; 476 if (OutputFormat == sysv) 477 outs() << o->getFileName() << " (ex " << a->getFileName() << "):\n"; 478 else if (MachO && OutputFormat == darwin) 479 outs() << a->getFileName() << "(" << o->getFileName() << "):\n"; 480 PrintObjectSectionSizes(o); 481 if (OutputFormat == berkeley) { 482 if (MachO) 483 outs() << a->getFileName() << "(" << o->getFileName() << ")\n"; 484 else 485 outs() << o->getFileName() << " (ex " << a->getFileName() << ")\n"; 486 } 487 } 488 } 489 } else if (MachOUniversalBinary *UB = 490 dyn_cast<MachOUniversalBinary>(&Bin)) { 491 // If we have a list of architecture flags specified dump only those. 492 if (!ArchAll && ArchFlags.size() != 0) { 493 // Look for a slice in the universal binary that matches each ArchFlag. 494 bool ArchFound; 495 for (unsigned i = 0; i < ArchFlags.size(); ++i) { 496 ArchFound = false; 497 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), 498 E = UB->end_objects(); 499 I != E; ++I) { 500 if (ArchFlags[i] == I->getArchTypeName()) { 501 ArchFound = true; 502 ErrorOr<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile(); 503 std::unique_ptr<Archive> UA; 504 if (UO) { 505 if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) { 506 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 507 if (OutputFormat == sysv) 508 outs() << o->getFileName() << " :\n"; 509 else if (MachO && OutputFormat == darwin) { 510 if (moreThanOneFile || ArchFlags.size() > 1) 511 outs() << o->getFileName() << " (for architecture " 512 << I->getArchTypeName() << "): \n"; 513 } 514 PrintObjectSectionSizes(o); 515 if (OutputFormat == berkeley) { 516 if (!MachO || moreThanOneFile || ArchFlags.size() > 1) 517 outs() << o->getFileName() << " (for architecture " 518 << I->getArchTypeName() << ")"; 519 outs() << "\n"; 520 } 521 } 522 } else if (!I->getAsArchive(UA)) { 523 // This is an archive. Iterate over each member and display its 524 // sizes. 525 for (object::Archive::child_iterator i = UA->child_begin(), 526 e = UA->child_end(); 527 i != e; ++i) { 528 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary(); 529 if (std::error_code EC = ChildOrErr.getError()) { 530 errs() << ToolName << ": " << file << ": " << EC.message() 531 << ".\n"; 532 continue; 533 } 534 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) { 535 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 536 if (OutputFormat == sysv) 537 outs() << o->getFileName() << " (ex " << UA->getFileName() 538 << "):\n"; 539 else if (MachO && OutputFormat == darwin) 540 outs() << UA->getFileName() << "(" << o->getFileName() 541 << ")" 542 << " (for architecture " << I->getArchTypeName() 543 << "):\n"; 544 PrintObjectSectionSizes(o); 545 if (OutputFormat == berkeley) { 546 if (MachO) { 547 outs() << UA->getFileName() << "(" << o->getFileName() 548 << ")"; 549 if (ArchFlags.size() > 1) 550 outs() << " (for architecture " << I->getArchTypeName() 551 << ")"; 552 outs() << "\n"; 553 } else 554 outs() << o->getFileName() << " (ex " << UA->getFileName() 555 << ")\n"; 556 } 557 } 558 } 559 } 560 } 561 } 562 if (!ArchFound) { 563 errs() << ToolName << ": file: " << file 564 << " does not contain architecture" << ArchFlags[i] << ".\n"; 565 return; 566 } 567 } 568 return; 569 } 570 // No architecture flags were specified so if this contains a slice that 571 // matches the host architecture dump only that. 572 if (!ArchAll) { 573 StringRef HostArchName = MachOObjectFile::getHostArch().getArchName(); 574 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), 575 E = UB->end_objects(); 576 I != E; ++I) { 577 if (HostArchName == I->getArchTypeName()) { 578 ErrorOr<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile(); 579 std::unique_ptr<Archive> UA; 580 if (UO) { 581 if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) { 582 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 583 if (OutputFormat == sysv) 584 outs() << o->getFileName() << " :\n"; 585 else if (MachO && OutputFormat == darwin) { 586 if (moreThanOneFile) 587 outs() << o->getFileName() << " (for architecture " 588 << I->getArchTypeName() << "):\n"; 589 } 590 PrintObjectSectionSizes(o); 591 if (OutputFormat == berkeley) { 592 if (!MachO || moreThanOneFile) 593 outs() << o->getFileName() << " (for architecture " 594 << I->getArchTypeName() << ")"; 595 outs() << "\n"; 596 } 597 } 598 } else if (!I->getAsArchive(UA)) { 599 // This is an archive. Iterate over each member and display its 600 // sizes. 601 for (object::Archive::child_iterator i = UA->child_begin(), 602 e = UA->child_end(); 603 i != e; ++i) { 604 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary(); 605 if (std::error_code EC = ChildOrErr.getError()) { 606 errs() << ToolName << ": " << file << ": " << EC.message() 607 << ".\n"; 608 continue; 609 } 610 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) { 611 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 612 if (OutputFormat == sysv) 613 outs() << o->getFileName() << " (ex " << UA->getFileName() 614 << "):\n"; 615 else if (MachO && OutputFormat == darwin) 616 outs() << UA->getFileName() << "(" << o->getFileName() << ")" 617 << " (for architecture " << I->getArchTypeName() 618 << "):\n"; 619 PrintObjectSectionSizes(o); 620 if (OutputFormat == berkeley) { 621 if (MachO) 622 outs() << UA->getFileName() << "(" << o->getFileName() 623 << ")\n"; 624 else 625 outs() << o->getFileName() << " (ex " << UA->getFileName() 626 << ")\n"; 627 } 628 } 629 } 630 } 631 return; 632 } 633 } 634 } 635 // Either all architectures have been specified or none have been specified 636 // and this does not contain the host architecture so dump all the slices. 637 bool moreThanOneArch = UB->getNumberOfObjects() > 1; 638 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), 639 E = UB->end_objects(); 640 I != E; ++I) { 641 ErrorOr<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile(); 642 std::unique_ptr<Archive> UA; 643 if (UO) { 644 if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) { 645 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 646 if (OutputFormat == sysv) 647 outs() << o->getFileName() << " :\n"; 648 else if (MachO && OutputFormat == darwin) { 649 if (moreThanOneFile || moreThanOneArch) 650 outs() << o->getFileName() << " (for architecture " 651 << I->getArchTypeName() << "):"; 652 outs() << "\n"; 653 } 654 PrintObjectSectionSizes(o); 655 if (OutputFormat == berkeley) { 656 if (!MachO || moreThanOneFile || moreThanOneArch) 657 outs() << o->getFileName() << " (for architecture " 658 << I->getArchTypeName() << ")"; 659 outs() << "\n"; 660 } 661 } 662 } else if (!I->getAsArchive(UA)) { 663 // This is an archive. Iterate over each member and display its sizes. 664 for (object::Archive::child_iterator i = UA->child_begin(), 665 e = UA->child_end(); 666 i != e; ++i) { 667 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = i->getAsBinary(); 668 if (std::error_code EC = ChildOrErr.getError()) { 669 errs() << ToolName << ": " << file << ": " << EC.message() << ".\n"; 670 continue; 671 } 672 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) { 673 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 674 if (OutputFormat == sysv) 675 outs() << o->getFileName() << " (ex " << UA->getFileName() 676 << "):\n"; 677 else if (MachO && OutputFormat == darwin) 678 outs() << UA->getFileName() << "(" << o->getFileName() << ")" 679 << " (for architecture " << I->getArchTypeName() << "):\n"; 680 PrintObjectSectionSizes(o); 681 if (OutputFormat == berkeley) { 682 if (MachO) 683 outs() << UA->getFileName() << "(" << o->getFileName() << ")" 684 << " (for architecture " << I->getArchTypeName() 685 << ")\n"; 686 else 687 outs() << o->getFileName() << " (ex " << UA->getFileName() 688 << ")\n"; 689 } 690 } 691 } 692 } 693 } 694 } else if (ObjectFile *o = dyn_cast<ObjectFile>(&Bin)) { 695 if (!checkMachOAndArchFlags(o, file)) 696 return; 697 if (OutputFormat == sysv) 698 outs() << o->getFileName() << " :\n"; 699 PrintObjectSectionSizes(o); 700 if (OutputFormat == berkeley) { 701 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o); 702 if (!MachO || moreThanOneFile) 703 outs() << o->getFileName(); 704 outs() << "\n"; 705 } 706 } else { 707 errs() << ToolName << ": " << file << ": " 708 << "Unrecognized file type.\n"; 709 } 710 // System V adds an extra newline at the end of each file. 711 if (OutputFormat == sysv) 712 outs() << "\n"; 713 } 714 715 int main(int argc, char **argv) { 716 // Print a stack trace if we signal out. 717 sys::PrintStackTraceOnErrorSignal(); 718 PrettyStackTraceProgram X(argc, argv); 719 720 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 721 cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n"); 722 723 ToolName = argv[0]; 724 if (OutputFormatShort.getNumOccurrences()) 725 OutputFormat = OutputFormatShort; 726 if (RadixShort.getNumOccurrences()) 727 Radix = RadixShort; 728 729 for (unsigned i = 0; i < ArchFlags.size(); ++i) { 730 if (ArchFlags[i] == "all") { 731 ArchAll = true; 732 } else { 733 if (!MachOObjectFile::isValidArch(ArchFlags[i])) { 734 outs() << ToolName << ": for the -arch option: Unknown architecture " 735 << "named '" << ArchFlags[i] << "'"; 736 return 1; 737 } 738 } 739 } 740 741 if (InputFilenames.size() == 0) 742 InputFilenames.push_back("a.out"); 743 744 moreThanOneFile = InputFilenames.size() > 1; 745 std::for_each(InputFilenames.begin(), InputFilenames.end(), 746 PrintFileSectionSizes); 747 748 return 0; 749 } 750