/* Copyright (C) 2021-2023 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 <strings.h>
#include "DerivedMetrics.h"
#include "util.h"
enum opType
{
opNULL,
opPrimitive,
opDivide
};
class definition
{
public:
definition();
~definition();
char *name;
char *def;
opType op;
definition *arg1;
definition *arg2;
int index;
};
definition::definition ()
{
name = def = NULL;
arg1 = arg2 = NULL;
}
definition::~definition ()
{
free (name);
free (def);
}
DerivedMetrics::DerivedMetrics ()
{
items = new Vector<definition*>;
}
DerivedMetrics::~DerivedMetrics ()
{
Destroy (items);
}
definition *
DerivedMetrics::add_definition (char *_name, char *_username, char *_def)
{
definition *p;
// if the name doesn't matter, maybe there is a duplicate we can use
if (_name == NULL)
{
int i;
Vec_loop (definition*, items, i, p)
{
if (strcmp (p->def, _def) == 0)
return p;
}
}
p = new definition;
p->name = dbe_strdup (_name);
p->def = dbe_strdup (_def);
// parse the definition
if (strchr (_def, '/') == NULL)
{
// it's a primitive metric
p->op = opPrimitive;
p->arg1 = p->arg2 = NULL;
}
else
{
// it's some operation on arguments
p->op = opDivide;
char *op_ptr = strchr (p->def, '/');
*op_ptr = 0;
p->arg1 = add_definition (NULL, NULL, p->def);
*op_ptr = '/';
p->arg2 = add_definition (NULL, NULL, op_ptr + 1);
}
p->index = items->size ();
items->append (p);
return p;
}
int *
DerivedMetrics::construct_map (Vector<Metric*> *mitems, BaseMetric::SubType st, char *expr_spec)
{
if (items == NULL)
return NULL;
int ndm = items->size ();
if (ndm == 0)
return NULL;
int nmetrics = mitems->size ();
// allocate arrays for the mapping between derived metrics and requested values
int *map = (int *) malloc (ndm * sizeof (int));
// map derived metrics to requested metrics // EUGENE explain this more clearly
// 0 means not mapped
// >0 means primitive metric maps to map-1
// <0 means derived metric maps to 1-map
int ndm_requested = 0;
for (int idm = 0; idm < ndm; idm++)
{
definition *defdm = items->fetch (idm);
map[idm] = 0;
// figure out what name to use for this derived metric
char *dname;
if (defdm->op == opPrimitive)
dname = defdm->def;
else
{
dname = defdm->name;
if (dname == NULL) break;
}
// look for this name among metrics
int im;
for (im = 0; im < nmetrics; im++)
{
Metric *m = mitems->fetch (im);
if (strcmp (dname, m->get_cmd ()) == 0 && m->get_subtype () == st)
// apparent match, but let's check comparison mode
if (dbe_strcmp (expr_spec, m->get_expr_spec ()) == 0)
break;
}
// encode the mapping
if (im >= nmetrics)
map[idm] = 0; // does not map to requested metrics
else if (defdm->op == opPrimitive)
map[idm] = +1 + im; // encode as a positive index
else
{
map[idm] = -1 - im; // encode as a negative index
ndm_requested++;
}
}
if (ndm_requested == 0)
{
free (map);
map = NULL;
}
return map;
}
void
DerivedMetrics::fill_dependencies (definition *def, int *vec)
{
switch (def->op)
{
case opPrimitive:
vec[def->index] = 1;
break;
case opDivide:
fill_dependencies (def->arg1, vec);
fill_dependencies (def->arg2, vec);
break;
default:
break;
}
}
Vector<definition*> *
DerivedMetrics::get_dependencies (definition *def)
{
int n = items->size ();
// zero out a vector representing definitions
int *vec = (int *) malloc (n * sizeof (int));
for (int i = 0; i < n; i++)
vec[i] = 0;
fill_dependencies (def, vec);
// construct the dependency vector
Vector<definition*> *dependencies = new Vector<definition*>;
for (int i = 0; i < n; i++)
if (vec[i] == 1)
dependencies->append (items->fetch (i));
free (vec);
return dependencies;
}
void
DerivedMetrics::dump (FILE *dis_file, int verbosity)
{
int i;
definition *item;
// deal with the possibility that names might be NULL
const char *UNNAMED = "(unnamed)";
#define NAME(x) ( (x) ? (x) : UNNAMED)
Vec_loop (definition*, items, i, item)
{
// at low verbosity, skip over some items
if (verbosity == 0)
{
if (item->name == NULL)
continue;
if (strcmp (item->name, item->def) && item->op == opPrimitive)
continue;
}
// dump the definition
switch (item->op)
{
case opPrimitive:
fprintf (dis_file, "%s [%s] is a primitive metric\n", NAME (item->name),
item->def);
break;
case opDivide:
fprintf (dis_file, "%s [%s] = %s [%s] / %s [%s]\n", NAME (item->name),
item->def, NAME (item->arg1->name), item->arg1->def,
NAME (item->arg2->name), item->arg2->def);
break;
default:
fprintf (dis_file, "%s [%s] has an unrecognized op %d\n",
NAME (item->name), item->def, item->op);
break;
}
}
}
double
DerivedMetrics::eval_one_item (definition *def, int *map, double *values)
{
switch (def->op)
{
case opNULL:
fprintf (stderr, GTXT ("cannot eval NULL expression\n"));
return 0.;
case opPrimitive:
{
int ival = map[def->index];
if (ival <= 0) return 0.;
ival--;
return values[ival];
}
case opDivide:
{
double x1 = eval_one_item (def->arg1, map, values);
double x2 = eval_one_item (def->arg2, map, values);
if (x2 == 0) return 0.;
return (x1 / x2);
}
default:
fprintf (stderr, GTXT ("unknown expression\n"));
return 0.;
}
}
int
DerivedMetrics::eval (int *map, double *values)
{
for (int i = 0, n = items->size (); i < n; i++)
{
if (map[i] < 0)
{
int ival = -1 - map[i];
values[ival] = eval_one_item (items->fetch (i), map, values);
}
}
return 0;
}