gprofng/src/DataSpace.cc

/* Copyright (C) 2021-2024 Free Software Foundation, Inc.
   Contributed by Oracle.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "config.h"
#include <stdlib.h>
#include <stdarg.h>

#include "util.h"
#include "Application.h"
#include "CallStack.h"
#include "Experiment.h"
#include "Exp_Layout.h"
#include "DataObject.h"
#include "DbeSession.h"
#include "MetricList.h"
#include "Function.h"
#include "Module.h"
#include "MemObject.h"
#include "DbeView.h"
#include "Metric.h"
#include "DataSpace.h"
#include "LoadObject.h"

#include "debug.h"
#include "ABS.h"

//char *DOBJ_UNSPECIFIED  = STXT("(Not identified by the compiler as a memory-referencing instruction)");
char *DOBJ_UNSPECIFIED  = STXT("(No type information)");
char *DOBJ_UNIDENTIFIED = STXT("(No identifying descriptor provided by the compiler)");
char *DOBJ_UNDETERMINED = STXT("(Not determined from the symbolic information provided by the compiler)");
char *DOBJ_ANON         = STXT("(Padding in structure)");

// run-time codes
//  ABS_UNSUPPORTED = 0x01, /* inappropriate HWC event type */
//  ABS_BLOCKED     = 0x02, /* runtime backtrack blocker reached */
//  ABS_INCOMPLETE  = 0x03, /* runtime backtrack limit reached */
//  ABS_REG_LOSS    = 0x04, /* address register contaminated */
//  ABS_INVALID_EA  = 0x05, /* invalid effective address value */

const char *ABS_RT_CODES[NUM_ABS_RT_CODES] = {
  "(OK)",
  "(Dataspace data not requested during data collection)",
  "(Backtracking was prevented by a jump or call instruction)",
  "(Backtracking did not find trigger PC)",
  "(Could not determine VA because registers changed after trigger instruction)",
  "(Memory-referencing instruction did not specify a valid VA)",
  "(UNKNOWN)"
};

// post-processing codes
//  ABS_NO_CTI_INFO = 0x10, /* no AnalyzerInfo for validation */
//  ABS_INFO_FAILED = 0x20, /* info failed to validate backtrack */
//  ABS_CTI_TARGET  = 0x30, /* CTI target invalidated backtrack */
char *DOBJ_UNASCERTAINABLE = STXT("(Module with trigger PC not compiled with -xhwcprof)");
char *DOBJ_UNVERIFIABLE    = STXT("(Backtracking failed to find a valid branch target)");
char *DOBJ_UNRESOLVABLE    = STXT("(Backtracking traversed a branch target)");

char *ABS_PP_CODES[NUM_ABS_PP_CODES] = {
  STXT ("(OK)"),
  DOBJ_UNASCERTAINABLE,
  DOBJ_UNVERIFIABLE,
  DOBJ_UNRESOLVABLE,
  STXT ("(<INTERNAL ERROR DURING POST-PROCESSING>)")
};

DataSpace::DataSpace (DbeView *_dbev, int /* _picked */)
{
  dbev = _dbev;
}

DataSpace::~DataSpace () { }

void
DataSpace::reset () { }

char *
DataSpace::status_str ()
{
  return NULL;
}

