* Authors: Ali Saidi
*/
-#include "arch/utility.hh"
-#include "arch/alpha/linux/threadinfo.hh"
#include "base/cp_annotate.hh"
+
+#include "arch/generic/linux/threadinfo.hh"
+#include "arch/utility.hh"
#include "base/callback.hh"
#include "base/loader/object_file.hh"
#include "base/output.hh"
#include "base/trace.hh"
#include "config/the_isa.hh"
#include "cpu/thread_context.hh"
+#include "debug/Annotate.hh"
+#include "debug/AnnotateVerbose.hh"
#include "sim/arguments.hh"
#include "sim/core.hh"
#include "sim/sim_exit.hh"
registerExitCallback(new AnnotateDumpCallback(this));
}
+
+uint64_t
+CPA::getFrame(ThreadContext *tc)
+{
+ // This code is ISA specific and will need to be changed
+ // if the annotation code is used for something other than Alpha
+ return (tc->readMiscRegNoEffect(TheISA::IPR_PALtemp23) &
+ ~ULL(0x3FFF));
+
+}
+
void
CPA::swSmBegin(ThreadContext *tc)
{
debugSymbolTable->findNearestSymbol(
tc->readIntReg(ReturnAddressReg), st, junk);
- CopyStringOut(tc, sm, args[0], 50);
+ tc->getVirtProxy().readString(sm, args[0], 50);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
int smi = getSm(sysi, sm, args[1]);
DPRINTF(Annotate, "Starting machine: %s(%d) sysi: %d id: %#x\n", sm,
smi, sysi, args[1]);
- DPRINTF(Annotate, "smMap[%d] = %d, %s, %#x\n", smi,
- smMap[smi-1].first, smMap[smi-1].second.first,
+ DPRINTF(Annotate, "smMap[%d] = %d, %s, %#x\n", smi,
+ smMap[smi-1].first, smMap[smi-1].second.first,
smMap[smi-1].second.second);
uint64_t frame = getFrame(tc);
scLinks[sysi-1].erase(id);
an->stq = smi;
an->dump = true;
- DPRINTF(Annotate,
+ DPRINTF(Annotate,
"Found prev unknown linking from %d to state machine %s(%d)\n",
an->sm, sm, smi);
Arguments args(tc);
char sm[50];
- CopyStringOut(tc, sm, args[0], 50);
+ tc->getVirtProxy().readString(sm, args[0], 50);
System *sys = tc->getSystemPtr();
doSwSmEnd(sys, tc->contextId(), sm, getFrame(tc));
}
warn("State machine stack not unwinding correctly at %d\n", curTick());
} else {
- DPRINTF(Annotate,
+ DPRINTF(Annotate,
"State machine ending:%s sysi:%d id:%#x back:%d getSm:%d\n",
sm, sysi, smMap[smib-1].second.second, smStack[sid].back(),
getSm(sysi, sm, smMap[smib-1].second.second));
- assert(getSm(sysi, sm, smMap[smib-1].second.second) ==
+ assert(getSm(sysi, sm, smMap[smib-1].second.second) ==
smStack[sid].back());
int smi = smStack[sid].back();
Arguments args(tc);
char st[50];
- CopyStringOut(tc, st, args[1], 50);
+ tc->getVirtProxy().readString(st, args[1], 50);
StringWrap name(tc->getSystemPtr()->name());
DPRINTF(Annotate, "Explict begin of state %s\n", st);
string sym;
Addr sym_addr = 0;
- SymbolTable *symtab = NULL;
-
if (!TheISA::inUserMode(tc)) {
debugSymbolTable->findNearestSymbol(next_pc, sym, sym_addr);
- symtab = debugSymbolTable;
} else {
Linux::ThreadInfo ti(tc);
string app = ti.curTaskName();
tc->readIntReg(ReturnAddressReg), st, junk);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
-
+
int sysi = getSys(sys);
StackId sid = StackId(sysi, getFrame(tc));
if (!smStack[sid].size()) {
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
int32_t count = args[2];
System *sys = tc->getSystemPtr();
//warn("Tried to queue 0 bytes in %s, ignoring\n", q);
return;
}
- DPRINTFS(AnnotateQ, sys,
+ DPRINTFS(AnnotateQ, sys,
"swQ: %s[%#x] cur size %d %d bytes: %d adding: %d\n",
q, id, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
doQ(sys, FL_NONE, tc->contextId(), smi, q, qi, count);
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
int32_t count = args[2];
System *sys = tc->getSystemPtr();
int qi = getQ(sysi, q, id);
if (swExpl[sid])
swExpl[sid] = false;
- DPRINTFS(AnnotateQ, sys,
+ DPRINTFS(AnnotateQ, sys,
"swDq: %s[%#x] cur size %d %d bytes: %d removing: %d\n",
q, id, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
assert(count != 0);
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
int32_t count = args[2];
int qi = getQ(sysi, q, id);
if (swExpl[sid])
swExpl[sid] = false;
- DPRINTFS(AnnotateQ, sys,
+ DPRINTFS(AnnotateQ, sys,
"swPq: %s [%#x] cur size %d %d bytes: %d peeking: %d\n",
q, id, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
int32_t count = args[2];
int qi = getQ(sysi, q, id);
if (swExpl[sid])
swExpl[sid] = false;
- DPRINTFS(AnnotateQ, sys,
+ DPRINTFS(AnnotateQ, sys,
"swRq: %s [%#x] cur size %d %d bytes: %d reserve: %d\n",
q, id, qSize[qi-1], qData[qi-1].size(), qBytes[qi-1], count);
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
int32_t count = args[3];
if (!!args[2]) {
char sm[50];
- CopyStringOut(tc, sm, args[2], 50);
+ tc->getVirtProxy().readString(sm, args[2], 50);
doSwSmEnd(tc->getSystemPtr(), tc->contextId(), sm, getFrame(tc));
}
}
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
int32_t count = args[3];
if (!!args[2]) {
char sm[50];
- CopyStringOut(tc, sm, args[2], 50);
+ tc->getVirtProxy().readString(sm, args[2], 50);
doSwSmEnd(tc->getSystemPtr(), tc->contextId(), sm, getFrame(tc));
}
}
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
int32_t size = args[2];
char q[50];
Arguments args(tc);
uint64_t id = args[0];
- CopyStringOut(tc, q, args[1], 50);
+ tc->getVirtProxy().readString(q, args[1], 50);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
int32_t size = args[2];
x++;
}
- warn("%d: Queue Assert: SW said there should be %d byte(s) in %s,"
+ warn("%d: Queue Assert: SW said there should be %d byte(s) in %s,"
"however there are %d byte(s)\n",
curTick(), size, q, qBytes[qi-1]);
DPRINTF(AnnotateQ, "%d: Queue Assert: SW said there should be %d"
char lsm[50];
Arguments args(tc);
- CopyStringOut(tc, lsm, args[0], 50);
+ tc->getVirtProxy().readString(lsm, args[0], 50);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
if (!!args[2]) {
char sm[50];
- CopyStringOut(tc, sm, args[2], 50);
+ tc->getVirtProxy().readString(sm, args[2], 50);
doSwSmEnd(tc->getSystemPtr(), tc->contextId(), sm, getFrame(tc));
}
}
char lsm[50];
Arguments args(tc);
- CopyStringOut(tc, lsm, args[0], 50);
+ tc->getVirtProxy().readString(lsm, args[0], 50);
System *sys = tc->getSystemPtr();
StringWrap name(sys->name());
int sysi = getSys(sys);
smi, lsm);
if (scLinks[sysi-1][id])
- DPRINTF(Annotate,
+ DPRINTF(Annotate,
"scLinks already contains entry for system %d %s[%x] of %d\n",
sysi, lsm, getFrame(tc), scLinks[sysi-1][id]);
assert(scLinks[sysi-1][id] == 0);
if (!!args[1]) {
char sm[50];
- CopyStringOut(tc, sm, args[1], 50);
+ tc->getVirtProxy().readString(sm, args[1], 50);
doSwSmEnd(tc->getSystemPtr(), tc->contextId(), sm, getFrame(tc));
}
}
CPA::AnnDataPtr
CPA::add(int t, int f, int c, int sm, int stq, int32_t d)
{
- AnnDataPtr an = new AnnotateData;
+ AnnDataPtr an = std::make_shared<AnnotateData>();
an->time = curTick();
an->data = d;
an->orig_data = d;
DPRINTF(AnnotateVerbose, "Annotate: op: %d flags: 0x%x sm: %d state: %d time: %d, data: %d\n",
an->op, an->flag, an->sm, an->stq, an->time, an->data);
-
+
// Don't dump Links because we might be setting no-dump on it
if (an->op != OP_LINK)
dump(false);
void
-CPA::serialize(std::ostream &os)
+CPA::serialize(CheckpointOut &cp) const
{
SERIALIZE_SCALAR(numSm);
arrayParamOut(os, "qSize", qSize);
arrayParamOut(os, "qBytes", qBytes);
- std::list<AnnDataPtr>::iterator ai;
-
SCache::iterator i;
int x = 0, y = 0;
}
// qData (vector<AnnotateList>)
- for(x = 0; x < qData.size(); x++) {
+ for (x = 0; x < qData.size(); x++) {
if (!qData[x].size())
continue;
y = 0;
- ai = qData[x].begin();
- while (ai != qData[x].end()) {
- nameOut(os, csprintf("%s.Q%d_%d", name(), x, y));
- (*ai)->serialize(os);
- ai++;
+ for (auto &ann : qData[x]) {
+ ann->serializeSection(os, csprintf("Q%d_%d", x, y));
y++;
}
}
}
void
-CPA::unserialize(Checkpoint *cp, const std::string §ion)
+CPA::unserialize(CheckpointIn &cp)
{
UNSERIALIZE_SCALAR(numSm);
UNSERIALIZE_SCALAR(numSmt);
- arrayParamIn(cp, section, "numSt", numSt);
- arrayParamIn(cp, section, "numQ", numQ);
+ UNSERIALIZE_CONTAINER(numSt);
+ UNSERIALIZE_CONTAINER(numQ);
UNSERIALIZE_SCALAR(numSys);
UNSERIALIZE_SCALAR(numQs);
UNSERIALIZE_SCALAR(conId);
- arrayParamIn(cp, section, "qSize", qSize);
- arrayParamIn(cp, section, "qBytes", qBytes);
+ UNSERIALIZE_CONTAINER(qSize);
+ UNSERIALIZE_CONTAINER(qBytes);
// smtCache (SCache
string str;
int smi;
for (int x = 0; x < numSmt; x++) {
- paramIn(cp, section, csprintf("smtCache%d.str", x), str);
- paramIn(cp, section, csprintf("smtCache%d.int", x), smi);
+ paramIn(cp, csprintf("smtCache%d.str", x), str);
+ paramIn(cp, csprintf("smtCache%d.int", x), smi);
smtCache[str] = smi;
}
stCache.resize(numSmt);
for (int x = 0; x < numSmt; x++) {
for (int y = 0; y < numSt[x]; y++) {
- paramIn(cp, section, csprintf("stCache%d_%d.str", x,y), str);
- paramIn(cp, section, csprintf("stCache%d_%d.int", x,y), smi);
+ paramIn(cp, csprintf("stCache%d_%d.str", x,y), str);
+ paramIn(cp, csprintf("stCache%d_%d.int", x,y), smi);
stCache[x][str] = smi;
}
}
qCache.resize(numSys);
for (int x = 0; x < numSys; x++) {
for (int y = 0; y < numQ[x]; y++) {
- paramIn(cp, section, csprintf("qCache%d_%d.str", x,y), str);
- paramIn(cp, section, csprintf("qCache%d_%d.id", x,y), id);
- paramIn(cp, section, csprintf("qCache%d_%d.int", x,y), smi);
+ paramIn(cp, csprintf("qCache%d_%d.str", x,y), str);
+ paramIn(cp, csprintf("qCache%d_%d.id", x,y), id);
+ paramIn(cp, csprintf("qCache%d_%d.int", x,y), smi);
qCache[x][Id(str,id)] = smi;
}
}
smCache.resize(numSys);
for (int x = 0; x < numSys; x++) {
int size;
- paramIn(cp, section, csprintf("smCache%d", x), size);
+ paramIn(cp, csprintf("smCache%d", x), size);
for (int y = 0; y < size; y++) {
- paramIn(cp, section, csprintf("smCache%d_%d.str", x,y), str);
- paramIn(cp, section, csprintf("smCache%d_%d.id", x,y), id);
- paramIn(cp, section, csprintf("smCache%d_%d.int", x,y), smi);
+ paramIn(cp, csprintf("smCache%d_%d.str", x,y), str);
+ paramIn(cp, csprintf("smCache%d_%d.id", x,y), id);
+ paramIn(cp, csprintf("smCache%d_%d.int", x,y), smi);
smCache[x][Id(str,id)] = smi;
}
}
string str;
int sysi;
- objParamIn(cp, section, csprintf("nameCache%d.name", x), sptr);
+ objParamIn(cp, csprintf("nameCache%d.name", x), sptr);
sys = dynamic_cast<System*>(sptr);
- paramIn(cp, section, csprintf("nameCache%d.str", x), str);
- paramIn(cp, section, csprintf("nameCache%d.int", x), sysi);
- nameCache[sys] = std::make_pair<std::string,int>(str, sysi);
+ paramIn(cp, csprintf("nameCache%d.str", x), str);
+ paramIn(cp, csprintf("nameCache%d.int", x), sysi);
+ nameCache[sys] = std::make_pair(str, sysi);
}
//smStack (SmStack)
int smStack_size;
- paramIn(cp, section, "smStackIdCount", smStack_size);
+ paramIn(cp, "smStackIdCount", smStack_size);
for (int x = 0; x < smStack_size; x++) {
int sysi;
uint64_t frame;
int count;
- paramIn(cp, section, csprintf("smStackId%d.sys", x), sysi);
- paramIn(cp, section, csprintf("smStackId%d.frame", x), frame);
- paramIn(cp, section, csprintf("smStackId%d.count", x), count);
+ paramIn(cp, csprintf("smStackId%d.sys", x), sysi);
+ paramIn(cp, csprintf("smStackId%d.frame", x), frame);
+ paramIn(cp, csprintf("smStackId%d.count", x), count);
StackId sid = StackId(sysi, frame);
for (int y = 0; y < count; y++) {
- paramIn(cp, section, csprintf("smStackId%d_%d", x, y), smi);
+ paramIn(cp, csprintf("smStackId%d_%d", x, y), smi);
smStack[sid].push_back(smi);
}
}
// lnMap (LinkMap)
int lsmi;
int lnMap_size;
- paramIn(cp, section, "lnMapSize", lnMap_size);
+ paramIn(cp, "lnMapSize", lnMap_size);
for (int x = 0; x < lnMap_size; x++) {
- paramIn(cp, section, csprintf("lnMap%d.smi", x), smi);
- paramIn(cp, section, csprintf("lnMap%d.lsmi", x), lsmi);
+ paramIn(cp, csprintf("lnMap%d.smi", x), smi);
+ paramIn(cp, csprintf("lnMap%d.lsmi", x), lsmi);
lnMap[smi] = lsmi;
}
// swExpl (vector)
int swExpl_size;
- paramIn(cp, section, "swExplCount", swExpl_size);
+ paramIn(cp, "swExplCount", swExpl_size);
for (int x = 0; x < swExpl_size; x++) {
int sysi;
uint64_t frame;
bool b;
- paramIn(cp, section, csprintf("swExpl%d.sys", x), sysi);
- paramIn(cp, section, csprintf("swExpl%d.frame", x), frame);
- paramIn(cp, section, csprintf("swExpl%d.swexpl", x), b);
+ paramIn(cp, csprintf("swExpl%d.sys", x), sysi);
+ paramIn(cp, csprintf("swExpl%d.frame", x), frame);
+ paramIn(cp, csprintf("swExpl%d.swexpl", x), b);
StackId sid = StackId(sysi, frame);
swExpl[sid] = b;
}
// lastState (IMap)
int sti;
int lastState_size;
- paramIn(cp, section, "lastStateSize", lastState_size);
+ paramIn(cp, "lastStateSize", lastState_size);
for (int x = 0; x < lastState_size; x++) {
- paramIn(cp, section, csprintf("lastState%d.smi", x), smi);
- paramIn(cp, section, csprintf("lastState%d.sti", x), sti);
+ paramIn(cp, csprintf("lastState%d.smi", x), smi);
+ paramIn(cp, csprintf("lastState%d.sti", x), sti);
lastState[smi] = sti;
}
//smMap (IdMap)
smMap.resize(numSm);
for (int x = 0; x < smMap.size(); x++) {
- paramIn(cp, section, csprintf("smMap%d.sys", x), smMap[x].first);
- paramIn(cp, section, csprintf("smMap%d.smname", x), smMap[x].second.first);
- paramIn(cp, section, csprintf("smMap%d.id", x), smMap[x].second.second);
+ paramIn(cp, csprintf("smMap%d.sys", x), smMap[x].first);
+ paramIn(cp, csprintf("smMap%d.smname", x), smMap[x].second.first);
+ paramIn(cp, csprintf("smMap%d.id", x), smMap[x].second.second);
}
//qMap (IdMap)
qMap.resize(numQs);
for (int x = 0; x < qMap.size(); x++) {
- paramIn(cp, section, csprintf("qMap%d.sys", x), qMap[x].first);
- paramIn(cp, section, csprintf("qMap%d.qname", x), qMap[x].second.first);
- paramIn(cp, section, csprintf("qMap%d.id", x), qMap[x].second.second);
+ paramIn(cp, csprintf("qMap%d.sys", x), qMap[x].first);
+ paramIn(cp, csprintf("qMap%d.qname", x), qMap[x].second.first);
+ paramIn(cp, csprintf("qMap%d.id", x), qMap[x].second.second);
}
if (!qSize[x])
continue;
for (int y = 0; y < qSize[x]; y++) {
- AnnDataPtr a = new AnnotateData;
- a->unserialize(cp, csprintf("%s.Q%d_%d", section, x, y));
+ AnnDataPtr a = std::make_shared<AnnotateData>();
+ a->unserializeSection(cp, csprintf("Q%d_%d", x, y));
data.push_back(a);
qData[x].push_back(a);
}
}
void
-CPA::AnnotateData::serialize(std::ostream &os)
+CPA::AnnotateData::serialize(CheckpointOut &cp) const
{
SERIALIZE_SCALAR(time);
SERIALIZE_SCALAR(data);
}
void
-CPA::AnnotateData::unserialize(Checkpoint *cp, const std::string §ion)
+CPA::AnnotateData::unserialize(CheckpointIn &cp)
{
UNSERIALIZE_SCALAR(time);
UNSERIALIZE_SCALAR(data);
projects / gem5.git / blobdiff