/*
- * Copyright (c) 2012 ARM Limited
+ * Copyright (c) 2012, 2014 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
#define __SYSTEM_HH__
#include <string>
+#include <utility>
#include <vector>
+#include "arch/isa_traits.hh"
#include "base/loader/symtab.hh"
#include "base/misc.hh"
#include "base/statistics.hh"
+#include "config/the_isa.hh"
#include "cpu/pc_event.hh"
#include "enums/MemoryMode.hh"
#include "kern/system_events.hh"
-#include "mem/fs_translating_port_proxy.hh"
#include "mem/mem_object.hh"
#include "mem/port.hh"
+#include "mem/port_proxy.hh"
#include "mem/physical.hh"
#include "params/System.hh"
BaseMasterPort& getMasterPort(const std::string &if_name,
PortID idx = InvalidPortID);
- static const char *MemoryModeStrings[4];
-
/** @{ */
/**
* Is the system in atomic mode?
void setMemoryMode(Enums::MemoryMode mode);
/** @} */
+ /**
+ * Get the cache line size of the system.
+ */
+ unsigned int cacheLineSize() const { return _cacheLineSize; }
+
+#if THE_ISA != NULL_ISA
PCEventQueue pcEventQueue;
+#endif
std::vector<ThreadContext *> threadContexts;
int _numContexts;
/** Port to physical memory used for writing object files into ram at
* boot.*/
PortProxy physProxy;
- FSTranslatingPortProxy virtProxy;
/** kernel symbol table */
SymbolTable *kernelSymtab;
*/
Addr loadAddrMask;
+ /** Offset that should be used for binary/symbol loading.
+ * This further allows more flexibily than the loadAddrMask allows alone in
+ * loading kernels and similar. The loadAddrOffset is applied after the
+ * loadAddrMask.
+ */
+ Addr loadAddrOffset;
+
protected:
uint64_t nextPID;
*/
bool isMemAddr(Addr addr) const;
+ /**
+ * Get the architecture.
+ */
+ Arch getArch() const { return Arch::TheISA; }
+
+ /**
+ * Get the page bytes for the ISA.
+ */
+ Addr getPageBytes() const { return TheISA::PageBytes; }
+
+ /**
+ * Get the number of bits worth of in-page adress for the ISA.
+ */
+ Addr getPageShift() const { return TheISA::PageShift; }
+
protected:
PhysicalMemory physmem;
Enums::MemoryMode memoryMode;
+
+ const unsigned int _cacheLineSize;
+
uint64_t workItemsBegin;
uint64_t workItemsEnd;
uint32_t numWorkIds;
* Called by pseudo_inst to track the number of work items completed by
* this system.
*/
- uint64_t
+ uint64_t
incWorkItemsEnd()
{
return ++workItemsEnd;
* Returns the total number of cpus that have executed work item begin or
* ends.
*/
- int
+ int
markWorkItem(int index)
{
int count = 0;
assert(index < activeCpus.size());
activeCpus[index] = true;
- for (std::vector<bool>::iterator i = activeCpus.begin();
+ for (std::vector<bool>::iterator i = activeCpus.begin();
i < activeCpus.end(); i++) {
if (*i) count++;
}
panic("Base fixFuncEventAddr not implemented.\n");
}
+ /** @{ */
/**
* Add a function-based event to the given function, to be looked
* up in the specified symbol table.
+ *
+ * The ...OrPanic flavor of the method causes the simulator to
+ * panic if the symbol can't be found.
+ *
+ * @param symtab Symbol table to use for look up.
+ * @param lbl Function to hook the event to.
+ * @param desc Description to be passed to the event.
+ * @param args Arguments to be forwarded to the event constructor.
*/
- template <class T>
- T *addFuncEvent(SymbolTable *symtab, const char *lbl)
+ template <class T, typename... Args>
+ T *addFuncEvent(const SymbolTable *symtab, const char *lbl,
+ const std::string &desc, Args... args)
{
- Addr addr = 0; // initialize only to avoid compiler warning
+ Addr addr M5_VAR_USED = 0; // initialize only to avoid compiler warning
+#if THE_ISA != NULL_ISA
if (symtab->findAddress(lbl, addr)) {
- T *ev = new T(&pcEventQueue, lbl, fixFuncEventAddr(addr));
+ T *ev = new T(&pcEventQueue, desc, fixFuncEventAddr(addr),
+ std::forward<Args>(args)...);
return ev;
}
+#endif
return NULL;
}
- /** Add a function-based event to kernel code. */
template <class T>
- T *addKernelFuncEvent(const char *lbl)
+ T *addFuncEvent(const SymbolTable *symtab, const char *lbl)
{
- return addFuncEvent<T>(kernelSymtab, lbl);
+ return addFuncEvent<T>(symtab, lbl, lbl);
}
+ template <class T, typename... Args>
+ T *addFuncEventOrPanic(const SymbolTable *symtab, const char *lbl,
+ Args... args)
+ {
+ T *e(addFuncEvent<T>(symtab, lbl, std::forward<Args>(args)...));
+ if (!e)
+ panic("Failed to find symbol '%s'", lbl);
+ return e;
+ }
+ /** @} */
+
+ /** @{ */
+ /**
+ * Add a function-based event to a kernel symbol.
+ *
+ * These functions work like their addFuncEvent() and
+ * addFuncEventOrPanic() counterparts. The only difference is that
+ * they automatically use the kernel symbol table. All arguments
+ * are forwarded to the underlying method.
+ *
+ * @see addFuncEvent()
+ * @see addFuncEventOrPanic()
+ *
+ * @param lbl Function to hook the event to.
+ * @param args Arguments to be passed to addFuncEvent
+ */
+ template <class T, typename... Args>
+ T *addKernelFuncEvent(const char *lbl, Args... args)
+ {
+ return addFuncEvent<T>(kernelSymtab, lbl,
+ std::forward<Args>(args)...);
+ }
+
+ template <class T, typename... Args>
+ T *addKernelFuncEventOrPanic(const char *lbl, Args... args)
+ {
+ T *e(addFuncEvent<T>(kernelSymtab, lbl,
+ std::forward<Args>(args)...));
+ if (!e)
+ panic("Failed to find kernel symbol '%s'", lbl);
+ return e;
+ }
+ /** @} */
+
public:
std::vector<BaseRemoteGDB *> remoteGDB;
std::vector<GDBListener *> gdbListen;
};
+void printSystems();
+
#endif // __SYSTEM_HH__
projects / gem5.git / blobdiff