Add UNUSED_IF_ASSERT_DISABLED and apply it.

[brucem]

Summary

This replaces (void)x; usages where they x was subsequently
involved in an assertion with this macro to make the
intent more clear.

[clayborg]

Looks good.

include/lldb/lldb-defines.h

 #define MAX_PATH 260
 #endif
 
 #ifdef _MSC_VER
 // ignore GCC function attributes
 #define __attribute__(X)
 #endif
 
+#define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
+
 #if defined(__cplusplus)
 
 //----------------------------------------------------------------------
 /// @def DISALLOW_COPY_AND_ASSIGN(TypeName)
 ///     Macro definition for easily disallowing copy constructor and
 ///     assignment operators in C++ classes.
 //----------------------------------------------------------------------
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
     TypeName(const TypeName&); \
     const TypeName& operator=(const TypeName&)
 
 #endif // #if defined(__cplusplus)
 
 #endif  // LLDB_lldb_defines_h_

source/Host/posix/MainLoopPosix.cpp

MainLoopPosix::RegisterSignal(int signo, const Callback &callback, Error &error)
 
     return SignalHandleUP(new SignalHandle(*this, signo));
 }
 
 void
 MainLoopPosix::UnregisterReadObject(IOObject::WaitableHandle handle)
 {
     bool erased = m_read_fds.erase(handle);
-    (void) erased;
+    UNUSED_IF_ASSERT_DISABLED(erased);
     assert(erased);
 }
 
 void
 MainLoopPosix::UnregisterSignal(int signo)
 {
     // We undo the actions of RegisterSignal on a best-effort basis.
     auto it = m_signals.find(signo);

source/Interpreter/CommandInterpreter.cpp

CommandInterpreter::LoadCommandDictionary ()
     {
         bool success = true;
         for (size_t i = 0; i < num_regexes; i++)
         {
             // If you add a resultant command string longer than 1024 characters be sure to increase the size of this buffer.
             char buffer[1024];
             int num_printed = snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o");
             assert (num_printed < 1024);
-      // Quiet unused variable warning for release builds.
-      (void) num_printed;
+            UNUSED_IF_ASSERT_DISABLED(num_printed);
             success = tbreak_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], buffer);
             if (!success)
                 break;
         }
         success = tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
 
         if (success)
         {

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (m_dyld_all_image_infos_addr != LLDB_INVALID_ADDRESS)
                                  addr_size +         // initialImageCount
                                  addr_size +         // errorKind
                                  addr_size +         // errorClientOfDylibPath
                                  addr_size +         // errorTargetDylibPath
                                  addr_size;          // errorSymbol
         const size_t count_v13 = count_v11 +
                                  addr_size +         // sharedCacheSlide
                                  sizeof (uuid_t);    // sharedCacheUUID
-        (void) count_v13; // Avoid warnings when assertions are off.
+        UNUSED_IF_ASSERT_DISABLED(count_v13);
         assert (sizeof (buf) >= count_v13);
 
         Error error;
         if (m_process->ReadMemory (m_dyld_all_image_infos_addr, buf, 4, error) == 4)
         {
             m_dyld_all_image_infos.version = data.GetU32(&offset);
             // If anything in the high byte is set, we probably got the byte 
             // order incorrect (the process might not have it set correctly 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

 
 std::string
 AppleObjCTypeEncodingParser::ReadQuotedString(lldb_utility::StringLexer& type)
 {
     StreamString buffer;
     while (type.HasAtLeast(1) && type.Peek() != '"')
         buffer.Printf("%c",type.Next());
     StringLexer::Character next = type.Next();
-    (void) next; // Avoid warnings when assertions are off.
+    UNUSED_IF_ASSERT_DISABLED(next);
     assert (next == '"');
     return buffer.GetString();
 }
 
 uint32_t
 AppleObjCTypeEncodingParser::ReadNumber (lldb_utility::StringLexer& type)
 {
     uint32_t total = 0;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

#else
     debugserver_launch_info.SetLaunchInSeparateProcessGroup(false);
     debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
     std::string platform_scheme;
     std::string platform_ip;
     int platform_port;
     std::string platform_path;
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
-    (void)ok;
+    UNUSED_IF_ASSERT_DISABLED(ok);
     assert(ok);
     Error error = StartDebugserverProcess (
                                      platform_ip.c_str(),
                                      port,
                                      debugserver_launch_info,
                                      port);
 
     lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();

source/Symbol/ClangASTImporter.cpp

ClangASTImporter::Minion::ExecuteDeportWorkQueues ()
     while (!m_decls_to_deport->empty())
     {
         NamedDecl *decl = *m_decls_to_deport->begin();
         
         m_decls_already_deported->insert(decl);
         m_decls_to_deport->erase(decl);
         
         DeclOrigin &origin = to_context_md->m_origins[decl];
-        (void)origin;
+        UNUSED_IF_ASSERT_DISABLED(origin);
         
         assert (origin.ctx == m_source_ctx);    // otherwise we should never have added this
                                                 // because it doesn't need to be deported
         
         Decl *original_decl = to_context_md->m_origins[decl].decl;
         
         ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
         

source/Target/Process.cpp

if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
             bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
                 
                 if (error.Success())
                 {
                     addr_t intersect_addr;
                     size_t intersect_size;
                     size_t opcode_offset;
                     const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
-                    (void)intersects;
+                    UNUSED_IF_ASSERT_DISABLED(intersects);
                     assert(intersects);
                     assert(addr <= intersect_addr && intersect_addr < addr + size);
                     assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
                     assert(opcode_offset + intersect_size <= bp->GetByteSize());
                     
                     // Check for bytes before this breakpoint
                     const addr_t curr_addr = addr + bytes_written;
                     if (intersect_addr > curr_addr)

tools/debugserver/source/DNB.cpp

if (processSP.get())
                     {
                         ::snprintf (err_str, err_len, "failed to get the task for process %i", pid);
                     }
                 }
             }
             else
             {
                 bool res = AddProcessToMap(pid, processSP);
-                (void)res;
+                UNUSED_IF_ASSERT_DISABLED(res);
                 assert(res && "Couldn't add process to map!");
                 return pid;
             }
         }
     }
     return INVALID_NUB_PROCESS;
 }
 
