17 files changed, 178 insertions, 177 deletions

diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh b/src/mem/ruby/filters/AbstractBloomFilter.hh
index 3a014dd85..097e0e204 100644
--- a/src/mem/ruby/filters/AbstractBloomFilter.hh
+++ b/src/mem/ruby/filters/AbstractBloomFilter.hh
@@ -38,19 +38,19 @@ class AbstractBloomFilter
   public:
     virtual ~AbstractBloomFilter() {};
     virtual void clear() = 0;
-    virtual void increment(const Address& addr) = 0;
-    virtual void decrement(const Address& addr) = 0;
+    virtual void increment(Addr addr) = 0;
+    virtual void decrement(Addr addr) = 0;
     virtual void merge(AbstractBloomFilter * other_filter) = 0;
-    virtual void set(const Address& addr) = 0;
-    virtual void unset(const Address& addr) = 0;
+    virtual void set(Addr addr) = 0;
+    virtual void unset(Addr addr) = 0;
 
-    virtual bool isSet(const Address& addr) = 0;
-    virtual int getCount(const Address& addr) = 0;
+    virtual bool isSet(Addr addr) = 0;
+    virtual int getCount(Addr addr) = 0;
     virtual int getTotalCount() = 0;
 
     virtual void print(std::ostream& out) const = 0;
 
-    virtual int getIndex(const Address& addr) = 0;
+    virtual int getIndex(Addr addr) = 0;
     virtual int readBit(const int index) = 0;
     virtual void writeBit(const int index, const int value) = 0;
 };
diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc b/src/mem/ruby/filters/BlockBloomFilter.cc
index d6ef9128a..c902f9f38 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.cc
+++ b/src/mem/ruby/filters/BlockBloomFilter.cc
@@ -65,13 +65,13 @@ BlockBloomFilter::clear()
 }
 
 void
-BlockBloomFilter::increment(const Address& addr)
+BlockBloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 void
-BlockBloomFilter::decrement(const Address& addr)
+BlockBloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -83,28 +83,28 @@ BlockBloomFilter::merge(AbstractBloomFilter * other_filter)
 }
 
 void
-BlockBloomFilter::set(const Address& addr)
+BlockBloomFilter::set(Addr addr)
 {
     int i = get_index(addr);
     m_filter[i] = 1;
 }
 
 void
-BlockBloomFilter::unset(const Address& addr)
+BlockBloomFilter::unset(Addr addr)
 {
     int i = get_index(addr);
     m_filter[i] = 0;
 }
 
 bool
-BlockBloomFilter::isSet(const Address& addr)
+BlockBloomFilter::isSet(Addr addr)
 {
     int i = get_index(addr);
     return (m_filter[i]);
 }
 
 int
-BlockBloomFilter::getCount(const Address& addr)
+BlockBloomFilter::getCount(Addr addr)
 {
     return m_filter[get_index(addr)];
 }
@@ -123,7 +123,7 @@ BlockBloomFilter::getTotalCount()
 }
 
 int
-BlockBloomFilter::getIndex(const Address& addr)
+BlockBloomFilter::getIndex(Addr addr)
 {
     return get_index(addr);
 }
@@ -146,17 +146,16 @@ BlockBloomFilter::writeBit(const int index, const int value)
 }
 
 int
