From 9cbe74a31771f816da0ac2b9016e2a20d1398fd8 Mon Sep 17 00:00:00 2001 From: Igor Sugak Date: Mon, 1 Feb 2016 10:44:42 -0800 Subject: [PATCH] folly: fix clang -Wmissing-field-initializers Summary: Fix a few `-Wmissing-field-initializers` exposed by clang. Reviewed By: yfeldblum Differential Revision: D2881902 fb-gh-sync-id: 67fdffd39d3ccca64f84055adae1f3b47fdec633 --- folly/experimental/fibers/Fiber.cpp | 2 + .../experimental/symbolizer/SignalHandler.cpp | 14 ++-- folly/io/RecordIO.cpp | 10 +-- folly/io/async/test/EventBaseTest.cpp | 78 +++++++++---------- 4 files changed, 53 insertions(+), 51 deletions(-) diff --git a/folly/experimental/fibers/Fiber.cpp b/folly/experimental/fibers/Fiber.cpp index 17502153..ad21a7ff 100644 --- a/folly/experimental/fibers/Fiber.cpp +++ b/folly/experimental/fibers/Fiber.cpp @@ -107,6 +107,8 @@ void Fiber::init(bool recordStackUsed) { stackFilledWithMagic_ = true; } +#else + (void)recordStackUsed; #endif } diff --git a/folly/experimental/symbolizer/SignalHandler.cpp b/folly/experimental/symbolizer/SignalHandler.cpp index 7719c5d4..b7032885 100644 --- a/folly/experimental/symbolizer/SignalHandler.cpp +++ b/folly/experimental/symbolizer/SignalHandler.cpp @@ -95,13 +95,13 @@ struct { const char* name; struct sigaction oldAction; } kFatalSignals[] = { - { SIGSEGV, "SIGSEGV" }, - { SIGILL, "SIGILL" }, - { SIGFPE, "SIGFPE" }, - { SIGABRT, "SIGABRT" }, - { SIGBUS, "SIGBUS" }, - { SIGTERM, "SIGTERM" }, - { 0, nullptr } + { SIGSEGV, "SIGSEGV", {} }, + { SIGILL, "SIGILL", {} }, + { SIGFPE, "SIGFPE", {} }, + { SIGABRT, "SIGABRT", {} }, + { SIGBUS, "SIGBUS", {} }, + { SIGTERM, "SIGTERM", {} }, + { 0, nullptr, {} } }; void callPreviousSignalHandler(int signum) { diff --git a/folly/io/RecordIO.cpp b/folly/io/RecordIO.cpp index 4f075302..0f350ccd 100644 --- a/folly/io/RecordIO.cpp +++ b/folly/io/RecordIO.cpp @@ -174,7 +174,7 @@ size_t prependHeader(std::unique_ptr& buf, uint32_t fileId) { RecordInfo validateRecord(ByteRange range, uint32_t fileId) { if (range.size() <= headerSize()) { // records may not be empty - return {0}; + return {0, {}}; } const Header* header = reinterpret_cast(range.begin()); range.advance(sizeof(Header)); @@ -184,14 +184,14 @@ RecordInfo validateRecord(ByteRange range, uint32_t fileId) { header->flags != 0 || (fileId != 0 && header->fileId != fileId) || header->dataLength > range.size()) { - return {0}; + return {0, {}}; } if (headerHash(*header) != header->headerHash) { - return {0}; + return {0, {}}; } range.reset(range.begin(), header->dataLength); if (dataHash(range) != header->dataHash) { - return {0}; + return {0, {}}; } return {header->fileId, range}; } @@ -226,7 +226,7 @@ RecordInfo findRecord(ByteRange searchRange, start += sizeof(magic); } - return {0}; + return {0, {}}; } } // namespace diff --git a/folly/io/async/test/EventBaseTest.cpp b/folly/io/async/test/EventBaseTest.cpp index ec448f18..8a456065 100644 --- a/folly/io/async/test/EventBaseTest.cpp +++ b/folly/io/async/test/EventBaseTest.cpp @@ -190,9 +190,9 @@ TEST(EventBaseTest, ReadEvent) { // Register timeouts to perform two write events ScheduledEvent events[] = { - { 10, EventHandler::WRITE, 2345 }, - { 160, EventHandler::WRITE, 99 }, - { 0, 0, 0 }, + { 10, EventHandler::WRITE, 2345, 0 }, + { 160, EventHandler::WRITE, 99, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -231,11 +231,11 @@ TEST(EventBaseTest, ReadPersist) { // Register several timeouts to perform writes ScheduledEvent events[] = { - { 10, EventHandler::WRITE, 1024 }, - { 20, EventHandler::WRITE, 2211 }, - { 30, EventHandler::WRITE, 4096 }, - { 100, EventHandler::WRITE, 100 }, - { 0, 0 }, + { 10, EventHandler::WRITE, 1024, 0 }, + { 20, EventHandler::WRITE, 2211, 0 }, + { 30, EventHandler::WRITE, 4096, 0 }, + { 100, EventHandler::WRITE, 100, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -282,8 +282,8 @@ TEST(EventBaseTest, ReadImmediate) { // Register a timeout to perform another write ScheduledEvent events[] = { - { 10, EventHandler::WRITE, 2345 }, - { 0, 0, 0 }, + { 10, EventHandler::WRITE, 2345, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -329,9 +329,9 @@ TEST(EventBaseTest, WriteEvent) { // Register timeouts to perform two reads ScheduledEvent events[] = { - { 10, EventHandler::READ, 0 }, - { 60, EventHandler::READ, 0 }, - { 0, 0, 0 }, + { 10, EventHandler::READ, 0, 0 }, + { 60, EventHandler::READ, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -370,11 +370,11 @@ TEST(EventBaseTest, WritePersist) { // Register several timeouts to read from the socket at several intervals ScheduledEvent events[] = { - { 10, EventHandler::READ, 0 }, - { 40, EventHandler::READ, 0 }, - { 70, EventHandler::READ, 0 }, - { 100, EventHandler::READ, 0 }, - { 0, 0 }, + { 10, EventHandler::READ, 0, 0 }, + { 40, EventHandler::READ, 0, 0 }, + { 70, EventHandler::READ, 0, 0 }, + { 100, EventHandler::READ, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -414,8 +414,8 @@ TEST(EventBaseTest, WriteImmediate) { // Register a timeout to perform a read ScheduledEvent events[] = { - { 10, EventHandler::READ, 0 }, - { 0, 0, 0 }, + { 10, EventHandler::READ, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -464,9 +464,9 @@ TEST(EventBaseTest, ReadWrite) { // Register timeouts to perform a write then a read. ScheduledEvent events[] = { - { 10, EventHandler::WRITE, 2345 }, - { 40, EventHandler::READ, 0 }, - { 0, 0, 0 }, + { 10, EventHandler::WRITE, 2345, 0 }, + { 40, EventHandler::READ, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -505,9 +505,9 @@ TEST(EventBaseTest, WriteRead) { // Register timeouts to perform a read then a write. size_t sock1WriteLength = 2345; ScheduledEvent events[] = { - { 10, EventHandler::READ, 0 }, - { 40, EventHandler::WRITE, sock1WriteLength }, - { 0, 0, 0 }, + { 10, EventHandler::READ, 0, 0 }, + { 40, EventHandler::WRITE, sock1WriteLength, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -551,8 +551,8 @@ TEST(EventBaseTest, ReadWriteSimultaneous) { // Register a timeout to perform a read and write together ScheduledEvent events[] = { - { 10, EventHandler::READ | EventHandler::WRITE, 0 }, - { 0, 0, 0 }, + { 10, EventHandler::READ | EventHandler::WRITE, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -590,13 +590,13 @@ TEST(EventBaseTest, ReadWritePersist) { // Register timeouts to perform several reads and writes ScheduledEvent events[] = { - { 10, EventHandler::WRITE, 2345 }, - { 20, EventHandler::READ, 0 }, - { 35, EventHandler::WRITE, 200 }, - { 45, EventHandler::WRITE, 15 }, - { 55, EventHandler::READ, 0 }, - { 120, EventHandler::WRITE, 2345 }, - { 0, 0, 0 }, + { 10, EventHandler::WRITE, 2345, 0 }, + { 20, EventHandler::READ, 0, 0 }, + { 35, EventHandler::WRITE, 200, 0 }, + { 45, EventHandler::WRITE, 15, 0 }, + { 55, EventHandler::READ, 0, 0 }, + { 120, EventHandler::WRITE, 2345, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -673,8 +673,8 @@ TEST(EventBaseTest, ReadPartial) { // Register a timeout to perform a single write, // with more data than PartialReadHandler will read at once ScheduledEvent events[] = { - { 10, EventHandler::WRITE, (3*readLength) + (readLength / 2) }, - { 0, 0, 0 }, + { 10, EventHandler::WRITE, (3*readLength) + (readLength / 2), 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); @@ -740,8 +740,8 @@ TEST(EventBaseTest, WritePartial) { // Register a timeout to read, so that more data can be written ScheduledEvent events[] = { - { 10, EventHandler::READ, 0 }, - { 0, 0, 0 }, + { 10, EventHandler::READ, 0, 0 }, + { 0, 0, 0, 0 }, }; scheduleEvents(&eb, sp[1], events); -- 2.34.1