

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: cmELF.cxx</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include &quot;cmELF.h&quot;

#include &lt;cstddef&gt;
#include &lt;cstdint&gt;
#include &lt;map&gt;
#include &lt;memory&gt;
#include &lt;sstream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;

#include &lt;cm/memory&gt;
#include &lt;cmext/algorithm&gt;

#include &lt;cm3p/kwiml/abi.h&gt;

#include &quot;cmsys/FStream.hxx&quot;

#include &quot;cmelf/elf32.h&quot;
#include &quot;cmelf/elf64.h&quot;
#include &quot;cmelf/elf_common.h&quot;

// Low-level byte swapping implementation.
template &lt;size_t s&gt;
struct cmELFByteSwapSize
{
};
static void cmELFByteSwap(char* data, cmELFByteSwapSize&lt;2&gt; /*unused*/)
{
  char one_byte;
  one_byte = data[0];
  data[0] = data[1];
  data[1] = one_byte;
}
static void cmELFByteSwap(char* data, cmELFByteSwapSize&lt;4&gt; /*unused*/)
{
  char one_byte;
  one_byte = data[0];
  data[0] = data[3];
  data[3] = one_byte;
  one_byte = data[1];
  data[1] = data[2];
  data[2] = one_byte;
}
static void cmELFByteSwap(char* data, cmELFByteSwapSize&lt;8&gt; /*unused*/)
{
  char one_byte;
  one_byte = data[0];
  data[0] = data[7];
  data[7] = one_byte;
  one_byte = data[1];
  data[1] = data[6];
  data[6] = one_byte;
  one_byte = data[2];
  data[2] = data[5];
  data[5] = one_byte;
  one_byte = data[3];
  data[3] = data[4];
  data[4] = one_byte;
}

// Low-level byte swapping interface.
template &lt;typename T&gt;
void cmELFByteSwap(T&amp; x)
{
  cmELFByteSwap(reinterpret_cast&lt;char*&gt;(&amp;x), cmELFByteSwapSize&lt;sizeof(T)&gt;());
}

class cmELFInternal
{
public:
  using StringEntry = cmELF::StringEntry;
  enum ByteOrderType
  {
    ByteOrderMSB,
    ByteOrderLSB
  };

  // Construct and take ownership of the file stream object.
  cmELFInternal(cmELF* external, std::unique_ptr&lt;std::istream&gt; fin,
                ByteOrderType order)
    : External(external)
    , Stream(std::move(fin))
    , ByteOrder(order)
  {
// In most cases the processor-specific byte order will match that
// of the target execution environment.  If we choose wrong here
// it is fixed when the header is read.
#if KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_LITTLE
    this-&gt;NeedSwap = (this-&gt;ByteOrder == ByteOrderMSB);
#elif KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_BIG
    this-&gt;NeedSwap = (this-&gt;ByteOrder == ByteOrderLSB);
#else
    this-&gt;NeedSwap = false; // Final decision is at runtime anyway.
#endif

    // We have not yet loaded the section info.
    this-&gt;DynamicSectionIndex = -1;
  }

  // Destruct and delete the file stream object.
  virtual ~cmELFInternal() = default;

  // Forward to the per-class implementation.
  virtual unsigned int GetNumberOfSections() const = 0;
  virtual unsigned long GetDynamicEntryPosition(int j) = 0;
  virtual cmELF::DynamicEntryList GetDynamicEntries() = 0;
  virtual std::vector&lt;char&gt; EncodeDynamicEntries(
    const cmELF::DynamicEntryList&amp;) = 0;
  virtual StringEntry const* GetDynamicSectionString(unsigned int tag) = 0;
  virtual bool IsMips() const = 0;
  virtual void PrintInfo(std::ostream&amp; os) const = 0;

  // Lookup the SONAME in the DYNAMIC section.
  StringEntry const* GetSOName()
  {
    return this-&gt;GetDynamicSectionString(DT_SONAME);
  }

  // Lookup the RPATH in the DYNAMIC section.
  StringEntry const* GetRPath()
  {
    return this-&gt;GetDynamicSectionString(DT_RPATH);
  }

  // Lookup the RUNPATH in the DYNAMIC section.
  StringEntry const* GetRunPath()
  {
    return this-&gt;GetDynamicSectionString(DT_RUNPATH);
  }

