opreport_options.cpp

Go to the documentation of this file.

#include <vector>
#include <list>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <fstream>

#include "op_config.h"
#include "profile_spec.h"
#include "arrange_profiles.h"
#include "opreport_options.h"
#include "popt_options.h"
#include "string_filter.h"
#include "file_manip.h"
#include "xml_output.h"
#include "xml_utils.h"
#include "cverb.h"

using namespace std;

profile_classes classes;
profile_classes classes2;

namespace options {
    demangle_type demangle = dmt_normal;
    bool symbols;
    bool callgraph;
    bool debug_info;
    bool details;
    bool exclude_dependent;
    string_filter symbol_filter;
    sort_options sort_by;
    merge_option merge_by;
    bool show_header = true;
    bool long_filenames;
    bool show_address;
    bool accumulated;
    bool reverse_sort;
    bool global_percent;
    bool xml;
    string xml_options;
}


namespace {

string outfile;
vector<string> mergespec;
vector<string> sort;
vector<string> exclude_symbols;
vector<string> include_symbols;
string demangle_option = "normal";

popt::option options_array[] = {
    popt::option(options::callgraph, "callgraph", 'c',
                 "show call graph"),
    popt::option(options::details, "details", 'd',
             "output detailed samples for each symbol"),
    popt::option(options::symbols, "symbols", 'l',
             "list all symbols"),

    popt::option(outfile, "output-file", 'o',
                 "output to the given filename", "file"),

    popt::option(sort, "sort", 's',
             "sort by", "sample,image,app-name,symbol,debug,vma"),
    popt::option(options::reverse_sort, "reverse-sort", 'r',
             "use reverse sort"),
    popt::option(mergespec, "merge", 'm',
             "comma separated list", "cpu,lib,tid,tgid,unitmask,all"),
    popt::option(options::exclude_dependent, "exclude-dependent", 'x',
             "exclude libs, kernel, and module samples for applications"),
    popt::option(exclude_symbols, "exclude-symbols", 'e',
             "exclude these comma separated symbols", "symbols"),
    popt::option(include_symbols, "include-symbols", 'i',
             "include these comma separated symbols", "symbols"),
    popt::option(options::threshold_opt, "threshold", 't',
             "minimum percentage needed to produce output",
             "percent"),

    popt::option(demangle_option, "demangle", 'D',
             "demangle GNU C++ symbol names (default normal)",
                 "none|normal|smart"),
    // PP:5
    popt::option(options::debug_info, "debug-info", 'g',
             "add source file and line number to output"),
    popt::option(options::show_header, "no-header", 'n',
             "remove all headers from output"),
    popt::option(options::show_address, "show-address", 'w',
                 "show VMA address of each symbol"),
    popt::option(options::long_filenames, "long-filenames", 'f',
             "show the full path of filenames"),
    popt::option(options::accumulated, "accumulated", 'a',
             "percentage field show accumulated count"),
    popt::option(options::global_percent, "global-percent", '%',
             "percentage are not relative to symbol count or image "
             "count but total sample count"),

    popt::option(options::xml, "xml", 'X',
             "XML output"),

};


void handle_sort_option()
{
    if (options::xml && !sort.empty()) {
        cerr << "warning: sort options ignored because they "
             << "are incompatible with --xml" << endl;
        // don't allow any other sorting, except the default below,
        // to mess up symbol traversal for XML
        sort.clear();
    }

    if (sort.empty() || options::xml) {
        // PP:5.14 sort default to sample
        if (options::xml) {
            // implicitly sort by app-name,image so that in the
            // symbol traversal all library module symbols are
            // grouped together with their application
            sort.push_back("app-name");
            sort.push_back("image");
        } else
            sort.push_back("sample");
    }

    vector<string>::const_iterator cit = sort.begin();
    vector<string>::const_iterator end = sort.end();

    for (; cit != end; ++cit)
        options::sort_by.add_sort_option(*cit);
}


void handle_output_file()
{
    if (outfile.empty())
        return;

    static ofstream os(outfile.c_str());
    if (!os) {
        cerr << "Couldn't open \"" << outfile
             << "\" for writing." << endl;
        exit(EXIT_FAILURE);
    }

    cout.rdbuf(os.rdbuf());
}


void check_options(bool diff)
{
    using namespace options;

    bool do_exit = false;

    if (callgraph) {
        symbols = true;
        if (details) {
            cerr << "--callgraph is incompatible with --details" << endl;
            do_exit = true;
        }

        if (diff) {
            cerr << "differential profiles are incompatible with --callgraph" << endl;
            do_exit = true;
        }
    }

    if (xml) {
        if (accumulated) {
            cerr << "--accumulated is incompatible with --xml" << endl;
            do_exit = true;
        }

        if (global_percent) {
            cerr << "--global_percent is incompatible with --xml" << endl;
            do_exit = true;
        }
    }


    if (details && diff) {
        cerr << "differential profiles are incompatible with --details" << endl;
        do_exit = true;
    }

    if (!symbols) {
        if (diff) {
            cerr << "different profiles are meaningless "
                "without --symbols" << endl;
            do_exit = true;
        }

        if (show_address) {
            cerr << "--show-address is meaningless "
                "without --symbols" << endl;
            do_exit = true;
        }

        if (debug_info || accumulated) {
            cerr << "--debug-info and --accumulated are "
                 << "meaningless without --symbols" << endl;
            do_exit = true;
        }

        if (!exclude_symbols.empty() || !include_symbols.empty()) {
            cerr << "--exclude-symbols and --include-symbols are "
                 << "meaningless without --symbols" << endl;
            do_exit = true;
        }

        if (find(sort_by.options.begin(), sort_by.options.end(), 
             sort_options::vma) != sort_by.options.end()) {
            cerr << "--sort=vma is "
                 << "meaningless without --symbols" << endl;
            do_exit = true;
        }
    }

    if (global_percent && symbols && !(details || callgraph)) {
        cerr << "--global-percent is meaningless with --symbols "
                "and without --details or --callgraph" << endl;
        do_exit = true;
    }

    if (do_exit)
        exit(EXIT_FAILURE);
}


void process_spec(profile_classes & classes, list<string> const & spec)
{
    using namespace options;

    copy(spec.begin(), spec.end(),
         ostream_iterator<string>(cverb << vsfile, " "));
    cverb << vsfile << "\n\n";

    profile_spec const pspec =
        profile_spec::create(spec, options::image_path,
                     options::root_path);

    if (!was_session_dir_supplied())
        cerr << "Using " << op_samples_dir << " for samples directory." << endl;

    list<string> sample_files = pspec.generate_file_list(exclude_dependent,
                                                !options::callgraph);

    cverb << vsfile << "Archive: " << pspec.get_archive_path() << endl;

    cverb << vsfile << "Matched sample files: " << sample_files.size()
          << endl;
    copy(sample_files.begin(), sample_files.end(),
         ostream_iterator<string>(cverb << vsfile, "\n"));

    classes = arrange_profiles(sample_files, merge_by,
                   pspec.extra_found_images);

    cverb << vsfile << "profile_classes:\n" << classes << endl;

    if (classes.v.empty()) {
        cerr << "error: no sample files found: profile specification "
             "too strict ?" << endl;
        exit(EXIT_FAILURE);
    }
}


} // namespace anon


