Skip to content

S
swiftshader
Commit ca8a16ef by Antonio Maiorano
Options

Subzero: clang-format crosstest, pnacl-llvm, runtime, and unittest

Formatted using: find ${DIR} -iname "*.cc" -o -iname "*.h" -o -iname "*.hpp" -o -iname "*.cpp" -o -iname "*.inl" | xargs ${CLANG_FORMAT} -i -style=file Bug: b/144825072 Change-Id: Ie6ebd83f85dc11a044dec4514a1e81edbbd4ed21 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/50169Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com> Tested-by: 's avatarAntonio Maiorano <amaiorano@google.com> Kokoro-Result: kokoro <noreply+kokoro@google.com>
parent debdfa2a
Showing with 653 additions and 541 deletions
third_party/subzero/crosstest/mem_intrin.cpp
......@@ -3,9 +3,9 @@
* (fixed length buffers, variable length buffers, etc.)
*/
#include <stdint.h> /* cstdint requires -std=c++0x or higher */
#include <cstdlib>
#include <cstring>
#include <stdint.h> /* cstdint requires -std=c++0x or higher */
#include "mem_intrin.h"
#include "xdefs.h"
......
third_party/subzero/crosstest/mem_intrin_main.cpp
/* crosstest.py --test=mem_intrin.cpp --driver=mem_intrin_main.cpp \
--prefix=Subzero_ --output=mem_intrin */
#include <stdint.h> /* cstdint requires -std=c++0x or higher */
#include <cstdio>
#include <stdint.h> /* cstdint requires -std=c++0x or higher */
#include "mem_intrin.h"
#include "xdefs.h"
......
third_party/subzero/crosstest/test_arith.h
......@@ -12,9 +12,9 @@
//
//===----------------------------------------------------------------------===//
#include <stdint.h>
#include "test_arith.def"
#include "xdefs.h"
#include <stdint.h>
#include "vectors.h"
......
third_party/subzero/crosstest/test_arith_main.cpp
......@@ -17,12 +17,12 @@
#include <stdint.h>
#include <climits> // CHAR_BIT
#include <limits>
#include <cfloat>
#include <climits> // CHAR_BIT
#include <cmath> // fmodf
#include <cstring> // memcmp
#include <iostream>
#include <limits>
// Include test_arith.h twice - once normally, and once within the
// Subzero_ namespace, corresponding to the llc and Subzero translated
......@@ -66,22 +66,26 @@ void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
bool ExcludeDivExceptions; // for divide related tests
} Funcs[] = {
#define X(inst, op, isdiv, isshift) \
{ STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv } \
,
{STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv},
UINTOP_TABLE
#undef X
#define X(inst, op, isdiv, isshift) \
{ STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv } \
,
{STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv},
SINTOP_TABLE
#undef X
#define X(mult_by) \
{ \
"Mult-By-" STR(mult_by), testMultiplyBy##mult_by, \
Subzero_::testMultiplyBy##mult_by, NULL, NULL, false \
} \
, {"Mult-By-Neg-" STR(mult_by), testMultiplyByNeg##mult_by, \
Subzero_::testMultiplyByNeg##mult_by, NULL, NULL, false},
{"Mult-By-" STR(mult_by), \
testMultiplyBy##mult_by, \
Subzero_::testMultiplyBy##mult_by, \
NULL, \
NULL, \
false}, \
{"Mult-By-Neg-" STR(mult_by), \
testMultiplyByNeg##mult_by, \
Subzero_::testMultiplyByNeg##mult_by, \
NULL, \
NULL, \
false},
MULIMM_TABLE};
#undef X
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
......@@ -187,13 +191,11 @@ void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
bool MaskShiftOperations; // for shift related tests
} Funcs[] = {
#define X(inst, op, isdiv, isshift) \
{ STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv, isshift } \
,
{STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv, isshift},
UINTOP_TABLE
#undef X
#define X(inst, op, isdiv, isshift) \
{ STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv, isshift } \
,
{STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv, isshift},
SINTOP_TABLE
#undef X
};
......@@ -256,8 +258,7 @@ void testsFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncType FuncSz;
} Funcs[] = {
#define X(inst, op, func) \
{ STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst } \
,
{STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst},
FPOP_TABLE
#undef X
};
......@@ -327,8 +328,7 @@ void testsVecFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncType FuncSz;
} Funcs[] = {
#define X(inst, op, func) \
{ STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst } \
,
{STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst},
FPOP_TABLE
#undef X
};
......
third_party/subzero/crosstest/test_bitmanip_main.cpp
......@@ -29,19 +29,56 @@ namespace Subzero_ {
#include "test_bitmanip.h"
}
volatile uint64 Values[] = {
0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
0xfffe, 0xffff, 0xc0de, 0xabcd, 0xdcba, 0x007fffff /*Max subnormal + */,
0x00800000 /*Min+ */, 0x7f7fffff /*Max+ */, 0x7f800000 /*+Inf*/,
0xff800000 /*-Inf*/, 0x7fa00000 /*SNaN*/, 0x7fc00000 /*QNaN*/, 0x7ffffffe,
0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0x12345678,
0xabcd1234, 0x1234dcba, 0x100000000ll, 0x100000001ll, 0x123456789abcdef1ll,
0x987654321ab1fedcll, 0x000fffffffffffffll /*Max subnormal + */,
0x0010000000000000ll /*Min+ */, 0x7fefffffffffffffll /*Max+ */,
0x7ff0000000000000ll /*+Inf*/, 0xfff0000000000000ll /*-Inf*/,
0x7ff0000000000001ll /*SNaN*/, 0x7ff8000000000000ll /*QNaN*/,
0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
volatile uint64 Values[] = {0,
1,
0x7e,
0x7f,
0x80,
0x81,
0xfe,
0xff,
0x7ffe,
0x7fff,
0x8000,
0x8001,
0xfffe,
0xffff,
0xc0de,
0xabcd,
0xdcba,
0x007fffff /*Max subnormal + */,
0x00800000 /*Min+ */,
0x7f7fffff /*Max+ */,
0x7f800000 /*+Inf*/,
0xff800000 /*-Inf*/,
0x7fa00000 /*SNaN*/,
0x7fc00000 /*QNaN*/,
0x7ffffffe,
0x7fffffff,
0x80000000,
0x80000001,
0xfffffffe,
0xffffffff,
0x12345678,
0xabcd1234,
0x1234dcba,
0x100000000ll,
0x100000001ll,
0x123456789abcdef1ll,
0x987654321ab1fedcll,
0x000fffffffffffffll /*Max subnormal + */,
0x0010000000000000ll /*Min+ */,
0x7fefffffffffffffll /*Max+ */,
0x7ff0000000000000ll /*+Inf*/,
0xfff0000000000000ll /*-Inf*/,
0x7ff0000000000001ll /*SNaN*/,
0x7ff8000000000000ll /*QNaN*/,
0x7ffffffffffffffell,
0x7fffffffffffffffll,
0x8000000000000000ll,
0x8000000000000001ll,
0xfffffffffffffffell,
0xffffffffffffffffll};
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
......@@ -54,8 +91,8 @@ void testBitManip(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncType FuncSz;
} Funcs[] = {
#define X(inst) \
{ STR(inst), test_##inst, Subzero_::test_##inst } \
, {STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst}, \
{STR(inst), test_##inst, Subzero_::test_##inst}, \
{STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst}, \
{STR(inst) "_const", test_const_##inst, Subzero_::test_const_##inst},
BMI_OPS
#undef X
......
third_party/subzero/crosstest/test_calling_conv.cpp
......@@ -50,9 +50,8 @@ void caller_vlvilvfvdviv(void) {
int arg11 = 26;
v4f32 arg12 = {27, 28, 29, 30};
CALL_AS_TYPE(callee_vlvilvfvdviv_Ty, Callee)(arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10,
arg11, arg12);
CALL_AS_TYPE(callee_vlvilvfvdviv_Ty, Callee)
(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
}
#define HANDLE_ARG(ARGNUM) \
......
third_party/subzero/crosstest/test_calling_conv_main.cpp
......@@ -72,19 +72,21 @@ void testCaller(size_t &TotalTests, size_t &Passes, size_t &Failures) {
#ifdef MIPS32
#define X(caller, callee, argc) \
{ \
STR(caller), STR(callee), argc, &caller, &Subzero_::caller, \
STR(caller), \
STR(callee), \
argc, \
&caller, \
&Subzero_::caller, \
reinterpret_cast<CalleePtrTy>(&Subzero_::callee), \
} \
,
},
TEST_FUNC_TABLE
#undef X
#else
#define X(caller, callee, argc) \
{ \
STR(caller), STR(callee), argc, &caller, &Subzero_::caller, \
reinterpret_cast<CalleePtrTy>(&callee), \
} \
,
STR(caller), STR(callee), argc, \
&caller, &Subzero_::caller, reinterpret_cast<CalleePtrTy>(&callee), \
},
TEST_FUNC_TABLE
#undef X
#endif
......@@ -130,12 +132,12 @@ void testCallee(size_t &TotalTests, size_t &Passes, size_t &Failures) {
CalleePtrTy Callee, Subzero_Callee;
} Funcs[] = {
#define X(caller, callee, argc) \
{ \
STR(caller), STR(callee), argc, &caller, \
{STR(caller), \
STR(callee), \
argc, \
&caller, \
reinterpret_cast<CalleePtrTy>(&callee), \
reinterpret_cast<CalleePtrTy>(&Subzero_::callee) \
} \
,
reinterpret_cast<CalleePtrTy>(&Subzero_::callee)},
TEST_FUNC_TABLE
#undef X
};
......
third_party/subzero/crosstest/test_cast.cpp
......@@ -14,9 +14,9 @@
// This aims to test all the conversion bitcode instructions across
// all PNaCl primitive data types.
#include <stdint.h>
#include "test_cast.h"
#include "xdefs.h"
#include <stdint.h>
template <typename FromType, typename ToType>
ToType __attribute__((noinline)) cast(FromType a) {
......
third_party/subzero/crosstest/test_cast_main.cpp
......@@ -179,20 +179,64 @@ int main(int argc, char *argv[]) {
0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
volatile uint64 ValsUi64[] = {
0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
0xfffffffe, 0xffffffff, 0x100000000ull, 0x100000001ull,
0x7ffffffffffffffeull, 0x7fffffffffffffffull, 0x8000000000000000ull,
0x8000000000000001ull, 0xfffffffffffffffeull, 0xffffffffffffffffull};
volatile uint64 ValsUi64[] = {0,
1,
0x7e,
0x7f,
0x80,
0x81,
0xfe,
0xff,
0x7ffe,
0x7fff,
0x8000,
0x8001,
0xfffe,
0xffff,
0x7ffffffe,
0x7fffffff,
0x80000000,
0x80000001,
0xfffffffe,
0xffffffff,
0x100000000ull,
0x100000001ull,
0x7ffffffffffffffeull,
0x7fffffffffffffffull,
0x8000000000000000ull,
0x8000000000000001ull,
0xfffffffffffffffeull,
0xffffffffffffffffull};
static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64);
volatile int64 ValsSi64[] = {
0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
0xfffffffe, 0xffffffff, 0x100000000ll, 0x100000001ll,
0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
volatile int64 ValsSi64[] = {0,
1,
0x7e,
0x7f,
0x80,
0x81,
0xfe,
0xff,
0x7ffe,
0x7fff,
0x8000,
0x8001,
0xfffe,
0xffff,
0x7ffffffe,
0x7fffffff,
0x80000000,
0x80000001,
0xfffffffe,
0xffffffff,
0x100000000ll,
0x100000001ll,
0x7ffffffffffffffell,
0x7fffffffffffffffll,
0x8000000000000000ll,
0x8000000000000001ll,
0xfffffffffffffffell,
0xffffffffffffffffll};
static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64);
static const double NegInf = -1.0 / 0.0;
......
third_party/subzero/crosstest/test_fcmp_main.cpp
......@@ -20,9 +20,9 @@
#include <cstring>
#include <iostream>
#include "vectors.h"
#include "test_arith.def"
#include "test_fcmp.def"
#include "vectors.h"
#define X(cmp) \
extern "C" bool fcmp##cmp##Float(float a, float b); \
......@@ -79,13 +79,11 @@ void testsScalar(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncTypeDoubleSelect FuncDoubleSelectLlc;
} Funcs[] = {
#define X(cmp) \
{ \
"fcmp" STR(cmp), Subzero_fcmp##cmp##Float, fcmp##cmp##Float, \
Subzero_fcmp##cmp##Double, fcmp##cmp##Double, \
Subzero_fcmpSelect##cmp##Float, fcmpSelect##cmp##Float, \
Subzero_fcmpSelect##cmp##Double, fcmpSelect##cmp##Double \
} \
,
{"fcmp" STR(cmp), Subzero_fcmp##cmp##Float, \
fcmp##cmp##Float, Subzero_fcmp##cmp##Double, \
fcmp##cmp##Double, Subzero_fcmpSelect##cmp##Float, \
fcmpSelect##cmp##Float, Subzero_fcmpSelect##cmp##Double, \
fcmpSelect##cmp##Double},
FCMP_TABLE
#undef X
};
......@@ -164,9 +162,7 @@ void testsVector(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncTypeVector FuncVectorSz;
FuncTypeVector FuncVectorLlc;
} Funcs[] = {
#define X(cmp) \
{ "fcmp" STR(cmp), Subzero_fcmp##cmp##Vector, fcmp##cmp##Vector } \
,
#define X(cmp) {"fcmp" STR(cmp), Subzero_fcmp##cmp##Vector, fcmp##cmp##Vector},
FCMP_TABLE
#undef X
};
......
third_party/subzero/crosstest/test_global.cpp
......@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
#include <stdint.h>
#include <cstdlib>
#include <stdint.h>
#include "test_global.h"
......
third_party/subzero/crosstest/test_global_main.cpp
......@@ -14,9 +14,9 @@
/* crosstest.py --test=test_global.cpp \
--driver=test_global_main.cpp --prefix=Subzero_ --output=test_global */
#include <stdint.h>
#include <cstdlib>
#include <iostream>
#include <stdint.h>
#include "test_global.h"
namespace Subzero_ {
......
third_party/subzero/crosstest/test_icmp_main.cpp
......@@ -16,8 +16,8 @@
#include <climits> // CHAR_BIT
#include <cstring> // memcmp, memset
#include <stdint.h>
#include <iostream>
#include <stdint.h>
// Include test_icmp.h twice - once normally, and once within the
// Subzero_ namespace, corresponding to the llc and Subzero translated
......@@ -49,19 +49,13 @@ void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncTypeUnsigned FuncSz;
} Funcs[] = {
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)icmp##cmp, \
(FuncTypeUnsigned)Subzero_::icmp##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)icmp##cmp, \
(FuncTypeUnsigned)Subzero_::icmp##cmp},
ICMP_U_TABLE
#undef X
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp},
ICMP_S_TABLE
#undef X
};
......@@ -132,19 +126,13 @@ void testsIntWithZero(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncTypeUnsigned FuncSz;
} Funcs[] = {
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)icmp_zero##cmp, \
(FuncTypeUnsigned)Subzero_::icmp_zero##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)icmp_zero##cmp, \
(FuncTypeUnsigned)Subzero_::icmp_zero##cmp},
ICMP_U_TABLE
#undef X
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp_zero##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp_zero##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp_zero##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp_zero##cmp},
ICMP_S_TABLE
#undef X
};
......@@ -210,19 +198,13 @@ void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncTypeUnsigned FuncSz;
} Funcs[] = {
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)icmp##cmp, \
(FuncTypeUnsigned)Subzero_::icmp##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)icmp##cmp, \
(FuncTypeUnsigned)Subzero_::icmp##cmp},
ICMP_U_TABLE
#undef X
#define X(cmp, op) \
{ \
STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp \
} \
,
{STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp, \
(FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp},
ICMP_S_TABLE
#undef X
};
......@@ -283,8 +265,7 @@ void testsVecI1(size_t &TotalTests, size_t &Passes, size_t &Failures) {
FuncType FuncSz;
} Funcs[] = {
#define X(cmp, op) \
{ STR(cmp), (FuncType)icmpi1##cmp, (FuncType)Subzero_::icmpi1##cmp } \
,
{STR(cmp), (FuncType)icmpi1##cmp, (FuncType)Subzero_::icmpi1##cmp},
ICMP_U_TABLE ICMP_S_TABLE};
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElements = Vectors<T>::NumElements;
......
third_party/subzero/crosstest/test_sync_atomic_main.cpp
......@@ -33,18 +33,48 @@ namespace Subzero_ {
#include "test_sync_atomic.h"
}
volatile uint64 Values[] = {
0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
0xfffe, 0xffff, 0x007fffff /*Max subnormal + */, 0x00800000 /*Min+ */,
0x7f7fffff /*Max+ */, 0x7f800000 /*+Inf*/, 0xff800000 /*-Inf*/,
0x7fa00000 /*SNaN*/, 0x7fc00000 /*QNaN*/, 0x7ffffffe, 0x7fffffff,
0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0x100000000ll,
0x100000001ll, 0x000fffffffffffffll /*Max subnormal + */,
0x0010000000000000ll /*Min+ */, 0x7fefffffffffffffll /*Max+ */,
0x7ff0000000000000ll /*+Inf*/, 0xfff0000000000000ll /*-Inf*/,
0x7ff0000000000001ll /*SNaN*/, 0x7ff8000000000000ll /*QNaN*/,
0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
volatile uint64 Values[] = {0,
1,
0x7e,
0x7f,
0x80,
0x81,
0xfe,
0xff,
0x7ffe,
0x7fff,
0x8000,
0x8001,
0xfffe,
0xffff,
0x007fffff /*Max subnormal + */,
0x00800000 /*Min+ */,
0x7f7fffff /*Max+ */,
0x7f800000 /*+Inf*/,
0xff800000 /*-Inf*/,
0x7fa00000 /*SNaN*/,
0x7fc00000 /*QNaN*/,
0x7ffffffe,
0x7fffffff,
0x80000000,
0x80000001,
0xfffffffe,
0xffffffff,
0x100000000ll,
0x100000001ll,
0x000fffffffffffffll /*Max subnormal + */,
0x0010000000000000ll /*Min+ */,
0x7fefffffffffffffll /*Max+ */,
0x7ff0000000000000ll /*+Inf*/,
0xfff0000000000000ll /*-Inf*/,
0x7ff0000000000001ll /*SNaN*/,
0x7ff8000000000000ll /*QNaN*/,
0x7ffffffffffffffell,
0x7fffffffffffffffll,
0x8000000000000000ll,
0x8000000000000001ll,
0xfffffffffffffffell,
0xffffffffffffffffll};
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
......@@ -65,8 +95,8 @@ void testAtomicRMW(volatile Type *AtomicLoc, size_t &TotalTests, size_t &Passes,
FuncType FuncSz;
} Funcs[] = {
#define X(inst) \
{ STR(inst), test_##inst, Subzero_::test_##inst } \
, {STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst}, \
{STR(inst), test_##inst, Subzero_::test_##inst}, \
{STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst}, \
{STR(inst) "_const", test_const_##inst, Subzero_::test_const_##inst},
RMWOP_TABLE
#undef X
......@@ -186,8 +216,8 @@ void testAtomicRMWThreads(volatile Type *AtomicLoc, size_t &TotalTests,
FuncType FuncSz;
} Funcs[] = {
#define X(inst) \
{ STR(inst), test_##inst, Subzero_::test_##inst } \
, {STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst},
{STR(inst), test_##inst, Subzero_::test_##inst}, \
{STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst},
RMWOP_TABLE
#undef X
};
......
third_party/subzero/crosstest/test_vector_ops.h
......@@ -44,18 +44,23 @@ template <typename T> struct VectorOps;
TY(NAME) Subzero_shufflevector_##NAME(TY(NAME), TY(NAME), uint32_t); \
uint32_t shufflevector_count_##NAME(); \
} \
TY(NAME) (*FIELD(NAME, insertelement))(TY(NAME), CASTTY(NAME), int32_t) = \
TY(NAME) \
(*FIELD(NAME, insertelement))(TY(NAME), CASTTY(NAME), int32_t) = \
&insertelement_##NAME; \
TY(NAME) (*FIELD(NAME, Subzero_insertelement))( \
TY(NAME), CASTTY(NAME), int32_t) = &Subzero_insertelement_##NAME; \
CASTTY(NAME) (*FIELD(NAME, extractelement))(TY(NAME), int32_t) = \
&extractelement_##NAME; \
CASTTY(NAME) (*FIELD(NAME, Subzero_extractelement))(TY(NAME), int32_t) = \
TY(NAME) \
(*FIELD(NAME, Subzero_insertelement))(TY(NAME), CASTTY(NAME), int32_t) = \
&Subzero_insertelement_##NAME; \
CASTTY(NAME) \
(*FIELD(NAME, extractelement))(TY(NAME), int32_t) = &extractelement_##NAME; \
CASTTY(NAME) \
(*FIELD(NAME, Subzero_extractelement))(TY(NAME), int32_t) = \
&Subzero_extractelement_##NAME; \
TY(NAME) (*FIELD(NAME, shufflevector))(TY(NAME), TY(NAME), uint32_t) = \
TY(NAME) \
(*FIELD(NAME, shufflevector))(TY(NAME), TY(NAME), uint32_t) = \
&shufflevector_##NAME; \
TY(NAME) (*FIELD(NAME, Subzero_shufflevector))( \
TY(NAME), TY(NAME), uint32_t) = &Subzero_shufflevector_##NAME; \
TY(NAME) \
(*FIELD(NAME, Subzero_shufflevector))(TY(NAME), TY(NAME), uint32_t) = \
&Subzero_shufflevector_##NAME; \
uint32_t (*FIELD(NAME, shufflevector_count))() = &shufflevector_count_##NAME;
#define X(ty, eltty, castty) DECLARE_VECTOR_OPS(ty)
......
third_party/subzero/crosstest/vectors.h
......@@ -16,9 +16,9 @@
#ifndef VECTORS_H
#define VECTORS_H
#include <sstream>
#include <stdint.h>
#include <string>
#include <sstream>
// The driver and the test program may be compiled by different
// versions of clang, with different standard libraries that have
......
third_party/subzero/pnacl-llvm/DataStream.cpp
......@@ -15,8 +15,8 @@
//===----------------------------------------------------------------------===//
#include "llvm/Support/DataStream.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Program.h"
#include <string>
......@@ -45,7 +45,7 @@ STATISTIC(NumStreamFetches, "Number of calls to Data stream fetch");
namespace llvm {
DataStreamer::~DataStreamer() {}
}
} // namespace llvm
namespace {
......@@ -53,6 +53,7 @@ namespace {
// actual file access is probably still best done with mmap.
class DataFileStreamer : public DataStreamer {
int Fd;
public:
DataFileStreamer() : Fd(0) {}
~DataFileStreamer() override { close(Fd); }
......@@ -72,14 +73,14 @@ public:
}
};
}
} // namespace
std::unique_ptr<DataStreamer>
llvm::getDataFileStreamer(const std::string &Filename, std::string *StrError) {
std::unique_ptr<DataFileStreamer> s = make_unique<DataFileStreamer>();
if (std::error_code e = s->OpenFile(Filename)) {
*StrError = std::string("Could not open ") + Filename + ": " +
e.message() + "\n";
*StrError =
std::string("Could not open ") + Filename + ": " + e.message() + "\n";
return nullptr;
}
return std::move(s);
......
third_party/subzero/pnacl-llvm/MemoryObject.cpp
......@@ -10,5 +10,4 @@
#include "llvm/Support/MemoryObject.h"
using namespace llvm;
MemoryObject::~MemoryObject() {
}
MemoryObject::~MemoryObject() {}
third_party/subzero/pnacl-llvm/NaClBitCodes.cpp
......@@ -13,8 +13,8 @@
//===----------------------------------------------------------------------===//
#include "llvm/Bitcode/NaCl/NaClBitCodes.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
......@@ -27,16 +27,12 @@ const bool NaClBitCodeAbbrevOp::HasValueArray[] = {
};
const char *NaClBitCodeAbbrevOp::EncodingNameArray[] = {
"Literal",
"Fixed",
"VBR",
"Array",
"Char6"
};
"Literal", "Fixed", "VBR", "Array", "Char6"};
NaClBitCodeAbbrevOp::NaClBitCodeAbbrevOp(Encoding E, uint64_t Data)
: Enc(E), Val(Data) {
if (isValid(E, Data)) return;
if (isValid(E, Data))
return;
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Invalid NaClBitCodeAbbrevOp(" << E << ", " << Data << ")";
......@@ -57,7 +53,7 @@ bool NaClBitCodeAbbrevOp::isValid(Encoding E, uint64_t Val) {
llvm_unreachable("unhandled abbreviation");
}
void NaClBitCodeAbbrevOp::Print(raw_ostream& Stream) const {
void NaClBitCodeAbbrevOp::Print(raw_ostream &Stream) const {
if (Enc == Literal) {
Stream << getValue();
return;
......@@ -69,11 +65,11 @@ void NaClBitCodeAbbrevOp::Print(raw_ostream& Stream) const {
}
static void PrintExpression(raw_ostream &Stream,
const NaClBitCodeAbbrev *Abbrev,
unsigned &Index) {
const NaClBitCodeAbbrev *Abbrev, unsigned &Index) {
// Bail out early, in case we are incrementally building the
// expression and the argument is not available yet.
if (Index >= Abbrev->getNumOperandInfos()) return;
if (Index >= Abbrev->getNumOperandInfos())
return;
const NaClBitCodeAbbrevOp &Op = Abbrev->getOperandInfo(Index);
Op.Print(Stream);
......@@ -81,7 +77,8 @@ static void PrintExpression(raw_ostream &Stream,
Stream << "(";
for (unsigned i = 0; i < NumArgs; ++i) {
++Index;
if (i > 0) Stream << ",";
if (i > 0)
Stream << ",";
PrintExpression(Stream, Abbrev, Index);
}
Stream << ")";
......@@ -91,11 +88,13 @@ static void PrintExpression(raw_ostream &Stream,
void NaClBitCodeAbbrev::Print(raw_ostream &Stream, bool AddNewLine) const {
Stream << "[";
for (unsigned i = 0; i < getNumOperandInfos(); ++i) {
if (i > 0) Stream << ", ";
if (i > 0)
Stream << ", ";
PrintExpression(Stream, this, i);
}
Stream << "]";
if (AddNewLine) Stream << "\n";
if (AddNewLine)
Stream << "\n";
}
NaClBitCodeAbbrev *NaClBitCodeAbbrev::Simplify() const {
......@@ -106,9 +105,9 @@ NaClBitCodeAbbrev *NaClBitCodeAbbrev::Simplify() const {
// is to remove unnecessary operands appearing immediately before an
// array operator. That is, apply the simplification:
// Op Array(Op) -> Array(Op)
assert(!Op.isArrayOp() || i == OperandList.size()-2);
assert(!Op.isArrayOp() || i == OperandList.size() - 2);
while (Op.isArrayOp() && !Abbrev->OperandList.empty() &&
Abbrev->OperandList.back() == OperandList[i+1]) {
Abbrev->OperandList.back() == OperandList[i + 1]) {
Abbrev->OperandList.pop_back();
}
Abbrev->OperandList.push_back(Op);
......@@ -120,7 +119,8 @@ bool NaClBitCodeAbbrev::isValid() const {
// Verify that an array op appears can only appear if it is the
// second to last element.
unsigned NumOperands = getNumOperandInfos();
if (NumOperands == 0) return false;
if (NumOperands == 0)
return false;
for (unsigned i = 0; i < NumOperands; ++i) {
const NaClBitCodeAbbrevOp &Op = getOperandInfo(i);
if (Op.isArrayOp() && i + 2 != NumOperands)
......
third_party/subzero/pnacl-llvm/NaClBitcodeDecoders.cpp
......@@ -13,8 +13,7 @@
namespace llvm {
namespace naclbitc {
bool DecodeCastOpcode(uint64_t NaClOpcode,
Instruction::CastOps &LLVMOpcode) {
bool DecodeCastOpcode(uint64_t NaClOpcode, Instruction::CastOps &LLVMOpcode) {
switch (NaClOpcode) {
default:
LLVMOpcode = Instruction::BitCast;
......@@ -223,6 +222,5 @@ bool DecodeIcmpPredicate(uint64_t NaClPredicate,
}
}
}
}
} // namespace naclbitc
} // namespace llvm
third_party/subzero/pnacl-llvm/NaClBitcodeHeader.cpp
......@@ -15,8 +15,8 @@
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/StreamingMemoryObject.h"
#include "llvm/Support/raw_ostream.h"
#include <cstring>
#include <iomanip>
......@@ -94,7 +94,7 @@ NaClBitcodeHeaderField::NaClBitcodeHeaderField(Tag MyID, size_t MyLen,
bool NaClBitcodeHeaderField::Write(uint8_t *Buf, size_t BufLen) const {
size_t FieldsLen = kTagLenSize + Len;
size_t PadLen = (WordSize - (FieldsLen & (WordSize-1))) & (WordSize-1);
size_t PadLen = (WordSize - (FieldsLen & (WordSize - 1))) & (WordSize - 1);
// Ensure buffer is large enough and that length can be represented
// in 32 bits
if (BufLen < FieldsLen + PadLen ||
......@@ -245,8 +245,7 @@ bool NaClBitcodeHeader::Read(MemoryObject *Bytes) {
}
// Then read the rest, starting after the 2 * WordSize of the prefix.
uint8_t *Header = new uint8_t[NumBytes];
bool failed =
Bytes->readBytes(Header, NumBytes, 2 * WordSize) != NumBytes ||
bool failed = Bytes->readBytes(Header, NumBytes, 2 * WordSize) != NumBytes ||
ReadFields(Header, Header + NumBytes, NumFields, NumBytes);
delete[] Header;
if (failed)
......
third_party/subzero/pnacl-llvm/NaClBitcodeParser.cpp
......@@ -14,19 +14,20 @@ using namespace llvm;
void NaClBitcodeRecordData::Print(raw_ostream &os) const {
os << "[" << Code;
for (NaClRecordVector::const_iterator
Iter = Values.begin(), IterEnd = Values.end();
for (NaClRecordVector::const_iterator Iter = Values.begin(),
IterEnd = Values.end();
Iter != IterEnd; ++Iter) {
os << ", " << *Iter;
}
os << "]";
}
void NaClBitcodeRecord::Print(raw_ostream& os) const {
void NaClBitcodeRecord::Print(raw_ostream &os) const {
Block.Print(os);
os << ", Code " << Data.Code << ", EntryID " << Entry.ID << ", <";
for (unsigned i = 0, e = Data.Values.size(); i != e; ++i) {
if (i > 0) os << " ";
if (i > 0)
os << " ";
os << Data.Values[i];
}
os << ">";
......@@ -34,11 +35,8 @@ void NaClBitcodeRecord::Print(raw_ostream& os) const {
NaClBitcodeBlock::NaClBitcodeBlock(unsigned BlockID,
const NaClBitcodeRecord &Record)
: NaClBitcodeData(Record),
BlockID(BlockID),
EnclosingBlock(&Record.GetBlock()),
LocalStartBit(Record.GetStartBit())
{}
: NaClBitcodeData(Record), BlockID(BlockID),
EnclosingBlock(&Record.GetBlock()), LocalStartBit(Record.GetStartBit()) {}
void NaClBitcodeBlock::Print(raw_ostream &os) const {
os << "Block " << BlockID;
......@@ -69,8 +67,8 @@ void NaClBitcodeParserListener::EndBlockInfoBlock() {
Parser->ExitBlock();
}
void NaClBitcodeParserListener::
ProcessAbbreviation(NaClBitCodeAbbrev *Abbrev, bool IsLocal) {
void NaClBitcodeParserListener::ProcessAbbreviation(NaClBitCodeAbbrev *Abbrev,
bool IsLocal) {
Parser->Record.SetStartBit(StartBit);
Parser->Record.Entry.Kind = NaClBitstreamEntry::Record;
Parser->Record.Entry.ID = naclbitc::DEFINE_ABBREV;
......@@ -86,8 +84,8 @@ NaClBitcodeParser::~NaClBitcodeParser() {
}
}
bool NaClBitcodeParser::ErrorAt(
naclbitc::ErrorLevel Level, uint64_t BitPosition,
bool NaClBitcodeParser::ErrorAt(naclbitc::ErrorLevel Level,
uint64_t BitPosition,
const std::string &Message) {
naclbitc::ErrorAt(*ErrStream, Level, BitPosition) << Message << "\n";
if (Level == naclbitc::Fatal)
......@@ -108,7 +106,8 @@ bool NaClBitcodeParser::ParseBlockInfoInternal() {
// BLOCKINFO is a special part of the stream. Let the bitstream
// reader process this block.
bool Result = Record.GetCursor().ReadBlockInfoBlock(Listener);
if (Result) return Error("Malformed BlockInfoBlock");
if (Result)
return Error("Malformed BlockInfoBlock");
return Result;
}
......@@ -136,7 +135,8 @@ bool NaClBitcodeParser::ParseBlockInternal() {
return false;
}
case NaClBitstreamEntry::SubBlock: {
if (ParseBlock(Record.GetEntryID())) return true;
if (ParseBlock(Record.GetEntryID()))
return true;
break;
}
case NaClBitstreamEntry::Record:
......@@ -145,7 +145,8 @@ bool NaClBitcodeParser::ParseBlockInternal() {
// Since this abbreviation is local, the listener doesn't
// have the start bit set (it is only set when processing
// the BlockInfo block). Fix this by setting it here.
if (Listener) Listener->StartBit = Record.GetStartBit();
if (Listener)
Listener->StartBit = Record.GetStartBit();
Record.GetCursor().ReadAbbrevRecord(true, Listener);
} else {
// Read in a record.
......
third_party/subzero/pnacl-llvm/StreamingMemoryObject.cpp
......@@ -17,14 +17,12 @@ namespace {
class RawMemoryObject : public MemoryObject {
public:
RawMemoryObject(const unsigned char *Start, const unsigned char *End) :
FirstChar(Start), LastChar(End) {
RawMemoryObject(const unsigned char *Start, const unsigned char *End)
: FirstChar(Start), LastChar(End) {
assert(LastChar >= FirstChar && "Invalid start/end range");
}
uint64_t getExtent() const override {
return LastChar - FirstChar;
}
uint64_t getExtent() const override { return LastChar - FirstChar; }
uint64_t readBytes(uint8_t *Buf, uint64_t Size,
uint64_t Address) const override;
const uint8_t *getPointer(uint64_t address, uint64_t size) const override;
......@@ -33,8 +31,8 @@ public:
}
private:
const uint8_t* const FirstChar;
const uint8_t* const LastChar;
const uint8_t *const FirstChar;
const uint8_t *const LastChar;
// These are implemented as inline functions here to avoid multiple virtual
// calls per public function
......@@ -42,8 +40,8 @@ private:
return static_cast<std::ptrdiff_t>(address) < LastChar - FirstChar;
}
RawMemoryObject(const RawMemoryObject&) = delete;
void operator=(const RawMemoryObject&) = delete;
RawMemoryObject(const RawMemoryObject &) = delete;
void operator=(const RawMemoryObject &) = delete;
};
uint64_t RawMemoryObject::readBytes(uint8_t *Buf, uint64_t Size,
......@@ -72,15 +70,18 @@ namespace llvm {
// If the bitcode has a header, then its size is known, and we don't have to
// block until we actually want to read it.
bool StreamingMemoryObject::isValidAddress(uint64_t address) const {
if (ObjectSize && address < ObjectSize) return true;
if (ObjectSize && address < ObjectSize)
return true;
return fetchToPos(address);
}
uint64_t StreamingMemoryObject::getExtent() const {
if (ObjectSize) return ObjectSize;
if (ObjectSize)
return ObjectSize;
size_t pos = BytesRead + kChunkSize;
// keep fetching until we run out of bytes
while (fetchToPos(pos)) pos += kChunkSize;
while (fetchToPos(pos))
pos += kChunkSize;
return ObjectSize;
}
......@@ -111,7 +112,8 @@ const uint8_t *StreamingMemoryObject::getPointer(uint64_t Address,
}
bool StreamingMemoryObject::dropLeadingBytes(size_t s) {
if (BytesRead < s) return true;
if (BytesRead < s)
return true;
BytesSkipped = s;
BytesRead -= s;
return false;
......@@ -135,4 +137,4 @@ StreamingMemoryObject::StreamingMemoryObject(
BytesSkipped(0), ObjectSize(0), EOFReached(false) {
BytesRead = this->Streamer->GetBytes(&Bytes[0], kChunkSize);
}
}
} // namespace llvm
third_party/subzero/pnacl-llvm/include/llvm/Bitcode/NaCl/NaClBitCodes.h
......@@ -37,9 +37,9 @@ enum StandardWidths {
MinRecordBitSize = 2 // Minimum number of bits needed to represent a record.
};
// The standard abbrev namespace always has a way to exit a block, enter a
// nested block, define abbrevs, and define an unabbreviated record.
enum FixedAbbrevIDs {
// The standard abbrev namespace always has a way to exit a block, enter a
// nested block, define abbrevs, and define an unabbreviated record.
enum FixedAbbrevIDs {
END_BLOCK = 0, // Must be zero to guarantee termination for broken bitcode.
ENTER_SUBBLOCK = 1,
......@@ -69,12 +69,12 @@ enum StandardWidths {
FIRST_APPLICATION_ABBREV = 4,
// Defines default values for code length, if no additional selectors
// are added.
DEFAULT_MAX_ABBREV = FIRST_APPLICATION_ABBREV-1
};
DEFAULT_MAX_ABBREV = FIRST_APPLICATION_ABBREV - 1
};
/// StandardBlockIDs - All bitcode files can optionally include a BLOCKINFO
/// block, which contains metadata about other blocks in the file.
enum StandardBlockIDs {
/// StandardBlockIDs - All bitcode files can optionally include a BLOCKINFO
/// block, which contains metadata about other blocks in the file.
enum StandardBlockIDs {
/// BLOCKINFO_BLOCK is used to define metadata about blocks, for example,
/// standard abbrevs that should be available to all blocks of a specified
/// ID.
......@@ -85,11 +85,11 @@ enum StandardWidths {
// appear in a block).
TOP_LEVEL_BLOCKID = 7,
FIRST_APPLICATION_BLOCKID = 8
};
};
/// BlockInfoCodes - The blockinfo block contains metadata about user-defined
/// blocks.
enum BlockInfoCodes {
/// BlockInfoCodes - The blockinfo block contains metadata about user-defined
/// blocks.
enum BlockInfoCodes {
// DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
// block, instead of the BlockInfo block.
......@@ -100,12 +100,12 @@ enum StandardWidths {
// the writer.
BLOCKINFO_CODE_BLOCKNAME = 2, // Not used in PNaCl.
BLOCKINFO_CODE_SETRECORDNAME = 3 // Not used in PNaCl.
};
};
} // End naclbitc namespace
} // namespace naclbitc
/// NaClBitCodeAbbrevOp - This describes one or more operands in an abbreviation.
/// This is actually a union of two different things:
/// NaClBitCodeAbbrevOp - This describes one or more operands in an
/// abbreviation. This is actually a union of two different things:
/// 1. It could be a literal integer value ("the operand is always 17").
/// 2. It could be an encoding specification ("this operand encoded like so").
///
......@@ -129,9 +129,7 @@ public:
uint64_t getValue() const { return Val; }
bool hasValue() const {
return hasValue(Enc);
}
bool hasValue() const { return hasValue(Enc); }
static bool hasValue(Encoding E) {
return E <= Encoding_MAX && HasValueArray[E];
}
......@@ -164,28 +162,42 @@ public:
/// isChar6 - Return true if this character is legal in the Char6 encoding.
static bool isChar6(char C) {
if (C >= 'a' && C <= 'z') return true;
if (C >= 'A' && C <= 'Z') return true;
if (C >= '0' && C <= '9') return true;
if (C == '.' || C == '_') return true;
if (C >= 'a' && C <= 'z')
return true;
if (C >= 'A' && C <= 'Z')
return true;
if (C >= '0' && C <= '9')
return true;
if (C == '.' || C == '_')
return true;
return false;
}
static unsigned EncodeChar6(char C) {
if (C >= 'a' && C <= 'z') return C-'a';
if (C >= 'A' && C <= 'Z') return C-'A'+26;
if (C >= '0' && C <= '9') return C-'0'+26+26;
if (C == '.') return 62;
if (C == '_') return 63;
if (C >= 'a' && C <= 'z')
return C - 'a';
if (C >= 'A' && C <= 'Z')
return C - 'A' + 26;
if (C >= '0' && C <= '9')
return C - '0' + 26 + 26;
if (C == '.')
return 62;
if (C == '_')
return 63;
llvm_unreachable("Not a value Char6 character!");
}
static char DecodeChar6(unsigned V) {
assert((V & ~63) == 0 && "Not a Char6 encoded character!");
if (V < 26) return V+'a';
if (V < 26+26) return V-26+'A';
if (V < 26+26+10) return V-26-26+'0';
if (V == 62) return '.';
if (V == 63) return '_';
if (V < 26)
return V + 'a';
if (V < 26 + 26)
return V - 26 + 'A';
if (V < 26 + 26 + 10)
return V - 26 - 26 + '0';
if (V == 62)
return '.';
if (V == 63)
return '_';
llvm_unreachable("Not a value Char6 character!");
}
......@@ -194,7 +206,8 @@ public:
int Compare(const NaClBitCodeAbbrevOp &Op) const {
// Compare encoding values.
int EncodingDiff = static_cast<int>(Enc) - static_cast<int>(Op.Enc);
if (EncodingDiff != 0) return EncodingDiff;
if (EncodingDiff != 0)
return EncodingDiff;
// Encodings don't differ, so now base on data associated with the
// encoding.
......@@ -218,7 +231,7 @@ private:
};
template <> struct isPodLike<NaClBitCodeAbbrevOp> {
static const bool value=true;
static const bool value = true;
};
static inline bool operator<(const NaClBitCodeAbbrevOp &Op1,
......@@ -258,11 +271,15 @@ class NaClBitCodeAbbrev {
SmallVector<NaClBitCodeAbbrevOp, 8> OperandList;
unsigned char RefCount; // Number of things using this.
~NaClBitCodeAbbrev() {}
public:
NaClBitCodeAbbrev() : RefCount(1) {}
void addRef() { ++RefCount; }
void dropRef() { if (--RefCount == 0) delete this; }
void dropRef() {
if (--RefCount == 0)
delete this;
}
unsigned getNumOperandInfos() const {
return static_cast<unsigned>(OperandList.size());
......@@ -271,9 +288,7 @@ public:
return OperandList[N];
}
void Add(const NaClBitCodeAbbrevOp &OpInfo) {
OperandList.push_back(OpInfo);
}
void Add(const NaClBitCodeAbbrevOp &OpInfo) { OperandList.push_back(OpInfo); }
// Returns a simplified version of the abbreviation. Used
// to recognize equivalent abbrevations.
......@@ -303,24 +318,25 @@ public:
// of fixed length.
bool IsFixedSize() const {
unsigned Size = getNumOperandInfos();
if (Size < 2) return true;
return !OperandList[Size-2].isArrayOp();
if (Size < 2)
return true;
return !OperandList[Size - 2].isArrayOp();
}
// Returns the smallest record size that will match this
// abbreviation.
size_t GetMinRecordSize() const {
size_t Min = getNumOperandInfos();
if (!IsFixedSize()) Min -= 2;
if (!IsFixedSize())
Min -= 2;
return Min;
}
void Print(raw_ostream &Stream, bool AddNewline=true) const;
void Print(raw_ostream &Stream, bool AddNewline = true) const;
NaClBitCodeAbbrev *Copy() const {
NaClBitCodeAbbrev *AbbrevCopy = new NaClBitCodeAbbrev();
for (unsigned I = 0, IEnd = getNumOperandInfos();
I != IEnd; ++I) {
for (unsigned I = 0, IEnd = getNumOperandInfos(); I != IEnd; ++I) {
AbbrevCopy->Add(NaClBitCodeAbbrevOp(getOperandInfo(I)));
}
return AbbrevCopy;
......@@ -360,8 +376,9 @@ static inline bool operator>(const NaClBitCodeAbbrev &A1,
inline unsigned NaClBitsNeededForValue(unsigned Value) {
// Note: Need to handle case where Value=0xFFFFFFFF as special case,
// since we can't add 1 to it.
if (Value >= 0x80000000) return 32;
return Log2_32_Ceil(Value+1);
if (Value >= 0x80000000)
return 32;
return Log2_32_Ceil(Value + 1);
}
/// \brief Encode a signed value by moving the sign to the LSB for dense
......@@ -393,8 +410,7 @@ public:
unsigned NumBits;
// Creates a selector range for the given values.
NaClBitcodeSelectorAbbrev(bool IF, unsigned NB)
: IsFixed(IF), NumBits(NB) {}
NaClBitcodeSelectorAbbrev(bool IF, unsigned NB) : IsFixed(IF), NumBits(NB) {}
// Creates a selector range when no abbreviations are defined.
NaClBitcodeSelectorAbbrev()
......@@ -404,9 +420,8 @@ public:
// Creates a selector range to handle fixed abbrevations up to
// the specified value.
explicit NaClBitcodeSelectorAbbrev(unsigned MaxAbbrev)
: IsFixed(true),
NumBits(NaClBitsNeededForValue(MaxAbbrev)) {}
: IsFixed(true), NumBits(NaClBitsNeededForValue(MaxAbbrev)) {}
};
} // End llvm namespace
} // namespace llvm
#endif
third_party/subzero/pnacl-llvm/include/llvm/Bitcode/NaCl/NaClBitcodeDecoders.h
//===- NaClBitcodeDecoders.h -------------------------------------*- C++ -*-===//
//===- NaClBitcodeDecoders.h -------------------------------------*- C++
//-*-===//
// Functions used to decode values in PNaCl bitcode files.
//
// The LLVM Compiler Infrastructure
......@@ -16,11 +17,11 @@
#ifndef LLVM_BITCODE_NACL_NACLBITCODEDECODERS_H
#define LLVM_BITCODE_NACL_NACLBITCODEDECODERS_H
#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
#include "llvm/IR/CallingConv.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
namespace llvm {
namespace naclbitc {
......@@ -29,8 +30,7 @@ namespace naclbitc {
/// LLVM cast opcode. Returns true if the conversion
/// succeeds. Otherwise sets LLVMOpcode to Instruction::BitCast and
/// returns false.
bool DecodeCastOpcode(uint64_t NaClOpcode,
Instruction::CastOps &LLVMOpcode);
bool DecodeCastOpcode(uint64_t NaClOpcode, Instruction::CastOps &LLVMOpcode);
/// Converts the NaCl (bitcode file) linkage type to the corresponding
/// LLVM linkage type. Returns true if the conversion
......@@ -68,7 +68,7 @@ bool DecodeFcmpPredicate(uint64_t NaClPredicate,
bool DecodeIcmpPredicate(uint64_t NaClPredicate,
CmpInst::Predicate &LLVMPredicate);
}
}
} // namespace naclbitc
} // namespace llvm
#endif
third_party/subzero/pnacl-llvm/include/llvm/Bitcode/NaCl/NaClBitcodeDefs.h
......@@ -49,5 +49,4 @@ static const size_t MaxNaClGlobalVarInits =
} // end of namespace llvm
#endif // LLVM_BITCODE_NACL_NACLBITCODEDEFS_H
third_party/subzero/pnacl-llvm/include/llvm/Bitcode/NaCl/NaClBitcodeHeader.h
......@@ -88,15 +88,11 @@ public:
/// \brief Returns string describing ID of field.
static const char *IDName(Tag ID);
const char *IDName() const {
return IDName(ID);
}
const char *IDName() const { return IDName(ID); }
/// \brief Returns string describing type of field.
static const char *TypeName(FieldType FType);
const char *TypeName() const {
return TypeName(FType);
}
const char *TypeName() const { return TypeName(FType); }
/// \brief Returns string describing field.
std::string Contents() const;
......@@ -132,7 +128,8 @@ private:
ID = (PossibleID > kTag_MAX ? kInvalid : static_cast<Tag>(PossibleID));
FixedSubfield PossibleFType = Subfield & 0xF;
FType = (PossibleFType > kFieldType_MAX
? kUnknownType : static_cast<FieldType>(PossibleFType));
? kUnknownType
: static_cast<FieldType>(PossibleFType));
}
// Combined size of the fixed subfields
const static size_t kTagLenSize = 2 * sizeof(FixedSubfield);
......@@ -182,9 +179,7 @@ public:
/// \brief Adds a field to the list of fields in a header. Takes ownership
/// of fields added.
void push_back(NaClBitcodeHeaderField *Field) {
Fields.push_back(Field);
}
void push_back(NaClBitcodeHeaderField *Field) { Fields.push_back(Field); }
/// \brief Read the PNaCl bitcode header, The format of the header is:
///
......@@ -255,7 +250,6 @@ private:
UnsupportedMessage = Message.str();
return true;
}
};
} // namespace llvm
......
third_party/subzero/pnacl-llvm/include/llvm/Bitcode/NaCl/NaClReaderWriter.h
......@@ -24,120 +24,117 @@
#include <string>
namespace llvm {
class LLVMContext;
class Module;
class NaClBitcodeHeader;
class NaClBitstreamWriter;
class StreamingMemoryObject;
class raw_ostream;
/// Defines the data layout used for PNaCl bitcode files. We set the
/// data layout of the module in the bitcode readers rather than in
/// pnacl-llc so that 'opt' will also use the correct data layout if
/// it is run on a pexe.
extern const char *PNaClDataLayout;
/// Allows (function) local symbol tables (unsupported) in PNaCl bitcode
/// files.
extern cl::opt<bool> PNaClAllowLocalSymbolTables;
/// \brief Defines the integer bit size used to model pointers in PNaCl.
static const unsigned PNaClIntPtrTypeBitSize = 32;
/// Diagnostic handler that redirects error diagnostics to the given stream.
DiagnosticHandlerFunction redirectNaClDiagnosticToStream(raw_ostream &Out);
/// Read the header of the specified bitcode buffer and prepare for lazy
/// deserialization of function bodies. If successful, this takes ownership
/// of 'Buffer' (extending its lifetime). On error, this returns an error
/// code and deletes Buffer.
///
/// The AcceptSupportedOnly argument is used to decide which PNaCl versions
/// of the PNaCl bitcode to accept. There are three forms:
/// 1) Readable and supported.
/// 2) Readable and unsupported. Allows testing of code before becoming
/// supported, as well as running experiments on the bitcode format.
/// 3) Unreadable.
/// When AcceptSupportedOnly is true, only form 1 is allowed. When
/// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
ErrorOr<Module *> getNaClLazyBitcodeModule(
std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
class LLVMContext;
class Module;
class NaClBitcodeHeader;
class NaClBitstreamWriter;
class StreamingMemoryObject;
class raw_ostream;
/// Defines the data layout used for PNaCl bitcode files. We set the
/// data layout of the module in the bitcode readers rather than in
/// pnacl-llc so that 'opt' will also use the correct data layout if
/// it is run on a pexe.
extern const char *PNaClDataLayout;
/// Allows (function) local symbol tables (unsupported) in PNaCl bitcode
/// files.
extern cl::opt<bool> PNaClAllowLocalSymbolTables;
/// \brief Defines the integer bit size used to model pointers in PNaCl.
static const unsigned PNaClIntPtrTypeBitSize = 32;
/// Diagnostic handler that redirects error diagnostics to the given stream.
DiagnosticHandlerFunction redirectNaClDiagnosticToStream(raw_ostream &Out);
/// Read the header of the specified bitcode buffer and prepare for lazy
/// deserialization of function bodies. If successful, this takes ownership
/// of 'Buffer' (extending its lifetime). On error, this returns an error
/// code and deletes Buffer.
///
/// The AcceptSupportedOnly argument is used to decide which PNaCl versions
/// of the PNaCl bitcode to accept. There are three forms:
/// 1) Readable and supported.
/// 2) Readable and unsupported. Allows testing of code before becoming
/// supported, as well as running experiments on the bitcode format.
/// 3) Unreadable.
/// When AcceptSupportedOnly is true, only form 1 is allowed. When
/// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
ErrorOr<Module *>
getNaClLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler = nullptr,
bool AcceptSupportedOnly = true);
/// Read the header of the specified stream and prepare for lazy
/// deserialization and streaming of function bodies. On error,
/// this returns null, and fills in *ErrMsg with an error description
/// if ErrMsg is non-null.
///
/// See getNaClLazyBitcodeModule for an explanation of argument
/// AcceptSupportedOnly.
/// TODO(kschimpf): Refactor this and getStreamedBitcodeModule to use
/// ErrorOr<Module *> API so that all methods have the same interface.
Module *getNaClStreamedBitcodeModule(
/// Read the header of the specified stream and prepare for lazy
/// deserialization and streaming of function bodies. On error,
/// this returns null, and fills in *ErrMsg with an error description
/// if ErrMsg is non-null.
///
/// See getNaClLazyBitcodeModule for an explanation of argument
/// AcceptSupportedOnly.
/// TODO(kschimpf): Refactor this and getStreamedBitcodeModule to use
/// ErrorOr<Module *> API so that all methods have the same interface.
Module *getNaClStreamedBitcodeModule(
const std::string &name, StreamingMemoryObject *streamer,
LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler = nullptr,
LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler = nullptr,
std::string *ErrMsg = nullptr, bool AcceptSupportedOnly = true);
/// Read the bitcode file from a buffer, returning the module.
///
/// See getNaClLazyBitcodeModule for an explanation of argument
/// AcceptSupportedOnly.
ErrorOr<Module *>
NaClParseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
/// Read the bitcode file from a buffer, returning the module.
///
/// See getNaClLazyBitcodeModule for an explanation of argument
/// AcceptSupportedOnly.
ErrorOr<Module *>
NaClParseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler = nullptr,
bool AcceptSupportedOnly = true);
/// Read the textual bitcode records in Filename, returning the module.
/// Note: If Filename is "-", stdin will be read.
///
/// TODO(kschimpf) Replace Verbose argument with a DiagnosticHandlerFunction.
ErrorOr<Module *> parseNaClBitcodeText(const std::string &Filename,
/// Read the textual bitcode records in Filename, returning the module.
/// Note: If Filename is "-", stdin will be read.
///
/// TODO(kschimpf) Replace Verbose argument with a DiagnosticHandlerFunction.
ErrorOr<Module *> parseNaClBitcodeText(const std::string &Filename,
LLVMContext &Context,
raw_ostream *Verbose = nullptr);
/// Write the specified module to the specified raw output stream, using
/// PNaCl wire format. For streams where it matters, the given stream
/// should be in "binary" mode.
///
/// The AcceptSupportedOnly argument is used to decide which PNaCl versions
/// of the PNaCl bitcode to generate. There are two forms:
/// 1) Writable and supported.
/// 2) Writable and unsupported. Allows testing of code before becoming
/// supported, as well as running experiments on the bitcode format.
/// When AcceptSupportedOnly is true, only form 1 is allowed. When
/// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
void NaClWriteBitcodeToFile(const Module *M, raw_ostream &Out,
/// Write the specified module to the specified raw output stream, using
/// PNaCl wire format. For streams where it matters, the given stream
/// should be in "binary" mode.
///
/// The AcceptSupportedOnly argument is used to decide which PNaCl versions
/// of the PNaCl bitcode to generate. There are two forms:
/// 1) Writable and supported.
/// 2) Writable and unsupported. Allows testing of code before becoming
/// supported, as well as running experiments on the bitcode format.
/// When AcceptSupportedOnly is true, only form 1 is allowed. When
/// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
void NaClWriteBitcodeToFile(const Module *M, raw_ostream &Out,
bool AcceptSupportedOnly = true);
/// isNaClBitcode - Return true if the given bytes are the magic bytes for
/// PNaCl bitcode wire format.
///
inline bool isNaClBitcode(const unsigned char *BufPtr,
/// isNaClBitcode - Return true if the given bytes are the magic bytes for
/// PNaCl bitcode wire format.
///
inline bool isNaClBitcode(const unsigned char *BufPtr,
const unsigned char *BufEnd) {
return BufPtr+4 <= BufEnd &&
BufPtr[0] == 'P' &&
BufPtr[1] == 'E' &&
BufPtr[2] == 'X' &&
BufPtr[3] == 'E';
}
/// NaClWriteHeader - Generate a default header (using the version
/// number defined by kPNaClVersion) and write to the corresponding
/// bitcode stream.
void NaClWriteHeader(NaClBitstreamWriter &Stream, bool AcceptSupportedOnly);
// NaClWriteHeader - Write the contents of the bitcode header to the
// corresponding bitcode stream.
void NaClWriteHeader(const NaClBitcodeHeader &Header,
return BufPtr + 4 <= BufEnd && BufPtr[0] == 'P' && BufPtr[1] == 'E' &&
BufPtr[2] == 'X' && BufPtr[3] == 'E';
}
/// NaClWriteHeader - Generate a default header (using the version
/// number defined by kPNaClVersion) and write to the corresponding
/// bitcode stream.
void NaClWriteHeader(NaClBitstreamWriter &Stream, bool AcceptSupportedOnly);
// NaClWriteHeader - Write the contents of the bitcode header to the
// corresponding bitcode stream.
void NaClWriteHeader(const NaClBitcodeHeader &Header,
NaClBitstreamWriter &Stream);
/// NaClObjDump - Read PNaCl bitcode file from input, and print a
/// textual representation of its contents. NoRecords and NoAssembly
/// define what should not be included in the dump.
bool NaClObjDump(MemoryBufferRef Input, raw_ostream &output,
bool NoRecords, bool NoAssembly);
/// NaClObjDump - Read PNaCl bitcode file from input, and print a
/// textual representation of its contents. NoRecords and NoAssembly
/// define what should not be included in the dump.
bool NaClObjDump(MemoryBufferRef Input, raw_ostream &output, bool NoRecords,
bool NoAssembly);
} // end llvm namespace
} // namespace llvm
#endif
third_party/subzero/pnacl-llvm/include/llvm/Support/DataStream.h
......@@ -13,7 +13,6 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_DATASTREAM_H
#define LLVM_SUPPORT_DATASTREAM_H
......@@ -33,6 +32,6 @@ public:
std::unique_ptr<DataStreamer> getDataFileStreamer(const std::string &Filename,
std::string *Err);
}
} // namespace llvm
#endif // LLVM_SUPPORT_DATASTREAM_H_
third_party/subzero/pnacl-llvm/include/llvm/Support/MemoryObject.h
......@@ -63,6 +63,6 @@ public:
virtual bool isValidAddress(uint64_t address) const = 0;
};
}
} // namespace llvm
#endif
third_party/subzero/pnacl-llvm/include/llvm/Support/StreamingMemoryObject.h
......@@ -49,7 +49,7 @@ private:
mutable std::vector<unsigned char> Bytes;
std::unique_ptr<DataStreamer> Streamer;
mutable size_t BytesRead; // Bytes read from stream
size_t BytesSkipped;// Bytes skipped at start of stream (e.g. wrapper/header)
size_t BytesSkipped; // Bytes skipped at start of stream (e.g. wrapper/header)
mutable size_t ObjectSize; // 0 if unknown, set if wrapper seen or EOF reached
mutable bool EOFReached;
......@@ -64,8 +64,8 @@ private:
if (EOFReached)
return false;
Bytes.resize(BytesRead + BytesSkipped + kChunkSize);
size_t bytes = Streamer->GetBytes(&Bytes[BytesRead + BytesSkipped],
kChunkSize);
size_t bytes =
Streamer->GetBytes(&Bytes[BytesRead + BytesSkipped], kChunkSize);
BytesRead += bytes;
if (bytes == 0) { // reached EOF/ran out of bytes
if (ObjectSize == 0)
......@@ -76,12 +76,12 @@ private:
return !ObjectSize || Pos < ObjectSize;
}
StreamingMemoryObject(const StreamingMemoryObject&) = delete;
void operator=(const StreamingMemoryObject&) = delete;
StreamingMemoryObject(const StreamingMemoryObject &) = delete;
void operator=(const StreamingMemoryObject &) = delete;
};
MemoryObject *getNonStreamedMemoryObject(
const unsigned char *Start, const unsigned char *End);
MemoryObject *getNonStreamedMemoryObject(const unsigned char *Start,
const unsigned char *End);
}
} // namespace llvm
#endif // STREAMINGMEMORYOBJECT_H_
third_party/subzero/runtime/wasm-runtime.cpp
......@@ -26,8 +26,8 @@
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
......
third_party/subzero/unittest/AssemblerX8632/ControlFlow.cpp
......@@ -6,8 +6,8 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "IceAssemblerX8632.h"
#include "AssemblerX8632/TestUtil.h"
#include "IceAssemblerX8632.h"
namespace Ice {
namespace X8632 {
......
third_party/subzero/unittest/AssemblerX8632/GPRArith.cpp
......@@ -135,8 +135,8 @@ TEST_F(AssemblerX8632Test, Lea) {
AssemblerFixup::NoFixup)); \
AssembledTest test = assemble(); \
test.run(); \
ASSERT_EQ(test.Base() + (Disp), test.Dst()) << TestString << " with Disp " \
<< Disp; \
ASSERT_EQ(test.Base() + (Disp), test.Dst()) \
<< TestString << " with Disp " << Disp; \
reset(); \
} while (0)
......@@ -620,8 +620,8 @@ TEST_F(AssemblerX8632Test, Arith_most) {
do { \
TestImplOp(And, Dst, Value0, Src, Value1, int, Size, &); \
TestImplOp(And, Dst, Value0, Src, Value1, uint, Size, &); \
TestImplOp(Or, Dst, Value0, Src, Value1, int, Size, | ); \
TestImplOp(Or, Dst, Value0, Src, Value1, uint, Size, | ); \
TestImplOp(Or, Dst, Value0, Src, Value1, int, Size, |); \
TestImplOp(Or, Dst, Value0, Src, Value1, uint, Size, |); \
TestImplOp(Xor, Dst, Value0, Src, Value1, int, Size, ^); \
TestImplOp(Xor, Dst, Value0, Src, Value1, uint, Size, ^); \
TestImplOp(add, Dst, Value0, Src, Value1, int, Size, +); \
......@@ -699,9 +699,8 @@ TEST_F(AssemblerX8632Test, Arith_BorrowNCarry) {
AssembledTest test = assemble(); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -734,9 +733,8 @@ TEST_F(AssemblerX8632Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -763,9 +761,8 @@ TEST_F(AssemblerX8632Test, Arith_BorrowNCarry) {
AssembledTest test = assemble(); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Imm) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Imm) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -798,9 +795,8 @@ TEST_F(AssemblerX8632Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.contentsOfDword(T0)) << TestString << ": 0"; \
......@@ -829,9 +825,8 @@ TEST_F(AssemblerX8632Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Imm) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Imm) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.contentsOfDword(T0)) << TestString << ": 0"; \
......
third_party/subzero/unittest/AssemblerX8632/TestUtil.h
......@@ -318,12 +318,12 @@ protected:
return *reinterpret_cast<Dqword *>(&Ret); \
}
DefinePackedComparisonOperator(< );
DefinePackedComparisonOperator(<= );
DefinePackedComparisonOperator(> );
DefinePackedComparisonOperator(>= );
DefinePackedComparisonOperator(== );
DefinePackedComparisonOperator(!= );
DefinePackedComparisonOperator(<);
DefinePackedComparisonOperator(<=);
DefinePackedComparisonOperator(>);
DefinePackedComparisonOperator(>=);
DefinePackedComparisonOperator(==);
DefinePackedComparisonOperator(!=);
#undef DefinePackedComparisonOperator
......@@ -387,7 +387,7 @@ protected:
DefinePackedArithOperator(/, true, false);
DefinePackedArithOperator(&, true, true);
DefinePackedArithOperator(|, true, true);
DefinePackedArithOperator (^, true, true);
DefinePackedArithOperator(^, true, true);
#undef DefinePackedArithOperator
......@@ -403,8 +403,8 @@ protected:
return *reinterpret_cast<Dqword *>(&Ret); \
}
DefinePackedArithShiftImm(>> );
DefinePackedArithShiftImm(<< );
DefinePackedArithShiftImm(>>);
DefinePackedArithShiftImm(<<);
#undef DefinePackedArithShiftImm
......@@ -693,8 +693,7 @@ protected:
Dqword contentsOfDqword(uint32_t InitialDword) const {
return *reinterpret_cast<Dqword *>(
static_cast<uint8_t *>(ExecutableData) +
dwordOffset(InitialDword));
static_cast<uint8_t *>(ExecutableData) + dwordOffset(InitialDword));
}
template <typename T = uint32_t, typename = typename std::enable_if<
......
third_party/subzero/unittest/AssemblerX8664/GPRArith.cpp
......@@ -646,8 +646,8 @@ TEST_F(AssemblerX8664Test, Arith_most) {
do { \
TestImplOp(And, Dst, Value0, Src, Value1, int, Size, &); \
TestImplOp(And, Dst, Value0, Src, Value1, uint, Size, &); \
TestImplOp(Or, Dst, Value0, Src, Value1, int, Size, | ); \
TestImplOp(Or, Dst, Value0, Src, Value1, uint, Size, | ); \
TestImplOp(Or, Dst, Value0, Src, Value1, int, Size, |); \
TestImplOp(Or, Dst, Value0, Src, Value1, uint, Size, |); \
TestImplOp(Xor, Dst, Value0, Src, Value1, int, Size, ^); \
TestImplOp(Xor, Dst, Value0, Src, Value1, uint, Size, ^); \
TestImplOp(add, Dst, Value0, Src, Value1, int, Size, +); \
......@@ -728,9 +728,8 @@ TEST_F(AssemblerX8664Test, Arith_BorrowNCarry) {
AssembledTest test = assemble(); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -761,9 +760,8 @@ TEST_F(AssemblerX8664Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -790,9 +788,8 @@ TEST_F(AssemblerX8664Test, Arith_BorrowNCarry) {
AssembledTest test = assemble(); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Imm) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Imm) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.Dst0()) << TestString << ": 0"; \
......@@ -823,9 +820,8 @@ TEST_F(AssemblerX8664Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Value1) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Value1) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.contentsOfDword(T0)) << TestString << ": 0"; \
......@@ -854,9 +850,8 @@ TEST_F(AssemblerX8664Test, Arith_BorrowNCarry) {
test.setDwordTo(T1, V1); \
test.run(); \
\
static constexpr uint64_t Result = \
(uint64_t(Value0) & ResultMask##Size)Op(uint64_t(Imm) & \
ResultMask##Size); \
static constexpr uint64_t Result = (uint64_t(Value0) & ResultMask##Size) \
Op(uint64_t(Imm) & ResultMask##Size); \
static constexpr uint32_t Expected0 = Result & Mask##Size; \
static constexpr uint32_t Expected1 = (Result >> Size) & Mask##Size; \
ASSERT_EQ(Expected0, test.contentsOfDword(T0)) << TestString << ": 0"; \
......
third_party/subzero/unittest/AssemblerX8664/TestUtil.h
......@@ -430,12 +430,12 @@ protected:
return *reinterpret_cast<Dqword *>(&Ret); \
}
DefinePackedComparisonOperator(< );
DefinePackedComparisonOperator(<= );
DefinePackedComparisonOperator(> );
DefinePackedComparisonOperator(>= );
DefinePackedComparisonOperator(== );
DefinePackedComparisonOperator(!= );
DefinePackedComparisonOperator(<);
DefinePackedComparisonOperator(<=);
DefinePackedComparisonOperator(>);
DefinePackedComparisonOperator(>=);
DefinePackedComparisonOperator(==);
DefinePackedComparisonOperator(!=);
#undef DefinePackedComparisonOperator
......@@ -499,7 +499,7 @@ protected:
DefinePackedArithOperator(/, true, false);
DefinePackedArithOperator(&, true, true);
DefinePackedArithOperator(|, true, true);
DefinePackedArithOperator (^, true, true);
DefinePackedArithOperator(^, true, true);
#undef DefinePackedArithOperator
......@@ -515,8 +515,8 @@ protected:
return *reinterpret_cast<Dqword *>(&Ret); \
}
DefinePackedArithShiftImm(>> );
DefinePackedArithShiftImm(<< );
DefinePackedArithShiftImm(>>);
DefinePackedArithShiftImm(<<);
#undef DefinePackedArithShiftImm
......@@ -879,8 +879,7 @@ protected:
Dqword contentsOfDqword(uint32_t InitialDword) const {
return *reinterpret_cast<Dqword *>(
static_cast<uint8_t *>(ExecutableData) +
dwordOffset(InitialDword));
static_cast<uint8_t *>(ExecutableData) + dwordOffset(InitialDword));
}
template <typename T = uint32_t, typename = typename std::enable_if<
......
third_party/subzero/unittest/BitcodeMunge.cpp
......@@ -14,8 +14,8 @@
#include "BitcodeMunge.h"
#include "IceCfg.h"
#include "IceClFlags.h"
#include "PNaClTranslator.h"
#include "IceTypes.h"
#include "PNaClTranslator.h"
namespace IceTest {
......
third_party/subzero/unittest/IceParseTypesTest.cpp
......@@ -24,16 +24,33 @@ namespace {
static const unsigned NO_LOCAL_ABBREVS =
NaClBitsNeededForValue(naclbitc::DEFAULT_MAX_ABBREV);
const uint64_t BitcodeRecords[] = {
naclbitc::ENTER_SUBBLOCK, naclbitc::BLK_CODE_ENTER,
naclbitc::MODULE_BLOCK_ID, NO_LOCAL_ABBREVS, Terminator,
naclbitc::ENTER_SUBBLOCK, naclbitc::BLK_CODE_ENTER,
naclbitc::TYPE_BLOCK_ID_NEW, NO_LOCAL_ABBREVS, Terminator,
naclbitc::UNABBREV_RECORD, naclbitc::TYPE_CODE_NUMENTRY, 2, Terminator,
naclbitc::UNABBREV_RECORD, naclbitc::TYPE_CODE_INTEGER, 32, Terminator,
naclbitc::UNABBREV_RECORD, naclbitc::TYPE_CODE_FLOAT, Terminator,
naclbitc::END_BLOCK, naclbitc::BLK_CODE_EXIT, Terminator,
naclbitc::END_BLOCK, naclbitc::BLK_CODE_EXIT, Terminator};
const uint64_t BitcodeRecords[] = {naclbitc::ENTER_SUBBLOCK,
naclbitc::BLK_CODE_ENTER,
naclbitc::MODULE_BLOCK_ID,
NO_LOCAL_ABBREVS,
Terminator,
naclbitc::ENTER_SUBBLOCK,
naclbitc::BLK_CODE_ENTER,
naclbitc::TYPE_BLOCK_ID_NEW,
NO_LOCAL_ABBREVS,
Terminator,
naclbitc::UNABBREV_RECORD,
naclbitc::TYPE_CODE_NUMENTRY,
2,
Terminator,
naclbitc::UNABBREV_RECORD,
naclbitc::TYPE_CODE_INTEGER,
32,
Terminator,
naclbitc::UNABBREV_RECORD,
naclbitc::TYPE_CODE_FLOAT,
Terminator,
naclbitc::END_BLOCK,
naclbitc::BLK_CODE_EXIT,
Terminator,
naclbitc::END_BLOCK,
naclbitc::BLK_CODE_EXIT,
Terminator};
const char *ExpectedDump =
" 0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
......@@ -75,8 +92,9 @@ TEST(NaClParseTypesTest, BadTypeCountRecord) {
// Index for "count 2;".
const uint64_t CountRecordIndex = 2;
const uint64_t Edit[] = {
CountRecordIndex, NaClMungedBitcode::Replace, naclbitc::UNABBREV_RECORD,
naclbitc::TYPE_CODE_NUMENTRY, 18446744073709547964ULL, Terminator};
CountRecordIndex, NaClMungedBitcode::Replace,
naclbitc::UNABBREV_RECORD, naclbitc::TYPE_CODE_NUMENTRY,
18446744073709547964ULL, Terminator};
SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
Munger.Flags.setGenerateUnitTestMessages(false);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment