sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Merge

Browse source 
cpu/pc_event.cc:
    SCCS merged

--HG--
extra : convert_revision : f7046f2bf6053be9b00150390fabe3d4f82b0981
This commit is contained in:
Nathan Binkert 2003-10-14 16:53:52 -04:00
parent 2ac3dc5aa1 4759c203c7
commit 638a07d15a
21 changed files with 1079 additions and 373 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
arch/alpha/arguments.cc
View file

@ -26,9 +26,9 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "targetarch/arguments.hh"
#include "cpu/exec_context.hh"
#include "mem/functional_mem/physical_memory.hh"
#include "targetarch/arguments.hh"
#include "targetarch/vtophys.hh"
AlphaArguments::Data::~Data()

3
arch/alpha/arguments.hh
View file

@ -31,9 +31,8 @@
#include <assert.h>
#include "sim/host.hh"
#include "kern/tru64/kernel.hh"
#include "base/refcnt.hh"
#include "sim/host.hh"
#include "targetarch/vtophys.hh"
class ExecContext;

2
arch/alpha/ev5.cc
View file

@ -560,7 +560,7 @@ ExecContext::simPalCheck(int palFunc)
case PAL::bpt:
case PAL::bugchk:
if (system->remoteGDB->trap(ALPHA_KENTRY_IF))
if (system->breakpoint())
return false;
break;
}

1
arch/alpha/vtophys.hh
View file

@ -29,6 +29,7 @@
#ifndef __VTOPHYS_H__
#define __VTOPHYS_H__
#include "targetarch/isa_traits.hh"
#include "targetarch/pmap.h"
inline bool entry_valid(uint64_t entry)

2
base/remote_gdb.hh
View file

@ -29,6 +29,8 @@
#ifndef __REMOTE_GDB_HH__
#define __REMOTE_GDB_HH__
#include <map>
#include "base/kgdb.h"
#include "cpu/pc_event.hh"
#include "base/pollevent.hh"

4
cpu/exec_context.hh
View file

