opgprof.cpp

Go to the documentation of this file.

#include <iostream>
#include <cstdio>

#include "op_header.h"
#include "profile.h"
#include "op_libiberty.h"
#include "op_fileio.h"
#include "string_filter.h"
#include "profile_container.h"
#include "arrange_profiles.h"
#include "image_errors.h"
#include "opgprof_options.h"
#include "cverb.h"
#include "op_file.h"

using namespace std;

extern profile_classes classes;

namespace {

#define GMON_VERSION 1
#define GMON_TAG_TIME_HIST 0
#define GMON_TAG_CG_ARC 1

struct gmon_hdr {
    char cookie[4];
    u32 version;
    u32 spare[3];
};


void op_write_vma(FILE * fp, op_bfd const & abfd, bfd_vma vma)
{
    // bfd vma write size is a per binary property not a bfd
    // configuration property
    switch (abfd.bfd_arch_bits_per_address()) {
        case 32:
            op_write_u32(fp, vma);
            break;
        case 64:
            op_write_u64(fp, vma);
            break;
        default:
            cerr << "oprofile: unknown vma size for this binary\n";
            exit(EXIT_FAILURE);
    }
}


void get_vma_range(bfd_vma & min, bfd_vma & max,
                   profile_container const & samples)
{
    min = bfd_vma(-1);
    max = 0;

    sample_container::samples_iterator it  = samples.begin();
    sample_container::samples_iterator end = samples.end();
    for (; it != end ; ++it) {
        if (it->second.vma < min)
            min = it->second.vma;
        if (it->second.vma > max)
            max = it->second.vma;
    }

    if (min == bfd_vma(-1))
        min = 0;
    // we must return a range [min, max) not a range [min, max]
    if (max != 0)
        max += 1;
}


bool aligned_samples(profile_container const & samples, int gap)
{
    sample_container::samples_iterator it  = samples.begin();
    sample_container::samples_iterator end = samples.end();
    for (; it != end ; ++it) {
        if (it->second.vma % gap)
            return false;
    }

    return true;
}


void output_cg(FILE * fp, op_bfd const & abfd, profile_t const & cg_db)
{
    opd_header const & header = cg_db.get_header();
    bfd_vma offset = 0;
    if (header.is_kernel)
        offset = abfd.get_start_offset(0);
    else
        offset = header.anon_start;
 
    profile_t::iterator_pair p_it = cg_db.samples_range();
    for (; p_it.first != p_it.second; ++p_it.first) {
        bfd_vma from = p_it.first.vma() >> 32;
        bfd_vma to = p_it.first.vma() & 0xffffffff;

        op_write_u8(fp, GMON_TAG_CG_ARC);
        op_write_vma(fp, abfd, abfd.offset_to_pc(from + offset));
        op_write_vma(fp, abfd, abfd.offset_to_pc(to + offset));
        u32 count = p_it.first.count();
        if (count != p_it.first.count()) {
            count = (u32)-1;
            cerr << "Warning: capping sample count by "
                 << p_it.first.count() - count << endl;
        }
        op_write_u32(fp, p_it.first.count());
    }
}


void output_gprof(op_bfd const & abfd, profile_container const & samples,
                  profile_t const & cg_db, string const & gmon_filename)
{
    static gmon_hdr hdr = { { 'g', 'm', 'o', 'n' }, GMON_VERSION, {0, 0, 0 } };

    bfd_vma low_pc;
    bfd_vma high_pc;

    /* FIXME worth to try more multiplier ? */
    int multiplier = 2;
    if (aligned_samples(samples, 4))
        multiplier = 8;

    cverb << vdebug << "opgrof multiplier: " << multiplier << endl;

    get_vma_range(low_pc, high_pc, samples);

    cverb << vdebug << "low_pc: " << hex << low_pc << " " << "high_pc: "
          << high_pc << dec << endl;

    // round-down low_pc to ensure bin number is correct in the inner loop
    low_pc = (low_pc / multiplier) * multiplier;
    // round-up high_pc to ensure a correct histsize calculus
    high_pc = ((high_pc + multiplier - 1) / multiplier) * multiplier;

    cverb << vdebug << "low_pc: " << hex << low_pc << " " << "high_pc: "
          << high_pc << dec << endl;

    size_t histsize = (high_pc - low_pc) / multiplier;

    // FIXME: must we skip the flat profile write if histsize == 0 ?
    // (this can occur with callgraph w/o samples to the binary) but in
    // this case user must gprof --no-flat-profile which is a bit boring
    // and result *seems* weirds.

    FILE * fp = op_open_file(gmon_filename.c_str(), "w");

    op_write_file(fp, &hdr, sizeof(gmon_hdr));
    op_write_u8(fp, GMON_TAG_TIME_HIST);

    op_write_vma(fp, abfd, low_pc);
    op_write_vma(fp, abfd, high_pc);
    /* size of histogram */
    op_write_u32(fp, histsize);
    /* profiling rate */
    op_write_u32(fp, 1);
    op_write_file(fp, "samples\0\0\0\0\0\0\0\0", 15);
    /* abbreviation */
    op_write_u8(fp, '1');

    u16 * hist = (u16*)xcalloc(histsize, sizeof(u16));

    profile_container::symbol_choice choice;
    choice.threshold = options::threshold;
    symbol_collection symbols = samples.select_symbols(choice);

    symbol_collection::const_iterator sit = symbols.begin();
    symbol_collection::const_iterator send = symbols.end();

    for (; sit != send; ++sit) {
        sample_container::samples_iterator it  = samples.begin(*sit);
        sample_container::samples_iterator end = samples.end(*sit);
        for (; it != end ; ++it) {
            u32 pos = (it->second.vma - low_pc) / multiplier;
            count_type count = it->second.counts[0];

            if (pos >= histsize) {
                cerr << "Bogus histogram bin " << pos
                     << ", larger than " << pos << " !\n";
                continue;
            }
    
            if (hist[pos] + count > (u16)-1) {
                hist[pos] = (u16)-1;
                cerr << "Warning: capping sample count by "
                     << hist[pos] + count - ((u16)-1) << endl;
            } else {
                hist[pos] += (u16)count;
            }
        }
    }

    op_write_file(fp, hist, histsize * sizeof(u16));

    if (!cg_db.empty())
        output_cg(fp, abfd, cg_db);

    op_close_file(fp);

    free(hist);
}


void
load_samples(op_bfd const & abfd, list<profile_sample_files> const & files,
                  string const & image, profile_container & samples)
{
    list<profile_sample_files>::const_iterator it = files.begin();
    list<profile_sample_files>::const_iterator const end = files.end();

    for (; it != end; ++it) {
        // we can get call graph w/o any samples to the binary
        if (it->sample_filename.empty())
            continue;
            
        cverb << vsfile << "loading flat samples files : "
              << it->sample_filename << endl;

        profile_t profile;

        profile.add_sample_file(it->sample_filename);
        profile.set_offset(abfd);

        check_mtime(abfd.get_filename(), profile.get_header());

        samples.add(profile, abfd, image, 0);
    }
}


void load_cg(profile_t & cg_db, list<profile_sample_files> const & files)
{
    list<profile_sample_files>::const_iterator it = files.begin();
    list<profile_sample_files>::const_iterator const end = files.end();

    /* the list of non cg files is a super set of the list of cg file
     * (module always log a samples to non-cg files before logging
     * call stack) so by using the list of non-cg file we are sure to get
     * all existing cg files.
     */
    for (; it != end; ++it) {
        list<string>::const_iterator cit;
        list<string>::const_iterator const cend = it->cg_files.end();
        for (cit = it->cg_files.begin(); cit != cend; ++cit) {
            // FIXME: do we need filtering ?
            /* We can't handle start_offset now but after splitting
             * data in from/to eip. */
            cverb << vsfile << "loading cg samples file : " 
                  << *cit << endl;
            cg_db.add_sample_file(*cit);
        }
    }
}


int opgprof(options::spec const & spec)
{
    handle_options(spec);

    profile_container samples(false, true, classes.extra_found_images);

    bool ok = image_profile.error == image_ok;
    // FIXME: symbol_filter would be allowed through option
    op_bfd abfd(image_profile.image, string_filter(),
            classes.extra_found_images, ok);
    if (!ok && image_profile.error == image_ok)
        image_profile.error = image_format_failure;

    if (image_profile.error != image_ok) {
        report_image_error(image_profile, true,
                   classes.extra_found_images);
        exit(EXIT_FAILURE);
    }

    profile_t cg_db;
    
    image_group_set const & groups = image_profile.groups[0];
    image_group_set::const_iterator it;
    for (it = groups.begin(); it != groups.end(); ++it) {
        load_samples(abfd, it->files, image_profile.image, samples);

        load_cg(cg_db, it->files);
    }

    output_gprof(abfd, samples, cg_db, options::gmon_filename);

    return 0;
}


} // anonymous namespace


int main(int argc, char const * argv[])
{
    return run_pp_tool(argc, argv, opgprof);
}