[Support] Reduce Dependence on Host.h

[lenary]

Summary

The intention behind this commit is to reduce the use of Host.h/Host.cpp
in Support, to where it is only necessary.

In this case, the endian-detection and support functionality needed by
these implementations can be provided by Support/SwapByteOrder.h in a
cleaner manner.

[dexonsmith]

llvm/lib/Support/SHA1.cpp

191–194

Can we use if constexpr here? Or is that not supported by all compilers yet?

193

I think usual LLVM style only uses braces when there are multiple lines on at least one side.

[lenary]

llvm/lib/Support/SHA1.cpp

191–194

I forgot this was something we could do, but LLVM is C++17, so it should be allowed, I believe.

193

Ack

[MaskRay]

llvm/Support/Endian.h read<T, little, aligned>(...) is likely better API for many code pieces in this file. Or use read32le if the alignment optimization doesn't really matter.

[lenary]

In D137834#3922044, @MaskRay wrote:

llvm/Support/Endian.h read<T, little, aligned>(...) is likely better API for many code pieces in this file. Or use read32le if the alignment optimization doesn't really matter.

I'll look into this as a follow up. I was really only doing it to make moving Host.h out of llvm/Support easier.

[MaskRay]

LGTM.

[dexonsmith]

LGTM!

[fpetrogalli]

Hi - I have noticed that there are tabes indenting the code I stead os spaces. Is this clang-format doing it?

Francesco

llvm/lib/Support/SHA256.cpp

246–252

Tabs?

253

This is an improvement that is unrelated to making libSupport less dependent on Host.cpp. I'd suggest to either mention the extra change in the commit message, or factor it out as a separate commit (up to you).

[lenary]

llvm/lib/Support/SHA256.cpp

246–252

No, I've indented with spaces. The chevrons are in the margin, and are Phabricator's way of showing that for most of these lines, only the indentation changed.

253

I'll mention it in the message when I commit this.

[fpetrogalli]

LGTM. Thank you.

llvm/lib/Support/SHA256.cpp

246–252

Thank you for explaining.

253

SGTM.

