[lldb] Use std::size instead of llvm::array_lengthof

[jloser]

Summary

LLVM contains a helpful function for getting the size of a C-style
array: llvm::array_lengthof. This is useful prior to C++17, but not as
helpful for C++17 or later: std::size already has support for C-style
arrays.

Change call sites to use std::size instead.

[JDevlieghere]

LGTM

lldb/source/DataFormatters/FormatManager.cpp

static constexpr FormatInfo g_format_infos[] = {
     {eFormatVoid, 'v', "void"},
     {eFormatUnicode8, 'u', "unicode8"},
 };
 
 static_assert((sizeof(g_format_infos) / sizeof(g_format_infos[0])) ==
                   kNumFormats,
               "All formats must have a corresponding info entry.");
 
-static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos);
+static uint32_t g_num_format_infos = std::size(g_format_infos);
 
 static bool GetFormatFromFormatChar(char format_char, Format &format) {
   for (uint32_t i = 0; i < g_num_format_infos; ++i) {
     if (g_format_infos[i].format_char == format_char) {
       format = g_format_infos[i].format;
       return true;
     }
   }

lldb/source/Host/posix/MainLoopPosix.cpp

 
 Status MainLoopPosix::RunImpl::Poll() {
   in_events.resize(loop.m_read_fds.size());
   unsigned i = 0;
   for (auto &fd : loop.m_read_fds)
     EV_SET(&in_events[i++], fd.first, EVFILT_READ, EV_ADD, 0, 0, 0);
 
   num_events = kevent(loop.m_kqueue, in_events.data(), in_events.size(),
-                      out_events, llvm::array_lengthof(out_events), nullptr);
+                      out_events, std::size(out_events), nullptr);
 
   if (num_events < 0) {
     if (errno == EINTR) {
       // in case of EINTR, let the main loop run one iteration
       // we need to zero num_events to avoid assertions failing
       num_events = 0;
     } else
       return Status(errno, eErrorTypePOSIX);

lldb/source/Host/windows/ConnectionGenericFileWindows.cpp

if (result || ::GetLastError() == ERROR_IO_PENDING) {
     if (!result) {
       // The expected return path.  The operation is pending.  Wait for the
       // operation to complete or be interrupted.
       DWORD milliseconds =
           timeout
               ? std::chrono::duration_cast<std::chrono::milliseconds>(*timeout)
                     .count()
               : INFINITE;
-      DWORD wait_result =
-          ::WaitForMultipleObjects(llvm::array_lengthof(m_event_handles),
-                                   m_event_handles, FALSE, milliseconds);
+      DWORD wait_result = ::WaitForMultipleObjects(
+          std::size(m_event_handles), m_event_handles, FALSE, milliseconds);
       // All of the events are manual reset events, so make sure we reset them
       // to non-signalled.
       switch (wait_result) {
       case WAIT_OBJECT_0 + kBytesAvailableEvent:
         break;
       case WAIT_OBJECT_0 + kInterruptEvent:
         return_info.Set(0, eConnectionStatusInterrupted, 0);
         goto finish;

lldb/source/Interpreter/CommandInterpreter.cpp

const char *break_regexes[][2] = {
       {"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$",
        "breakpoint set --name '%2' --shlib '%1'"},
       {"^\\&(.*[^[:space:]])[[:space:]]*$",
        "breakpoint set --name '%1' --skip-prologue=0"},
       {"^[\"']?(.*[^[:space:]\"'])[\"']?[[:space:]]*$",
        "breakpoint set --name '%1'"}};
   // clang-format on
 
-  size_t num_regexes = llvm::array_lengthof(break_regexes);
+  size_t num_regexes = std::size(break_regexes);
 
   std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_up(
       new CommandObjectRegexCommand(
           *this, "_regexp-break",
           "Set a breakpoint using one of several shorthand formats.",
           "\n"
           "_regexp-break <filename>:<linenum>:<colnum>\n"
           "              main.c:12:21          // Break at line 12 and column "

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
      }};
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
+static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;
 }
 
 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
 
   RegisterValue reg_value;
 
   const char *reg_names[] = {"r0", "r1", "r2", "r3"};
 
   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
 
-  for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
+  for (size_t i = 0; i < std::size(reg_names); ++i) {
     if (ai == ae)
       break;
 
     reg_value.SetUInt32(*ai);
     if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
                                 reg_value))
       return false;
 

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
      }};
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
+static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_arm::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;
 }
 
 size_t ABISysV_arm::GetRedZoneSize() const { return 0; }
bool ABISysV_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
   RegisterValue reg_value;
 
   const uint8_t reg_names[] = {
       LLDB_REGNUM_GENERIC_ARG1, LLDB_REGNUM_GENERIC_ARG2,
       LLDB_REGNUM_GENERIC_ARG3, LLDB_REGNUM_GENERIC_ARG4};
 
   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
 
-  for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
+  for (size_t i = 0; i < std::size(reg_names); ++i) {
     if (ai == ae)
       break;
 
     reg_value.SetUInt32(*ai);
     if (!reg_ctx->WriteRegister(
             reg_ctx->GetRegisterInfo(eRegisterKindGeneric, reg_names[i]),
             reg_value))
       return false;

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

static const RegisterInfo g_register_infos[] = {
      eFormatHex,
      {dwarf_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
     },
 };
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
+static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_mips::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;
 }
 
 size_t ABISysV_mips::GetRedZoneSize() const { return 0; }
bool ABISysV_mips::PrepareTrivialCall(Thread &thread, addr_t sp,
   RegisterValue reg_value;
 
   // Argument registers
   const char *reg_names[] = {"r4", "r5", "r6", "r7"};
 
   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
 
   // Write arguments to registers
-  for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
+  for (size_t i = 0; i < std::size(reg_names); ++i) {
     if (ai == ae)
       break;
 
     reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
                                         LLDB_REGNUM_GENERIC_ARG1 + i);
     LLDB_LOGF(log, "About to write arg%zd (0x%" PRIx64 ") into %s", i + 1,
               args[i], reg_info->name);
 

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

static const RegisterInfo g_register_infos_mips64[] = {
      eFormatHex,
      {dwarf_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
     },
 };
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos_mips64);
+static const uint32_t k_num_register_infos = std::size(g_register_infos_mips64);
 
 const lldb_private::RegisterInfo *
 ABISysV_mips64::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos_mips64;
 }
 
 size_t ABISysV_mips64::GetRedZoneSize() const { return 0; }

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

