Remove redundant .c_str() and .get() calls

[MaskRay]

llvm/include/llvm/ProfileData/InstrProfReader.h

703

delete parens. ditto below

[gAlfonso-bit]

Done! @MaskRay

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[shafik]

lldb/source/API/SBPlatform.cpp

14 ↗

(On Diff #481954)

These redundant header removals looks unrelated and should be done as a separate NFC change.

clang-tools-extra/modularize/ModuleAssistant.cpp

bool createModuleMap(llvm::StringRef ModuleMapPath,
                      llvm::ArrayRef<std::string> ProblemFileNames,
                      DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
                      llvm::StringRef RootModuleName) {
   // Load internal representation of modules.
   std::unique_ptr<Module> RootModule(
     loadModuleDescriptions(
       RootModuleName, HeaderFileNames, ProblemFileNames, Dependencies,
       HeaderPrefix));
-  if (!RootModule.get())
+  if (!RootModule)
     return false;
 
   // Write module map file.
   return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());
 }

clang/lib/Driver/OffloadBundler.cpp

Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
         CreateFileHandler(*CodeObjectBuffer, BundlerConfig);
     if (!FileHandlerOrErr)
       return FileHandlerOrErr.takeError();
 
     std::unique_ptr<FileHandler> &FileHandler = *FileHandlerOrErr;
     assert(FileHandler &&
            "FileHandle creation failed for file in the archive!");
 