Histable *
DataSpace::get_hist_obj (Histable::Type type, DataView *dview, long i)
{
  DataObject *dobj = NULL;
  char *errcode = NTXT ("<internal error>");
  switch (type)
    {
    case Histable::DOBJECT:
      dobj = (DataObject*) dview->getObjValue (PROP_HWCDOBJ, i);
      if (dobj == NULL)
	{
	  Vaddr leafVA = (Vaddr) dview->getLongValue (PROP_VADDR, i);
	  unsigned rt_code = (unsigned) ABS_GET_RT_CODE (leafVA);
	  unsigned pp_code = (unsigned) ABS_GET_PP_CODE (leafVA);
	  if (leafVA < ABS_CODE_RANGE
	      && (pp_code || (rt_code && rt_code != ABS_REG_LOSS)))
	    {
	      if (rt_code >= NUM_ABS_RT_CODES)
		rt_code = NUM_ABS_RT_CODES - 1;
	      if (pp_code >= NUM_ABS_PP_CODES)
		pp_code = NUM_ABS_PP_CODES - 1;
	      if (rt_code)
		errcode = PTXT (ABS_RT_CODES[rt_code]);
	      else
		errcode = PTXT (ABS_PP_CODES[pp_code]);
	    }
	  else
	    {
	      // associate dataobject with event
	      int index;

	      // search for memop in Module infoList
	      void *cstack = dview->getObjValue (PROP_MSTACK, i);
	      Histable *leafPCObj = CallStack::getStackPC (cstack, 0);
	      DbeInstr *leafPC = NULL;
	      if (leafPCObj->get_type () == Histable::INSTR)
		leafPC = (DbeInstr*) leafPCObj;
	      else  // DBELINE
		leafPC = (DbeInstr*) leafPCObj->convertto (Histable::INSTR);
	      Function *func = leafPC->func;
	      uint64_t leafPC_offset = func->img_offset + leafPC->addr;
	      Module *mod = func->module;
	      uint32_t dtype_id = 0;
	      inst_info_t *info = NULL;
	      Vec_loop (inst_info_t*, mod->infoList, index, info)
	      {
		if (info->offset == leafPC_offset)
		  {
		    dtype_id = info->memop->datatype_id;
		    break;
		  }
	      }
	      dobj = mod->get_dobj (dtype_id);
	      if (dobj == NULL)
		{
		  // ensure dobj is determined
		  if (dtype_id == DataObject::UNSPECIFIED_ID)
		    errcode = PTXT (DOBJ_UNSPECIFIED);
		  else
		    errcode = PTXT (DOBJ_UNIDENTIFIED);
		}
	      else
		{
		  // determine associated master dataobject
		  if (!dobj->master && dobj->scope)
		    dobj->master = dbeSession->createMasterDataObject (dobj);
		  if (dobj->scope)
		    dobj = dobj->master;  // use associated master
		}
	    }
	  if (!dobj)
	    {
	      // if dobj is not set yet, supply a dobj for errcode
	      // search for a dobj with the same name
	      dobj = dbeSession->find_dobj_by_name (errcode);
	      if (dobj == NULL)
		{
		  // create new DataObject for unknown code
		  dobj = (DataObject*) dbeSession->createHistObject (Histable::DOBJECT);
		  dobj->size = 0;
		  dobj->offset = -1;
		  dobj->parent = dbeSession->get_Unknown_DataObject ();
		  dobj->set_dobjname (errcode, NULL); // dobj->parent must already be set
		}
	    }
	  dview->setObjValue (PROP_HWCDOBJ, i, dobj);
	}
      break;
    default:
      break;
    }
  return dobj;
}

