Subzero: Rerun clang-format after LLVM 3.6 merge.
BUG= none
R=jvoung@chromium.org
Review URL: https://codereview.chromium.org/974113002
diff --git a/crosstest/test_arith_main.cpp b/crosstest/test_arith_main.cpp
index 49aa662..e95db44 100644
--- a/crosstest/test_arith_main.cpp
+++ b/crosstest/test_arith_main.cpp
@@ -64,14 +64,14 @@
#define X(inst, op, isdiv, isshift) \
{ STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv } \
,
- UINTOP_TABLE
+ UINTOP_TABLE
#undef X
#define X(inst, op, isdiv, isshift) \
{ STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv } \
,
- SINTOP_TABLE
+ SINTOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
if (sizeof(TypeUnsigned) <= sizeof(uint32_t)) {
@@ -177,14 +177,14 @@
#define X(inst, op, isdiv, isshift) \
{ STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv, isshift } \
,
- UINTOP_TABLE
+ UINTOP_TABLE
#undef X
#define X(inst, op, isdiv, isshift) \
{ STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv, isshift } \
,
- SINTOP_TABLE
+ SINTOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElementsInType = Vectors<TypeUnsigned>::NumElements;
for (size_t f = 0; f < NumFuncs; ++f) {
@@ -247,9 +247,9 @@
#define X(inst, op, func) \
{ STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst } \
,
- FPOP_TABLE
+ FPOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
for (size_t f = 0; f < NumFuncs; ++f) {
@@ -306,9 +306,9 @@
#define X(inst, op, func) \
{ STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst } \
,
- FPOP_TABLE
+ FPOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElementsInType = 4;
for (size_t f = 0; f < NumFuncs; ++f) {
diff --git a/crosstest/test_bitmanip_main.cpp b/crosstest/test_bitmanip_main.cpp
index 4901462..dfb5d1a 100644
--- a/crosstest/test_bitmanip_main.cpp
+++ b/crosstest/test_bitmanip_main.cpp
@@ -28,31 +28,18 @@
}
volatile uint64_t 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 + */,
+ 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};
+ 0x7ff0000000000000ll /*+Inf*/, 0xfff0000000000000ll /*-Inf*/,
+ 0x7ff0000000000001ll /*SNaN*/, 0x7ff8000000000000ll /*QNaN*/,
+ 0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
+ 0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
@@ -68,9 +55,9 @@
{ 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
+ BMI_OPS
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
for (size_t f = 0; f < NumFuncs; ++f) {
@@ -100,8 +87,8 @@
FuncType FuncLlc;
FuncType FuncSz;
} Funcs[] = {
- {"bswap", test_bswap, Subzero_::test_bswap},
- {"bswap_alloca", test_bswap_alloca, Subzero_::test_bswap_alloca}};
+ {"bswap", test_bswap, Subzero_::test_bswap},
+ {"bswap_alloca", test_bswap_alloca, Subzero_::test_bswap_alloca}};
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
for (size_t f = 0; f < NumFuncs; ++f) {
for (size_t i = 0; i < NumValues; ++i) {
diff --git a/crosstest/test_calling_conv_main.cpp b/crosstest/test_calling_conv_main.cpp
index f319a49..ce5ecda 100644
--- a/crosstest/test_calling_conv_main.cpp
+++ b/crosstest/test_calling_conv_main.cpp
@@ -75,9 +75,9 @@
reinterpret_cast<CalleePtrTy>(&callee), \
} \
,
- TEST_FUNC_TABLE
+ TEST_FUNC_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
@@ -125,9 +125,9 @@
reinterpret_cast<CalleePtrTy>(&Subzero_::callee) \
} \
,
- TEST_FUNC_TABLE
+ TEST_FUNC_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
diff --git a/crosstest/test_cast_main.cpp b/crosstest/test_cast_main.cpp
index dbd93aa..c395597 100644
--- a/crosstest/test_cast_main.cpp
+++ b/crosstest/test_cast_main.cpp
@@ -148,29 +148,19 @@
static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
volatile uint64_t 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};
+ 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_t 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};
+ 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;
diff --git a/crosstest/test_fcmp_main.cpp b/crosstest/test_fcmp_main.cpp
index 359ecc0..9e9c32c 100644
--- a/crosstest/test_fcmp_main.cpp
+++ b/crosstest/test_fcmp_main.cpp
@@ -72,9 +72,9 @@
Subzero_fcmp##cmp##Double, fcmp##cmp##Double \
} \
,
- FCMP_TABLE
+ FCMP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
bool ResultSz, ResultLlc;
@@ -125,9 +125,9 @@
#define X(cmp) \
{ "fcmp" STR(cmp), Subzero_fcmp##cmp##Vector, fcmp##cmp##Vector } \
,
- FCMP_TABLE
+ FCMP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElementsInType = 4;
const static size_t MaxTestsPerFunc = 100000;
diff --git a/crosstest/test_global.cpp b/crosstest/test_global.cpp
index b2f52b0..b5519a0 100644
--- a/crosstest/test_global.cpp
+++ b/crosstest/test_global.cpp
@@ -43,12 +43,12 @@
} NestedStuff;
uint8_t *Pointer5;
} StructEx = {
- {10, 20, 30, 40, 50},
- ExternName1,
- {0.5, 1.5, 2.5},
- ExternName4,
- {ExternName3, {1000, 1010, 1020}, ExternName2},
- ExternName5,
+ {10, 20, 30, 40, 50},
+ ExternName1,
+ {0.5, 1.5, 2.5},
+ ExternName4,
+ {ExternName3, {1000, 1010, 1020}, ExternName2},
+ ExternName5,
};
#define ARRAY(a) \
@@ -61,13 +61,13 @@
uint8_t *ArrayAddress;
size_t ArraySizeInBytes;
} Arrays[] = {
- ARRAY(ArrayInitPartial),
- ARRAY(ArrayInitFull),
- ARRAY(ArrayConst),
- ARRAY(ArrayDouble),
- {(uint8_t *)(ArrayInitPartial + 2),
- sizeof(ArrayInitPartial) - 2 * sizeof(int)},
- {(uint8_t *)(&StructEx), sizeof(StructEx)},
+ ARRAY(ArrayInitPartial),
+ ARRAY(ArrayInitFull),
+ ARRAY(ArrayConst),
+ ARRAY(ArrayDouble),
+ {(uint8_t *)(ArrayInitPartial + 2),
+ sizeof(ArrayInitPartial) - 2 * sizeof(int)},
+ {(uint8_t *)(&StructEx), sizeof(StructEx)},
};
size_t NumArraysElements = sizeof(Arrays) / sizeof(*Arrays);
diff --git a/crosstest/test_icmp_main.cpp b/crosstest/test_icmp_main.cpp
index dbfe515..f27d53b 100644
--- a/crosstest/test_icmp_main.cpp
+++ b/crosstest/test_icmp_main.cpp
@@ -50,17 +50,17 @@
(FuncTypeUnsigned)Subzero_::icmp##cmp \
} \
,
- ICMP_U_TABLE
+ 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
+ ICMP_S_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
if (sizeof(TypeUnsigned) <= sizeof(uint32_t)) {
@@ -137,17 +137,17 @@
(FuncTypeUnsigned)Subzero_::icmp##cmp \
} \
,
- ICMP_U_TABLE
+ 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
+ ICMP_S_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElementsInType = Vectors<TypeUnsigned>::NumElements;
for (size_t f = 0; f < NumFuncs; ++f) {
@@ -206,7 +206,7 @@
#define X(cmp, op) \
{ STR(cmp), (FuncType)icmpi1##cmp, (FuncType)Subzero_::icmpi1##cmp } \
,
- ICMP_U_TABLE ICMP_S_TABLE};
+ ICMP_U_TABLE ICMP_S_TABLE};
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElements = Vectors<T>::NumElements;
const static size_t MAX_NUMBER_OF_ELEMENTS_FOR_EXHAUSTIVE_TESTING = 8;
diff --git a/crosstest/test_sync_atomic_main.cpp b/crosstest/test_sync_atomic_main.cpp
index c9bf579..63dfc80 100644
--- a/crosstest/test_sync_atomic_main.cpp
+++ b/crosstest/test_sync_atomic_main.cpp
@@ -33,27 +33,17 @@
}
volatile uint64_t 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};
+ 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);
@@ -77,9 +67,9 @@
{ 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
+ RMWOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
for (size_t f = 0; f < NumFuncs; ++f) {
@@ -188,9 +178,9 @@
#define X(inst) \
{ STR(inst), test_##inst, Subzero_::test_##inst } \
, {STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst},
- RMWOP_TABLE
+ RMWOP_TABLE
#undef X
- };
+ };
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
// Just test a few values, otherwise it takes a *really* long time.
diff --git a/src/IceELFObjectWriter.cpp b/src/IceELFObjectWriter.cpp
index 34e6017..230848c 100644
--- a/src/IceELFObjectWriter.cpp
+++ b/src/IceELFObjectWriter.cpp
@@ -36,7 +36,7 @@
#define X(tag, str, is_elf64, e_machine, e_flags) \
{ is_elf64, e_machine, e_flags } \
,
- TARGETARCH_TABLE
+ TARGETARCH_TABLE
#undef X
};
diff --git a/src/IceInst.cpp b/src/IceInst.cpp
index ce5bde0..b06f6df 100644
--- a/src/IceInst.cpp
+++ b/src/IceInst.cpp
@@ -30,7 +30,7 @@
#define X(tag, str, commutative) \
{ str, commutative } \
,
- ICEINSTARITHMETIC_TABLE
+ ICEINSTARITHMETIC_TABLE
#undef X
};
@@ -41,7 +41,7 @@
#define X(tag, str) \
{ str } \
,
- ICEINSTCAST_TABLE
+ ICEINSTCAST_TABLE
#undef X
};
@@ -52,7 +52,7 @@
#define X(tag, str) \
{ str } \
,
- ICEINSTFCMP_TABLE
+ ICEINSTFCMP_TABLE
#undef X
};
@@ -63,7 +63,7 @@
#define X(tag, str) \
{ str } \
,
- ICEINSTICMP_TABLE
+ ICEINSTICMP_TABLE
#undef X
};
diff --git a/src/IceInstX8632.cpp b/src/IceInstX8632.cpp
index 53a431e..776a870 100644
--- a/src/IceInstX8632.cpp
+++ b/src/IceInstX8632.cpp
@@ -34,7 +34,7 @@
#define X(tag, encode, opp, dump, emit) \
{ CondX86::opp, dump, emit } \
,
- ICEINSTX8632BR_TABLE
+ ICEINSTX8632BR_TABLE
#undef X
};
@@ -44,7 +44,7 @@
#define X(tag, emit) \
{ emit } \
,
- ICEINSTX8632CMPPS_TABLE
+ ICEINSTX8632CMPPS_TABLE
#undef X
};
@@ -58,7 +58,7 @@
#define X(tag, elementty, cvt, sdss, pack, width, fld) \
{ cvt, sdss, pack, width, fld } \
,
- ICETYPEX8632_TABLE
+ ICETYPEX8632_TABLE
#undef X
};
@@ -1256,9 +1256,9 @@
Inst->getDest()->emit(Func);
}
-void
-emitIASVariableBlendInst(const Inst *Inst, const Cfg *Func,
- const x86::AssemblerX86::XmmEmitterRegOp &Emitter) {
+void emitIASVariableBlendInst(
+ const Inst *Inst, const Cfg *Func,
+ const x86::AssemblerX86::XmmEmitterRegOp &Emitter) {
assert(Inst->getSrcSize() == 3);
assert(llvm::cast<Variable>(Inst->getSrc(2))->getRegNum() ==
RegX8632::Reg_xmm0);
diff --git a/src/IceIntrinsics.cpp b/src/IceIntrinsics.cpp
index ffeed21..26a81de 100644
--- a/src/IceIntrinsics.cpp
+++ b/src/IceIntrinsics.cpp
@@ -51,24 +51,22 @@
} \
, "nacl.atomic.cmpxchg." NameSuffix \
}
- AtomicCmpxchgInit(IceType_i8, "i8"),
- AtomicCmpxchgInit(IceType_i16, "i16"),
- AtomicCmpxchgInit(IceType_i32, "i32"),
- AtomicCmpxchgInit(IceType_i64, "i64"),
+ AtomicCmpxchgInit(IceType_i8, "i8"),
+ AtomicCmpxchgInit(IceType_i16, "i16"),
+ AtomicCmpxchgInit(IceType_i32, "i32"),
+ AtomicCmpxchgInit(IceType_i64, "i64"),
#undef AtomicCmpxchgInit
- {{INTRIN(AtomicFence, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32},
- 2},
- "nacl.atomic.fence"},
- {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F),
- {IceType_void},
- 1},
- "nacl.atomic.fence.all"},
- {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F),
- {IceType_i1, IceType_i32, IceType_i32},
- 3},
- "nacl.atomic.is.lock.free"},
+ {{INTRIN(AtomicFence, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32},
+ 2},
+ "nacl.atomic.fence"},
+ {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
+ "nacl.atomic.fence.all"},
+ {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F),
+ {IceType_i1, IceType_i32, IceType_i32},
+ 3},
+ "nacl.atomic.is.lock.free"},
#define AtomicLoadInit(Overload, NameSuffix) \
{ \
@@ -78,10 +76,10 @@
} \
, "nacl.atomic.load." NameSuffix \
}
- AtomicLoadInit(IceType_i8, "i8"),
- AtomicLoadInit(IceType_i16, "i16"),
- AtomicLoadInit(IceType_i32, "i32"),
- AtomicLoadInit(IceType_i64, "i64"),
+ AtomicLoadInit(IceType_i8, "i8"),
+ AtomicLoadInit(IceType_i16, "i16"),
+ AtomicLoadInit(IceType_i32, "i32"),
+ AtomicLoadInit(IceType_i64, "i64"),
#undef AtomicLoadInit
#define AtomicRMWInit(Overload, NameSuffix) \
@@ -92,10 +90,10 @@
} \
, "nacl.atomic.rmw." NameSuffix \
}
- AtomicRMWInit(IceType_i8, "i8"),
- AtomicRMWInit(IceType_i16, "i16"),
- AtomicRMWInit(IceType_i32, "i32"),
- AtomicRMWInit(IceType_i64, "i64"),
+ AtomicRMWInit(IceType_i8, "i8"),
+ AtomicRMWInit(IceType_i16, "i16"),
+ AtomicRMWInit(IceType_i32, "i32"),
+ AtomicRMWInit(IceType_i64, "i64"),
#undef AtomicRMWInit
#define AtomicStoreInit(Overload, NameSuffix) \
@@ -106,10 +104,10 @@
} \
, "nacl.atomic.store." NameSuffix \
}
- AtomicStoreInit(IceType_i8, "i8"),
- AtomicStoreInit(IceType_i16, "i16"),
- AtomicStoreInit(IceType_i32, "i32"),
- AtomicStoreInit(IceType_i64, "i64"),
+ AtomicStoreInit(IceType_i8, "i8"),
+ AtomicStoreInit(IceType_i16, "i16"),
+ AtomicStoreInit(IceType_i32, "i32"),
+ AtomicStoreInit(IceType_i64, "i64"),
#undef AtomicStoreInit
#define BswapInit(Overload, NameSuffix) \
@@ -120,9 +118,9 @@
} \
, "bswap." NameSuffix \
}
- BswapInit(IceType_i16, "i16"),
- BswapInit(IceType_i32, "i32"),
- BswapInit(IceType_i64, "i64"),
+ BswapInit(IceType_i16, "i16"),
+ BswapInit(IceType_i32, "i32"),
+ BswapInit(IceType_i64, "i64"),
#undef BswapInit
#define CtlzInit(Overload, NameSuffix) \
@@ -133,8 +131,8 @@
} \
, "ctlz." NameSuffix \
}
- CtlzInit(IceType_i32, "i32"),
- CtlzInit(IceType_i64, "i64"),
+ CtlzInit(IceType_i32, "i32"),
+ CtlzInit(IceType_i64, "i64"),
#undef CtlzInit
#define CtpopInit(Overload, NameSuffix) \
@@ -145,8 +143,8 @@
} \
, "ctpop." NameSuffix \
}
- CtpopInit(IceType_i32, "i32"),
- CtpopInit(IceType_i64, "i64"),
+ CtpopInit(IceType_i32, "i32"),
+ CtpopInit(IceType_i64, "i64"),
#undef CtpopInit
#define CttzInit(Overload, NameSuffix) \
@@ -157,53 +155,52 @@
} \
, "cttz." NameSuffix \
}
- CttzInit(IceType_i32, "i32"),
- CttzInit(IceType_i64, "i64"),
+ CttzInit(IceType_i32, "i32"),
+ CttzInit(IceType_i64, "i64"),
#undef CttzInit
- {{INTRIN(Longjmp, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32, IceType_i32},
- 3},
- "nacl.longjmp"},
- {{INTRIN(Memcpy, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
- IceType_i1},
- 6},
- "memcpy.p0i8.p0i8.i32"},
- {{INTRIN(Memmove, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
- IceType_i1},
- 6},
- "memmove.p0i8.p0i8.i32"},
- {{INTRIN(Memset, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32, IceType_i8, IceType_i32, IceType_i32,
- IceType_i1},
- 6},
- "memset.p0i8.i32"},
- {{INTRIN(NaClReadTP, SideEffects_F, ReturnsTwice_F), {IceType_i32}, 1},
- "nacl.read.tp"},
- {{INTRIN(Setjmp, SideEffects_T, ReturnsTwice_T),
- {IceType_i32, IceType_i32},
- 2},
- "nacl.setjmp"},
+ {{INTRIN(Longjmp, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32, IceType_i32},
+ 3},
+ "nacl.longjmp"},
+ {{INTRIN(Memcpy, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
+ IceType_i1},
+ 6},
+ "memcpy.p0i8.p0i8.i32"},
+ {{INTRIN(Memmove, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
+ IceType_i1},
+ 6},
+ "memmove.p0i8.p0i8.i32"},
+ {{INTRIN(Memset, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32, IceType_i8, IceType_i32, IceType_i32,
+ IceType_i1},
+ 6},
+ "memset.p0i8.i32"},
+ {{INTRIN(NaClReadTP, SideEffects_F, ReturnsTwice_F), {IceType_i32}, 1},
+ "nacl.read.tp"},
+ {{INTRIN(Setjmp, SideEffects_T, ReturnsTwice_T),
+ {IceType_i32, IceType_i32},
+ 2},
+ "nacl.setjmp"},
#define SqrtInit(Overload, NameSuffix) \
{ \
{ INTRIN(Sqrt, SideEffects_F, ReturnsTwice_F), {Overload, Overload}, 2 } \
, "sqrt." NameSuffix \
}
- SqrtInit(IceType_f32, "f32"),
- SqrtInit(IceType_f64, "f64"),
+ SqrtInit(IceType_f32, "f32"),
+ SqrtInit(IceType_f64, "f64"),
#undef SqrtInit
- {{INTRIN(Stacksave, SideEffects_T, ReturnsTwice_F), {IceType_i32}, 1},
- "stacksave"},
- {{INTRIN(Stackrestore, SideEffects_T, ReturnsTwice_F),
- {IceType_void, IceType_i32},
- 2},
- "stackrestore"},
- {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
- "trap"}};
+ {{INTRIN(Stacksave, SideEffects_T, ReturnsTwice_F), {IceType_i32}, 1},
+ "stacksave"},
+ {{INTRIN(Stackrestore, SideEffects_T, ReturnsTwice_F),
+ {IceType_void, IceType_i32},
+ 2},
+ "stackrestore"},
+ {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1}, "trap"}};
const size_t IceIntrinsicsTableSize = llvm::array_lengthof(IceIntrinsicsTable);
#undef INTRIN
diff --git a/src/IceTargetLoweringX8632.cpp b/src/IceTargetLoweringX8632.cpp
index 12c2f1c..ebfc4d2 100644
--- a/src/IceTargetLoweringX8632.cpp
+++ b/src/IceTargetLoweringX8632.cpp
@@ -61,7 +61,7 @@
#define X(val, dflt, swapS, C1, C2, swapV, pred) \
{ dflt, swapS, CondX86::C1, CondX86::C2, swapV, CondX86::pred } \
,
- FCMPX8632_TABLE
+ FCMPX8632_TABLE
#undef X
};
const size_t TableFcmpSize = llvm::array_lengthof(TableFcmp);
@@ -76,7 +76,7 @@
#define X(val, C_32, C1_64, C2_64, C3_64) \
{ CondX86::C_32 } \
,
- ICMPX8632_TABLE
+ ICMPX8632_TABLE
#undef X
};
const size_t TableIcmp32Size = llvm::array_lengthof(TableIcmp32);
@@ -91,7 +91,7 @@
#define X(val, C_32, C1_64, C2_64, C3_64) \
{ CondX86::C1_64, CondX86::C2_64, CondX86::C3_64 } \
,
- ICMPX8632_TABLE
+ ICMPX8632_TABLE
#undef X
};
const size_t TableIcmp64Size = llvm::array_lengthof(TableIcmp64);
@@ -108,7 +108,7 @@
#define X(tag, elementty, cvt, sdss, pack, width, fld) \
{ elementty } \
,
- ICETYPEX8632_TABLE
+ ICETYPEX8632_TABLE
#undef X
};
const size_t TableTypeX8632AttributesSize =
@@ -4120,8 +4120,8 @@
// We can eliminate the sext operation by copying the result of pcmpeqd,
// pcmpgtd, or cmpps (which produce sign extended results) to the result
// of the sext operation.
-void
-TargetX8632::eliminateNextVectorSextInstruction(Variable *SignExtendedResult) {
+void TargetX8632::eliminateNextVectorSextInstruction(
+ Variable *SignExtendedResult) {
if (InstCast *NextCast =
llvm::dyn_cast_or_null<InstCast>(Context.getNextInst())) {
if (NextCast->getCastKind() == InstCast::Sext &&
diff --git a/src/main.cpp b/src/main.cpp
index 4763f3e..8ced212 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -386,9 +386,8 @@
SMDiagnostic Err;
Ice::TimerMarker T1(Ice::TimerStack::TT_parse, &Ctx);
raw_ostream *Verbose = LLVMVerboseErrors ? &errs() : nullptr;
- std::unique_ptr<Module> Mod =
- NaClParseIRFile(IRFilename, InputFileFormat, Err, Verbose,
- getGlobalContext());
+ std::unique_ptr<Module> Mod = NaClParseIRFile(
+ IRFilename, InputFileFormat, Err, Verbose, getGlobalContext());
if (!Mod) {
Err.print(argv[0], errs());
return GetReturnValue(Ice::EC_Bitcode);