  // Return the recorded ELF type.
  cmELF::FileType GetFileType() const { return this-&gt;ELFType; }

  // Return the recorded machine.
  std::uint16_t GetMachine() const { return this-&gt;Machine; }

protected:
  // Data common to all ELF class implementations.

  // The external cmELF object.
  cmELF* External;

  // The stream from which to read.
  std::unique_ptr&lt;std::istream&gt; Stream;

  // The byte order of the ELF file.
  ByteOrderType ByteOrder;

  // The ELF file type.
  cmELF::FileType ELFType = cmELF::FileTypeInvalid;

  // The ELF architecture.
  std::uint16_t Machine;

  // Whether we need to byte-swap structures read from the stream.
  bool NeedSwap;

  // The section header index of the DYNAMIC section (-1 if none).
  int DynamicSectionIndex;

  // Helper methods for subclasses.
  void SetErrorMessage(const char* msg)
  {
    this-&gt;External-&gt;ErrorMessage = msg;
    this-&gt;ELFType = cmELF::FileTypeInvalid;
  }

  // Store string table entry states.
  std::map&lt;unsigned int, StringEntry&gt; DynamicSectionStrings;
};

// Configure the implementation template for 32-bit ELF files.
struct cmELFTypes32
{
  using ELF_Ehdr = Elf32_Ehdr;
  using ELF_Shdr = Elf32_Shdr;
  using ELF_Dyn = Elf32_Dyn;
  using ELF_Half = Elf32_Half;
  using tagtype = ::uint32_t;
  static const char* GetName() { return &quot;32-bit&quot;; }
};

// Configure the implementation template for 64-bit ELF files.
struct cmELFTypes64
{
  using ELF_Ehdr = Elf64_Ehdr;
  using ELF_Shdr = Elf64_Shdr;
  using ELF_Dyn = Elf64_Dyn;
  using ELF_Half = Elf64_Half;
  using tagtype = ::uint64_t;
  static const char* GetName() { return &quot;64-bit&quot;; }
};

// Parser implementation template.
template &lt;class Types&gt;
class cmELFInternalImpl : public cmELFInternal
{
public:
  // Copy the ELF file format types from our configuration parameter.
  using ELF_Ehdr = typename Types::ELF_Ehdr;
  using ELF_Shdr = typename Types::ELF_Shdr;
  using ELF_Dyn = typename Types::ELF_Dyn;
  using ELF_Half = typename Types::ELF_Half;
  using tagtype = typename Types::tagtype;

  // Construct with a stream and byte swap indicator.
  cmELFInternalImpl(cmELF* external, std::unique_ptr&lt;std::istream&gt; fin,
                    ByteOrderType order);

  // Return the number of sections as specified by the ELF header.
  unsigned int GetNumberOfSections() const override
  {
    return static_cast&lt;unsigned int&gt;(this-&gt;ELFHeader.e_shnum);
  }

  // Get the file position of a dynamic section entry.
  unsigned long GetDynamicEntryPosition(int j) override;

  cmELF::DynamicEntryList GetDynamicEntries() override;
  std::vector&lt;char&gt; EncodeDynamicEntries(
    const cmELF::DynamicEntryList&amp;) override;

  // Lookup a string from the dynamic section with the given tag.
  StringEntry const* GetDynamicSectionString(unsigned int tag) override;

  bool IsMips() const override { return this-&gt;ELFHeader.e_machine == EM_MIPS; }

