Replace integer literals which are cast to bool

[davide]

LGTM

source/Commands/CommandObjectPlatform.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     Stream &ostrm = result.GetOutputStream();
     ostrm.Printf("Available platforms:\n");
 
     PlatformSP host_platform_sp(Platform::GetHostPlatform());
     ostrm.Printf("%s: %s\n", host_platform_sp->GetPluginName().GetCString(),
                  host_platform_sp->GetDescription());
 
     uint32_t idx;
-    for (idx = 0; 1; ++idx) {
+    for (idx = 0; true; ++idx) {
       const char *plugin_name =
           PluginManager::GetPlatformPluginNameAtIndex(idx);
       if (plugin_name == nullptr)
         break;
       const char *plugin_desc =
           PluginManager::GetPlatformPluginDescriptionAtIndex(idx);
       if (plugin_desc == nullptr)
         break;

source/Commands/CommandObjectTarget.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
 
       case 't':
         m_str = option_arg;
         m_type = eLookupTypeType;
         break;
 
       case 'v':
-        m_verbose = 1;
+        m_verbose = true;
         break;
 
       case 'A':
         m_print_all = true;
         break;
 
       case 'r':
         m_use_regex = true;

source/Commands/CommandObjectThread.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 'm': {
         auto enum_values = GetDefinitions()[option_idx].enum_values;
         m_run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
             option_arg, enum_values, eOnlyDuringStepping, error);
       } break;
 
       case 'e':
         if (option_arg == "block") {
-          m_end_line_is_block_end = 1;
+          m_end_line_is_block_end = true;
           break;
         }
         if (option_arg.getAsInteger(0, m_end_line))
           error.SetErrorStringWithFormat("invalid end line number '%s'",
                                          option_arg.str().c_str());
         break;
 
       case 'r':

source/Core/Address.cpp

if (success) {
     return true;
   }
   return false;
 }
 
 static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
                      uint32_t byte_size, Stream *strm) {
   if (exe_scope == nullptr || byte_size == 0)
-    return 0;
+    return false;
   std::vector<uint8_t> buf(byte_size, 0);
 
   if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) {
     ByteOrder byte_order = eByteOrderInvalid;
     uint32_t addr_size = 0;
     if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
       DataExtractor data(&buf.front(), buf.size(), byte_order, addr_size);
 

source/Host/macosx/objcxx/Host.mm

if (::sysctl(proc_args_mib, 3, arg_data.GetBytes(), &arg_data_size, NULL,
         process_info.GetExecutableFile().SetFile(cstr, FileSpec::Style::native);
 
         if (match_info_ptr == NULL ||
             NameMatches(
                 process_info.GetExecutableFile().GetFilename().GetCString(),
                 match_info_ptr->GetNameMatchType(),
                 match_info_ptr->GetProcessInfo().GetName())) {
           // Skip NULLs
-          while (1) {
+          while (true) {
             const uint8_t *p = data.PeekData(offset, 1);
             if ((p == NULL) || (*p != '\0'))
               break;
             ++offset;
           }
           // Now extract all arguments
           Args &proc_args = process_info.GetArguments();
           for (int i = 0; i < static_cast<int>(argc); ++i) {

source/Interpreter/Options.cpp

llvm::Expected<Args> Options::ParseAlias(const Args &args,
   }
 
   Args args_copy = args;
   std::vector<char *> argv = GetArgvForParsing(args);
 
   std::unique_lock<std::mutex> lock;
   OptionParser::Prepare(lock);
   int val;
-  while (1) {
+  while (true) {
     int long_options_index = -1;
     val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
                               long_options, &long_options_index);
 
     if (val == -1)
       break;
 
     if (val == '?') {
OptionElementVector Options::ParseForCompletion(const Args &args,
 
   // I stick an element on the end of the input, because if the last element
   // is option that requires an argument, getopt_long_only will freak out.
   dummy_vec.push_back(const_cast<char *>("<FAKE-VALUE>"));
 
   bool failed_once = false;
   uint32_t dash_dash_pos = -1;
 
-  while (1) {
+  while (true) {
     bool missing_argument = false;
     int long_options_index = -1;
 
     val = OptionParser::Parse(dummy_vec.size(), &dummy_vec[0], sstr.GetString(),
                               long_options, &long_options_index);
 
     if (val == -1) {
       // When we're completing a "--" which is the last option on line,
if (long_options[i].flag == nullptr) {
         }
       }
     }
   }
   std::vector<char *> argv = GetArgvForParsing(args);
   std::unique_lock<std::mutex> lock;
   OptionParser::Prepare(lock);
   int val;
-  while (1) {
+  while (true) {
     int long_options_index = -1;
     val = OptionParser::Parse(argv.size(), &*argv.begin(), sstr.GetString(),
                               long_options, &long_options_index);
     if (val == -1)
       break;
 
     // Did we get an error?
     if (val == '?') {

source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

if (*byte_size <= 16) {
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       RegisterValue r2_value, r3_value, f0_value, f1_value, f2_value;
       // Tracks how much bytes of r2 and r3 registers we've consumed so far
       uint32_t integer_bytes = 0;
 
       // True if return values are in FP return registers.
-      bool use_fp_regs = 0;
+      bool use_fp_regs = false;
       // True if we found any non floating point field in structure.
-      bool found_non_fp_field = 0;
+      bool found_non_fp_field = false;
       // True if return values are in r2 register.
-      bool use_r2 = 0;
+      bool use_r2 = false;
       // True if return values are in r3 register.
-      bool use_r3 = 0;
+      bool use_r3 = false;
       // True if the result is copied into our data buffer
-      bool sucess = 0;
+      bool sucess = false;
       std::string name;
       bool is_complex;
       uint32_t count;
       const uint32_t num_children = return_compiler_type.GetNumFields();
 
       // A structure consisting of one or two FP values (and nothing else) will
       // be returned in the two FP return-value registers i.e fp0 and fp2.
       if (num_children <= 2) {
         uint64_t field_bit_offset = 0;
 
         // Check if this structure contains only floating point fields
         for (uint32_t idx = 0; idx < num_children; idx++) {
           CompilerType field_compiler_type =
               return_compiler_type.GetFieldAtIndex(idx, name, &field_bit_offset,
                                                    nullptr, nullptr);
 
           if (field_compiler_type.IsFloatingPointType(count, is_complex))
-            use_fp_regs = 1;
+            use_fp_regs = true;
           else
-            found_non_fp_field = 1;
+            found_non_fp_field = true;
         }
 
         if (use_fp_regs && !found_non_fp_field) {
           // We have one or two FP-only values in this structure. Get it from
           // f0/f2 registers.
           DataExtractor f0_data, f1_data, f2_data;
           const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
if (*byte_size <= 16) {
 
           if (integer_bytes < 8) {
             // We have not yet consumed r2 completely.
             if (integer_bytes + *field_byte_width + padding <= 8) {
               // This field fits in r2, copy its value from r2 to our result
               // structure
               integer_bytes = integer_bytes + *field_byte_width +
                               padding; // Increase the consumed bytes.
-              use_r2 = 1;
+              use_r2 = true;
             } else {
               // There isn't enough space left in r2 for this field, so this
               // will be in r3.
               integer_bytes = integer_bytes + *field_byte_width +
                               padding; // Increase the consumed bytes.
-              use_r3 = 1;
+              use_r3 = true;
             }
           }
           // We already have consumed at-least 8 bytes that means r2 is done,
           // and this field will be in r3. Check if this field can fit in r3.
           else if (integer_bytes + *field_byte_width + padding <= 16) {
             integer_bytes = integer_bytes + *field_byte_width + padding;
-            use_r3 = 1;
+            use_r3 = true;
           } else {
             // There isn't any space left for this field, this should not
             // happen as we have already checked the overall size is not
             // greater than 16 bytes. For now, return a nullptr return value
             // object.
             return return_valobj_sp;
           }
         }
       }
       // Vector types up to 16 bytes are returned in GP return registers
       if (type_flags & eTypeIsVector) {
         if (*byte_size <= 8)
-          use_r2 = 1;
+          use_r2 = true;
         else {
-          use_r2 = 1;
-          use_r3 = 1;
+          use_r2 = true;
+          use_r3 = true;
         }
       }
 
       if (use_r2) {
         reg_ctx->ReadRegister(r2_info, r2_value);
 
         const size_t bytes_copied = r2_value.GetAsMemoryData(
             r2_info, data_sp->GetBytes(), r2_info->byte_size, target_byte_order,
             error);
         if (bytes_copied != r2_info->byte_size)
           return return_valobj_sp;
-        sucess = 1;
+        sucess = true;
       }
       if (use_r3) {
         reg_ctx->ReadRegister(r3_info, r3_value);
         const size_t bytes_copied = r3_value.GetAsMemoryData(
             r3_info, data_sp->GetBytes() + r2_info->byte_size,
             r3_info->byte_size, target_byte_order, error);
 
         if (bytes_copied != r3_info->byte_size)
           return return_valobj_sp;
-        sucess = 1;
+        sucess = true;
       }
       if (sucess) {
         // The result is in our data buffer.  Create a variable object out of
         // it
         return_valobj_sp = ValueObjectConstResult::Create(
             &thread, return_compiler_type, ConstString(""), return_ext);
       }
       return return_valobj_sp;

source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

do {
 
     if (!implicit_cast)
       break;
 
     if (implicit_cast->getCastKind() != CK_LValueToRValue)
       break;
 
     last_expr = implicit_cast->getSubExpr();
-  } while (0);
+  } while (false);
 
   // is_lvalue is used to record whether the expression returns an assignable
   // Lvalue or an Rvalue.  This is relevant because they are handled
   // differently.
   //
   // For Lvalues
   //
   //   - In AST result synthesis (here!) the expression E is transformed into an

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

do {
         break;
 
       DeclVendor *runtime_decl_vendor = language_runtime->GetDeclVendor();
 
       if (!runtime_decl_vendor)
         break;
 
       sources.push_back(runtime_decl_vendor->GetImporterSource());
-    } while (0);
+    } while (false);
 
     do {
       DeclVendor *modules_decl_vendor =
           m_target->GetClangModulesDeclVendor();
 
       if (!modules_decl_vendor)
         break;
 
       sources.push_back(modules_decl_vendor->GetImporterSource());
-    } while (0);
+    } while (false);
 
     if (!is_shared_context) {
       // Update the scratch AST context's merger to reflect any new sources we
       // might have come across since the last time an expression was parsed.
 
       auto scratch_ast_context = static_cast<ClangASTContextForExpressions*>(
           m_target->GetScratchClangASTContext());
 
       scratch_ast_context->GetMergerUnchecked().AddSources(sources);
 
       sources.push_back({*scratch_ast_context->getASTContext(),
                          *scratch_ast_context->getFileManager(),
                          scratch_ast_context->GetOriginMap()});
-    } while (0);
+    }
+    while (false)
+      ;
 
     m_merger_up =
         llvm::make_unique<clang::ExternalASTMerger>(target, sources);
   } else {
     m_ast_importer_sp->InstallMapCompleter(&ast_context, *this);
   }
 }
 
if (!context.m_found.type) {
               break;
             }
 
             context.AddNamedDecl(copied_named_decl);
 
             context.m_found.type = true;
           }
         }
-      } while (0);
+      } while (false);
     }
 
     if (!context.m_found.type) {
       do {
         // Couldn't find any types elsewhere.  Try the Objective-C runtime if
         // one exists.
 
         lldb::ProcessSP process(m_target->GetProcessSP());
if (!context.m_found.type) {
             log->Printf(
                 "  CAS::FEVD[%u] - Couldn't export a type from the runtime",
                 current_id);
 
           break;
         }
 
         context.AddNamedDecl(copied_named_decl);
-      } while (0);
+      } while (false);
     }
 
-  } while (0);
+  } while (false);
 }
 
 template <class D> class TaggedASTDecl {
 public:
   TaggedASTDecl() : decl(nullptr) {}
   TaggedASTDecl(D *_decl) : decl(_decl) {}
   bool IsValid() const { return (decl != nullptr); }
   bool IsInvalid() const { return !IsValid(); }
if (!original_decl)
       break;
 
     ObjCInterfaceDecl *original_interface_decl =
         dyn_cast<ObjCInterfaceDecl>(original_decl);
 
     if (FindObjCMethodDeclsWithOrigin(current_id, context,
                                       original_interface_decl, "at origin"))
       return; // found it, no need to look any further
-  } while (0);
+  } while (false);
 
   StreamString ss;
 
   if (decl_name.isObjCZeroArgSelector()) {
     ss.Printf("%s", decl_name.getAsString().c_str());
   } else if (decl_name.isObjCOneArgSelector()) {
     ss.Printf("%s", decl_name.getAsString().c_str());
   } else {
for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) {
       if (strncmp(cursor, interface_name.c_str(), interface_len))
         continue;
 
       cursor += interface_len;
 
       if (*cursor == ' ' || *cursor == '(')
         sc_list.Append(candidate_sc);
     }
