gprofng/src/DataSpace.cc - third_party/binutils-gdb - Git at Google

 /* 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;
 }
	/* 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;
	}