-    if (Error ReadErr = FileHandler.get()->ReadHeader(*CodeObjectBuffer))
+    if (Error ReadErr = FileHandler->ReadHeader(*CodeObjectBuffer))
       return ReadErr;
 
     Expected<std::optional<StringRef>> CurBundleIDOrErr =
         FileHandler->ReadBundleStart(*CodeObjectBuffer);
     if (!CurBundleIDOrErr)
       return CurBundleIDOrErr.takeError();
 
     std::optional<StringRef> OptionalCurBundleID = *CurBundleIDOrErr;
     // No device code in this child, skip.
     if (!OptionalCurBundleID)
       continue;
     StringRef CodeObject = *OptionalCurBundleID;
 
     // Process all bundle entries (CodeObjects) found in this child of input
     // archive.
     while (!CodeObject.empty()) {
       SmallVector<StringRef> CompatibleTargets;
       auto CodeObjectInfo = OffloadTargetInfo(CodeObject, BundlerConfig);
       if (CodeObjectInfo.hasHostKind()) {
         // Do nothing, we don't extract host code yet.
       } else if (getCompatibleOffloadTargets(CodeObjectInfo, CompatibleTargets,
                                              BundlerConfig)) {
         std::string BundleData;
         raw_string_ostream DataStream(BundleData);
-        if (Error Err =
-                FileHandler.get()->ReadBundle(DataStream, *CodeObjectBuffer))
+        if (Error Err = FileHandler->ReadBundle(DataStream, *CodeObjectBuffer))
           return Err;
 
         for (auto &CompatibleTarget : CompatibleTargets) {
           SmallString<128> BundledObjectFileName;
           BundledObjectFileName.assign(BundledObjectFile);
           auto OutputBundleName =
               Twine(llvm::sys::path::stem(BundledObjectFileName) + "-" +
                     CodeObject +
while (!CodeObject.empty()) {
                                                std::move(ArchiveMembers));
           } else {
             OutputArchivesMap[CompatibleTarget].push_back(
                 NewArchiveMember(MemBufRef));
           }
         }
       }
 
-      if (Error Err = FileHandler.get()->ReadBundleEnd(*CodeObjectBuffer))
+      if (Error Err = FileHandler->ReadBundleEnd(*CodeObjectBuffer))
         return Err;
 
       Expected<std::optional<StringRef>> NextTripleOrErr =
           FileHandler->ReadBundleStart(*CodeObjectBuffer);
       if (!NextTripleOrErr)
         return NextTripleOrErr.takeError();
 
       CodeObject = ((*NextTripleOrErr).has_value()) ? **NextTripleOrErr : "";

clang/lib/Driver/ToolChain.cpp

 SanitizerArgs
 ToolChain::getSanitizerArgs(const llvm::opt::ArgList &JobArgs) const {
   SanitizerArgs SanArgs(*this, JobArgs, !SanitizerArgsChecked);
   SanitizerArgsChecked = true;
   return SanArgs;
 }
 
 const XRayArgs& ToolChain::getXRayArgs() const {
-  if (!XRayArguments.get())
+  if (!XRayArguments)
     XRayArguments.reset(new XRayArgs(*this, Args));
-  return *XRayArguments.get();
+  return *XRayArguments;
 }
 
 namespace {
 
 struct DriverSuffix {
   const char *Suffix;
   const char *ModeFlag;
 };

lld/ELF/Writer.cpp

 // time any references to these symbols are processed and is equivalent to
 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
   if (ElfSym::globalOffsetTable) {
     // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually
     // to the start of the .got or .got.plt section.
     InputSection *sec = in.gotPlt.get();
     if (!target->gotBaseSymInGotPlt)
-      sec = in.mipsGot.get() ? cast<InputSection>(in.mipsGot.get())
-                             : cast<InputSection>(in.got.get());
+      sec = in.mipsGot ? cast<InputSection>(in.mipsGot.get())
     ElfSym::globalOffsetTable->section = sec;
   }
 
   // .rela_iplt_{start,end} mark the start and the end of in.relaIplt.
   if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) {
     ElfSym::relaIpltStart->section = in.relaIplt.get();
     ElfSym::relaIpltEnd->section = in.relaIplt.get();
     ElfSym::relaIpltEnd->value = in.relaIplt->getSize();

llvm/include/llvm/Analysis/RegionInfoImpl.h

void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
   OS << "End region tree\n";
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 template <class Tr>
 void RegionInfoBase<Tr>::dump() const { print(dbgs()); }
 #endif
 
-template <class Tr>
-void RegionInfoBase<Tr>::releaseMemory() {
+template <class Tr> void RegionInfoBase<Tr>::releaseMemory() {
   BBtoRegion.clear();
-  if (TopLevelRegion)
+  if (TopLevelRegion) {
     delete TopLevelRegion;
     TopLevelRegion = nullptr;
   }
+}
 
 template <class Tr>
 void RegionInfoBase<Tr>::verifyAnalysis() const {
   // Do only verify regions if explicitely activated using EXPENSIVE_CHECKS or
   // -verify-region-info
   if (!RegionInfoBase<Tr>::VerifyRegionInfo)
     return;
 

llvm/include/llvm/MC/MCContext.h

private:
   /// catch errors if .secure_log_unique appears twice without
   /// .secure_log_reset appearing between them.
   bool SecureLogUsed = false;
 
   /// The compilation directory to use for DW_AT_comp_dir.
   SmallString<128> CompilationDir;
 
   /// Prefix replacement map for source file information.
-  std::map<std::string, const std::string, std::greater<std::string>>
-      DebugPrefixMap;
+  std::map<std::string, const std::string, std::greater<>> DebugPrefixMap;
 
   /// The main file name if passed in explicitly.
   std::string MainFileName;
 
   /// The dwarf file and directory tables from the dwarf .file directive.
   /// We now emit a line table for each compile unit. To reduce the prologue
   /// size of each line table, the files and directories used by each compile
   /// unit are separated.

llvm/include/llvm/ProfileData/InstrProfReader.h

public:
 
   /// Read the header.
   Error readHeader() override;
 
   /// Read a single record.
   Error readNextRecord(NamedInstrProfRecord &Record) override;
 
   InstrProfSymtab &getSymtab() override {
-    assert(Symtab.get());
-    return *Symtab.get();
+    assert(Symtab);
+    return *Symtab;
   }
 };
 
 /// Reader for the raw instrprof binary format from runtime.
 ///
 /// This format is a raw memory dump of the instrumentation-based profiling data
 /// from the runtime.  It has no index.
 ///
public:
   // the client is the compiler.
   InstrProfSymtab &getSymtab() override;
 
   /// Return the profile summary.
   /// \c UseCS indicates whether to use the context-sensitive summary.
   ProfileSummary &getSummary(bool UseCS) {
     if (UseCS) {
       assert(CS_Summary && "No context sensitive summary");
-      return *(CS_Summary.get());
+      return *CS_Summary;
     } else {
       assert(Summary && "No profile summary");
-      return *(Summary.get());
+      return *Summary;
     }
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFREADER_H

llvm/include/llvm/Support/YAMLParser.h

if (!(*Doc)->skip()) {
       Doc->reset(nullptr);
     } else {
       Stream &S = (*Doc)->stream;
       Doc->reset(new Document(S));
     }
     return *this;
   }
 
-  Document &operator*() { return *Doc->get(); }
+  Document &operator*() { return **Doc; }
 
   std::unique_ptr<Document> &operator->() { return *Doc; }
 
 private:
   bool isAtEnd() const { return !Doc || !*Doc; }
 
   std::unique_ptr<Document> *Doc = nullptr;
 };
 
 } // end namespace yaml
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_YAMLPARSER_H

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
   // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
   // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   return Error::success();
 }
 
 bool DWARFUnit::parseDWO(StringRef DWOAlternativeLocation) {
   if (IsDWO)
     return false;
-  if (DWO.get())
+  if (DWO)
     return false;
   DWARFDie UnitDie = getUnitDIE();
   if (!UnitDie)
     return false;
   auto DWOFileName = getVersion() >= 5
                          ? dwarf::toString(UnitDie.find(DW_AT_dwo_name))
                          : dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
   if (!DWOFileName)

llvm/lib/DebugInfo/LogicalView/Core/LVElement.cpp

void LVElement::resolveFullname(LVElement *BaseType, StringRef Name) {
   }
 
   // For a better and consistent layout, check if the generated name
   // contains double space sequences.
   assert((Fullname.find("  ", 0) == std::string::npos) &&
          "Extra double spaces in name.");
 
   LLVM_DEBUG({ dbgs() << "Fullname = '" << Fullname << "'\n"; });
-  setName(Fullname.c_str());
+  setName(Fullname);
 }
 
 void LVElement::setFile(LVElement *Reference) {
   if (!options().getAttributeAnySource())
     return;
 
   // At this point, any existing reference to another element, have been
   // resolved and the file ID extracted from the DI entry.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

void LVScope::resolveTemplate() {
   // Check if we need to encode the template arguments.
   if (options().getAttributeEncoded()) {
     LVTypes Params;
     if (getTemplateParameterTypes(Params)) {
       std::string EncodedArgs;
       // Encode the arguments as part of the template name and update the
       // template name, to reflect the encoded parameters.
       encodeTemplateArguments(EncodedArgs, &Params);
-      setEncodedArgs(EncodedArgs.c_str());
+      setEncodedArgs(EncodedArgs);
     }
   }
 }
 
 // Get the qualified name for the template.
 void LVScope::getQualifiedName(std::string &QualifiedName) const {
   if (getIsRoot() || getIsCompileUnit())
     return;
for (LVSymbol *Symbol : *Symbols)
         Name.append(std::string(Symbol->getTypeName()));
         AddComma = true;
       }
   }
 
   Name.append(")");
 
   // Update the scope name, to reflect the encoded parameters.