@ -245,8 +245,8 @@ class ExecContext
// stores (WH64?)
// Unsuccesful Store Conditionals would have returned above,
// and wouldn't fall through
for(int i = 0; i < system->num_cpus; i++){
cregs = &system->xc_array[i]->regs.miscRegs;
for(int i = 0; i < system->xcvec.size(); i++){
cregs = &system->xcvec[i]->regs.miscRegs;
if((cregs->lock_addr & ~0xf) == (req->paddr & ~0xf)) {
cregs->lock_flag = false;
}

83
cpu/pc_event.cc
View file

@ -37,16 +37,6 @@
#include "base/trace.hh"
#include "sim/universe.hh"
#ifdef FULL_SYSTEM
#include "targetarch/arguments.hh"
#include "targetarch/pmap.h"
#include "kern/tru64/kernel.hh"
#include "mem/functional_mem/memory_control.hh"
#include "sim/system.hh"
#include "cpu/base_cpu.hh"
#include "cpu/full_cpu/bpred.hh"
#endif
using namespace std;
PCEventQueue::PCEventQueue()
@ -85,7 +75,7 @@ PCEventQueue::schedule(PCEvent *event)
}
bool
PCEventQueue::service(ExecContext *xc)
PCEventQueue::doService(ExecContext *xc)
{
Addr pc = xc->regs.pc;
int serviced = 0;
@ -125,77 +115,6 @@ PCEventQueue::equal_range(Addr pc)
return std::equal_range(pc_map.begin(), pc_map.end(), pc, MapCompare());
}
#ifdef FULL_SYSTEM
void
SkipFuncEvent::process(ExecContext *xc)
{
Addr newpc = xc->regs.intRegFile[ReturnAddressReg];
DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
xc->regs.pc, newpc);
xc->regs.pc = newpc;
xc->regs.npc = xc->regs.pc + sizeof(MachInst);
BranchPred *bp = xc->cpu->getBranchPred();
if (bp != NULL) {
bp->popRAS(xc->thread_num);
}
}
void
BadAddrEvent::process(ExecContext *xc)
{
// The following gross hack is the equivalent function to the
// annotation for vmunix::badaddr in:
// simos/simulation/apps/tcl/osf/tlaser.tcl
uint64_t a0 = xc->regs.intRegFile[ArgumentReg0];
if (a0 < ALPHA_K0SEG_BASE || a0 >= ALPHA_K1SEG_BASE ||
xc->memCtrl->badaddr(ALPHA_K0SEG_TO_PHYS(a0) & PA_IMPL_MASK)) {
DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
xc->regs.intRegFile[ReturnValueReg] = 0x1;
SkipFuncEvent::process(xc);
}
else
DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
}
void
PrintfEvent::process(ExecContext *xc)
{
if (DTRACE(Printf)) {
DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
AlphaArguments args(xc);
Kernel::Printf(args);
}
}
void
DebugPrintfEvent::process(ExecContext *xc)
{
if (DTRACE(DebugPrintf)) {
if (!raw)
DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
AlphaArguments args(xc);
Kernel::Printf(args);
}
}
void
DumpMbufEvent::process(ExecContext *xc)
{
if (DTRACE(DebugPrintf)) {
AlphaArguments args(xc);
Kernel::DumpMbuf(args);
}
}
#endif
BreakPCEvent::BreakPCEvent(PCEventQueue *q, const std::string &desc, bool del)
: PCEvent(q, desc), remove(del)
{

57
cpu/pc_event.hh
View file

@ -98,13 +98,21 @@ class PCEventQueue
protected:
map_t pc_map;
bool doService(ExecContext *xc);
public:
PCEventQueue();
~PCEventQueue();
bool remove(PCEvent *event);
bool schedule(PCEvent *event);
bool service(ExecContext *xc);
bool service(ExecContext *xc)
{
if (pc_map.empty())
return false;
return doService(xc);
}
range_t equal_range(Addr pc);
range_t equal_range(PCEvent *event) { return equal_range(event->pc()); }
@ -155,52 +163,6 @@ PCEvent::schedule(PCEventQueue *q, Addr pc)
return schedule();
}
#ifdef FULL_SYSTEM
class SkipFuncEvent : public PCEvent
{
public:
SkipFuncEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class BadAddrEvent : public SkipFuncEvent
{
public:
BadAddrEvent(PCEventQueue *q, const std::string &desc)
: SkipFuncEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class PrintfEvent : public PCEvent
{
public:
PrintfEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class DebugPrintfEvent : public PCEvent
{
private:
bool raw;
public:
DebugPrintfEvent(PCEventQueue *q, const std::string &desc, bool r = false)
: PCEvent(q, desc), raw(r) {}
virtual void process(ExecContext *xc);
};
class DumpMbufEvent : public PCEvent
{
public:
DumpMbufEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
#endif
class BreakPCEvent : public PCEvent
{
protected:
@ -211,5 +173,4 @@ class BreakPCEvent : public PCEvent
virtual void process(ExecContext *xc);
};
#endif // __PC_EVENT_HH__

2
cpu/simple_cpu/simple_cpu.cc
View file

@ -150,7 +150,7 @@ SimpleCPU::SimpleCPU(const string &_name, Process *_process,
_status = Idle;
}
else {
system->initBootContext(xc);
system->init(xc);
// Reset the system
//

2
dev/alpha_console.cc
View file

@ -153,7 +153,7 @@ AlphaConsole::write(MemReqPtr req, const uint8_t *data)
int cpu = val;
assert(cpu > 0 && "Must not access primary cpu");
ExecContext *other_xc = req->xc->system->xc_array[cpu];
ExecContext *other_xc = req->xc->system->xcvec[cpu];
other_xc->regs.intRegFile[16] = cpu;
other_xc->regs.ipr[TheISA::IPR_PALtemp16] = cpu;
other_xc->regs.intRegFile[0] = cpu;

72
kern/tru64/dump_mbuf.cc Normal file
View file

@ -0,0 +1,72 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/types.h>
#include <algorithm>
#include "base/cprintf.hh"
#include "base/trace.hh"
#include "kern/tru64/mbuf.hh"
#include "sim/host.hh"
#include "targetarch/arguments.hh"
#include "targetarch/isa_traits.hh"
#include "targetarch/vtophys.hh"
namespace Tru64 {
void
DumpMbuf(AlphaArguments args)
{
ExecContext *xc = args.getExecContext();
Addr addr = (Addr)args;
struct mbuf m;
CopyData(xc, &m, addr, sizeof(m));
int count = m.m_pkthdr.len;
ccprintf(DebugOut(), "m=%#lx, m->m_pkthdr.len=%#d\n", addr,
m.m_pkthdr.len);
while (count > 0) {
ccprintf(DebugOut(), "m=%#lx, m->m_data=%#lx, m->m_len=%d\n",
addr, m.m_data, m.m_len);
char *buffer = new char[m.m_len];
CopyData(xc, buffer, m.m_data, m.m_len);
Trace::rawDump((uint8_t *)buffer, m.m_len);
delete [] buffer;
count -= m.m_len;
if (!m.m_next)
break;
CopyData(xc, &m, m.m_next, sizeof(m));
}
}
} // namespace Tru64

38
kern/tru64/dump_mbuf.hh Normal file
View file

@ -0,0 +1,38 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __DUMP_MBUF_HH__
#define __DUMP_MBUF_HH__
class AlphaArguments;
namespace Tru64 {
void DumpMbuf(AlphaArguments args);
}
#endif // __DUMP_MBUF_HH__

94
kern/tru64/mbuf.hh Normal file
View file

@ -0,0 +1,94 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __MBUF_HH__
#define __MBUF_HH__
#include "sim/host.hh"
#include "targetarch/isa_traits.hh"
struct m_hdr {
Addr mh_next; // 0x00
Addr mh_nextpkt; // 0x08
Addr mh_data; // 0x10
int32_t mh_len; // 0x18
int32_t mh_type; // 0x1C
int32_t mh_flags; // 0x20
int32_t mh_pad0; // 0x24
Addr mh_foo[4]; // 0x28, 0x30, 0x38, 0x40
};
struct pkthdr {
int32_t len;
int32_t protocolSum;
Addr rcvif;
};
struct m_ext {
Addr ext_buf; // 0x00
Addr ext_free; // 0x08
uint32_t ext_size; // 0x10
uint32_t ext_pad0; // 0x14
Addr ext_arg; // 0x18
struct ext_refq {
Addr forw, back; // 0x20, 0x28
} ext_ref;
Addr uiomove_f; // 0x30
int32_t protocolSum; // 0x38
int32_t bytesSummed; // 0x3C
Addr checksum; // 0x40
};
struct mbuf {
struct m_hdr m_hdr;
union {
struct {
struct pkthdr MH_pkthdr;
union {
struct m_ext MH_ext;
char MH_databuf[1];
} MH_dat;
} MH;
char M_databuf[1];
} M_dat;
};
#define m_attr m_hdr.mh_attr
#define m_next m_hdr.mh_next
#define m_len m_hdr.mh_len
#define m_data m_hdr.mh_data
#define m_type m_hdr.mh_type
#define m_flags m_hdr.mh_flags
#define m_nextpkt m_hdr.mh_nextpkt
#define m_act m_nextpkt
#define m_pkthdr M_dat.MH.MH_pkthdr
#define m_ext M_dat.MH.MH_dat.MH_ext
#define m_pktdat M_dat.MH.MH_dat.MH_databuf
#define m_dat M_dat.M_databuf
#endif // __MBUF_HH__

266
kern/tru64/printf.cc Normal file
View file

@ -0,0 +1,266 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/types.h>
#include <algorithm>
#include "base/cprintf.hh"
#include "base/trace.hh"
#include "sim/host.hh"
#include "targetarch/arguments.hh"
#include "targetarch/vtophys.hh"
using namespace std;
namespace Tru64 {
void
Printf(AlphaArguments args)
{
char *p = (char *)args++;
ios::fmtflags saved_flags = DebugOut().flags();
char old_fill = DebugOut().fill();
int old_precision = DebugOut().precision();
while (*p) {
switch (*p) {
case '%': {
bool more = true;
bool islong = false;
bool leftjustify = false;
bool format = false;
bool zero = false;
int width = 0;
while (more && *++p) {
switch (*p) {
case 'l':
case 'L':
islong = true;
break;
case '-':
leftjustify = true;
break;
case '#':
format = true;
break;
case '0':
if (width)
width *= 10;
else
zero = true;
break;
default:
if (*p >= '1' && *p <= '9')
width = 10 * width + *p - '0';
else
more = false;
break;
}
}
bool hexnum = false;
bool octal = false;
bool sign = false;
switch (*p) {
case 'X':
case 'x':
hexnum = true;
break;
case 'O':
case 'o':
octal = true;
break;
case 'D':
case 'd':
sign = true;
break;
case 'P':
format = true;
case 'p':
hexnum = true;
break;
}
switch (*p) {
case 'D':
case 'd':
case 'U':
case 'u':
case 'X':
case 'x':
case 'O':
case 'o':
case 'P':
case 'p': {
if (hexnum)
DebugOut() << hex;
if (octal)
DebugOut() << oct;
if (format) {
if (!zero)
DebugOut().setf(ios::showbase);
else {
if (hexnum) {
DebugOut() << "0x";
width -= 2;
} else if (octal) {
DebugOut() << "0";
width -= 1;
}
}
}
if (zero)
DebugOut().fill('0');
if (width > 0)
DebugOut().width(width);
if (leftjustify && !zero)
DebugOut().setf(ios::left);
if (sign) {
if (islong)
DebugOut() << (int64_t)args;
else
DebugOut() << (int32_t)args;
} else {
if (islong)
DebugOut() << (uint64_t)args;
else
DebugOut() << (uint32_t)args;
}
if (zero)
DebugOut().fill(' ');
if (width > 0)
DebugOut().width(0);
DebugOut() << dec;
++args;
}
break;
case 's': {
char *s = (char *)args;
if (!s)
s = "<NULL>";
if (width > 0)
DebugOut().width(width);
if (leftjustify)
DebugOut().setf(ios::left);
DebugOut() << s;
++args;
}
break;
case 'C':
case 'c': {
uint64_t mask = (*p == 'C') ? 0xffL : 0x7fL;
uint64_t num;
int width;
if (islong) {
num = (uint64_t)args;
width = sizeof(uint64_t);
} else {
num = (uint32_t)args;
width = sizeof(uint32_t);
}
while (width-- > 0) {
char c = (char)(num & mask);
if (c)
DebugOut() << c;
num >>= 8;
}
++args;
}
break;
case 'b': {
uint64_t n = (uint64_t)args++;
char *s = (char *)args++;
DebugOut() << s << ": " << n;
}
break;
case 'n':
case 'N': {
args += 2;
#if 0
uint64_t n = (uint64_t)args++;
struct reg_values *rv = (struct reg_values *)args++;
#endif
}
break;
case 'r':
case 'R': {
args += 2;
#if 0
uint64_t n = (uint64_t)args++;
struct reg_desc *rd = (struct reg_desc *)args++;
#endif
}
break;
case '%':
DebugOut() << '%';
break;
}
++p;
}
break;
case '\n':
DebugOut() << endl;
++p;
break;
case '\r':
++p;
if (*p != '\n')
DebugOut() << endl;
break;
default: {
size_t len = strcspn(p, "%\n\r\0");
DebugOut().write(p, len);
p += len;
}
}
}
DebugOut().flags(saved_flags);
DebugOut().fill(old_fill);
DebugOut().precision(old_precision);
}
} // namespace Tru64

38
kern/tru64/printf.hh Normal file
View file

@ -0,0 +1,38 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __PRINTF_HH__
#define __PRINTF_HH__
class AlphaArguments;
namespace Tru64 {
void Printf(AlphaArguments args);
}
#endif // __PRINTF_HH__

106
kern/tru64/tru64_events.cc Normal file
View file

@ -0,0 +1,106 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "cpu/exec_context.hh"
#include "cpu/full_cpu/bpred.hh"
#include "cpu/full_cpu/cpu.hh"
#include "kern/tru64/dump_mbuf.hh"
#include "kern/tru64/printf.hh"
#include "kern/tru64/tru64_events.hh"
#include "mem/functional_mem/memory_control.hh"
#include "targetarch/arguments.hh"
void
SkipFuncEvent::process(ExecContext *xc)
{
Addr newpc = xc->regs.intRegFile[ReturnAddressReg];
DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
xc->regs.pc, newpc);
xc->regs.pc = newpc;
xc->regs.npc = xc->regs.pc + sizeof(MachInst);
BranchPred *bp = xc->cpu->getBranchPred();
if (bp != NULL) {
bp->popRAS(xc->thread_num);
}
}
void
BadAddrEvent::process(ExecContext *xc)
{
// The following gross hack is the equivalent function to the
// annotation for vmunix::badaddr in:
// simos/simulation/apps/tcl/osf/tlaser.tcl
uint64_t a0 = xc->regs.intRegFile[ArgumentReg0];
if (a0 < ALPHA_K0SEG_BASE || a0 >= ALPHA_K1SEG_BASE ||
xc->memCtrl->badaddr(ALPHA_K0SEG_TO_PHYS(a0) & PA_IMPL_MASK)) {
DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
xc->regs.intRegFile[ReturnValueReg] = 0x1;
SkipFuncEvent::process(xc);
}
else
DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
}
void
PrintfEvent::process(ExecContext *xc)
{
if (DTRACE(Printf)) {
DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
AlphaArguments args(xc);
Tru64::Printf(args);
}
}
void
DebugPrintfEvent::process(ExecContext *xc)
{
if (DTRACE(DebugPrintf)) {
if (!raw)
DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
AlphaArguments args(xc);
Tru64::Printf(args);
}
}
void
DumpMbufEvent::process(ExecContext *xc)
{
if (DTRACE(DebugPrintf)) {
AlphaArguments args(xc);
Tru64::DumpMbuf(args);
}
}

81
kern/tru64/tru64_events.hh Normal file
View file

@ -0,0 +1,81 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __TRU64_EVENTS_HH__
#define __TRU64_EVENTS_HH__
#include <string>
#include "cpu/pc_event.hh"
class ExecContext;
class SkipFuncEvent : public PCEvent
{
public:
SkipFuncEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class BadAddrEvent : public SkipFuncEvent
{
public:
BadAddrEvent(PCEventQueue *q, const std::string &desc)
: SkipFuncEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class PrintfEvent : public PCEvent
{
public:
PrintfEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
class DebugPrintfEvent : public PCEvent
{
private:
bool raw;
public:
DebugPrintfEvent(PCEventQueue *q, const std::string &desc, bool r = false)
: PCEvent(q, desc), raw(r) {}
virtual void process(ExecContext *xc);
};
class DumpMbufEvent : public PCEvent
{
public:
DumpMbufEvent(PCEventQueue *q, const std::string &desc)
: PCEvent(q, desc) {}
virtual void process(ExecContext *xc);
};
#endif // __TRU64_EVENTS_HH__

239
kern/tru64/tru64_system.cc Normal file
View file

@ -0,0 +1,239 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "base/remote_gdb.hh"
#include "base/trace.hh"
#include "base/loader/aout_object.hh"
#include "base/loader/ecoff_object.hh"
#include "base/loader/object_file.hh"
#include "base/loader/symtab.hh"
#include "cpu/exec_context.hh"
#include "kern/tru64/tru64_events.hh"
#include "kern/tru64/tru64_system.hh"
#include "mem/functional_mem/memory_control.hh"
#include "mem/functional_mem/physical_memory.hh"
#include "targetarch/isa_traits.hh"
#include "targetarch/vtophys.hh"
using namespace std;
Tru64System::Tru64System(const string _name, MemoryController *_memCtrl,
PhysicalMemory *_physmem, const string &kernel_path,
const string &console_path, const string &palcode,
const string &boot_osflags)
: System(_name, _memCtrl, _physmem)
{
kernelSymtab = new SymbolTable;
consoleSymtab = new SymbolTable;
ObjectFile *kernel = createObjectFile(kernel_path);
if (kernel == NULL)
fatal("Could not load kernel file %s", kernel_path);
ObjectFile *console = createObjectFile(console_path);
if (console == NULL)
fatal("Could not load console file %s", console_path);
if (!kernel->loadGlobalSymbols(kernelSymtab))
panic("could not load kernel symbols\n");
if (!console->loadGlobalSymbols(consoleSymtab))
panic("could not load console symbols\n");
// Load pal file
ObjectFile *pal = createObjectFile(palcode);
if (pal == NULL)
fatal("Could not load PALcode file %s", palcode);
pal->loadSections(physmem, true);
// copy of initial reg file contents
initRegs = new RegFile;
memset(initRegs, 0, sizeof(RegFile));
// Load console file
console->loadSections(physmem, true);
// Load kernel file
kernel->loadSections(physmem, true);
kernelStart = kernel->textBase();
kernelEnd = kernel->bssBase() + kernel->bssSize();
kernelEntry = kernel->entryPoint();
DPRINTF(Loader, "Kernel start = %#x\n"
"Kernel end = %#x\n"
"Kernel entry = %#x\n",
kernelStart, kernelEnd, kernelEntry);
// Setup kernel boot parameters
initRegs->pc = 0x4001;
initRegs->npc = initRegs->pc + sizeof(MachInst);
DPRINTF(Loader, "Kernel loaded...\n");
kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic");
consolePanicEvent = new BreakPCEvent(&pcEventQueue, "console panic");
badaddrEvent = new BadAddrEvent(&pcEventQueue, "badaddr");
skipPowerStateEvent = new SkipFuncEvent(&pcEventQueue,
"tl_v48_capture_power_state");
skipScavengeBootEvent = new SkipFuncEvent(&pcEventQueue,
"pmap_scavenge_boot");
printfEvent = new PrintfEvent(&pcEventQueue, "printf");
debugPrintfEvent = new DebugPrintfEvent(&pcEventQueue,
"debug_printf", false);
debugPrintfrEvent = new DebugPrintfEvent(&pcEventQueue,
"debug_printfr", true);
dumpMbufEvent = new DumpMbufEvent(&pcEventQueue, "dump_mbuf");
Addr addr = 0;
if (kernelSymtab->findAddress("enable_async_printf", addr)) {
Addr paddr = vtophys(physmem, addr);
uint8_t *enable_async_printf =
physmem->dma_addr(paddr, sizeof(uint32_t));
if (enable_async_printf)
*(uint32_t *)enable_async_printf = 0;
}
if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
Addr paddr = vtophys(physmem, addr);
char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
if (osflags)
strcpy(osflags, boot_osflags.c_str());
}
if (kernelSymtab->findAddress("panic", addr))
kernelPanicEvent->schedule(addr);
else
panic("could not find kernel symbol \'panic\'");
if (consoleSymtab->findAddress("panic", addr))
consolePanicEvent->schedule(addr);
if (kernelSymtab->findAddress("badaddr", addr))
badaddrEvent->schedule(addr);
else
panic("could not find kernel symbol \'badaddr\'");
if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
skipPowerStateEvent->schedule(addr);
if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
skipScavengeBootEvent->schedule(addr);
#if TRACING_ON
if (kernelSymtab->findAddress("printf", addr))
printfEvent->schedule(addr);
if (kernelSymtab->findAddress("m5printf", addr))
debugPrintfEvent->schedule(addr);
if (kernelSymtab->findAddress("m5printfr", addr))
debugPrintfrEvent->schedule(addr);
if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
dumpMbufEvent->schedule(addr);
#endif
}
Tru64System::~Tru64System()
{
delete initRegs;
delete kernel;
delete console;
delete kernelSymtab;
delete consoleSymtab;
delete kernelPanicEvent;
delete consolePanicEvent;
delete badaddrEvent;
delete skipPowerStateEvent;
delete skipScavengeBootEvent;
delete printfEvent;
delete debugPrintfEvent;
delete debugPrintfrEvent;
delete dumpMbufEvent;
}
void
Tru64System::init(ExecContext *xc)
{
xc->regs = *initRegs;
remoteGDB = new RemoteGDB(this, xc);
gdbListen = new GDBListener(remoteGDB, 7000);
gdbListen->listen();
// Reset the system
//
TheISA::init(physmem, &xc->regs);
}
bool
Tru64System::breakpoint()
{
return remoteGDB->trap(ALPHA_KENTRY_IF);
}
BEGIN_DECLARE_SIM_OBJECT_PARAMS(Tru64System)
SimObjectParam<MemoryController *> mem_ctl;
SimObjectParam<PhysicalMemory *> physmem;
Param<string> kernel_code;
Param<string> console_code;
Param<string> pal_code;
Param<string> boot_osflags;
END_DECLARE_SIM_OBJECT_PARAMS(Tru64System)
BEGIN_INIT_SIM_OBJECT_PARAMS(Tru64System)
INIT_PARAM(mem_ctl, "memory controller"),
INIT_PARAM(physmem, "phsyical memory"),
INIT_PARAM(kernel_code, "file that contains the kernel code"),
INIT_PARAM(console_code, "file that contains the console code"),
INIT_PARAM(pal_code, "file that contains palcode"),
INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
"a")
END_INIT_SIM_OBJECT_PARAMS(Tru64System)
CREATE_SIM_OBJECT(Tru64System)
{
Tru64System *sys = new Tru64System(getInstanceName(), mem_ctl, physmem,
kernel_code, console_code, pal_code,
boot_osflags);
return sys;
}
REGISTER_SIM_OBJECT("Tru64System", Tru64System)

101
kern/tru64/tru64_system.hh Normal file
View file

@ -0,0 +1,101 @@
/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __TRU64_SYSTEM_HH__
#define __TRU64_SYSTEM_HH__
#include "sim/system.hh"
#include "targetarch/isa_traits.hh"
class ExecContext;
class EcoffObject;
class SymbolTable;
class BreakPCEvent;
class BadAddrEvent;
class SkipFuncEvent;
class PrintfEvent;
class DebugPrintfEvent;
class DumpMbufEvent;
class AlphaArguments;
class Tru64System : public System
{
private:
ExecContext *xc;
EcoffObject *kernel;
EcoffObject *console;
SymbolTable *kernelSymtab;
SymbolTable *consoleSymtab;
BreakPCEvent *kernelPanicEvent;
BreakPCEvent *consolePanicEvent;
BadAddrEvent *badaddrEvent;
SkipFuncEvent *skipPowerStateEvent;
SkipFuncEvent *skipScavengeBootEvent;
PrintfEvent *printfEvent;
DebugPrintfEvent *debugPrintfEvent;
DebugPrintfEvent *debugPrintfrEvent;
DumpMbufEvent *dumpMbufEvent;
private:
RegFile *initRegs;
Addr kernelStart;
Addr kernelEnd;
Addr kernelEntry;
public:
RemoteGDB *remoteGDB;
GDBListener *gdbListen;
public:
Tru64System(const std::string _name,
MemoryController *_memCtrl,
PhysicalMemory *_physmem,
const std::string &kernel_path,
const std::string &console_path,
const std::string &palcode,
const std::string &boot_osflags);
~Tru64System();
void init(ExecContext *xc);
Addr getKernelStart() const { return kernelStart; }
Addr getKernelEnd() const { return kernelEnd; }
Addr getKernelEntry() const { return kernelEntry; }
bool breakpoint();
static void Printf(AlphaArguments args);
static void DumpMbuf(AlphaArguments args);
};
#endif // __TRU64_SYSTEM_HH__

198
sim/system.cc
View file

@ -27,14 +27,8 @@
*/
#include "cpu/exec_context.hh"
#include "base/loader/object_file.hh"
#include "mem/functional_mem/memory_control.hh"
#include "mem/functional_mem/physical_memory.hh"
#include "base/loader/symtab.hh"
#include "base/remote_gdb.hh"
#include "targetarch/vtophys.hh"
#include "sim/system.hh"
#include "base/trace.hh"
using namespace std;
@ -44,170 +38,31 @@ int System::numSystemsRunning = 0;
System::System(const std::string _name,
MemoryController *_memCtrl,
PhysicalMemory *_physmem,
const std::string &kernel_path,
const std::string &console_path,
const std::string &palcode,
const std::string &boot_osflags)
PhysicalMemory *_physmem)
: SimObject(_name),
kernel_panic_event(&pcEventQueue, "kernel panic"),
console_panic_event(&pcEventQueue, "console panic"),
badaddr_event(&pcEventQueue, "badaddr"),
skip_power_state(&pcEventQueue, "tl_v48_capture_power_state"),
skip_scavenge_boot(&pcEventQueue, "pmap_scavenge_boot"),
printf_event(&pcEventQueue, "printf"),
debug_printf_event(&pcEventQueue, "debug_printf", false),
debug_printfr_event(&pcEventQueue, "debug_printfr", true),
dump_mbuf_event(&pcEventQueue, "dump_mbuf"),
memCtrl(_memCtrl),
physmem(_physmem),
remoteGDB(NULL),
gdbListen(NULL)
physmem(_physmem)
{
kernelSymtab = new SymbolTable;
consoleSymtab = new SymbolTable;
ObjectFile *kernel = createObjectFile(kernel_path);
if (kernel == NULL)
fatal("Could not load kernel file %s", kernel_path);
ObjectFile *console = createObjectFile(console_path);
if (console == NULL)
fatal("Could not load console file %s", console_path);
if (!kernel->loadGlobalSymbols(kernelSymtab))
panic("could not load kernel symbols\n");
if (!console->loadGlobalSymbols(consoleSymtab))
panic("could not load console symbols\n");
// Load pal file
ObjectFile *pal = createObjectFile(palcode);
if (pal == NULL)
fatal("Could not load PALcode file %s", palcode);
pal->loadSections(physmem, true);
// copy of initial reg file contents
initRegs = new RegFile;
memset(initRegs, 0, sizeof(RegFile));
// Load console file
console->loadSections(physmem, true);
// Load kernel file
kernel->loadSections(physmem, true);
kernelStart = kernel->textBase();
kernelEnd = kernel->bssBase() + kernel->bssSize();
kernelEntry = kernel->entryPoint();
DPRINTF(Loader, "Kernel start = %#x\n"
"Kernel end = %#x\n"
"Kernel entry = %#x\n",
kernelStart, kernelEnd, kernelEntry);
// Setup kernel boot parameters
initRegs->pc = 0x4001;
initRegs->npc = initRegs->pc + sizeof(MachInst);
DPRINTF(Loader, "Kernel loaded...\n");
#ifdef FULL_SYSTEM
Addr addr = 0;
for(int i = 0; i < 12/*MAX_CPUS*/; i++)
xc_array[i] = (ExecContext *) 0;
num_cpus = 0;
if (kernelSymtab->findAddress("enable_async_printf", addr)) {
Addr paddr = vtophys(physmem, addr);
uint8_t *enable_async_printf =
physmem->dma_addr(paddr, sizeof(uint32_t));
if (enable_async_printf)
*(uint32_t *)enable_async_printf = 0;
}
if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
Addr paddr = vtophys(physmem, addr);
char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
if (osflags)
strcpy(osflags, boot_osflags.c_str());
}
if (kernelSymtab->findAddress("panic", addr))
kernel_panic_event.schedule(addr);
else
panic("could not find kernel symbol \'panic\'");
if (consoleSymtab->findAddress("panic", addr))
console_panic_event.schedule(addr);
if (kernelSymtab->findAddress("badaddr", addr))
badaddr_event.schedule(addr);
else
panic("could not find kernel symbol \'badaddr\'");
if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
skip_power_state.schedule(addr);
if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
skip_scavenge_boot.schedule(addr);
#if TRACING_ON
if (kernelSymtab->findAddress("printf", addr))
printf_event.schedule(addr);
if (kernelSymtab->findAddress("m5printf", addr))
debug_printf_event.schedule(addr);
if (kernelSymtab->findAddress("m5printfr", addr))
debug_printfr_event.schedule(addr);
if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
dump_mbuf_event.schedule(addr);
#endif
#endif
// add self to global system list
systemList.push_back(this);
numSystemsRunning++;
}
System::~System()
{
delete kernelSymtab;
delete consoleSymtab;
delete initRegs;
}
void
System::initBootContext(ExecContext *xc)
{
xc->regs = *initRegs;
remoteGDB = new RemoteGDB(this, xc);
gdbListen = new GDBListener(remoteGDB, 7000);
gdbListen->listen();
// Reset the system
//
TheISA::init(physmem, &xc->regs);
}
void
System::registerExecContext(ExecContext *xc)
{
if (num_cpus == 12/*MAX_CPUS*/)
if (xc->cpu_id >= 12/*MAX_CPUS*/)
panic("Too many CPU's\n");
xc_array[xc->cpu_id] = xc;
num_cpus++;
if (xc->cpu_id >= xcvec.size())
xcvec.resize(xc->cpu_id + 1);
xcvec[xc->cpu_id] = xc;
}
@ -222,7 +77,6 @@ System::printSystems()
}
}
extern "C"
void
printSystems()
@ -230,39 +84,5 @@ printSystems()
System::printSystems();
}
DEFINE_SIM_OBJECT_CLASS_NAME("System", System)
BEGIN_DECLARE_SIM_OBJECT_PARAMS(System)
SimObjectParam<MemoryController *> mem_ctl;
SimObjectParam<PhysicalMemory *> physmem;
Param<string> kernel_code;
Param<string> console_code;
Param<string> pal_code;
Param<string> boot_osflags;
END_DECLARE_SIM_OBJECT_PARAMS(System)
BEGIN_INIT_SIM_OBJECT_PARAMS(System)
INIT_PARAM(mem_ctl, "memory controller"),
INIT_PARAM(physmem, "phsyical memory"),
INIT_PARAM(kernel_code, "file that contains the kernel code"),
INIT_PARAM(console_code, "file that contains the console code"),
INIT_PARAM(pal_code, "file that contains palcode"),
INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
"a")
END_INIT_SIM_OBJECT_PARAMS(System)
CREATE_SIM_OBJECT(System)
{
System *sys = new System(getInstanceName(), mem_ctl, physmem,
kernel_code, console_code, pal_code,
boot_osflags);
return sys;
}
REGISTER_SIM_OBJECT("System", System)

