tools/llvm-size/llvm-size.cpp

   1 //===-- llvm-size.cpp - Print the size of each object section ---*- C++ -*-===//
   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/ELFObjectFile.h"
  19 #include "llvm/Object/MachO.h"
  20 #include "llvm/Object/MachOUniversal.h"
  21 #include "llvm/Object/ObjectFile.h"
  22 #include "llvm/Support/Casting.h"
  23 #include "llvm/Support/CommandLine.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/Format.h"
  26 #include "llvm/Support/InitLLVM.h"
  27 #include "llvm/Support/MemoryBuffer.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include <algorithm>
  30 #include <string>
  31 #include <system_error>
  32
  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")),
  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")),
  49     cl::init(berkeley));
  50
  51 static bool BerkeleyHeaderPrinted = false;
  52 static bool MoreThanOneFile = false;
  53 static uint64_t TotalObjectText = 0;
  54 static uint64_t TotalObjectData = 0;
  55 static uint64_t TotalObjectBss = 0;
  56 static uint64_t TotalObjectTotal = 0;
  57
  58 cl::opt<bool>
  59 DarwinLongFormat("l", cl::desc("When format is darwin, use long format "
  60                                "to include addresses and offsets."));
  61
  62 cl::opt<bool>
  63     ELFCommons("common",
  64                cl::desc("Print common symbols in the ELF file.  When using "
  65                         "Berkely format, this is added to bss."),
  66                cl::init(false));
  67
  68 static cl::list<std::string>
  69 ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
  70           cl::ZeroOrMore);
  71 static bool ArchAll = false;
  72
  73 enum RadixTy { octal = 8, decimal = 10, hexadecimal = 16 };
  74 static cl::opt<unsigned int>
  75 Radix("radix", cl::desc("Print size in radix. Only 8, 10, and 16 are valid"),
  76       cl::init(decimal));
  77
  78 static cl::opt<RadixTy>
  79 RadixShort(cl::desc("Print size in radix:"),
  80            cl::values(clEnumValN(octal, "o", "Print size in octal"),
  81                       clEnumValN(decimal, "d", "Print size in decimal"),
  82                       clEnumValN(hexadecimal, "x", "Print size in hexadecimal")),
  83            cl::init(decimal));
  84
  85 static cl::opt<bool>
  86     TotalSizes("totals",
  87                cl::desc("Print totals of all objects - Berkeley format only"),
  88                cl::init(false));
  89
  90 static cl::alias TotalSizesShort("t", cl::desc("Short for --totals"),
  91                                  cl::aliasopt(TotalSizes));
  92
  93 static cl::list<std::string>
  94 InputFilenames(cl::Positional, cl::desc("<input files>"), cl::ZeroOrMore);
  95
  96 static bool HadError = false;
  97
  98 static std::string ToolName;
  99
 100 /// If ec is not success, print the error and return true.
 101 static bool error(std::error_code ec) {
 102   if (!ec)
 103     return false;
 104
 105   HadError = true;
 106   errs() << ToolName << ": error reading file: " << ec.message() << ".\n";
 107   errs().flush();
 108   return true;
 109 }
 110
 111 static bool error(Twine Message) {
 112   HadError = true;
 113   errs() << ToolName << ": " << Message << ".\n";
 114   errs().flush();
 115   return true;
 116 }
 117
 118 // This version of error() prints the archive name and member name, for example:
 119 // "libx.a(foo.o)" after the ToolName before the error message.  It sets
 120 // HadError but returns allowing the code to move on to other archive members.
 121 static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
 122                   StringRef ArchitectureName = StringRef()) {
 123   HadError = true;
 124   errs() << ToolName << ": " << FileName;
 125
 126   Expected<StringRef> NameOrErr = C.getName();
 127   // TODO: if we have a error getting the name then it would be nice to print
 128   // the index of which archive member this is and or its offset in the
 129   // archive instead of "???" as the name.
 130   if (!NameOrErr) {
 131     consumeError(NameOrErr.takeError());
 132     errs() << "(" << "???" << ")";
 133   } else
 134     errs() << "(" << NameOrErr.get() << ")";
 135
 136   if (!ArchitectureName.empty())
 137     errs() << " (for architecture " << ArchitectureName << ") ";
 138
 139   std::string Buf;
 140   raw_string_ostream OS(Buf);
 141   logAllUnhandledErrors(std::move(E), OS, "");
 142   OS.flush();
 143   errs() << " " << Buf << "\n";
 144 }
 145
 146 // This version of error() prints the file name and which architecture slice it // is from, for example: "foo.o (for architecture i386)" after the ToolName
 147 // before the error message.  It sets HadError but returns allowing the code to
 148 // move on to other architecture slices.
 149 static void error(llvm::Error E, StringRef FileName,
 150                   StringRef ArchitectureName = StringRef()) {
 151   HadError = true;
 152   errs() << ToolName << ": " << FileName;
 153
 154   if (!ArchitectureName.empty())
 155     errs() << " (for architecture " << ArchitectureName << ") ";
 156
 157   std::string Buf;
 158   raw_string_ostream OS(Buf);
 159   logAllUnhandledErrors(std::move(E), OS, "");
 160   OS.flush();
 161   errs() << " " << Buf << "\n";
 162 }
 163
 164 /// Get the length of the string that represents @p num in Radix including the
 165 /// leading 0x or 0 for hexadecimal and octal respectively.
 166 static size_t getNumLengthAsString(uint64_t num) {
 167   APInt conv(64, num);
 168   SmallString<32> result;
 169   conv.toString(result, Radix, false, true);
 170   return result.size();
 171 }
 172
 173 /// Return the printing format for the Radix.
 174 static const char *getRadixFmt() {
 175   switch (Radix) {
 176   case octal:
 177     return PRIo64;
 178   case decimal:
 179     return PRIu64;
 180   case hexadecimal:
 181     return PRIx64;
 182   }
 183   return nullptr;
 184 }
 185
 186 /// Remove unneeded ELF sections from calculation
 187 static bool considerForSize(ObjectFile *Obj, SectionRef Section) {
 188   if (!Obj->isELF())
 189     return true;
 190   switch (static_cast<ELFSectionRef>(Section).getType()) {
 191   case ELF::SHT_NULL:
 192   case ELF::SHT_SYMTAB:
 193   case ELF::SHT_STRTAB:
 194   case ELF::SHT_REL:
 195   case ELF::SHT_RELA:
 196     return false;
 197   }
 198   return true;
 199 }
 200
 201 /// Total size of all ELF common symbols
 202 static uint64_t getCommonSize(ObjectFile *Obj) {
 203   uint64_t TotalCommons = 0;
 204   for (auto &Sym : Obj->symbols())
 205     if (Obj->getSymbolFlags(Sym.getRawDataRefImpl()) & SymbolRef::SF_Common)
 206       TotalCommons += Obj->getCommonSymbolSize(Sym.getRawDataRefImpl());
 207   return TotalCommons;
 208 }
 209
 210 /// Print the size of each Mach-O segment and section in @p MachO.
 211 ///
 212 /// This is when used when @c OutputFormat is darwin and produces the same
 213 /// output as darwin's size(1) -m output.
 214 static void printDarwinSectionSizes(MachOObjectFile *MachO) {
 215   std::string fmtbuf;
 216   raw_string_ostream fmt(fmtbuf);
 217   const char *radix_fmt = getRadixFmt();
 218   if (Radix == hexadecimal)
 219     fmt << "0x";
 220   fmt << "%" << radix_fmt;
 221
 222   uint32_t Filetype = MachO->getHeader().filetype;
 223
 224   uint64_t total = 0;
 225   for (const auto &Load : MachO->load_commands()) {
 226     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
 227       MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load);
 228       outs() << "Segment " << Seg.segname << ": "
 229              << format(fmt.str().c_str(), Seg.vmsize);
 230       if (DarwinLongFormat)
 231         outs() << " (vmaddr 0x" << format("%" PRIx64, Seg.vmaddr) << " fileoff "
 232                << Seg.fileoff << ")";
 233       outs() << "\n";
 234       total += Seg.vmsize;
 235       uint64_t sec_total = 0;
 236       for (unsigned J = 0; J < Seg.nsects; ++J) {
 237         MachO::section_64 Sec = MachO->getSection64(Load, J);
 238         if (Filetype == MachO::MH_OBJECT)
 239           outs() << "\tSection (" << format("%.16s", &Sec.segname) << ", "
 240                  << format("%.16s", &Sec.sectname) << "): ";
 241         else
 242           outs() << "\tSection " << format("%.16s", &Sec.sectname) << ": ";
 243         outs() << format(fmt.str().c_str(), Sec.size);
 244         if (DarwinLongFormat)
 245           outs() << " (addr 0x" << format("%" PRIx64, Sec.addr) << " offset "
 246                  << Sec.offset << ")";
 247         outs() << "\n";
 248         sec_total += Sec.size;
 249       }
 250       if (Seg.nsects != 0)
 251         outs() << "\ttotal " << format(fmt.str().c_str(), sec_total) << "\n";
 252     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
 253       MachO::segment_command Seg = MachO->getSegmentLoadCommand(Load);
 254       uint64_t Seg_vmsize = Seg.vmsize;
 255       outs() << "Segment " << Seg.segname << ": "
 256              << format(fmt.str().c_str(), Seg_vmsize);
 257       if (DarwinLongFormat)
 258         outs() << " (vmaddr 0x" << format("%" PRIx32, Seg.vmaddr) << " fileoff "
 259                << Seg.fileoff << ")";
 260       outs() << "\n";
 261       total += Seg.vmsize;
 262       uint64_t sec_total = 0;
 263       for (unsigned J = 0; J < Seg.nsects; ++J) {
 264         MachO::section Sec = MachO->getSection(Load, J);
 265         if (Filetype == MachO::MH_OBJECT)
 266           outs() << "\tSection (" << format("%.16s", &Sec.segname) << ", "
 267                  << format("%.16s", &Sec.sectname) << "): ";
 268         else
 269           outs() << "\tSection " << format("%.16s", &Sec.sectname) << ": ";
 270         uint64_t Sec_size = Sec.size;
 271         outs() << format(fmt.str().c_str(), Sec_size);
 272         if (DarwinLongFormat)
 273           outs() << " (addr 0x" << format("%" PRIx32, Sec.addr) << " offset "
 274                  << Sec.offset << ")";
 275         outs() << "\n";
 276         sec_total += Sec.size;
 277       }
 278       if (Seg.nsects != 0)
 279         outs() << "\ttotal " << format(fmt.str().c_str(), sec_total) << "\n";
 280     }
 281   }
 282   outs() << "total " << format(fmt.str().c_str(), total) << "\n";
 283 }
 284
 285 /// Print the summary sizes of the standard Mach-O segments in @p MachO.
 286 ///
 287 /// This is when used when @c OutputFormat is berkeley with a Mach-O file and
 288 /// produces the same output as darwin's size(1) default output.
 289 static void printDarwinSegmentSizes(MachOObjectFile *MachO) {
 290   uint64_t total_text = 0;
 291   uint64_t total_data = 0;
 292   uint64_t total_objc = 0;
 293   uint64_t total_others = 0;
 294   for (const auto &Load : MachO->load_commands()) {
 295     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
 296       MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load);
 297       if (MachO->getHeader().filetype == MachO::MH_OBJECT) {
 298         for (unsigned J = 0; J < Seg.nsects; ++J) {
 299           MachO::section_64 Sec = MachO->getSection64(Load, J);
 300           StringRef SegmentName = StringRef(Sec.segname);
 301           if (SegmentName == "__TEXT")
 302             total_text += Sec.size;
 303           else if (SegmentName == "__DATA")
 304             total_data += Sec.size;
 305           else if (SegmentName == "__OBJC")
 306             total_objc += Sec.size;
 307           else
 308             total_others += Sec.size;
 309         }
 310       } else {
 311         StringRef SegmentName = StringRef(Seg.segname);
 312         if (SegmentName == "__TEXT")
 313           total_text += Seg.vmsize;
 314         else if (SegmentName == "__DATA")
 315           total_data += Seg.vmsize;
 316         else if (SegmentName == "__OBJC")
 317           total_objc += Seg.vmsize;
 318         else
 319           total_others += Seg.vmsize;
 320       }
 321     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
 322       MachO::segment_command Seg = MachO->getSegmentLoadCommand(Load);
 323       if (MachO->getHeader().filetype == MachO::MH_OBJECT) {
 324         for (unsigned J = 0; J < Seg.nsects; ++J) {
 325           MachO::section Sec = MachO->getSection(Load, J);
 326           StringRef SegmentName = StringRef(Sec.segname);
 327           if (SegmentName == "__TEXT")
 328             total_text += Sec.size;
 329           else if (SegmentName == "__DATA")
 330             total_data += Sec.size;
 331           else if (SegmentName == "__OBJC")
 332             total_objc += Sec.size;
 333           else
 334             total_others += Sec.size;
 335         }
 336       } else {
 337         StringRef SegmentName = StringRef(Seg.segname);
 338         if (SegmentName == "__TEXT")
 339           total_text += Seg.vmsize;
 340         else if (SegmentName == "__DATA")
 341           total_data += Seg.vmsize;
 342         else if (SegmentName == "__OBJC")
 343           total_objc += Seg.vmsize;
 344         else
 345           total_others += Seg.vmsize;
 346       }
 347     }
 348   }
 349   uint64_t total = total_text + total_data + total_objc + total_others;
 350
 351   if (!BerkeleyHeaderPrinted) {
 352     outs() << "__TEXT\t__DATA\t__OBJC\tothers\tdec\thex\n";
 353     BerkeleyHeaderPrinted = true;
 354   }
 355   outs() << total_text << "\t" << total_data << "\t" << total_objc << "\t"
 356          << total_others << "\t" << total << "\t" << format("%" PRIx64, total)
 357          << "\t";
 358 }
 359
 360 /// Print the size of each section in @p Obj.
 361 ///
 362 /// The format used is determined by @c OutputFormat and @c Radix.
 363 static void printObjectSectionSizes(ObjectFile *Obj) {
 364   uint64_t total = 0;
 365   std::string fmtbuf;
 366   raw_string_ostream fmt(fmtbuf);
 367   const char *radix_fmt = getRadixFmt();
 368
 369   // If OutputFormat is darwin and we have a MachOObjectFile print as darwin's
 370   // size(1) -m output, else if OutputFormat is darwin and not a Mach-O object
 371   // let it fall through to OutputFormat berkeley.
 372   MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(Obj);
 373   if (OutputFormat == darwin && MachO)
 374     printDarwinSectionSizes(MachO);
 375   // If we have a MachOObjectFile and the OutputFormat is berkeley print as
 376   // darwin's default berkeley format for Mach-O files.
 377   else if (MachO && OutputFormat == berkeley)
 378     printDarwinSegmentSizes(MachO);
 379   else if (OutputFormat == sysv) {
 380     // Run two passes over all sections. The first gets the lengths needed for
 381     // formatting the output. The second actually does the output.
 382     std::size_t max_name_len = strlen("section");
 383     std::size_t max_size_len = strlen("size");
 384     std::size_t max_addr_len = strlen("addr");
 385     for (const SectionRef &Section : Obj->sections()) {
 386       if (!considerForSize(Obj, Section))
 387         continue;
 388       uint64_t size = Section.getSize();
 389       total += size;
 390
 391       StringRef name;
 392       if (error(Section.getName(name)))
 393         return;
 394       uint64_t addr = Section.getAddress();
 395       max_name_len = std::max(max_name_len, name.size());
 396       max_size_len = std::max(max_size_len, getNumLengthAsString(size));
 397       max_addr_len = std::max(max_addr_len, getNumLengthAsString(addr));
 398     }
 399
 400     // Add extra padding.
 401     max_name_len += 2;
 402     max_size_len += 2;
 403     max_addr_len += 2;
 404
 405     // Setup header format.
 406     fmt << "%-" << max_name_len << "s "
 407         << "%" << max_size_len << "s "
 408         << "%" << max_addr_len << "s\n";
 409
 410     // Print header
 411     outs() << format(fmt.str().c_str(), static_cast<const char *>("section"),
 412                      static_cast<const char *>("size"),
 413                      static_cast<const char *>("addr"));
 414     fmtbuf.clear();
 415
 416     // Setup per section format.
 417     fmt << "%-" << max_name_len << "s "
 418         << "%#" << max_size_len << radix_fmt << " "
 419         << "%#" << max_addr_len << radix_fmt << "\n";
 420
 421     // Print each section.
 422     for (const SectionRef &Section : Obj->sections()) {
 423       if (!considerForSize(Obj, Section))
 424         continue;
 425       StringRef name;
 426       if (error(Section.getName(name)))
 427         return;
 428       uint64_t size = Section.getSize();
 429       uint64_t addr = Section.getAddress();
 430       std::string namestr = name;
 431
 432       outs() << format(fmt.str().c_str(), namestr.c_str(), size, addr);
 433     }
 434
 435     if (ELFCommons) {
 436       uint64_t CommonSize = getCommonSize(Obj);
 437       total += CommonSize;
 438       outs() << format(fmt.str().c_str(), std::string("*COM*").c_str(),
 439                        CommonSize, static_cast<uint64_t>(0));
 440     }
 441
 442     // Print total.
 443     fmtbuf.clear();
 444     fmt << "%-" << max_name_len << "s "
 445         << "%#" << max_size_len << radix_fmt << "\n";
 446     outs() << format(fmt.str().c_str(), static_cast<const char *>("Total"),
 447                      total);
 448   } else {
 449     // The Berkeley format does not display individual section sizes. It
 450     // displays the cumulative size for each section type.
 451     uint64_t total_text = 0;
 452     uint64_t total_data = 0;
 453     uint64_t total_bss = 0;
 454
 455     // Make one pass over the section table to calculate sizes.
 456     for (const SectionRef &Section : Obj->sections()) {
 457       uint64_t size = Section.getSize();
 458       bool isText = Section.isText();
 459       bool isData = Section.isData();
 460       bool isBSS = Section.isBSS();
 461       if (isText)
 462         total_text += size;
 463       else if (isData)
 464         total_data += size;
 465       else if (isBSS)
 466         total_bss += size;
 467     }
 468
 469     if (ELFCommons)
 470       total_bss += getCommonSize(Obj);
 471
 472     total = total_text + total_data + total_bss;
 473
 474     if (TotalSizes) {
 475       TotalObjectText += total_text;
 476       TotalObjectData += total_data;
 477       TotalObjectBss += total_bss;
 478       TotalObjectTotal += total;
 479     }
 480
 481     if (!BerkeleyHeaderPrinted) {
 482       outs() << "   text\t"
 483                 "   data\t"
 484                 "    bss\t"
 485                 "    "
 486              << (Radix == octal ? "oct" : "dec")
 487              << "\t"
 488                 "    hex\t"
 489                 "filename\n";
 490       BerkeleyHeaderPrinted = true;
 491     }
 492
 493     // Print result.
 494     fmt << "%#7" << radix_fmt << "\t"
 495         << "%#7" << radix_fmt << "\t"
 496         << "%#7" << radix_fmt << "\t";
 497     outs() << format(fmt.str().c_str(), total_text, total_data, total_bss);
 498     fmtbuf.clear();
 499     fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << "\t"
 500         << "%7" PRIx64 "\t";
 501     outs() << format(fmt.str().c_str(), total, total);
 502   }
 503 }
 504
 505 /// Checks to see if the @p O ObjectFile is a Mach-O file and if it is and there
 506 /// is a list of architecture flags specified then check to make sure this
 507 /// Mach-O file is one of those architectures or all architectures was
 508 /// specificed.  If not then an error is generated and this routine returns
 509 /// false.  Else it returns true.
 510 static bool checkMachOAndArchFlags(ObjectFile *O, StringRef Filename) {
 511   auto *MachO = dyn_cast<MachOObjectFile>(O);
 512
 513   if (!MachO || ArchAll || ArchFlags.empty())
 514     return true;
 515
 516   MachO::mach_header H;
 517   MachO::mach_header_64 H_64;
 518   Triple T;
 519   if (MachO->is64Bit()) {
 520     H_64 = MachO->MachOObjectFile::getHeader64();
 521     T = MachOObjectFile::getArchTriple(H_64.cputype, H_64.cpusubtype);
 522   } else {
 523     H = MachO->MachOObjectFile::getHeader();
 524     T = MachOObjectFile::getArchTriple(H.cputype, H.cpusubtype);
 525   }
 526   if (none_of(ArchFlags, [&](const std::string &Name) {
 527         return Name == T.getArchName();
 528       })) {
 529     error(Filename + ": No architecture specified");
 530     return false;
 531   }
 532   return true;
 533 }
 534
 535 /// Print the section sizes for @p file. If @p file is an archive, print the
 536 /// section sizes for each archive member.
 537 static void printFileSectionSizes(StringRef file) {
 538
 539   // Attempt to open the binary.
 540   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(file);
 541   if (!BinaryOrErr) {
 542     error(BinaryOrErr.takeError(), file);
 543     return;
 544   }
 545   Binary &Bin = *BinaryOrErr.get().getBinary();
 546
 547   if (Archive *a = dyn_cast<Archive>(&Bin)) {
 548     // This is an archive. Iterate over each member and display its sizes.
 549     Error Err = Error::success();
 550     for (auto &C : a->children(Err)) {
 551       Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
 552       if (!ChildOrErr) {
 553         if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
 554           error(std::move(E), a->getFileName(), C);
 555         continue;
 556       }
 557       if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
 558         MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 559         if (!checkMachOAndArchFlags(o, file))
 560           return;
 561         if (OutputFormat == sysv)
 562           outs() << o->getFileName() << "   (ex " << a->getFileName() << "):\n";
 563         else if (MachO && OutputFormat == darwin)
 564           outs() << a->getFileName() << "(" << o->getFileName() << "):\n";
 565         printObjectSectionSizes(o);
 566         if (OutputFormat == berkeley) {
 567           if (MachO)
 568             outs() << a->getFileName() << "(" << o->getFileName() << ")\n";
 569           else
 570             outs() << o->getFileName() << " (ex " << a->getFileName() << ")\n";
 571         }
 572       }
 573     }
 574     if (Err)
 575       error(std::move(Err), a->getFileName());
 576   } else if (MachOUniversalBinary *UB =
 577                  dyn_cast<MachOUniversalBinary>(&Bin)) {
 578     // If we have a list of architecture flags specified dump only those.
 579     if (!ArchAll && ArchFlags.size() != 0) {
 580       // Look for a slice in the universal binary that matches each ArchFlag.
 581       bool ArchFound;
 582       for (unsigned i = 0; i < ArchFlags.size(); ++i) {
 583         ArchFound = false;
 584         for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
 585                                                    E = UB->end_objects();
 586              I != E; ++I) {
 587           if (ArchFlags[i] == I->getArchFlagName()) {
 588             ArchFound = true;
 589             Expected<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile();
 590             if (UO) {
 591               if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) {
 592                 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 593                 if (OutputFormat == sysv)
 594                   outs() << o->getFileName() << "  :\n";
 595                 else if (MachO && OutputFormat == darwin) {
 596                   if (MoreThanOneFile || ArchFlags.size() > 1)
 597                     outs() << o->getFileName() << " (for architecture "
 598                            << I->getArchFlagName() << "): \n";
 599                 }
 600                 printObjectSectionSizes(o);
 601                 if (OutputFormat == berkeley) {
 602                   if (!MachO || MoreThanOneFile || ArchFlags.size() > 1)
 603                     outs() << o->getFileName() << " (for architecture "
 604                            << I->getArchFlagName() << ")";
 605                   outs() << "\n";
 606                 }
 607               }
 608             } else if (auto E = isNotObjectErrorInvalidFileType(
 609                        UO.takeError())) {
 610               error(std::move(E), file, ArchFlags.size() > 1 ?
 611                     StringRef(I->getArchFlagName()) : StringRef());
 612               return;
 613             } else if (Expected<std::unique_ptr<Archive>> AOrErr =
 614                            I->getAsArchive()) {
 615               std::unique_ptr<Archive> &UA = *AOrErr;
 616               // This is an archive. Iterate over each member and display its
 617               // sizes.
 618               Error Err = Error::success();
 619               for (auto &C : UA->children(Err)) {
 620                 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
 621                 if (!ChildOrErr) {
 622                   if (auto E = isNotObjectErrorInvalidFileType(
 623                                     ChildOrErr.takeError()))
 624                     error(std::move(E), UA->getFileName(), C,
 625                           ArchFlags.size() > 1 ?
 626                           StringRef(I->getArchFlagName()) : StringRef());
 627                   continue;
 628                 }
 629                 if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
 630                   MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 631                   if (OutputFormat == sysv)
 632                     outs() << o->getFileName() << "   (ex " << UA->getFileName()
 633                            << "):\n";
 634                   else if (MachO && OutputFormat == darwin)
 635                     outs() << UA->getFileName() << "(" << o->getFileName()
 636                            << ")"
 637                            << " (for architecture " << I->getArchFlagName()
 638                            << "):\n";
 639                   printObjectSectionSizes(o);
 640                   if (OutputFormat == berkeley) {
 641                     if (MachO) {
 642                       outs() << UA->getFileName() << "(" << o->getFileName()
 643                              << ")";
 644                       if (ArchFlags.size() > 1)
 645                         outs() << " (for architecture " << I->getArchFlagName()
 646                                << ")";
 647                       outs() << "\n";
 648                     } else
 649                       outs() << o->getFileName() << " (ex " << UA->getFileName()
 650                              << ")\n";
 651                   }
 652                 }
 653               }
 654               if (Err)
 655                 error(std::move(Err), UA->getFileName());
 656             } else {
 657               consumeError(AOrErr.takeError());
 658               error("Mach-O universal file: " + file + " for architecture " +
 659                     StringRef(I->getArchFlagName()) +
 660                     " is not a Mach-O file or an archive file");
 661             }
 662           }
 663         }
 664         if (!ArchFound) {
 665           errs() << ToolName << ": file: " << file
 666                  << " does not contain architecture" << ArchFlags[i] << ".\n";
 667           return;
 668         }
 669       }
 670       return;
 671     }
 672     // No architecture flags were specified so if this contains a slice that
 673     // matches the host architecture dump only that.
 674     if (!ArchAll) {
 675       StringRef HostArchName = MachOObjectFile::getHostArch().getArchName();
 676       for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
 677                                                  E = UB->end_objects();
 678            I != E; ++I) {
 679         if (HostArchName == I->getArchFlagName()) {
 680           Expected<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile();
 681           if (UO) {
 682             if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) {
 683               MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 684               if (OutputFormat == sysv)
 685                 outs() << o->getFileName() << "  :\n";
 686               else if (MachO && OutputFormat == darwin) {
 687                 if (MoreThanOneFile)
 688                   outs() << o->getFileName() << " (for architecture "
 689                          << I->getArchFlagName() << "):\n";
 690               }
 691               printObjectSectionSizes(o);
 692               if (OutputFormat == berkeley) {
 693                 if (!MachO || MoreThanOneFile)
 694                   outs() << o->getFileName() << " (for architecture "
 695                          << I->getArchFlagName() << ")";
 696                 outs() << "\n";
 697               }
 698             }
 699           } else if (auto E = isNotObjectErrorInvalidFileType(UO.takeError())) {
 700             error(std::move(E), file);
 701             return;
 702           } else if (Expected<std::unique_ptr<Archive>> AOrErr =
 703                          I->getAsArchive()) {
 704             std::unique_ptr<Archive> &UA = *AOrErr;
 705             // This is an archive. Iterate over each member and display its
 706             // sizes.
 707             Error Err = Error::success();
 708             for (auto &C : UA->children(Err)) {
 709               Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
 710               if (!ChildOrErr) {
 711                 if (auto E = isNotObjectErrorInvalidFileType(
 712                                 ChildOrErr.takeError()))
 713                   error(std::move(E), UA->getFileName(), C);
 714                 continue;
 715               }
 716               if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
 717                 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 718                 if (OutputFormat == sysv)
 719                   outs() << o->getFileName() << "   (ex " << UA->getFileName()
 720                          << "):\n";
 721                 else if (MachO && OutputFormat == darwin)
 722                   outs() << UA->getFileName() << "(" << o->getFileName() << ")"
 723                          << " (for architecture " << I->getArchFlagName()
 724                          << "):\n";
 725                 printObjectSectionSizes(o);
 726                 if (OutputFormat == berkeley) {
 727                   if (MachO)
 728                     outs() << UA->getFileName() << "(" << o->getFileName()
 729                            << ")\n";
 730                   else
 731                     outs() << o->getFileName() << " (ex " << UA->getFileName()
 732                            << ")\n";
 733                 }
 734               }
 735             }
 736             if (Err)
 737               error(std::move(Err), UA->getFileName());
 738           } else {
 739             consumeError(AOrErr.takeError());
 740             error("Mach-O universal file: " + file + " for architecture " +
 741                    StringRef(I->getArchFlagName()) +
 742                    " is not a Mach-O file or an archive file");
 743           }
 744           return;
 745         }
 746       }
 747     }
 748     // Either all architectures have been specified or none have been specified
 749     // and this does not contain the host architecture so dump all the slices.
 750     bool MoreThanOneArch = UB->getNumberOfObjects() > 1;
 751     for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
 752                                                E = UB->end_objects();
 753          I != E; ++I) {
 754       Expected<std::unique_ptr<ObjectFile>> UO = I->getAsObjectFile();
 755       if (UO) {
 756         if (ObjectFile *o = dyn_cast<ObjectFile>(&*UO.get())) {
 757           MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 758           if (OutputFormat == sysv)
 759             outs() << o->getFileName() << "  :\n";
 760           else if (MachO && OutputFormat == darwin) {
 761             if (MoreThanOneFile || MoreThanOneArch)
 762               outs() << o->getFileName() << " (for architecture "
 763                      << I->getArchFlagName() << "):";
 764             outs() << "\n";
 765           }
 766           printObjectSectionSizes(o);
 767           if (OutputFormat == berkeley) {
 768             if (!MachO || MoreThanOneFile || MoreThanOneArch)
 769               outs() << o->getFileName() << " (for architecture "
 770                      << I->getArchFlagName() << ")";
 771             outs() << "\n";
 772           }
 773         }
 774       } else if (auto E = isNotObjectErrorInvalidFileType(UO.takeError())) {
 775         error(std::move(E), file, MoreThanOneArch ?
 776               StringRef(I->getArchFlagName()) : StringRef());
 777         return;
 778       } else if (Expected<std::unique_ptr<Archive>> AOrErr =
 779                          I->getAsArchive()) {
 780         std::unique_ptr<Archive> &UA = *AOrErr;
 781         // This is an archive. Iterate over each member and display its sizes.
 782         Error Err = Error::success();
 783         for (auto &C : UA->children(Err)) {
 784           Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
 785           if (!ChildOrErr) {
 786             if (auto E = isNotObjectErrorInvalidFileType(
 787                               ChildOrErr.takeError()))
 788               error(std::move(E), UA->getFileName(), C, MoreThanOneArch ?
 789                     StringRef(I->getArchFlagName()) : StringRef());
 790             continue;
 791           }
 792           if (ObjectFile *o = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
 793             MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 794             if (OutputFormat == sysv)
 795               outs() << o->getFileName() << "   (ex " << UA->getFileName()
 796                      << "):\n";
 797             else if (MachO && OutputFormat == darwin)
 798               outs() << UA->getFileName() << "(" << o->getFileName() << ")"
 799                      << " (for architecture " << I->getArchFlagName() << "):\n";
 800             printObjectSectionSizes(o);
 801             if (OutputFormat == berkeley) {
 802               if (MachO)
 803                 outs() << UA->getFileName() << "(" << o->getFileName() << ")"
 804                        << " (for architecture " << I->getArchFlagName()
 805                        << ")\n";
 806               else
 807                 outs() << o->getFileName() << " (ex " << UA->getFileName()
 808                        << ")\n";
 809             }
 810           }
 811         }
 812         if (Err)
 813           error(std::move(Err), UA->getFileName());
 814       } else {
 815         consumeError(AOrErr.takeError());
 816         error("Mach-O universal file: " + file + " for architecture " +
 817                StringRef(I->getArchFlagName()) +
 818                " is not a Mach-O file or an archive file");
 819       }
 820     }
 821   } else if (ObjectFile *o = dyn_cast<ObjectFile>(&Bin)) {
 822     if (!checkMachOAndArchFlags(o, file))
 823       return;
 824     MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o);
 825     if (OutputFormat == sysv)
 826       outs() << o->getFileName() << "  :\n";
 827     else if (MachO && OutputFormat == darwin && MoreThanOneFile)
 828       outs() << o->getFileName() << ":\n";
 829     printObjectSectionSizes(o);
 830     if (OutputFormat == berkeley) {
 831       if (!MachO || MoreThanOneFile)
 832         outs() << o->getFileName();
 833       outs() << "\n";
 834     }
 835   } else {
 836     errs() << ToolName << ": " << file << ": "
 837            << "Unrecognized file type.\n";
 838   }
 839   // System V adds an extra newline at the end of each file.
 840   if (OutputFormat == sysv)
 841     outs() << "\n";
 842 }
 843
 844 static void printBerkelyTotals() {
 845   std::string fmtbuf;
 846   raw_string_ostream fmt(fmtbuf);
 847   const char *radix_fmt = getRadixFmt();
 848   fmt << "%#7" << radix_fmt << "\t"
 849       << "%#7" << radix_fmt << "\t"
 850       << "%#7" << radix_fmt << "\t";
 851   outs() << format(fmt.str().c_str(), TotalObjectText, TotalObjectData,
 852                    TotalObjectBss);
 853   fmtbuf.clear();
 854   fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << "\t"
 855       << "%7" PRIx64 "\t";
 856   outs() << format(fmt.str().c_str(), TotalObjectTotal, TotalObjectTotal)
 857          << "(TOTALS)\n";
 858 }
 859
 860 int main(int argc, char **argv) {
 861   InitLLVM X(argc, argv);
 862   cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
 863
 864   ToolName = argv[0];
 865   if (OutputFormatShort.getNumOccurrences())
 866     OutputFormat = static_cast<OutputFormatTy>(OutputFormatShort);
 867   if (RadixShort.getNumOccurrences())
 868     Radix = RadixShort;
 869
 870   for (unsigned i = 0; i < ArchFlags.size(); ++i) {
 871     if (ArchFlags[i] == "all") {
 872       ArchAll = true;
 873     } else {
 874       if (!MachOObjectFile::isValidArch(ArchFlags[i])) {
 875         outs() << ToolName << ": for the -arch option: Unknown architecture "
 876                << "named '" << ArchFlags[i] << "'";
 877         return 1;
 878       }
 879     }
 880   }
 881
 882   if (InputFilenames.size() == 0)
 883     InputFilenames.push_back("a.out");
 884
 885   MoreThanOneFile = InputFilenames.size() > 1;
 886   llvm::for_each(InputFilenames, printFileSectionSizes);
 887   if (OutputFormat == berkeley && TotalSizes)
 888     printBerkelyTotals();
 889
 890   if (HadError)
 891     return 1;
 892 }