-BlockBloomFilter::get_index(const Address& addr)
+BlockBloomFilter::get_index(Addr addr)
 {
     // Pull out some bit field ==> B1
     // Pull out additional bits, not the same as B1 ==> B2
     //  XOR B1 and B2 to get hash index
-    physical_address_t block_bits =
-        addr.bitSelect(RubySystem::getBlockSizeBits(),
+    Addr block_bits = bitSelect(addr, RubySystem::getBlockSizeBits(),
                        2 * RubySystem::getBlockSizeBits() - 1);
     int offset = 5;
-    physical_address_t other_bits =
-        addr.bitSelect(2 * RubySystem::getBlockSizeBits() + offset,
+    Addr other_bits = bitSelect(addr,
+                       2 * RubySystem::getBlockSizeBits() + offset,
                        2 * RubySystem::getBlockSizeBits() + offset +
                        m_filter_size_bits - 1);
     int index = block_bits ^ other_bits;
diff --git a/src/mem/ruby/filters/BlockBloomFilter.hh b/src/mem/ruby/filters/BlockBloomFilter.hh
index fc7ea1d33..d45dd236b 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.hh
+++ b/src/mem/ruby/filters/BlockBloomFilter.hh
@@ -43,23 +43,23 @@ class BlockBloomFilter : public AbstractBloomFilter
     ~BlockBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
     void print(std::ostream& out) const;
 
   private:
-    int get_index(const Address& addr);
+    int get_index(Addr addr);
 
     std::vector<int> m_filter;
     int m_filter_size;
diff --git a/src/mem/ruby/filters/BulkBloomFilter.cc b/src/mem/ruby/filters/BulkBloomFilter.cc
index 8b8f3c42d..953add219 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.cc
+++ b/src/mem/ruby/filters/BulkBloomFilter.cc
@@ -73,13 +73,13 @@ BulkBloomFilter::clear()
 }
 
 void
-BulkBloomFilter::increment(const Address& addr)
+BulkBloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 void
-BulkBloomFilter::decrement(const Address& addr)
+BulkBloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -91,16 +91,16 @@ BulkBloomFilter::merge(AbstractBloomFilter * other_filter)
 }
 
 void
-BulkBloomFilter::set(const Address& addr)
+BulkBloomFilter::set(Addr addr)
 {
     // c0 contains the cache index bits
     int set_bits = m_sector_bits;
     int block_bits = RubySystem::getBlockSizeBits();
-    int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
+    int c0 = bitSelect(addr, block_bits, block_bits + set_bits - 1);
     // c1 contains the lower m_sector_bits permuted bits
     //Address permuted_bits = permute(addr);
     //int c1 = permuted_bits.bitSelect(0, set_bits-1);
-    int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
+    int c1 = bitSelect(addr, block_bits+set_bits, (block_bits+2*set_bits) - 1);
     //assert(c0 < (m_filter_size/2));
     //assert(c0 + (m_filter_size/2) < m_filter_size);
     //assert(c1 < (m_filter_size/2));
@@ -111,22 +111,22 @@ BulkBloomFilter::set(const Address& addr)
 }
 
 void
-BulkBloomFilter::unset(const Address& addr)
+BulkBloomFilter::unset(Addr addr)
 {
     // not used
 }
 
 bool
-BulkBloomFilter::isSet(const Address& addr)
+BulkBloomFilter::isSet(Addr addr)
 {
     // c0 contains the cache index bits
     int set_bits = m_sector_bits;
     int block_bits = RubySystem::getBlockSizeBits();
-    int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
+    int c0 = bitSelect(addr, block_bits, block_bits + set_bits - 1);
     // c1 contains the lower 10 permuted bits
     //Address permuted_bits = permute(addr);
     //int c1 = permuted_bits.bitSelect(0, set_bits-1);
-    int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
+    int c1 = bitSelect(addr, block_bits+set_bits, (block_bits+2*set_bits) - 1);
     //assert(c0 < (m_filter_size/2));
     //assert(c0 + (m_filter_size/2) < m_filter_size);
     //assert(c1 < (m_filter_size/2));
@@ -173,7 +173,7 @@ BulkBloomFilter::isSet(const Address& addr)
 }
 
 int
-BulkBloomFilter::getCount(const Address& addr)
+BulkBloomFilter::getCount(Addr addr)
 {
     // not used
     return 0;
@@ -192,7 +192,7 @@ BulkBloomFilter::getTotalCount()
 }
 
 int
-BulkBloomFilter::getIndex(const Address& addr)
+BulkBloomFilter::getIndex(Addr addr)
 {
     return get_index(addr);
 }
@@ -216,40 +216,40 @@ BulkBloomFilter::print(ostream& out) const
 }
 
 int