DNBProcessAttach (nub_process_t attach_pid, struct timespec *timeout, char *err_str, size_t err_len)
     if (processSP.get())
     {
         DNBLogThreadedIf(LOG_PROCESS, "(DebugNub) attaching to pid %d...", attach_pid);
         pid = processSP->AttachForDebug (attach_pid, err_str,  err_len);
 
         if (pid != INVALID_NUB_PROCESS)
         {
             bool res = AddProcessToMap(pid, processSP);
-            (void)res;
+            UNUSED_IF_ASSERT_DISABLED(res);
             assert(res && "Couldn't add process to map!");
             spawn_waitpid_thread(pid);
         }
     }
 
     while (pid != INVALID_NUB_PROCESS)
     {
         // Wait for process to start up and hit entry point

tools/debugserver/source/DNBDefs.h

enum DNBProfileDataScanType
     
     eProfileAll                 = 0xffffffff
 };
 
 typedef nub_addr_t (*DNBCallbackNameToAddress)(nub_process_t pid, const char *name, const char *shlib_regex, void *baton);
 typedef nub_size_t (*DNBCallbackCopyExecutableImageInfos)(nub_process_t pid, struct DNBExecutableImageInfo **image_infos, nub_bool_t only_changed, void *baton);
 typedef void (*DNBCallbackLog)(void *baton, uint32_t flags, const char *format, va_list args);
 
+#define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
+
 #endif    // #ifndef __DNBDefs_h__

tools/debugserver/source/MacOSX/MachProcess.mm