static const RegisterInfo g_register_infos[] = {
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_cfa, dwarf_cfa, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
      }};
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
+static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_ppc::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;
 }
 
 size_t ABISysV_ppc::GetRedZoneSize() const { return 224; }

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ABISysV_ppc64)
 
 const lldb_private::RegisterInfo *
 ABISysV_ppc64::GetRegisterInfoArray(uint32_t &count) {
   if (GetByteOrder() == lldb::eByteOrderLittle) {
-    count = llvm::array_lengthof(g_register_infos_ppc64le);
+    count = std::size(g_register_infos_ppc64le);
     return g_register_infos_ppc64le;
   } else {
-    count = llvm::array_lengthof(g_register_infos_ppc64);
+    count = std::size(g_register_infos_ppc64);
     return g_register_infos_ppc64;
   }
 }
 
 size_t ABISysV_ppc64::GetRedZoneSize() const { return 224; }
 
 lldb::ByteOrder ABISysV_ppc64::GetByteOrder() const {
   return GetProcessSP()->GetByteOrder();

lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.cpp

static const RegisterInfo g_register_infos[] = {
     DEFINE_REG(f10, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(f11, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(f12, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(f13, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(f14, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(f15, 8, nullptr, LLDB_INVALID_REGNUM),
 };
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
+static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_s390x::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;
 }
 
 size_t ABISysV_s390x::GetRedZoneSize() const { return 0; }

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (process->ReadMemory(addr, &header, sizeof(header), error) !=
     if (read_error)
       *read_error = true;
     return false;
   }
 
   const uint32_t magicks[] = { llvm::MachO::MH_MAGIC_64, llvm::MachO::MH_MAGIC, llvm::MachO::MH_CIGAM, llvm::MachO::MH_CIGAM_64};
 
   bool found_matching_pattern = false;
-  for (size_t i = 0; i < llvm::array_lengthof (magicks); i++)
+  for (size_t i = 0; i < std::size(magicks); i++)
     if (::memcmp (&header.magic, &magicks[i], sizeof (uint32_t)) == 0)
         found_matching_pattern = true;
 
   if (!found_matching_pattern)
     return false;
 
   if (header.magic == llvm::MachO::MH_CIGAM ||
       header.magic == llvm::MachO::MH_CIGAM_64) {

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

static ARMOpcode g_arm_opcodes[] = {
       {0x0fff00f0, 0x06ef0070, ARMV6_ABOVE, eEncodingA1, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateUXTB, "uxtb<c> <Rd>,<Rm>{,<rotation>}"},
       {0x0fff00f0, 0x06ff0070, ARMV6_ABOVE, eEncodingA1, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateUXTH, "uxth<c> <Rd>,<Rm>{,<rotation>}"},
       {0xfe500000, 0xf8100000, ARMV6_ABOVE, eEncodingA1, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateRFE, "rfe{<amode>} <Rn>{!}"}
 
   };
-  static const size_t k_num_arm_opcodes = llvm::array_lengthof(g_arm_opcodes);
+  static const size_t k_num_arm_opcodes = std::size(g_arm_opcodes);
 
   for (size_t i = 0; i < k_num_arm_opcodes; ++i) {
     if ((g_arm_opcodes[i].mask & opcode) == g_arm_opcodes[i].value &&
         (g_arm_opcodes[i].variants & arm_isa) != 0)
       return &g_arm_opcodes[i];
   }
   return nullptr;
 }
static ARMOpcode g_thumb_opcodes[] = {
       {0xfffff080, 0xfa5ff080, ARMV6T2_ABOVE, eEncodingT2, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateUXTB, "uxtb<c>.w <Rd>,<Rm>{,<rotation>}"},
       {0xffffffc0, 0x0000b280, ARMV6_ABOVE, eEncodingT1, No_VFP, eSize16,
        &EmulateInstructionARM::EmulateUXTH, "uxth<c> <Rd>,<Rm>"},
       {0xfffff080, 0xfa1ff080, ARMV6T2_ABOVE, eEncodingT2, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateUXTH, "uxth<c>.w <Rd>,<Rm>{,<rotation>}"},
   };
 
-  const size_t k_num_thumb_opcodes = llvm::array_lengthof(g_thumb_opcodes);
+  const size_t k_num_thumb_opcodes = std::size(g_thumb_opcodes);
   for (size_t i = 0; i < k_num_thumb_opcodes; ++i) {
     if ((g_thumb_opcodes[i].mask & opcode) == g_thumb_opcodes[i].value &&
         (g_thumb_opcodes[i].variants & arm_isa) != 0)
       return &g_thumb_opcodes[i];
   }
   return nullptr;
 }
 

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

 #include "Plugins/Process/Utility/InstructionUtils.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE_ADV(EmulateInstructionARM64, InstructionARM64)
 
 static bool LLDBTableGetRegisterInfo(uint32_t reg_num, RegisterInfo &reg_info) {
-  if (reg_num >= llvm::array_lengthof(g_register_infos_arm64_le))
+  if (reg_num >= std::size(g_register_infos_arm64_le))
     return false;
   reg_info = g_register_infos_arm64_le[reg_num];
   return true;
 }
 
 #define No_VFP 0
 #define VFPv1 (1u << 1)
 #define VFPv2 (1u << 2)
static EmulateInstructionARM64::Opcode g_opcodes[] = {
       {0x7f000000, 0x35000000, No_VFP, &EmulateInstructionARM64::EmulateCBZ,
        "CBNZ <Wt>, <label>"},
       {0x7f000000, 0x36000000, No_VFP, &EmulateInstructionARM64::EmulateTBZ,
        "TBZ <R><t>, #<imm>, <label>"},
       {0x7f000000, 0x37000000, No_VFP, &EmulateInstructionARM64::EmulateTBZ,
        "TBNZ <R><t>, #<imm>, <label>"},
 
   };
-  static const size_t k_num_arm_opcodes = llvm::array_lengthof(g_opcodes);
+  static const size_t k_num_arm_opcodes = std::size(g_opcodes);
 
   for (size_t i = 0; i < k_num_arm_opcodes; ++i) {
     if ((g_opcodes[i].mask & opcode) == g_opcodes[i].value)
       return &g_opcodes[i];
   }
   return nullptr;
 }
 

lldb/source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp

EmulateInstructionPPC64::CreateInstance(const ArchSpec &arch,
   return nullptr;
 }
 
 bool EmulateInstructionPPC64::SetTargetTriple(const ArchSpec &arch) {
   return arch.GetTriple().isPPC64();
 }
 
 static bool LLDBTableGetRegisterInfo(uint32_t reg_num, RegisterInfo &reg_info) {
-  if (reg_num >= llvm::array_lengthof(g_register_infos_ppc64le))
+  if (reg_num >= std::size(g_register_infos_ppc64le))
     return false;
   reg_info = g_register_infos_ppc64le[reg_num];
   return true;
 }
 
 bool EmulateInstructionPPC64::GetRegisterInfo(RegisterKind reg_kind,
                                               uint32_t reg_num,
                                               RegisterInfo &reg_info) {
static EmulateInstructionPPC64::Opcode g_opcodes[] = {
       {0xfc000003, 0xf8000001, &EmulateInstructionPPC64::EmulateSTD,
        "stdu RS, DS(RA)"},
       {0xfc0007fe, 0x7c000378, &EmulateInstructionPPC64::EmulateOR,
        "or RA, RS, RB"},
       {0xfc000000, 0x38000000, &EmulateInstructionPPC64::EmulateADDI,
        "addi RT, RA, SI"},
       {0xfc000003, 0xe8000000, &EmulateInstructionPPC64::EmulateLD,
        "ld RT, DS(RA)"}};
-  static const size_t k_num_ppc_opcodes = llvm::array_lengthof(g_opcodes);
+  static const size_t k_num_ppc_opcodes = std::size(g_opcodes);
 
   for (size_t i = 0; i < k_num_ppc_opcodes; ++i) {
     if ((g_opcodes[i].mask & opcode) == g_opcodes[i].value)
       return &g_opcodes[i];
   }
   return nullptr;
 }
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

AppleObjCTrampolineHandler::AppleObjCTrampolineHandler(
 
   // Look up the addresses for the objc dispatch functions and cache
   // them.  For now I'm inspecting the symbol names dynamically to
   // figure out how to dispatch to them.  If it becomes more
   // complicated than this we can turn the g_dispatch_functions char *
   // array into a template table, and populate the DispatchFunction
   // map from there.
 
-  for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++) {
+  for (size_t i = 0; i != std::size(g_dispatch_functions); i++) {
     ConstString name_const_str(g_dispatch_functions[i].name);
     const Symbol *msgSend_symbol =
         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
                                                          eSymbolTypeCode);
     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
       // FIXME: Make g_dispatch_functions static table of
       // DispatchFunctions, and have the map be address->index.
       // Problem is we also need to lookup the dispatch function.  For
       // now we could have a side table of stret & non-stret dispatch
       // functions.  If that's as complex as it gets, we're fine.
 
       lldb::addr_t sym_addr =
           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
 
       m_msgSend_map.insert(std::pair<lldb::addr_t, int>(sym_addr, i));
     }
   }
-  
   // Similarly, cache the addresses of the "optimized dispatch" function.
-  for (size_t i = 0; i != llvm::array_lengthof(g_opt_dispatch_names); i++) {
+  for (size_t i = 0; i != std::size(g_opt_dispatch_names); i++) {
     ConstString name_const_str(g_opt_dispatch_names[i]);
     const Symbol *msgSend_symbol =
         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
                                                          eSymbolTypeCode);
     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
       lldb::addr_t sym_addr =
           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
 

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (section_header_data.ValidOffsetForDataOfSize(
       }
     }
   }
 
   return !m_sect_headers.empty();
 }
 
 llvm::StringRef ObjectFilePECOFF::GetSectionName(const section_header_t &sect) {
-  llvm::StringRef hdr_name(sect.name, llvm::array_lengthof(sect.name));
+  llvm::StringRef hdr_name(sect.name, std::size(sect.name));
   hdr_name = hdr_name.split('\0').first;
   if (hdr_name.consume_front("/")) {
     lldb::offset_t stroff;
     if (!to_integer(hdr_name, stroff, 10))
       return "";
     lldb::offset_t string_file_offset =
         m_coff_header.symoff + (m_coff_header.nsyms * 18) + stroff;
     if (const char *name = m_data.GetCStr(&string_file_offset))

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

 
 uint32_t EHProgramBuilder::ConvertMachineToLLDBRegister(uint8_t machine_reg) {
   static uint32_t machine_to_lldb_register[] = {
       lldb_rax_x86_64, lldb_rcx_x86_64, lldb_rdx_x86_64, lldb_rbx_x86_64,
       lldb_rsp_x86_64, lldb_rbp_x86_64, lldb_rsi_x86_64, lldb_rdi_x86_64,
       lldb_r8_x86_64,  lldb_r9_x86_64,  lldb_r10_x86_64, lldb_r11_x86_64,
       lldb_r12_x86_64, lldb_r13_x86_64, lldb_r14_x86_64, lldb_r15_x86_64};
 
-  if (machine_reg >= llvm::array_lengthof(machine_to_lldb_register))
+  if (machine_reg >= std::size(machine_to_lldb_register))
     return LLDB_INVALID_REGNUM;
 
   return machine_to_lldb_register[machine_reg];
 }
 
 uint32_t EHProgramBuilder::ConvertXMMToLLDBRegister(uint8_t xmm_reg) {
   static uint32_t xmm_to_lldb_register[] = {
       lldb_xmm0_x86_64,  lldb_xmm1_x86_64,  lldb_xmm2_x86_64,
       lldb_xmm3_x86_64,  lldb_xmm4_x86_64,  lldb_xmm5_x86_64,
       lldb_xmm6_x86_64,  lldb_xmm7_x86_64,  lldb_xmm8_x86_64,
       lldb_xmm9_x86_64,  lldb_xmm10_x86_64, lldb_xmm11_x86_64,
       lldb_xmm12_x86_64, lldb_xmm13_x86_64, lldb_xmm14_x86_64,
       lldb_xmm15_x86_64};
 
-  if (xmm_reg >= llvm::array_lengthof(xmm_to_lldb_register))
+  if (xmm_reg >= std::size(xmm_to_lldb_register))
     return LLDB_INVALID_REGNUM;
 
   return xmm_to_lldb_register[xmm_reg];
 }
 
 bool EHProgramBuilder::ProcessUnwindCode(UnwindCode code) {
   uint8_t o = m_iterator.IsChained() ? 0 : code.u.CodeOffset;
   uint8_t unwind_operation = code.getUnwindOp();

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

BreakpointSP PlatformDarwin::SetThreadCreationBreakpoint(Target &target) {
   static const char *g_bp_names[] = {
       "start_wqthread", "_pthread_wqthread", "_pthread_start",
   };
 
   static const char *g_bp_modules[] = {"libsystem_c.dylib",
                                        "libSystem.B.dylib"};
 
   FileSpecList bp_modules;
-  for (size_t i = 0; i < llvm::array_lengthof(g_bp_modules); i++) {
+  for (size_t i = 0; i < std::size(g_bp_modules); i++) {
     const char *bp_module = g_bp_modules[i];
     bp_modules.EmplaceBack(bp_module);
   }
 
   bool internal = true;
   bool hardware = false;
   LazyBool skip_prologue = eLazyBoolNo;
   bp_sp = target.CreateBreakpoint(&bp_modules, nullptr, g_bp_names,
-                                  llvm::array_lengthof(g_bp_names),
-                                  eFunctionNameTypeFull, eLanguageTypeUnknown,
-                                  0, skip_prologue, internal, hardware);
+                                  std::size(g_bp_names), eFunctionNameTypeFull,
+                                  eLanguageTypeUnknown, 0, skip_prologue,
+                                  internal, hardware);
   bp_sp->SetBreakpointKind("thread-creation");
 
   return bp_sp;
 }
 
 uint32_t
 PlatformDarwin::GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) {
   const FileSpec &shell = launch_info.GetShell();

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

 };
 
 // Exception registers
 
 static uint32_t g_exc_regnums[] = {
     exc_exception, exc_fsr, exc_far,
 };
 
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
+static size_t k_num_register_infos = std::size(g_register_infos);
 
 RegisterContextDarwin_arm::RegisterContextDarwin_arm(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
size_t RegisterContextDarwin_arm::GetRegisterInfosCount() {
   return k_num_register_infos;
 }
 
 const RegisterInfo *RegisterContextDarwin_arm::GetRegisterInfos() {
   return g_register_infos;
 }
 
 // Number of registers in each register set
-const size_t k_num_gpr_registers = llvm::array_lengthof(g_gpr_regnums);
-const size_t k_num_fpu_registers = llvm::array_lengthof(g_fpu_regnums);
-const size_t k_num_exc_registers = llvm::array_lengthof(g_exc_regnums);
+const size_t k_num_gpr_registers = std::size(g_gpr_regnums);
+const size_t k_num_fpu_registers = std::size(g_fpu_regnums);
+const size_t k_num_exc_registers = std::size(g_exc_regnums);
 
 // Register set definitions. The first definitions at register set index of
 // zero is for all registers, followed by other registers sets. The register
 // information for the all register set need not be filled in.
 static const RegisterSet g_reg_sets[] = {
     {
         "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums,
     },
     {"Floating Point Registers", "fpu", k_num_fpu_registers, g_fpu_regnums},
     {"Exception State Registers", "exc", k_num_exc_registers, g_exc_regnums}};
 
-const size_t k_num_regsets = llvm::array_lengthof(g_reg_sets);
+const size_t k_num_regsets = std::size(g_reg_sets);
 
 size_t RegisterContextDarwin_arm::GetRegisterSetCount() {
   return k_num_regsets;
 }
 
 const RegisterSet *RegisterContextDarwin_arm::GetRegisterSet(size_t reg_set) {
   if (reg_set < k_num_regsets)
     return &g_reg_sets[reg_set];

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

static uint32_t g_fpu_regnums[] = {
     fpu_v14, fpu_v15, fpu_v16, fpu_v17, fpu_v18,  fpu_v19, fpu_v20,
     fpu_v21, fpu_v22, fpu_v23, fpu_v24, fpu_v25,  fpu_v26, fpu_v27,
     fpu_v28, fpu_v29, fpu_v30, fpu_v31, fpu_fpsr, fpu_fpcr};
 
 // Exception registers
 
 static uint32_t g_exc_regnums[] = {exc_far, exc_esr, exc_exception};
 
-static size_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos_arm64_le);
+static size_t k_num_register_infos = std::size(g_register_infos_arm64_le);
 
 RegisterContextDarwin_arm64::RegisterContextDarwin_arm64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc(), dbg() {
   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
size_t RegisterContextDarwin_arm64::GetRegisterInfosCount() {
   return k_num_register_infos;
 }
 
 const RegisterInfo *RegisterContextDarwin_arm64::GetRegisterInfos() {
   return g_register_infos_arm64_le;
 }
 
 // Number of registers in each register set
-const size_t k_num_gpr_registers = llvm::array_lengthof(g_gpr_regnums);
-const size_t k_num_fpu_registers = llvm::array_lengthof(g_fpu_regnums);
-const size_t k_num_exc_registers = llvm::array_lengthof(g_exc_regnums);
+const size_t k_num_gpr_registers = std::size(g_gpr_regnums);
+const size_t k_num_fpu_registers = std::size(g_fpu_regnums);
+const size_t k_num_exc_registers = std::size(g_exc_regnums);
 
 // Register set definitions. The first definitions at register set index of
 // zero is for all registers, followed by other registers sets. The register
 // information for the all register set need not be filled in.
 static const RegisterSet g_reg_sets[] = {
     {
         "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums,
     },
     {"Floating Point Registers", "fpu", k_num_fpu_registers, g_fpu_regnums},
     {"Exception State Registers", "exc", k_num_exc_registers, g_exc_regnums}};
 
-const size_t k_num_regsets = llvm::array_lengthof(g_reg_sets);
+const size_t k_num_regsets = std::size(g_reg_sets);
 
 size_t RegisterContextDarwin_arm64::GetRegisterSetCount() {
   return k_num_regsets;
 }
 
 const RegisterSet *RegisterContextDarwin_arm64::GetRegisterSet(size_t reg_set) {
   if (reg_set < k_num_regsets)
     return &g_reg_sets[reg_set];

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

static RegisterInfo g_register_infos[] = {
     },
     {DEFINE_EXC(faultvaddr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_faultvaddr},
      nullptr,
      nullptr,
      }};
 
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
+static size_t k_num_register_infos = std::size(g_register_infos);
 
 RegisterContextDarwin_i386::RegisterContextDarwin_i386(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
static uint32_t g_fpu_regnums[] = {
     fpu_xmm0,  fpu_xmm1,  fpu_xmm2,  fpu_xmm3,      fpu_xmm4,  fpu_xmm5,
     fpu_xmm6,  fpu_xmm7};
 
 // Exception registers
 
 static uint32_t g_exc_regnums[] = {exc_trapno, exc_err, exc_faultvaddr};
 
 // Number of registers in each register set
-const size_t k_num_gpr_registers = llvm::array_lengthof(g_gpr_regnums);
-const size_t k_num_fpu_registers = llvm::array_lengthof(g_fpu_regnums);
-const size_t k_num_exc_registers = llvm::array_lengthof(g_exc_regnums);
+const size_t k_num_gpr_registers = std::size(g_gpr_regnums);
+const size_t k_num_fpu_registers = std::size(g_fpu_regnums);
+const size_t k_num_exc_registers = std::size(g_exc_regnums);
 
 // Register set definitions. The first definitions at register set index of
 // zero is for all registers, followed by other registers sets. The register
 // information for the all register set need not be filled in.
 static const RegisterSet g_reg_sets[] = {
     {
         "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums,
     },
     {"Floating Point Registers", "fpu", k_num_fpu_registers, g_fpu_regnums},
     {"Exception State Registers", "exc", k_num_exc_registers, g_exc_regnums}};
 
-const size_t k_num_regsets = llvm::array_lengthof(g_reg_sets);
+const size_t k_num_regsets = std::size(g_reg_sets);
 
 size_t RegisterContextDarwin_i386::GetRegisterSetCount() {
   return k_num_regsets;
 }
 
 const RegisterSet *RegisterContextDarwin_i386::GetRegisterSet(size_t reg_set) {
   if (reg_set < k_num_regsets)
     return &g_reg_sets[reg_set];

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

static RegisterInfo g_register_infos[] = {
     },
     {DEFINE_EXC(faultvaddr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_faultvaddr},
      nullptr,
      nullptr,
      }};
 
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
+static size_t k_num_register_infos = std::size(g_register_infos);
 
 RegisterContextDarwin_x86_64::RegisterContextDarwin_x86_64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
static uint32_t g_fpu_regnums[] = {
     fpu_stmm2, fpu_stmm3, fpu_stmm4, fpu_stmm5,     fpu_stmm6, fpu_stmm7,
     fpu_xmm0,  fpu_xmm1,  fpu_xmm2,  fpu_xmm3,      fpu_xmm4,  fpu_xmm5,
     fpu_xmm6,  fpu_xmm7,  fpu_xmm8,  fpu_xmm9,      fpu_xmm10, fpu_xmm11,
     fpu_xmm12, fpu_xmm13, fpu_xmm14, fpu_xmm15};
 
 static uint32_t g_exc_regnums[] = {exc_trapno, exc_err, exc_faultvaddr};
 
 // Number of registers in each register set
-const size_t k_num_gpr_registers = llvm::array_lengthof(g_gpr_regnums);
-const size_t k_num_fpu_registers = llvm::array_lengthof(g_fpu_regnums);
-const size_t k_num_exc_registers = llvm::array_lengthof(g_exc_regnums);
+const size_t k_num_gpr_registers = std::size(g_gpr_regnums);
+const size_t k_num_fpu_registers = std::size(g_fpu_regnums);
+const size_t k_num_exc_registers = std::size(g_exc_regnums);
 
 // Register set definitions. The first definitions at register set index of
 // zero is for all registers, followed by other registers sets. The register
 // information for the all register set need not be filled in.
 static const RegisterSet g_reg_sets[] = {
     {
         "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums,
     },
     {"Floating Point Registers", "fpu", k_num_fpu_registers, g_fpu_regnums},
     {"Exception State Registers", "exc", k_num_exc_registers, g_exc_regnums}};
 
-const size_t k_num_regsets = llvm::array_lengthof(g_reg_sets);
+const size_t k_num_regsets = std::size(g_reg_sets);
 
 size_t RegisterContextDarwin_x86_64::GetRegisterSetCount() {
   return k_num_regsets;
 }
 
 const RegisterSet *
 RegisterContextDarwin_x86_64::GetRegisterSet(size_t reg_set) {
   if (reg_set < k_num_regsets)

lldb/source/Plugins/Process/Utility/RegisterContextWindows_i386.cpp

RegisterContextWindows_i386::RegisterContextWindows_i386(
   assert(target_arch.GetMachine() == llvm::Triple::x86);
 }
 
 const RegisterInfo *RegisterContextWindows_i386::GetRegisterInfo() const {
   return g_register_infos_i386;
 }
 
 uint32_t RegisterContextWindows_i386::GetRegisterCount() const {
-  return llvm::array_lengthof(g_register_infos_i386);
+  return std::size(g_register_infos_i386);
 }
 
 uint32_t RegisterContextWindows_i386::GetUserRegisterCount() const {
-  return llvm::array_lengthof(g_register_infos_i386);
+  return std::size(g_register_infos_i386);
 }
 
 size_t RegisterContextWindows_i386::GetGPRSize() const { return sizeof(GPR); }

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

RegisterContextWindows_x86_64::RegisterContextWindows_x86_64(
   assert(target_arch.GetMachine() == llvm::Triple::x86_64);
 }
 
 const RegisterInfo *RegisterContextWindows_x86_64::GetRegisterInfo() const {
   return g_register_infos_x86_64;
 }
 
 uint32_t RegisterContextWindows_x86_64::GetRegisterCount() const {
-  return llvm::array_lengthof(g_register_infos_x86_64);
+  return std::size(g_register_infos_x86_64);
 }
 
 uint32_t RegisterContextWindows_x86_64::GetUserRegisterCount() const {
-  return llvm::array_lengthof(g_register_infos_x86_64);
+  return std::size(g_register_infos_x86_64);
 }
 
 size_t RegisterContextWindows_x86_64::GetGPRSize() const { return sizeof(GPR); }

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_WoW64.cpp

static const uint32_t g_gpr_regnums_WoW64[] = {
     lldb_eax_i386,      lldb_ebx_i386,    lldb_ecx_i386, lldb_edx_i386,
     lldb_edi_i386,      lldb_esi_i386,    lldb_ebp_i386, lldb_esp_i386,
     lldb_eip_i386,      lldb_eflags_i386, lldb_cs_i386,  lldb_fs_i386,
     lldb_gs_i386,       lldb_ss_i386,     lldb_ds_i386,  lldb_es_i386,
     LLDB_INVALID_REGNUM // Register set must be terminated with this flag.
 };
 
 static const RegisterSet g_reg_sets_WoW64[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_regnums_WoW64) - 1, g_gpr_regnums_WoW64},
+    {"General Purpose Registers", "gpr", std::size(g_gpr_regnums_WoW64) - 1,
+     g_gpr_regnums_WoW64},
 };
 enum { k_num_register_sets = 1 };
 
 static const DWORD kWoW64ContextFlags =
     WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER | WOW64_CONTEXT_SEGMENTS;
 
 } // namespace
 

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_arm.cpp

static const uint32_t g_fpr_regnums_arm[] = {
     fpu_fpscr_arm,
     LLDB_INVALID_REGNUM // Register set must be terminated with this flag
 };
 static_assert(((sizeof g_fpr_regnums_arm / sizeof g_fpr_regnums_arm[0]) - 1) ==
                   k_num_fpr_registers_arm,
               "g_fpu_regnums_arm has wrong number of register infos");
 
 static const RegisterSet g_reg_sets_arm[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_regnums_arm) - 1, g_gpr_regnums_arm},
-    {"Floating Point Registers", "fpr",
-     llvm::array_lengthof(g_fpr_regnums_arm) - 1, g_fpr_regnums_arm},
+    {"General Purpose Registers", "gpr", std::size(g_gpr_regnums_arm) - 1,
+     g_gpr_regnums_arm},
+    {"Floating Point Registers", "fpr", std::size(g_fpr_regnums_arm) - 1,
+     g_fpr_regnums_arm},
 };
 
 enum { k_num_register_sets = 2 };
 
 } // namespace
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_arm64.cpp

static const uint32_t g_fpr_regnums_arm64[] = {
     fpu_fpsr_arm64,     fpu_fpcr_arm64,
     LLDB_INVALID_REGNUM // Register set must be terminated with this flag
 };
 static_assert(((sizeof g_fpr_regnums_arm64 / sizeof g_fpr_regnums_arm64[0]) -
                1) == k_num_fpr_registers_arm64,
               "g_fpu_regnums_arm64 has wrong number of register infos");
 
 static const RegisterSet g_reg_sets_arm64[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_regnums_arm64) - 1, g_gpr_regnums_arm64},
