Add a compiler test.
C leaves some details as implementation-defined. We only support
implementations which define things consistent with the obvious
representation on current machines.
Change-Id: I255a2e54a86c8a7d987dea51ea7168ad66ad9ddd
Reviewed-on: https://boringssl-review.googlesource.com/15305
Reviewed-by: Adam Langley <agl@google.com>
diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt
index be36c4b..56ce7eb 100644
--- a/crypto/CMakeLists.txt
+++ b/crypto/CMakeLists.txt
@@ -238,6 +238,7 @@
bio/bio_test.cc
bytestring/bytestring_test.cc
chacha/chacha_test.cc
+ compiler_test.cc
constant_time_test.cc
curve25519/x25519_test.cc
dh/dh_test.cc
diff --git a/crypto/compiler_test.cc b/crypto/compiler_test.cc
new file mode 100644
index 0000000..5b1c014
--- /dev/null
+++ b/crypto/compiler_test.cc
@@ -0,0 +1,168 @@
+/* Copyright (c) 2017, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <limits.h>
+#include <stdint.h>
+
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include "test/test_util.h"
+
+
+template <typename T>
+static void CheckRepresentation(T value) {
+ SCOPED_TRACE(value);
+
+ // Convert to the corresponding two's-complement unsigned value. We use an
+ // unsigned value so the right-shift below has defined value. Right-shifts of
+ // negative numbers in C are implementation defined.
+ //
+ // If |T| is already unsigned, this is a no-op, as desired.
+ //
+ // If |T| is signed, conversion to unsigned is defined to repeatedly add or
+ // subtract (numerically, not within |T|) one more than the unsigned type's
+ // maximum value until it fits (this must be a power of two). This is the
+ // conversion we want.
+ using UnsignedT = typename std::make_unsigned<T>::type;
+ UnsignedT value_u = static_cast<UnsignedT>(value);
+ EXPECT_EQ(sizeof(UnsignedT), sizeof(T));
+
+ // Integers must be little-endian.
+ uint8_t expected[sizeof(UnsignedT)];
+ for (size_t i = 0; i < sizeof(UnsignedT); i++) {
+ expected[i] = static_cast<uint8_t>(value_u);
+ // Divide instead of right-shift to appease compilers that warn if |T| is a
+ // char. The explicit cast is also needed to appease MSVC if integer
+ // promotion happened.
+ value_u = static_cast<UnsignedT>(value_u / 256);
+ }
+ EXPECT_EQ(0u, value_u);
+
+ // Check that |value| has the expected representation.
+ EXPECT_EQ(Bytes(expected),
+ Bytes(reinterpret_cast<const uint8_t *>(&value), sizeof(value)));
+}
+
+TEST(CompilerTest, IntegerRepresentation) {
+ EXPECT_EQ(8, CHAR_BIT);
+ EXPECT_EQ(0xff, UCHAR_MAX);
+
+ // uint8_t is assumed to be unsigned char. I.e., casting to uint8_t should be
+ // as good as unsigned char for strict aliasing purposes.
+ uint8_t u8 = 0;
+ unsigned char *ptr = &u8;
+ (void)ptr;
+
+ // Sized integers have the expected size.
+ EXPECT_EQ(1u, sizeof(uint8_t));
+ EXPECT_EQ(2u, sizeof(uint16_t));
+ EXPECT_EQ(4u, sizeof(uint32_t));
+ EXPECT_EQ(8u, sizeof(uint64_t));
+
+ // size_t does not exceed uint64_t.
+ EXPECT_LE(sizeof(size_t), 8u);
+
+ // int must be 32-bit or larger.
+ EXPECT_LE(0x7fffffff, INT_MAX);
+ EXPECT_LE(0xffffffffu, UINT_MAX);
+
+ CheckRepresentation(static_cast<signed char>(127));
+ CheckRepresentation(static_cast<signed char>(1));
+ CheckRepresentation(static_cast<signed char>(0));
+ CheckRepresentation(static_cast<signed char>(-1));
+ CheckRepresentation(static_cast<signed char>(-42));
+ CheckRepresentation(static_cast<signed char>(-128));
+
+ CheckRepresentation(static_cast<int>(INT_MAX));
+ CheckRepresentation(static_cast<int>(0x12345678));
+ CheckRepresentation(static_cast<int>(1));
+ CheckRepresentation(static_cast<int>(0));
+ CheckRepresentation(static_cast<int>(-1));
+ CheckRepresentation(static_cast<int>(-0x12345678));
+ CheckRepresentation(static_cast<int>(INT_MIN));
+
+ CheckRepresentation(static_cast<unsigned>(UINT_MAX));
+ CheckRepresentation(static_cast<unsigned>(0x12345678));
+ CheckRepresentation(static_cast<unsigned>(1));
+ CheckRepresentation(static_cast<unsigned>(0));
+
+ CheckRepresentation(static_cast<long>(LONG_MAX));
+ CheckRepresentation(static_cast<long>(0x12345678));
+ CheckRepresentation(static_cast<long>(1));
+ CheckRepresentation(static_cast<long>(0));
+ CheckRepresentation(static_cast<long>(-1));
+ CheckRepresentation(static_cast<long>(-0x12345678));
+ CheckRepresentation(static_cast<long>(LONG_MIN));
+
+ CheckRepresentation(static_cast<unsigned long>(ULONG_MAX));
+ CheckRepresentation(static_cast<unsigned long>(0x12345678));
+ CheckRepresentation(static_cast<unsigned long>(1));
+ CheckRepresentation(static_cast<unsigned long>(0));
+
+ CheckRepresentation(static_cast<int16_t>(0x7fff));
+ CheckRepresentation(static_cast<int16_t>(0x1234));
+ CheckRepresentation(static_cast<int16_t>(1));
+ CheckRepresentation(static_cast<int16_t>(0));
+ CheckRepresentation(static_cast<int16_t>(-1));
+ CheckRepresentation(static_cast<int16_t>(-0x7fff - 1));
+
+ CheckRepresentation(static_cast<uint16_t>(0xffff));
+ CheckRepresentation(static_cast<uint16_t>(0x1234));
+ CheckRepresentation(static_cast<uint16_t>(1));
+ CheckRepresentation(static_cast<uint16_t>(0));
+
+ CheckRepresentation(static_cast<int32_t>(0x7fffffff));
+ CheckRepresentation(static_cast<int32_t>(0x12345678));
+ CheckRepresentation(static_cast<int32_t>(1));
+ CheckRepresentation(static_cast<int32_t>(0));
+ CheckRepresentation(static_cast<int32_t>(-1));
+ CheckRepresentation(static_cast<int32_t>(-0x7fffffff - 1));
+
+ CheckRepresentation(static_cast<uint32_t>(0xffffffff));
+ CheckRepresentation(static_cast<uint32_t>(0x12345678));
+ CheckRepresentation(static_cast<uint32_t>(1));
+ CheckRepresentation(static_cast<uint32_t>(0));
+
+ CheckRepresentation(static_cast<int64_t>(0x7fffffffffffffff));
+ CheckRepresentation(static_cast<int64_t>(0x123456789abcdef0));
+ CheckRepresentation(static_cast<int64_t>(1));
+ CheckRepresentation(static_cast<int64_t>(0));
+ CheckRepresentation(static_cast<int64_t>(-1));
+ CheckRepresentation(static_cast<int64_t>(-0x7fffffffffffffff - 1));
+
+ CheckRepresentation(static_cast<uint64_t>(0xffffffffffffffff));
+ CheckRepresentation(static_cast<uint64_t>(0x12345678abcdef0));
+ CheckRepresentation(static_cast<uint64_t>(1));
+ CheckRepresentation(static_cast<uint64_t>(0));
+}
+
+// Converting pointers to integers and doing arithmetic on those values are both
+// defined. Converting those values back into pointers is undefined, but, for
+// aliasing checks, we require that the implementation-defined result of that
+// computation commutes with pointer arithmetic.
+TEST(CompilerTest, PointerRepresentation) {
+ char chars[256];
+ for (size_t i = 0; i < sizeof(chars); i++) {
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(chars) + i,
+ reinterpret_cast<uintptr_t>(chars + i));
+ }
+
+ int ints[256];
+ for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(ints); i++) {
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(ints) + i * sizeof(int),
+ reinterpret_cast<uintptr_t>(ints + i));
+ }
+}
