pp/opgprof.cpp - platform/external/oprofile - Git at Google

 /**
  * @file opgprof.cpp
  * Implement opgprof utility
  *
  * @remark Copyright 2003 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon
  * @author Philippe Elie
  */

 #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;
 }


 /**
  * @param abfd  bfd object
  * @param samples_files  profile container to act on
  * @param gap  a power of 2
  *
  * return true if all sample in samples_files are at least aligned on gap. This
  * function is used to get at runtime the right size of gprof bin size
  * reducing gmon.out on arch with fixed size instruction length
  *
  */
 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);
 }
	/**
	* @file opgprof.cpp
	* Implement opgprof utility
	*
	* @remark Copyright 2003 OProfile authors
	* @remark Read the file COPYING
	*
	* @author John Levon
	* @author Philippe Elie
	*/

	#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;
	}


	/**
	* @param abfd bfd object
	* @param samples_files profile container to act on
	* @param gap a power of 2
	*
	* return true if all sample in samples_files are at least aligned on gap. This
	* function is used to get at runtime the right size of gprof bin size
	* reducing gmon.out on arch with fixed size instruction length
	*
	*/
	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);
	}