diff options
| -rw-r--r-- | arch/alpha/alpha_memory.cc | 3 | ||||
| -rw-r--r-- | arch/alpha/isa_desc | 35 | ||||
| -rw-r--r-- | base/compression/null_compression.hh | 4 | ||||
| -rw-r--r-- | base/range.cc | 83 | ||||
| -rw-r--r-- | base/range.hh | 429 | ||||
| -rw-r--r-- | base/remote_gdb.cc | 2 | ||||
| -rw-r--r-- | cpu/static_inst.hh | 24 | ||||
| -rw-r--r-- | dev/alpha_access.h | 2 | ||||
| -rw-r--r-- | dev/alpha_console.cc | 19 | ||||
| -rw-r--r-- | dev/alpha_console.hh | 11 | ||||
| -rw-r--r-- | dev/etherlink.hh | 2 | ||||
| -rw-r--r-- | sim/eventq.hh | 4 | ||||
| -rw-r--r-- | sim/serialize.cc | 4 | ||||
| -rw-r--r-- | sim/serialize.hh | 2 | ||||
| -rw-r--r-- | sim/sim_object.hh | 2 | ||||
| -rw-r--r-- | test/Makefile | 2 | ||||
| -rw-r--r-- | test/rangetest.cc | 78 |
17 files changed, 457 insertions, 249 deletions
diff --git a/arch/alpha/alpha_memory.cc b/arch/alpha/alpha_memory.cc index d68c99b2c..00e97250f 100644 --- a/arch/alpha/alpha_memory.cc +++ b/arch/alpha/alpha_memory.cc @@ -97,7 +97,8 @@ AlphaTlb::checkCacheability(MemReqPtr &req) break; default: - panic("IPR memory space not implemented! PA=%x\n", req->paddr); + panic("IPR memory space not implemented! PA=%x\n", + req->paddr); } } } else { diff --git a/arch/alpha/isa_desc b/arch/alpha/isa_desc index 51bce65c2..75b2f4138 100644 --- a/arch/alpha/isa_desc +++ b/arch/alpha/isa_desc @@ -1225,7 +1225,7 @@ declare {{ { } - Addr branchTarget(Addr branchPC) + Addr branchTarget(Addr branchPC) const { return branchPC + 4 + disp; } @@ -1287,7 +1287,7 @@ declare {{ { } - Addr branchTarget(ExecContext *xc) + Addr branchTarget(ExecContext *xc) const { Addr NPC = xc->readPC() + 4; uint64_t Rb = xc->readIntReg(_srcRegIdx[0]); @@ -2330,10 +2330,6 @@ decode OPCODE default Unknown::unknown() { // miscellaneous mem-format ops 0x18: decode MEMFUNC { format WarnUnimpl { - 0x0000: trapb(); - 0x0400: excb(); - 0x4000: mb(); - 0x4400: wmb(); 0x8000: fetch(); 0xa000: fetch_m(); 0xe800: ecb(); @@ -2347,6 +2343,27 @@ decode OPCODE default Unknown::unknown() { format BasicOperate { 0xc000: rpcc({{ Ra = curTick; }}); + + // All of the barrier instructions below do nothing in + // their execute() methods (hence the empty code blocks). + // All of their functionality is hard-coded in the + // pipeline based on the flags IsSerializing, + // IsMemBarrier, and IsWriteBarrier. In the current + // detailed CPU model, the execute() function only gets + // called at fetch, so there's no way to generate pipeline + // behavior at any other stage. Once we go to an + // exec-in-exec CPU model we should be able to get rid of + // these flags and implement this behavior via the + // execute() methods. + + // trapb is just a barrier on integer traps, where excb is + // a barrier on integer and FP traps. "EXCB is thus a + // superset of TRAPB." (Alpha ARM, Sec 4.11.4) We treat + // them the same though. + 0x0000: trapb({{ }}, IsSerializing, No_OpClass); + 0x0400: excb({{ }}, IsSerializing, No_OpClass); + 0x4000: mb({{ }}, IsMemBarrier, RdPort); + 0x4400: wmb({{ }}, IsWriteBarrier, WrPort); } #ifdef FULL_SYSTEM @@ -2356,13 +2373,13 @@ decode OPCODE default Unknown::unknown() { if (!xc->misspeculating()) { xc->regs.intrflag = 0; } - }}, No_OpClass); + }}); 0xf000: rs({{ Ra = xc->regs.intrflag; if (!xc->misspeculating()) { xc->regs.intrflag = 1; } - }}, No_OpClass); + }}); } #else format FailUnimpl { @@ -2476,7 +2493,7 @@ decode OPCODE default Unknown::unknown() { if (!xc->misspeculating()) AlphaPseudo::m5exit(xc); }}, No_OpClass); - 0x30: initparam({{ Ra = xc->cpu->system->init_param; }}); + 0x30: initparam({{ Ra = cpu->system->init_param; }}); 0x40: resetstats({{ if (!xc->misspeculating()) AlphaPseudo::resetstats(xc); diff --git a/base/compression/null_compression.hh b/base/compression/null_compression.hh index d2bc76eef..6a630b113 100644 --- a/base/compression/null_compression.hh +++ b/base/compression/null_compression.hh @@ -34,6 +34,10 @@ * This file defines a doNothing compression algorithm. */ +#include <inttypes.h> // for uint8_t +#include "base/misc.hh" // for fatal() + + /** * A dummy compression class to use when no data compression is desired. */ diff --git a/base/range.cc b/base/range.cc new file mode 100644 index 000000000..0a4876e89 --- /dev/null +++ b/base/range.cc @@ -0,0 +1,83 @@ +/* + * 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/intmath.hh" +#include "base/range.hh" +#include "base/str.hh" + +using namespace std; + +template <class T> +bool +__x_parse_range(const std::string &str, T &start, T &end) +{ + std::vector<std::string> values; + tokenize(values, str, ':'); + + T thestart, theend; + + if (values.size() != 2) + return false; + + std::string s = values[0]; + std::string e = values[1]; + + if (!to_number(s, thestart)) + return false; + + bool increment = (e[0] == '+'); + if (increment) + e = e.substr(1); + + if (!to_number(e, theend)) + return false; + + if (increment) + theend += thestart; + + start = thestart; + end = theend; + + return true; +} + +#define RANGE_PARSE(type) \ +template<> bool \ +__parse_range(const std::string &s, type &start, type &end) \ +{ return __x_parse_range(s, start, end); } + +RANGE_PARSE(unsigned long long); +RANGE_PARSE(signed long long); +RANGE_PARSE(unsigned long); +RANGE_PARSE(signed long); +RANGE_PARSE(unsigned int); +RANGE_PARSE(signed int); +RANGE_PARSE(unsigned short); +RANGE_PARSE(signed short); +RANGE_PARSE(unsigned char); +RANGE_PARSE(signed char); diff --git a/base/range.hh b/base/range.hh index 3443bf246..d72aa9755 100644 --- a/base/range.hh +++ b/base/range.hh @@ -29,232 +29,351 @@ #ifndef __RANGE_HH__ #define __RANGE_HH__ -#include <assert.h> +#include <cassert> +#include <string> -#include "base/intmath.hh" -#include "base/str.hh" +template <class T> +bool __parse_range(const std::string &s, T &start, T &end); -template<class T> -class Range +template <class T> +struct Range { private: - bool valid; + /** + * @param s range string + * Ranges are in the following format: + * <range> := {<start_val>}:{<end>} + * <end> := <end_val> | +<delta> + */ + void + parse(const std::string &s) + { + if (!__parse_range(s, start, end)) + invalidate(); + } public: T start; T end; public: - Range() {} + Range() + { + invalidate(); + } - Range(const Range &r) { operator=(r); } + Range(T first, T second) + : start(first), end(second) + {} - Range(const T &s, const T &e) - : start(s), end(e) + template <class U> + Range(const Range<U> &r) + : start(r.start), end(r.end) + {} + + template <class U> + Range(const std::pair<U, U> &r) + : start(r.first), end(r.second) + {} + + Range(const std::string &s) { - valid = (start <= end); + parse(s); } - Range(const std::string &s) { valid = parse(s); } + template <class U> + const Range<T> &operator=(const Range<U> &r) + { + start = r.start; + end = r.end; + return *this; + } - ~Range() {} + template <class U> + const Range<T> &operator=(const std::pair<U, U> &r) + { + start = r.first; + end = r.second; + return *this; + } - int compare(const T &p); - bool parse(const std::string &s); - const Range &operator=(const Range &r); + const Range &operator=(const std::string &s) + { + parse(s); + return *this; + } - bool isValid() const { return valid; } + void invalidate() { start = 0; end = 0; } + T size() const { return end - start; } + bool valid() const { return start < end; } }; +template <class T> +inline Range<T> +make_range(T start, T end) +{ + return Range<T>(start, end); +} -template<class T> -inline int -Range<T>::compare(const T &p) +template <class T> +inline std::ostream & +operator<<(std::ostream &o, const Range<T> &r) { - assert(isValid()); - - if (p < start) - return -1; - else if (p > end) - return 1; - else - return 0; + // don't currently support output of invalid ranges + assert(r.valid()); + o << r.start << ":" << r.end; + return o; } -// Parse a range string +//////////////////////////////////////////////////////////////////////// +// +// Range to Range Comparisons // -// Ranges are in the following format: -// <range> := {<start_val>}:{<end>} -// <end> := <end_val> | +<delta> -template<class T> + +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 and range2 are identical. + */ +template <class T, class U> inline bool -Range<T>::parse(const std::string &str) +operator==(const Range<T> &range1, const Range<U> &range2) { - std::vector<std::string> values; - tokenize(values, str, ':'); - - T thestart, theend; - - if (values.size() != 2) - return false; - - std::string s = values[0]; - std::string e = values[1]; - - if (!to_number(s, thestart)) - return false; - - bool increment = (e[0] == '+'); - if (increment) - e = e.substr(1); - - if (!to_number(e, theend)) - return false; - - if (increment) - theend += thestart; - - start = thestart; - end = theend; - - if (start > end) - return false; - - return true; + assert(range1.valid() && range2.valid()); + return range1.start == range2.start && range1.end == range2.end; } - -template<class T> -inline const Range<T> & -Range<T>::operator=(const Range<T> &r) +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 and range2 are not identical. + */ +template <class T, class U> +inline bool +operator!=(const Range<T> &range1, const Range<U> &range2) { - if (this != &r) { - start = r.start; - end = r.end; - - valid = r.valid; - } - else { - valid = false; - } + assert(range1.valid() && range2.valid()); + return range1.start != range2.start || range1.end != range2.end; +} - return *this; +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 is less than range2 and does not overlap range1. + */ +template <class T, class U> +inline bool +operator<(const Range<T> &range1, const Range<U> &range2) +{ + assert(range1.valid() && range2.valid()); + return range1.end <= range2.start; } -template<class T> -inline std::ostream & -operator<<(std::ostream &o, const Range<T> &r) +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 is less than range2. range1 may overlap range2, + * but not extend beyond the end of range2. + */ +template <class T, class U> +inline bool +operator<=(const Range<T> &range1, const Range<U> &range2) { - // don't currently support output of invalid ranges - assert(r.isValid()); - o << r.start << ":" << r.end; - return o; + assert(range1.valid() && range2.valid()); + return range1.start <= range2.start && range1.end <= range2.end; } -////////////////////////////////////////// -// -// Compare two ranges -// -template<class T> +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 is greater than range2 and does not overlap range2. + */ +template <class T, class U> inline bool -operator==(const Range<T> &l, const Range<T> &r) +operator>(const Range<T> &range1, const Range<U> &range2) { - // ranges must both be valid to be equal - return (l.isValid() && r.isValid() && - (l.start == r.start) && (l.end == r.end)); + assert(range1.valid() && range2.valid()); + return range1.start >= range2.end; } -template<class T> +/** + * @param range1 is a range. + * @param range2 is a range. + * @return if range1 is greater than range2. range1 may overlap range2, + * but not extend beyond the beginning of range2. + */ +template <class T, class U> inline bool -operator!=(const Range<T> &l, const Range<T> &r) +operator>=(const Range<T> &range1, const Range<U> &range2) { - // for symmetry with ==, an invalid range is not equal to any other - return (!l.isValid() || !r.isValid() || - (l.start != r.start) || (l.end != r.end)); + assert(range1.valid() && range2.valid()); + return range1.start >= range2.start && range1.end >= range2.end; } -////////////////////////////////////////// -// -// Compare position to a range -// -// - 'pos == range' indicates that position pos is within the given range. -// This test always returns false if the range is invalid. -// -// - 'pos < range' and 'pos > range' indicate that the position is -// before the start of or after the end of the range, respectively. -// The range must be valid for these comparisons to be made. -// -// All other comparisons do the obvious thing based on these definitions. +//////////////////////////////////////////////////////////////////////// // +// Position to Range Comparisons // -// -// Basic comparisons -// -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is within the range. + */ +template <class T, class U> inline bool -operator==(const T &pos, const Range<T> &range) -{ return range.isValid() && pos >= range.start && pos <= range.end; } +operator==(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos >= range.start && pos < range.end; +} -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is not within the range. + */ +template <class T, class U> inline bool -operator<(const T &pos, const Range<T> &range) -{ assert(range.isValid()); return pos < range.start; } +operator!=(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos < range.start || pos >= range.end; +} -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is below the range. + */ +template <class T, class U> inline bool -operator>(const T &pos, const Range<T> &range) -{ assert(range.isValid()); return pos > range.end; } +operator<(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos < range.start; +} -// -// Derived comparisons -// -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is below or in the range. + */ +template <class T, class U> inline bool -operator<=(const T &pos, const Range<T> &range) -{ assert(range.isValid()); return pos <= range.end; } +operator<=(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos < range.end; +} -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is above the range. + */ +template <class T, class U> inline bool -operator>=(const T &pos, const Range<T> &range) -{ assert(range.isValid()); return pos >= range.start; } +operator>(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos >= range.end; +} -template<class T> +/** + * @param pos position compared to the range. + * @param range range compared against. + * @return indicates that position pos is above or in the range. + */ +template <class T, class U> inline bool -operator!=(const T &pos, const Range<T> &range) -{ return !(pos == range); } +operator>=(const T &pos, const Range<U> &range) +{ + assert(range.valid()); + return pos >= range.start; +} +//////////////////////////////////////////////////////////////////////// // -// Define symmetric comparisons based on above +// Range to Position Comparisons (for symmetry) // -template<class T> + +/** + * @param range range compared against. + * @param pos position compared to the range. + * @return indicates that position pos is within the range. + */ +template <class T, class U> inline bool -operator>(const Range<T> &range, const T &pos) -{ return pos < range; } +operator==(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return pos >= range.start && pos < range.end; +} -template<class T> +/** + * @param range range compared against. + * @param pos position compared to the range. + * @return indicates that position pos is not within the range. + */ +template <class T, class U> inline bool -operator<(const Range<T> &range, const T &pos) -{ return pos > range; } +operator!=(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return pos < range.start || pos >= range.end; +} -template<class T> +/** + * @param range range compared against. + * @param pos position compared to the range. + * @return indicates that position pos is above the range. + */ +template <class T, class U> inline bool -operator<=(const Range<T> &range, const T &pos) -{ return pos >= range; } +operator<(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return range.end <= pos; +} -template<class T> +/** + * @param range range compared against. + * @param pos position compared to the range. + * @return indicates that position pos is above or in the range. + */ +template <class T, class U> inline bool -operator>=(const Range<T> &range, const T &pos) -{ return pos <= range; } +operator<=(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return range.start <= pos; +} -template<class T> +/** + * @param range range compared against. + * @param pos position compared to the range. + * 'range > pos' indicates that position pos is below the range. + */ +template <class T, class U> inline bool -operator==(const Range<T> &range, const T &pos) -{ return (pos == range); } +operator>(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return range.start > pos; +} -template<class T> +/** + * @param range range compared against. + * @param pos position compared to the range. + * 'range >= pos' indicates that position pos is below or in the range. + */ +template <class T, class U> inline bool -operator!=(const Range<T> &range, const T &pos) -{ return (pos != range); } +operator>=(const Range<T> &range, const U &pos) +{ + assert(range.valid()); + return range.end > pos; +} #endif // __RANGE_HH__ diff --git a/base/remote_gdb.cc b/base/remote_gdb.cc index e701b5a01..e20800d12 100644 --- a/base/remote_gdb.cc +++ b/base/remote_gdb.cc @@ -338,7 +338,7 @@ RemoteGDB::acc(Addr va, size_t len) } if (va < ALPHA_K1SEG_BASE) { - if (va < (ALPHA_K0SEG_BASE + pmem->getSize())) { + if (va < (ALPHA_K0SEG_BASE + pmem->size())) { DPRINTF(GDBAcc, "acc: Mapping is valid K0SEG <= " "%#x < K0SEG + size\n", va); return true; diff --git a/cpu/static_inst.hh b/cpu/static_inst.hh index f3fd6fa24..5f4bcae3d 100644 --- a/cpu/static_inst.hh +++ b/cpu/static_inst.hh @@ -78,6 +78,12 @@ class StaticInstBase : public RefCounted /// - If IsControl is set, then exactly one of IsDirectControl or /// IsIndirect Control will be set, and exactly one of /// IsCondControl or IsUncondControl will be set. + /// - IsSerializing, IsMemBarrier, and IsWriteBarrier are + /// implemented as flags since in the current model there's no + /// other way for instructions to inject behavior into the + /// pipeline outside of fetch. Once we go to an exec-in-exec CPU + /// model we should be able to get rid of these flags and + /// implement this behavior via the execute() methods. /// enum Flags { IsNop, ///< Is a no-op (no effect at all). @@ -99,7 +105,12 @@ class StaticInstBase : public RefCounted IsCall, ///< Subroutine call. IsReturn, ///< Subroutine return. - IsThreadSync, ///< Thread synchronization operation. + IsThreadSync, ///< Thread synchronization operation. + + IsSerializing, ///< Serializes pipeline: won't until all + /// older instructions have committed. + IsMemBarrier, ///< Is a memory barrier + IsWriteBarrier, ///< Is a write barrier NumFlags }; @@ -178,6 +189,9 @@ class StaticInstBase : public RefCounted bool isUncondCtrl() const { return flags[IsUncondControl]; } bool isThreadSync() const { return flags[IsThreadSync]; } + bool isSerializing() const { return flags[IsSerializing]; } + bool isMemBarrier() const { return flags[IsMemBarrier]; } + bool isWriteBarrier() const { return flags[IsWriteBarrier]; } //@} /// Operation class. Used to select appropriate function unit in issue. @@ -216,11 +230,11 @@ class StaticInst : public StaticInstBase /// Return logical index (architectural reg num) of i'th destination reg. /// Only the entries from 0 through numDestRegs()-1 are valid. - RegIndex destRegIdx(int i) { return _destRegIdx[i]; } + RegIndex destRegIdx(int i) const { return _destRegIdx[i]; } /// Return logical index (architectural reg num) of i'th source reg. /// Only the entries from 0 through numSrcRegs()-1 are valid. - RegIndex srcRegIdx(int i) { return _srcRegIdx[i]; } + RegIndex srcRegIdx(int i) const { return _srcRegIdx[i]; } /// Pointer to a statically allocated "null" instruction object. /// Used to give eaCompInst() and memAccInst() something to return @@ -305,7 +319,7 @@ class StaticInst : public StaticInstBase * Invalid if not a PC-relative branch (i.e. isDirectCtrl() * should be true). */ - virtual Addr branchTarget(Addr branchPC) + virtual Addr branchTarget(Addr branchPC) const { panic("StaticInst::branchTarget() called on instruction " "that is not a PC-relative branch."); @@ -318,7 +332,7 @@ class StaticInst : public StaticInstBase * execute the branch in question. Invalid if not an indirect * branch (i.e. isIndirectCtrl() should be true). */ - virtual Addr branchTarget(ExecContext *xc) + virtual Addr branchTarget(ExecContext *xc) const { panic("StaticInst::branchTarget() called on instruction " "that is not an indirect branch."); diff --git a/dev/alpha_access.h b/dev/alpha_access.h index 7502635e9..40567e96f 100644 --- a/dev/alpha_access.h +++ b/dev/alpha_access.h @@ -36,7 +36,7 @@ #define ALPHA_ACCESS_VERSION (1301) /* CH++*/ #ifndef CONSOLE -#include <ostream> +#include <iosfwd> #include <string> class Checkpoint; #endif diff --git a/dev/alpha_console.cc b/dev/alpha_console.cc index 9411c6470..e1b69c3ce 100644 --- a/dev/alpha_console.cc +++ b/dev/alpha_console.cc @@ -56,6 +56,8 @@ AlphaConsole::AlphaConsole(const string &name, SimConsole *cons, Addr addr, Addr mask, MemoryController *mmu) : MmapDevice(name, addr, mask, mmu), disk(d), console(cons) { + mmu->add_child(this, Range<Addr>(addr, addr + size)); + consoleData = new uint8_t[size]; memset(consoleData, 0, size); @@ -66,7 +68,7 @@ AlphaConsole::AlphaConsole(const string &name, SimConsole *cons, alphaAccess->version = ALPHA_ACCESS_VERSION; alphaAccess->numCPUs = num_cpus; - alphaAccess->mem_size = system->physmem->getSize(); + alphaAccess->mem_size = system->physmem->size(); alphaAccess->cpuClock = cpu->getFreq() / 1000000; alphaAccess->intrClockFrequency = clock->frequency(); @@ -79,7 +81,8 @@ AlphaConsole::read(MemReqPtr &req, uint8_t *data) memset(data, 0, req->size); uint64_t val; - Addr daddr = req->paddr & addr_mask; + Addr daddr = req->paddr - addr; + switch (daddr) { case offsetof(AlphaAccess, inputChar): val = console->console_in(); @@ -126,7 +129,7 @@ AlphaConsole::write(MemReqPtr &req, const uint8_t *data) return Machine_Check_Fault; } - Addr daddr = req->paddr & addr_mask; + Addr daddr = req->paddr - addr; ExecContext *other_xc; switch (daddr) { @@ -244,11 +247,9 @@ BEGIN_DECLARE_SIM_OBJECT_PARAMS(AlphaConsole) SimObjectParam<SimConsole *> sim_console; SimObjectParam<SimpleDisk *> disk; - Param<int> size; Param<int> num_cpus; SimObjectParam<MemoryController *> mmu; Param<Addr> addr; - Param<Addr> mask; SimObjectParam<System *> system; SimObjectParam<BaseCPU *> cpu; SimObjectParam<TsunamiIO *> clock; @@ -259,11 +260,9 @@ BEGIN_INIT_SIM_OBJECT_PARAMS(AlphaConsole) INIT_PARAM(sim_console, "The Simulator Console"), INIT_PARAM(disk, "Simple Disk"), - INIT_PARAM_DFLT(size, "AlphaConsole size", sizeof(AlphaAccess)), INIT_PARAM_DFLT(num_cpus, "Number of CPU's", 1), INIT_PARAM(mmu, "Memory Controller"), INIT_PARAM(addr, "Device Address"), - INIT_PARAM(mask, "Address Mask"), INIT_PARAM(system, "system object"), INIT_PARAM(cpu, "Processor"), INIT_PARAM(clock, "Turbolaser Clock") @@ -272,10 +271,8 @@ END_INIT_SIM_OBJECT_PARAMS(AlphaConsole) CREATE_SIM_OBJECT(AlphaConsole) { - return new AlphaConsole(getInstanceName(), sim_console, - disk, size, system, - cpu, clock, num_cpus, - addr, mask, mmu); + return new AlphaConsole(getInstanceName(), sim_console, disk, + system, cpu, clock, num_cpus, mmu, addr); } REGISTER_SIM_OBJECT("AlphaConsole", AlphaConsole) diff --git a/dev/alpha_console.hh b/dev/alpha_console.hh index 4647be538..29ebec1bb 100644 --- a/dev/alpha_console.hh +++ b/dev/alpha_console.hh @@ -33,9 +33,10 @@ #ifndef __ALPHA_CONSOLE_HH__ #define __ALPHA_CONSOLE_HH__ -#include "sim/host.hh" +#include "base/range.hh" #include "dev/alpha_access.h" -#include "mem/functional_mem/mmap_device.hh" +#include "mem/functional_mem/functional_memory.hh" +#include "sim/host.hh" #include "dev/tsunami_io.hh" class BaseCPU; @@ -69,7 +70,7 @@ class SimpleDisk; * primarily used doing boot before the kernel has loaded its device * drivers. */ -class AlphaConsole : public MmapDevice +class AlphaConsole : public FunctionalMemory { protected: union { @@ -83,6 +84,9 @@ class AlphaConsole : public MmapDevice /** the system console (the terminal) is accessable from the console */ SimConsole *console; + Addr addr; + static const Addr size = 0x80; // equal to sizeof(alpha_access); + public: /** Standard Constructor */ AlphaConsole(const std::string &name, SimConsole *cons, @@ -91,7 +95,6 @@ class AlphaConsole : public MmapDevice TsunamiIO *clock, int num_cpus, Addr addr, Addr mask, MemoryController *mmu); - public: /** * memory mapped reads and writes */ diff --git a/dev/etherlink.hh b/dev/etherlink.hh index 895bac2e1..e1a7957ee 100644 --- a/dev/etherlink.hh +++ b/dev/etherlink.hh @@ -89,7 +89,7 @@ class EtherLink : public SimObject Link(const std::string &name, double rate, EtherDump *dump); ~Link() {} - virtual std::string name() const { return objName; } + virtual const std::string name() const { return objName; } bool busy() const { return (bool)packet; } bool transmit(PacketPtr &packet); diff --git a/sim/eventq.hh b/sim/eventq.hh index 36cb402a8..31bf9d652 100644 --- a/sim/eventq.hh +++ b/sim/eventq.hh @@ -153,7 +153,7 @@ class Event : public Serializable, public FastAlloc ~Event() {} - virtual std::string name() const { + virtual const std::string name() const { return csprintf("Event_%x", (uintptr_t)this); } @@ -257,7 +257,7 @@ class EventQueue : public Serializable : objName(n), head(NULL) {} - virtual std::string name() const { return objName; } + virtual const std::string name() const { return objName; } // schedule the given event on this queue void schedule(Event *ev); diff --git a/sim/serialize.cc b/sim/serialize.cc index ba5a99afd..f8d6b46bf 100644 --- a/sim/serialize.cc +++ b/sim/serialize.cc @@ -186,7 +186,7 @@ INSTANTIATE_PARAM_TEMPLATES(string) class Globals : public Serializable { public: - string name() const; + const string name() const; void serialize(ostream &os); void unserialize(Checkpoint *cp); }; @@ -194,7 +194,7 @@ class Globals : public Serializable /// The one and only instance of the Globals class. Globals globals; -string +const string Globals::name() const { return "Globals"; diff --git a/sim/serialize.hh b/sim/serialize.hh index e561604bf..36622b7fe 100644 --- a/sim/serialize.hh +++ b/sim/serialize.hh @@ -111,7 +111,7 @@ class Serializable virtual ~Serializable() {} // manditory virtual function, so objects must provide names - virtual std::string name() const = 0; + virtual const std::string name() const = 0; virtual void serialize(std::ostream &os) {} virtual void unserialize(Checkpoint *cp, const std::string §ion) {} diff --git a/sim/sim_object.hh b/sim/sim_object.hh index 165931b2b..aaaafc04b 100644 --- a/sim/sim_object.hh +++ b/sim/sim_object.hh @@ -63,7 +63,7 @@ class SimObject : public Serializable virtual ~SimObject() {} - virtual std::string name() const { return objName; } + virtual const std::string name() const { return objName; } // initialization pass of all objects. Gets invoked by SimInit() virtual void init(); diff --git a/test/Makefile b/test/Makefile index 2c3780c93..d62dba64a 100644 --- a/test/Makefile +++ b/test/Makefile @@ -49,7 +49,7 @@ nmtest: nmtest.o object_file.o symtab.o misc.o str.o offtest: offtest.o $(CXX) $(LFLAGS) -o $@ $^ -rangetest: rangetest.o str.o +rangetest: rangetest.o range.o str.o $(CXX) $(LFLAGS) -o $@ $^ stattest: cprintf.o hostinfo.o misc.o python.o statistics.o stattest.o \ diff --git a/test/rangetest.cc b/test/rangetest.cc index f44d835b7..c38c13fd1 100644 --- a/test/rangetest.cc +++ b/test/rangetest.cc @@ -31,11 +31,12 @@ #include "base/range.hh" +using namespace std; int main() { - Range<int> r1(9, 28); + Range<int> r1(make_pair(9, 28)); Range<unsigned> r2("0x1000:+0x100"); cout << r1 << "\n" @@ -44,61 +45,30 @@ main() #define RANGETEST(X, C, Y) \ cout << X << " "#C" " << Y << " => " << ((X C Y) ? "true" : "false") << "\n" - int i1 = 10; - int i2 = 0x1001; - RANGETEST(i1, < , r1); - RANGETEST(i1, <=, r1); - RANGETEST(i1, > , r1); - RANGETEST(i1, >=, r1); - RANGETEST(i1, ==, r1); - RANGETEST(i1, !=, r1); - RANGETEST(r1, < , i1); - RANGETEST(r1, <=, i1); - RANGETEST(r1, > , i1); - RANGETEST(r1, >=, i1); - RANGETEST(r1, ==, i1); - RANGETEST(r1, !=, i1); +#define TESTEM(X, Y) do { \ + RANGETEST(X, < , Y); \ + RANGETEST(X, <=, Y); \ + RANGETEST(X, > , Y); \ + RANGETEST(X, >=, Y); \ + RANGETEST(X, ==, Y); \ + RANGETEST(X, !=, Y); \ + RANGETEST(Y, < , X); \ + RANGETEST(Y, <=, X); \ + RANGETEST(Y, > , X); \ + RANGETEST(Y, >=, X); \ + RANGETEST(Y, ==, X); \ + RANGETEST(Y, !=, X); \ +} while (0) - RANGETEST(i2, < , r1); - RANGETEST(i2, <=, r1); - RANGETEST(i2, > , r1); - RANGETEST(i2, >=, r1); - RANGETEST(i2, ==, r1); - RANGETEST(i2, !=, r1); - RANGETEST(r1, < , i2); - RANGETEST(r1, <=, i2); - RANGETEST(r1, > , i2); - RANGETEST(r1, >=, i2); - RANGETEST(r1, ==, i2); - RANGETEST(r1, !=, i2); + TESTEM(8, r1); + TESTEM(9, r1); + TESTEM(27, r1); + TESTEM(28, r1); - unsigned u1 = 10; - unsigned u2 = 0x1001; - RANGETEST(u1, < , r2); - RANGETEST(u1, <=, r2); - RANGETEST(u1, > , r2); - RANGETEST(u1, >=, r2); - RANGETEST(u1, ==, r2); - RANGETEST(u1, !=, r2); - RANGETEST(r2, < , u1); - RANGETEST(r2, <=, u1); - RANGETEST(r2, > , u1); - RANGETEST(r2, >=, u1); - RANGETEST(r2, ==, u1); - RANGETEST(r2, !=, u1); - - RANGETEST(u2, < , r2); - RANGETEST(u2, <=, r2); - RANGETEST(u2, > , r2); - RANGETEST(u2, >=, r2); - RANGETEST(u2, ==, r2); - RANGETEST(u2, !=, r2); - RANGETEST(r2, < , u2); - RANGETEST(r2, <=, u2); - RANGETEST(r2, > , u2); - RANGETEST(r2, >=, u2); - RANGETEST(r2, ==, u2); - RANGETEST(r2, !=, u2); + TESTEM(0x0fff, r2); + TESTEM(0x1000, r2); + TESTEM(0x10ff, r2); + TESTEM(0x1100, r2); return 0; } |