-BulkBloomFilter::get_index(const Address& addr)
+BulkBloomFilter::get_index(Addr addr)
 {
-    return addr.bitSelect(RubySystem::getBlockSizeBits(),
-                          RubySystem::getBlockSizeBits() +
-                          m_filter_size_bits - 1);
+    return bitSelect(addr, RubySystem::getBlockSizeBits(),
+                     RubySystem::getBlockSizeBits() +
+                     m_filter_size_bits - 1);
 }
 
-Address
-BulkBloomFilter::permute(const Address & addr)
+Addr
+BulkBloomFilter::permute(Addr addr)
 {
     // permutes the original address bits according to Table 5
     int block_offset = RubySystem::getBlockSizeBits();
-    physical_address_t part1 = addr.bitSelect(block_offset, block_offset + 6),
-        part2 = addr.bitSelect(block_offset + 9, block_offset + 9),
-        part3 = addr.bitSelect(block_offset + 11, block_offset + 11),
-        part4 = addr.bitSelect(block_offset + 17, block_offset + 17),
-        part5 = addr.bitSelect(block_offset + 7, block_offset + 8),
-        part6 = addr.bitSelect(block_offset + 10, block_offset + 10),
-        part7 = addr.bitSelect(block_offset + 12, block_offset + 12),
-        part8 = addr.bitSelect(block_offset + 13, block_offset + 13),
-        part9 = addr.bitSelect(block_offset + 15, block_offset + 16),
-        part10 = addr.bitSelect(block_offset + 18, block_offset + 20),
-        part11 = addr.bitSelect(block_offset + 14, block_offset + 14);
-
-    physical_address_t result =
+    Addr part1 = bitSelect(addr, block_offset, block_offset + 6),
+        part2 = bitSelect(addr, block_offset + 9, block_offset + 9),
+        part3 = bitSelect(addr, block_offset + 11, block_offset + 11),
+        part4 = bitSelect(addr, block_offset + 17, block_offset + 17),
+        part5 = bitSelect(addr, block_offset + 7, block_offset + 8),
+        part6 = bitSelect(addr, block_offset + 10, block_offset + 10),
+        part7 = bitSelect(addr, block_offset + 12, block_offset + 12),
+        part8 = bitSelect(addr, block_offset + 13, block_offset + 13),
+        part9 = bitSelect(addr, block_offset + 15, block_offset + 16),
+        part10 = bitSelect(addr, block_offset + 18, block_offset + 20),
+        part11 = bitSelect(addr, block_offset + 14, block_offset + 14);
+
+    Addr result =
         (part1 << 14) | (part2 << 13) | (part3 << 12) | (part4 << 11) |
         (part5 << 9)  | (part6 << 8)  | (part7 << 7)  | (part8 << 6)  |
         (part9 << 4)  | (part10 << 1) | (part11);
 
     // assume 32 bit addresses (both virtual and physical)
     // select the remaining high-order 11 bits
-    physical_address_t remaining_bits =
-        addr.bitSelect(block_offset + 21, 31) << 21;
+    Addr remaining_bits =
+        bitSelect(addr, block_offset + 21, 31) << 21;
     result = result | remaining_bits;
 
-    return Address(result);
+    return result;
 }
diff --git a/src/mem/ruby/filters/BulkBloomFilter.hh b/src/mem/ruby/filters/BulkBloomFilter.hh
index 9c10bfc6f..8b67c718e 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.hh
+++ b/src/mem/ruby/filters/BulkBloomFilter.hh
@@ -43,24 +43,24 @@ class BulkBloomFilter : public AbstractBloomFilter
     ~BulkBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
     void print(std::ostream& out) const;
 
   private:
-    int get_index(const Address& addr);
-    Address permute(const Address & addr);
+    int get_index(Addr addr);
+    Addr permute(Addr addr);
 
     std::vector<int> m_filter;
     std::vector<int> m_temp_filter;
diff --git a/src/mem/ruby/filters/GenericBloomFilter.cc b/src/mem/ruby/filters/GenericBloomFilter.cc
index 0f53a9712..3d4cb9ed3 100644
--- a/src/mem/ruby/filters/GenericBloomFilter.cc
+++ b/src/mem/ruby/filters/GenericBloomFilter.cc
@@ -79,13 +79,13 @@ GenericBloomFilter::clear()
 }
 
 void
-GenericBloomFilter::increment(const Address& addr)
+GenericBloomFilter::increment(Addr addr)
 {
     m_filter->increment(addr);
 }
 
 void
-GenericBloomFilter::decrement(const Address& addr)
+GenericBloomFilter::decrement(Addr addr)
 {
     m_filter->decrement(addr);
 }
@@ -97,25 +97,25 @@ GenericBloomFilter::merge(GenericBloomFilter * other_filter)
 }
 
 void
-GenericBloomFilter::set(const Address& addr)
+GenericBloomFilter::set(Addr addr)
 {
     m_filter->set(addr);
 }
 
 void
-GenericBloomFilter::unset(const Address& addr)
+GenericBloomFilter::unset(Addr addr)
 {
     m_filter->unset(addr);
 }
 
 bool
-GenericBloomFilter::isSet(const Address& addr)
+GenericBloomFilter::isSet(Addr addr)
 {
     return m_filter->isSet(addr);
 }
 
 int
-GenericBloomFilter::getCount(const Address& addr)
+GenericBloomFilter::getCount(Addr addr)
 {
     return m_filter->getCount(addr);
 }
@@ -127,7 +127,7 @@ GenericBloomFilter::getTotalCount()
 }
 
 int
-GenericBloomFilter::getIndex(const Address& addr)
+GenericBloomFilter::getIndex(Addr addr)
 {
     return m_filter->getIndex(addr);
 }
diff --git a/src/mem/ruby/filters/GenericBloomFilter.hh b/src/mem/ruby/filters/GenericBloomFilter.hh
index 38f9d370e..869c40ba7 100644
--- a/src/mem/ruby/filters/GenericBloomFilter.hh
+++ b/src/mem/ruby/filters/GenericBloomFilter.hh
@@ -42,24 +42,24 @@ class GenericBloomFilter
     ~GenericBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(GenericBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
     AbstractBloomFilter *
     getFilter()
     {
         return m_filter;
     }
 
-    bool isSet(const Address& addr);
+    bool isSet(Addr addr);
 
-    int getCount(const Address& addr);
+    int getCount(Addr addr);
 
     int getTotalCount();
 
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
diff --git a/src/mem/ruby/filters/H3BloomFilter.cc b/src/mem/ruby/filters/H3BloomFilter.cc
index a4521d223..21b9152be 100644
--- a/src/mem/ruby/filters/H3BloomFilter.cc
+++ b/src/mem/ruby/filters/H3BloomFilter.cc
@@ -416,13 +416,13 @@ H3BloomFilter::clear()
 }
 
 void
-H3BloomFilter::increment(const Address& addr)
+H3BloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 void
-H3BloomFilter::decrement(const Address& addr)
+H3BloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -438,7 +438,7 @@ H3BloomFilter::merge(AbstractBloomFilter *other_filter)
 }
 
 void
