X-Git-Url: http://plrg.eecs.uci.edu/git/?p=folly.git;a=blobdiff_plain;f=folly%2FSpookyHashV2.cpp;h=0f623625a603f0364c2f82074e1c7f66cec72f18;hp=d55a62be2acdeb36e2c01a7aeb34aed79f4e2538;hb=27249d4447e18aa8de6fbd1f483a346aabdd75da;hpb=321542683a01c3f334047531e9b487f047129775

diff --git a/folly/SpookyHashV2.cpp b/folly/SpookyHashV2.cpp
index d55a62be..0f623625 100644
--- a/folly/SpookyHashV2.cpp
+++ b/folly/SpookyHashV2.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@
 
 #include <folly/SpookyHashV2.h>
 
+#include <folly/CppAttributes.h>
 #include <folly/Portability.h>
 
 #include <cstring>
@@ -35,8 +36,6 @@
 namespace folly {
 namespace hash {
 
-static constexpr auto kAllowUnalignedReads = bool(FOLLY_HAVE_UNALIGNED_READS);
-
 //
 // short hash ... it could be used on any message,
 // but it's used by Spooky just for short messages.
@@ -58,7 +57,7 @@ void SpookyHashV2::Short(
 
     u.p8 = (const uint8_t *)message;
 
-    if (!kAllowUnalignedReads && (u.i & 0x7))
+    if (!kHasUnalignedAccess && (u.i & 0x7))
     {
         memcpy(buf, message, length);
         u.p64 = buf;
@@ -100,37 +99,48 @@ void SpookyHashV2::Short(
     switch (remainder)
     {
     case 15:
-    d += ((uint64_t)u.p8[14]) << 48;
+        d += ((uint64_t)u.p8[14]) << 48;
+        FOLLY_FALLTHROUGH;
     case 14:
         d += ((uint64_t)u.p8[13]) << 40;
+        FOLLY_FALLTHROUGH;
     case 13:
         d += ((uint64_t)u.p8[12]) << 32;
+        FOLLY_FALLTHROUGH;
     case 12:
         d += u.p32[2];
         c += u.p64[0];
         break;
     case 11:
         d += ((uint64_t)u.p8[10]) << 16;
+        FOLLY_FALLTHROUGH;
     case 10:
         d += ((uint64_t)u.p8[9]) << 8;
+        FOLLY_FALLTHROUGH;
     case 9:
         d += (uint64_t)u.p8[8];
+        FOLLY_FALLTHROUGH;
     case 8:
         c += u.p64[0];
         break;
     case 7:
         c += ((uint64_t)u.p8[6]) << 48;
+        FOLLY_FALLTHROUGH;
     case 6:
         c += ((uint64_t)u.p8[5]) << 40;
+        FOLLY_FALLTHROUGH;
     case 5:
         c += ((uint64_t)u.p8[4]) << 32;
+        FOLLY_FALLTHROUGH;
     case 4:
         c += u.p32[0];
         break;
     case 3:
         c += ((uint64_t)u.p8[2]) << 16;
+        FOLLY_FALLTHROUGH;
     case 2:
         c += ((uint64_t)u.p8[1]) << 8;
+        FOLLY_FALLTHROUGH;
     case 1:
         c += (uint64_t)u.p8[0];
         break;
@@ -178,7 +188,7 @@ void SpookyHashV2::Hash128(
     end = u.p64 + (length/sc_blockSize)*sc_numVars;
 
     // handle all whole sc_blockSize blocks of bytes
-    if (kAllowUnalignedReads || ((u.i & 0x7) == 0))
+    if (kHasUnalignedAccess || ((u.i & 0x7) == 0))
     {
         while (u.p64 < end)
         {
@@ -200,7 +210,7 @@ void SpookyHashV2::Hash128(
     remainder = (length - ((const uint8_t *)end-(const uint8_t *)message));
     memcpy(buf, end, remainder);
     memset(((uint8_t *)buf)+remainder, 0, sc_blockSize-remainder);
-    ((uint8_t *)buf)[sc_blockSize-1] = remainder;
+    ((uint8_t*)buf)[sc_blockSize - 1] = uint8_t(remainder);
 
     // do some final mixing
     End(buf, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
@@ -286,7 +296,7 @@ void SpookyHashV2::Update(const void *message, size_t length)
     // handle all whole blocks of sc_blockSize bytes
     end = u.p64 + (length/sc_blockSize)*sc_numVars;
     remainder = (uint8_t)(length-((const uint8_t *)end-u.p8));
-    if (kAllowUnalignedReads || (u.i & 0x7) == 0)
+    if (kHasUnalignedAccess || (u.i & 0x7) == 0)
     {
         while (u.p64 < end)
         {