  // Print information about the ELF file.
  void PrintInfo(std::ostream&amp; os) const override
  {
    os &lt;&lt; &quot;ELF &quot; &lt;&lt; Types::GetName();
    if (this-&gt;ByteOrder == ByteOrderMSB) {
      os &lt;&lt; &quot; MSB&quot;;
    } else if (this-&gt;ByteOrder == ByteOrderLSB) {
      os &lt;&lt; &quot; LSB&quot;;
    }
    switch (this-&gt;ELFType) {
      case cmELF::FileTypeInvalid:
        os &lt;&lt; &quot; invalid file&quot;;
        break;
      case cmELF::FileTypeRelocatableObject:
        os &lt;&lt; &quot; relocatable object&quot;;
        break;
      case cmELF::FileTypeExecutable:
        os &lt;&lt; &quot; executable&quot;;
        break;
      case cmELF::FileTypeSharedLibrary:
        os &lt;&lt; &quot; shared library&quot;;
        break;
      case cmELF::FileTypeCore:
        os &lt;&lt; &quot; core file&quot;;
        break;
      case cmELF::FileTypeSpecificOS:
        os &lt;&lt; &quot; os-specific type&quot;;
        break;
      case cmELF::FileTypeSpecificProc:
        os &lt;&lt; &quot; processor-specific type&quot;;
        break;
    }
    os &lt;&lt; &quot;\n&quot;;
  }

private:
  static_assert(sizeof(ELF_Dyn().d_un.d_val) == sizeof(ELF_Dyn().d_un.d_ptr),
                &quot;ByteSwap(ELF_Dyn) assumes d_val and d_ptr are the same size&quot;);

  void ByteSwap(ELF_Ehdr&amp; elf_header)
  {
    cmELFByteSwap(elf_header.e_type);
    cmELFByteSwap(elf_header.e_machine);
    cmELFByteSwap(elf_header.e_version);
    cmELFByteSwap(elf_header.e_entry);
    cmELFByteSwap(elf_header.e_phoff);
    cmELFByteSwap(elf_header.e_shoff);
    cmELFByteSwap(elf_header.e_flags);
    cmELFByteSwap(elf_header.e_ehsize);
    cmELFByteSwap(elf_header.e_phentsize);
    cmELFByteSwap(elf_header.e_phnum);
    cmELFByteSwap(elf_header.e_shentsize);
    cmELFByteSwap(elf_header.e_shnum);
    cmELFByteSwap(elf_header.e_shstrndx);
  }

  void ByteSwap(ELF_Shdr&amp; sec_header)
  {
    cmELFByteSwap(sec_header.sh_name);
    cmELFByteSwap(sec_header.sh_type);
    cmELFByteSwap(sec_header.sh_flags);
    cmELFByteSwap(sec_header.sh_addr);
    cmELFByteSwap(sec_header.sh_offset);
    cmELFByteSwap(sec_header.sh_size);
    cmELFByteSwap(sec_header.sh_link);
    cmELFByteSwap(sec_header.sh_info);
    cmELFByteSwap(sec_header.sh_addralign);
    cmELFByteSwap(sec_header.sh_entsize);
  }

  void ByteSwap(ELF_Dyn&amp; dyn)
  {
    cmELFByteSwap(dyn.d_tag);
    cmELFByteSwap(dyn.d_un.d_val);
  }

  bool FileTypeValid(ELF_Half et)
  {
    unsigned int eti = static_cast&lt;unsigned int&gt;(et);
    if (eti == ET_NONE || eti == ET_REL || eti == ET_EXEC || eti == ET_DYN ||
        eti == ET_CORE) {
      return true;
    }
    if (eti &gt;= ET_LOOS &amp;&amp; eti &lt;= ET_HIOS) {
      return true;
    }
    if (eti &gt;= ET_LOPROC &amp;&amp; eti &lt;= ET_HIPROC) {
      return true;
    }
    return false;
  }

  bool Read(ELF_Ehdr&amp; x)
  {
    // Read the header from the file.
    if (!this-&gt;Stream-&gt;read(reinterpret_cast&lt;char*&gt;(&amp;x), sizeof(x))) {
      return false;
    }

    // The byte order of ELF header fields may not match that of the
    // processor-specific data.  The header fields are ordered to
    // match the target execution environment, so we may need to
    // memorize the order of all platforms based on the e_machine
    // value.  As a heuristic, if the type is invalid but its
    // swapped value is okay then flip our swap mode.
    ELF_Half et = x.e_type;
    if (this-&gt;NeedSwap) {
      cmELFByteSwap(et);
    }
    if (!this-&gt;FileTypeValid(et)) {
      cmELFByteSwap(et);
      if (this-&gt;FileTypeValid(et)) {
        // The previous byte order guess was wrong.  Flip it.
        this-&gt;NeedSwap = !this-&gt;NeedSwap;
      }
    }

    // Fix the byte order of the header.
    if (this-&gt;NeedSwap) {
      this-&gt;ByteSwap(x);
    }
    return true;
  }
  bool Read(ELF_Shdr&amp; x)
  {
    if (this-&gt;Stream-&gt;read(reinterpret_cast&lt;char*&gt;(&amp;x), sizeof(x)) &amp;&amp;
        this-&gt;NeedSwap) {
      this-&gt;ByteSwap(x);
    }
    return !this-&gt;Stream-&gt;fail();
  }
  bool Read(ELF_Dyn&amp; x)
  {
    if (this-&gt;Stream-&gt;read(reinterpret_cast&lt;char*&gt;(&amp;x), sizeof(x)) &amp;&amp;
        this-&gt;NeedSwap) {
      this-&gt;ByteSwap(x);
    }
    return !this-&gt;Stream-&gt;fail();
  }

