mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 23:29:22 +00:00
This compiles with no changes to clang/lld/lldb with MSVC and includes overloads to various functions which are used by those projects and llvm which have OwningPtr's as parameters. This should allow out of tree projects some time to move. There are also no changes to libs/Target, which should help out of tree targets have time to move, if necessary. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203083 91177308-0d34-0410-b5e6-96231b3b80d8
300 lines
9.7 KiB
C++
300 lines
9.7 KiB
C++
//===-- llvm-size.cpp - Print the size of each object section -------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This program is a utility that works like traditional Unix "size",
|
|
// that is, it prints out the size of each section, and the total size of all
|
|
// sections.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ADT/APInt.h"
|
|
#include "llvm/Object/Archive.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/Support/system_error.h"
|
|
#include <algorithm>
|
|
#include <string>
|
|
using namespace llvm;
|
|
using namespace object;
|
|
|
|
enum OutputFormatTy {berkeley, sysv};
|
|
static cl::opt<OutputFormatTy>
|
|
OutputFormat("format",
|
|
cl::desc("Specify output format"),
|
|
cl::values(clEnumVal(sysv, "System V format"),
|
|
clEnumVal(berkeley, "Berkeley format"),
|
|
clEnumValEnd),
|
|
cl::init(berkeley));
|
|
|
|
static cl::opt<OutputFormatTy>
|
|
OutputFormatShort(cl::desc("Specify output format"),
|
|
cl::values(clEnumValN(sysv, "A", "System V format"),
|
|
clEnumValN(berkeley, "B", "Berkeley format"),
|
|
clEnumValEnd),
|
|
cl::init(berkeley));
|
|
|
|
enum RadixTy {octal = 8, decimal = 10, hexadecimal = 16};
|
|
static cl::opt<unsigned int>
|
|
Radix("-radix",
|
|
cl::desc("Print size in radix. Only 8, 10, and 16 are valid"),
|
|
cl::init(decimal));
|
|
|
|
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::list<std::string>
|
|
InputFilenames(cl::Positional, cl::desc("<input files>"),
|
|
cl::ZeroOrMore);
|
|
|
|
static std::string ToolName;
|
|
|
|
/// @brief If ec is not success, print the error and return true.
|
|
static bool error(error_code ec) {
|
|
if (!ec) return false;
|
|
|
|
outs() << ToolName << ": error reading file: " << ec.message() << ".\n";
|
|
outs().flush();
|
|
return true;
|
|
}
|
|
|
|
/// @brief Get the length of the string that represents @p num in Radix
|
|
/// including the leading 0x or 0 for hexadecimal and octal respectively.
|
|
static size_t getNumLengthAsString(uint64_t num) {
|
|
APInt conv(64, num);
|
|
SmallString<32> result;
|
|
conv.toString(result, Radix, false, true);
|
|
return result.size();
|
|
}
|
|
|
|
/// @brief Print the size of each section in @p o.
|
|
///
|
|
/// The format used is determined by @c OutputFormat and @c Radix.
|
|
static void PrintObjectSectionSizes(ObjectFile *o) {
|
|
uint64_t total = 0;
|
|
std::string fmtbuf;
|
|
raw_string_ostream fmt(fmtbuf);
|
|
|
|
const char *radix_fmt = 0;
|
|
switch (Radix) {
|
|
case octal:
|
|
radix_fmt = PRIo64;
|
|
break;
|
|
case decimal:
|
|
radix_fmt = PRIu64;
|
|
break;
|
|
case hexadecimal:
|
|
radix_fmt = PRIx64;
|
|
break;
|
|
}
|
|
if (OutputFormat == sysv) {
|
|
// Run two passes over all sections. The first gets the lengths needed for
|
|
// formatting the output. The second actually does the output.
|
|
std::size_t max_name_len = strlen("section");
|
|
std::size_t max_size_len = strlen("size");
|
|
std::size_t max_addr_len = strlen("addr");
|
|
for (section_iterator i = o->section_begin(), e = o->section_end();
|
|
i != e; ++i) {
|
|
uint64_t size = 0;
|
|
if (error(i->getSize(size)))
|
|
return;
|
|
total += size;
|
|
|
|
StringRef name;
|
|
uint64_t addr = 0;
|
|
if (error(i->getName(name))) return;
|
|
if (error(i->getAddress(addr))) return;
|
|
max_name_len = std::max(max_name_len, name.size());
|
|
max_size_len = std::max(max_size_len, getNumLengthAsString(size));
|
|
max_addr_len = std::max(max_addr_len, getNumLengthAsString(addr));
|
|
}
|
|
|
|
// Add extra padding.
|
|
max_name_len += 2;
|
|
max_size_len += 2;
|
|
max_addr_len += 2;
|
|
|
|
// Setup header format.
|
|
fmt << "%-" << max_name_len << "s "
|
|
<< "%" << max_size_len << "s "
|
|
<< "%" << max_addr_len << "s\n";
|
|
|
|
// Print header
|
|
outs() << format(fmt.str().c_str(),
|
|
static_cast<const char*>("section"),
|
|
static_cast<const char*>("size"),
|
|
static_cast<const char*>("addr"));
|
|
fmtbuf.clear();
|
|
|
|
// Setup per section format.
|
|
fmt << "%-" << max_name_len << "s "
|
|
<< "%#" << max_size_len << radix_fmt << " "
|
|
<< "%#" << max_addr_len << radix_fmt << "\n";
|
|
|
|
// Print each section.
|
|
for (section_iterator i = o->section_begin(), e = o->section_end();
|
|
i != e; ++i) {
|
|
StringRef name;
|
|
uint64_t size = 0;
|
|
uint64_t addr = 0;
|
|
if (error(i->getName(name))) return;
|
|
if (error(i->getSize(size))) return;
|
|
if (error(i->getAddress(addr))) return;
|
|
std::string namestr = name;
|
|
|
|
outs() << format(fmt.str().c_str(),
|
|
namestr.c_str(),
|
|
size,
|
|
addr);
|
|
}
|
|
|
|
// Print total.
|
|
fmtbuf.clear();
|
|
fmt << "%-" << max_name_len << "s "
|
|
<< "%#" << max_size_len << radix_fmt << "\n";
|
|
outs() << format(fmt.str().c_str(),
|
|
static_cast<const char*>("Total"),
|
|
total);
|
|
} else {
|
|
// The Berkeley format does not display individual section sizes. It
|
|
// displays the cumulative size for each section type.
|
|
uint64_t total_text = 0;
|
|
uint64_t total_data = 0;
|
|
uint64_t total_bss = 0;
|
|
|
|
// Make one pass over the section table to calculate sizes.
|
|
for (section_iterator i = o->section_begin(), e = o->section_end();
|
|
i != e; ++i) {
|
|
uint64_t size = 0;
|
|
bool isText = false;
|
|
bool isData = false;
|
|
bool isBSS = false;
|
|
if (error(i->getSize(size))) return;
|
|
if (error(i->isText(isText))) return;
|
|
if (error(i->isData(isData))) return;
|
|
if (error(i->isBSS(isBSS))) return;
|
|
if (isText)
|
|
total_text += size;
|
|
else if (isData)
|
|
total_data += size;
|
|
else if (isBSS)
|
|
total_bss += size;
|
|
}
|
|
|
|
total = total_text + total_data + total_bss;
|
|
|
|
// Print result.
|
|
fmt << "%#7" << radix_fmt << " "
|
|
<< "%#7" << radix_fmt << " "
|
|
<< "%#7" << radix_fmt << " ";
|
|
outs() << format(fmt.str().c_str(),
|
|
total_text,
|
|
total_data,
|
|
total_bss);
|
|
fmtbuf.clear();
|
|
fmt << "%7" << (Radix == octal ? PRIo64 : PRIu64) << " "
|
|
<< "%7" PRIx64 " ";
|
|
outs() << format(fmt.str().c_str(),
|
|
total,
|
|
total);
|
|
}
|
|
}
|
|
|
|
/// @brief Print the section sizes for @p file. If @p file is an archive, print
|
|
/// the section sizes for each archive member.
|
|
static void PrintFileSectionSizes(StringRef file) {
|
|
// If file is not stdin, check that it exists.
|
|
if (file != "-") {
|
|
bool exists;
|
|
if (sys::fs::exists(file, exists) || !exists) {
|
|
errs() << ToolName << ": '" << file << "': " << "No such file\n";
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Attempt to open the binary.
|
|
ErrorOr<Binary *> BinaryOrErr = createBinary(file);
|
|
if (error_code EC = BinaryOrErr.getError()) {
|
|
errs() << ToolName << ": " << file << ": " << EC.message() << ".\n";
|
|
return;
|
|
}
|
|
std::unique_ptr<Binary> binary(BinaryOrErr.get());
|
|
|
|
if (Archive *a = dyn_cast<Archive>(binary.get())) {
|
|
// This is an archive. Iterate over each member and display its sizes.
|
|
for (object::Archive::child_iterator i = a->child_begin(),
|
|
e = a->child_end(); i != e; ++i) {
|
|
std::unique_ptr<Binary> child;
|
|
if (error_code ec = i->getAsBinary(child)) {
|
|
errs() << ToolName << ": " << file << ": " << ec.message() << ".\n";
|
|
continue;
|
|
}
|
|
if (ObjectFile *o = dyn_cast<ObjectFile>(child.get())) {
|
|
if (OutputFormat == sysv)
|
|
outs() << o->getFileName() << " (ex " << a->getFileName()
|
|
<< "):\n";
|
|
PrintObjectSectionSizes(o);
|
|
if (OutputFormat == berkeley)
|
|
outs() << o->getFileName() << " (ex " << a->getFileName() << ")\n";
|
|
}
|
|
}
|
|
} else if (ObjectFile *o = dyn_cast<ObjectFile>(binary.get())) {
|
|
if (OutputFormat == sysv)
|
|
outs() << o->getFileName() << " :\n";
|
|
PrintObjectSectionSizes(o);
|
|
if (OutputFormat == berkeley)
|
|
outs() << o->getFileName() << "\n";
|
|
} else {
|
|
errs() << ToolName << ": " << file << ": " << "Unrecognized file type.\n";
|
|
}
|
|
// System V adds an extra newline at the end of each file.
|
|
if (OutputFormat == sysv)
|
|
outs() << "\n";
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
// Print a stack trace if we signal out.
|
|
sys::PrintStackTraceOnErrorSignal();
|
|
PrettyStackTraceProgram X(argc, argv);
|
|
|
|
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
|
|
cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
|
|
|
|
ToolName = argv[0];
|
|
if (OutputFormatShort.getNumOccurrences())
|
|
OutputFormat = OutputFormatShort;
|
|
if (RadixShort.getNumOccurrences())
|
|
Radix = RadixShort;
|
|
|
|
if (InputFilenames.size() == 0)
|
|
InputFilenames.push_back("a.out");
|
|
|
|
if (OutputFormat == berkeley)
|
|
outs() << " text data bss "
|
|
<< (Radix == octal ? "oct" : "dec")
|
|
<< " hex filename\n";
|
|
|
|
std::for_each(InputFilenames.begin(), InputFilenames.end(),
|
|
PrintFileSectionSizes);
|
|
|
|
return 0;
|
|
}
|