-  } while (0);
+  } while (false);
 
   if (sc_list.GetSize()) {
     // We found a good function symbol.  Use that.
 
     for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) {
       SymbolContext sc;
 
       if (!sc_list.GetContextAtIndex(i, sc))
if (log)
                   "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
                   current_id, static_cast<void *>(complete_interface_decl),
                   static_cast<void *>(&complete_iface_decl->getASTContext()));
 
     FindObjCMethodDeclsWithOrigin(current_id, context, complete_interface_decl,
                                   "in debug info");
 
     return;
-  } while (0);
+  } while (false);
 
   do {
     // Check the modules only if the debug information didn't have a complete
     // interface.
 
     if (ClangModulesDeclVendor *modules_decl_vendor =
             m_target->GetClangModulesDeclVendor()) {
       ConstString interface_name(interface_decl->getNameAsString().c_str());
if (ClangModulesDeclVendor *modules_decl_vendor =
 
       if (!interface_decl_from_modules)
         break;
 
       if (FindObjCMethodDeclsWithOrigin(
               current_id, context, interface_decl_from_modules, "in modules"))
         return;
     }
-  } while (0);
+  } while (false);
 
   do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and the modules don't get us anywhere.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
     if (!process)
do {
     ObjCInterfaceDecl *runtime_interface_decl =
         dyn_cast<ObjCInterfaceDecl>(decls[0]);
 
     if (!runtime_interface_decl)
       break;
 
     FindObjCMethodDeclsWithOrigin(current_id, context, runtime_interface_decl,
                                   "in runtime");
-  } while (0);
+  } while (false);
 }
 
 static bool FindObjCPropertyAndIvarDeclsWithOrigin(
     unsigned int current_id, NameSearchContext &context, ClangASTSource &source,
     DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (origin_iface_decl.IsInvalid())
if (log)
                   current_id,
                   static_cast<const void *>(complete_iface_decl.decl),
                   static_cast<void *>(&complete_iface_decl->getASTContext()));
 
     FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
                                            complete_iface_decl);
 
     return;