-    {"Floating Point Registers", "fpr",
-     llvm::array_lengthof(g_fpr_regnums_arm64) - 1, g_fpr_regnums_arm64},
+    {"General Purpose Registers", "gpr", std::size(g_gpr_regnums_arm64) - 1,
+     g_gpr_regnums_arm64},
+    {"Floating Point Registers", "fpr", std::size(g_fpr_regnums_arm64) - 1,
+     g_fpr_regnums_arm64},
 };
 
 enum { k_num_register_sets = 2 };
 
 } // namespace
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp

static const uint32_t g_gpr_regnums_i386[] = {
     lldb_eax_i386,      lldb_ebx_i386,    lldb_ecx_i386, lldb_edx_i386,
     lldb_edi_i386,      lldb_esi_i386,    lldb_ebp_i386, lldb_esp_i386,
     lldb_eip_i386,      lldb_eflags_i386, lldb_cs_i386,  lldb_fs_i386,
     lldb_gs_i386,       lldb_ss_i386,     lldb_ds_i386,  lldb_es_i386,
     LLDB_INVALID_REGNUM // Register sets must be terminated with this flag.
 };
 
 static const RegisterSet g_reg_sets_i386[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_regnums_i386) - 1, g_gpr_regnums_i386},
+    {"General Purpose Registers", "gpr", std::size(g_gpr_regnums_i386) - 1,
+     g_gpr_regnums_i386},
 };
 
 enum { k_num_register_sets = 1 };
 
 } // namespace
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

