Fix pedentic warnings

Author: Dave Allison

MODULE.bazel.lock

@@ -48,13 +48,13 @@ struct Color {
   FixedColor fixed = FixedColor::kNotSet;
 
   // Your terminal might not support this.
-  int eight; // 8-bit color for k8bit.
+  int eight = 0; // 8-bit color for k8bit.
 
   // If fixed is kNotSet, these are RGB values for the color.
   // Your terminal may not support this.
-  int r;
-  int g;
-  int b;
+  int r = 0;
+  int g = 0;
+  int b = 0;
 };
 
 // Make a 3-bit fixed color.

toolbelt/color.h

@@ -98,9 +98,9 @@ class FileDescriptor {
   // Construct and return a struct pollfd suitable for use in ::poll.
   struct pollfd GetPollFd() {
     if (data_ == nullptr) {
-      return {.fd = -1, .events = POLLIN};
+      return {.fd = -1, .events = POLLIN, .revents = 0};
     }
-    return {.fd = data_->fd, .events = POLLIN};
+    return {.fd = data_->fd, .events = POLLIN, .revents = 0};
   }
 
   bool operator==(const FileDescriptor &fd) const {

toolbelt/fd.h

@@ -732,7 +732,7 @@ BitMapRun *PayloadBuffer::AllocateBitMapRun(PayloadBuffer **self, uint32_t size,
   return run;
 }
 
-void *BitMapRun::Allocate(PayloadBuffer **pb, int index, uint32_t n, int size,
+void *BitMapRun::Allocate(PayloadBuffer **pb, int index, uint32_t, int size,
                           int num, bool clear) {
   // Lazy init of vector.
   if ((*pb)->bitmaps[index] == 0) {

toolbelt/payload_buffer.cc

@@ -1,14 +1,14 @@
 #pragma once
 
 #include "absl/types/span.h"
+#include "toolbelt/hexdump.h"
 #include <functional>
 #include <iostream>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string>
 #include <string_view>
-#include "toolbelt/hexdump.h"
 
 namespace toolbelt {
 
@@ -228,7 +228,7 @@ struct PayloadBuffer {
     return (p[word] & (1 << bit)) != 0;
   }
 
-  static uint32_t DecodeSize(BufferOffset* addr) {
+  static uint32_t DecodeSize(BufferOffset *addr) {
     // Length is 64 bits long but we only need the bottom 32 bits of it.
     uint32_t *p = reinterpret_cast<uint32_t *>(addr) - 2;
     if ((*p & (1U << 31)) == 0) {
@@ -314,12 +314,11 @@ struct PayloadBuffer {
   FreeBlockHeader *FreeList() { return ToAddress<FreeBlockHeader>(free_list); }
 
   // Allocate some memory in the buffer.  The buffer might move.
-  static void *Allocate(PayloadBuffer **buffer, uint32_t n,
-                        bool clear = true, bool enable_small_block = true);
+  static void *Allocate(PayloadBuffer **buffer, uint32_t n, bool clear = true,
+                        bool enable_small_block = true);
   void Free(void *p);
   static void *Realloc(PayloadBuffer **buffer, void *p, uint32_t n,
-                       bool clear = true,
-                       bool enable_small_block = true);
+                       bool clear = true, bool enable_small_block = true);
   static BufferOffset AllocateBitMapRunVector(PayloadBuffer **self);
   static void *AllocateSmallBlock(PayloadBuffer **pb, uint32_t size, int index,
                                   bool clear = true);
@@ -331,8 +330,7 @@ struct PayloadBuffer {
   // individually. The addresses of the allocated items are returned in a
   // vector.
   static std::vector<void *> AllocateMany(PayloadBuffer **buffer, uint32_t size,
-                                          uint32_t n,
-                                          bool clear = true);
+                                          uint32_t n, bool clear = true);
 
   bool IsValidMagic() const {
     uint32_t m = magic & kBitMapMask;
@@ -353,12 +351,12 @@ struct PayloadBuffer {
   // Given the address of a block, return the size of the block.  This is
   // in the previous 8 bytes but might be encoded if the block is a small
   // block.
-  static uint32_t DecodedSize(BufferOffset* addr) {
-      BufferOffset* p = addr - 2;
-      if (*p & (1U << 31)) {
-          return *p & kBitmapRunSizeMask;
-      }
-      return *p;
+  static uint32_t DecodedSize(BufferOffset *addr) {
+    BufferOffset *p = addr - 2;
+    if (*p & (1U << 31)) {
+      return *p & kBitmapRunSizeMask;
+    }
+    return *p;
   }
 
   template <typename T = void>
@@ -483,21 +481,28 @@ inline void PayloadBuffer::VectorPush(PayloadBuffer **self, VectorHeader *hdr,
   // BufferOffset data;         - BufferOffset to vector contents
   // The vector contents is allocated in the buffer.  It is preceded
   // by the block size (in bytes).
+  BufferOffset hdr_offset = (*self)->ToOffset(hdr);
+
   uint32_t total_size = hdr->num_elements * sizeof(T);
   if (hdr->data == 0) {
     // The vector is empty, allocate it with a default size of 2.
     void *vecp = Allocate(self, 2 * sizeof(T), true, enable_small_block);
     hdr->data = (*self)->ToOffset(vecp);
+    VectorHeader *new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+    new_hdr->data = (*self)->ToOffset(vecp);
+    hdr = new_hdr;
   } else {
     // Vector has some values in it.  Retrieve the total size from
     // the allocated block header (before the start of the memory)
     uint32_t *block = (*self)->ToAddress<uint32_t>(hdr->data);
     uint32_t current_size = DecodeSize(block);
     if (current_size == total_size) {
       // Need to double the size of the memory.
-      void *vecp = Realloc(self, block, 2 * hdr->num_elements * sizeof(T),
-                           true, enable_small_block);
-      hdr->data = (*self)->ToOffset(vecp);
+      void *vecp = Realloc(self, block, 2 * hdr->num_elements * sizeof(T), true,
+                           enable_small_block);
+      VectorHeader *new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+      new_hdr->data = (*self)->ToOffset(vecp);
+      hdr = new_hdr;
     }
   }
   // Get address of next location in vector.
@@ -512,9 +517,12 @@ template <typename T>
 inline void PayloadBuffer::VectorReserve(PayloadBuffer **self,
                                          VectorHeader *hdr, size_t n,
                                          bool enable_small_block) {
+  BufferOffset hdr_offset = (*self)->ToOffset(hdr);
   if (hdr->data == 0) {
     void *vecp = Allocate(self, n * sizeof(T), false, enable_small_block);
-    hdr->data = (*self)->ToOffset(vecp);
+    VectorHeader* new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+    new_hdr->data = (*self)->ToOffset(vecp);
+    hdr = new_hdr;
   } else {
     // Vector has some values in it.  Retrieve the total size from
     // the allocated block header (before the start of the memory)
@@ -524,17 +532,22 @@ inline void PayloadBuffer::VectorReserve(PayloadBuffer **self,
       // Need to expand the memory to the size given.
       void *vecp =
           Realloc(self, block, n * sizeof(T), false, enable_small_block);
-      hdr->data = (*self)->ToOffset(vecp);
+      VectorHeader* new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+      new_hdr->data = (*self)->ToOffset(vecp);
+      hdr = new_hdr;
     }
   }
 }
 
 template <typename T>
 inline void PayloadBuffer::VectorResize(PayloadBuffer **self, VectorHeader *hdr,
                                         size_t n) {
+  BufferOffset hdr_offset = (*self)->ToOffset(hdr);
   if (hdr->data == 0) {
     void *vecp = Allocate(self, n * sizeof(T));
-    hdr->data = (*self)->ToOffset(vecp);
+    VectorHeader* new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+    new_hdr->data = (*self)->ToOffset(vecp);
+    hdr = new_hdr;
   } else {
     // Vector has some values in it.  Retrieve the total size from
     // the allocated block header (before the start of the memory)
@@ -543,7 +556,9 @@ inline void PayloadBuffer::VectorResize(PayloadBuffer **self, VectorHeader *hdr,
     if (current_size < n * sizeof(T)) {
       // Need to expand the memory to the size given.
       void *vecp = Realloc(self, block, n * sizeof(T), 8);
-      hdr->data = (*self)->ToOffset(vecp);
+      VectorHeader* new_hdr = (*self)->ToAddress<VectorHeader>(hdr_offset);
+      new_hdr->data = (*self)->ToOffset(vecp);
+      hdr = new_hdr;
     }
   }
   hdr->num_elements = n;

toolbelt/payload_buffer.h

@@ -338,7 +338,8 @@ TEST(BufferTest, TypicalPerformance) {
     for (int j = 0; j < 1000; j++) {
       int prev_size = int(large_blocks.size());
       for (int i = 0; i < kNumBlocks; i++) {
-        void *addr = PayloadBuffer::Allocate(&pb, 10, false, /*enable_small_block=*/false);
+        void *addr = PayloadBuffer::Allocate(&pb, 10, false,
+                                             /*enable_small_block=*/false);
         large_blocks.push_back(addr);
       }
       // Free some of the blocks.
@@ -367,8 +368,7 @@ TEST(BufferTest, Many) {
   char *buffer = (char *)malloc(kSize);
   PayloadBuffer *pb = new (buffer) PayloadBuffer(kSize);
 
-  std::vector<void *> addrs =
-      PayloadBuffer::AllocateMany(&pb, 100, 10, true);
+  std::vector<void *> addrs = PayloadBuffer::AllocateMany(&pb, 100, 10, true);
   ASSERT_EQ(10, addrs.size());
   // Print the addresses.
   for (auto addr : addrs) {
@@ -497,10 +497,22 @@ TEST(BufferTest, VectorExpandMore) {
 TEST(BufferTest, Resizeable) {
   char *buffer = (char *)malloc(512);
   bool resized = false;
-  PayloadBuffer *pb = new (buffer)
-      PayloadBuffer(256, [&resized](PayloadBuffer **p, size_t old_size, size_t new_size) {
+  PayloadBuffer *pb = new (buffer) PayloadBuffer(
+      256, [&resized](PayloadBuffer **p, size_t, size_t new_size) {
         std::cout << "resize for " << new_size << std::endl;
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wclass-memaccess"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
         *p = reinterpret_cast<PayloadBuffer *>(realloc(*p, new_size));
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
         resized = true;
       });
   pb->Dump(std::cout);

toolbelt/payload_buffer_test.cc

@@ -150,11 +150,11 @@ template <typename T> class SharedPtrPipe : public Pipe {
   SharedPtrPipe(int r, int w) : Pipe(r, w) {}
 
   // You can't use raw buffers with shared ptr pipes.
-  absl::StatusOr<ssize_t> Read(char *buffer, size_t length,
-                               const co::Coroutine *c = nullptr) override {
+  absl::StatusOr<ssize_t> Read(char *, size_t ,
+                               const co::Coroutine * = nullptr) override {
     return absl::InternalError("Not supported on SharedPtrPipe");
   }
-  absl::StatusOr<ssize_t> Write(const char *buffer, size_t length,
+  absl::StatusOr<ssize_t> Write(const char *, size_t ,
                                 const co::Coroutine *c = nullptr) override {
     return absl::InternalError("Not supported on SharedPtrPipe");
   }