-  } while (0);
+  } while (false);
 
   do {
     // Check the modules only if the debug information didn't have a complete
     // interface.
 
     ClangModulesDeclVendor *modules_decl_vendor =
         m_target->GetClangModulesDeclVendor();
 
if (log)
           "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
           current_id,
           static_cast<const void *>(interface_decl_from_modules.decl),
           static_cast<void *>(&interface_decl_from_modules->getASTContext()));
 
     if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
                                                interface_decl_from_modules))
       return;
-  } while (0);
+  } while (false);
 
   do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and nothing was in the modules.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
     if (!process)
if (log)
           "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
           current_id,
           static_cast<const void *>(interface_decl_from_runtime.decl),
           static_cast<void *>(&interface_decl_from_runtime->getASTContext()));
 
     if (FindObjCPropertyAndIvarDeclsWithOrigin(
             current_id, context, *this, interface_decl_from_runtime))
       return;
-  } while (0);
+  } while (false);
 }
 
 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap;
 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
 
 template <class D, class O>
 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
                             llvm::DenseMap<const D *, O> &source_map,

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

do {
         MaybeRegisterFunctionBody(parser_function_decl);
       }
 
       if (log)
         log->Printf("  CEDM::FEVD[%u] Found persistent decl %s", current_id,
                     name.GetCString());
 
       context.AddNamedDecl(parser_named_decl);
