llvm-size: Add --totals option

[khemant]

Summary

--totals size sums up all the sized displayed in Berkeley format.

test/tools/llvm-size/X86/ignore-sections.s

 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: llvm-size -A %t.o | FileCheck --check-prefix="SYSV" %s
-// RUN: llvm-size -B %t.o| FileCheck --check-prefix="BSD" %s
+// RUN: llvm-size -B -t %t.o| FileCheck --check-prefix="BSD" %s
 
         .text
         .zero 4
         .data
         .long foo
         .bss
         .zero 4
         .ident "foo"

 // SYSV-NEXT:    .bss                   4      0
 // SYSV-NEXT:    .comment               5      0
 // SYSV-NEXT:    foo                    4      0
 // SYSV-NEXT:    .eh_frame             48      0
 // SYSV-NEXT:    Total                 69
 
 // BSD:        text    data     bss     dec     hex filename
 // BSD-NEXT:      4       4       4      12       c {{[ -\(\)_A-Za-z0-9.\\/:]+}}
+// BSD-NEXT:      4       4       4      12       c (TOTALS)

tools/llvm-size/llvm-size.cpp

static cl::opt<OutputFormatTy> OutputFormatShort(
     cl::desc("Specify output format"),
     cl::values(clEnumValN(sysv, "A", "System V format"),
                clEnumValN(berkeley, "B", "Berkeley format"),
                clEnumValN(darwin, "m", "Darwin -m format"), clEnumValEnd),
     cl::init(berkeley));
 
 static bool BerkeleyHeaderPrinted = false;
 static bool MoreThanOneFile = false;
+static uint64_t TotalObjectText = 0;
+static uint64_t TotalObjectData = 0;
+static uint64_t TotalObjectBss = 0;
+static uint64_t TotalObjectTotal = 0;
 
 cl::opt<bool>
 DarwinLongFormat("l", cl::desc("When format is darwin, use long format "
                                "to include addresses and offsets."));
 
 cl::opt<bool>
     ELFCommons("common",
                cl::desc("Print common symbols in the ELF file.  When using "

 static cl::opt<RadixTy>
 RadixShort(cl::desc("Print size in radix:"),
            cl::values(clEnumValN(octal, "o", "Print size in octal"),
                       clEnumValN(decimal, "d", "Print size in decimal"),
                       clEnumValN(hexadecimal, "x", "Print size in hexadecimal"),
                       clEnumValEnd),
            cl::init(decimal));
 
+static cl::opt<bool>
+    TotalSizes("totals",
+               cl::desc("Print totals of all objects - Berkeley format only"),
+               cl::init(false));
+
+static cl::alias TotalSizesShort("t", cl::desc("Short for --totals"),
+                                 cl::aliasopt(TotalSizes));
+
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::desc("<input files>"), cl::ZeroOrMore);
 
 bool HadError = false;
 
 static std::string ToolName;
 
 /// If ec is not success, print the error and return true.
static bool error(Twine Message) {
   HadError = true;
   errs() << ToolName << ": " << Message << ".\n";
   errs().flush();
   return true;
 }
 
 // This version of error() prints the archive name and member name, for example:
 // "libx.a(foo.o)" after the ToolName before the error message.  It sets
-// HadError but returns allowing the code to move on to other archive members. 
+// HadError but returns allowing the code to move on to other archive members.
 static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
                   StringRef ArchitectureName = StringRef()) {
   HadError = true;
   errs() << ToolName << ": " << FileName;
 
   Expected<StringRef> NameOrErr = C.getName();
   // TODO: if we have a error getting the name then it would be nice to print
   // the index of which archive member this is and or its offset in the
static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
   raw_string_ostream OS(Buf);
   logAllUnhandledErrors(std::move(E), OS, "");
   OS.flush();
   errs() << " " << Buf << "\n";
 }
 
 // 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
 // before the error message.  It sets HadError but returns allowing the code to
-// move on to other architecture slices.        
+// move on to other architecture slices.
 static void error(llvm::Error E, StringRef FileName,
                   StringRef ArchitectureName = StringRef()) {
   HadError = true;
   errs() << ToolName << ": " << FileName;
 
   if (!ArchitectureName.empty())
     errs() << " (for architecture " << ArchitectureName << ") ";
 
for (const SectionRef &Section : Obj->sections()) {
         total_bss += size;
     }
 
     if (ELFCommons)
       total_bss += getCommonSize(Obj);
 
     total = total_text + total_data + total_bss;
 
+    if (TotalSizes) {
+      TotalObjectText += total_text;
+      TotalObjectData += total_data;
+      TotalObjectBss += total_bss;
+      TotalObjectTotal += total;
+    }
+
     if (!BerkeleyHeaderPrinted) {
       outs() << "   text    data     bss     "
              << (Radix == octal ? "oct" : "dec") << "     hex filename\n";
       BerkeleyHeaderPrinted = true;
     }
 
     // Print result.
     fmt << "%#7" << radix_fmt << " "
if (Archive *a = dyn_cast<Archive>(&Bin)) {
     errs() << ToolName << ": " << file << ": "
            << "Unrecognized file type.\n";
   }
   // System V adds an extra newline at the end of each file.
   if (OutputFormat == sysv)
     outs() << "\n";
 }
 
+static void printBerkelyTotals() {
+  std::string fmtbuf;
+  raw_string_ostream fmt(fmtbuf);
+  const char *radix_fmt = getRadixFmt();
+  fmt << "%#7" << radix_fmt << " "
+      << "%#7" << radix_fmt << " "
+      << "%#7" << radix_fmt << " ";
+  outs() << format(fmt.str().c_str(), TotalObjectText, TotalObjectData,
+                   TotalObjectBss);
+  fmtbuf.clear();
+  fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << " "
+      << "%7" PRIx64 " ";
+  outs() << format(fmt.str().c_str(), TotalObjectTotal, TotalObjectTotal)
+         << "(TOTALS)\n";
+}
+
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
 
int main(int argc, char **argv) {
   }
 
   if (InputFilenames.size() == 0)
     InputFilenames.push_back("a.out");
 
   MoreThanOneFile = InputFilenames.size() > 1;
   std::for_each(InputFilenames.begin(), InputFilenames.end(),
                 printFileSectionSizes);
+  if (OutputFormat == berkeley && TotalSizes)
+    printBerkelyTotals();
 
   if (HadError)
     return 1;
 }