  bool LoadSectionHeader(ELF_Half i)
  {
    // Read the section header from the file.
    this-&gt;Stream-&gt;seekg(this-&gt;ELFHeader.e_shoff +
                        this-&gt;ELFHeader.e_shentsize * i);
    if (!this-&gt;Read(this-&gt;SectionHeaders[i])) {
      return false;
    }

    // Identify some important sections.
    if (this-&gt;SectionHeaders[i].sh_type == SHT_DYNAMIC) {
      this-&gt;DynamicSectionIndex = i;
    }
    return true;
  }

  bool LoadDynamicSection();

  // Store the main ELF header.
  ELF_Ehdr ELFHeader;

  // Store all the section headers.
  std::vector&lt;ELF_Shdr&gt; SectionHeaders;

  // Store all entries of the DYNAMIC section.
  std::vector&lt;ELF_Dyn&gt; DynamicSectionEntries;
};

template &lt;class Types&gt;
cmELFInternalImpl&lt;Types&gt;::cmELFInternalImpl(cmELF* external,
                                            std::unique_ptr&lt;std::istream&gt; fin,
                                            ByteOrderType order)
  : cmELFInternal(external, std::move(fin), order)
{
  // Read the main header.
  if (!this-&gt;Read(this-&gt;ELFHeader)) {
    this-&gt;SetErrorMessage(&quot;Failed to read main ELF header.&quot;);
    return;
  }

  // Determine the ELF file type.
  switch (this-&gt;ELFHeader.e_type) {
    case ET_NONE:
      this-&gt;SetErrorMessage(&quot;ELF file type is NONE.&quot;);
      return;
    case ET_REL:
      this-&gt;ELFType = cmELF::FileTypeRelocatableObject;
      break;
    case ET_EXEC:
      this-&gt;ELFType = cmELF::FileTypeExecutable;
      break;
    case ET_DYN:
      this-&gt;ELFType = cmELF::FileTypeSharedLibrary;
      break;
    case ET_CORE:
      this-&gt;ELFType = cmELF::FileTypeCore;
      break;
    default: {
      unsigned int eti = static_cast&lt;unsigned int&gt;(this-&gt;ELFHeader.e_type);
      if (eti &gt;= ET_LOOS &amp;&amp; eti &lt;= ET_HIOS) {
        this-&gt;ELFType = cmELF::FileTypeSpecificOS;
        break;
      }
      if (eti &gt;= ET_LOPROC &amp;&amp; eti &lt;= ET_HIPROC) {
        this-&gt;ELFType = cmELF::FileTypeSpecificProc;
        break;
      }
      std::ostringstream e;
      e &lt;&lt; &quot;Unknown ELF file type &quot; &lt;&lt; eti;
      this-&gt;SetErrorMessage(e.str().c_str());
      return;
    }
  }

  this-&gt;Machine = this-&gt;ELFHeader.e_machine;

  // Load the section headers.
  this-&gt;SectionHeaders.resize(this-&gt;ELFHeader.e_shnum);
  for (ELF_Half i = 0; i &lt; this-&gt;ELFHeader.e_shnum; ++i) {
    if (!this-&gt;LoadSectionHeader(i)) {
      this-&gt;SetErrorMessage(&quot;Failed to load section headers.&quot;);
      return;
    }
  }
}

