tools/llvm-size/llvm-size.cpp

   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/Support/Casting.h"
  20 #include "llvm/Support/CommandLine.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Format.h"
  23 #include "llvm/Support/ManagedStatic.h"
  24 #include "llvm/Support/MemoryBuffer.h"
  25 #include "llvm/Support/PrettyStackTrace.h"
  26 #include "llvm/Support/Signals.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include "llvm/Support/system_error.h"
  29 #include <algorithm>
  30 #include <string>
  31 using namespace llvm;
  32 using namespace object;
  33
  34 enum OutputFormatTy {berkeley, sysv};
  35 static cl::opt<OutputFormatTy>
  36        OutputFormat("format",
  37          cl::desc("Specify output format"),
  38          cl::values(clEnumVal(sysv, "System V format"),
  39                     clEnumVal(berkeley, "Berkeley format"),
  40                     clEnumValEnd),
  41          cl::init(berkeley));
  42
  43 static cl::opt<OutputFormatTy>
  44        OutputFormatShort(cl::desc("Specify output format"),
  45          cl::values(clEnumValN(sysv, "A", "System V format"),
  46                     clEnumValN(berkeley, "B", "Berkeley format"),
  47                     clEnumValEnd),
  48          cl::init(berkeley));
  49
  50 enum RadixTy {octal = 8, decimal = 10, hexadecimal = 16};
  51 static cl::opt<unsigned int>
  52        Radix("-radix",
  53          cl::desc("Print size in radix. Only 8, 10, and 16 are valid"),
  54          cl::init(decimal));
  55
  56 static cl::opt<RadixTy>
  57        RadixShort(cl::desc("Print size in radix:"),
  58          cl::values(clEnumValN(octal, "o", "Print size in octal"),
  59                     clEnumValN(decimal, "d", "Print size in decimal"),
  60                     clEnumValN(hexadecimal, "x", "Print size in hexadecimal"),
  61                     clEnumValEnd),
  62          cl::init(decimal));
  63
  64 static cl::list<std::string>
  65        InputFilenames(cl::Positional, cl::desc("<input files>"),
  66                       cl::ZeroOrMore);
  67
  68 static std::string ToolName;
  69
  70 ///  @brief If ec is not success, print the error and return true.
  71 static bool error(error_code ec) {
  72   if (!ec) return false;
  73
  74   outs() << ToolName << ": error reading file: " << ec.message() << ".\n";
  75   outs().flush();
  76   return true;
  77 }
  78
  79 /// @brief Get the length of the string that represents @p num in Radix
  80 ///        including the leading 0x or 0 for hexadecimal and octal respectively.
  81 static size_t getNumLengthAsString(uint64_t num) {
  82   APInt conv(64, num);
  83   SmallString<32> result;
  84   conv.toString(result, Radix, false, true);
  85   return result.size();
  86 }
  87
  88 /// @brief Print the size of each section in @p o.
  89 ///
  90 /// The format used is determined by @c OutputFormat and @c Radix.
  91 static void PrintObjectSectionSizes(ObjectFile *o) {
  92   uint64_t total = 0;
  93   std::string fmtbuf;
  94   raw_string_ostream fmt(fmtbuf);
  95
  96   const char *radix_fmt = 0;
  97   switch (Radix) {
  98   case octal:
  99     radix_fmt = PRIo64;
 100     break;
 101   case decimal:
 102     radix_fmt = PRIu64;
 103     break;
 104   case hexadecimal:
 105     radix_fmt = PRIx64;
 106     break;
 107   }
 108   if (OutputFormat == sysv) {
 109     // Run two passes over all sections. The first gets the lengths needed for
 110     // formatting the output. The second actually does the output.
 111     std::size_t max_name_len = strlen("section");
 112     std::size_t max_size_len = strlen("size");
 113     std::size_t max_addr_len = strlen("addr");
 114     error_code ec;
 115     for (section_iterator i = o->begin_sections(),
 116                           e = o->end_sections(); i != e;
 117                           i.increment(ec)) {
 118       if (error(ec))
 119         return;
 120       uint64_t size = 0;
 121       if (error(i->getSize(size)))
 122         return;
 123       total += size;
 124
 125       StringRef name;
 126       uint64_t addr = 0;
 127       if (error(i->getName(name))) return;
 128       if (error(i->getAddress(addr))) return;
 129       max_name_len = std::max(max_name_len, name.size());
 130       max_size_len = std::max(max_size_len, getNumLengthAsString(size));
 131       max_addr_len = std::max(max_addr_len, getNumLengthAsString(addr));
 132     }
 133
 134     // Add extra padding.
 135     max_name_len += 2;
 136     max_size_len += 2;
 137     max_addr_len += 2;
 138
 139     // Setup header format.
 140     fmt << "%-" << max_name_len << "s "
 141         << "%" << max_size_len << "s "
 142         << "%" << max_addr_len << "s\n";
 143
 144     // Print header
 145     outs() << format(fmt.str().c_str(),
 146                      static_cast<const char*>("section"),
 147                      static_cast<const char*>("size"),
 148                      static_cast<const char*>("addr"));
 149     fmtbuf.clear();
 150
 151     // Setup per section format.
 152     fmt << "%-" << max_name_len << "s "
 153         << "%#" << max_size_len << radix_fmt << " "
 154         << "%#" << max_addr_len << radix_fmt << "\n";
 155
 156     // Print each section.
 157     for (section_iterator i = o->begin_sections(),
 158                           e = o->end_sections(); i != e;
 159                           i.increment(ec)) {
 160       if (error(ec))
 161         return;
 162
 163       StringRef name;
 164       uint64_t size = 0;
 165       uint64_t addr = 0;
 166       if (error(i->getName(name))) return;
 167       if (error(i->getSize(size))) return;
 168       if (error(i->getAddress(addr))) return;
 169       std::string namestr = name;
 170
 171       outs() << format(fmt.str().c_str(),
 172                        namestr.c_str(),
 173                        size,
 174                        addr);
 175     }
 176
 177     // Print total.
 178     fmtbuf.clear();
 179     fmt << "%-" << max_name_len << "s "
 180         << "%#" << max_size_len << radix_fmt << "\n";
 181     outs() << format(fmt.str().c_str(),
 182                      static_cast<const char*>("Total"),
 183                      total);
 184   } else {
 185     // The Berkeley format does not display individual section sizes. It
 186     // displays the cumulative size for each section type.
 187     uint64_t total_text = 0;
 188     uint64_t total_data = 0;
 189     uint64_t total_bss = 0;
 190
 191     // Make one pass over the section table to calculate sizes.
 192     error_code ec;
 193     for (section_iterator i = o->begin_sections(),
 194                           e = o->end_sections(); i != e;
 195                           i.increment(ec)) {
 196       if (error(ec))
 197         return;
 198
 199       uint64_t size = 0;
 200       bool isText = false;
 201       bool isData = false;
 202       bool isBSS = false;
 203       if (error(i->getSize(size))) return;
 204       if (error(i->isText(isText))) return;
 205       if (error(i->isData(isData))) return;
 206       if (error(i->isBSS(isBSS))) return;
 207       if (isText)
 208         total_text += size;
 209       else if (isData)
 210         total_data += size;
 211       else if (isBSS)
 212         total_bss += size;
 213     }
 214
 215     total = total_text + total_data + total_bss;
 216
 217     // Print result.
 218     fmt << "%#7" << radix_fmt << " "
 219         << "%#7" << radix_fmt << " "
 220         << "%#7" << radix_fmt << " ";
 221     outs() << format(fmt.str().c_str(),
 222                      total_text,
 223                      total_data,
 224                      total_bss);
 225     fmtbuf.clear();
 226     fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << " "
 227         << "%7" PRIx64 " ";
 228     outs() << format(fmt.str().c_str(),
 229                      total,
 230                      total);
 231   }
 232 }
 233
 234 /// @brief Print the section sizes for @p file. If @p file is an archive, print
 235 ///        the section sizes for each archive member.
 236 static void PrintFileSectionSizes(StringRef file) {
 237   // If file is not stdin, check that it exists.
 238   if (file != "-") {
 239     bool exists;
 240     if (sys::fs::exists(file, exists) || !exists) {
 241       errs() << ToolName << ": '" << file << "': " << "No such file\n";
 242       return;
 243     }
 244   }
 245
 246   // Attempt to open the binary.
 247   ErrorOr<Binary *> BinaryOrErr = createBinary(file);
 248   if (error_code EC = BinaryOrErr.getError()) {
 249     errs() << ToolName << ": " << file << ": " << EC.message() << ".\n";
 250     return;
 251   }
 252   OwningPtr<Binary> binary(BinaryOrErr.get());
 253
 254   if (Archive *a = dyn_cast<Archive>(binary.get())) {
 255     // This is an archive. Iterate over each member and display its sizes.
 256     for (object::Archive::child_iterator i = a->begin_children(),
 257                                          e = a->end_children(); i != e; ++i) {
 258       OwningPtr<Binary> child;
 259       if (error_code ec = i->getAsBinary(child)) {
 260         errs() << ToolName << ": " << file << ": " << ec.message() << ".\n";
 261         continue;
 262       }
 263       if (ObjectFile *o = dyn_cast<ObjectFile>(child.get())) {
 264         if (OutputFormat == sysv)
 265           outs() << o->getFileName() << "   (ex " << a->getFileName()
 266                   << "):\n";
 267         PrintObjectSectionSizes(o);
 268         if (OutputFormat == berkeley)
 269           outs() << o->getFileName() << " (ex " << a->getFileName() << ")\n";
 270       }
 271     }
 272   } else if (ObjectFile *o = dyn_cast<ObjectFile>(binary.get())) {
 273     if (OutputFormat == sysv)
 274       outs() << o->getFileName() << "  :\n";
 275     PrintObjectSectionSizes(o);
 276     if (OutputFormat == berkeley)
 277       outs() << o->getFileName() << "\n";
 278   } else {
 279     errs() << ToolName << ": " << file << ": " << "Unrecognized file type.\n";
 280   }
 281   // System V adds an extra newline at the end of each file.
 282   if (OutputFormat == sysv)
 283     outs() << "\n";
 284 }
 285
 286 int main(int argc, char **argv) {
 287   // Print a stack trace if we signal out.
 288   sys::PrintStackTraceOnErrorSignal();
 289   PrettyStackTraceProgram X(argc, argv);
 290
 291   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 292   cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
 293
 294   ToolName = argv[0];
 295   if (OutputFormatShort.getNumOccurrences())
 296     OutputFormat = OutputFormatShort;
 297   if (RadixShort.getNumOccurrences())
 298     Radix = RadixShort;
 299
 300   if (InputFilenames.size() == 0)
 301     InputFilenames.push_back("a.out");
 302
 303   if (OutputFormat == berkeley)
 304     outs() << "   text    data     bss     "
 305            << (Radix == octal ? "oct" : "dec")
 306            << "     hex filename\n";
 307
 308   std::for_each(InputFilenames.begin(), InputFilenames.end(),
 309                 PrintFileSectionSizes);
 310
 311   return 0;
 312 }