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

Clean up the Range class and associated usages. The code was

Browse source 
never clear about whether the end of the range was inclusive
or exclusive.  Make it inclusive, but also provide a RangeSize()
function that will generate a Range based on a start and a size.
This, in combination with using the comparison operators, makes
almost all usages of the range not care how it is stored.

base/range.cc:
    Make the end of the range inclusive.

    start/end -> first/last
    (end seems too much like end() in stl)
base/range.hh:
    Make the end of the range inclusive.

    Fix all comparison operators so that they work correctly with
    an inclusive range.  Also, when comparing one range to another
    with <, <=, >, >=, we only look at the beginning of the range
    beacuse x <= y should be the same as x < y || x == y.  (This wasn't
    the case before.)

    Add a few functions for making a range:
    RangeSize is start and size
    RangeEx is start and end where end is exclusive
    RangeIn is start and end where end is inclusive

    start/end -> first/last
    (end seems too much like end() in stl)
dev/alpha_console.cc:
dev/baddev.cc:
dev/ide_ctrl.cc:
dev/ns_gige.cc:
dev/pciconfigall.cc:
dev/pcidev.cc:
dev/tsunami_cchip.cc:
dev/tsunami_io.cc:
dev/tsunami_pchip.cc:
dev/uart.cc:
    Use the RangeSize function to create a range.

--HG--
extra : convert_revision : 29a7eb7fce745680f1c77fefff456c2144bc3994
This commit is contained in:
Nathan Binkert 2004-10-22 01:34:40 -04:00
parent f267dc4a87
commit b881408ed7
12 changed files with 98 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
base/range.cc
View file

@ -34,12 +34,12 @@ using namespace std;
template <class T> template <class T>
bool bool
__x_parse_range(const std::string &str, T &start, T &end) __x_parse_range(const std::string &str, T &first, T &last)
{ {
std::vector<std::string> values; std::vector<std::string> values;
tokenize(values, str, ':'); tokenize(values, str, ':');
T thestart, theend; T thefirst, thelast;
if (values.size() != 2) if (values.size() != 2)
return false; return false;
@ -47,29 +47,29 @@ __x_parse_range(const std::string &str, T &start, T &end)
std::string s = values[0]; std::string s = values[0];
std::string e = values[1]; std::string e = values[1];
if (!to_number(s, thestart)) if (!to_number(s, thefirst))
return false; return false;
bool increment = (e[0] == '+'); bool increment = (e[0] == '+');
if (increment) if (increment)
e = e.substr(1); e = e.substr(1);
if (!to_number(e, theend)) if (!to_number(e, thelast))
return false; return false;
if (increment) if (increment)
theend += thestart; thelast += thefirst - 1;
start = thestart; first = thefirst;
end = theend; last = thelast;
return true; return true;
} }
#define RANGE_PARSE(type) \ #define RANGE_PARSE(type) \
template<> bool \ template<> bool \
__parse_range(const std::string &s, type &start, type &end) \ __parse_range(const std::string &s, type &first, type &last) \
{ return __x_parse_range(s, start, end); } { return __x_parse_range(s, first, last); }
RANGE_PARSE(unsigned long long); RANGE_PARSE(unsigned long long);
RANGE_PARSE(signed long long); RANGE_PARSE(signed long long);

119
base/range.hh
View file

