coverage-tool/coverage-plugin/trace_sources.h - ci/qa-tools - TrustedFirmware Git Browser

 /*!
 ##############################################################################
 # Copyright (c) 2020, ARM Limited and Contributors. All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
 ##############################################################################
 */

 #ifndef _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_
 #define _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_

 #include <map>
 #include <vector>
 #include <string>
 #include <algorithm>
 #include "MTI/ModelTraceInterface.h"

 using namespace MTI;
 using namespace std;

 struct InstStat {
     uint64_t cnt;
     uint64_t size;
 };

 typedef std::map<uint32_t, InstStat> InstStatMap;

 //Defining types for fields
 enum enum_types {u32, boolT, u8};
 typedef enum_types ValueTypes;

 /*
  * Structure used to save field data
  */
 struct TFields{
     ValueTypes t;
     MTI::ValueIndex index;
     void *value;
 };
 // Map of fields => Key -> Field name
 typedef map<string, TFields> TraceFieldsMap;

 /*
  * Structure used to pass field data between trace contexts
  */
 struct TParams {
     void *value;
     ValueTypes t;
 };
 // Map of fields => Key -> Field name
 typedef map<string, TParams> ParamsMap;

 /*
  * Generic function to output errors
  */
 bool Error(const char *msg)
 {
     fprintf(stderr, "%s\n", msg);
     return false;
 }

 /*
  * Base class for Trace Source contexts
  *
  */
 class TraceSourceContext {
     public:
         string name; //Trace source name
         TraceFieldsMap fields; //Fields to be used for the event
         MTI::EventClass *event_class; //Event object to register callback
         ParamsMap params; //List of parameters from another trace source

 /*
  * Constructor that converts/stores the pairs of <field name, field type>
  * in the 'fields' member.
 */
 TraceSourceContext(const char* tname,
                     vector<pair<string, ValueTypes>> fields_def) {
     name = tname;
     string key;
     // Referenced by field name => field type
     for (size_t i=0; i < fields_def.size(); ++ i) {
         key = fields_def[i].first;
         fields[key].t = fields_def[i].second;
     }
 }

 /*
  * Generic Callback that can be used by derived objects. It fills the
  * 'value' member in the 'fields' structure with a void* to the value
  * retrieved from the component.
 */
 template <class T>
 static T *TraceCallback(void* user_data,
                          const MTI::EventClass *event_class,
                          const MTI::EventRecord *record) {
     T *tc = static_cast<T*>(user_data);
     // Filled by Component
     TraceFieldsMap::iterator it;
     for (it = tc->fields.begin(); it != tc->fields.end(); ++it) {
        // Based in the type creates an object with initial
        // value retrieved from the component using the index
        // for that field.
         switch (it->second.t) {
             case u32: it->second.value = new uint32_t(
                 record->Get<uint32_t>(event_class, it->second.index));
                 break;
             case boolT: it->second.value = new bool(
                 record->GetBool(event_class, it->second.index));
                 break;
             case u8: it->second.value = new uint8_t(
                 record->Get<uint8_t>(event_class, it->second.index));
                 break;
         }
     }
     return tc;
 }

 /*
  * Generic method to copy the fields from this trace source to the params
  * member in other trace source. Optionally a list of field names can be
  * passed to filter the list of field names copied.
  * The params member is a Map of with the Field Id (name)  as the key.
 */
 void PassFieldstoParams(TraceSourceContext *target,
                             vector<string> field_names={}) {
         TraceFieldsMap::iterator it;
         for (it = fields.begin(); it != fields.end(); ++it) {
             bool found = std::find(field_names.begin(), field_names.end(),
                 it->first) != field_names.end();
             if ((!field_names.empty()) && (!found))
                 continue;
             target->params[it->first].t = it->second.t;
             switch (it->second.t) {
                 case u32:
                     target->params[it->first].value =
                         new uint32_t(*((uint32_t*)it->second.value));
                     break;
                 case boolT:
                     target->params[it->first].value =
                         new bool(*((bool*)it->second.value));
                     break;
                 case u8:
                     target->params[it->first].value =
                         new uint8_t(*((uint8_t*)it->second.value));
                     break;
             }
         }
 }
 /*
  * Method that creates an event object in the trace source based in the
  * fields given in the constructor. It then registers the given callback
  * to this event.
 */
 MTI::EventClass *CreateEvent(ComponentTraceInterface **ptr_cti,
                 MTI::CallbackT callback) {

     ComponentTraceInterface *cti = *ptr_cti;
     std::stringstream ss;
     ComponentTraceInterface *mti = 0;

     if (cti->GetTraceSource(name.c_str()) != 0) {
         TraceSource* ts = cti->GetTraceSource(name.c_str());
         printf("Trace source attached: %s\n", ts->GetName());

         size_t map_size = fields.size();
         ValueBind_t *values_array = new ValueBind_t[map_size + 1];
         TraceFieldsMap::iterator it;
         int i = 0;
         for (it = fields.begin(); it != fields.end(); ++it) {
             values_array[i]= ((ValueBind_t) { it->first.c_str(),
                 &it->second.index });
             ++i;
         };
         values_array[map_size] = {0, 0}; //sentinel

         mti = static_cast<ModelTraceInterface *>(cti);
         if (!RegisterCallbackForComponent(mti, name.c_str(), values_array,
             this, callback, &event_class, ss)) {
             Error(ss.str().c_str());
             return 0;
         }
         return event_class;
     }
     return 0;
 }
 };

 /*
  * Class and types used to handle trace sources belonging to a
  * component.
 */
 typedef map<string, TraceSourceContext*> MapTraceSourcesType;
 class TraceComponentContext {
     public:
         string trace_path;
         MapTraceSourcesType trace_sources;

 TraceComponentContext(string tpath) {
         trace_path = tpath;
 }

 void AddTraceSource(TraceSourceContext *ts) {
         trace_sources[ts->name] = ts;
 }
 };

 /*
  * Class used to instantiate a Instruction trace source
 */
 class InstructionTraceContext: public TraceSourceContext {
     public:
         using TraceSourceContext::TraceSourceContext;
         InstStatMap stats;
         uint64_t nb_insts;

     static void Callback(void* user_data,
                          const MTI::EventClass *event_class,
                          const MTI::EventRecord *record) {
         InstructionTraceContext* itc = static_cast<InstructionTraceContext*>
                                        (user_data);
         itc->nb_insts++; // Number of instructions
         // Filled by Component
         uint32_t pc = record->GetAs<uint32_t>(event_class,
                                                       itc->fields["PC"].index);
         uint32_t size = record->Get<uint32_t>(event_class,
                                                     itc->fields["SIZE"].index);
         // Save PC stats. If not already present in the map, a counter with
         // value 0 will be created before incrementing.
         InstStat& is = itc->stats[pc];
         is.cnt++;
         is.size = size;
     };
 };

 struct mode_change_type {
     uint8_t mode_value;
     char name[5];
 };
 const struct mode_change_type types[] = {
     {0x0 , "EL0t"}, //0
     {0x4 , "EL1t"}, //1
     {0x5 , "EL1h"}, //2
     {0x8 , "EL2t"}, //3
     {0x9 , "EL2h"}, //4
     {0xc , "EL3t"}, //5
     {0xd , "EL3h"}, //6
     {0x10 , "usr"}, //7
     {0x11 , "fiq"}, //8
     {0x12 , "irq"}, //9
     {0x13 , "svc"}, //10
     {0x16 , "mon"}, //11
     {0x17 , "abt"}, //12
     {0x1a , "hyp"}, //13
     {0x1b , "und"}, //14
     {0x1f , "sys"},  //15
     /* Secure modes */
     {0x0 , "EL0t"}, //16
     {0x4 , "EL1t"}, //17
     {0x5 , "EL1h"}, //18
     {0x8 , "EL2t"}, //19
     {0x9 , "EL2h"}, //20
     {0xc , "EL3t"}, //21
     {0xd , "EL3h"}, //22
     {0x10 , "usr"}, //23
     {0x11 , "fiq"}, //24
     {0x12 , "irq"}, //25
     {0x13 , "svc"}, //26
     {0x16 , "mon"}, //27
     {0x17 , "abt"}, //28
     {0x1a , "hyp"}, //29
     {0x1b , "und"}, //30
     {0x1f , "sys"}  //31
 };

 class ModeChangeTraceContext: public TraceSourceContext {
     public:
         using TraceSourceContext::TraceSourceContext;
         MTI::EventClass *event;
         uint32_t mode_mask;
         InstructionTraceContext* itc;


         static void Callback(void* user_data,
                              const MTI::EventClass *event_class,
                              const MTI::EventRecord *record)
         {
             ModeChangeTraceContext* mtc = static_cast<ModeChangeTraceContext*>
                 (user_data);
             static bool trace = false;
             bool new_trace = false;
             uint8_t mode = record->GetAs<char>(event_class,
                     mtc->fields["MODE"].index);
             uint8_t nsecure = record->Get<char>(event_class,
                     mtc->fields["NON_SECURE"].index);
             int start_mask  = 0;

             if(nsecure) {
                 start_mask = 0;
             } else {
                 start_mask = 16;
             }

             for (int i = start_mask; i < start_mask + 16; i++) {
                 if (types[i].mode_value == mode) {
                     new_trace = new_trace || (mtc->mode_mask & (1 << i));
                     break;
                 }
             }

             if (new_trace && !trace) {
                 mtc->event->RegisterCallback(InstructionTraceContext::Callback,
                                              mtc->itc);
             } else if (!new_trace && trace){
                 mtc->event->UnregisterCallback(
                         InstructionTraceContext::Callback,
                         mtc->itc);
             }
             trace = new_trace;
         };

 };
 #endif // _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_
	/*!
	##############################################################################
	# Copyright (c) 2020, ARM Limited and Contributors. All rights reserved.
	#
	# SPDX-License-Identifier: BSD-3-Clause
	##############################################################################
	*/

	#ifndef _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_
	#define _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_

	#include <map>
	#include <vector>
	#include <string>
	#include <algorithm>
	#include "MTI/ModelTraceInterface.h"

	using namespace MTI;
	using namespace std;

	struct InstStat {
	uint64_t cnt;
	uint64_t size;
	};

	typedef std::map<uint32_t, InstStat> InstStatMap;

	//Defining types for fields
	enum enum_types {u32, boolT, u8};
	typedef enum_types ValueTypes;

	/*
	* Structure used to save field data
	*/
	struct TFields{
	ValueTypes t;
	MTI::ValueIndex index;
	void *value;
	};
	// Map of fields => Key -> Field name
	typedef map<string, TFields> TraceFieldsMap;

	/*
	* Structure used to pass field data between trace contexts
	*/
	struct TParams {
	void *value;
	ValueTypes t;
	};
	// Map of fields => Key -> Field name
	typedef map<string, TParams> ParamsMap;

	/*
	* Generic function to output errors
	*/
	bool Error(const char *msg)
	{
	fprintf(stderr, "%s\n", msg);
	return false;
	}

	/*
	* Base class for Trace Source contexts
	*
	*/
	class TraceSourceContext {
	public:
	string name; //Trace source name
	TraceFieldsMap fields; //Fields to be used for the event
	MTI::EventClass *event_class; //Event object to register callback
	ParamsMap params; //List of parameters from another trace source

	/*
	* Constructor that converts/stores the pairs of <field name, field type>
	* in the 'fields' member.
	*/
	TraceSourceContext(const char* tname,
	vector<pair<string, ValueTypes>> fields_def) {
	name = tname;
	string key;
	// Referenced by field name => field type
	for (size_t i=0; i < fields_def.size(); ++ i) {
	key = fields_def[i].first;
	fields[key].t = fields_def[i].second;
	}
	}

	/*
	* Generic Callback that can be used by derived objects. It fills the
	* 'value' member in the 'fields' structure with a void* to the value
	* retrieved from the component.
	*/
	template <class T>
	static T TraceCallback(void user_data,
	const MTI::EventClass *event_class,
	const MTI::EventRecord *record) {
	T tc = static_cast<T>(user_data);
	// Filled by Component
	TraceFieldsMap::iterator it;
	for (it = tc->fields.begin(); it != tc->fields.end(); ++it) {
	// Based in the type creates an object with initial
	// value retrieved from the component using the index
	// for that field.
	switch (it->second.t) {
	case u32: it->second.value = new uint32_t(
	record->Get<uint32_t>(event_class, it->second.index));
	break;
	case boolT: it->second.value = new bool(
	record->GetBool(event_class, it->second.index));
	break;
	case u8: it->second.value = new uint8_t(
	record->Get<uint8_t>(event_class, it->second.index));
	break;
	}
	}
	return tc;
	}

	/*
	* Generic method to copy the fields from this trace source to the params
	* member in other trace source. Optionally a list of field names can be
	* passed to filter the list of field names copied.
	* The params member is a Map of with the Field Id (name) as the key.
	*/
	void PassFieldstoParams(TraceSourceContext *target,
	vector<string> field_names={}) {
	TraceFieldsMap::iterator it;
	for (it = fields.begin(); it != fields.end(); ++it) {
	bool found = std::find(field_names.begin(), field_names.end(),
	it->first) != field_names.end();
	if ((!field_names.empty()) && (!found))
	continue;
	target->params[it->first].t = it->second.t;
	switch (it->second.t) {
	case u32:
	target->params[it->first].value =
	new uint32_t(((uint32_t)it->second.value));
	break;
	case boolT:
	target->params[it->first].value =
	new bool(((bool)it->second.value));
	break;
	case u8:
	target->params[it->first].value =
	new uint8_t(((uint8_t)it->second.value));
	break;
	}
	}
	}
	/*
	* Method that creates an event object in the trace source based in the
	* fields given in the constructor. It then registers the given callback
	* to this event.
	*/
	MTI::EventClass CreateEvent(ComponentTraceInterface *ptr_cti,
	MTI::CallbackT callback) {

	ComponentTraceInterface cti = ptr_cti;
	std::stringstream ss;
	ComponentTraceInterface *mti = 0;

	if (cti->GetTraceSource(name.c_str()) != 0) {
	TraceSource* ts = cti->GetTraceSource(name.c_str());
	printf("Trace source attached: %s\n", ts->GetName());

	size_t map_size = fields.size();
	ValueBind_t *values_array = new ValueBind_t[map_size + 1];
	TraceFieldsMap::iterator it;
	int i = 0;
	for (it = fields.begin(); it != fields.end(); ++it) {
	values_array[i]= ((ValueBind_t) { it->first.c_str(),
	&it->second.index });
	++i;
	};
	values_array[map_size] = {0, 0}; //sentinel

	mti = static_cast<ModelTraceInterface *>(cti);
	if (!RegisterCallbackForComponent(mti, name.c_str(), values_array,
	this, callback, &event_class, ss)) {
	Error(ss.str().c_str());
	return 0;
	}
	return event_class;
	}
	return 0;
	}
	};

	/*
	* Class and types used to handle trace sources belonging to a
	* component.
	*/
	typedef map<string, TraceSourceContext*> MapTraceSourcesType;
	class TraceComponentContext {
	public:
	string trace_path;
	MapTraceSourcesType trace_sources;

	TraceComponentContext(string tpath) {
	trace_path = tpath;
	}

	void AddTraceSource(TraceSourceContext *ts) {
	trace_sources[ts->name] = ts;
	}
	};

	/*
	* Class used to instantiate a Instruction trace source
	*/
	class InstructionTraceContext: public TraceSourceContext {
	public:
	using TraceSourceContext::TraceSourceContext;
	InstStatMap stats;
	uint64_t nb_insts;

	static void Callback(void* user_data,
	const MTI::EventClass *event_class,
	const MTI::EventRecord *record) {
	InstructionTraceContext* itc = static_cast<InstructionTraceContext*>
	(user_data);
	itc->nb_insts++; // Number of instructions
	// Filled by Component
	uint32_t pc = record->GetAs<uint32_t>(event_class,
	itc->fields["PC"].index);
	uint32_t size = record->Get<uint32_t>(event_class,
	itc->fields["SIZE"].index);
	// Save PC stats. If not already present in the map, a counter with
	// value 0 will be created before incrementing.
	InstStat& is = itc->stats[pc];
	is.cnt++;
	is.size = size;
	};
	};

	struct mode_change_type {
	uint8_t mode_value;
	char name[5];
	};
	const struct mode_change_type types[] = {
	{0x0 , "EL0t"}, //0
	{0x4 , "EL1t"}, //1
	{0x5 , "EL1h"}, //2
	{0x8 , "EL2t"}, //3
	{0x9 , "EL2h"}, //4
	{0xc , "EL3t"}, //5
	{0xd , "EL3h"}, //6
	{0x10 , "usr"}, //7
	{0x11 , "fiq"}, //8
	{0x12 , "irq"}, //9
	{0x13 , "svc"}, //10
	{0x16 , "mon"}, //11
	{0x17 , "abt"}, //12
	{0x1a , "hyp"}, //13
	{0x1b , "und"}, //14
	{0x1f , "sys"}, //15
	/* Secure modes */
	{0x0 , "EL0t"}, //16
	{0x4 , "EL1t"}, //17
	{0x5 , "EL1h"}, //18
	{0x8 , "EL2t"}, //19
	{0x9 , "EL2h"}, //20
	{0xc , "EL3t"}, //21
	{0xd , "EL3h"}, //22
	{0x10 , "usr"}, //23
	{0x11 , "fiq"}, //24
	{0x12 , "irq"}, //25
	{0x13 , "svc"}, //26
	{0x16 , "mon"}, //27
	{0x17 , "abt"}, //28
	{0x1a , "hyp"}, //29
	{0x1b , "und"}, //30
	{0x1f , "sys"} //31
	};

	class ModeChangeTraceContext: public TraceSourceContext {
	public:
	using TraceSourceContext::TraceSourceContext;
	MTI::EventClass *event;
	uint32_t mode_mask;
	InstructionTraceContext* itc;


	static void Callback(void* user_data,
	const MTI::EventClass *event_class,
	const MTI::EventRecord *record)
	{
	ModeChangeTraceContext* mtc = static_cast<ModeChangeTraceContext*>
	(user_data);
	static bool trace = false;
	bool new_trace = false;
	uint8_t mode = record->GetAs<char>(event_class,
	mtc->fields["MODE"].index);
	uint8_t nsecure = record->Get<char>(event_class,
	mtc->fields["NON_SECURE"].index);
	int start_mask = 0;

	if(nsecure) {
	start_mask = 0;
	} else {
	start_mask = 16;
	}

	for (int i = start_mask; i < start_mask + 16; i++) {
	if (types[i].mode_value == mode) {
	new_trace = new_trace \|\| (mtc->mode_mask & (1 << i));
	break;
	}
	}

	if (new_trace && !trace) {
	mtc->event->RegisterCallback(InstructionTraceContext::Callback,
	mtc->itc);
	} else if (!new_trace && trace){
	mtc->event->UnregisterCallback(
	InstructionTraceContext::Callback,
	mtc->itc);
	}
	trace = new_trace;
	};

	};
	#endif // _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_