llvm/include/llvm/Support/OnDiskHashTable.h

 //===----------------------------------------------------------------------===//
 #ifndef LLVM_SUPPORT_ONDISKHASHTABLE_H
 #define LLVM_SUPPORT_ONDISKHASHTABLE_H
 
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
 
 namespace llvm {
 
 /// Generates an on disk hash table.

llvm/lib/Support/FoldingSet.cpp

 // nodes in a graph.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/SwapByteOrder.h"
 #include <cassert>
 #include <cstring>
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // FoldingSetNodeIDRef Implementation
 
 bool FoldingSetNodeIDRef::operator==(FoldingSetNodeIDRef RHS) const {

llvm/lib/Support/SHA1.cpp

 // and removing unnecessary code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/SHA1.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Endian.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/SwapByteOrder.h"
 #include <string.h>
 
 using namespace llvm;
 
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-#define SHA_BIG_ENDIAN
-#endif
-
 static inline uint32_t rol(uint32_t Number, int Bits) {
   return (Number << Bits) | (Number >> (32 - Bits));
 }
 
 static inline uint32_t blk0(uint32_t *Buf, int I) { return Buf[I]; }
 
 static inline uint32_t blk(uint32_t *Buf, int I) {
   Buf[I & 15] = rol(Buf[(I + 13) & 15] ^ Buf[(I + 8) & 15] ^ Buf[(I + 2) & 15] ^
void SHA1::hashBlock() {
   InternalState.State[0] += A;
   InternalState.State[1] += B;
   InternalState.State[2] += C;
   InternalState.State[3] += D;
   InternalState.State[4] += E;
 }
 
 void SHA1::addUncounted(uint8_t Data) {
-#ifdef SHA_BIG_ENDIAN
+  if constexpr (sys::IsBigEndianHost)
     InternalState.Buffer.C[InternalState.BufferOffset] = Data;
-#else
+  else
     InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;
-#endif
 
   InternalState.BufferOffset++;
   if (InternalState.BufferOffset == BLOCK_LENGTH) {
     hashBlock();
     InternalState.BufferOffset = 0;
   }
 }
 
void SHA1::pad() {
   addUncounted(InternalState.ByteCount >> 5);
   addUncounted(InternalState.ByteCount << 3);
 }
 
 void SHA1::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
   // Pad to complete the last block
   pad();
 
-#ifdef SHA_BIG_ENDIAN
+  if constexpr (sys::IsBigEndianHost) {
     // Just copy the current state
     for (int i = 0; i < 5; i++) {
       HashResult[i] = InternalState.State[i];
     }
-#else
+  } else {
     // Swap byte order back
     for (int i = 0; i < 5; i++) {
-    HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
-                    (((InternalState.State[i]) << 8) & 0x00ff0000) |
-                    (((InternalState.State[i]) >> 8) & 0x0000ff00) |
-                    (((InternalState.State[i]) >> 24) & 0x000000ff);
+      HashResult[i] = sys::getSwappedBytes(InternalState.State[i]);
+    }
   }
-#endif
 }
 
 std::array<uint8_t, 20> SHA1::final() {
   union {
     std::array<uint32_t, HASH_LENGTH / 4> HashResult;
     std::array<uint8_t, HASH_LENGTH> ReturnResult;
   };
   static_assert(sizeof(HashResult) == sizeof(ReturnResult));

llvm/lib/Support/SHA256.cpp

  *   [1] llvm/lib/Support/SHA1.{h,cpp}
  */
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/SHA256.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Endian.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/SwapByteOrder.h"
 #include <string.h>
 
 namespace llvm {
 
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-#define SHA_BIG_ENDIAN
-#endif
-
 #define SHR(x, c) ((x) >> (c))
 #define ROTR(x, n) (((x) >> n) | ((x) << (32 - (n))))
 
 #define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
 #define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
 
 #define SIGMA_0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
 #define SIGMA_1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
void SHA256::hashBlock() {
   InternalState.State[3] += D;
   InternalState.State[4] += E;
   InternalState.State[5] += F;
   InternalState.State[6] += G;
   InternalState.State[7] += H;
 }
 
 void SHA256::addUncounted(uint8_t Data) {
-#ifdef SHA_BIG_ENDIAN
+  if constexpr (sys::IsBigEndianHost)
     InternalState.Buffer.C[InternalState.BufferOffset] = Data;
-#else
+  else
     InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;
-#endif
 
   InternalState.BufferOffset++;
   if (InternalState.BufferOffset == BLOCK_LENGTH) {
     hashBlock();
     InternalState.BufferOffset = 0;
   }
 }
 
void SHA256::pad() {
   addUncounted(len >> 8);
   addUncounted(len);
 }
 
 void SHA256::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
   // Pad to complete the last block
   pad();
 
-#ifdef SHA_BIG_ENDIAN
+  if constexpr (sys::IsBigEndianHost) {
     // Just copy the current state
     for (int i = 0; i < 8; i++) {
       HashResult[i] = InternalState.State[i];
     }
-#else
+  } else {
     // Swap byte order back
     for (int i = 0; i < 8; i++) {
-    HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
-                    (((InternalState.State[i]) << 8) & 0x00ff0000) |
-                    (((InternalState.State[i]) >> 8) & 0x0000ff00) |
-                    (((InternalState.State[i]) >> 24) & 0x000000ff);
+      HashResult[i] = sys::getSwappedBytes(InternalState.State[i]);
+    }
   }
-#endif
 }
 
 std::array<uint8_t, 32> SHA256::final() {
   union {
     std::array<uint32_t, HASH_LENGTH / 4> HashResult;
     std::array<uint8_t, HASH_LENGTH> ReturnResult;
   };
   static_assert(sizeof(HashResult) == sizeof(ReturnResult));