@ -26,44 +26,32 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __RANGE_HH__ #ifndef __BASE_RANGE_HH__
#define __RANGE_HH__ #define __BASE_RANGE_HH__
#include <cassert> #include <cassert>
#include <string> #include <string>
/**
* @param s range string
* EndExclusive Ranges are in the following format:
* <range> := {<start_val>}:{<end>}
* <start> := <end_val> | +<delta>
*/
template <class T> template <class T>
bool __parse_range(const std::string &s, T &start, T &end); bool __parse_range(const std::string &s, T &start, T &end);
template <class T> template <class T>
struct Range struct Range
{ {
private:
/**
* @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 start;
T end; T end;
public: Range() { invalidate(); }
Range()
{
invalidate();
}
Range(T first, T second) template <class U>
: start(first), end(second) Range(const std::pair<U, U> &r)
: start(r.first), end(r.second)
{} {}
template <class U> template <class U>
@ -71,14 +59,10 @@ struct Range
: start(r.start), end(r.end) : 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) Range(const std::string &s)
{ {
parse(s); if (!__parse_range(s, start, end))
invalidate();
} }
template <class U> template <class U>
@ -99,32 +83,39 @@ struct Range
const Range &operator=(const std::string &s) const Range &operator=(const std::string &s)
{ {
parse(s); if (!__parse_range(s, start, end))
invalidate();
return *this; return *this;
} }
void invalidate() { start = 0; end = 0; } void invalidate() { start = 1; end = 0; }
T size() const { return end - start; } T size() const { return end - start + 1; }
bool valid() const { return start < end; } 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> template <class T>
inline std::ostream & inline std::ostream &
operator<<(std::ostream &o, const Range<T> &r) operator<<(std::ostream &o, const Range<T> &r)
{ {
// don't currently support output of invalid ranges o << '[' << r.start << "," << r.end << ']';
assert(r.valid());
o << r.start << ":" << r.end;
return o; return o;
} }
template <class T>
inline Range<T>
RangeEx(T start, T end)
{ return std::make_pair(start, end - 1); }
template <class T>
inline Range<T>
RangeIn(T start, T end)
{ return std::make_pair(start, end); }
template <class T, class U>
inline Range<T>
RangeSize(T start, U size)
{ return std::make_pair(start, start + size - 1); }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// //
// Range to Range Comparisons // Range to Range Comparisons
@ -139,7 +130,6 @@ template <class T, class U>
inline bool inline bool
operator==(const Range<T> &range1, const Range<U> &range2) operator==(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid());
return range1.start == range2.start && range1.end == range2.end; return range1.start == range2.start && range1.end == range2.end;
} }
@ -152,7 +142,6 @@ template <class T, class U>
inline bool inline bool
operator!=(const Range<T> &range1, const Range<U> &range2) operator!=(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid());
return range1.start != range2.start || range1.end != range2.end; return range1.start != range2.start || range1.end != range2.end;
} }
@ -165,8 +154,7 @@ template <class T, class U>
inline bool inline bool
operator<(const Range<T> &range1, const Range<U> &range2) operator<(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid()); return range1.start < range2.start;
return range1.end <= range2.start;
} }
/** /**
@ -179,8 +167,7 @@ template <class T, class U>
inline bool inline bool
operator<=(const Range<T> &range1, const Range<U> &range2) operator<=(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid()); return range1.start <= range2.start;
return range1.start <= range2.start && range1.end <= range2.end;
} }
/** /**
@ -192,8 +179,7 @@ template <class T, class U>
inline bool inline bool
operator>(const Range<T> &range1, const Range<U> &range2) operator>(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid()); return range1.start > range2.start;
return range1.start >= range2.end;
} }
/** /**
@ -206,8 +192,7 @@ template <class T, class U>
inline bool inline bool
operator>=(const Range<T> &range1, const Range<U> &range2) operator>=(const Range<T> &range1, const Range<U> &range2)
{ {
assert(range1.valid() && range2.valid()); return range1.start >= range2.start;
return range1.start >= range2.start && range1.end >= range2.end;
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
@ -224,7 +209,6 @@ template <class T, class U>
inline bool inline bool
operator==(const T &pos, const Range<U> &range) operator==(const T &pos, const Range<U> &range)
{ {
assert(range.valid());
return pos >= range.start && pos <= range.end; return pos >= range.start && pos <= range.end;
} }
@ -237,8 +221,7 @@ template <class T, class U>
inline bool inline bool
operator!=(const T &pos, const Range<U> &range) operator!=(const T &pos, const Range<U> &range)
{ {
assert(range.valid()); return pos < range.start || pos > range.end;
return pos < range.start || pos >= range.end;
} }
/** /**
@ -250,7 +233,6 @@ template <class T, class U>
inline bool inline bool
operator<(const T &pos, const Range<U> &range) operator<(const T &pos, const Range<U> &range)
{ {
assert(range.valid());
return pos < range.start; return pos < range.start;
} }
@ -263,8 +245,7 @@ template <class T, class U>
inline bool inline bool
operator<=(const T &pos, const Range<U> &range) operator<=(const T &pos, const Range<U> &range)
{ {
assert(range.valid()); return pos <= range.end;
return pos < range.end;
} }
/** /**
@ -276,8 +257,7 @@ template <class T, class U>
inline bool inline bool
operator>(const T &pos, const Range<U> &range) operator>(const T &pos, const Range<U> &range)
{ {
assert(range.valid()); return pos > range.end;
return pos >= range.end;
} }
/** /**
@ -289,7 +269,6 @@ template <class T, class U>
inline bool inline bool
operator>=(const T &pos, const Range<U> &range) operator>=(const T &pos, const Range<U> &range)
{ {
assert(range.valid());
return pos >= range.start; return pos >= range.start;
} }
@ -307,8 +286,7 @@ template <class T, class U>
inline bool inline bool
operator==(const Range<T> &range, const U &pos) operator==(const Range<T> &range, const U &pos)
{ {
assert(range.valid()); return pos >= range.start && pos <= range.end;
return pos >= range.start && pos < range.end;
} }
/** /**
@ -320,8 +298,7 @@ template <class T, class U>
inline bool inline bool
operator!=(const Range<T> &range, const U &pos) operator!=(const Range<T> &range, const U &pos)
{ {
assert(range.valid()); return pos < range.start || pos > range.end;
return pos < range.start || pos >= range.end;
} }
/** /**
@ -333,8 +310,7 @@ template <class T, class U>
inline bool inline bool
operator<(const Range<T> &range, const U &pos) operator<(const Range<T> &range, const U &pos)
{ {
assert(range.valid()); return range.end < pos;
return range.end <= pos;
} }
/** /**
@ -346,7 +322,6 @@ template <class T, class U>
inline bool inline bool
operator<=(const Range<T> &range, const U &pos) operator<=(const Range<T> &range, const U &pos)
{ {
assert(range.valid());
return range.start <= pos; return range.start <= pos;
} }
@ -359,7 +334,6 @@ template <class T, class U>
inline bool inline bool
operator>(const Range<T> &range, const U &pos) operator>(const Range<T> &range, const U &pos)
{ {
assert(range.valid());
return range.start > pos; return range.start > pos;
} }
@ -372,8 +346,7 @@ template <class T, class U>
inline bool inline bool
operator>=(const Range<T> &range, const U &pos) operator>=(const Range<T> &range, const U &pos)
{ {
assert(range.valid()); return range.end >= pos;
return range.end > pos;
} }
#endif // __RANGE_HH__ #endif // __BASE_RANGE_HH__

4
dev/alpha_console.cc
View file

@ -61,12 +61,12 @@ AlphaConsole::AlphaConsole(const string &name, SimConsole *cons, SimpleDisk *d,
HierParams *hier, Bus *bus) HierParams *hier, Bus *bus)
: PioDevice(name), disk(d), console(cons), addr(a) : PioDevice(name), disk(d), console(cons), addr(a)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&AlphaConsole::cacheAccess); &AlphaConsole::cacheAccess);
pioInterface->addAddrRange(addr, addr + size); pioInterface->addAddrRange(RangeSize(addr, size));
} }
alphaAccess = new AlphaAccess; alphaAccess = new AlphaAccess;

4
dev/baddev.cc
View file

@ -50,12 +50,12 @@ BadDevice::BadDevice(const string &name, Addr a, MemoryController *mmu,
HierParams *hier, Bus *bus, const string &devicename) HierParams *hier, Bus *bus, const string &devicename)
: PioDevice(name), addr(a), devname(devicename) : PioDevice(name), addr(a), devname(devicename)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&BadDevice::cacheAccess); &BadDevice::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
} }
} }

32
dev/ide_ctrl.cc
View file

@ -377,8 +377,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[0] != 0) { if (BARAddrs[0] != 0) {
pri_cmd_addr = BARAddrs[0]; pri_cmd_addr = BARAddrs[0];
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(pri_cmd_addr, pioInterface->addAddrRange(RangeSize(pri_cmd_addr,
pri_cmd_addr + pri_cmd_size - 1); pri_cmd_size));
pri_cmd_addr &= PA_UNCACHED_MASK; pri_cmd_addr &= PA_UNCACHED_MASK;
} }
@ -388,8 +388,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[1] != 0) { if (BARAddrs[1] != 0) {
pri_ctrl_addr = BARAddrs[1]; pri_ctrl_addr = BARAddrs[1];
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(pri_ctrl_addr, pioInterface->addAddrRange(RangeSize(pri_ctrl_addr,
pri_ctrl_addr + pri_ctrl_size - 1); pri_ctrl_size));
pri_ctrl_addr &= PA_UNCACHED_MASK; pri_ctrl_addr &= PA_UNCACHED_MASK;
} }
@ -399,8 +399,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[2] != 0) { if (BARAddrs[2] != 0) {
sec_cmd_addr = BARAddrs[2]; sec_cmd_addr = BARAddrs[2];
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(sec_cmd_addr, pioInterface->addAddrRange(RangeSize(sec_cmd_addr,
sec_cmd_addr + sec_cmd_size - 1); sec_cmd_size));
sec_cmd_addr &= PA_UNCACHED_MASK; sec_cmd_addr &= PA_UNCACHED_MASK;
} }
@ -410,8 +410,8 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[3] != 0) { if (BARAddrs[3] != 0) {
sec_ctrl_addr = BARAddrs[3]; sec_ctrl_addr = BARAddrs[3];
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(sec_ctrl_addr, pioInterface->addAddrRange(RangeSize(sec_ctrl_addr,
sec_ctrl_addr + sec_ctrl_size - 1); sec_ctrl_size));
sec_ctrl_addr &= PA_UNCACHED_MASK; sec_ctrl_addr &= PA_UNCACHED_MASK;
} }
@ -421,7 +421,7 @@ IdeController::WriteConfig(int offset, int size, uint32_t data)
if (BARAddrs[4] != 0) { if (BARAddrs[4] != 0) {
bmi_addr = BARAddrs[4]; bmi_addr = BARAddrs[4];
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(bmi_addr, bmi_addr + bmi_size - 1); pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
bmi_addr &= PA_UNCACHED_MASK; bmi_addr &= PA_UNCACHED_MASK;
} }
@ -675,15 +675,11 @@ IdeController::unserialize(Checkpoint *cp, const std::string &section)
UNSERIALIZE_ARRAY(cmd_in_progress, 4); UNSERIALIZE_ARRAY(cmd_in_progress, 4);
if (pioInterface) { if (pioInterface) {
pioInterface->addAddrRange(pri_cmd_addr, pri_cmd_addr + pioInterface->addAddrRange(RangeSize(pri_cmd_addr, pri_cmd_size));
pri_cmd_size - 1); pioInterface->addAddrRange(RangeSize(pri_ctrl_addr, pri_ctrl_size));
pioInterface->addAddrRange(pri_ctrl_addr, pri_ctrl_addr + pioInterface->addAddrRange(RangeSize(sec_cmd_addr, sec_cmd_size));
pri_ctrl_size - 1); pioInterface->addAddrRange(RangeSize(sec_ctrl_addr, sec_ctrl_size));
pioInterface->addAddrRange(sec_cmd_addr, sec_cmd_addr + pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
sec_cmd_size - 1);
pioInterface->addAddrRange(sec_ctrl_addr, sec_ctrl_addr +
sec_ctrl_size - 1);
pioInterface->addAddrRange(bmi_addr, bmi_addr + bmi_size - 1);
} }
} }

10
dev/ns_gige.cc
View file

@ -344,8 +344,7 @@ NSGigE::WriteConfig(int offset, int size, uint32_t data)
case PCI0_BASE_ADDR0: case PCI0_BASE_ADDR0:
if (BARAddrs[0] != 0) { if (BARAddrs[0] != 0) {
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(BARAddrs[0], pioInterface->addAddrRange(RangeSize(BARAddrs[0], BARSize[0]));
BARAddrs[0] + BARSize[0] - 1);
BARAddrs[0] &= PA_UNCACHED_MASK; BARAddrs[0] &= PA_UNCACHED_MASK;
} }
@ -353,8 +352,7 @@ NSGigE::WriteConfig(int offset, int size, uint32_t data)
case PCI0_BASE_ADDR1: case PCI0_BASE_ADDR1:
if (BARAddrs[1] != 0) { if (BARAddrs[1] != 0) {
if (pioInterface) if (pioInterface)
pioInterface->addAddrRange(BARAddrs[1], pioInterface->addAddrRange(RangeSize(BARAddrs[1], BARSize[1]));
BARAddrs[1] + BARSize[1] - 1);
BARAddrs[1] &= PA_UNCACHED_MASK; BARAddrs[1] &= PA_UNCACHED_MASK;
} }
@ -2410,8 +2408,8 @@ NSGigE::unserialize(Checkpoint *cp, const std::string &section)
* re-add addrRanges to bus bridges * re-add addrRanges to bus bridges
*/ */
if (pioInterface) { if (pioInterface) {
pioInterface->addAddrRange(BARAddrs[0], BARAddrs[0] + BARSize[0] - 1); pioInterface->addAddrRange(RangeSize(BARAddrs[0], BARSize[0]));
pioInterface->addAddrRange(BARAddrs[1], BARAddrs[1] + BARSize[1] - 1); pioInterface->addAddrRange(RangeSize(BARAddrs[1], BARSize[1]));
} }
} }

4
dev/pciconfigall.cc
View file

@ -50,12 +50,12 @@ PciConfigAll::PciConfigAll(const string &name, Addr a, MemoryController *mmu,
HierParams *hier, Bus *bus, Tick pio_latency) HierParams *hier, Bus *bus, Tick pio_latency)
: PioDevice(name), addr(a) : PioDevice(name), addr(a)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&PciConfigAll::cacheAccess); &PciConfigAll::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio; pioLatency = pio_latency * bus->clockRatio;
} }

33
dev/pcidev.cc
View file

@ -184,21 +184,17 @@ PciDev::WriteConfig(int offset, int size, uint32_t data)
if (word_value & ~0x1) { if (word_value & ~0x1) {
Addr base_addr = (word_value & ~0x1) + TSUNAMI_PCI0_IO; Addr base_addr = (word_value & ~0x1) + TSUNAMI_PCI0_IO;
Addr base_size = BARSize[barnum]-1; Addr base_size = BARSize[barnum];
// It's never been set // It's never been set
if (BARAddrs[barnum] == 0) if (BARAddrs[barnum] == 0)
mmu->add_child((FunctionalMemory *)this, mmu->add_child((FunctionalMemory *)this,
Range<Addr>(base_addr, RangeSize(base_addr, base_size));
base_addr + base_size));
else else
mmu->update_child((FunctionalMemory *)this, mmu->update_child((FunctionalMemory *)this,
Range<Addr>(BARAddrs[barnum], RangeSize(BARAddrs[barnum],
BARAddrs[barnum] + base_size),
base_size), RangeSize(base_addr, base_size));
Range<Addr>(base_addr,
base_addr +
base_size));
BARAddrs[barnum] = base_addr; BARAddrs[barnum] = base_addr;
} }
@ -212,21 +208,17 @@ PciDev::WriteConfig(int offset, int size, uint32_t data)
Addr base_addr = (word_value & ~0x3) + Addr base_addr = (word_value & ~0x3) +
TSUNAMI_PCI0_MEMORY; TSUNAMI_PCI0_MEMORY;
Addr base_size = BARSize[barnum]-1; Addr base_size = BARSize[barnum];
// It's never been set // It's never been set
if (BARAddrs[barnum] == 0) if (BARAddrs[barnum] == 0)
mmu->add_child((FunctionalMemory *)this, mmu->add_child((FunctionalMemory *)this,
Range<Addr>(base_addr, RangeSize(base_addr, base_size));
base_addr + base_size));
else else
mmu->update_child((FunctionalMemory *)this, mmu->update_child((FunctionalMemory *)this,
Range<Addr>(BARAddrs[barnum], RangeSize(BARAddrs[barnum],
BARAddrs[barnum] + base_size),
base_size), RangeSize(base_addr, base_size));
Range<Addr>(base_addr,
base_addr +
base_size));
BARAddrs[barnum] = base_addr; BARAddrs[barnum] = base_addr;
} }
@ -273,10 +265,7 @@ PciDev::unserialize(Checkpoint *cp, const std::string &section)
// Add the MMU mappings for the BARs // Add the MMU mappings for the BARs
for (int i=0; i < 6; i++) { for (int i=0; i < 6; i++) {
if (BARAddrs[i] != 0) if (BARAddrs[i] != 0)
mmu->add_child((FunctionalMemory *)this, mmu->add_child(this, RangeSize(BARAddrs[i], BARSize[i]));
Range<Addr>(BARAddrs[i],
BARAddrs[i] +
BARSize[i] - 1));
} }
} }

