Remove no-op null checks, NFC

[vsk]

Summary

Null-checking functions which aren't marked 'weak_import' is a no-op
(the compiler rewrites the check to 'true'), regardless of whether a
library providing its definition is weak-linked.

Remove the no-op checks to clean up the code and silence
-Wpointer-to-bool.

[jasonmolenda]

I don't think that is correct. here's an example in the form of a makefile. the main binary calls foo() which is weak linked from a library. In the first run, foo() is present in the library. In the second run, the library is rebuilt so foo() is absent. The behavior of the program differs.

In this case, we needed an lldb which was built on a system with libcompression to be able to run on a system without libcompression. Although for Apple's purposes, we are no longer supporting lldb on systems without libcompression so it's not really needed any longer for our uses.

[jasonmolenda]

all:
echo 'int foo() { return 5; }' > mylib.c
echo "int foo() attribute((weak_import)); int printf(const char *, ...); int main() { if (foo) printf (\"have foo() %d\\\n\", foo()); else printf(\"do not have foo\\\n\"); return 0; }" > main.c
clang -dynamiclib -o libmylib.dylib mylib.c
clang main.c -L. -lmylib
./a.out
echo 'int bar() { return 5; }' > mylib.c
clang -dynamiclib -o libmylib.dylib mylib.c
./a.out

[jasonmolenda]

The output looks like this:

% make
echo 'int foo() { return 5; }' > mylib.c
echo "int foo() attribute((weak_import)); int printf(const char *, ...); int main() { if (foo) printf (\"have foo() %d\\\n\", foo()); else printf(\"do not have foo\\\n\"); return 0; }" > main.c
clang -dynamiclib -o libmylib.dylib mylib.c
clang main.c -L. -lmylib
./a.out
have foo() 5
echo 'int bar() { return 5; }' > mylib.c
clang -dynamiclib -o libmylib.dylib mylib.c
./a.out
do not have foo

[vsk]

Ah, sorry, I should have mentioned that the header vending compression_decode_buffer() does not provide the 'weak_import' attribute (as far as I can see!). If you change your example to drop 'weak_import' from foo, I think it will be closer to the current situation.

[jasonmolenda]

Ah I see, I bet I assumed it was marked weak but it never was. patch looks good to me.

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

if (decompressed_buffer == nullptr) {
       m_bytes.erase(0, size_of_first_packet);
       return false;
     }
   }
 
 #if defined(HAVE_LIBCOMPRESSION)
   // libcompression is weak linked so check that compression_decode_buffer() is
   // available