-H3BloomFilter::set(const Address& addr)
+H3BloomFilter::set(Addr addr)
 {
     for (int i = 0; i < m_num_hashes; i++) {
         int idx = get_index(addr, i);
@@ -447,14 +447,14 @@ H3BloomFilter::set(const Address& addr)
 }
 
 void
-H3BloomFilter::unset(const Address& addr)
+H3BloomFilter::unset(Addr addr)
 {
     cout << "ERROR: Unset should never be called in a Bloom filter";
     assert(0);
 }
 
 bool
-H3BloomFilter::isSet(const Address& addr)
+H3BloomFilter::isSet(Addr addr)
 {
     bool res = true;
 
@@ -466,13 +466,13 @@ H3BloomFilter::isSet(const Address& addr)
 }
 
 int
-H3BloomFilter::getCount(const Address& addr)
+H3BloomFilter::getCount(Addr addr)
 {
     return isSet(addr)? 1: 0;
 }
 
 int
-H3BloomFilter::getIndex(const Address& addr)
+H3BloomFilter::getIndex(Addr addr)
 {
     return 0;
 }
@@ -505,9 +505,9 @@ H3BloomFilter::print(ostream& out) const
 }
 
 int
-H3BloomFilter::get_index(const Address& addr, int i)
+H3BloomFilter::get_index(Addr addr, int i)
 {
-    uint64 x = addr.getLineAddress();
+    uint64 x = makeLineAddress(addr);
     // uint64 y = (x*mults_list[i] + adds_list[i]) % primes_list[i];
     int y = hash_H3(x,i);
 
diff --git a/src/mem/ruby/filters/H3BloomFilter.hh b/src/mem/ruby/filters/H3BloomFilter.hh
index c63477b9a..8596d6acb 100644
--- a/src/mem/ruby/filters/H3BloomFilter.hh
+++ b/src/mem/ruby/filters/H3BloomFilter.hh
@@ -34,6 +34,7 @@
 #include <vector>
 
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/TypeDefines.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
 class H3BloomFilter : public AbstractBloomFilter
@@ -43,18 +44,18 @@ class H3BloomFilter : public AbstractBloomFilter
     ~H3BloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
     void print(std::ostream& out) const;
 
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
@@ -65,7 +66,7 @@ class H3BloomFilter : public AbstractBloomFilter
     }
 
   private:
-    int get_index(const Address& addr, int hashNumber);
+    int get_index(Addr addr, int hashNumber);
 
     int hash_H3(uint64 value, int index);
 
diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
index 833680fb7..265e58625 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
@@ -65,7 +65,7 @@ LSB_CountingBloomFilter::clear()
 }
 
 void
-LSB_CountingBloomFilter::increment(const Address& addr)
+LSB_CountingBloomFilter::increment(Addr addr)
 {
     int i = get_index(addr);
     if (m_filter[i] < m_count)
@@ -74,7 +74,7 @@ LSB_CountingBloomFilter::increment(const Address& addr)
 
 
 void
-LSB_CountingBloomFilter::decrement(const Address& addr)
+LSB_CountingBloomFilter::decrement(Addr addr)
 {
     int i = get_index(addr);
     if (m_filter[i] > 0)
@@ -88,26 +88,26 @@ LSB_CountingBloomFilter::merge(AbstractBloomFilter * other_filter)
 }
 
 void
-LSB_CountingBloomFilter::set(const Address& addr)
+LSB_CountingBloomFilter::set(Addr addr)
 {
     // TODO
 }
 
 void
-LSB_CountingBloomFilter::unset(const Address& addr)
+LSB_CountingBloomFilter::unset(Addr addr)
 {
     // TODO
 }
 
 bool
-LSB_CountingBloomFilter::isSet(const Address& addr)
+LSB_CountingBloomFilter::isSet(Addr addr)
 {
     // TODO
     return false;
 }
 
 int
-LSB_CountingBloomFilter::getCount(const Address& addr)
+LSB_CountingBloomFilter::getCount(Addr addr)
 {
     return m_filter[get_index(addr)];
 }
@@ -124,7 +124,7 @@ LSB_CountingBloomFilter::getTotalCount()
 }
 
 int