-    } while (0);
+    } while (false);
   }
 
   if (name.GetCString()[0] == '$' && !namespace_decl) {
     static ConstString g_lldb_class_name("$__lldb_class");
 
     if (name == g_lldb_class_name) {
       if (m_ctx_obj) {
         Status status;
if (!context.m_found.function_with_type_info) {
               break;
             }
 
             context.AddNamedDecl(copied_var_decl);
 
             context.m_found.variable = true;
           }
         }
-      } while (0);
+      } while (false);
     }
 
     if (target && !context.m_found.variable && !namespace_decl) {
       // We couldn't find a non-symbol variable for this.  Now we'll hunt for a
       // generic data symbol, and -- if it is found -- treat it as a variable.
       Status error;
 
       const Symbol *data_symbol =

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

bool EmulateInstructionARM64::EmulateADDSUBImm(const uint32_t opcode) {
   uint64_t result;
   uint64_t operand1 =
       ReadRegisterUnsigned(eRegisterKindLLDB, gpr_x0_arm64 + n, 0, &success);
   uint64_t operand2 = imm;
   bit carry_in;
 
   if (sub_op) {
     operand2 = NOT(operand2);
-    carry_in = 1;
+    carry_in = true;
     imm = -imm; // For the Register plug offset context below
   } else {
-    carry_in = 0;
+    carry_in = false;
   }
 
   ProcState proc_state;
 
   result = AddWithCarry(datasize, operand1, operand2, carry_in, proc_state);
 
   if (setflags) {
     m_emulated_pstate.N = proc_state.N;

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

std::function<bool(const char *, const char *, lldb::addr_t,
                        uint64_t)> const &ivar_func) const {
   lldb_private::Process *process = m_runtime.GetProcess();
 
   std::unique_ptr<objc_class_t> objc_class;
   std::unique_ptr<class_ro_t> class_ro;
   std::unique_ptr<class_rw_t> class_rw;
 
   if (!Read_objc_class(process, objc_class))
-    return 0;
+    return false;
   if (!Read_class_row(process, *objc_class, class_ro, class_rw))
-    return 0;
+    return false;
 
   static ConstString NSObject_name("NSObject");
 
   if (m_name != NSObject_name && superclass_func)
     superclass_func(objc_class->m_superclass);
 
   if (instance_method_func) {
     std::unique_ptr<method_list_t> base_method_list;

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

do {
 
       if (!m_decl_vendor.FinishDecl(non_const_interface_decl))
         break;
 
       clang::DeclContext::lookup_result result =
           non_const_interface_decl->lookup(name);
 
       return (result.size() != 0);
-    } while (0);
+    } while (false);
 
     SetNoExternalVisibleDeclsForName(decl_ctx, name);
     return false;
   }
 
   void CompleteType(clang::TagDecl *tag_decl) override {
     static unsigned int invocation_id = 0;
     unsigned int current_id = invocation_id++;
public:
   ObjCRuntimeMethodType(const char *types) : m_is_valid(false) {
     const char *cursor = types;
     enum ParserState { Start = 0, InType, InPos } state = Start;
     const char *type = nullptr;
     int brace_depth = 0;
 
     uint32_t stepsLeft = 256;
 
-    while (1) {
+    while (true) {
       if (--stepsLeft == 0) {
         m_is_valid = false;
         return;
       }
 
       switch (state) {
       case Start: {
         switch (*cursor) {
if (log) {
       ASTDumper dumper(new_iface_type);
       log->Printf("AOCTV::FT [%u] Created %s (isa 0x%" PRIx64 ")", current_id,
                   dumper.GetCString(), (uint64_t)isa);
     }
 
     decls.push_back(iface_decl);
     ret++;
     break;
-  } while (0);
+  } while (false);
 
   return ret;
 }
 
 clang::ExternalASTMerger::ImporterSource
 AppleObjCDeclVendor::GetImporterSource() {
         return {*m_ast_ctx.getASTContext(),
                 *m_ast_ctx.getFileManager(),
                 m_ast_ctx.GetOriginMap()
         };
 }

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (header.filetype == MH_PRELOAD) {
               break;
             os << os_env.os_type << min_os.major_version << '.'
                << min_os.minor_version << '.' << min_os.patch_version;
             triple.setOSName(os.str());
             if (!os_env.environment.empty())
               triple.setEnvironmentName(os_env.environment);
             return arch;
           }
-        } while (0);
+        } while (false);
         offset = cmd_offset + load_cmd.cmdsize;
       }
 
       if (header.filetype != MH_KEXT_BUNDLE) {
         // We didn't find a LC_VERSION_MIN load command and this isn't a KEXT
         // so lets not say our Vendor is Apple, leave it as an unspecified
         // unknown
         triple.setVendor(llvm::Triple::UnknownVendor);

source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp

#ifdef LLDB_CONFIGURATION_DEBUG
   assert(request_packet.GetSize() ==
          *((const uint16_t *)(request_packet.GetData() + 2)));
 #endif
   lldb::offset_t offset = 1;
   const uint32_t num_retries = 3;
   for (uint32_t i = 0; i < num_retries; ++i) {
     if (SendRequestPacketNoLock(request_packet)) {
       const uint8_t request_sequence_id = (uint8_t)request_packet.GetData()[1];
-      while (1) {
+      while (true) {
         if (WaitForPacketWithTimeoutMicroSecondsNoLock(
                 reply_packet,
                 std::chrono::microseconds(GetPacketTimeout()).count())) {
           offset = 0;
           const uint8_t reply_command = reply_packet.GetU8(&offset);
           const uint8_t reply_sequence_id = reply_packet.GetU8(&offset);
           if (request_sequence_id == reply_sequence_id) {
             // The sequent ID was correct, now verify we got the response we

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

bool DWARFASTParserClang::ParseChildMembers(
     const SymbolContext &sc, const DWARFDIE &parent_die,
     CompilerType &class_clang_type, const LanguageType class_language,
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
     std::vector<int> &member_accessibilities,
     std::vector<DWARFDIE> &member_function_dies,
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
-    return 0;
+    return false;
 
   // Get the parent byte size so we can verify any members will fit
   const uint64_t parent_byte_size =
       parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX);
   const uint64_t parent_bit_size =
       parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8;
 
   uint32_t member_idx = 0;
   BitfieldInfo last_field_info;
 
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
   ClangASTContext *ast =
       llvm::dyn_cast_or_null<ClangASTContext>(class_clang_type.GetTypeSystem());
   if (ast == nullptr)
-    return 0;
+    return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_member:
     case DW_TAG_APPLE_property: {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (!(orig_die.Tag() == DW_TAG_subprogram ||
         (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
     return false;
 
   DWARFDIE die = orig_die;
   DWARFDIE inlined_die;
   if (die.Tag() == DW_TAG_inlined_subroutine) {
     inlined_die = die;
 
-    while (1) {
+    while (true) {
       die = die.GetParent();
 
       if (die) {
         if (die.Tag() == DW_TAG_subprogram)
           break;
       } else
         break;
     }

source/Symbol/ClangASTContext.cpp

if (lhs_decl && rhs_decl) {
     const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
 
     if (lhs_decl_kind == rhs_decl_kind) {
       // Now check that the decl contexts kinds are all equivalent before we
       // have to check any names of the decl contexts...
       clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
       clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
       if (lhs_decl_ctx && rhs_decl_ctx) {
-        while (1) {
+        while (true) {
           if (lhs_decl_ctx && rhs_decl_ctx) {
             const clang::Decl::Kind lhs_decl_ctx_kind =
                 lhs_decl_ctx->getDeclKind();
             const clang::Decl::Kind rhs_decl_ctx_kind =
                 rhs_decl_ctx->getDeclKind();
             if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
               lhs_decl_ctx = lhs_decl_ctx->getParent();
               rhs_decl_ctx = rhs_decl_ctx->getParent();
if (lhs_decl_kind == rhs_decl_kind) {
             return false;
         } else
           return false;
 
         // We know that the decl context kinds all match, so now we need to
         // make sure the names match as well
         lhs_decl_ctx = lhs_decl->getDeclContext();
         rhs_decl_ctx = rhs_decl->getDeclContext();
-        while (1) {
+        while (true) {
           switch (lhs_decl_ctx->getDeclKind()) {
           case clang::Decl::TranslationUnit:
             // We don't care about the translation unit names
             return true;
           default: {
             clang::NamedDecl *lhs_named_decl =
                 llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
             clang::NamedDecl *rhs_named_decl =
default:
         return DumpDataExtractor(data, s, byte_offset, format, byte_size,
                                  item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
                                  bitfield_bit_size, bitfield_bit_offset,
                                  exe_scope);
       }
       break;
     }
   }
-  return 0;
+  return false;
 }
 
 void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
                                   ExecutionContext *exe_ctx, Stream *s,
                                   const lldb_private::DataExtractor &data,
                                   lldb::offset_t data_byte_offset,
                                   size_t data_byte_size) {
   uint32_t length = 0;

source/Symbol/ClangASTImporter.cpp

do {
       if (!imported_from_superclass)
         break;
 
       if (!to_objc_interface->hasDefinition())
         to_objc_interface->startDefinition();
 
       to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo(
           m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
-    } while (0);
+    } while (false);
   }
 }
 
 void ClangASTImporter::ASTImporterDelegate::Imported(clang::Decl *from,
                                                      clang::Decl *to) {
   ClangASTMetrics::RegisterClangImport();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

source/Symbol/CompilerType.cpp

if (IsValid())
     return m_type_system->IsFunctionPointerType(m_type);
   return false;
 }
 
 bool CompilerType::IsBlockPointerType(
     CompilerType *function_pointer_type_ptr) const {
   if (IsValid())
     return m_type_system->IsBlockPointerType(m_type, function_pointer_type_ptr);
-  return 0;
+  return false;
 }
 
 bool CompilerType::IsIntegerType(bool &is_signed) const {
   if (IsValid())
     return m_type_system->IsIntegerType(m_type, is_signed);
   return false;
 }
 

source/Symbol/Function.cpp

if (line_table) {
 
         const addr_t func_start_file_addr =
             m_range.GetBaseAddress().GetFileAddress();
         const addr_t func_end_file_addr =
             func_start_file_addr + m_range.GetByteSize();
 
         // Now calculate the offset to pass the subsequent line 0 entries.
         uint32_t first_non_zero_line = prologue_end_line_idx;
-        while (1) {
+        while (true) {
           LineEntry line_entry;
           if (line_table->GetLineEntryAtIndex(first_non_zero_line,
                                               line_entry)) {
             if (line_entry.line != 0)
               break;
           }
           if (line_entry.range.GetBaseAddress().GetFileAddress() >=
               func_end_file_addr)

source/Symbol/SymbolContext.cpp

if (line_entry.line > end_line) {
     error.SetErrorStringWithFormat(
         "end line option %d must be after the current line: %d", end_line,
         line_entry.line);
     return false;
   }
 
   uint32_t line_index = 0;
   bool found = false;
-  while (1) {
+  while (true) {
     LineEntry this_line;
     line_index = comp_unit->FindLineEntry(line_index, line_entry.line, nullptr,
                                           false, &this_line);
     if (line_index == UINT32_MAX)
       break;
     if (LineEntry::Compare(this_line, line_entry) == 0) {
       found = true;
       break;

source/Target/Process.cpp

if (return_value == eExpressionInterrupted ||
                 if (stop_desc)
                   ts.PutCString(stop_desc);
               }
               ts.Printf(">");
             }
 
             event_explanation = ts.GetData();
           }
-        } while (0);
+        } while (false);
 
         if (event_explanation)
           log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s",
                       s.GetData(), event_explanation);
         else
           log->Printf("Process::RunThreadPlan(): execution interrupted: %s",
                       s.GetData());
       }

source/Target/Target.cpp

 }
 
 size_t Target::ReadCStringFromMemory(const Address &addr, std::string &out_str,
                                      Status &error) {
   char buf[256];
   out_str.clear();
   addr_t curr_addr = addr.GetLoadAddress(this);
   Address address(addr);
-  while (1) {
+  while (true) {
     size_t length = ReadCStringFromMemory(address, buf, sizeof(buf), error);
     if (length == 0)
       break;
     out_str.append(buf, length);
     // If we got "length - 1" bytes, we didn't get the whole C string, we need
     // to read some more characters
     if (length == sizeof(buf) - 1)
       curr_addr += length;

source/Target/Thread.cpp

if (!done_processing_current_plan) {
     if (PlanIsBasePlan(current_plan)) {
       should_stop = current_plan->ShouldStop(event_ptr);
       if (log)
         log->Printf("Base plan says should stop: %i.", should_stop);
     } else {
       // Otherwise, don't let the base plan override what the other plans say
       // to do, since presumably if there were other plans they would know what
       // to do...
-      while (1) {
+      while (true) {
         if (PlanIsBasePlan(current_plan))
           break;
 
         should_stop = current_plan->ShouldStop(event_ptr);
         if (log)
           log->Printf("Plan %s should stop: %d.", current_plan->GetName(),
                       should_stop);
         if (current_plan->MischiefManaged()) {
if (m_completed_plan_stack.size() > 0) {
     if (log)
       log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
                   ": returning vote  for complete stack's back plan",
                   GetID());
     return m_completed_plan_stack.back()->ShouldReportStop(event_ptr);
   } else {
     Vote thread_vote = eVoteNoOpinion;
     ThreadPlan *plan_ptr = GetCurrentPlan();
-    while (1) {
+    while (true) {
       if (plan_ptr->PlanExplainsStop(event_ptr)) {
         thread_vote = plan_ptr->ShouldReportStop(event_ptr);
         break;
       }
       if (PlanIsBasePlan(plan_ptr))
         break;
       else
         plan_ptr = GetPreviousPlan(plan_ptr);
void Thread::DiscardThreadPlans(bool force) {
   if (force) {
     int stack_size = m_plan_stack.size();
     for (int i = stack_size - 1; i > 0; i--) {
       DiscardPlan();
     }
     return;
   }
 
-  while (1) {
+  while (true) {
     int master_plan_idx;
     bool discard = true;
 
     // Find the first master plan, see if it wants discarding, and if yes
     // discard up to it.
     for (master_plan_idx = m_plan_stack.size() - 1; master_plan_idx >= 0;
          master_plan_idx--) {
       if (m_plan_stack[master_plan_idx]->IsMasterPlan()) {
if (!abi) {
       return_error.SetErrorString("Could not find ABI to set return value.");
       return return_error;
     }
     SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextFunction);
 
     // FIXME: ValueObject::Cast doesn't currently work correctly, at least not
     // for scalars.
     // Turn that back on when that works.
-    if (/* DISABLES CODE */ (0) && sc.function != nullptr) {
+    if (/* DISABLES CODE */ (false) && sc.function != nullptr) {
       Type *function_type = sc.function->GetType();
       if (function_type) {
         CompilerType return_type =
             sc.function->GetCompilerType().GetFunctionReturnType();
         if (return_type) {
           StreamString s;
           return_type.DumpTypeDescription(&s);
           ValueObjectSP cast_value_sp = return_value_sp->Cast(return_type);

source/Utility/JSON.cpp

JSONParser::Token JSONParser::GetToken(std::string &value) {
   case 'n':
     if (GetChar() == 'u')
       if (GetChar() == 'l')
         if (GetChar() == 'l')
           return Token::Null;
     break;
 
   case '"': {
-    while (1) {
+    while (true) {
       bool was_escaped = false;
       int escaped_ch = GetEscapedChar(was_escaped);
       if (escaped_ch == -1) {
         error.Printf(
             "error: an error occurred getting a character from offset %" PRIu64,
             start_index);
         value = std::move(error.GetString());
         return Token::Status;

 
 JSONValue::SP JSONParser::ParseJSONObject() {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
   std::unique_ptr<JSONObject> dict_up(new JSONObject());
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     JSONParser::Token token = GetToken(value);
 
     if (token == JSONParser::Token::String) {
       key.swap(value);
       token = GetToken(value);
       if (token == JSONParser::Token::Colon) {
         JSONValue::SP value_sp = ParseJSONValue();
         if (value_sp)

 
 JSONValue::SP JSONParser::ParseJSONArray() {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
   std::unique_ptr<JSONArray> array_up(new JSONArray());
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     JSONValue::SP value_sp = ParseJSONValue();
     if (value_sp)
       array_up->AppendObject(value_sp);
     else
       break;
 
     JSONParser::Token token = GetToken(value);
     if (token == JSONParser::Token::Comma) {

source/Utility/SelectHelper.cpp

for (auto &pair : m_fd_map) {
     if (pair.second.error_set)
       FD_SET(fd, error_fdset_ptr);
   }
 
   // Setup our timeout time value if needed
   struct timeval *tv_ptr = nullptr;
   struct timeval tv = {0, 0};
 
-  while (1) {
+  while (true) {
     using namespace std::chrono;
     // Setup out relative timeout based on the end time if we have one
     if (m_end_time.hasValue()) {
       tv_ptr = &tv;
       const auto remaining_dur = duration_cast<microseconds>(
           m_end_time.getValue() - steady_clock::now());
       if (remaining_dur.count() > 0) {
         // Wait for a specific amount of time

source/Utility/StructuredData.cpp

 
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
   auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     JSONParser::Token token = json_parser.GetToken(value);
 
     if (token == JSONParser::Token::String) {
       key.swap(value);
       token = json_parser.GetToken(value);
       if (token == JSONParser::Token::Colon) {
         StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
         if (value_sp)

 
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
   auto array_up = llvm::make_unique<StructuredData::Array>();
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
     if (value_sp)
       array_up->AddItem(value_sp);
     else
       break;
 
     JSONParser::Token token = json_parser.GetToken(value);
     if (token == JSONParser::Token::Comma) {

tools/debugserver/source/DNB.cpp

if (pthread_getschedparam(pthread_self(), &thread_sched_policy,
                             &thread_param) == 0) {
     thread_param.sched_priority = 47;
     pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
   }
 #endif
 #endif
 
   struct kevent death_event;
-  while (1) {
+  while (true) {
     int n_events = kevent(kq_id, NULL, 0, &death_event, 1, NULL);
     if (n_events == -1) {
       if (errno == EINTR)
         continue;
       else {
         DNBLogError("kqueue failed with error: (%d): %s", errno,
                     strerror(errno));
         return NULL;
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   if (pthread_getschedparam(pthread_self(), &thread_sched_policy,
                             &thread_param) == 0) {
     thread_param.sched_priority = 47;
     pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
   }
 #endif
 #endif
 
-  while (1) {
+  while (true) {
     pid_t child_pid = waitpid(pid, &status, 0);
     DNBLogThreadedIf(LOG_PROCESS, "waitpid_thread (): waitpid (pid = %i, "
                                   "&status, 0) => %i, status = %i, errno = %i",
                      pid, child_pid, status, errno);
 
     if (child_pid < 0) {
       if (errno == EINTR)
         continue;

tools/debugserver/source/JSON.cpp

JSONParser::Token JSONParser::GetToken(std::string &value) {
   case 'n':
     if (GetChar() == 'u')
       if (GetChar() == 'l')
         if (GetChar() == 'l')
           return Token::Null;
     break;
 
   case '"': {
-    while (1) {
+    while (true) {
       bool was_escaped = false;
       int escaped_ch = GetEscapedChar(was_escaped);
       if (escaped_ch == -1) {
         error << "error: an error occurred getting a character from offset "
               << start_index;
         value = error.str();
         return Token::Status;
 

 JSONValue::SP JSONParser::ParseJSONObject() {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed
   // by the time this function is called
   std::unique_ptr<JSONObject> dict_up(new JSONObject());
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     JSONParser::Token token = GetToken(value);
 
     if (token == JSONParser::Token::String) {
       key.swap(value);
       token = GetToken(value);
       if (token == JSONParser::Token::Colon) {
         JSONValue::SP value_sp = ParseJSONValue();
         if (value_sp)

 JSONValue::SP JSONParser::ParseJSONArray() {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed
   // by the time this function is called
   std::unique_ptr<JSONArray> array_up(new JSONArray());
 
   std::string value;
   std::string key;
-  while (1) {
+  while (true) {
     JSONValue::SP value_sp = ParseJSONValue();
     if (value_sp)
       array_up->AppendObject(value_sp);
     else
       break;
 
     JSONParser::Token token = GetToken(value);
     if (token == JSONParser::Token::Comma) {

tools/debugserver/source/MacOSX/MachThreadList.cpp

if (thread_sp)
     return thread_sp->SaveRegisterState();
   return 0;
 }
 
 bool MachThreadList::RestoreRegisterState(nub_thread_t tid, uint32_t save_id) {
   MachThreadSP thread_sp(GetThreadByID(tid));
   if (thread_sp)
     return thread_sp->RestoreRegisterState(save_id);
-  return 0;
+  return false;
 }
 
 nub_size_t MachThreadList::NumThreads() const {
   PTHREAD_MUTEX_LOCKER(locker, m_threads_mutex);
   return m_threads.size();
 }
 
 nub_thread_t MachThreadList::ThreadIDAtIndex(nub_size_t idx) const {

tools/debugserver/source/RNBRemote.cpp

if (name == "enable") {
       uint32_t int_value = 0;
       if (iss >> std::hex >> int_value) {
         scan_type = (DNBProfileDataScanType)int_value;
       }
     }
   }
 
   if (interval_usec == 0) {
-    enable = 0;
+    enable = false;
   }
 
   DNBProcessSetEnableAsyncProfiling(pid, enable, interval_usec, scan_type);
   return SendPacket("OK");
 }
 
 // QEnableCompression:type:<COMPRESSION-TYPE>;minsize:<MINIMUM PACKET SIZE TO
 // COMPRESS>;
if (*c == ':') {
              (*c == ' ' || *c == '\t' || *c == '\n' || *c == '\r'))
         c++;
 
       if (*c == '[') {
         c++;
         while (*c != '\0' &&
                (*c == ' ' || *c == '\t' || *c == '\n' || *c == '\r'))
           c++;
-        while (1) {
+        while (true) {
           if (!isdigit(*c)) {
             return true;
           }
 
           errno = 0;
           char *endptr;
           uint64_t value = strtoul(c, &endptr, 10);
           if (errno == 0) {
#endif
           DNBDataRef data(arg_data, arg_data_size, false);
           DNBDataRef::offset_t offset = 0;
           uint32_t argc = data.Get32(&offset);
           const char *cstr;
 
           cstr = data.GetCStr(&offset);
           if (cstr) {
             // Skip NULLs
-            while (1) {
+            while (true) {
               const char *p = data.PeekCStr(offset);
               if ((p == NULL) || (*p != '\0'))
                 break;
               ++offset;
             }
             // Now skip all arguments
             for (uint32_t i = 0; i < argc; ++i) {
               data.GetCStr(&offset);

tools/debugserver/source/debugserver.cpp

RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemote *remote) {
   std::string packet;
 
   if (remote) {
     RNBContext &ctx = remote->Context();
     uint32_t event_mask = RNBContext::event_read_packet_available |
                           RNBContext::event_read_thread_exiting;
 
     // Spin waiting to get the A packet.
-    while (1) {
+    while (true) {
       DNBLogThreadedIf(LOG_RNB_MAX,
                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) ...",
                        __FUNCTION__, event_mask);
       nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
       DNBLogThreadedIf(LOG_RNB_MAX,
                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) => 0x%08x",
                        __FUNCTION__, event_mask, set_events);
 

tools/debugserver/source/libdebugserver.cpp

RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemoteSP &remoteSP) {
   std::string packet;
 
   if (remoteSP.get() != NULL) {
     RNBRemote *remote = remoteSP.get();
     RNBContext &ctx = remote->Context();
     uint32_t event_mask = RNBContext::event_read_packet_available;
 
     // Spin waiting to get the A packet.
-    while (1) {
+    while (true) {
       DNBLogThreadedIf(LOG_RNB_MAX,
                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) ...",
                        __FUNCTION__, event_mask);
       nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
       DNBLogThreadedIf(LOG_RNB_MAX,
                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) => 0x%08x",
                        __FUNCTION__, event_mask, set_events);