Simple text list of symbol (or address) and count
will be dumped to m5prof.<cpu-name> if the cpu's
pc_sample_interval param is set.
SConscript:
Add cpu/full_cpu/pc_sample_profile.cc
base/callback.hh:
Add a comment about MakeCallback.
Fix type in another comment.
base/loader/symtab.cc:
Revamp findNearestSymbol() to provide addresses of both
nearest symbols (preceding and following) as well as
string for former.
Move global definition of debugSymbolTable here too.
base/loader/symtab.hh:
Revamp findNearestSymbol() to provide addresses of both
nearest symbols (preceding and following) as well as
string for former.
Move global declaration of debugSymbolTable here too.
cpu/exetrace.cc:
Use new findNearestSymbol() interface for trace symbols.
kern/linux/linux_system.cc:
sim/system.cc:
Remove extern of debugSymbolTable (now in symtab.hh)
sim/process.cc:
Initialize debugSymbolTable if binary has a symbol table.
--HG--
extra : convert_revision :
0b5393dc39c40ac88c953684708f1125da550671
cpu/full_cpu/issue.cc
cpu/full_cpu/ls_queue.cc
cpu/full_cpu/machine_queue.cc
+ cpu/full_cpu/pc_sample_profile.cc
cpu/full_cpu/pipetrace.cc
cpu/full_cpu/readyq.cc
cpu/full_cpu/reg_info.cc
#include <list>
/**
- * Generic callback class. This base class provides a virutal process
+ * Generic callback class. This base class provides a virtual process
* function that gets called when the callback queue is processed.
*/
class Callback
}
};
+/// Helper template class to turn a simple class member function into
+/// a callback.
template <class T, void (T::* F)()>
class MakeCallback : public Callback
{
public:
MakeCallback(T *o)
- : object(o)
+ : object(o)
{ }
+
void process() { (object->*F)(); }
};
using namespace std;
+SymbolTable *debugSymbolTable = NULL;
+
bool
SymbolTable::insert(Addr address, string symbol)
{
}
bool
-SymbolTable::findNearestSymbol(Addr address, string &symbol) const
+SymbolTable::findNearestSymbol(Addr address, string &symbol,
+ Addr &sym_address, Addr &next_sym_address) const
{
- ATable::const_iterator i = addrTable.lower_bound(address);
-
- // check for PALCode
- if (address & 0x1)
- return false;
+ // find first key *larger* than desired address
+ ATable::const_iterator i = addrTable.upper_bound(address);
- // first check for the end
- if (i == addrTable.end())
- i--;
- else if (i == addrTable.begin() && (*i).first != address)
+ // if very first key is larger, we're out of luck
+ if (i == addrTable.begin())
return false;
- else if ((*i).first != address)
- i--;
-
- symbol = (*i).second;
- if (address != (*i).first)
- symbol += csprintf("+%d", address - (*i).first);
+ next_sym_address = i->first;
+ --i;
+ sym_address = i->first;
+ symbol = i->second;
return true;
}
bool insert(Addr address, std::string symbol);
bool load(const std::string &file);
- bool findNearestSymbol(Addr address, std::string &symbol) const;
+ /// Find the nearest symbol equal to or less than the supplied
+ /// address (e.g., the label for the enclosing function).
+ /// @param address The address to look up.
+ /// @param symbol Return reference for symbol string.
+ /// @param sym_address Return reference for symbol address.
+ /// @param next_sym_address Address of following symbol (for
+ /// determining valid range of symbol).
+ /// @retval True if a symbol was found.
+ bool findNearestSymbol(Addr address, std::string &symbol,
+ Addr &sym_address, Addr &next_sym_address) const;
+
+ /// Overload for findNearestSymbol() for callers who don't care
+ /// about next_sym_address.
+ bool findNearestSymbol(Addr address, std::string &symbol,
+ Addr &sym_address) const
+ {
+ Addr dummy;
+ return findNearestSymbol(address, symbol, sym_address, dummy);
+ }
+
+
bool findSymbol(Addr address, std::string &symbol) const;
bool findAddress(const std::string &symbol, Addr &address) const;
Addr find(const std::string &symbol) const;
};
+/// Global unified debugging symbol table (for target). Conceptually
+/// there should be one of these per System object for full system,
+/// and per Process object for non-full-system, but so far one big
+/// global one has worked well enough.
+extern SymbolTable *debugSymbolTable;
+
#endif // __SYMTAB_HH__
//
-SymbolTable *debugSymbolTable = NULL;
-
void
Trace::InstRecord::dump(ostream &outs)
{
outs << "T" << thread << " : ";
- std::string str;
- if ((debugSymbolTable) && (debugSymbolTable->findNearestSymbol(PC, str)))
- outs << "@" << setw(17) << str << " : ";
- else
+ std::string sym_str;
+ Addr sym_addr;
+ if (debugSymbolTable
+ && debugSymbolTable->findNearestSymbol(PC, sym_str, sym_addr)) {
+ if (PC != sym_addr)
+ sym_str += csprintf("+%d", addr - sym_addr);
+ outs << "@" << setw(17) << sym_str << " : ";
+ }
+ else {
outs << "0x" << hex << PC << " : ";
+ }
//
// Print decoded instruction
#include "targetarch/vtophys.hh"
#include "sim/debug.hh"
-extern SymbolTable *debugSymbolTable;
-
using namespace std;
LinuxSystem::LinuxSystem(Params *p)
#include "base/intmath.hh"
#include "base/loader/object_file.hh"
+#include "base/loader/symtab.hh"
#include "base/statistics.hh"
#include "cpu/exec_context.hh"
#include "cpu/full_cpu/smt.hh"
// load object file into target memory
objFile->loadSections(memory);
+ // load up symbols, if any... these may be used for debugging or
+ // profiling.
+ if (!debugSymbolTable) {
+ debugSymbolTable = new SymbolTable();
+ if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
+ !objFile->loadLocalSymbols(debugSymbolTable)) {
+ // didn't load any symbols
+ delete debugSymbolTable;
+ debugSymbolTable = NULL;
+ }
+ }
+
// Set up stack. On Alpha, stack goes below text section. This
// code should get moved to some architecture-specific spot.
stack_base = text_base - (409600+4096);
int System::numSystemsRunning = 0;
-extern SymbolTable *debugSymbolTable;
-
System::System(Params *p)
: SimObject(p->name), memctrl(p->memctrl), physmem(p->physmem),
init_param(p->init_param), params(p)
projects / gem5.git / commitdiff