static const uint32_t g_fpr_regnums_x86_64[] = {
     lldb_xmm0_x86_64,   lldb_xmm1_x86_64,  lldb_xmm2_x86_64,  lldb_xmm3_x86_64,
     lldb_xmm4_x86_64,   lldb_xmm5_x86_64,  lldb_xmm6_x86_64,  lldb_xmm7_x86_64,
     lldb_xmm8_x86_64,   lldb_xmm9_x86_64,  lldb_xmm10_x86_64, lldb_xmm11_x86_64,
     lldb_xmm12_x86_64,  lldb_xmm13_x86_64, lldb_xmm14_x86_64, lldb_xmm15_x86_64,
     LLDB_INVALID_REGNUM // Register set must be terminated with this flag
 };
 
 static const RegisterSet g_reg_sets_x86_64[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_regnums_x86_64) - 1, g_gpr_regnums_x86_64},
-    {"Floating Point Registers", "fpr",
-     llvm::array_lengthof(g_fpr_regnums_x86_64) - 1, g_fpr_regnums_x86_64}};
+    {"General Purpose Registers", "gpr", std::size(g_gpr_regnums_x86_64) - 1,
+     g_gpr_regnums_x86_64},
+    {"Floating Point Registers", "fpr", std::size(g_fpr_regnums_x86_64) - 1,
+     g_fpr_regnums_x86_64}};
 
 enum { k_num_register_sets = 2 };
 
 } // namespace
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&