61
sim/system.hh
View file

@ -30,6 +30,7 @@
#define __SYSTEM_HH__
#include <string>
#include <vector>
#include "sim/sim_object.hh"
#include "cpu/pc_event.hh"
@ -44,67 +45,35 @@ class ExecContext;
class System : public SimObject
{
private:
SymbolTable *kernelSymtab;
SymbolTable *consoleSymtab;
BreakPCEvent kernel_panic_event;
BreakPCEvent console_panic_event;
BadAddrEvent badaddr_event;
SkipFuncEvent skip_power_state;
SkipFuncEvent skip_scavenge_boot;
PrintfEvent printf_event;
DebugPrintfEvent debug_printf_event;
DebugPrintfEvent debug_printfr_event;
DumpMbufEvent dump_mbuf_event;
RegFile *initRegs;
Addr kernelStart;
Addr kernelEnd;
Addr kernelEntry;
public:
MemoryController *memCtrl;
PhysicalMemory *physmem;
PCEventQueue pcEventQueue;
ExecContext *xc_array[12/*MAX_CPUS*/];
int num_cpus;
RemoteGDB *remoteGDB;
GDBListener *gdbListen;
System(const std::string name,
MemoryController *, PhysicalMemory *,
const std::string &kernel_path, const std::string &console_path,
const std::string &palcode, const std::string &boot_osflags);
~System();
const SymbolTable *getKernelSymtab() const { return kernelSymtab; }
const SymbolTable *getConsoleSymtab() const { return consoleSymtab; }
Addr getKernelStart() const { return kernelStart; }
Addr getKernelEnd() const { return kernelEnd; }
Addr getKernelEntry() const { return kernelEntry; }
void initBootContext(ExecContext *xc);
std::vector<ExecContext *> xcvec;
void registerExecContext(ExecContext *xc);
public:
System(const std::string name, MemoryController *, PhysicalMemory *);
~System();
virtual void init(ExecContext *xc) = 0;
virtual Addr getKernelStart() const = 0;
virtual Addr getKernelEnd() const = 0;
virtual Addr getKernelEntry() const = 0;
virtual bool breakpoint() = 0;
public:
////////////////////////////////////////////
//
// STATIC GLOBAL SYSTEM LIST
//
////////////////////////////////////////////
public:
static std::vector<System *> systemList;
static int numSystemsRunning;
static void printSystems();