void handle_options(options::spec const & spec)
{
    using namespace options;

    if (details) {
        symbols = true;
        show_address = true;
    }

    if (options::xml) {
        if (spec.common.size() != 0)
            xml_utils::add_option(SESSION, spec.common);
        if (debug_info)
            xml_utils::add_option(DEBUG_INFO, true);
        if (details)
            xml_utils::add_option(DETAILS, true);
        if (!image_path.empty())
            xml_utils::add_option(IMAGE_PATH, image_path);
        if (!mergespec.empty())
            xml_utils::add_option(MERGE, mergespec);
        if (exclude_dependent)
            xml_utils::add_option(EXCLUDE_DEPENDENT, true);
        if (!exclude_symbols.empty())
            xml_utils::add_option(EXCLUDE_SYMBOLS, exclude_symbols);
        if (!include_symbols.empty())
            xml_utils::add_option(INCLUDE_SYMBOLS, include_symbols);
    }

    handle_sort_option();
    merge_by = handle_merge_option(mergespec, true, exclude_dependent);
    handle_output_file();
    demangle = handle_demangle_option(demangle_option);
    check_options(spec.first.size());

    symbol_filter = string_filter(include_symbols, exclude_symbols);

    if (!spec.first.size()) {
        process_spec(classes, spec.common);
    } else {
        if (options::xml) {
            cerr << "differential profiles are incompatible with --xml" << endl;
            exit(EXIT_FAILURE);
        }
        cverb << vsfile << "profile spec 1:" << endl;
        process_spec(classes, spec.first);
        cverb << vsfile << "profile spec 2:" << endl;
        process_spec(classes2, spec.second);

        if (!classes.matches(classes2)) {
            cerr << "profile classes are incompatible" << endl;
            exit(EXIT_FAILURE);
        }
    }
}