Change base/intmath.{cc,hh} to follow m5 style.

arch/alpha/alpha_tru64_process.cc:
base/intmath.hh:
base/statistics.cc:
base/str.cc:
cpu/o3/btb.cc:
sim/process.cc:
sim/syscall_emul.hh:
    Rename intmath.hh functions to follow m5 style
    (RoundUp -> roundUp, etc.).
base/intmath.cc:
    Rename intmath.hh functions to follow m5 style
    (RoundUp -> roundUp, etc.).
    Also reindent code in m5 style.

--HG--
extra : convert_revision : 57b853002bc3c9911e122599d9062b41a06d8e6a

diff --git a/arch/alpha/alpha_tru64_process.cc b/arch/alpha/alpha_tru64_process.cc
index ab8558182a004a56c8779d07f0a4d1df7909835a..b7a1c7d5920f0f41cb4f65ec0145a9d36fa0087b 100644 (file)
--- a/arch/alpha/alpha_tru64_process.cc
+++ b/arch/alpha/alpha_tru64_process.cc
@@ -843,7 +843,7 @@ class Tru64 {
             // Actual size includes padded string rounded up for alignment.
             // Subtract 256 for dummy char array in Tru64::dirent definition.
             // Add 1 to namelen for terminating null char.
-            int tgt_bufsize = sizeof(Tru64::dirent) - 256 + RoundUp(namelen+1, 8);
+            int tgt_bufsize = sizeof(Tru64::dirent) - 256 + roundUp(namelen+1, 8);
             TypedBufferArg<Tru64::dirent> tgt_dp(tgt_buf_ptr, tgt_bufsize);
             tgt_dp->d_ino = host_dp->d_ino;
             tgt_dp->d_reclen = tgt_bufsize;

diff --git a/base/intmath.cc b/base/intmath.cc
index 099ab1c9aa26f13f3d17e4be825ef95940f4eccb..f1c1651ba805bda755308c6a87f1900edf2d08bd 100644 (file)
--- a/base/intmath.cc
+++ b/base/intmath.cc
@@ -29,30 +29,30 @@
 #include "base/intmath.hh"
 
 int
-PrevPrime(int n)
+prevPrime(int n)
 {
-  int decr;
+    int decr;
 
-  // If the number is even, let's start with the previous odd number.
-  if (!(n & 1))
-    --n;
+    // If the number is even, let's start with the previous odd number.
+    if (!(n & 1))
+        --n;
 
-  // Lets test for divisibility by 3.  Then we will be able to easily
-  // avoid numbers that are divisible by 3 in the future.
-  decr = n % 3;
-  if (decr == 0) {
-    n -= 2;
-    decr = 2;
-  }
-  else if (decr == 1)
-    decr = 4;
+    // Lets test for divisibility by 3.  Then we will be able to easily
+    // avoid numbers that are divisible by 3 in the future.
+    decr = n % 3;
+    if (decr == 0) {
+        n -= 2;
+        decr = 2;
+    }
+    else if (decr == 1)
+        decr = 4;
 
-  for (;;) {
-    if (IsPrime(n))
-      return n;
-    n -= decr;
-    // Toggle between 2 and 4 to prevent trying numbers that are known
-    // to be divisible by 3.
-    decr = 6 - decr;
-  }
+    for (;;) {
+        if (isPrime(n))
+            return n;
+        n -= decr;
+        // Toggle between 2 and 4 to prevent trying numbers that are known
+        // to be divisible by 3.
+        decr = 6 - decr;
+    }
 }

diff --git a/base/intmath.hh b/base/intmath.hh
index 28d47fadd90901017b7e049750ef6a386998d999..3922a326bb8d82d0d56909540b35a423c0d474f9 100644 (file)
--- a/base/intmath.hh
+++ b/base/intmath.hh
@@ -34,12 +34,12 @@
 #include "sim/host.hh"
 
 // Returns the prime number one less than n.
-int PrevPrime(int n);
+int prevPrime(int n);
 
 // Determine if a number is prime
 template <class T>
 inline bool
-IsPrime(T n)
+isPrime(T n)
 {
     T i;
 
@@ -60,20 +60,20 @@ IsPrime(T n)
 
 template <class T>
 inline T
-LeastSigBit(T n)
+leastSigBit(T n)
 {
     return n & ~(n - 1);
 }
 
 template <class T>
 inline bool
-IsPowerOf2(T n)
+isPowerOf2(T n)
 {
-    return n != 0 && LeastSigBit(n) == n;
+    return n != 0 && leastSigBit(n) == n;
 }
 
 inline int
-FloorLog2(unsigned x)
+floorLog2(unsigned x)
 {
     assert(x > 0);
 
@@ -89,7 +89,7 @@ FloorLog2(unsigned x)
 }
 
 inline int
-FloorLog2(unsigned long x)
+floorLog2(unsigned long x)
 {
     assert(x > 0);
 
@@ -108,7 +108,7 @@ FloorLog2(unsigned long x)
 }
 
 inline int
-FloorLog2(unsigned long long x)
+floorLog2(unsigned long long x)
 {
     assert(x > 0);
 
@@ -125,76 +125,76 @@ FloorLog2(unsigned long long x)
 }
 
 inline int
-FloorLog2(int x)
+floorLog2(int x)
 {
     assert(x > 0);
-    return FloorLog2((unsigned)x);
+    return floorLog2((unsigned)x);
 }
 
 inline int
-FloorLog2(long x)
+floorLog2(long x)
 {
     assert(x > 0);
-    return FloorLog2((unsigned long)x);
+    return floorLog2((unsigned long)x);
 }
 
 inline int
-FloorLog2(long long x)
+floorLog2(long long x)
 {
     assert(x > 0);
-    return FloorLog2((unsigned long long)x);
+    return floorLog2((unsigned long long)x);
 }
 
 #if defined(__APPLE__)
 inline int
-FloorLog2(size_t x)
+floorLog2(size_t x)
 {
     assert(x > 0);
     assert(sizeof(size_t) == 4 || sizeof(size_t) == 8);
 
     // It's my hope that this is optimized away?
     if (sizeof(size_t) == 4)
-        return FloorLog2((uint32_t)x);
+        return floorLog2((uint32_t)x);
      else if (sizeof(size_t) == 8)
-        return FloorLog2((uint64_t)x);
+        return floorLog2((uint64_t)x);
 
 }
 #endif
 
 template <class T>
 inline int
-CeilLog2(T n)
+ceilLog2(T n)
 {
     if (n == 1)
         return 0;
 
-    return FloorLog2(n - (T)1) + 1;
+    return floorLog2(n - (T)1) + 1;
 }
 
 template <class T>
 inline T
-FloorPow2(T n)
+floorPow2(T n)
 {
-    return (T)1 << FloorLog2(n);
+    return (T)1 << floorLog2(n);
 }
 
 template <class T>
 inline T
-CeilPow2(T n)
+ceilPow2(T n)
 {
-    return (T)1 << CeilLog2(n);
+    return (T)1 << ceilLog2(n);
 }
 
 template <class T>
 inline T
-DivCeil(T a, T b)
+divCeil(T a, T b)
 {
     return (a + b - 1) / b;
 }
 
 template <class T>
 inline T
-RoundUp(T val, T align)
+roundUp(T val, T align)
 {
     T mask = align - 1;
     return (val + mask) & ~mask;
@@ -202,14 +202,14 @@ RoundUp(T val, T align)
 
 template <class T>
 inline T
-RoundDown(T val, T align)
+roundDown(T val, T align)
 {
     T mask = align - 1;
     return val & ~mask;
 }
 
 inline bool
-IsHex(char c)
+isHex(char c)
 {
     return c >= '0' && c <= '9' ||
         c >= 'A' && c <= 'F' ||
@@ -217,19 +217,19 @@ IsHex(char c)
 }
 
 inline bool
-IsOct(char c)
+isOct(char c)
 {
     return c >= '0' && c <= '7';
 }
 
 inline bool
-IsDec(char c)
+isDec(char c)
 {
     return c >= '0' && c <= '9';
 }
 
 inline int
-Hex2Int(char c)
+hex2Int(char c)
 {
   if (c >= '0' && c <= '9')
     return (c - '0');

diff --git a/base/statistics.cc b/base/statistics.cc
index eaefd5f15a69ed0f754adfd11d8e075e1dc33e97..c9756464176d5e5a5530024ce13cc1b8a20f8f95 100644 (file)
--- a/base/statistics.cc
+++ b/base/statistics.cc
@@ -253,7 +253,7 @@ char *
 MainBin::memory(off_t off)
 {
     if (memsize == -1)
-        memsize = CeilPow2((size_t) offset());
+        memsize = ceilPow2((size_t) offset());
 
     if (!mem) {
         mem = new char[memsize];

diff --git a/base/str.cc b/base/str.cc
index 15f44dad27a6260d112586b90780b81f08278bf8..5f7f50286efff3fd5a275e216781472014623886 100644 (file)
--- a/base/str.cc
+++ b/base/str.cc
@@ -142,7 +142,7 @@ __to_number(string value, T &retval)
     int i = 0;
 
     char c = value[i];
-    if (!IsDec(c)) {
+    if (!isDec(c)) {
         if (c == '-' && sign)
             negative = true;
         else
@@ -161,7 +161,7 @@ __to_number(string value, T &retval)
         if (sign && negative)
             return false;
 
-        if (!IsOct(c)) {
+        if (!isOct(c)) {
             if (c == 'X' || c == 'x') {
                 hex = true;
                 oct = false;
@@ -170,7 +170,7 @@ __to_number(string value, T &retval)
         }
         else
             retval += c - '0';
-    } else if (!IsDec(c))
+    } else if (!isDec(c))
         goto multiply;
     else {
         if (sign && negative && c == '0')
@@ -190,18 +190,18 @@ __to_number(string value, T &retval)
 
         for (i = 2; i <= last ; i++) {
             c = value[i];
-            if (!IsHex(c))
+            if (!isHex(c))
                 return false;
 
             if (retval > hexmax) return false;
             retval *= 16;
-            retval += Hex2Int(c);
+            retval += hex2Int(c);
         }
         return true;
     } else if (oct) {
         for (i = 2; i <= last ; i++) {
             c = value[i];
-            if (!IsOct(c))
+            if (!isOct(c))
                 return false;
 
             if (retval > octmax) return false;
@@ -213,7 +213,7 @@ __to_number(string value, T &retval)
 
     for (i = 2; i < last ; i++) {
         c = value[i];
-        if (!IsDec(c))
+        if (!isDec(c))
             goto multiply;
 
         if (retval > decmax) return false;
@@ -226,7 +226,7 @@ __to_number(string value, T &retval)
     }
 
     c = value[last];
-    if (IsDec(c)) {
+    if (isDec(c)) {
 
         if (retval > decmax) return false;
         bool atmax = retval == decmax;
@@ -274,7 +274,7 @@ __to_number(string value, T &retval)
         mult = 0;
         for (i++; i <= last; i++) {
             c = value[i];
-            if (!IsDec(c))
+            if (!isDec(c))
                 return false;
 
             mult *= 10;

diff --git a/cpu/o3/btb.cc b/cpu/o3/btb.cc
index c2bca34ae9e23d8630111a8b7209a8a02646aa65..7671e61e28f8d631fc171c9146d753f26cc9d136 100644 (file)
--- a/cpu/o3/btb.cc
+++ b/cpu/o3/btb.cc
@@ -52,7 +52,7 @@ DefaultBTB::DefaultBTB(unsigned _numEntries,
 
     tagMask = (1 << tagBits) - 1;
 
-    tagShiftAmt = instShiftAmt + FloorLog2(numEntries);
+    tagShiftAmt = instShiftAmt + floorLog2(numEntries);
 }
 
 inline

diff --git a/sim/process.cc b/sim/process.cc
index a6cf5ded7de2e6cbd6fb8161c4ec1f9f3eedcee6..28bc5ac3b9671602528d57cf0a3429d215163596 100644 (file)
--- a/sim/process.cc
+++ b/sim/process.cc
@@ -274,7 +274,7 @@ LiveProcess::LiveProcess(const string &nm, ObjectFile *objFile,
     text_size = objFile->textSize();
     data_base = objFile->dataBase();
     data_size = objFile->dataSize() + objFile->bssSize();
-    brk_point = RoundUp<uint64_t>(data_base + data_size, VMPageSize);
+    brk_point = roundUp<uint64_t>(data_base + data_size, VMPageSize);
 
     // load object file into target memory
     objFile->loadSections(memory);

diff --git a/sim/syscall_emul.hh b/sim/syscall_emul.hh
index 2bd8969d7b003d986ddf28bcf860b39fe17419df..c535b5ad6aaeb4694cd43f183a9305da30c1cd8c 100644 (file)
--- a/sim/syscall_emul.hh
+++ b/sim/syscall_emul.hh
@@ -634,7 +634,7 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
     if (start == 0) {
         // user didn't give an address... pick one from our "mmap region"
         start = p->mmap_end;
-        p->mmap_end += RoundUp<Addr>(length, VMPageSize);
+        p->mmap_end += roundUp<Addr>(length, VMPageSize);
         if (p->nxm_start != 0) {
             //If we have an nxm space, make sure we haven't colided
             assert(p->mmap_end < p->nxm_start);