-  setName(Name.c_str());
+  setName(Name);
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF namespace (DW_TAG_namespace).
 //===----------------------------------------------------------------------===//
 bool LVScopeNamespace::equals(const LVScope *Scope) const {
   if (!LVScope::equals(Scope))
     return false;

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

case MCDisassembler::Fail:
       break;
     case MCDisassembler::SoftFail:
       LLVM_DEBUG({ dbgs() << "Potentially undefined instruction:"; });
       LLVM_FALLTHROUGH;
     case MCDisassembler::Success: {
       std::string Buffer;
       raw_string_ostream Stream(Buffer);
       StringRef AnnotationsStr = Annotations.str();
-      MIP.get()->printInst(&Instruction, Address, AnnotationsStr, *STI, Stream);
+      MIP->printInst(&Instruction, Address, AnnotationsStr, *STI, Stream);
       LLVM_DEBUG({
         std::string BufferCodes;
         raw_string_ostream StreamCodes(BufferCodes);
         StreamCodes << format_bytes(
             ArrayRef<uint8_t>(Begin, Begin + BytesConsumed), std::nullopt, 16,
             16);
         dbgs() << "[" << hexValue((uint64_t)Begin) << "] "
                << "Size: " << format_decimal(BytesConsumed, 2) << " ("

llvm/lib/ObjCopy/MachO/MachOObjcopy.cpp

auto FoundSec = llvm::find_if(FoundSeg->Sections,
                                   return Sec->Sectname == SecName;
                                 });
   if (FoundSec == FoundSeg->Sections.end())
     return createStringError(errc::invalid_argument,
                              "could not find section with name '%s'",
                              SecName.str().c_str());
 
   assert(FoundSec->get()->CanonicalName == (SegName + "," + SecName).str());
-  return *FoundSec->get();
+  return **FoundSec;
 }
 
 static Error updateSection(const NewSectionInfo &NewSection, Object &O) {
   Expected<Section &> SecToUpdateOrErr = findSection(NewSection.SectionName, O);
 
   if (!SecToUpdateOrErr)
     return SecToUpdateOrErr.takeError();
   Section &Sec = *SecToUpdateOrErr;

llvm/lib/Target/BPF/BTFDebug.cpp

if (!DL || PrevInstLoc == DL) {
     return;
   }
 
   // Create a temporary label to remember the insn for lineinfo.
   MCSymbol *LineSym = OS.getContext().createTempSymbol();
   OS.emitLabel(LineSym);
 
   // Construct the lineinfo.
-  auto SP = DL.get()->getScope()->getSubprogram();
+  auto SP = DL->getScope()->getSubprogram();
   constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
 
   LineInfoGenerated = true;
   PrevInstLoc = DL;
 }
 
 void BTFDebug::processGlobals(bool ProcessingMapDef) {
   // Collect all types referenced by globals.

llvm/tools/dsymutil/BinaryHolder.cpp

BinaryHolder::ArchiveEntry::getObjectEntry(StringRef Filename,
   StringRef ArchiveFilename;
   StringRef ObjectFilename;
   std::tie(ArchiveFilename, ObjectFilename) = getArchiveAndObjectName(Filename);
   KeyTy Key = {ObjectFilename, Timestamp};
 
   // Try the cache first.
   std::lock_guard<std::mutex> Lock(MemberCacheMutex);
   if (MemberCache.count(Key))
-    return *MemberCache[Key].get();
+    return *MemberCache[Key];
 
   // Create a new ObjectEntry, but don't add it to the cache yet. Loading of
   // the archive members might fail and we don't want to lock the whole archive
   // during this operation.
   auto OE = std::make_unique<ObjectEntry>();
 
   for (const auto &Archive : Archives) {
     Error Err = Error::success();

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

for (const auto &Branch : Graph.ConditionalBranchNodes) {
     }
   }
 
   return Graph.BaseAddress;
 }
 
 void FileAnalysis::printInstruction(const Instr &InstrMeta,
                                     raw_ostream &OS) const {
-  Printer->printInst(&InstrMeta.Instruction, 0, "", *SubtargetInfo.get(), OS);
+  Printer->printInst(&InstrMeta.Instruction, 0, "", *SubtargetInfo, OS);
 }
 
 Error FileAnalysis::initialiseDisassemblyMembers() {
   std::string TripleName = ObjectTriple.getTriple();
   ArchName = "";
   MCPU = "";
   std::string ErrorString;
 

llvm/tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::doShow(int argc, const char **argv,
   }
 
   if (!Filters.empty()) {
     // Build the map of filenames to functions.
     std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
         FilenameFunctionMap;
     for (const auto &SourceFile : SourceFiles)
       for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
-        if (Filters.matches(*Coverage.get(), Function))
+        if (Filters.matches(*Coverage, Function))
           FilenameFunctionMap[SourceFile].push_back(&Function);
 
     // Only print filter matching functions for each file.
     for (const auto &FileFunc : FilenameFunctionMap) {
       StringRef File = FileFunc.first;
       const auto &Functions = FileFunc.second;
 
       auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
if (std::error_code EC = sys::fs::status(PGOFilename, Status)) {
     error("Could not read profile data!" + EC.message(), PGOFilename);
     return 1;
   }
 
   auto Coverage = load();
   if (!Coverage)
     return 1;
 
-  CoverageReport Report(ViewOpts, *Coverage.get());
+  CoverageReport Report(ViewOpts, *Coverage);
   if (!ShowFunctionSummaries) {
     if (SourceFiles.empty())
       Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
     else
       Report.renderFileReports(llvm::outs(), SourceFiles);
   } else {
     if (SourceFiles.empty()) {
       error("Source files must be specified when -show-functions=true is "
if (!Coverage) {
     error("Could not load coverage information");
     return 1;
   }
 
   std::unique_ptr<CoverageExporter> Exporter;
 
   switch (ViewOpts.Format) {
   case CoverageViewOptions::OutputFormat::Text:
-    Exporter = std::make_unique<CoverageExporterJson>(*Coverage.get(),
-                                                       ViewOpts, outs());
+    Exporter =
+        std::make_unique<CoverageExporterJson>(*Coverage, ViewOpts, outs());
     break;
   case CoverageViewOptions::OutputFormat::HTML:
     // Unreachable because we should have gracefully terminated with an error
     // above.
     llvm_unreachable("Export in HTML is not supported!");
   case CoverageViewOptions::OutputFormat::Lcov:
-    Exporter = std::make_unique<CoverageExporterLcov>(*Coverage.get(),
-                                                       ViewOpts, outs());
+    Exporter =
+        std::make_unique<CoverageExporterLcov>(*Coverage, ViewOpts, outs());
     break;
   }
 
   if (SourceFiles.empty())
     Exporter->renderRoot(IgnoreFilenameFilters);
   else
     Exporter->renderRoot(SourceFiles);
 

llvm/tools/obj2yaml/elf2yaml.cpp

std::unique_ptr<ELFYAML::SectionHeaderTable> SHT =
         std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/false);
     SHT->Sections.emplace();
     for (ELFYAML::Section *S : OriginalOrder)
       SHT->Sections->push_back({S->Name});
     Chunks.push_back(std::move(SHT));
   }
 
   llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
-    if (isa<ELFYAML::SectionHeaderTable>(*C.get()))
+    if (isa<ELFYAML::SectionHeaderTable>(*C))
       return false;
 
-    const ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
+    const ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
     return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
   });
 
   // The section header string table by default is assumed to be called
   // ".shstrtab" and be in its own unique section. However, it's possible for it
   // to be called something else and shared with another section. If the name
   // isn't the default, provide this in the YAML.
   if (ShStrTabIndex && *ShStrTabIndex != ELF::SHN_UNDEF &&
for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
     // We do not print the default alignment to reduce noise in the output.
     if (Phdr.p_align != 1)
       PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align);
 
     // Here we match sections with segments.
     // It is not possible to have a non-Section chunk, because
     // obj2yaml does not create Fill chunks.
     for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) {
-      ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
+      ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
       if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) {
         if (!PH.FirstSec)
           PH.FirstSec = S.Name;
         PH.LastSec = S.Name;
         PH.Chunks.push_back(C.get());
       }
     }
 
if (ELFYAML::RawContentSection *RawSec =
       // name, which defeats this attempt to skip reading a section header
       // string table with the same name as a DWARF section.
       if (ShStrTabIndex && RawSec->OriginalSecNdx == *ShStrTabIndex)
         continue;
       Error Err = Error::success();
       cantFail(std::move(Err));
 
       if (RawSec->Name == ".debug_aranges")
-        Err = dumpDebugARanges(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugARanges(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_str")
-        Err = dumpDebugStrings(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugStrings(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_ranges")
-        Err = dumpDebugRanges(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugRanges(*DWARFCtx, DWARF);
       else if (RawSec->Name == ".debug_addr")
-        Err = dumpDebugAddr(*DWARFCtx.get(), DWARF);
+        Err = dumpDebugAddr(*DWARFCtx, DWARF);
       else
         continue;
 
       // If the DWARF section cannot be successfully parsed, emit raw content
       // instead of an entry in the DWARF section of the YAML.
       if (Err)
         consumeError(std::move(Err));
       else

llvm/tools/obj2yaml/macho2yaml.cpp

if (Expected<MachOYAML::Section> S =
       if ((RawSegment & ::RawSegments::data) &&
           StringRef(S->segname).startswith("__DATA"))
         S->content =
             yaml::BinaryRef(Obj.getSectionContents(Sec.offset, Sec.size));
 
       if (SecName.startswith("__debug_")) {
         // If the DWARF section cannot be successfully parsed, emit raw content
         // instead of an entry in the DWARF section of the YAML.
-        if (Error Err = dumpDebugSection(SecName, *DWARFCtx.get(), Y.DWARF))
+        if (Error Err = dumpDebugSection(SecName, *DWARFCtx, Y.DWARF))
           consumeError(std::move(Err));
         else
           S->content.reset();
       }
       Sections.push_back(std::move(*S));
     } else
       return S.takeError();
   }
for (auto LoadCmd : Obj.load_commands()) {
     const char *EndPtr = LoadCmd.Ptr;
     switch (LoadCmd.C.cmd) {
     default:
       memcpy((void *)&(LC.Data.load_command_data), LoadCmd.Ptr,
              sizeof(MachO::load_command));
       if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
         MachO::swapStruct(LC.Data.load_command_data);
       if (Expected<const char *> ExpectedEndPtr =
-              processLoadCommandData<MachO::load_command>(LC, LoadCmd,
-                                                          *Y.get()))
+              processLoadCommandData<MachO::load_command>(LC, LoadCmd, *Y))
         EndPtr = *ExpectedEndPtr;
       else
         return ExpectedEndPtr.takeError();
       break;
 #include "llvm/BinaryFormat/MachO.def"
     }
     auto RemainingBytes = LoadCmd.C.cmdsize - (EndPtr - LoadCmd.Ptr);
     if (!std::all_of(EndPtr, &EndPtr[RemainingBytes],