template &lt;class Types&gt;
bool cmELFInternalImpl&lt;Types&gt;::LoadDynamicSection()
{
  // If there is no dynamic section we are done.
  if (this-&gt;DynamicSectionIndex &lt; 0) {
    return false;
  }

  // If the section was already loaded we are done.
  if (!this-&gt;DynamicSectionEntries.empty()) {
    return true;
  }

  // If there are no entries we are done.
  ELF_Shdr const&amp; sec = this-&gt;SectionHeaders[this-&gt;DynamicSectionIndex];
  if (sec.sh_entsize == 0) {
    return false;
  }

  // Allocate the dynamic section entries.
  int n = static_cast&lt;int&gt;(sec.sh_size / sec.sh_entsize);
  this-&gt;DynamicSectionEntries.resize(n);

  // Read each entry.
  for (int j = 0; j &lt; n; ++j) {
    // Seek to the beginning of the section entry.
    this-&gt;Stream-&gt;seekg(sec.sh_offset + sec.sh_entsize * j);
    ELF_Dyn&amp; dyn = this-&gt;DynamicSectionEntries[j];

    // Try reading the entry.
    if (!this-&gt;Read(dyn)) {
      this-&gt;SetErrorMessage(&quot;Error reading entry from DYNAMIC section.&quot;);
      this-&gt;DynamicSectionIndex = -1;
      return false;
    }
  }
  return true;
}

template &lt;class Types&gt;
unsigned long cmELFInternalImpl&lt;Types&gt;::GetDynamicEntryPosition(int j)
{
  if (!this-&gt;LoadDynamicSection()) {
    return 0;
  }
  if (j &lt; 0 || j &gt;= static_cast&lt;int&gt;(this-&gt;DynamicSectionEntries.size())) {
    return 0;
  }
  ELF_Shdr const&amp; sec = this-&gt;SectionHeaders[this-&gt;DynamicSectionIndex];
  return static_cast&lt;unsigned long&gt;(sec.sh_offset + sec.sh_entsize * j);
}

template &lt;class Types&gt;
cmELF::DynamicEntryList cmELFInternalImpl&lt;Types&gt;::GetDynamicEntries()
{
  cmELF::DynamicEntryList result;

  // Ensure entries have been read from file
  if (!this-&gt;LoadDynamicSection()) {
    return result;
  }

  // Copy into public array
  result.reserve(this-&gt;DynamicSectionEntries.size());
  for (ELF_Dyn&amp; dyn : this-&gt;DynamicSectionEntries) {
    result.emplace_back(dyn.d_tag, dyn.d_un.d_val);
  }

  return result;
}

template &lt;class Types&gt;
std::vector&lt;char&gt; cmELFInternalImpl&lt;Types&gt;::EncodeDynamicEntries(
  const cmELF::DynamicEntryList&amp; entries)
{
  std::vector&lt;char&gt; result;
  result.reserve(sizeof(ELF_Dyn) * entries.size());

  for (auto const&amp; entry : entries) {
    // Store the entry in an ELF_Dyn, byteswap it, then serialize to chars
    ELF_Dyn dyn;
    dyn.d_tag = static_cast&lt;tagtype&gt;(entry.first);
    dyn.d_un.d_val = static_cast&lt;tagtype&gt;(entry.second);

    if (this-&gt;NeedSwap) {
      this-&gt;ByteSwap(dyn);
    }

    char* pdyn = reinterpret_cast&lt;char*&gt;(&amp;dyn);
    cm::append(result, pdyn, pdyn + sizeof(ELF_Dyn));
  }

  return result;
}