Hist_data *
DataSpace::compute_metrics (MetricList *mlist, Histable::Type type,
			    Hist_data::Mode mode, Histable *sel_obj)
{
  int nmetrics = mlist->get_items ()->size ();
  int sort_ind = -1;
  Hist_data::HistItem *hi;
  int index;

  // reset event_data count for all datatypes
  Vector<LoadObject*> *lobjs = dbeSession->get_text_segments ();
  for (int i = 0, sz = lobjs ? lobjs->size () : -1; i < sz; i++)
    {
      LoadObject *lo = lobjs->fetch (i);
      Vector<Module*> *modules = lo->seg_modules;
      for (int j = 0, msize = modules ? modules->size () : -1; j < msize; j++)
	{
	  Module *mod = modules->fetch (j);
	  mod->reset_datatypes ();
	}
    }
  Hist_data *hist_data = new Hist_data (mlist, type, mode);

  // add each experiment, skipping disabled and broken experiments
  for (index = 0; index < dbeSession->nexps (); index++)
    {
      Experiment *exp = dbeSession->get_exp (index);
      if (exp->broken)
	continue;

      Collection_params *params = exp->get_params ();
      if (!params->xhw_mode)
	continue;

      char *expt_name = exp->get_expt_name ();
      char *base_name = strrchr (expt_name, '/');
      base_name = base_name ? base_name + 1 : expt_name;

      // Determine mapping of experiment HWC metrics to hist_data metric list
      int *xlate = new int[MAX_HWCOUNT];
      for (unsigned i = 0; i < MAX_HWCOUNT; i++)
	{
	  xlate[i] = -1;
	  if (params->hw_interval[i] > 0)
	    {
	      const char *ctr_name = params->hw_aux_name[i];
	      int mindex;
	      Metric *met;
	      Vec_loop (Metric*, mlist->get_items (), mindex, met)
	      {
		if (dbe_strcmp (met->get_cmd (), ctr_name) == 0)
		  xlate[i] = mindex;
	      }
	    }
	}

      //
      // Process hardware profiling data
      //
      DataView *dview = dbev->get_filtered_events (index, DATA_HWC);
      if (dview)
	{
	  DataDescriptor *ddscr = dview ->getDataDescriptor ();
	  if (ddscr->getProp (PROP_HWCDOBJ) == NULL)
	    {
	      PropDescr *prop = new PropDescr (PROP_HWCDOBJ, NTXT ("HWCDOBJ"));
	      prop->uname = NULL;
	      prop->vtype = TYPE_OBJ;
	      ddscr->addProperty (prop);
	    }
	}
      if (dview && dview->getSize () != 0)
	{
	  char *msg = NULL;
	  for (long i = 0; i < dview->getSize (); i++)
	    {
	      if (i % 5000 == 0)
		{
		  int percent = (int) (100.0 * i / dview->getSize ());
		  if (percent == 0 && msg == NULL)
		    msg = dbe_sprintf (GTXT ("Filtering HW Profile Address Data: %s"), base_name);
		  theApplication->set_progress (percent, (percent != 0) ? NULL : msg);
		}

	      uint32_t tag = dview->getIntValue (PROP_HWCTAG, i);
	      if (tag < 0 || tag >= MAX_HWCOUNT)
		continue;  // invalid HWC tag in the record; ignore it
	      int mHwcntr_idx = xlate[tag];
	      if (mHwcntr_idx < 0)
		continue;

	      Vaddr leafVA = (Vaddr) dview->getLongValue (PROP_VADDR, i);
	      if (leafVA == ABS_UNSUPPORTED)
		continue; // skip this record
	      Histable *obj = get_hist_obj (type, dview, i);
	      if (obj == NULL)
		continue;
	      uint64_t interval = dview->getLongValue (PROP_HWCINT, i);
	      if (HWCVAL_HAS_ERR (interval))
		continue;
	      if (mode == Hist_data::ALL)
		{ // data_objects
		  hi = hist_data->append_hist_item (obj);
		  hi->value[mHwcntr_idx].ll += interval;
		  for (DataObject *dobj = ((DataObject *) obj)->parent; dobj; dobj = dobj->parent)
		    {
		      hi = hist_data->append_hist_item (dobj);
		      hi->value[mHwcntr_idx].ll += interval;
		    }
		}
	      else if (mode == Hist_data::LAYOUT || mode == Hist_data::DETAIL)
		{ // data_single
		  {
		    // for data layout, insert elements that have no metrics yet
		    DataObject *tmpParent = ((DataObject *) obj)->parent;
		    if (tmpParent && tmpParent->get_typename ())
		      {
			// dobj is an aggregate element
			if (!hist_data->find_hist_item (tmpParent))
			  {
			    // parent not yet a member of hist_data
			    // supply parent's children with 0 values for layout
			    Vector<DataObject*> *elements = dbeSession->get_dobj_elements (tmpParent);
			    for (long eli = 0, sz = elements->size (); eli < sz; eli++)
			      {
				DataObject* element = elements->fetch (eli);
				assert (!hist_data->find_hist_item (element));
				hi = hist_data->append_hist_item (element);
			      }
			  }
		      }
		  }

		  // Same as for mode == Hist_data::ALL:
		  hi = hist_data->append_hist_item (obj);
		  hi->value[mHwcntr_idx].ll += interval;
		  for (DataObject *dobj = ((DataObject *) obj)->parent; dobj; dobj = dobj->parent)
		    {
		      hi = hist_data->append_hist_item (dobj);
		      hi->value[mHwcntr_idx].ll += interval;
		    }
		}
	      else if (mode == Hist_data::SELF)
		{ // used by dbeGetSummary()
		  if (obj == sel_obj)
		    {
		      hi = hist_data->append_hist_item (obj);
		      hi->value[mHwcntr_idx].ll += interval;
		    }
		  else
		    {
		      for (DataObject *dobj = ((DataObject *) obj)->parent; dobj; dobj = dobj->parent)
			{
			  if ((Histable*) dobj == sel_obj)
			    {
			      hi = hist_data->append_hist_item (dobj);
			      hi->value[mHwcntr_idx].ll += interval;
			      break;
			    }
			}
		    }
		}
	      // Update total
	      hist_data->total->value[mHwcntr_idx].ll += interval;
	    }
	  free (msg);
	  theApplication->set_progress (0, NTXT (""));
	}
      delete[] xlate;
    }

  // include a regular HistItem for <Total> -- for all DataObjects, and MemObjects
  DataObject *dtot = dbeSession->get_Total_DataObject ();
  if (mode == Hist_data::ALL || mode == Hist_data::DETAIL
      || mode == Hist_data::LAYOUT ||
      sel_obj == dtot)
    {
      hi = hist_data->append_hist_item (dtot);
      for (int mind = 0; mind < nmetrics; mind++)
	hi->value[mind] = hist_data->total->value[mind];
    }
  if (hist_data->get_status () != Hist_data::SUCCESS)
    return hist_data;
  theApplication->set_progress (0, GTXT ("Constructing Metrics"));

  // Determine by which metric to sort if any
  bool rev_sort = mlist->get_sort_rev ();

  // Compute static metrics: SIZES, ADDRESS.
  for (int mind = 0; mind < nmetrics; mind++)
    {
      Metric *mtr = mlist->get_items ()->fetch (mind);
      if (mlist->get_sort_ref_index () == mind)
	sort_ind = mind;
      else if (!mtr->is_visible () && !mtr->is_tvisible ()
	       && !mtr->is_pvisible ())
	continue;
      Metric::Type mtype = mtr->get_type ();
      if (mtype == Metric::SIZES)
	{
	  Vec_loop (Hist_data::HistItem *, hist_data->hist_items, index, hi)
	  {
	    Histable *h = mtr->get_comparable_obj (hi->obj);
	    hi->value[mind].tag = VT_LLONG;
	    hi->value[mind].ll = h ? h->get_size () : 0;
	  }
	}
      else if (mtype == Metric::ONAME
	       && (mode == Hist_data::SELF
		   || ((DataObject*) sel_obj == dbeSession->get_Total_DataObject ())))
	{
	  Vec_loop (Hist_data::HistItem *, hist_data->hist_items, index, hi)
	  {
	    hi->value[mind].tag = VT_OFFSET; // offset labels
	  }
	}
      else if (mtype == Metric::ADDRESS)
	{ // pseudo-address
	  Vec_loop (Hist_data::HistItem *, hist_data->hist_items, index, hi)
	  {
	    hi->value[mind].tag = VT_ADDRESS;
	    Histable *h = mtr->get_comparable_obj (hi->obj);
	    hi->value[mind].ll = h ? h->get_addr () : 0;
	  }
	  // force sort by offset // XXXX should visibility also be set?
	  if (mode == Hist_data::SELF)
	    { // used by dbeGetSummary()
	      sort_ind = mind;
	      //hist_data->metrics->fetch(mind)->set_visible(T);
	    }
	}
      else
	{
	  ValueTag vtype = mtr->get_vtype ();
	  switch (vtype)
	    {
	    case VT_ULLONG: // most Data-derived HWC metrics are VT_ULLONG
	      hist_data->total->value[mind].tag = vtype;
	      Vec_loop (Hist_data::HistItem *, hist_data->hist_items, index, hi)
	      {
		hi->value[mind].tag = vtype;
	      }
	      break;
	    case VT_DOUBLE:
	      {
		double prec = mtr->get_precision ();
		hist_data->total->value[mind].tag = vtype;
		hist_data->total->value[mind].d = hist_data->total->value[mind].ll / prec;
		Vec_loop (Hist_data::HistItem *, hist_data->hist_items, index, hi)
		{
		  hi->value[mind].tag = vtype;
		  hi->value[mind].d = hi->value[mind].ll / prec;
		}
		break;
	      }
	    default:
	      if (mtr->get_subtype () != Metric::STATIC)
		abort ();
	      break;
	    }
	}
    }
  hist_data->sort (sort_ind, rev_sort);
  hist_data->compute_minmax ();
  theApplication->set_progress (0, NTXT (""));
  return hist_data;
}