4
dev/tsunami_cchip.cc
View file

@ -53,7 +53,7 @@ TsunamiCChip::TsunamiCChip(const string &name, Tsunami *t, Addr a,
Tick pio_latency) Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t) : PioDevice(name), addr(a), tsunami(t)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
for(int i=0; i < Tsunami::Max_CPUs; i++) { for(int i=0; i < Tsunami::Max_CPUs; i++) {
dim[i] = 0; dim[i] = 0;
@ -66,7 +66,7 @@ TsunamiCChip::TsunamiCChip(const string &name, Tsunami *t, Addr a,
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiCChip::cacheAccess); &TsunamiCChip::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio; pioLatency = pio_latency * bus->clockRatio;
} }

4
dev/tsunami_io.cc
View file

@ -164,12 +164,12 @@ TsunamiIO::TsunamiIO(const string &name, Tsunami *t, time_t init_time,
Tick pio_latency) Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t), rtc(t) : PioDevice(name), addr(a), tsunami(t), rtc(t)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiIO::cacheAccess); &TsunamiIO::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio; pioLatency = pio_latency * bus->clockRatio;
} }

4
dev/tsunami_pchip.cc
View file

@ -53,7 +53,7 @@ TsunamiPChip::TsunamiPChip(const string &name, Tsunami *t, Addr a,
Bus *bus, Tick pio_latency) Bus *bus, Tick pio_latency)
: PioDevice(name), addr(a), tsunami(t) : PioDevice(name), addr(a), tsunami(t)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
wsba[i] = 0; wsba[i] = 0;
@ -64,7 +64,7 @@ TsunamiPChip::TsunamiPChip(const string &name, Tsunami *t, Addr a,
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&TsunamiPChip::cacheAccess); &TsunamiPChip::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio; pioLatency = pio_latency * bus->clockRatio;
} }

4
dev/uart.cc
View file

@ -92,13 +92,13 @@ Uart::Uart(const string &name, SimConsole *c, MemoryController *mmu, Addr a,
: PioDevice(name), addr(a), size(s), cons(c), txIntrEvent(this, TX_INT), : PioDevice(name), addr(a), size(s), cons(c), txIntrEvent(this, TX_INT),
rxIntrEvent(this, RX_INT), platform(p) rxIntrEvent(this, RX_INT), platform(p)
{ {
mmu->add_child(this, Range<Addr>(addr, addr + size)); mmu->add_child(this, RangeSize(addr, size));
if (bus) { if (bus) {
pioInterface = newPioInterface(name, hier, bus, this, pioInterface = newPioInterface(name, hier, bus, this,
&Uart::cacheAccess); &Uart::cacheAccess);
pioInterface->addAddrRange(addr, addr + size - 1); pioInterface->addAddrRange(RangeSize(addr, size));
pioLatency = pio_latency * bus->clockRatio; pioLatency = pio_latency * bus->clockRatio;
} }