-  if (compression_decode_buffer != NULL &&
-      (m_compression_type == CompressionType::ZlibDeflate ||
-       m_compression_type == CompressionType::LZFSE ||
-       m_compression_type == CompressionType::LZ4)) {
+  if (m_compression_type == CompressionType::ZlibDeflate ||
+      m_compression_type == CompressionType::LZ4) {
     compression_algorithm compression_type;
     if (m_compression_type == CompressionType::LZFSE)
       compression_type = COMPRESSION_LZFSE;
     else if (m_compression_type == CompressionType::ZlibDeflate)
       compression_type = COMPRESSION_ZLIB;
     else if (m_compression_type == CompressionType::LZ4)
       compression_type = COMPRESSION_LZ4_RAW;
     else if (m_compression_type == CompressionType::LZMA)

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 }
 
 void GDBRemoteCommunicationClient::MaybeEnableCompression(
     std::vector<std::string> supported_compressions) {
   CompressionType avail_type = CompressionType::None;
   std::string avail_name;
 
 #if defined(HAVE_LIBCOMPRESSION)
-  // libcompression is weak linked so test if compression_decode_buffer() is
-  // available
-  if (compression_decode_buffer != NULL &&
-      avail_type == CompressionType::None) {
+  if (avail_type == CompressionType::None) {
     for (auto compression : supported_compressions) {
       if (compression == "lzfse") {
         avail_type = CompressionType::LZFSE;
         avail_name = compression;
         break;
       }
     }
   }
 #endif
 
 #if defined(HAVE_LIBCOMPRESSION)
-  // libcompression is weak linked so test if compression_decode_buffer() is
-  // available
-  if (compression_decode_buffer != NULL &&
-      avail_type == CompressionType::None) {
+  if (avail_type == CompressionType::None) {
     for (auto compression : supported_compressions) {
       if (compression == "zlib-deflate") {
         avail_type = CompressionType::ZlibDeflate;
         avail_name = compression;
         break;
       }
     }
   }
 #endif
 
 #if defined(HAVE_LIBZ)
   if (avail_type == CompressionType::None) {
     for (auto compression : supported_compressions) {
       if (compression == "zlib-deflate") {
         avail_type = CompressionType::ZlibDeflate;
         avail_name = compression;
         break;
       }
     }
   }
 #endif
 
 #if defined(HAVE_LIBCOMPRESSION)
-  // libcompression is weak linked so test if compression_decode_buffer() is
-  // available
-  if (compression_decode_buffer != NULL &&
-      avail_type == CompressionType::None) {
+  if (avail_type == CompressionType::None) {
     for (auto compression : supported_compressions) {
       if (compression == "lz4") {
         avail_type = CompressionType::LZ4;
         avail_name = compression;
         break;
       }
     }
   }
 #endif
 
 #if defined(HAVE_LIBCOMPRESSION)
-  // libcompression is weak linked so test if compression_decode_buffer() is
-  // available
-  if (compression_decode_buffer != NULL &&
-      avail_type == CompressionType::None) {
+  if (avail_type == CompressionType::None) {
     for (auto compression : supported_compressions) {
       if (compression == "lzma") {
         avail_type = CompressionType::LZMA;
         avail_name = compression;
         break;
       }
     }
   }

lldb/trunk/tools/debugserver/source/MacOSX/OsLogger.cpp

void DarwinLogCallback(void *baton, uint32_t flags, const char *format,
   // This code is unfortunate.  os_log* only takes static strings, but
   // our current log API isn't set up to make use of that style.
   char buffer[LLDB_OS_LOG_MAX_BUFFER_LENGTH];
   vsnprintf(buffer, sizeof(buffer), format, args);
   os_log_with_type(g_logger, log_type, "%{public}s", buffer);
 }
 }
 
-DNBCallbackLog OsLogger::GetLogFunction() {
-  return _os_log_impl ? DarwinLogCallback : nullptr;
-}
+DNBCallbackLog OsLogger::GetLogFunction() { return DarwinLogCallback; }
 
 #else
 
 DNBCallbackLog OsLogger::GetLogFunction() { return nullptr; }
 
 #endif
 

lldb/trunk/tools/debugserver/source/RNBRemote.cpp

if (compression_type != compression_types::none) {
     }
 
     if (compress_this_packet) {
       const size_t encoded_data_buf_size = orig.size() + 128;
       std::vector<uint8_t> encoded_data(encoded_data_buf_size);
       size_t compressed_size = 0;
 
 #if defined(HAVE_LIBCOMPRESSION)
-      if (compression_decode_buffer &&
-          compression_type == compression_types::lz4) {
+      if (compression_type == compression_types::lz4) {
         compressed_size = compression_encode_buffer(
             encoded_data.data(), encoded_data_buf_size, (uint8_t *)orig.c_str(),
             orig.size(), nullptr, COMPRESSION_LZ4_RAW);
       }
-      if (compression_decode_buffer &&
-          compression_type == compression_types::zlib_deflate) {
+      if (compression_type == compression_types::zlib_deflate) {
         compressed_size = compression_encode_buffer(
             encoded_data.data(), encoded_data_buf_size, (uint8_t *)orig.c_str(),
             orig.size(), nullptr, COMPRESSION_ZLIB);
       }
-      if (compression_decode_buffer &&
-          compression_type == compression_types::lzma) {
+      if (compression_type == compression_types::lzma) {
         compressed_size = compression_encode_buffer(
             encoded_data.data(), encoded_data_buf_size, (uint8_t *)orig.c_str(),
             orig.size(), nullptr, COMPRESSION_LZMA);
       }
-      if (compression_decode_buffer &&
-          compression_type == compression_types::lzfse) {
+      if (compression_type == compression_types::lzfse) {
         compressed_size = compression_encode_buffer(
             encoded_data.data(), encoded_data_buf_size, (uint8_t *)orig.c_str(),
             orig.size(), nullptr, COMPRESSION_LZFSE);
       }
 #endif
 
 #if defined(HAVE_LIBZ)
       if (compressed_size == 0 &&

 
 #if (defined (TARGET_OS_WATCH) && TARGET_OS_WATCH == 1) || (defined (TARGET_OS_IOS) && TARGET_OS_IOS == 1) || (defined (TARGET_OS_TV) && TARGET_OS_TV == 1)
   enable_compression = true;
 #endif
 
 #if defined(HAVE_LIBCOMPRESSION)
   // libcompression is weak linked so test if compression_decode_buffer() is
   // available
-  if (enable_compression && compression_decode_buffer != NULL) {
+  if (enable_compression) {
     strcat(buf, ";SupportedCompressions=lzfse,zlib-deflate,lz4,lzma;"
                 "DefaultCompressionMinSize=");
     char numbuf[16];
     snprintf(numbuf, sizeof(numbuf), "%zu", m_compression_minsize);
     numbuf[sizeof(numbuf) - 1] = '\0';
     strcat(buf, numbuf);
   }
 #elif defined(HAVE_LIBZ)
if (new_compression_minsize_str) {
     errno = 0;
     new_compression_minsize = strtoul(new_compression_minsize_str, NULL, 10);
     if (errno != 0 || new_compression_minsize == ULONG_MAX) {
       new_compression_minsize = m_compression_minsize;
     }
   }
 
 #if defined(HAVE_LIBCOMPRESSION)
-  if (compression_decode_buffer != NULL) {
-    if (strstr(p, "type:zlib-deflate;") != nullptr) {
-      EnableCompressionNextSendPacket(compression_types::zlib_deflate);
-      m_compression_minsize = new_compression_minsize;
-      return SendPacket("OK");
-    } else if (strstr(p, "type:lz4;") != nullptr) {
-      EnableCompressionNextSendPacket(compression_types::lz4);
-      m_compression_minsize = new_compression_minsize;
-      return SendPacket("OK");
-    } else if (strstr(p, "type:lzma;") != nullptr) {
-      EnableCompressionNextSendPacket(compression_types::lzma);
-      m_compression_minsize = new_compression_minsize;
-      return SendPacket("OK");
-    } else if (strstr(p, "type:lzfse;") != nullptr) {
-      EnableCompressionNextSendPacket(compression_types::lzfse);
-      m_compression_minsize = new_compression_minsize;
-      return SendPacket("OK");
-    }
-  }
 #endif
 
 #if defined(HAVE_LIBZ)
   if (strstr(p, "type:zlib-deflate;") != nullptr) {
     EnableCompressionNextSendPacket(compression_types::zlib_deflate);
     m_compression_minsize = new_compression_minsize;
     return SendPacket("OK");
   }