MachProcess::WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf)
     nub_size_t opcode_offset;
     const uint8_t *ubuf = (const uint8_t *)buf;
 
     for (size_t i=0; i<num_bps; ++i)
     {
         DNBBreakpoint *bp = bps[i];
 
         const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
-        (void)intersects;
+        UNUSED_IF_ASSERT_DISABLED(intersects);
         assert(intersects);
         assert(addr <= intersect_addr && intersect_addr < addr + size);
         assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
         assert(opcode_offset + intersect_size <= bp->ByteSize());
         
         // Check for bytes before this breakpoint
         const nub_addr_t curr_addr = addr + bytes_written;
         if (intersect_addr > curr_addr)

tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp

if (buf && buf_len)
         ::memcpy (p, &m_state.context.gpr, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (p, &m_state.context.vfp, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (p, &m_state.context.exc, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
 
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
 
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM::GetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
if (size)
         ::memcpy (&m_state.context.gpr, p, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (&m_state.context.vfp, p, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (&m_state.context.exc, p, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
 
         if (SetGPRState() | SetVFPState() | SetEXCState())
             return 0;
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM::SetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     return size;
 }

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp

if (buf && buf_len)
         ::memcpy (p, &m_state.context.gpr, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (p, &m_state.context.vfp, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (p, &m_state.context.exc, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM64::GetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
 nub_size_t
if (size)
         ::memcpy (&m_state.context.gpr, p, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (&m_state.context.vfp, p, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (&m_state.context.exc, p, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
         SetGPRState();
         SetVFPState();
         SetEXCState();
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM64::SetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size);
     return size;
 }

tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp

if (buf && buf_len)
             }
             
             // Copy the exception registers
             memcpy(p, &m_state.context.exc, sizeof(EXC));
             p += sizeof(EXC);
             
             // make sure we end up with exactly what we think we should have
             size_t bytes_written = p - (uint8_t *)buf;
-            (void)bytes_written;
+            UNUSED_IF_ASSERT_DISABLED(bytes_written);
             assert (bytes_written == size);
         }
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::GetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
if (size)
         }
         
         // Copy the exception registers
         memcpy(&m_state.context.exc, p, sizeof(EXC));
         p += sizeof(EXC);
         
         // make sure we end up with exactly what we think we should have
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
         kern_return_t kret;
         if ((kret = SetGPRState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: GPR regs failed to write: %u", buf, (uint64_t)buf_len, kret);
         if ((kret = SetFPUState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: %s regs failed to write: %u", buf, (uint64_t)buf_len, CPUHasAVX() ? "AVX" : "FPU", kret);
         if ((kret = SetEXCState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: EXP regs failed to write: %u", buf, (uint64_t)buf_len, kret);

tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp

if (buf && buf_len)
             }
             
             // Copy the exception registers
             memcpy(p, &m_state.context.exc, sizeof(EXC));
             p += sizeof(EXC);
             
             // make sure we end up with exactly what we think we should have
             size_t bytes_written = p - (uint8_t *)buf;
-            (void)bytes_written;
+            UNUSED_IF_ASSERT_DISABLED(bytes_written);
             assert (bytes_written == size);
         }
 
     }
 
     DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::GetRegisterContext (buf = %p, len = %llu) => %u", buf, (uint64_t)buf_len, size);
     // Return the size of the register context even if NULL was passed in
     return size;
if (size)
         }
         
         // Copy the exception registers
         memcpy(&m_state.context.exc, p, sizeof(EXC));
         p += sizeof(EXC);
         
         // make sure we end up with exactly what we think we should have
         size_t bytes_written = p - (uint8_t *)buf;
-        (void)bytes_written;
+        UNUSED_IF_ASSERT_DISABLED(bytes_written);
         assert (bytes_written == size);
 
         kern_return_t kret;
         if ((kret = SetGPRState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::SetRegisterContext (buf = %p, len = %llu) error: GPR regs failed to write: %u", buf, (uint64_t)buf_len, kret);
         if ((kret = SetFPUState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::SetRegisterContext (buf = %p, len = %llu) error: %s regs failed to write: %u", buf, (uint64_t)buf_len, CPUHasAVX() ? "AVX" : "FPU", kret);
         if ((kret = SetEXCState()) != KERN_SUCCESS)