-LSB_CountingBloomFilter::getIndex(const Address& addr)
+LSB_CountingBloomFilter::getIndex(Addr addr)
 {
     return get_index(addr);
 }
@@ -148,11 +148,11 @@ LSB_CountingBloomFilter::writeBit(const int index, const int value)
 }
 
 int
-LSB_CountingBloomFilter::get_index(const Address& addr)
+LSB_CountingBloomFilter::get_index(Addr addr)
 {
-    return addr.bitSelect(RubySystem::getBlockSizeBits(),
-                          RubySystem::getBlockSizeBits() +
-                          m_filter_size_bits - 1);
+    return bitSelect(addr, RubySystem::getBlockSizeBits(),
+                     RubySystem::getBlockSizeBits() +
+                     m_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
index e6bb5cf19..2f23896e2 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
@@ -43,23 +43,23 @@ class LSB_CountingBloomFilter : public AbstractBloomFilter
     ~LSB_CountingBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
     void print(std::ostream& out) const;
 
   private:
-    int get_index(const Address& addr);
+    int get_index(Addr addr);
 
     std::vector<int> m_filter;
     int m_filter_size;
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
index 0f3ea8e2f..3cdca7e3b 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
@@ -76,14 +76,14 @@ MultiBitSelBloomFilter::clear()
 }
 
 void
-MultiBitSelBloomFilter::increment(const Address& addr)
+MultiBitSelBloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 
 void
-MultiBitSelBloomFilter::decrement(const Address& addr)
+MultiBitSelBloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -99,7 +99,7 @@ MultiBitSelBloomFilter::merge(AbstractBloomFilter *other_filter)
 }
 
 void
-MultiBitSelBloomFilter::set(const Address& addr)
+MultiBitSelBloomFilter::set(Addr addr)
 {
     for (int i = 0; i < m_num_hashes; i++) {
         int idx = get_index(addr, i);
@@ -108,14 +108,14 @@ MultiBitSelBloomFilter::set(const Address& addr)
 }
 
 void
-MultiBitSelBloomFilter::unset(const Address& addr)
+MultiBitSelBloomFilter::unset(Addr addr)
 {
     cout << "ERROR: Unset should never be called in a Bloom filter";
     assert(0);
 }
 
 bool
-MultiBitSelBloomFilter::isSet(const Address& addr)
+MultiBitSelBloomFilter::isSet(Addr addr)
 {
     bool res = true;
 
@@ -127,13 +127,13 @@ MultiBitSelBloomFilter::isSet(const Address& addr)
 }
 
 int
-MultiBitSelBloomFilter::getCount(const Address& addr)
+MultiBitSelBloomFilter::getCount(Addr addr)
 {
     return isSet(addr)? 1: 0;
 }
 
 int
-MultiBitSelBloomFilter::getIndex(const Address& addr)
+MultiBitSelBloomFilter::getIndex(Addr addr)
 {
     return 0;
 }
@@ -166,12 +166,12 @@ MultiBitSelBloomFilter::print(ostream& out) const
 }
 
 int
-MultiBitSelBloomFilter::get_index(const Address& addr, int i)
+MultiBitSelBloomFilter::get_index(Addr addr, int i)
 {
     // m_skip_bits is used to perform BitSelect after skipping some
     // bits. Used to simulate BitSel hashing on larger than cache-line
     // granularities
-    uint64 x = (addr.getLineAddress()) >> m_skip_bits;
+    uint64 x = (makeLineAddress(addr) >> m_skip_bits);
     int y = hash_bitsel(x, i, m_num_hashes, 30, m_filter_size_bits);
     //36-bit addresses, 6-bit cache lines
 
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
index 7edb45953..e43dcd6f1 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
@@ -34,6 +34,7 @@
 #include <vector>
 
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/TypeDefines.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
 class MultiBitSelBloomFilter : public AbstractBloomFilter
@@ -43,18 +44,18 @@ class MultiBitSelBloomFilter : public AbstractBloomFilter
     ~MultiBitSelBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
     void print(std::ostream& out) const;
 
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
@@ -65,7 +66,7 @@ class MultiBitSelBloomFilter : public AbstractBloomFilter
     }
 
   private:
-    int get_index(const Address& addr, int hashNumber);
+    int get_index(Addr addr, int hashNumber);
 
     int hash_bitsel(uint64 value, int index, int jump, int maxBits,
                     int numBits);
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
index 4f8775853..33d80f0c4 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
@@ -72,14 +72,14 @@ MultiGrainBloomFilter::clear()
 }
 
 void
-MultiGrainBloomFilter::increment(const Address& addr)
+MultiGrainBloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 
 void
-MultiGrainBloomFilter::decrement(const Address& addr)
+MultiGrainBloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -91,7 +91,7 @@ MultiGrainBloomFilter::merge(AbstractBloomFilter *other_filter)
 }
 
 void
-MultiGrainBloomFilter::set(const Address& addr)
+MultiGrainBloomFilter::set(Addr addr)
 {
     int i = get_block_index(addr);
     assert(i < m_filter_size);
@@ -102,13 +102,13 @@ MultiGrainBloomFilter::set(const Address& addr)
 }
 
 void
-MultiGrainBloomFilter::unset(const Address& addr)
+MultiGrainBloomFilter::unset(Addr addr)
 {
     // not used
 }
 
 bool
-MultiGrainBloomFilter::isSet(const Address& addr)
+MultiGrainBloomFilter::isSet(Addr addr)
 {
     int i = get_block_index(addr);
     assert(i < m_filter_size);
@@ -118,7 +118,7 @@ MultiGrainBloomFilter::isSet(const Address& addr)
 }
 
 int
-MultiGrainBloomFilter::getCount(const Address& addr)
+MultiGrainBloomFilter::getCount(Addr addr)
 {
     // not used
     return 0;
@@ -141,7 +141,7 @@ MultiGrainBloomFilter::getTotalCount()
 }
 
 int
-MultiGrainBloomFilter::getIndex(const Address& addr)
+MultiGrainBloomFilter::getIndex(Addr addr)
 {
     return 0;
     // TODO
@@ -166,21 +166,21 @@ MultiGrainBloomFilter::print(ostream& out) const
 }
 
 int
-MultiGrainBloomFilter::get_block_index(const Address& addr)
+MultiGrainBloomFilter::get_block_index(Addr addr)
 {
     // grap a chunk of bits after byte offset
-    return addr.bitSelect(RubySystem::getBlockSizeBits(),
-                          RubySystem::getBlockSizeBits() +
-                          m_filter_size_bits - 1);
+    return bitSelect(addr, RubySystem::getBlockSizeBits(),
+                     RubySystem::getBlockSizeBits() +
+                     m_filter_size_bits - 1);
 }
 
 int
-MultiGrainBloomFilter::get_page_index(const Address & addr)
+MultiGrainBloomFilter::get_page_index(Addr addr)
 {
     int bits = RubySystem::getBlockSizeBits() + m_filter_size_bits - 1;
 
     // grap a chunk of bits after first chunk
-    return addr.bitSelect(bits, bits + m_page_filter_size_bits - 1);
+    return bitSelect(addr, bits, bits + m_page_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
index 26a8113cb..ceb364a49 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
@@ -43,24 +43,24 @@ class MultiGrainBloomFilter : public AbstractBloomFilter
     ~MultiGrainBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
     void print(std::ostream& out) const;
 
   private:
-    int get_block_index(const Address& addr);
-    int get_page_index(const Address & addr);
+    int get_block_index(Addr addr);
+    int get_page_index(Addr addr);
 
     // The block filter
     std::vector<int> m_filter;
diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.cc b/src/mem/ruby/filters/NonCountingBloomFilter.cc
index 246189357..14bb3a245 100644
--- a/src/mem/ruby/filters/NonCountingBloomFilter.cc
+++ b/src/mem/ruby/filters/NonCountingBloomFilter.cc
@@ -64,13 +64,13 @@ NonCountingBloomFilter::clear()
 }
 
 void
-NonCountingBloomFilter::increment(const Address& addr)
+NonCountingBloomFilter::increment(Addr addr)
 {
     // Not used
 }
 
 void
-NonCountingBloomFilter::decrement(const Address& addr)
+NonCountingBloomFilter::decrement(Addr addr)
 {
     // Not used
 }
@@ -86,21 +86,21 @@ NonCountingBloomFilter::merge(AbstractBloomFilter *other_filter)
 }
 
 void