lldb/source/Plugins/Process/Windows/Common/arm/RegisterContextWindows_arm.cpp

#reg, NULL,                                                                  \
                                LLDB_INVALID_REGNUM },                          \
                                NULL, NULL
 
 // Include RegisterInfos_arm to declare our g_register_infos_arm structure.
 #define DECLARE_REGISTER_INFOS_ARM_STRUCT
 #include "Plugins/Process/Utility/RegisterInfos_arm.h"
 #undef DECLARE_REGISTER_INFOS_ARM_STRUCT
 
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos_arm);
+static size_t k_num_register_infos = std::size(g_register_infos_arm);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {
     gpr_r0, gpr_r1,  gpr_r2,  gpr_r3,  gpr_r4, gpr_r5, gpr_r6, gpr_r7,   gpr_r8,
     gpr_r9, gpr_r10, gpr_r11, gpr_r12, gpr_sp, gpr_lr, gpr_pc, gpr_cpsr,
 };
 
uint32_t g_fpu_reg_indices[] = {
 
     fpu_q0,    fpu_q1,  fpu_q2,  fpu_q3,  fpu_q4,  fpu_q5,  fpu_q6,  fpu_q7,
     fpu_q8,    fpu_q9,  fpu_q10, fpu_q11, fpu_q12, fpu_q13, fpu_q14, fpu_q15,
 
     fpu_fpscr,
 };
 
 RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