template &lt;class Types&gt;
cmELF::StringEntry const* cmELFInternalImpl&lt;Types&gt;::GetDynamicSectionString(
  unsigned int tag)
{
  // Short-circuit if already checked.
  auto dssi = this-&gt;DynamicSectionStrings.find(tag);
  if (dssi != this-&gt;DynamicSectionStrings.end()) {
    if (dssi-&gt;second.Position &gt; 0) {
      return &amp;dssi-&gt;second;
    }
    return nullptr;
  }

  // Create an entry for this tag.  Assume it is missing until found.
  StringEntry&amp; se = this-&gt;DynamicSectionStrings[tag];
  se.Position = 0;
  se.Size = 0;
  se.IndexInSection = -1;

  // Try reading the dynamic section.
  if (!this-&gt;LoadDynamicSection()) {
    return nullptr;
  }

  // Get the string table referenced by the DYNAMIC section.
  ELF_Shdr const&amp; sec = this-&gt;SectionHeaders[this-&gt;DynamicSectionIndex];
  if (sec.sh_link &gt;= this-&gt;SectionHeaders.size()) {
    this-&gt;SetErrorMessage(&quot;Section DYNAMIC has invalid string table index.&quot;);
    return nullptr;
  }
  ELF_Shdr const&amp; strtab = this-&gt;SectionHeaders[sec.sh_link];

  // Look for the requested entry.
  for (auto di = this-&gt;DynamicSectionEntries.begin();
       di != this-&gt;DynamicSectionEntries.end(); ++di) {
    ELF_Dyn&amp; dyn = *di;
    if (static_cast&lt;tagtype&gt;(dyn.d_tag) == static_cast&lt;tagtype&gt;(tag)) {
      // We found the tag requested.
      // Make sure the position given is within the string section.
      if (dyn.d_un.d_val &gt;= strtab.sh_size) {
        this-&gt;SetErrorMessage(&quot;Section DYNAMIC references string beyond &quot;
                              &quot;the end of its string section.&quot;);
        return nullptr;
      }

      // Seek to the position reported by the entry.
      unsigned long first = static_cast&lt;unsigned long&gt;(dyn.d_un.d_val);
      unsigned long last = first;
      unsigned long end = static_cast&lt;unsigned long&gt;(strtab.sh_size);
      this-&gt;Stream-&gt;seekg(strtab.sh_offset + first);

      // Read the string.  It may be followed by more than one NULL
      // terminator.  Count the total size of the region allocated to
      // the string.  This assumes that the next string in the table
      // is non-empty, but the &quot;chrpath&quot; tool makes the same
      // assumption.
      bool terminated = false;
      char c;
      while (last != end &amp;&amp; this-&gt;Stream-&gt;get(c) &amp;&amp; !(terminated &amp;&amp; c)) {
        ++last;
        if (c) {
          se.Value += c;
        } else {
          terminated = true;
        }
      }

      // Make sure the whole value was read.
      if (!(*this-&gt;Stream)) {
        this-&gt;SetErrorMessage(&quot;Dynamic section specifies unreadable RPATH.&quot;);
        se.Value = &quot;&quot;;
        return nullptr;
      }

      // The value has been read successfully.  Report it.
      se.Position = static_cast&lt;unsigned long&gt;(strtab.sh_offset + first);
      se.Size = last - first;
      se.IndexInSection =
        static_cast&lt;int&gt;(di - this-&gt;DynamicSectionEntries.begin());
      return &amp;se;
    }
  }
  return nullptr;
}

//============================================================================
// External class implementation.

const long cmELF::TagRPath = DT_RPATH;
const long cmELF::TagRunPath = DT_RUNPATH;
const long cmELF::TagMipsRldMapRel = DT_MIPS_RLD_MAP_REL;

cmELF::cmELF(const char* fname)
{
  // Try to open the file.
  auto fin = cm::make_unique&lt;cmsys::ifstream&gt;(fname, std::ios::binary);

  // Quit now if the file could not be opened.
  if (!fin || !*fin) {
    this-&gt;ErrorMessage = &quot;Error opening input file.&quot;;
    return;
  }

  // Read the ELF identification block.
  char ident[EI_NIDENT];
  if (!fin-&gt;read(ident, EI_NIDENT)) {
    this-&gt;ErrorMessage = &quot;Error reading ELF identification.&quot;;
    return;
  }
  if (!fin-&gt;seekg(0)) {
    this-&gt;ErrorMessage = &quot;Error seeking to beginning of file.&quot;;
    return;
  }

  // Verify the ELF identification.
  if (!(ident[EI_MAG0] == ELFMAG0 &amp;&amp; ident[EI_MAG1] == ELFMAG1 &amp;&amp;
        ident[EI_MAG2] == ELFMAG2 &amp;&amp; ident[EI_MAG3] == ELFMAG3)) {
    this-&gt;ErrorMessage = &quot;File does not have a valid ELF identification.&quot;;
    return;
  }

  // Check the byte order in which the rest of the file is encoded.
  cmELFInternal::ByteOrderType order;
  if (ident[EI_DATA] == ELFDATA2LSB) {
    // File is LSB.
    order = cmELFInternal::ByteOrderLSB;
  } else if (ident[EI_DATA] == ELFDATA2MSB) {
    // File is MSB.
    order = cmELFInternal::ByteOrderMSB;
  } else {
    this-&gt;ErrorMessage = &quot;ELF file is not LSB or MSB encoded.&quot;;
    return;
  }

  // Check the class of the file and construct the corresponding
  // parser implementation.
  if (ident[EI_CLASS] == ELFCLASS32) {
    // 32-bit ELF
    this-&gt;Internal = cm::make_unique&lt;cmELFInternalImpl&lt;cmELFTypes32&gt;&gt;(
      this, std::move(fin), order);
  } else if (ident[EI_CLASS] == ELFCLASS64) {
    // 64-bit ELF
    this-&gt;Internal = cm::make_unique&lt;cmELFInternalImpl&lt;cmELFTypes64&gt;&gt;(
      this, std::move(fin), order);
  } else {
    this-&gt;ErrorMessage = &quot;ELF file class is not 32-bit or 64-bit.&quot;;
    return;
  }
}

