diff --git a/coverage-tool/coverage-plugin/trace_sources.h b/coverage-tool/coverage-plugin/trace_sources.h
new file mode 100644
index 0000000..57f6462
--- /dev/null
+++ b/coverage-tool/coverage-plugin/trace_sources.h
@@ -0,0 +1,229 @@
+/*!
+##############################################################################
+# 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};
+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;
+        }
+    }
+    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;
+            }
+        }
+}
+/*
+ * 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;
+    };
+};
+
+#endif // _COVERAGE_TOOL_COVERAGE_PLUGIN_TRACE_SOURCES_H_