projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / rst / trconv / trconv.H
/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: trconv.H
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
*
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
*
* The above named 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 work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ========== Copyright Header End ============================================
*/
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: trconv.H
// Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named 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 work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
// File: trconv.H
//
// Description: Part of trconv library file, trconv.o, for printing and
// converting execution traces
//
// How to add another RST record type to trconv:
//
// This file, trconv.H, is the main file supporting the class
// definitions of each trace record type. It includes a global struct
// "gbl" containing variables used throughout trconv, including the
// counts of each record type. Also here is the base class "Trace"
// containing the pure virtual functions you will need to define in
// your new derived class.
//
// To create a new derived class, copy one of the existing classes,
// and modify it accordingly. RSTF_Traceinfo is a simple example;
// RSTF_Instr is a more elaborate example.
//
// All RST traces are first processed by RSTF_Union. In
// RSTF_Union the rtype of each RST record is examined, and the
// corresponding class member function is called. The protected member
// function RSTF_Union::get_rst_type() determines to RST rtype and
// returns a pointer to the corresponding RST class.
//
// Finally in init_globals(char *argv[]) in trconv.C, initialize
// the new counter variable to 0. And in print_counts(FILE* outfp) in
// trconv.C add an fprintf(stdout, ...) statement to print the count
// of the new record type.
//
// Cross you fingers, recompile (ignore the warnings about "master is
// defined but not used" and various member functions being "too large
// and will not be expanded inline", they're normal), and run...
#pragma ident "@(#) trconv.H 1.19: 11/06/07 11:35:08 @(#)"
#include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <string>
#include <map>
#define RSTF_NOADDR -1
#include "rstf/rstf.h"
#include "rstf/rstf_deprecated.h"
#if defined(ARCH_AMD64)
#include "rstf/rstf_convert.h"
#endif
#include "MISC.h"
#include "ITYPES.h"
#define MAX_CPUID (1024)
#define NUM_VERIFY (8)
#define PSTATE_AM (0x8)
extern char switch_error_string[];
enum {
NONE = 0,
RTF99,
SHADE5,
SHADE6x32,
SHADE6x64,
MASTER64,
RST
};
typedef struct {
// format options
int fromtype; // -from FX
int totype; // -to FX
// selection options
uint64_t maxRecs; // -n N
uint64_t maxInstrs; // -n Ni
uint64_t skipRecs; // -s N
uint64_t skipInstrs; // -s Ni
uint64_t frompc; // -pc=pc1[,pc2] // -frompc ?
uint64_t topc; // // -topc ?
uint64_t fromea; // -ea=ea1[,ea2] // -fromea ?
uint64_t toea; // // -toea ?
char cpu[MAX_CPUID + 1]; // -cpu=
uint16_t pstate[MAX_CPUID + 1]; // monitor pstate.am per cpu
// printing options
bool record; // -a
bool disassembly; // -d
bool verbose; // -x
bool showIdx; // -nid
bool countOnly; // -c
#ifdef _PRINT_PA
bool printPA; // -pa
#endif // _PRINT_PA
#ifdef _VALUE_TRACE
bool valueTrace; // -vt
#endif // _VALUE_TRACE
FILE* msgfp; // -msg ?
bool show_syms;
symbol_table_t symbol_table;
// verification options
bool verify; // -nv
bool checkError; // -e
bool fast; // -fast
// rst options
bool onlyIns; // -i
bool reorderIns; // -ic
bool noIns; // -ni
bool reorderNoIns; // -nic
bool branch; // -branch (-nobranch?)
bool pc_pavadiff; // -pc_pavadiff (-nopc_pavadiff?)
bool ea_pavadiff; // -ea_pavadiff (-noea_pavadiff?)
// patching options
bool clean; // -patchcleanrst
bool genIHash; // -patchihash
// output options
FILE* infp; // [input-file]
FILE* outfp; // -stdout || -o
// convenient variables
char* progname;
char* infile;
int fromsize;
int tosize;
bool checkIHash;
uint64_t icount, rcount; // instr count & total record count.
uint64_t skipInstrsRecs;
// rst-related
bool rstf_pre212;
// rst types
uint64_t headercount,
// instrcount, ---> use icount
//asicount,
traceinfocount, // ASI_T == TRACEINFO_T, TRACEINFO_T is to replace ASI_T
tlbcount,
threadcount,
pregcount,
trapcount,
trapexitcount,
trappinginstrcount,
cpucount,
dmacount,
snoopcount,
tsb_access_count,
rfs_section_header_count,
bpwarming_count,
cachewarming_count,
delimcount, // combination of leftdelim & rightdelim
physaddrcount,
pavadiffcount,
//nullrec??? // null record, can be ignored
filemarkercount,
//hwinfocount,
recnumcount,
stringcount, // combination of strdesc & strcont
statuscount,
patchcount,
regvalcount,
memval64count,
memval128count,
bustracecount,
processcount,
timesynccount,
devidstrcount,
zerocount,
unknowncount;
#ifdef _PRINT_PA
bool ea_pavadiff_valid[MAX_INSTR_CPUID];
uint64_t ea_pavadiff_value[MAX_INSTR_CPUID];
bool pc_pavadiff_valid[MAX_INSTR_CPUID];
uint64_t pc_pavadiff_value[MAX_INSTR_CPUID];
#endif // _PRINT_PA
std::map<int, std::string> devid2string;
} Globals_T;
extern Globals_T gbl;
extern char usage_string[];
void usage(char progName[]);
void parse_args(int argc, char *argv[], bool debug = false);
void init_globals(char *argv[]);
int format2int(const char str[]);
int format2size(int format);
bool streqprefix(const char* a, const char* b);
bool streq(const char* a, const char* b);
void get_pc_range(char* pc_str);
void get_range(char* str, uint64_t *from, uint64_t* to);
void get_cpu_range(char* pc_str);
bool in_range(const uint64_t x, const uint64_t a, const uint64_t b);
void print_counts(FILE* outfp);
// base class for all trace structs
class Trace {
public:
// increments global record and instruction counts
virtual void count() {
gbl.rcount++;
gbl.icount++;
}
// prints record fields without disassembly of instruction records
virtual void print_rec(uint64_t idx) = 0;
// prints record disassenbly
virtual void print_dasm(uint64_t idx) {
print_rec(idx);
} // Trace::print_dasm()
// prints verbose record disassembly
virtual void print_verb(uint64_t idx) {
print_rec(idx);
} // Trace::print_verb()
// converts record type to Tmaster64
virtual void convert_to_master() {
// not converted
} // Trace::convert_to_master()
// converts master to record type
virtual void convert_from_master(Tmaster64* master) {
Tmaster64* useless = master;
// not converted
} // Trace::convert_from_master()
// sets ihash field to correct value for instruction records
virtual void gen_ihash() {
// not generated
} // Trace::gen_ihash()
// verifies ihash value of instruction records;
// returns 1 on error, 0 otherwise
virtual int check_ihash_error() {
return 0;
} // Trace::check_ihash_error()
// verifies pc values of instruction records; prints message on error
virtual void verify() {
// not verified
} // Trace::verify()
// returns RSTF_NOADDR for non-instruction, non-trap types
virtual uint64_t get_pc() {
return RSTF_NOADDR;
} // Trace::get_pc()
// returns RSTF_NOADDR for non-instruction types
virtual uint64_t get_ea() {
return RSTF_NOADDR;
} // Trace::get_ea()
// returns ihash value in trace record
virtual int get_ihash() {
return 0;
} // Trace::get_ihash()
// increments trace pointer to next trace record in trace buffer
virtual void inc_tr() = 0;
// sets trace pointer to ptr; optionally sets tr_orig to ptr also
virtual void set_tr(void* ptr, bool set_orig = true) = 0;
// resets trace pointer to tr_orig
virtual void reset_tr() = 0;
// returns pointer to static protected data member this_master
virtual Tmaster64* get_master() {
return &this_master;
} // Trace::get_master()
// used for piping to and from rst trace types
virtual rstf_unionT* copy_from_rst() {
// do nothing (except for RSTF_Union::copy_from_rst() )
return NULL;
}
// used for piping to and from rst trace types
virtual void copy_to_rst(rstf_unionT* from) {
rstf_unionT* useless = from;
// do nothing (except for RSTF_Union::copy_to_rst() )
}
// used to verify branch targets in RSTF disassembly printouts
int check_branch_ea(uint64_t dis_ea, uint64_t tr_ea) {
if (dis_ea != tr_ea) {
if ((dis_ea ^ tr_ea) != (0xffffffff00000000ull)) {
fprintf(stderr, "trconv: warning: branch target != effective address "
"(Rec #%llu: 0x%llx != 0x%llx)\n",
gbl.rcount - 1, dis_ea, tr_ea);
return 1;
}
}
return 0;
}
virtual int getCpuID() {
return -1;
}
protected:
// static data member, shared by all derived classes
static Tmaster64 this_master;
}; // Trace
//======================================================================
//======================================================================
class RSTF_Header : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.headercount++;
if (tr->majorVer*1000 + tr->minorVer <= 2011) {
gbl.rstf_pre212 = true;
}
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "header : majorVer=%d minorVer=%d %s",
tr->majorVer, tr->minorVer, tr->header_str);
fprintf(gbl.outfp, "\n");
} // RSTF_Header::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Header::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_headerT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Header::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Header::reset_tr()
protected:
rstf_headerT* tr;
rstf_headerT* tr_orig;
}; // RSTF_Header
//======================================================================
//======================================================================
class RSTF_Instr : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.icount++;
if (gbl.clean == true) {
if (!tr->ea_valid){
tr->ea_va = RSTF_NOADDR;
}
}
} // RSTF_Instr::count()
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
uint64_t ea_va = -1;
int cpuid = getCpuID();
sprintDiss(dis_string, tr->instr, tr->pc_va);
int ihash = spix_sparc_iop(SPIX_SPARC_V9, &tr->instr);
// if (ih_isbranch(tr->ihash) || tr->ihash == SPIX_SPARC_IOP_CALL) {
if (ih_isbranch(ihash) || ihash == SPIX_SPARC_IOP_CALL) {
if (gbl.branch && tr->bt) {
ea_va = getCtiEa(tr->instr, ihash, tr->pc_va);
if (gbl.pstate[cpuid] & PSTATE_AM) {
ea_va &= 0xffffffff;
}
if (!tr->an) {
check_branch_ea(ea_va, tr->ea_va);
}
}
}
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "instr : cpuid=%d ", cpuid);
if (tr->hpriv) {
fprintf(gbl.outfp, "h ");
} else if (tr->pr) {
fprintf(gbl.outfp, "p ");
} else {
fprintf(gbl.outfp, "u ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->pc_va);
if (gbl.show_syms) {
char *symbol;
uint64_t offset;
if (gbl.symbol_table.search_symbol_table(tr->pc_va, symbol, offset)) {
fprintf(gbl.outfp, "(%s+0x%llx) ", symbol, offset);
}
else {
fprintf(gbl.outfp, "(???+???) ", symbol, offset);
}
}
fprintf(gbl.outfp, "%-32s", dis_string);
if (ih_iscti(ihash)) {
if (tr->bt) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
#ifdef _PRINT_PA
if (gbl.printPA) {
if (!tr->an) {
if (tr->ea_valid) {
fprintf(gbl.outfp, "v[0x%016llx] ", tr->ea_va);
if ((ih_isload(ihash) || ih_isstore(ihash)) &&
tr->tr == 0) {
if (gbl.ea_pavadiff_valid[cpuid]) {
fprintf(gbl.outfp, "p[0x%016llx] ", tr->ea_va + gbl.ea_pavadiff_value[cpuid]);
}
} else {
if (gbl.pc_pavadiff_valid[cpuid]) {
fprintf(gbl.outfp, "p[0x%016llx] ", tr->ea_va + gbl.pc_pavadiff_value[cpuid]);
}
}
} else if (tr->bt) { // so it must be a branch...(?)
fprintf(gbl.outfp, "<0x%016llx> ", tr->ea_va);
}
}
} else
#endif //_PRINT_PA
{
if (!tr->an) {
if (tr->ea_valid) {
fprintf(gbl.outfp, "[0x%016llx] ", tr->ea_va);
} else if (tr->bt) { // so it must be a branch...(?)
fprintf(gbl.outfp, "<0x%016llx> ", tr->ea_va);
}
}
}
if (tr->an) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr) {
fprintf(gbl.outfp, "tr ");
}
fprintf(gbl.outfp, "\n");
} // RSTF_Instr::print_dasm()
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp, "%6lld ", idx);
}
// int ihash = spix_sparc_iop(SPIX_SPARC_V9, &tr->instr);
fprintf(gbl.outfp, "instr : cpuid=%d ", gbl.rstf_pre212? tr->cpuid: rstf_instrT_get_cpuid(tr));
fprintf(gbl.outfp, "pc=0x%016llx ", tr->pc_va);
fprintf(gbl.outfp, "instr=0x%08x ", tr->instr);
// fprintf(gbl.outfp, "ihash=%-3d ", ihash);
fprintf(gbl.outfp, "hpriv=%d ", tr->hpriv);
fprintf(gbl.outfp, "pr=%d ", tr->pr);
fprintf(gbl.outfp, "bt=%d ", tr->bt);
fprintf(gbl.outfp, "ea=0x%016llx ", tr->ea_va);
fprintf(gbl.outfp, "ev=%d ", tr->ea_valid);
fprintf(gbl.outfp, "an=%d ", tr->an);
fprintf(gbl.outfp, "tr=%d ", tr->tr);
fprintf(gbl.outfp, "\n");
} // RSTF_Instr::print_rec()
virtual void print_verb(uint64_t idx) {
char dis_string[80];
uint64_t ea_va = -1;
int cpuid = gbl.rstf_pre212? tr->cpuid: rstf_instrT_get_cpuid(tr);
sprintDiss(dis_string, tr->instr, tr->pc_va);
int ihash = spix_sparc_iop(SPIX_SPARC_V9, &tr->instr);
if (ih_isbranch(ihash) || ihash == SPIX_SPARC_IOP_CALL) {
if (gbl.branch && tr->bt) {
ea_va = getCtiEa(tr->instr, ihash, tr->pc_va);
if (gbl.pstate[cpuid] & PSTATE_AM) {
ea_va &= 0xffffffff;
}
if (!tr->an) {
check_branch_ea(ea_va, tr->ea_va);
}
}
}
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "instr : cpuid=%d ", cpuid);
if (tr->hpriv) {
fprintf(gbl.outfp, "h ");
} else if (tr->pr) {
fprintf(gbl.outfp, "p ");
} else {
fprintf(gbl.outfp, "u ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->pc_va);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->instr);
fprintf(gbl.outfp, "%3d ", ihash);
if (ih_iscti(ihash)) {
if (tr->bt) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
#ifdef _PRINT_PA
if (gbl.printPA) {
fprintf(gbl.outfp, "v[0x%016llx]", tr->ea_va);
if (!tr->ea_valid) {
fprintf(gbl.outfp, "x ");
} else {
fprintf(gbl.outfp, " ");
}
if ((ih_isload(ihash) || ih_isstore(ihash)) &&
tr->tr == 0) {
if (gbl.ea_pavadiff_valid[cpuid]) {
fprintf(gbl.outfp, "p[0x%016llx] ", tr->ea_va + gbl.ea_pavadiff_value[cpuid]);
}
} else {
if (gbl.pc_pavadiff_valid[cpuid]) {
fprintf(gbl.outfp, "p[0x%016llx] ", tr->ea_va + gbl.pc_pavadiff_value[cpuid]);
}
}
} else
#endif // _PRINT_PA
{
fprintf(gbl.outfp, "[0x%016llx]", tr->ea_va);
if (!tr->ea_valid) {
fprintf(gbl.outfp, "x ");
} else {
fprintf(gbl.outfp, " ");
}
}
if (tr->an) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr) {
fprintf(gbl.outfp, "tr ");
}
fprintf(gbl.outfp, "\n");
} // RSTF_Instr::print_verb()
virtual void convert_to_master() {
this_master.tr_pc_va = tr->pc_va;
this_master.tr_ea_va = tr->ea_va ;
this_master.tr_tid = 0;
this_master.tr_ih = spix_sparc_iop(SPIX_SPARC_V9, &tr->instr);
this_master.tr_reserved0 = 0;
this_master.tr_taken = tr->bt;
this_master.tr_annulled = tr->an;
this_master.tr_i = tr->instr;
this_master.tr_reserved1 = 0;
this_master.tr_pc_pa = 0;
this_master.tr_ea_pa = 0;
this_master.tr_context = 0;
//this_master.tr_traceinfo = 0;
this_master.tr_got_trap = tr->tr;
this_master.tr_privmode = tr->pr;
this_master.tr_va_valid = tr->ea_valid;
} // RSTF_Instr::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr->rtype = INSTR_T;
tr->notused = 0;
tr->ea_valid = master->tr_va_valid;
tr->tr = master->tr_got_trap;
tr->pr = master->tr_privmode;
tr->bt = master->tr_taken;
tr->an = master->tr_annulled;
// tr->ihash = master->tr_ih;
tr->instr = master->tr_i;
tr->pc_va = master->tr_pc_va;
tr->ea_va = master->tr_ea_va;
} // RSTF_Instr::convert_from_master()
virtual void gen_ihash() {
// tr->ihash = getIHash(tr->instr);
} // RSTF_Instr::gen_ihash()
virtual int check_ihash_error() {
#if 0
if (tr->ihash != getIHash(tr->instr)) {
return 1;
}
#endif
return 0;
} // RSTF_Instr::check_ihash_error()
virtual void verify() {
rstf_instrT* vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].rtype == INSTR_T) {
if (vtr[i].pc_va % 4 != 0 && RSTF_IS_BADADDR(vtr[i].pc_va) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
}
} // RSTF_Instr::verify()
virtual uint64_t get_pc() {
return tr->pc_va;
} // RSTF_Instr::get_pc()
virtual uint64_t get_ea() {
if (tr->ea_valid) {
return tr->ea_va;
}
return RSTF_NOADDR;
} // RSTF_Instr::get_ea()
virtual int get_ihash() {
return spix_sparc_iop(SPIX_SPARC_V9, &tr->instr);
} // RSTF_Instr::get_ihash()
virtual void inc_tr() {
tr++;
} // RSTF_Instr::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_instrT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Instr::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Instr::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_instrT_get_cpuid(tr);
}
protected:
rstf_instrT* tr;
rstf_instrT* tr_orig;
}; // RSTF_Instr
#if 0 // deprecated
//======================================================================
//======================================================================
// ASI_T is deprecated, is replaced by TRACEINFO_T with the same enum value.
class RSTF_Asi : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.asicount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
//FIXME should use rstf_traceinfoT, but it is not done yet, stay tune.
fprintf(gbl.outfp, "asi : rtype=%d asi=%d", tr->rtype, tr->asi);
fprintf(gbl.outfp, "\n");
} // RSTF_Asi::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Asi::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_asiT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Asi::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Asi::reset_tr()
protected:
rstf_asiT* tr;
rstf_asiT* tr_orig;
}; // RSTF_Asi
#endif
//======================================================================
//======================================================================
class RSTF_Traceinfo : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.traceinfocount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
switch(ti_level->rtype2) {
case RSTT2_NLEVEL_T:
{ time_t t = ti_level->time64;
fprintf(gbl.outfp, "trinfo : LEVEL=%d time=%s", ti_level->level, ctime(&t));
}
break;
case RSTT2_CPUINFO_T:
fprintf(gbl.outfp, "trinfo : NCPUS=%d mincpuid=%d maxcpuid=%d\n", ti_cpuinfo->numcpus,
ti_cpuinfo->min_cpu_id, ti_cpuinfo->max_cpu_id);
break;
case RSTT2_CPUIDINFO_T:
fprintf(gbl.outfp, "trinfo : CPUIDS={ ");
int i;
for (i=0; i<10; i++) {
fprintf(gbl.outfp, "%d,", ti_cpuid->cpuids[i]);
}
fprintf(gbl.outfp, "}\n");
break;
default:
fprintf(gbl.outfp, "Unknown TRACEINFO record\n");
}
} // RSTF_Traceinfo::print_rec()
virtual void inc_tr() {
ti_level++;
} // RSTF_Traceinfo::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
ti_level = (rstf_traceinfo_levelT*) ptr;
ti_cpuinfo = (rstf_cpuinfoT*) ptr;
ti_cpuid = (rstf_cpuidinfoT*) ptr;
if (set_orig) {
tr_orig = ti_level;
}
} // RSTF_Traceinfo::set_tr()
virtual void reset_tr() {
ti_level = (rstf_traceinfo_levelT*) tr_orig;
ti_cpuinfo = (rstf_cpuinfoT*) tr_orig;
ti_cpuid = (rstf_cpuidinfoT*) tr_orig;
} // RSTF_Traceinfo::reset_tr()
protected:
rstf_traceinfo_levelT* ti_level;
rstf_cpuinfoT * ti_cpuinfo;
rstf_cpuidinfoT * ti_cpuid;
rstf_traceinfo_levelT* tr_orig;
}; // RSTF_Traceinfo
//======================================================================
//======================================================================
class RSTF_Tlb : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.tlbcount++;
}
virtual void print_rec(uint64_t idx) {
uint64_t pa;
pa = tr->tte_data;
pa &= (~ 0x1fffULL);
pa &= 0x7ffffffffffULL;
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "tlb : cpuid=%d demap=%d ", getCpuID(), tr->demap);
fprintf(gbl.outfp, "type=%d ", tr->tlb_type);
//fprintf(gbl.outfp, "valid=%d ", tr->valid);
fprintf(gbl.outfp, "index=%-4d ", tr->tlb_index);
fprintf(gbl.outfp, "no=%d ", tr->tlb_no);
//fprintf(gbl.outfp, "state=0x%04x ", tr->state);
//fprintf(gbl.outfp, "context=0x%04x ", tr->context);
fprintf(gbl.outfp, "tag=0x%016llx ", tr->tte_tag);
fprintf(gbl.outfp, "data=0x%016llx ", tr->tte_data);
fprintf(gbl.outfp, "pa=0x%llx", pa);
fprintf(gbl.outfp, "\n");
} // RSTF_Tlb::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Tlb::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_tlbT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Tlb::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Tlb::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_tlbT_get_cpuid(tr);
}
protected:
rstf_tlbT* tr;
rstf_tlbT* tr_orig;
}; // RSTF_Tlb
//======================================================================
//======================================================================
class RSTF_Thread : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.threadcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "thread : rtype=%d", tr->rtype);
//fprintf(gbl.outfp, "thread : rtype=%d newtid=%d newpid=%d",
// tr->rtype, tr->newtid, tr->newpid);
fprintf(gbl.outfp, "\n");
} // RSTF_Thread::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Thread::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_threadT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Thread::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Thread::reset_tr()
protected:
rstf_threadT* tr;
rstf_threadT* tr_orig;
}; // RSTF_Thread
inline void
decode_pstate_bits (FILE* const out, uint16_t pstate)
{
fprintf (out, "(");
if ((pstate & 0x800) != 0) { // Cheetah specific
fprintf(out, " IG");
}
if ((pstate & 0x400) != 0) { // Cheetah specific
fprintf(out, " MG");
}
if ((pstate & 0x4) != 0) {
fprintf(out, " PRIV");
}
if ((pstate & 0x2) != 0) {
fprintf(out, " IE");
}
if ((pstate & 0x1) != 0) {
fprintf(out, " AG");
}
fprintf (out, ") ");
}
//======================================================================
//======================================================================
class RSTF_Trap : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.trapcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "trap : cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "async==%d ", tr->is_async);
fprintf(gbl.outfp, "tl=%d ", tr->tl);
fprintf(gbl.outfp, "ttype=0x%03x ", tr->ttype);
switch (tr->ttype) {
case 0x12:
fprintf(gbl.outfp, "(unimplemented LDD instr) ");
break;
case 0x24: case 0x25: case 0x26: case 0x27:
fprintf(gbl.outfp, "(clean window) ");
break;
case 0x40: case 0x41: case 0x42: case 0x43:
case 0x44: case 0x45: case 0x46: case 0x47:
case 0x48: case 0x49: case 0x4A: case 0x4B:
case 0x4C: case 0x4D: case 0x4E: case 0x4F:
fprintf(gbl.outfp, "(interrupt request lvl n) ");
break;
case 0x60:
fprintf(gbl.outfp, "(interrupt request) ");
break;
case 0x64: case 0x65: case 0x66: case 0x67:
fprintf(gbl.outfp, "(ITLB miss) ");
break;
case 0x68: case 0x69: case 0x6A: case 0x6B:
fprintf(gbl.outfp, "(DTLB miss) ");
break;
case 0x80: case 0x81: case 0x82: case 0x83:
case 0x84: case 0x85: case 0x86: case 0x87:
case 0x88: case 0x89: case 0x8A: case 0x8B:
case 0x8C: case 0x8D: case 0x8E: case 0x8F:
case 0x90: case 0x91: case 0x92: case 0x93:
case 0x94: case 0x95: case 0x96: case 0x97:
case 0x98: case 0x99: case 0x9A: case 0x9B:
case 0x9C: case 0x9D: case 0x9E: case 0x9F:
fprintf(gbl.outfp, "(spill normal) ");
break;
case 0xA0: case 0xA1: case 0xA2: case 0xA3:
case 0xA4: case 0xA5: case 0xA6: case 0xA7:
case 0xA8: case 0xA9: case 0xAA: case 0xAB:
case 0xAC: case 0xAD: case 0xAE: case 0xAF:
case 0xB0: case 0xB1: case 0xB2: case 0xB3:
case 0xB4: case 0xB5: case 0xB6: case 0xB7:
case 0xB8: case 0xB9: case 0xBA: case 0xBB:
case 0xBC: case 0xBD: case 0xBE: case 0xBF:
fprintf(gbl.outfp, "(spill other) ");
break;
case 0xC0: case 0xC1: case 0xC2: case 0xC3:
case 0xC4: case 0xC5: case 0xC6: case 0xC7:
case 0xC8: case 0xC9: case 0xCA: case 0xCB:
case 0xCC: case 0xCD: case 0xCE: case 0xCF:
case 0xD0: case 0xD1: case 0xD2: case 0xD3:
case 0xD4: case 0xD5: case 0xD6: case 0xD7:
case 0xD8: case 0xD9: case 0xDA: case 0xDB:
case 0xDC: case 0xDD: case 0xDE: case 0xDF:
fprintf(gbl.outfp, "(fill normal) ");
break;
// 0x100 - 0x176 - Tcc instruction executed
case 0x100: case 0x101: case 0x102: case 0x103:
case 0x108: case 0x109: case 0x10a: case 0x10b:
case 0x120: case 0x121: case 0x122: case 0x123:
case 0x124: case 0x125: case 0x126: case 0x127:
case 0x140:
fprintf(gbl.outfp, "(tcc instr.) ");
break;
default:
/* do nothing */
break;
}
fprintf(gbl.outfp, "pstate=0x%03x ", tr->pstate);
decode_pstate_bits (gbl.outfp, tr->pstate);
fprintf(gbl.outfp, "syscall=0x%04x ", tr->syscall);
fprintf(gbl.outfp, "pc=0x%016llx ", tr->pc);
fprintf(gbl.outfp, "npc=0x%016llx", tr->npc);
fprintf(gbl.outfp, "\n");
} // RSTF_Trap::print_rec()
virtual uint64_t get_pc() {
return tr->pc;
} // RSTF_Trap::get_pc()
virtual void inc_tr() {
tr++;
} // RSTF_Trap::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_trapT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Trap::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Trap::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_trapT_get_cpuid(tr);
}
protected:
rstf_trapT* tr;
rstf_trapT* tr_orig;
}; // RSTF_Trap
//======================================================================
//======================================================================
class RSTF_Trapexit : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.trapexitcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "trapexit: cpuid=%d tl=%d ", getCpuID(), tr->tl);
fprintf(gbl.outfp, "tstate=%d ", tr->tstate);
//fprintf(gbl.outfp, "pc=0x%016llx ", tr->pc);
//fprintf(gbl.outfp, "npc=0x%016llx ", tr->npc);
fprintf(gbl.outfp, "\n");
} // RSTF_Trapexit::print_rec()
#if 0
virtual uint64_t get_pc() {
return tr->pc;
} // RSTF_Trapexit::get_pc()
#endif
virtual void inc_tr() {
tr++;
} // RSTF_Trapexit::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_trapexitT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Trapexit::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Trapexit::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_trapexitT_get_cpuid(tr);
}
protected:
rstf_trapexitT* tr;
rstf_trapexitT* tr_orig;
}; // RSTF_Trapexit
//======================================================================
//======================================================================
class RSTF_Regval : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.regvalcount++;
}
#ifdef _VALUE_TRACE
virtual void print_rec_valueTrace(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "regval : ");
fprintf(gbl.outfp, "cpuid=%d ", getCpuID());
// fprintf(gbl.outfp, "postInstr=%d ", tr->postInstr);
for(long i=0; i<2; i++) {
vtPrintReg(gbl.outfp, tr->regtype[i], tr->regid[i], tr->reg64[i], i);
}
fprintf(gbl.outfp, "\n");
} // RSTF_Regval::print_rec()
#endif // _VALUE_TRACE
virtual void print_rec_normal(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "regval : ");
fprintf(gbl.outfp, "cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "postInstr=%d ", tr->postInstr);
fprintf(gbl.outfp, "regtype[0]=%d ", tr->regtype[0]);
fprintf(gbl.outfp, "regid[0]=%d ", tr->regid[0]);
fprintf(gbl.outfp, "reg64[0]=0x%llx ", tr->reg64[0]);
fprintf(gbl.outfp, "regtype[1]=%d ", tr->regtype[1]);
fprintf(gbl.outfp, "regid[1]=%d ", tr->regid[1]);
fprintf(gbl.outfp, "reg64[1]=0x%llx", tr->reg64[1]);
fprintf(gbl.outfp, "\n");
//fprintf(gbl.outfp, "regnum=%d ", tr->regnum);
//fprintf(gbl.outfp, "reg32=%d ", tr->reg32);
} // RSTF_Regval::print_rec()
virtual void print_rec(uint64_t idx) {
#ifdef _VALUE_TRACE
if (gbl.valueTrace) {
print_rec_valueTrace(idx);
} else
#endif // _VALUE_TRACE
{
print_rec_normal(idx);
}
}
virtual void inc_tr() {
tr++;
} // RSTF_Regval::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_regvalT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Regval::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Regval::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_regvalT_get_cpuid(tr);
}
protected:
rstf_regvalT* tr;
rstf_regvalT* tr_orig;
#ifdef _VALUE_TRACE
virtual void
vtPrintIntRegName(FILE *outfp, long regid)
{
if (regid < 0 || regid >= 32) {
fprintf(stderr, "trconv: warning: Register number %d should be <32 (Rec #%llu)\n", regid, gbl.rcount);
}
static char prefix[5] = "goli";
char toprint[3] = "g0";
toprint[0] = prefix[(regid/8)];
toprint[1] = '0' + (regid%8);
fprintf(outfp, "%%%s ", toprint);
}
virtual void
vtPrintFloatReg(FILE *outfp, long regid, uint64_t reg64,
long i, char &isQuad, uint64_t &quadWord)
{
if (regid >= 0 && regid < 32) {
// Single
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
float f = (float) reg64;
fprintf(outfp, "(Reg %d: %%f%d = %f(0x%llx)) ", i, regid, f, reg64);
}
else if (regid < 64) {
// Double
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
double d = (double) reg64;
fprintf(outfp, "(Reg %d: %%d%d = %f(0x%llx)) ", i, ((regid - 32) * 2), d, reg64);
}
else {
if (regid >= 80) {
fprintf(stderr, "trconv: warning: regid = %d should have been <80 (Rec #%llu\n", regid, gbl.rcount);
}
if (i == 0) {
isQuad = 1;
quadWord = reg64;
}
else {
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
fprintf(outfp, "(Reg 0+1: %%q%d = 0x%016llx%016llx) ",
i, ((regid - 64) * 4), quadWord, reg64);
}
}
}
virtual void
vtPrintPrivReg(FILE *outfp, long regid)
{
switch (regid) {
case RSTREG_TPC_R: fprintf(outfp, "%%tpc "); break;
case RSTREG_TNPC_R: fprintf(outfp, "%%tnpc "); break;
case RSTREG_TSTATE_R: fprintf(outfp, "%%tstate "); break;
case RSTREG_TT_R: fprintf(outfp, "%%tt "); break;
case RSTREG_TICK_R: fprintf(outfp, "%%tick "); break;
case RSTREG_TBA_R: fprintf(outfp, "%%tba "); break;
case RSTREG_PSTATE_R: fprintf(outfp, "%%pstate "); break;
case RSTREG_TL_R: fprintf(outfp, "%%tl "); break;
case RSTREG_PIL_R: fprintf(outfp, "%%pil "); break;
case RSTREG_CWP_R: fprintf(outfp, "%%cwp "); break;
case RSTREG_CANSAVE_R: fprintf(outfp, "%%cansave "); break;
case RSTREG_CANRESTORE_R: fprintf(outfp, "%%canrestore "); break;
case RSTREG_CLEANWIN_R: fprintf(outfp, "%%cleanwin "); break;
case RSTREG_OTHERWIN_R: fprintf(outfp, "%%otherwin "); break;
case RSTREG_WSTATE_R: fprintf(outfp, "%%wstate "); break;
case RSTREG_FQ_R: fprintf(outfp, "%%fq "); break;
case RSTREG_VERSION_R: fprintf(outfp, "%%ver "); break;
case RSTREG_TPC_RBASE + 0:
case RSTREG_TPC_RBASE + 1:
case RSTREG_TPC_RBASE + 2:
case RSTREG_TPC_RBASE + 3:
case RSTREG_TPC_RBASE + 4:
if (regid == RSTREG_TPC_RBASE){ // does not make sense to have trap level 0
fprintf(stderr, "trconv: warning: TPC should not be present for trap level 0 (#%llu) \n", gbl.rcount);
}
fprintf(outfp, "%%tpc[%d]", regid-RSTREG_TPC_RBASE); break;
case RSTREG_TNPC_RBASE + 0:
case RSTREG_TNPC_RBASE + 1:
case RSTREG_TNPC_RBASE + 2:
case RSTREG_TNPC_RBASE + 3:
case RSTREG_TNPC_RBASE + 4:
if (regid == RSTREG_TNPC_RBASE){ // does not make sense to have trap level 0
fprintf(stderr, "trconv: warning: TNPC should not be present for trap level 0 (#%llu) \n", gbl.rcount);
}
fprintf(outfp, "%%tnpc[%d]", regid-RSTREG_TNPC_RBASE); break;
case RSTREG_TSTATE_RBASE + 0:
case RSTREG_TSTATE_RBASE + 1:
case RSTREG_TSTATE_RBASE + 2:
case RSTREG_TSTATE_RBASE + 3:
case RSTREG_TSTATE_RBASE + 4:
if (regid == RSTREG_TSTATE_RBASE){ // does not make sense to have trap level 0
fprintf(stderr, "trconv: warning: TSTATE should not be present for trap level 0 (#%llu) \n", gbl.rcount);
}
fprintf(outfp, "%%tstate[%d]", regid-RSTREG_TSTATE_RBASE); break;
case RSTREG_TT_RBASE + 0: case RSTREG_TT_RBASE + 1: case RSTREG_TT_RBASE + 2: case RSTREG_TT_RBASE + 3: case RSTREG_TT_RBASE + 4:
if (regid == RSTREG_TT_RBASE){ // does not make sense to have trap level 0
fprintf(stderr, "trconv: warning: TT should not be present for trap level 0 (#%llu) \n", gbl.rcount);
}
fprintf(outfp, "%%tt[%d]", regid-RSTREG_TT_RBASE); break;
default:
fprintf(outfp, "%%unknownpr%d ", regid);
// fprintf(stderr, "trconv: warning: Unknown priv regid %d (#%llu)", regid, gbl.rcount);
break;
}
}
virtual void
vtPrintOtherReg(FILE *outfp, long regid)
{
switch (regid) {
case RSTREG_Y_R: fprintf(outfp, "%%y "); break;
case RSTREG_CC_R: fprintf(outfp, "%%cc "); break;
case RSTREG_ASI_R: fprintf(outfp, "%%asi "); break;
case RSTREG_TICK_R: fprintf(outfp, "%%tick "); break;
case RSTREG_PC_R: fprintf(outfp, "%%pc "); break;
case RSTREG_FPRS_R: fprintf(outfp, "%%fprs "); break;
// case RSTREG_ASR_R: fprintf(outfp, "%%asr "); break;
case RSTREG_ASR_PCR_R: fprintf(outfp, "%%pcr "); break;
case RSTREG_ASR_PIC_R: fprintf(outfp, "%%pic "); break;
case RSTREG_ASR_IEU_CTRL_R: fprintf(outfp, "%%ieu_ctrl "); break;
case RSTREG_ASR_GSR_R: fprintf(outfp, "%%gsr "); break;
case RSTREG_ASR_INTR_SET_R: fprintf(outfp, "%%intr_set "); break;
case RSTREG_ASR_INTR_CLR_R: fprintf(outfp, "%%intr_clr "); break;
case RSTREG_ASR_INTR_WRITE_R: fprintf(outfp, "%%intr_write "); break;
case RSTREG_ASR_TICK_CMPR_R: fprintf(outfp, "%%tick_cmpr "); break;
case RSTREG_ASR_STICK_REG_R: fprintf(outfp, "%%stick "); break;
case RSTREG_ASR_STICK_CMPR_R: fprintf(outfp, "%%stick_cmpr "); break;
case RSTREG_ASR_STICK_THR_STR_R: fprintf(outfp, "%%stick_thr_str "); break;
case RSTREG_ASR_NPC_R: fprintf(outfp, "%%npc "); break;
case RSTREG_ASR_FSR_R: fprintf(outfp, "%%fsr "); break;
default:
fprintf(outfp, "%%UnknownASR ");
break;
}
}
virtual void
vtPrintReg(FILE *outfp, long regtype, long regid, uint64_t reg64, int i)
{
static char isQuad = 0;
static uint64_t quadWord = 0x0;
switch (regtype) {
case RSTREG_INT_RT:
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
fprintf(outfp, "(Reg %d: ", i);
vtPrintIntRegName(outfp, regid);
fprintf(outfp, "= 0x%llx) ", reg64);
break;
case RSTREG_FLOAT_RT:
vtPrintFloatReg(outfp, regid, reg64, i, isQuad, quadWord);
break;
case RSTREG_PRIV_RT:
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
fprintf(outfp, "(Reg %d: ", i);
vtPrintPrivReg(outfp, regid);
fprintf(outfp, "= 0x%llx) ", reg64);
if (regid == RSTREG_PSTATE_R)
decode_pstate_bits (outfp, reg64);
break;
case RSTREG_OTHER_RT:
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
fprintf(outfp, "(Reg %d: ", i);
vtPrintOtherReg(outfp, regid);
fprintf(outfp, "= 0x%llx) ", reg64);
break;
case RSTREG_UNUSED_RT:
if(isQuad) {
fprintf(stderr,
"trconv: warning: quad register encountered (#%llu)\n",
gbl.rcount);
}
// fprintf(outfp, "(Reg %d unused)", i);
break;
case RSTREG_CC_RT:
fprintf(outfp, "(Reg %d: %%ccr=0x%02x) ", i, regid);
break;
case RSTREG_FCC_RT:
fprintf(outfp, "(Reg %d: %%fcc=0x%02x) ", i, regid);
break;
case RSTREG_MMU_RT:
if (regid == RSTREG_MMU_PCONTEXT) {
fprintf(outfp, "(Reg %d: PContext=0x%02llx) ", i, reg64);
} else if (regid == RSTREG_MMU_SCONTEXT) {
fprintf(outfp, "(Reg %d: SContext=0x%02llx) ", i, reg64);
} else {
fprintf(stderr, "trconv: warning: (#%llu) (Reg %d: Unknown MMU RegID %d = 0x%02x)\n",
gbl.rcount, i, regid, reg64);
}
break;
case RSTREG_HPRIV_RT:
switch(regid) {
case RSTREG_HPR_HPSTATE:
fprintf(outfp, "(Reg %d: %%hpstate=0x%llx) ", i, reg64);
break;
case RSTREG_HPR_HTSTATE:
fprintf(outfp, "(Reg %d: %%htstate=0x%llx) ", i, reg64);
break;
case RSTREG_HPR_HINTP:
fprintf(outfp, "(Reg %d: %%hintp=0x%llx) ", i, reg64);
break;
case RSTREG_HPR_HTBA:
fprintf(outfp, "(Reg %d: %%htba=0x%llx) ", i, reg64);
break;
case RSTREG_HPR_HVER:
fprintf(outfp, "(Reg %d: %%hver=0x%llx) ", i, reg64);
break;
case RSTREG_HPR_HSTICK_CMPR:
fprintf(outfp, "(Reg %d: %%hstick_cmpr=0x%llx) ", i, reg64);
break;
default:
fprintf(outfp, "(Reg %d: UnknownHPR%d = 0x%llx) ", i, regid, reg64);
}
break;
default:
fprintf(stderr, "trconv: warning: Unknown regtype %d for reg[%d] (#%llu)", regtype, i, gbl.rcount);
break;
}
}
#endif // _VALUE_TRACE
}; // RSTF_Regval
//======================================================================
//======================================================================
class RSTF_Cpu : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.cpucount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "cpu : cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "timestamp=%llu", tr->timestamp);
fprintf(gbl.outfp, "\n");
} // RSTF_Cpu::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Cpu::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_cpuT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Cpu::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Cpu::reset_tr()
virtual int getCpuID() {
return tr->cpu;
}
protected:
rstf_cpuT* tr;
rstf_cpuT* tr_orig;
}; // RSTF_Cpu
//======================================================================
//======================================================================
class RSTF_Process : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.processcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "process : ");
fprintf(gbl.outfp, "%d ", tr->oldpid);
fprintf(gbl.outfp, "%d ", tr->newpid);
fprintf(gbl.outfp, "%d ", tr->oldcontext);
fprintf(gbl.outfp, "%d", tr->newcontext);
fprintf(gbl.outfp, "\n");
} // RSTF_Process::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Process::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_processT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Process::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Process::reset_tr()
protected:
rstf_processT* tr;
rstf_processT* tr_orig;
}; // RSTF_Process
//======================================================================
//======================================================================
class RSTF_Dma : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.dmacount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "dma : ");
//fprintf(gbl.outfp, "rtype=%d ", tr->rtype);
fprintf(gbl.outfp, "iswrite=%d ", tr->iswrite);
fprintf(gbl.outfp, "start_pa=0x%016llx ", tr->start_pa);
fprintf(gbl.outfp, "nbytes=%d ", tr->nbytes);
if (tr->devid) {
fprintf(gbl.outfp, "dev_id=%d ", tr->devid);
std::string idstring = gbl.devid2string[tr->devid];
if (idstring.length() == 0) {
idstring = "unknown";
}
fprintf(gbl.outfp, "(%s)", idstring.c_str());
}
fprintf(gbl.outfp, "\n");
} // RSTF_Dma::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Dma::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_dmaT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Dma::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Dma::reset_tr()
protected:
rstf_dmaT* tr;
rstf_dmaT* tr_orig;
}; // RSTF_Dma
//======================================================================
//======================================================================
class RSTF_String : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.stringcount++;
}
virtual void print_rec(uint64_t idx) {
static char desc_string[800];
static char* desc_str = desc_string;
char cont_string[32];
int i;
if (tr->rtype == STRDESC_T) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
for (i = 0; i < 23; i++) {
if (tr->string[i] == 0) {
break;
}
}
if (i == 23) {
fprintf(stderr,
"trconv: warning: strdesc string not null terminated (#%llu)\n",
gbl.rcount);
}
strncpy(desc_str, tr->string, 23);
desc_str += 23;
desc_str[0] = 0;
fprintf(gbl.outfp, "strdesc : \"%s\"\n", desc_string);
desc_str = desc_string;
} else {
strncpy(desc_str, tr->string, 23);
desc_str += 23;
desc_str[0] = 0;
strncpy(cont_string, tr->string, 23);
cont_string[23] = 0;
if (gbl.fast) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "strcont : \"%s\"\n", cont_string);
}
}
} // RSTF_String::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_String::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_stringT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_String::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_String::reset_tr()
protected:
rstf_stringT* tr;
rstf_stringT* tr_orig;
}; // RSTF_String
//======================================================================
//======================================================================
class RSTF_Delim : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.delimcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->rtype == LEFTDELIM_T) {
fprintf(gbl.outfp, "delimTl : ");
} else {
fprintf(gbl.outfp, "delimTr : ");
}
fprintf(gbl.outfp, "id=%d ", tr->id);
fprintf(gbl.outfp, "what=%d ", tr->what);
fprintf(gbl.outfp, "length=%d", tr->length);
fprintf(gbl.outfp, "\n");
} // RSTF_Delim::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Delim::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_delimT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Delim::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Delim::reset_tr()
protected:
rstf_delimT* tr;
rstf_delimT* tr_orig;
}; // RSTF_Delim
//======================================================================
//======================================================================
class RSTF_Preg : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.pregcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "preg : cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "asiReg=%d ", tr->asiReg);
//fprintf(gbl.outfp, "last_context=%d ", tr->lastcontext);
fprintf(gbl.outfp, "trap_lvl=0x%02x ", tr->traplevel);
fprintf(gbl.outfp, "trap_type=0x%02x ", tr->traptype);
fprintf(gbl.outfp, "pstate=0x%04x ", tr->pstate);
decode_pstate_bits(gbl.outfp, tr->pstate);
fprintf(gbl.outfp, "primA=%d ", tr->primA);
fprintf(gbl.outfp, "secA=%d ", tr->secA);
fprintf(gbl.outfp, "primD=%d ", tr->primD);
fprintf(gbl.outfp, "secD=%d", tr->secD);
fprintf(gbl.outfp, "\n");
} // RSTF_Preg::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Preg::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_pregT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Preg::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Preg::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_pregT_get_cpuid(tr);
}
protected:
rstf_pregT* tr;
rstf_pregT* tr_orig;
}; // RSTF_Preg
//======================================================================
//======================================================================
class RSTF_Physaddr : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.physaddrcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "physadd : ");
fprintf(gbl.outfp, "pc_pa=0x%08llx ", tr->pc_pa);
if (tr->ea_valid) {
fprintf(gbl.outfp, "ea_pa=0x%08llx ", tr->ea_pa);
} else {
fprintf(gbl.outfp, "((ea_pa=0x%08llx)) ", tr->ea_pa);
}
fprintf(gbl.outfp, "ea_valid=%d", tr->ea_valid);
fprintf(gbl.outfp, "\n");
} // RSTF_Physaddr::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Physaddr::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_physaddrT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Physaddr::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Physaddr::reset_tr()
protected:
rstf_physaddrT* tr;
rstf_physaddrT* tr_orig;
}; // RSTF_Physaddr
#define PAVADIFF_MASK (0x1fff) // lower 13 bits
//======================================================================
//======================================================================
class RSTF_Pavadiff : public Trace {
public:
virtual void count() {
static uint64_t prev_pc_pa_va = 0;
gbl.rcount++;
gbl.pavadiffcount++;
if (gbl.pc_pavadiff) {
if (tr->pc_pa_va != prev_pc_pa_va) {
prev_pc_pa_va = tr->pc_pa_va;
if (tr->pc_pa_va & PAVADIFF_MASK) {
fprintf(gbl.msgfp, "trconv: warning: pc pa-va error "
"(#%llu pc_pa_va=0x%llx not multiple of pagesize)\n",
gbl.rcount - 1, tr->pc_pa_va);
}
}
if (tr->ea_valid) {
if (tr->ea_pa_va & PAVADIFF_MASK) {
fprintf(gbl.msgfp, "trconv: warning: ea pa-va error "
"(#%llu ea_pa_va=0x%llx not multiple of pagesize)\n",
gbl.rcount - 1, tr->ea_pa_va);
}
}
}
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "pavadiff: cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "icontext=%d ", tr->icontext);
fprintf(gbl.outfp, "dcontext=%d ", tr->dcontext);
fprintf(gbl.outfp, "pc_pa_va=0x%016llx ", tr->pc_pa_va);
if (tr->ea_valid) {
fprintf(gbl.outfp, "ea_pa_va=0x%016llx ", tr->ea_pa_va);
} else {
fprintf(gbl.outfp, "((ea_pa_va=0x%016llx)) ", tr->ea_pa_va);
}
fprintf(gbl.outfp, "ea_valid=%d", tr->ea_valid);
fprintf(gbl.outfp, "\n");
} // RSTF_Pavadiff::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Pavadiff::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_pavadiffT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Pavadiff::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Pavadiff::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_pavadiffT_get_cpuid(tr);
}
protected:
rstf_pavadiffT* tr;
rstf_pavadiffT* tr_orig;
}; // RSTF_Pavadiff
//======================================================================
//======================================================================
class RSTF_Filemarker : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.filemarkercount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->recNum == 0) {
// FILEMARKER_T
fprintf(gbl.outfp, "filemark: ");
fprintf(gbl.outfp, "recNum=%u ", tr->recNum);
fprintf(gbl.outfp, "level=%u ", tr->level);
fprintf(gbl.outfp, "incount=%llu ", tr->incount);
fprintf(gbl.outfp, "outcount=%llu", tr->outcount);
fprintf(gbl.outfp, "\n");
}
else {
// RECNUM_T
rstf_recnumT *ttr = (rstf_recnumT *)tr;
fprintf(gbl.outfp, "recnum : cpuid=%d ", gbl.rstf_pre212? tr->cpuID: rstf_filemarkerT_get_cpuid(tr));
fprintf(gbl.outfp, "recNum=%u ", ttr->recNum);
fprintf(gbl.outfp, "level=%u ", ttr->level);
fprintf(gbl.outfp, "level=%d ", ttr->recType);
fprintf(gbl.outfp, "incount=%llu", ttr->incount);
fprintf(gbl.outfp, "\n");
}
} // RSTF_Filemarker::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Filemarker::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_filemarkerT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Filemarker::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Filemarker::reset_tr()
protected:
rstf_filemarkerT* tr;
rstf_filemarkerT* tr_orig;
}; // RSTF_Filemarker
//======================================================================
//======================================================================
class RSTF_Status : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.statuscount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "status : ");
fprintf(gbl.outfp, "status=");
switch (tr->status) {
case RST_EOF:
fprintf(gbl.outfp, "RST_EOF\n");
break;
case RST_ERROR:
fprintf(gbl.outfp, "RST_ERROR\n");
break;
case RST_STATUS_END:
fprintf(gbl.outfp, "RST_STATUS_END\n");
break;
default:
fprintf(gbl.outfp, "Unknown status id: %d\n", tr->status);
}
} // RSTF_Status::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Status::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_statusT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Status::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Status::reset_tr()
protected:
rstf_statusT* tr;
rstf_statusT* tr_orig;
}; // RSTF_Status
//======================================================================
//======================================================================
class RSTF_Patch : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.patchcount++;
}
virtual void print_rec(uint64_t idx) {
char text[16] = {0};
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "patch : ");
fprintf(gbl.outfp, "isbegin=%d ", tr->isBegin);
fprintf(gbl.outfp, "rewindrecs=%d ", tr->rewindrecs);
fprintf(gbl.outfp, "id=%d ", tr->id);
fprintf(gbl.outfp, "length=%d ", tr->length);
fprintf(gbl.outfp, "descr=%s", memcpy(text, tr->descr, 8));
fprintf(gbl.outfp, "\n");
} // RSTF_Patch::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Patch::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_patchT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Patch::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Patch::reset_tr()
protected:
rstf_patchT* tr;
rstf_patchT* tr_orig;
}; // RSTF_Patch
//======================================================================
//======================================================================
class RSTF_Hwinfo : public Trace {
//FIXME nothing is defined yet, stay tune.
}; // RSTF_Hwinfo
//======================================================================
//======================================================================
class RSTF_Memval64 : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.memval64count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "mem64 : ");
//fprintf(gbl.outfp, "128=%1d ", tr->ismemval128);
fprintf(gbl.outfp, "isVA=%1d ", tr->addrisVA);
//fprintf(gbl.outfp, "cont=%1d ", tr->isContRec);
//fprintf(gbl.outfp, "zero5=%1d ", tr->zero5);
fprintf(gbl.outfp, "cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "sz=%d ", tr->size);
fprintf(gbl.outfp, "addr=0x%016llx ", tr->addr);
fprintf(gbl.outfp, "val=0x%llx ", tr->val);
fprintf(gbl.outfp, "\n");
} // RSTF_Memval64::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Memval64::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_memval64T*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Memval64::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Memval64::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_memval64T_get_cpuid(tr);
}
protected:
rstf_memval64T* tr;
rstf_memval64T* tr_orig;
}; // RSTF_Memval64
//======================================================================
//======================================================================
class RSTF_Memval128 : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.memval128count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "mem128 : ");
//fprintf(gbl.outfp, "128=%1d ", tr->ismemval128);
fprintf(gbl.outfp, "isVA=%1d ", tr->addrisVA);
fprintf(gbl.outfp, "cont=%1d ", tr->isContRec);
//fprintf(gbl.outfp, "zero5=%1d ", tr->zero5);
fprintf(gbl.outfp, "cpuid=%d ", getCpuID());
if (tr->isContRec == 0) {
fprintf(gbl.outfp, "addr=0x%016llx ", makeAddr());
}
fprintf(gbl.outfp, "val[0]=0x%llx ", tr->val[0]);
fprintf(gbl.outfp, "val[1]=0x%llx ", tr->val[1]);
fprintf(gbl.outfp, "\n");
} // RSTF_Memval128::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Memval128::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_memval128T*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Memval128::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Memval128::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_memval128T_get_cpuid(tr);
}
protected:
rstf_memval128T* tr;
rstf_memval128T* tr_orig;
uint64_t makeAddr() {
int64_t addr = 0;
int8_t* paddr = (int8_t*) &addr;
if (tr->isContRec == 0) {
paddr[0] = tr->addr36_43;
addr >>= 20;
addr |= (tr->addr04_35 << 4);
}
return (uint64_t) addr;
}
}; // RSTF_Memval128
//======================================================================
//======================================================================
class RSTF_Bustrace : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.bustracecount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "bustrace: ");
fprintf(gbl.outfp, "dv=%1d ", tr->dirtyvictim);
fprintf(gbl.outfp, "sh=%1d ", tr->shared);
fprintf(gbl.outfp, "own=%1d ", tr->owned);
fprintf(gbl.outfp, "mc=%1d ", tr->memcancel);
//fprintf(gbl.outfp, "bt_type=%2d ", tr->bt_type);
fprintf(gbl.outfp, "txType=%2d ", tr->txType);
fprintf(gbl.outfp, "aid=%2d ", tr->agentid);
fprintf(gbl.outfp, "tscale=%1d ", tr->nsScale);
fprintf(gbl.outfp, "ts=%7d ", tr->timestamp);
fprintf(gbl.outfp, "addr=0x%016llx ", tr->addr_pa);
fprintf(gbl.outfp, "\n");
} // RSTF_Bustrace::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Bustrace::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_bustraceT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Bustrace::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Bustrace::reset_tr()
protected:
rstf_bustraceT* tr;
rstf_bustraceT* tr_orig;
}; // RSTF_Bustrace
//======================================================================
//======================================================================
class RSTF_Snoop : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.snoopcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->device_type == DEVICE_CPU) {
fprintf(gbl.outfp, "snoop : cpuid=%d ", tr->device_id);
}
else {
fprintf(gbl.outfp, "snoop : unknown device=%d ", tr->device_id);
}
switch(tr->snoopreq) {
case SNOOP_RTO:
fprintf(gbl.outfp, "RTO ");
break;
case SNOOP_RTS:
fprintf(gbl.outfp, "RTS ");
break;
default:
fprintf(gbl.outfp, "Unknown snoop type ");
break;
}
fprintf(gbl.outfp, "[0x%016llx]\n", tr->addr_pa);
} // RSTF_Snoop::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Snoop::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_snoopT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Snoop::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Snoop::reset_tr()
protected:
rstf_snoopT* tr;
rstf_snoopT* tr_orig;
}; // RSTF_Snoop
class RSTF_tsb_access : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.tsb_access_count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp, "%6lld ", idx);
}
fprintf(gbl.outfp, "tsbaccess: cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "%s ", (tr->isdata? "DTSB": "ITSB"));
fprintf(gbl.outfp, "pa=0x%016llx\n", tr->pa);
} // RSTF_tsb_access::print_rec()
virtual void inc_tr() {
tr++;
}
virtual void set_tr(void * ptr, bool set_orig = true) {
tr = (rstf_tsb_accessT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_tsb_access::set_tr()
virtual void reset_tr() {
tr = tr_orig;
}
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_tsb_accessT_get_cpuid(tr);
}
protected:
rstf_tsb_accessT * tr;
rstf_tsb_accessT * tr_orig;
}; // class RSTF_tsb_access : public Trace
class RSTF_rfs_section_header : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.rfs_section_header_count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp, "%6lld ", idx);
}
fprintf(gbl.outfp, "rfs_section_header: ");
switch(tr->section_type) {
case RFS_CW_T:
fprintf(gbl.outfp, "CacheWarming: ");
break;
case RFS_BT_T:
fprintf(gbl.outfp, "BranchTrace: ");
break;
case RFS_RST_T:
fprintf(gbl.outfp, "RST Trace: ");
break;
default:
fprintf(gbl.outfp, "Unknown Type: ");
break;
}
if (tr->n_records == rfs_unknown_nrecords) {
fprintf(gbl.outfp, "All remaining records\n");
} else {
fprintf(gbl.outfp, "%lld records\n", tr->n_records);
}
}
virtual void inc_tr() {
tr++;
} // RSTF_Snoop::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_rfs_section_headerT *) ptr;
if (set_orig) {
tr_orig = tr;
}
}
virtual void reset_tr() {
tr = tr_orig;
}
protected:
rstf_rfs_section_headerT * tr;
rstf_rfs_section_headerT * tr_orig;
}; // class RSTF_rfs_section_header : public Trace
class RSTF_bpwarming : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.bpwarming_count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp, "%6lld ", idx);
}
fprintf(gbl.outfp, "bpwarm : ");
char dis_string[80];
sprintDiss(dis_string, tr->instr, tr->pc_va);
fprintf(gbl.outfp, "cpuid=%d [0x%016llx] %08x %-32s %c [0x%016llx]", getCpuID(), tr->pc_va, tr->instr, dis_string, (tr->taken? 'T' : 'N'), tr->npc_va);
}
virtual void inc_tr() {
tr++;
} // RSTF_Snoop::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_bpwarmingT *) ptr;
if (set_orig) {
tr_orig = tr;
}
}
virtual void reset_tr() {
tr = tr_orig;
}
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_bpwarmingT_get_cpuid(tr);
}
protected:
rstf_bpwarmingT * tr;
rstf_bpwarmingT * tr_orig;
}; // class Rstf_bpwarming: public Trace
class RSTF_cachewarming : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.cachewarming_count++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp, "%6lld ", idx);
}
fprintf(gbl.outfp, "cachewarm: ");
fprintf(gbl.outfp, "cpuid=%d ", getCpuID());
switch(tr->reftype) {
case cw_reftype_I:
fprintf(gbl.outfp, "ifetch ");
break;
case cw_reftype_R:
fprintf(gbl.outfp, "load ");
break;
case cw_reftype_W:
fprintf(gbl.outfp, "store ");
break;
case cw_reftype_PF_I:
fprintf(gbl.outfp, "i-prefetch ");
break;
case cw_reftype_PF_D:
fprintf(gbl.outfp, "d-prefetch ");
break;
case cw_reftype_DMA_R:
fprintf(gbl.outfp, "dma-read ");
break;
case cw_reftype_DMA_W:
fprintf(gbl.outfp, "dma-write ");
break;
default:
fprintf(gbl.outfp, "unknown reftype ");
break;
}
if (tr->reftype == cw_reftype_DMA_R || tr->reftype == cw_reftype_DMA_W) {
fprintf(gbl.outfp, "pa=0x%016llx size=%08x\n", tr->pa, tr->refinfo.dma_size);
} else {
fprintf(gbl.outfp, "asi=%02x ", tr->refinfo.s.asi);
fprintf(gbl.outfp, "va=0x%016llx pa=0x%016llx ", tr->va, tr->pa);
if (tr->reftype == cw_reftype_PF_D) {
fprintf(gbl.outfp, "fcn=%d\n", tr->refinfo.s.fcn);
} else {
fprintf(gbl.outfp, "\n");
}
}
}
virtual void inc_tr() {
tr++;
} // RSTF_Snoop::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_cachewarmingT *) ptr;
if (set_orig) {
tr_orig = tr;
}
}
virtual void reset_tr() {
tr = tr_orig;
}
virtual int getCpuID() {
return gbl.rstf_pre212 ? tr->cpuid : rstf_cachewarmingT_get_cpuid(tr);
}
protected:
rstf_cachewarmingT * tr;
rstf_cachewarmingT * tr_orig;
}; // class Rstf_cachewarming: public Trace
class RSTF_Trapping_Instr : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.trappinginstrcount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "tr_instr : cpuid=%d", rstf_trapping_instrT_get_cpuid(tr));
if (tr->hpriv) fprintf(gbl.outfp, " h"); else if (tr->priv) fprintf(gbl.outfp, " p"); else fprintf(gbl.outfp, " u");
fprintf(gbl.outfp, " [0x%016llx] ", tr->pc_va);
if (tr->iftrap) {
fprintf(gbl.outfp, "ifetch_trap");
} else {
fprintf(gbl.outfp, "%08x", tr->instr);
// output decoded instr
if (tr->ea_va_valid) {
fprintf(gbl.outfp, " [%llx]", tr->ea_va);
if (tr->ea_pa_valid) {
fprintf(gbl.outfp, " ea_pa valid");
} else {
fprintf(gbl.outfp, " ea_pa INVALID");
}
} // if ea_va_valid
} // tr->iftrap?
fprintf(gbl.outfp, "\n");
} // RSTF_Trapexit::print_rec()
#if 0
virtual uint64_t get_pc() {
return tr->pc;
} // RSTF_Trapexit::get_pc()
#endif
virtual void inc_tr() {
tr++;
} // RSTF_Trapexit::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_trapping_instrT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Trapexit::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Trapexit::reset_tr()
virtual int getCpuID() {
return gbl.rstf_pre212? tr->cpuid: rstf_trapping_instrT_get_cpuid(tr);
}
protected:
rstf_trapping_instrT* tr;
rstf_trapping_instrT* tr_orig;
}; // RSTF_TRAPPING_INSTR_T
//======================================================================
//======================================================================
class RSTF_Timesync : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.timesynccount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "timesync: cpuid=%d ", getCpuID());
fprintf(gbl.outfp, "seqnum=%llu ", tr->sequence_number);
switch(tr->subtype) {
case rstf_timesyncT_local:
fprintf(gbl.outfp, "local");
break;
case rstf_timesyncT_global:
fprintf(gbl.outfp, "global");
break;
default:
fprintf(gbl.outfp, "unknown-sync-type");
break;
}
fprintf(gbl.outfp, "\n");
} // RSTF_Timesync::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_TimeSync::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_timesyncT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Timesync::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Timesync::reset_tr()
virtual int getCpuID() {
return rstf_timesyncT_get_cpuid(tr);
}
protected:
rstf_timesyncT* tr;
rstf_timesyncT* tr_orig;
}; // RSTF_Timesync
//======================================================================
//======================================================================
class RSTF_Devidstr : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.devidstrcount++;
}
virtual void print_rec(uint64_t idx) {
static uint32_t id;
static std::string idstring;
char cstr[20];
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->id != rstf_devidstr_continuation_id) {
id = tr->id;
}
int i;
for (i=0; i<19; i++) {
if (tr->str[i] != '\0') {
idstring += tr->str[i];
cstr[i] = tr->str[i];
} else {
break;
}
}
cstr[i] = 0;
fprintf(gbl.outfp, "devidstr: id=%d \"%s\"\n", id, cstr);
if (i < 19) {
gbl.devid2string[tr->id] = idstring;
idstring.clear();
}
} // RSTF_Devidstr::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Devidstr::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_devidstrT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Devidstr::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Devidstr::reset_tr()
protected:
rstf_devidstrT* tr;
rstf_devidstrT* tr_orig;
}; // RSTF_Devidstr
//======================================================================
//======================================================================
class RSTF_Zero : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.zerocount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld\t\tZero Record", idx);
}
} // RSTF_Zero::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Zero::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_xxxT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Zero::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Zero::reset_tr()
protected:
rstf_xxxT* tr;
rstf_xxxT* tr_orig;
}; // RSTF_Zero
//======================================================================
//======================================================================
class RSTF_Unknown : public Trace {
public:
virtual void count() {
gbl.rcount++;
gbl.unknowncount++;
}
virtual void print_rec(uint64_t idx) {
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "unknown : [Unsupported record type; rtype=%d]\n",
tr->rtype);
} // RSTF_Unknown::print_rec()
virtual void inc_tr() {
tr++;
} // RSTF_Unknown::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_protoT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Unknown::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Unknown::reset_tr()
protected:
rstf_protoT* tr;
rstf_protoT* tr_orig;
}; // RSTF_Unknown
//======================================================================
//======================================================================
class RSTF_Union : public Trace {
public:
virtual void count() {
Trace* tr_trace;
#if defined(ARCH_AMD64)
rstf_convertT::b2l((rstf_uint8T *)tr);
#endif
tr_trace = get_rst_type();
if (tr_trace != NULL) {
tr_trace->set_tr(tr, false);
tr_trace->count();
}
} // RSTF_Union::count()
virtual void print_dasm(uint64_t idx) {
Trace* tr_trace;
print_header();
if (gbl.onlyIns) {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
tr_instr.print_dasm(idx);
}
} else {
tr_trace = get_rst_type();
if (gbl.noIns && tr->proto.rtype == INSTR_T) {
tr_trace = NULL;
}
if (tr_trace) {
tr_trace->set_tr(tr, false);
tr_trace->print_dasm(idx);
}
}
} // RSTF_Union::print_dasm()
virtual void print_rec(uint64_t idx) {
Trace* tr_trace;
print_header();
if (gbl.onlyIns) {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
tr_instr.print_rec(idx);
}
} else {
tr_trace = get_rst_type();
if (gbl.noIns && tr->proto.rtype == INSTR_T) {
tr_trace = NULL;
}
if (tr_trace) {
tr_trace->set_tr(tr, false);
tr_trace->print_rec(idx);
}
}
} // RSTF_Union::print_rec()
virtual void print_verb(uint64_t idx) {
Trace* tr_trace;
print_header();
if (gbl.onlyIns) {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
tr_instr.print_verb(idx);
}
} else {
tr_trace = get_rst_type();
if (gbl.noIns && tr->proto.rtype == INSTR_T) {
tr_trace = NULL;
}
if (tr_trace) {
tr_trace->set_tr(tr, false);
tr_trace->print_verb(idx);
}
}
} // RSTF_Union::print_verb()
virtual void convert_to_master() {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
tr_instr.convert_to_master();
}
} // RSTF_Union::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr_instr.set_tr(tr, false);
tr_instr.convert_from_master(master);
} // RSTF_Union::convert_from_master()
virtual void gen_ihash() {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
tr_instr.gen_ihash();
}
} // RSTF_Union::gen_ihash()
virtual int check_ihash_error() {
if (tr->proto.rtype == INSTR_T) {
tr_instr.set_tr(tr, false);
return tr_instr.check_ihash_error();
}
return 0;
} // RSTF_Union::check_ihash_error()
// check pc value of last NUM_VERIFY records in buffer
virtual void verify() {
tr_instr.set_tr(tr_orig, true);
tr_instr.set_tr(tr, false);
tr_instr.verify();
} // RSTF_Union::verify()
virtual uint64_t get_pc() {
switch (tr->proto.rtype) {
case INSTR_T:
return tr->instr.pc_va;
case TRAP_T:
return tr->trap.pc;
#if 0
case TRAPEXIT_T:
return tr->trapexit.pc;
#endif
}
return RSTF_NOADDR;
} // RSTF_Union::get_pc()
virtual uint64_t get_ea() {
if (tr->proto.rtype == INSTR_T) {
if (tr->instr.ea_valid) {
return tr->instr.ea_va;
}
}
return RSTF_NOADDR;
} // RSTF_Union::get_ea()
virtual int get_ihash() {
if (tr->proto.rtype == INSTR_T) {
return spix_sparc_iop(SPIX_SPARC_V9, &tr->instr.instr);
// return tr->instr.ihash;
}
return 0;
} // RSTF_Union::get_ihash()
virtual void inc_tr() {
tr++;
} // RSTF_Union::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (rstf_unionT*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // RSTF_Union::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // RSTF_Union::reset_tr()
virtual rstf_unionT* copy_from_rst() {
return tr;
} // RSTF_Union::copy_from_rst()
virtual void copy_to_rst(rstf_unionT* from) {
*tr = *from;
} // RSTF_Union::copy_to_rst()
virtual int getCpuID() {
return get_rst_type()->getCpuID();
}
protected:
rstf_unionT* tr;
rstf_unionT* tr_orig;
RSTF_Header tr_header;
RSTF_Instr tr_instr;
//RSTF_Asi tr_asi;
RSTF_Traceinfo tr_traceinfo;
RSTF_Tlb tr_tlb;
RSTF_Thread tr_thread;
RSTF_Trap tr_trap;
RSTF_Trapexit tr_trapexit;
RSTF_Trapping_Instr tr_trapping_instr;
RSTF_Bustrace tr_bustrace;
RSTF_Regval tr_regval;
RSTF_Memval64 tr_memval64;
RSTF_Memval128 tr_memval128;
RSTF_Cpu tr_cpu;
RSTF_Process tr_process;
RSTF_Dma tr_dma;
RSTF_String tr_string;
RSTF_Delim tr_delim;
RSTF_Preg tr_preg;
RSTF_Physaddr tr_physaddr;
RSTF_Pavadiff tr_pavadiff;
RSTF_Filemarker tr_filemarker;
RSTF_Status tr_status;
RSTF_Patch tr_patch;
//RSTF_Hwinfo tr_hwinfo;
//RSTF_Memval tr_memval;
RSTF_Snoop tr_snoop;
RSTF_tsb_access tr_tsb_access;
RSTF_rfs_section_header tr_rfs_shdr;
RSTF_bpwarming tr_bpwarming;
RSTF_cachewarming tr_cachewarming;
RSTF_Timesync tr_timesync;
RSTF_Devidstr tr_devidstr;
RSTF_Zero tr_zero;
RSTF_Unknown tr_unknown;
Trace* get_rst_type() {
int cpuid = -1;
switch (tr->proto.rtype) {
case RSTHEADER_T:
return &tr_header;
case INSTR_T:
return &tr_instr;
//case ASI_T: // ASI is deprecated. ASI_T == TRACEINFO_T
//return &tr_asi;
case TRACEINFO_T:
return &tr_traceinfo;
case TLB_T:
return &tr_tlb;
case THREAD_T:
return &tr_thread;
case TRAP_T:
return &tr_trap;
case TRAPEXIT_T:
return &tr_trapexit;
case TRAPPING_INSTR_T:
return & tr_trapping_instr;
case BUSTRACE_T:
return &tr_bustrace;
case REGVAL_T:
return &tr_regval;
case MEMVAL_T:
if (tr->memval64.ismemval128) {
return &tr_memval128;
}
return &tr_memval64;
case CPU_T: // CPU_T == TIMESTAMP_T
return &tr_cpu;
case PROCESS_T:
return &tr_process;
case DMA_T:
return &tr_dma;
case STRDESC_T:
case STRCONT_T:
return &tr_string;
case LEFTDELIM_T:
case RIGHTDELIM_T:
return &tr_delim;
case PREG_T:
gbl.pstate[gbl.rstf_pre212? tr->preg.cpuid: rstf_pregT_get_cpuid(&tr->preg)] = tr->preg.pstate;
return &tr_preg;
case PHYSADDR_T:
return &tr_physaddr;
case PAVADIFF_T:
#ifdef _PRINT_PA
cpuid = gbl.rstf_pre212? tr->pavadiff.cpuid: rstf_pavadiffT_get_cpuid(&tr->pavadiff);
if (tr->pavadiff.ea_valid) {
gbl.ea_pavadiff_valid[cpuid] = true;
gbl.ea_pavadiff_value[cpuid] = tr->pavadiff.ea_pa_va;
}
gbl.pc_pavadiff_value[cpuid] = tr->pavadiff.pc_pa_va;
gbl.pc_pavadiff_valid[cpuid] = true;
#endif
return &tr_pavadiff;
case FILEMARKER_T: // FILEMARKER_T == RECNUM_T
return &tr_filemarker;
case STATUS_T:
return &tr_status;
case PATCH_T:
return &tr_patch;
case HWINFO_T:
//return &tr_hwinfo;
return &tr_unknown;
case SNOOP_T:
return &tr_snoop;
case TSB_ACCESS_T:
return &tr_tsb_access;
case RFS_SECTION_HEADER_T:
return &tr_rfs_shdr;
case RFS_BT_T:
return & tr_bpwarming;
case RFS_CW_T:
return & tr_cachewarming;
case TIMESYNC_T:
return & tr_timesync;
case DEVIDSTR_T:
return & tr_devidstr;
case RST_ZERO_T:
return &tr_zero;
default:
return &tr_unknown;
}
} // RSTF_Union::get_rst_type()
void print_header() {
static bool prheader = true;
if (prheader) {
fprintf(gbl.outfp, "RST trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "================\n");
if (!gbl.noIns) {
if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp,
" User/ Branch\n"
" Rec # Type Priv PC Disassembly Taken EA \n");
} else {
fprintf(gbl.outfp,
" User/ Branch\n"
"Type Priv PC Disassembly Taken EA \n");
}
} else if (gbl.verbose) {
if (gbl.showIdx) {
fprintf(gbl.outfp,
" User/ Br\n"
" Rec # Type Priv PC Disassembly Instr Word IH Tk EA (x = invalid ea)\n");
} else {
fprintf(gbl.outfp,
" User/ Br\n"
"Type Priv PC Disassembly Instr Word IH Tk EA (x = invalid ea)\n");
}
}
}
prheader = false;
}
} // RSTF_Union::print_header()
}; // RSTF_Union
//======================================================================
//======================================================================
// Trtf99 and Tshade5 use Shade5 ihash values;
// all other formats use the Shade6 ihash values.
//
class rtf99 : public Trace {
public:
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
fprintf(gbl.outfp, "0x%x", tr->tr_misc);
fprintf(gbl.outfp, "\n");
} // rtf99::print_dasm()
virtual void print_rec(uint64_t idx) {
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
fprintf(gbl.outfp, "0x%x ", tr->tr_misc);
fprintf(gbl.outfp, "\n");
} // rtf99::print_rec()
virtual void print_verb(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
fprintf(gbl.outfp, "0x%x", tr->tr_misc);
fprintf(gbl.outfp, "\n");
} // rtf99::print_verb()
virtual void convert_to_master() {
this_master.tr_pc_va = tr->tr_pc;
this_master.tr_ea_va = tr->tr_ea ;
this_master.tr_tid = 0;
this_master.tr_ih = tr->tr_ih;
this_master.tr_reserved0 = 0;
this_master.tr_taken = tr->tr_misc & 1;
this_master.tr_annulled = (tr->tr_misc << 1) & 1;
this_master.tr_iwstart = 0;
this_master.tr_i = tr->tr_i;
this_master.tr_reserved1 = 0;
this_master.tr_pc_pa = 0;
this_master.tr_ea_pa = 0;
this_master.tr_context = 0;
this_master.tr_asi = 0;
this_master.tr_got_trap = 0;
this_master.tr_asi_change = 0;
this_master.tr_privmode = 0;
} // rtf99::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr->tr_pc = (uint32_t)master->tr_pc_va;
tr->tr_ea = (uint32_t)master->tr_ea_va;
tr->tr_ih = master->tr_ih;
tr->tr_misc = master->tr_taken + (master->tr_annulled >> 1);
tr->tr_i = master->tr_i;
} // rtf99::convert_from_master()
virtual void gen_ihash() {
tr->tr_ih = getIHash(tr->tr_i);
} // tfr99::gen_ihash()
virtual int check_ihash_error() {
if (tr->tr_ih != getIHash(tr->tr_i)) {
return 1;
}
return 0;
} // rtf99::check_ihash_error()
virtual void verify() {
Trtf99 * vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].tr_pc % 4 != 0 && RSTF_IS_BADADDR(vtr[i].tr_pc) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
} // rtf99::verify()
virtual uint64_t get_pc() {
return tr->tr_pc;
} // rtf99::get_pc()
virtual uint64_t get_ea() {
return tr->tr_ea;
} // rtf99::get_ea()
virtual int get_ihash() {
return tr->tr_ih;
} // rtf99::get_ihash()
virtual void inc_tr() {
tr++;
} // rtf99::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (Trtf99 *) ptr;
if (set_orig) {
tr_orig = tr;
}
} // rtf99::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // rtf99::reset_tr()
protected:
Trtf99 * tr;
Trtf99 * tr_orig;
void print_header() {
static bool prheader = false;
if (!prheader) {
fprintf(gbl.outfp, "rtf99 trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "====================\n");
if (gbl.record) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # tr_pc tr_i "
"tr_ih tr_ea misc\n");
} else {
fprintf(gbl.outfp, " tr_pc tr_i "
"tr_ih tr_ea misc\n");
}
} else if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # PC Disassembly"
" EA Misc\n");
} else {
fprintf(gbl.outfp, " PC Disassembly"
" EA Misc\n");
}
} else {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # PC Disassembly"
" Instr Word IH EA\n");
} else {
fprintf(gbl.outfp, " PC Disassembly"
" Instr Word IH EA\n");
}
}
prheader = true;
}
} // rtf99::print_header()
}; // rtf99
// Trtf99 and Tshade5 use Shade5 ihash values;
// all other formats use the Shade6 ihash values.
class Shade5 : public Trace {
public:
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
} else {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
}
fprintf(gbl.outfp, "\n");
} // Shade5::print_dasm()
virtual void print_rec(uint64_t idx) {
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
fprintf(gbl.outfp, "%d ", tr->tr_annulled);
fprintf(gbl.outfp, "\n");
} // Shade5::print_rec()
virtual void print_verb(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
}
fprintf(gbl.outfp, "\n");
} // Shade5::print_verb()
virtual void convert_to_master() {
this_master.tr_pc_va = tr->tr_pc;
this_master.tr_ea_va = tr->tr_ea ;
this_master.tr_tid = 0;
this_master.tr_ih = tr->tr_ih;
this_master.tr_reserved0 = 0;
this_master.tr_taken = tr->tr_taken;
this_master.tr_annulled = tr->tr_annulled;
this_master.tr_iwstart = 0;
this_master.tr_i = tr->tr_i;
this_master.tr_reserved1 = 0;
this_master.tr_pc_pa = 0;
this_master.tr_ea_pa = 0;
this_master.tr_context = 0;
this_master.tr_asi = 0;
this_master.tr_got_trap = 0;
this_master.tr_asi_change = 0;
this_master.tr_privmode = 0;
} // Shade5::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr->tr_pc = (uint32_t) master->tr_pc_va;
tr->tr_ea = (uint32_t) master->tr_ea_va;
tr->tr_ih = master->tr_ih;
tr->tr_taken = master->tr_taken;
tr->tr_annulled = master->tr_annulled;
tr->tr_i = master->tr_i;
} // Shade5::convert_from_master()
virtual void gen_ihash() {
tr->tr_ih = getIHash(tr->tr_i);
} // Shade5::gen_ihash()
virtual int check_ihash_error() {
if (tr->tr_ih != getIHash(tr->tr_i)) {
return 1;
}
return 0;
} // Shade5::check_ihash_error()
virtual void verify() {
Tshade5* vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].tr_pc % 4 != 0 && RSTF_IS_BADADDR(vtr[i].tr_pc) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
} // Shade5::verify()
virtual uint64_t get_pc() {
return tr->tr_pc;
} // Shade5::get_pc()
virtual uint64_t get_ea() {
return tr->tr_ea;
} // Shade5::get_ea()
virtual int get_ihash() {
return tr->tr_ih;
} // Shade5::get_ihash()
virtual void inc_tr() {
tr++;
} // Shade5::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (Tshade5*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // Shade5::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // Shade5::reset_tr()
protected:
Tshade5* tr;
Tshade5* tr_orig;
void print_header() {
static bool prheader = true;
if (prheader) {
fprintf(gbl.outfp, "Shade5 trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "=====================\n");
if (gbl.record) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # tr_pc tr_i "
"tr_ih tr_ea an\n");
} else {
fprintf(gbl.outfp, " tr_pc tr_i "
"tr_ih tr_ea an\n");
}
} else if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Tk EA\n");
}
} else {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Instr Word IH Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Instr Word IH Tk EA\n");
}
}
prheader = false;
}
}
}; // Shade5
class Shade6x32 : public Trace {
public:
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
} else {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
}
if (tr->tr_tid) {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_tid);
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Shade6x32::print_dasm()
virtual void print_rec(uint64_t idx) {
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
fprintf(gbl.outfp, "%d ", tr->tr_annulled);
fprintf(gbl.outfp, "%d ", tr->tr_iwstart);
fprintf(gbl.outfp, "0x%08x ", tr->tr_tid);
fprintf(gbl.outfp, "\n");
} // Shade6x32::print_rec()
virtual void print_verb(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_ea);
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr_tid) {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_tid);
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Shade6x32::print_verb()
virtual void convert_to_master() {
this_master.tr_pc_va = tr->tr_pc;
this_master.tr_ea_va = tr->tr_ea ;
this_master.tr_tid = tr->tr_tid;
this_master.tr_ih = tr->tr_ih;
this_master.tr_reserved0 = tr->tr_shade_reserved0;
this_master.tr_taken = tr->tr_taken;
this_master.tr_annulled = tr->tr_annulled;
this_master.tr_iwstart = tr->tr_iwstart;
this_master.tr_i = tr->tr_i;
this_master.tr_reserved1 = tr->tr_shade_reserved1;
this_master.tr_pc_pa = 0;
this_master.tr_ea_pa = 0;
this_master.tr_context = 0;
this_master.tr_asi = 0;
this_master.tr_got_trap = 0;
this_master.tr_asi_change = 0;
this_master.tr_privmode = 0;
} // Shade6x32::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr->tr_pc = (uint32_t)master->tr_pc_va;
tr->tr_ea = (uint32_t)master->tr_ea_va ;
tr->tr_tid = master->tr_tid;
tr->tr_ih = master->tr_ih;
tr->tr_ih = tr->tr_ih;
tr->tr_shade_reserved0 = master->tr_reserved0;
tr->tr_taken = master->tr_taken;
tr->tr_annulled = master->tr_annulled;
tr->tr_iwstart = master->tr_iwstart;
tr->tr_i = master->tr_i;
tr->tr_shade_reserved1 = master->tr_reserved1;
} // Shade6x32::convert_from_master()
virtual void gen_ihash() {
tr->tr_ih = getIHash(tr->tr_i);
} // Shade6x32::gen_ihash()
virtual int check_ihash_error() {
if (tr->tr_ih != getIHash(tr->tr_i)) {
return 1;
}
return 0;
} // Shade6x32::check_ihash_error()
virtual void verify() {
Tshade6x32* vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].tr_pc % 4 != 0 && RSTF_IS_BADADDR(vtr[i].tr_pc) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
} // Shade6x32::verify()
virtual uint64_t get_pc() {
return tr->tr_pc;
} // Shade6x32::get_pc()
virtual uint64_t get_ea() {
return tr->tr_ea;
} // Shade6x32::get_ea()
virtual int get_ihash() {
return tr->tr_ih;
} // Shade6x32::get_ihash()
virtual void inc_tr() {
tr++;
} // Shade6x32::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (Tshade6x32*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // Shade6x32::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // Shade6x32::reset_tr()
protected:
Tshade6x32* tr;
Tshade6x32* tr_orig;
void print_header() {
static bool prheader = true;
if (prheader) {
fprintf(gbl.outfp, "Shade6 (32bit) trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "=============================\n");
if (gbl.record) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # tr_pc tr_i "
"tr_ih tr_ea a w tr_tid\n");
} else {
fprintf(gbl.outfp, " tr_pc tr_i "
"tr_ih tr_ea a w tr_tid\n");
}
} else if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Tk EA\n");
}
} else {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Instr Word IH Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Instr Word IH Tk EA\n");
}
}
prheader = false;
}
}
}; // Shade6x32
class Shade6x64 : public Trace {
public:
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
} else {
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_ea);
}
if (tr->tr_tid) {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_tid);
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Shade6x64::print_dasm()
virtual void print_rec(uint64_t idx) {
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_ea);
fprintf(gbl.outfp, "%d ", tr->tr_annulled);
fprintf(gbl.outfp, "%d ", tr->tr_iwstart);
fprintf(gbl.outfp, "0x%08x ", tr->tr_tid);
fprintf(gbl.outfp, "\n");
} // Shade6x64::print_rec()
virtual void print_verb(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_ea);
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr_tid) {
fprintf(gbl.outfp, "[0x%08x] ", tr->tr_tid);
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Shade6x64::print_verb()
virtual void convert_to_master() {
this_master.tr_pc_va = tr->tr_pc;
this_master.tr_ea_va = tr->tr_ea ;
this_master.tr_tid = tr->tr_tid;
this_master.tr_ih = tr->tr_ih;
this_master.tr_reserved0 = tr->tr_shade_reserved0;
this_master.tr_taken = tr->tr_taken;
this_master.tr_annulled = tr->tr_annulled;
this_master.tr_iwstart = tr->tr_iwstart;
this_master.tr_i = tr->tr_i;
this_master.tr_reserved1 = tr->tr_shade_reserved1;
this_master.tr_pc_pa = 0;
this_master.tr_ea_pa = 0;
this_master.tr_context = 0;
this_master.tr_asi = 0;
this_master.tr_got_trap = 0;
this_master.tr_asi_change = 0;
this_master.tr_privmode = 0;
} // Shade6x64::convert_to_master()
virtual void convert_from_master(Tmaster64* master) {
tr->tr_pc = master->tr_pc_va;
tr->tr_ea = master->tr_ea_va ;
tr->tr_tid = master->tr_tid;
tr->tr_ih = master->tr_ih;
tr->tr_shade_reserved0 = master->tr_reserved0;
tr->tr_taken = master->tr_taken;
tr->tr_annulled = master->tr_annulled;
tr->tr_iwstart = master->tr_iwstart;
tr->tr_i = master->tr_i;
tr->tr_shade_reserved1 = master->tr_reserved1;
} // Shade6x64::convert_from_master()
virtual void gen_ihash() {
tr->tr_ih = getIHash(tr->tr_i);
} // Shade6x64::gen_ihash()
virtual int check_ihash_error() {
if (tr->tr_ih != getIHash(tr->tr_i)) {
return 1;
}
return 0;
} // Shade6x64::check_ihash_error()
virtual void verify() {
Tshade6x64* vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].tr_pc % 4 != 0 && RSTF_IS_BADADDR(vtr[i].tr_pc) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
} // Shade6x64::verify()
virtual uint64_t get_pc() {
return tr->tr_pc;
} // Shade6x64::get_pc()
virtual uint64_t get_ea() {
return tr->tr_ea;
} // Shade6x64::get_ea()
virtual int get_ihash() {
return tr->tr_ih;
} // Shade6x64::get_ihash()
virtual void inc_tr() {
tr++;
} // Shade6x64::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (Tshade6x64*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // Shade6x64::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // Shade6x64::reset_tr()
protected:
Tshade6x64* tr;
Tshade6x64* tr_orig;
void print_header() {
static bool prheader = true;
if (prheader) {
fprintf(gbl.outfp, "Shade6 (64bit) trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "=============================\n");
if (gbl.record) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # tr_pc tr_i "
"tr_ih tr_ea a w tr_tid\n");
} else {
fprintf(gbl.outfp, " tr_pc tr_i "
"tr_ih tr_ea a w tr_tid\n");
}
} else if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Tk EA\n");
}
} else {
if (gbl.showIdx) {
fprintf(gbl.outfp, " "
" Br\n"
" Rec # PC Disassembly"
" Instr Word IH Tk EA\n");
} else {
fprintf(gbl.outfp, " "
" Br\n"
" PC Disassembly"
" Instr Word IH Tk EA\n");
}
}
prheader = false;
}
} // Shade6x64::print_header()
}; // Shade6x64
class Master : public Trace {
public:
virtual void print_dasm(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc_va);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->tr_privmode) {
fprintf(gbl.outfp, "p ");
} else {
fprintf(gbl.outfp, "u ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc_va);
fprintf(gbl.outfp, "%-32s", dis_string);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
if (tr->tr_va_valid && !tr->tr_annulled) {
fprintf(gbl.outfp, "[0x%016llx]", tr->tr_ea_va);
}
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr_got_trap) {
fprintf(gbl.outfp, "tr ");
}
if (tr->tr_asi_change) {
fprintf(gbl.outfp, "asi ");
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Master::print_dasm()
virtual void print_rec(uint64_t idx) {
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
fprintf(gbl.outfp, " [0x%016llx] ", tr->tr_pc_va);
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc_pa);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
if (tr->tr_privmode) {
fprintf(gbl.outfp, " p ");
} else {
fprintf(gbl.outfp, " u ");
}
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_ea_va);
fprintf(gbl.outfp, "<0x%016llx> ", tr->tr_ea_pa);
fprintf(gbl.outfp, "%d ", tr->tr_va_valid);
fprintf(gbl.outfp, " %d ", tr->tr_annulled);
fprintf(gbl.outfp, " %d ", tr->tr_got_trap);
fprintf(gbl.outfp, " %d ", tr->tr_asi_change);
fprintf(gbl.outfp, "0x%04x", tr->tr_tid);
fprintf(gbl.outfp, " %d ", tr->tr_context);
fprintf(gbl.outfp, " %d ", tr->tr_asi);
fprintf(gbl.outfp, " %d ", tr->tr_iwstart);
fprintf(gbl.outfp, "\n");
} // Master::print_rec
virtual void print_verb(uint64_t idx) {
char dis_string[80];
sprintDiss(dis_string, tr->tr_i, tr->tr_pc_va);
print_header();
if (gbl.showIdx) {
fprintf(gbl.outfp , "%6lld ", idx);
}
if (tr->tr_privmode) {
fprintf(gbl.outfp, "p ");
} else {
fprintf(gbl.outfp, "u ");
}
fprintf(gbl.outfp, "[0x%016llx] ", tr->tr_pc_va);
fprintf(gbl.outfp, "<0x%016llx> ", tr->tr_pc_pa);
fprintf(gbl.outfp, "%-32s", dis_string);
fprintf(gbl.outfp, "(0x%08x) ", tr->tr_i);
fprintf(gbl.outfp, "%3d ", tr->tr_ih);
if (ih_iscti(tr->tr_ih)) {
if (tr->tr_taken) {
fprintf(gbl.outfp, "T ");
} else {
fprintf(gbl.outfp, "N ");
}
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "[0x%016llx]", tr->tr_ea_va);
if (!tr->tr_va_valid) {
fprintf(gbl.outfp, "x ");
} else {
fprintf(gbl.outfp, " ");
}
fprintf(gbl.outfp, "<0x%016llx> ", tr->tr_ea_pa);
if (tr->tr_annulled) {
fprintf(gbl.outfp, "an ");
}
if (tr->tr_got_trap) {
fprintf(gbl.outfp, "tr ");
}
if (tr->tr_asi_change) {
fprintf(gbl.outfp, "asi ");
}
if (tr->tr_iwstart) {
fprintf(gbl.outfp, "wi ");
}
fprintf(gbl.outfp, "\n");
} // Master::print_verb()
virtual void convert_to_master() {
this_master = *tr;
} // Master::convert_to_master
virtual void convert_from_master(Tmaster64* master) {
*tr = *master;
} // Master::convert_from_master()
virtual void gen_ihash() {
tr->tr_ih = getIHash(tr->tr_i);
} // Master::gen_ihash()
virtual int check_ihash_error() {
if (tr->tr_ih != getIHash(tr->tr_i)) {
return 1;
}
return 0;
} // Master::check_ihash_error()
virtual void verify() {
Tmaster64* vtr = tr - NUM_VERIFY;
int i;
for (i = 0; i < NUM_VERIFY - 1; i++) {
if (vtr[i].tr_pc_va % 4 != 0 && RSTF_IS_BADADDR(vtr[i].tr_pc_va) == 0) {
fprintf(stderr, "trconv: Error: Incorrect pc value in input file.\n");
set_tr(&vtr[i], false);
print_verb(gbl.rcount - NUM_VERIFY + i);
//exit(2);
}
}
} // Master::verify()
virtual uint64_t get_pc() {
return tr->tr_pc_va;
} // Master::get_pc()
virtual uint64_t get_ea() {
return tr->tr_ea_va;
} // Master::get_ea()
virtual int get_ihash() {
return tr->tr_ih;
} // Master::get_ihash()
virtual void inc_tr() {
tr++;
} // Master::inc_tr()
virtual void set_tr(void* ptr, bool set_orig = true) {
tr = (Tmaster64*) ptr;
if (set_orig) {
tr_orig = tr;
}
} // Master::set_tr()
virtual void reset_tr() {
tr = tr_orig;
} // Master::reset_tr()
protected:
Tmaster64* tr;
Tmaster64* tr_orig;
void print_header() {
static bool prheader = true;
if (prheader) {
fprintf(gbl.outfp, "Master trace format (%s)\n", gbl.infile);
fprintf(gbl.outfp, "===================\n");
if (gbl.record) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Rec # tr_pc_va tr_pc_pa "
"tr_i tr_ih tr_ea_va tr_ea_pa "
" va an gt ac tid cx a iw\n");
} else {
fprintf(gbl.outfp, " tr_pc_va tr_pc_pa "
"tr_i tr_ih tr_ea_va tr_ea_pa "
" va an gt ac tid cx a iw\n");
}
} else if (gbl.disassembly) {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Usr/ "
" Br\n"
" Rec # Pr PC Disassembly"
" Tk EA\n");
} else {
fprintf(gbl.outfp, "Usr/ "
" Br\n"
"Pr PC Disassembly"
" Tk EA\n");
}
} else {
if (gbl.showIdx) {
fprintf(gbl.outfp, " Usr/ "
" "
" Br\n"
" Rec # Pr PC (virtual) PC (physical)"
" Disassembly "
"Instr Word IH"
" Tk EA (virtual, x=inv) EA (physical)\n");
} else {
fprintf(gbl.outfp, "Usr/ "
" "
" Br\n"
"Pr PC (virtual) PC (physical)"
" Disassembly "
"Instr Word IH"
" Tk EA (virtual, x=inv) EA (physical)\n");
}
}
prheader = false;
} // Master::print_header()
}
}; // Master
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.