cmELF::~cmELF() = default;

bool cmELF::Valid() const
{
  return this-&gt;Internal &amp;&amp; this-&gt;Internal-&gt;GetFileType() != FileTypeInvalid;
}

cmELF::FileType cmELF::GetFileType() const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;GetFileType();
  }
  return FileTypeInvalid;
}

std::uint16_t cmELF::GetMachine() const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;GetMachine();
  }
  return 0;
}

unsigned int cmELF::GetNumberOfSections() const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;GetNumberOfSections();
  }
  return 0;
}

unsigned long cmELF::GetDynamicEntryPosition(int index) const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;GetDynamicEntryPosition(index);
  }
  return 0;
}

cmELF::DynamicEntryList cmELF::GetDynamicEntries() const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;GetDynamicEntries();
  }

  return cmELF::DynamicEntryList();
}

std::vector&lt;char&gt; cmELF::EncodeDynamicEntries(
  const cmELF::DynamicEntryList&amp; dentries) const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;EncodeDynamicEntries(dentries);
  }

  return std::vector&lt;char&gt;();
}

bool cmELF::GetSOName(std::string&amp; soname)
{
  if (StringEntry const* se = this-&gt;GetSOName()) {
    soname = se-&gt;Value;
    return true;
  }
  return false;
}

cmELF::StringEntry const* cmELF::GetSOName()
{
  if (this-&gt;Valid() &amp;&amp;
      this-&gt;Internal-&gt;GetFileType() == cmELF::FileTypeSharedLibrary) {
    return this-&gt;Internal-&gt;GetSOName();
  }
  return nullptr;
}

cmELF::StringEntry const* cmELF::GetRPath()
{
  if (this-&gt;Valid() &amp;&amp;
      (this-&gt;Internal-&gt;GetFileType() == cmELF::FileTypeExecutable ||
       this-&gt;Internal-&gt;GetFileType() == cmELF::FileTypeSharedLibrary)) {
    return this-&gt;Internal-&gt;GetRPath();
  }
  return nullptr;
}

cmELF::StringEntry const* cmELF::GetRunPath()
{
  if (this-&gt;Valid() &amp;&amp;
      (this-&gt;Internal-&gt;GetFileType() == cmELF::FileTypeExecutable ||
       this-&gt;Internal-&gt;GetFileType() == cmELF::FileTypeSharedLibrary)) {
    return this-&gt;Internal-&gt;GetRunPath();
  }
  return nullptr;
}

bool cmELF::IsMIPS() const
{
  if (this-&gt;Valid()) {
    return this-&gt;Internal-&gt;IsMips();
  }
  return false;
}

void cmELF::PrintInfo(std::ostream&amp; os) const
{
  if (this-&gt;Valid()) {
    this-&gt;Internal-&gt;PrintInfo(os);
  } else {
    os &lt;&lt; &quot;Not a valid ELF file.\n&quot;;
  }
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/src/cmake-3.25.0/Source/cmELF.cxx'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fsrc%2Fcmake-3.25.0%2FSource' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>