Split up kernel.cc into separate files for dump_mbuf and printf

cpu/exec_context.hh:
dev/alpha_console.cc:
sim/system.cc:
sim/system.hh:
    Convert from fixed array to a vector
arch/alpha/arguments.hh:
    now that CopyData and CopyString are in vtophys.hh, this
    include is not necessary
arch/alpha/vtophys.hh:
    Include isa_traits.hh for Addr
cpu/pc_event.cc:
    Temporarily get this working while we're changing things

--HG--
extra : convert_revision : 9a7597b7bd5d050819766f8edf7a02f28447b9ca

10 files changed, 442 insertions, 18 deletions

diff --git a/arch/alpha/arguments.hh b/arch/alpha/arguments.hh
index 18569c688..78e66b3fd 100644
--- a/arch/alpha/arguments.hh
+++ b/arch/alpha/arguments.hh
@@ -32,7 +32,6 @@
 #include <assert.h>
 
 #include "base/refcnt.hh"
-#include "kern/tru64/kernel.hh"
 #include "sim/host.hh"
 #include "targetarch/vtophys.hh"
 
diff --git a/arch/alpha/vtophys.hh b/arch/alpha/vtophys.hh
index 75a589259..47ee538a6 100644
--- a/arch/alpha/vtophys.hh
+++ b/arch/alpha/vtophys.hh
@@ -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)
diff --git a/cpu/exec_context.hh b/cpu/exec_context.hh
index 5c1db6297..6964b35b8 100644
--- a/cpu/exec_context.hh
+++ b/cpu/exec_context.hh
@@ -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;
             }
diff --git a/cpu/pc_event.cc b/cpu/pc_event.cc
index a275c2c41..7b72f5c08 100644
--- a/cpu/pc_event.cc
+++ b/cpu/pc_event.cc
@@ -40,7 +40,6 @@
 #ifdef FULL_SYSTEM
 #include "targetarch/arguments.hh"
 #include "targetarch/pmap.h"
-#include "kern/tru64/kernel.hh"
 #include "mem/functional_mem/memory_control.hh"
 #include "cpu/full_cpu/cpu.hh"
 #include "sim/system.hh"
@@ -163,6 +162,9 @@ BadAddrEvent::process(ExecContext *xc)
         DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
 }
 
+void Printf(AlphaArguments args);
+void DumpMbuf(AlphaArguments args);
+
 void
 PrintfEvent::process(ExecContext *xc)
 {
@@ -170,7 +172,7 @@ PrintfEvent::process(ExecContext *xc)
         DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
 
         AlphaArguments args(xc);
-        Kernel::Printf(args);
+        Printf(args);
     }
 }
 
@@ -182,7 +184,7 @@ DebugPrintfEvent::process(ExecContext *xc)
             DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
 
         AlphaArguments args(xc);
-        Kernel::Printf(args);
+        Printf(args);
     }
 }
 
@@ -191,7 +193,7 @@ DumpMbufEvent::process(ExecContext *xc)
 {
     if (DTRACE(DebugPrintf)) {
         AlphaArguments args(xc);
-        Kernel::DumpMbuf(args);
+        DumpMbuf(args);
     }
 }
 #endif
diff --git a/dev/alpha_console.cc b/dev/alpha_console.cc
index e2de5f7ac..526ef0b3c 100644
--- a/dev/alpha_console.cc
+++ b/dev/alpha_console.cc
@@ -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;
diff --git a/kern/tru64/dump_mbuf.cc b/kern/tru64/dump_mbuf.cc
new file mode 100644
index 000000000..987412d95
--- /dev/null
+++ b/kern/tru64/dump_mbuf.cc
@@ -0,0 +1,68 @@
+/*
+ * 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"
+
+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));
+    }
+}
diff --git a/kern/tru64/mbuf.hh b/kern/tru64/mbuf.hh
new file mode 100644
index 000000000..bfee0b3fa
--- /dev/null
+++ b/kern/tru64/mbuf.hh
@@ -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__
diff --git a/kern/tru64/printf.cc b/kern/tru64/printf.cc
new file mode 100644
index 000000000..3dd1ee664
--- /dev/null
+++ b/kern/tru64/printf.cc
@@ -0,0 +1,262 @@
+/*
+ * 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;
+
+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);
+}
diff --git a/sim/system.cc b/sim/system.cc
index 74216176a..999782e48 100644
--- a/sim/system.cc
+++ b/sim/system.cc
@@ -114,11 +114,6 @@ System::System(const std::string _name,
 #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 =
@@ -204,10 +199,13 @@ System::initBootContext(ExecContext *xc)
 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;
 }
 
 
diff --git a/sim/system.hh b/sim/system.hh
index 830e78f4a..3ab514bfa 100644
--- a/sim/system.hh
+++ b/sim/system.hh
@@ -30,6 +30,7 @@
 #define __SYSTEM_HH__
 
 #include <string>
+#include <vector>
 
 #include "sim/sim_object.hh"
 #include "cpu/pc_event.hh"
@@ -72,8 +73,7 @@ class System : public SimObject
 
     PCEventQueue pcEventQueue;
 
-    ExecContext *xc_array[12/*MAX_CPUS*/];
-    int num_cpus;
+    std::vector<ExecContext *> xcvec;
 
     RemoteGDB *remoteGDB;
     GDBListener *gdbListen;