-    {"Floating Point Registers", "fpu", llvm::array_lengthof(g_fpu_reg_indices),
+    {"General Purpose Registers", "gpr", std::size(g_gpr_reg_indices),
+     g_gpr_reg_indices},
+    {"Floating Point Registers", "fpu", std::size(g_fpu_reg_indices),
      g_fpu_reg_indices},
 };
 
 // Constructors and Destructors
 RegisterContextWindows_arm::RegisterContextWindows_arm(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContextWindows(thread, concrete_frame_idx) {}
 
 RegisterContextWindows_arm::~RegisterContextWindows_arm() {}
 
 size_t RegisterContextWindows_arm::GetRegisterCount() {
-  return llvm::array_lengthof(g_register_infos_arm);
+  return std::size(g_register_infos_arm);
 }
 
 const RegisterInfo *
 RegisterContextWindows_arm::GetRegisterInfoAtIndex(size_t reg) {
   if (reg < k_num_register_infos)
     return &g_register_infos_arm[reg];
   return NULL;
 }
 
 size_t RegisterContextWindows_arm::GetRegisterSetCount() {
-  return llvm::array_lengthof(g_register_sets);
+  return std::size(g_register_sets);
 }
 
 const RegisterSet *RegisterContextWindows_arm::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_arm::ReadRegister(const RegisterInfo *reg_info,
                                               RegisterValue &reg_value) {

lldb/source/Plugins/Process/Windows/Common/arm64/RegisterContextWindows_arm64.cpp

#reg, NULL,                                                                  \
                                LLDB_INVALID_REGNUM },                          \
                                NULL, NULL
 
 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "Plugins/Process/Utility/RegisterInfos_arm64.h"
 #undef DECLARE_REGISTER_INFOS_ARM64_STRUCT
 
-static size_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos_arm64_le);
+static size_t k_num_register_infos = std::size(g_register_infos_arm64_le);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {
     gpr_x0,  gpr_x1,   gpr_x2,  gpr_x3,  gpr_x4,  gpr_x5,  gpr_x6,  gpr_x7,
     gpr_x8,  gpr_x9,   gpr_x10, gpr_x11, gpr_x12, gpr_x13, gpr_x14, gpr_x15,
     gpr_x16, gpr_x17,  gpr_x18, gpr_x19, gpr_x20, gpr_x21, gpr_x22, gpr_x23,
     gpr_x24, gpr_x25,  gpr_x26, gpr_x27, gpr_x28, gpr_fp,  gpr_lr,  gpr_sp,
uint32_t g_fpu_reg_indices[] = {
     fpu_d8,   fpu_d9,   fpu_d10, fpu_d11, fpu_d12, fpu_d13, fpu_d14, fpu_d15,
     fpu_d16,  fpu_d17,  fpu_d18, fpu_d19, fpu_d20, fpu_d21, fpu_d22, fpu_d23,
     fpu_d24,  fpu_d25,  fpu_d26, fpu_d27, fpu_d28, fpu_d29, fpu_d30, fpu_d31,
 
     fpu_fpsr, fpu_fpcr,
 };
 
 RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
-    {"Floating Point Registers", "fpu", llvm::array_lengthof(g_fpu_reg_indices),
+    {"General Purpose Registers", "gpr", std::size(g_gpr_reg_indices),
+     g_gpr_reg_indices},
+    {"Floating Point Registers", "fpu", std::size(g_fpu_reg_indices),
      g_fpu_reg_indices},
 };
 
 // Constructors and Destructors
 RegisterContextWindows_arm64::RegisterContextWindows_arm64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContextWindows(thread, concrete_frame_idx) {}
 
 RegisterContextWindows_arm64::~RegisterContextWindows_arm64() {}
 
 size_t RegisterContextWindows_arm64::GetRegisterCount() {
-  return llvm::array_lengthof(g_register_infos_arm64_le);
+  return std::size(g_register_infos_arm64_le);
 }
 
 const RegisterInfo *
 RegisterContextWindows_arm64::GetRegisterInfoAtIndex(size_t reg) {
   if (reg < k_num_register_infos)
     return &g_register_infos_arm64_le[reg];
   return NULL;
 }
 
 size_t RegisterContextWindows_arm64::GetRegisterSetCount() {
-  return llvm::array_lengthof(g_register_sets);
+  return std::size(g_register_sets);
 }
 
 const RegisterSet *
 RegisterContextWindows_arm64::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_arm64::ReadRegister(const RegisterInfo *reg_info,

lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp

RegisterInfo g_register_infos[] = {
     {DEFINE_FPU_XMM(xmm9)},
     {DEFINE_FPU_XMM(xmm10)},
     {DEFINE_FPU_XMM(xmm11)},
     {DEFINE_FPU_XMM(xmm12)},
     {DEFINE_FPU_XMM(xmm13)},
     {DEFINE_FPU_XMM(xmm14)},
     {DEFINE_FPU_XMM(xmm15)}};
 
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
+static size_t k_num_register_infos = std::size(g_register_infos);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {
     eRegisterIndexRax,  eRegisterIndexRbx,  eRegisterIndexRcx,
     eRegisterIndexRdx,  eRegisterIndexRdi,  eRegisterIndexRsi,
     eRegisterIndexRbp,  eRegisterIndexRsp,  eRegisterIndexR8,
     eRegisterIndexR9,   eRegisterIndexR10,  eRegisterIndexR11,
uint32_t g_fpu_reg_indices[] = {
     eRegisterIndexXmm3,  eRegisterIndexXmm4,  eRegisterIndexXmm5,
     eRegisterIndexXmm6,  eRegisterIndexXmm7,  eRegisterIndexXmm8,
     eRegisterIndexXmm9,  eRegisterIndexXmm10, eRegisterIndexXmm11,
     eRegisterIndexXmm12, eRegisterIndexXmm13, eRegisterIndexXmm14,
     eRegisterIndexXmm15
 };
 
 RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
-    {"Floating Point Registers", "fpu",
-     llvm::array_lengthof(g_fpu_reg_indices), g_fpu_reg_indices}};
+    {"General Purpose Registers", "gpr", std::size(g_gpr_reg_indices),
+     g_gpr_reg_indices},
+    {"Floating Point Registers", "fpu", std::size(g_fpu_reg_indices),
+     g_fpu_reg_indices}};
 }
 
 // Constructors and Destructors
 RegisterContextWindows_x64::RegisterContextWindows_x64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContextWindows(thread, concrete_frame_idx) {}
 
 RegisterContextWindows_x64::~RegisterContextWindows_x64() {}
 
 size_t RegisterContextWindows_x64::GetRegisterCount() {
-  return llvm::array_lengthof(g_register_infos);
+  return std::size(g_register_infos);
 }
 
 const RegisterInfo *
 RegisterContextWindows_x64::GetRegisterInfoAtIndex(size_t reg) {
   if (reg < k_num_register_infos)
     return &g_register_infos[reg];
   return NULL;
 }
 
 size_t RegisterContextWindows_x64::GetRegisterSetCount() {
-  return llvm::array_lengthof(g_register_sets);
+  return std::size(g_register_sets);
 }
 
 const RegisterSet *RegisterContextWindows_x64::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info,
                                               RegisterValue &reg_value) {

lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

RegisterInfo g_register_infos[] = {
     },
     {DEFINE_GPR_BIN(eflags, "flags"),
      {ehframe_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS,
       LLDB_INVALID_REGNUM, lldb_eflags_i386},
      nullptr,
      nullptr,
     },
 };
