Fix strlen() of unbound array undefined behavior

[jankratochvil]

Summary

LLDB testsuite fails when built by GCC8 on:

LLDB :: SymbolFile/DWARF/find-basic-namespace.cpp

This is because this code in LLDB codebase has undefined behavior:

#include <algorithm>
#include <string.h>
// lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp:1731
static struct section_64 {
  char sectname[16];
  char segname[16];
} sect64 = { {'_','_','a','p','p','l','e','_','n','a','m','e','s','p','a','c'}, "__DWARF" };
int main() {
  return std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname));
}

It has been discussed as a (false) bugreport to GCC: wrong-code: LLDB testcase fails: SymbolFile/DWARF/find-basic-namespace.cpp

I will check it in if there are no comments as it looks obvious enough to me.

[aprantl]

Thanks!

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

if (!m_data.GetU8(&offset, (uint8_t *)load_cmd.segname, 16))
     return;
 
   ModuleSP module_sp = GetModule();
   const bool is_core = GetType() == eTypeCoreFile;
   const bool is_dsym = (m_header.filetype == MH_DSYM);
   bool add_section = true;
   bool add_to_unified = true;
   ConstString const_segname(
-      load_cmd.segname,
-      std::min<size_t>(strlen(load_cmd.segname), sizeof(load_cmd.segname)));
+      load_cmd.segname, strnlen(load_cmd.segname, sizeof(load_cmd.segname)));
 
   SectionSP unified_section_sp(
       context.UnifiedList.FindSectionByName(const_segname));
   if (is_dsym && unified_section_sp) {
     if (const_segname == GetSegmentNameLINKEDIT()) {
       // We need to keep the __LINKEDIT segment private to this object file
       // only
       add_to_unified = false;
if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == NULL)
       break;
 
     // Keep a list of mach sections around in case we need to get at data that
     // isn't stored in the abstracted Sections.
     m_mach_sections.push_back(sect64);
 
     if (add_section) {
       ConstString section_name(
-          sect64.sectname,
-          std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname)));
+          sect64.sectname, strnlen(sect64.sectname, sizeof(sect64.sectname)));
       if (!const_segname) {
         // We have a segment with no name so we need to conjure up segments
         // that correspond to the section's segname if there isn't already such
         // a section. If there is such a section, we resize the section so that
         // it spans all sections.  We also mark these sections as fake so
         // address matches don't hit if they land in the gaps between the child
         // sections.
         const_segname.SetTrimmedCStringWithLength(sect64.segname,

lldb/trunk/source/Utility/ConstString.cpp

GetConstCStringAndSetMangledCounterPart(llvm::StringRef demangled,
 
     // Return the constant demangled C string
     return demangled_ccstr;
   }
 
   const char *GetConstTrimmedCStringWithLength(const char *cstr,
                                                size_t cstr_len) {
     if (cstr != nullptr) {
-      const size_t trimmed_len = std::min<size_t>(strlen(cstr), cstr_len);
+      const size_t trimmed_len = strnlen(cstr, cstr_len);
       return GetConstCStringWithLength(cstr, trimmed_len);
     }
     return nullptr;
   }
 
   //------------------------------------------------------------------
   // Return the size in bytes that this object and any items in its collection
   // of uniqued strings + data count values takes in memory.