-NonCountingBloomFilter::set(const Address& addr)
+NonCountingBloomFilter::set(Addr addr)
 {
     int i = get_index(addr);
     m_filter[i] = 1;
 }
 
 void
-NonCountingBloomFilter::unset(const Address& addr)
+NonCountingBloomFilter::unset(Addr addr)
 {
     int i = get_index(addr);
     m_filter[i] = 0;
 }
 
 bool
-NonCountingBloomFilter::isSet(const Address& addr)
+NonCountingBloomFilter::isSet(Addr addr)
 {
     int i = get_index(addr);
     return (m_filter[i]);
@@ -108,7 +108,7 @@ NonCountingBloomFilter::isSet(const Address& addr)
 
 
 int
-NonCountingBloomFilter::getCount(const Address& addr)
+NonCountingBloomFilter::getCount(Addr addr)
 {
     return m_filter[get_index(addr)];
 }
@@ -130,7 +130,7 @@ NonCountingBloomFilter::print(ostream& out) const
 }
 
 int
-NonCountingBloomFilter::getIndex(const Address& addr)
+NonCountingBloomFilter::getIndex(Addr addr)
 {
     return get_index(addr);
 }
@@ -148,11 +148,11 @@ NonCountingBloomFilter::writeBit(const int index, const int value)
 }
 
 int
-NonCountingBloomFilter::get_index(const Address& addr)
+NonCountingBloomFilter::get_index(Addr addr)
 {
-    return addr.bitSelect(RubySystem::getBlockSizeBits() + m_offset,
-                          RubySystem::getBlockSizeBits() + m_offset +
-                          m_filter_size_bits - 1);
+    return bitSelect(addr, RubySystem::getBlockSizeBits() + m_offset,
+                     RubySystem::getBlockSizeBits() + m_offset +
+                     m_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.hh b/src/mem/ruby/filters/NonCountingBloomFilter.hh
index 9eec25528..a092cd667 100644
--- a/src/mem/ruby/filters/NonCountingBloomFilter.hh
+++ b/src/mem/ruby/filters/NonCountingBloomFilter.hh
@@ -43,17 +43,17 @@ class NonCountingBloomFilter : public AbstractBloomFilter
     ~NonCountingBloomFilter();
 
     void clear();
-    void increment(const Address& addr);
-    void decrement(const Address& addr);
+    void increment(Addr addr);
+    void decrement(Addr addr);
     void merge(AbstractBloomFilter * other_filter);
-    void set(const Address& addr);
-    void unset(const Address& addr);
+    void set(Addr addr);
+    void unset(Addr addr);
 
-    bool isSet(const Address& addr);
-    int getCount(const Address& addr);
+    bool isSet(Addr addr);
+    int getCount(Addr addr);
     int getTotalCount();
 
-    int getIndex(const Address& addr);
+    int getIndex(Addr addr);
     int readBit(const int index);
     void writeBit(const int index, const int value);
 
@@ -66,7 +66,7 @@ class NonCountingBloomFilter : public AbstractBloomFilter
     }
 
   private:
-    int get_index(const Address& addr);
+    int get_index(Addr addr);
 
     std::vector<int> m_filter;
     int m_filter_size;