-static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
+static size_t k_num_register_infos = std::size(g_register_infos);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {eRegisterIndexEax, eRegisterIndexEbx,
                                 eRegisterIndexEcx, eRegisterIndexEdx,
                                 eRegisterIndexEdi, eRegisterIndexEsi,
                                 eRegisterIndexEbp, eRegisterIndexEsp,
                                 eRegisterIndexEip, eRegisterIndexEflags};
 
 RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr",
-     llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
+    {"General Purpose Registers", "gpr", std::size(g_gpr_reg_indices),
+     g_gpr_reg_indices},
 };
 }
 
 // Constructors and Destructors
 RegisterContextWindows_x86::RegisterContextWindows_x86(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContextWindows(thread, concrete_frame_idx) {}
 
 RegisterContextWindows_x86::~RegisterContextWindows_x86() {}
 
 size_t RegisterContextWindows_x86::GetRegisterCount() {
-  return llvm::array_lengthof(g_register_infos);
+  return std::size(g_register_infos);
 }
 
 const RegisterInfo *
 RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg) {
   if (reg < k_num_register_infos)
     return &g_register_infos[reg];
   return NULL;
 }
 
 size_t RegisterContextWindows_x86::GetRegisterSetCount() {
-  return llvm::array_lengthof(g_register_sets);
+  return std::size(g_register_sets);
 }
 
 const RegisterSet *RegisterContextWindows_x86::GetRegisterSet(size_t reg_set) {
   return &g_register_sets[reg_set];
 }
 
 bool RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info,
                                               RegisterValue &reg_value) {

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp

static RegisterInfo g_reg_infos[] = {
     DEF_Q(9),
     DEF_Q(10),
     DEF_Q(11),
     DEF_Q(12),
     DEF_Q(13),
     DEF_Q(14),
     DEF_Q(15)};
 
-constexpr size_t k_num_reg_infos = llvm::array_lengthof(g_reg_infos);
+constexpr size_t k_num_reg_infos = std::size(g_reg_infos);
 
 // ARM general purpose registers.
 const uint32_t g_gpr_regnums[] = {
     reg_r0,
     reg_r1,
     reg_r2,
     reg_r3,
     reg_r4,
const uint32_t g_fpu_regnums[] = {
     reg_q12,
     reg_q13,
     reg_q14,
     reg_q15,
     LLDB_INVALID_REGNUM // register sets need to end with this flag
 };
 
 // Skip the last LLDB_INVALID_REGNUM in each count below by subtracting 1
-constexpr size_t k_num_gpr_regs = llvm::array_lengthof(g_gpr_regnums) - 1;
-constexpr size_t k_num_fpu_regs = llvm::array_lengthof(g_fpu_regnums) - 1;
+constexpr size_t k_num_gpr_regs = std::size(g_gpr_regnums) - 1;
+constexpr size_t k_num_fpu_regs = std::size(g_fpu_regnums) - 1;
 
 static RegisterSet g_reg_sets[] = {
     {"General Purpose Registers", "gpr", k_num_gpr_regs, g_gpr_regnums},
     {"Floating Point Registers", "fpu", k_num_fpu_regs, g_fpu_regnums},
 };
 
-constexpr size_t k_num_reg_sets = llvm::array_lengthof(g_reg_sets);
+constexpr size_t k_num_reg_sets = std::size(g_reg_sets);
 
 RegisterContextMinidump_ARM::RegisterContextMinidump_ARM(
     lldb_private::Thread &thread, const DataExtractor &data, bool apple)
     : RegisterContext(thread, 0), m_apple(apple) {
   lldb::offset_t offset = 0;
   m_regs.context_flags = data.GetU32(&offset);
-  for (unsigned i = 0; i < llvm::array_lengthof(m_regs.r); ++i)
+  for (unsigned i = 0; i < std::size(m_regs.r); ++i)
     m_regs.r[i] = data.GetU32(&offset);
   m_regs.cpsr = data.GetU32(&offset);
   m_regs.fpscr = data.GetU64(&offset);
-  for (unsigned i = 0; i < llvm::array_lengthof(m_regs.d); ++i)
+  for (unsigned i = 0; i < std::size(m_regs.d); ++i)
     m_regs.d[i] = data.GetU64(&offset);
   lldbassert(k_num_regs == k_num_reg_infos);
 }
 
 size_t RegisterContextMinidump_ARM::GetRegisterCountStatic() {
   return k_num_regs;
 }
 

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_ARM64.cpp

static RegisterInfo g_reg_infos[] = {
     DEF_H(26),
     DEF_H(27),
     DEF_H(28),
     DEF_H(29),
     DEF_H(30),
     DEF_H(31),
 };
 
-constexpr size_t k_num_reg_infos = llvm::array_lengthof(g_reg_infos);
+constexpr size_t k_num_reg_infos = std::size(g_reg_infos);
 
 // ARM64 general purpose registers.
 const uint32_t g_gpr_regnums[] = {
     reg_x0,
     reg_x1,
     reg_x2,
     reg_x3,
     reg_x4,
const uint32_t g_fpu_regnums[] = {
     reg_h30,
     reg_h31,
     reg_fpsr,
     reg_fpcr,
     LLDB_INVALID_REGNUM // register sets need to end with this flag
 };
 
 // Skip the last LLDB_INVALID_REGNUM in each count below by subtracting 1
-constexpr size_t k_num_gpr_regs = llvm::array_lengthof(g_gpr_regnums) - 1;
-constexpr size_t k_num_fpu_regs = llvm::array_lengthof(g_fpu_regnums) - 1;
+constexpr size_t k_num_gpr_regs = std::size(g_gpr_regnums) - 1;
+constexpr size_t k_num_fpu_regs = std::size(g_fpu_regnums) - 1;
 
 static RegisterSet g_reg_sets[] = {
     {"General Purpose Registers", "gpr", k_num_gpr_regs, g_gpr_regnums},
     {"Floating Point Registers", "fpu", k_num_fpu_regs, g_fpu_regnums},
 };
 
-constexpr size_t k_num_reg_sets = llvm::array_lengthof(g_reg_sets);
+constexpr size_t k_num_reg_sets = std::size(g_reg_sets);
 
 RegisterContextMinidump_ARM64::RegisterContextMinidump_ARM64(
     lldb_private::Thread &thread, const DataExtractor &data)
     : RegisterContext(thread, 0) {
   lldb::offset_t offset = 0;
   m_regs.context_flags = data.GetU64(&offset);
   for (unsigned i = 0; i < 32; ++i)
     m_regs.x[i] = data.GetU64(&offset);

lldb/source/Utility/ArchSpec.cpp

static const ArchDefinitionEntry g_macho_arch_entries[] = {
     {ArchSpec::eCore_x86_64_x86_64,   llvm::MachO::CPU_TYPE_X86_64,     llvm::MachO::CPU_SUBTYPE_X86_ARCH1,     UINT32_MAX, SUBTYPE_MASK},
     {ArchSpec::eCore_x86_64_x86_64h,  llvm::MachO::CPU_TYPE_X86_64,     llvm::MachO::CPU_SUBTYPE_X86_64_H,      UINT32_MAX, SUBTYPE_MASK},
     {ArchSpec::eCore_x86_64_x86_64,   llvm::MachO::CPU_TYPE_X86_64,     CPU_ANY, UINT32_MAX, UINT32_MAX},
     // Catch any unknown mach architectures so we can always use the object and symbol mach-o files
     {ArchSpec::eCore_uknownMach32,    0,                                0,                                      0xFF000000u, 0x00000000u},
     {ArchSpec::eCore_uknownMach64,    llvm::MachO::CPU_ARCH_ABI64,      0,                                      0xFF000000u, 0x00000000u}};
 // clang-format on
 
-static const ArchDefinition g_macho_arch_def = {
-    eArchTypeMachO, llvm::array_lengthof(g_macho_arch_entries),
+static const ArchDefinition g_macho_arch_def = {eArchTypeMachO,
+                                                std::size(g_macho_arch_entries),
                                                 g_macho_arch_entries, "mach-o"};
 
 //===----------------------------------------------------------------------===//
 // A table that gets searched linearly for matches. This table is used to
 // convert cpu type and subtypes to architecture names, and to convert
 // architecture names to cpu types and subtypes. The ordering is important and
 // allows the precedence to be set when the table is built.
 static const ArchDefinitionEntry g_elf_arch_entries[] = {
     {ArchSpec::eCore_sparc_generic, llvm::ELF::EM_SPARC, LLDB_INVALID_CPUTYPE,
static const ArchDefinitionEntry g_elf_arch_entries[] = {
     {ArchSpec::eCore_riscv32, llvm::ELF::EM_RISCV,
      ArchSpec::eRISCVSubType_riscv32, 0xFFFFFFFFu, 0xFFFFFFFFu}, // riscv32
     {ArchSpec::eCore_riscv64, llvm::ELF::EM_RISCV,
      ArchSpec::eRISCVSubType_riscv64, 0xFFFFFFFFu, 0xFFFFFFFFu}, // riscv64
 };
 
 static const ArchDefinition g_elf_arch_def = {
     eArchTypeELF,
-    llvm::array_lengthof(g_elf_arch_entries),
+    std::size(g_elf_arch_entries),
     g_elf_arch_entries,
     "elf",
 };
 
 static const ArchDefinitionEntry g_coff_arch_entries[] = {
     {ArchSpec::eCore_x86_32_i386, llvm::COFF::IMAGE_FILE_MACHINE_I386,
      LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu}, // Intel 80x86
     {ArchSpec::eCore_ppc_generic, llvm::COFF::IMAGE_FILE_MACHINE_POWERPC,
static const ArchDefinitionEntry g_coff_arch_entries[] = {
     {ArchSpec::eCore_x86_64_x86_64, llvm::COFF::IMAGE_FILE_MACHINE_AMD64,
      LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu}, // AMD64
     {ArchSpec::eCore_arm_arm64, llvm::COFF::IMAGE_FILE_MACHINE_ARM64,
      LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu} // ARM64
 };
 
 static const ArchDefinition g_coff_arch_def = {
     eArchTypeCOFF,
-    llvm::array_lengthof(g_coff_arch_entries),
+    std::size(g_coff_arch_entries),
     g_coff_arch_entries,
     "pe-coff",
 };
 
 //===----------------------------------------------------------------------===//
 // Table of all ArchDefinitions
 static const ArchDefinition *g_arch_definitions[] = {
     &g_macho_arch_def, &g_elf_arch_def, &g_coff_arch_def};
static const CoreDefinition *FindCoreDefinition(llvm::StringRef name) {
   for (const auto &def : g_core_definitions) {
     if (name.equals_insensitive(def.name))
       return &def;
   }
   return nullptr;
 }
 
 static inline const CoreDefinition *FindCoreDefinition(ArchSpec::Core core) {
-  if (core < llvm::array_lengthof(g_core_definitions))
+  if (core < std::size(g_core_definitions))
     return &g_core_definitions[core];
   return nullptr;
 }
 
 // Get a definition entry by cpu type and subtype.
 static const ArchDefinitionEntry *
 FindArchDefinitionEntry(const ArchDefinition *def, uint32_t cpu, uint32_t sub) {
   if (def == nullptr)

lldb/unittests/Utility/StatusTest.cpp

 #ifdef _WIN32
 TEST(StatusTest, ErrorWin32) {
   auto success = Status(NO_ERROR, ErrorType::eErrorTypeWin32);
   EXPECT_STREQ(NULL, success.AsCString());
   EXPECT_FALSE(success.ToError());
   EXPECT_TRUE(success.Success());
 
   WCHAR name[128]{};
-  ULONG nameLen = llvm::array_lengthof(name);
+  ULONG nameLen = std::size(name);
   ULONG langs = 0;
   GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &langs,
                               reinterpret_cast<PZZWSTR>(&name), &nameLen);
   // Skip the following tests on non-English, non-US, locales because the
   // formatted messages will be different.
   bool skip = wcscmp(L"en-US", name) != 0;
 
   auto s = Status(ERROR_ACCESS_DENIED, ErrorType::eErrorTypeWin32);