// generate annotated structure info for data_layout
// note: similar data traversal found in er_print_histogram::dump_detail()
Hist_data *
DataSpace::get_layout_data (Hist_data *sorted_data,
			    Vector<int> *marks, int /* _threshold */)
{
  Hist_data *data_items = NULL;
  Hist_data::HistItem *new_item;
  MetricList *mlist = new MetricList (sorted_data->get_metric_list ());
  int no_metrics = mlist->get_items ()->size ();
  int index, addr_index = -1, name_index = -1;
  Dprintf (DEBUG_DATAOBJ, NTXT ("DataSpace::get_layout_data(ALL)\n"));

  // Allocate a new Hist_data for the list, to be copied from the DataObect list
  data_items = new Hist_data (mlist, Histable::DOBJECT, Hist_data::MODL);
  data_items->set_status (sorted_data->get_status ());

  // suppress threshold setting
  // XXX this threshold should probably not be used
  sorted_data->set_threshold ((double) 75. / 100.0);
  TValue* all_empty = new TValue[no_metrics];
  memset (all_empty, 0, sizeof (TValue) * no_metrics);

  Metric *mitem;
  Vec_loop (Metric*, mlist->get_items (), index, mitem)
  {
    // new data items have same total as original items
    data_items->total->value[index] = sorted_data->total->value[index];
    // empty metric items need matching types
    all_empty[index].tag = mitem->get_vtype ();
    if (mitem->get_type () == Metric::ONAME) name_index = index;
    if (mitem->get_type () == Metric::ADDRESS) addr_index = index;
  }

  int64_t next_elem_offset = 0;
  for (long i = 0; i < sorted_data->size (); i++)
    {
      Hist_data::HistItem* ditem = sorted_data->fetch (i);
      DataObject* dobj = (DataObject*) (ditem->obj);
      if (!dobj->get_parent ())
	{ // doesn't have a parent; top level item
	  next_elem_offset = 0;
	  if (i > 0)
	    { // add a blank line as separator
	      // fixme xxxxx, is it really ok to create a DataObject just for this?
	      DataObject* empty = new DataObject ();
	      empty->size = 0;
	      empty->offset = 0;
	      empty->set_name (NTXT (""));
	      new_item = sorted_data->new_hist_item (empty, Module::AT_EMPTY, all_empty);
	      new_item->value[name_index].tag = VT_LABEL;
	      new_item->value[name_index].l = NULL;
	      data_items->append_hist_item (new_item);
	    }
	  // then add the aggregate
	  new_item = sorted_data->new_hist_item (dobj, Module::AT_SRC, ditem->value);
	  new_item->value[name_index].tag = VT_OFFSET;
	  new_item->value[name_index].l = dbe_strdup (dobj->get_name ());
	  data_items->append_hist_item (new_item);
	}
      else
	{ // is a child
	  if (dobj->get_parent ()->get_typename ())
	    { // typed sub-element that has offset
	      if (dobj->offset > next_elem_offset)
		{ // filler entry
		  // hole in offsets
		  // fixme xxxxx, is it really ok to create a DataObject just for this?
		  DataObject* filler = new DataObject ();
		  filler->set_name (PTXT (DOBJ_ANON));
		  filler->size = (dobj->offset - next_elem_offset);
		  filler->offset = next_elem_offset;
		  new_item = sorted_data->new_hist_item (filler, Module::AT_EMPTY, all_empty);
		  new_item->value[name_index].tag = VT_OFFSET;
		  new_item->value[name_index].l = dbe_strdup (filler->get_offset_name ());
		  if (addr_index >= 0)
		    {
		      new_item->value[addr_index].tag = VT_ADDRESS;
		      new_item->value[addr_index].ll = (dobj->get_addr () - filler->size);
		    }
		  data_items->append_hist_item (new_item);
		}
	      next_elem_offset = dobj->offset + dobj->size;
	    }
	  // then add the aggregate's subelement
	  if (marks)
	    if (sorted_data->above_threshold (ditem))
	      marks->append (data_items->size ());
	  new_item = sorted_data->new_hist_item (dobj, Module::AT_DIS, ditem->value);
	  new_item->value[name_index].tag = VT_OFFSET;
	  new_item->value[name_index].l = dbe_strdup (dobj->get_offset_name ());
	  data_items->append_hist_item (new_item);
	}
    }
  delete[] all_empty;
  return data_items;
}