Fix warnings from clang build on macOS.

lldb/trunk/source/Expression/LLVMUserExpression.cpp

 LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope,
                                        llvm::StringRef expr,
                                        llvm::StringRef prefix,
                                        lldb::LanguageType language,
                                        ResultType desired_type,
                                        const EvaluateExpressionOptions &options)
     : UserExpression(exe_scope, expr, prefix, language, desired_type, options),
       m_stack_frame_bottom(LLDB_INVALID_ADDRESS),
+      m_stack_frame_top(LLDB_INVALID_ADDRESS),
       m_allow_cxx(false),
       m_allow_objc(false),
-      m_stack_frame_top(LLDB_INVALID_ADDRESS), m_transformed_text(),
+      m_transformed_text(),
       m_execution_unit_sp(), m_materializer_ap(), m_jit_module_wp(),
       m_enforce_valid_object(true), m_in_cplusplus_method(false),
       m_in_objectivec_method(false), m_in_static_method(false),
       m_needs_object_ptr(false), m_target(NULL), m_can_interpret(false),
       m_materialized_address(LLDB_INVALID_ADDRESS) {}
 
 LLVMUserExpression::~LLVMUserExpression() {
   if (m_target) {

lldb/trunk/source/Host/common/Symbols.cpp

 static bool FileAtPathContainsArchAndUUID(const FileSpec &file_fspec,
                                           const ArchSpec *arch,
                                           const lldb_private::UUID *uuid) {
   ModuleSpecList module_specs;
   if (ObjectFile::GetModuleSpecifications(file_fspec, 0, 0, module_specs)) {
     ModuleSpec spec;
     for (size_t i = 0; i < module_specs.GetSize(); ++i) {
       bool got_spec = module_specs.GetModuleSpecAtIndex(i, spec);
+      UNUSED_IF_ASSERT_DISABLED(got_spec);
       assert(got_spec);
       if ((uuid == NULL || (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) &&
           (arch == NULL || (spec.GetArchitecturePtr() &&
                             spec.GetArchitecture().IsCompatibleMatch(*arch)))) {
         return true;
       }
     }
   }

lldb/trunk/source/Host/macosx/Symbols.cpp

if (dirp.is_valid()) {
         if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN) {
           dsym_fspec.GetFilename().SetCString(dp->d_name);
           ModuleSpecList module_specs;
           if (ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0,
                                                   module_specs)) {
             ModuleSpec spec;
             for (size_t i = 0; i < module_specs.GetSize(); ++i) {
               bool got_spec = module_specs.GetModuleSpecAtIndex(i, spec);
+              UNUSED_IF_ASSERT_DISABLED(got_spec);
               assert(got_spec);
               if ((uuid == NULL ||
                    (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) &&
                   (arch == NULL ||
                    (spec.GetArchitecturePtr() &&
                     spec.GetArchitecture().IsCompatibleMatch(*arch)))) {
                 return dsym_fspec;
               }

lldb/trunk/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes",
       assert(reg_info.dynamic_size_dwarf_len > 0);
 
       std::vector<uint8_t> dwarf_opcode_bytes(reg_info.dynamic_size_dwarf_len);
       uint32_t j;
       StringExtractor opcode_extractor;
       // Swap "dwarf_opcode_string" over into "opcode_extractor"
       opcode_extractor.GetStringRef().swap(dwarf_opcode_string);
       uint32_t ret_val = opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
+      UNUSED_IF_ASSERT_DISABLED(ret_val);
       assert(ret_val == reg_info.dynamic_size_dwarf_len);
 
       for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j)
         m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
 
       reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data();
     }
 

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

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:MD5:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
-    uint64_t a, b;
     StreamGDBRemote response;
     auto Result = llvm::sys::fs::md5_contents(path);
     if (!Result) {
       response.PutCString("F,");
       response.PutCString("x");
     } else {
       response.PutCString("F,");
       response.PutHex64(Result->low());