DynamicEntryFlags.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 Quarkslab
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef LIEF_ELF_DYNAMIC_ENTRY_FLAGS_H
#define LIEF_ELF_DYNAMIC_ENTRY_FLAGS_H
 
#include <memory>
#include <numeric>
#include <ostream>
#include <vector>
 
#include "LIEF/ELF/DynamicEntry.hpp"
#include "LIEF/visibility.h"
 
 
namespace LIEF::ELF {
 
class LIEF_API DynamicEntryFlags : public DynamicEntry {
  public:
  static constexpr uint64_t BASE = 0x100000000;
 
  // clang-format off
  enum class FLAG : uint64_t {
    ORIGIN        = 0x00000001, 
    SYMBOLIC      = 0x00000002, 
    TEXTREL       = 0x00000004, 
    BIND_NOW      = 0x00000008, 
    STATIC_TLS    = 0x00000010, 
 
    NOW           = BASE + 0x000000001, 
    GLOBAL        = BASE + 0x000000002, 
    GROUP         = BASE + 0x000000004, 
    NODELETE      = BASE + 0x000000008, 
    LOADFLTR      = BASE + 0x000000010, 
    INITFIRST     = BASE + 0x000000020, 
    NOOPEN        = BASE + 0x000000040, 
    HANDLE_ORIGIN = BASE + 0x000000080, 
    DIRECT        = BASE + 0x000000100, 
    TRANS         = BASE + 0x000000200,
    INTERPOSE     = BASE + 0x000000400, 
    NODEFLIB      = BASE + 0x000000800, 
    NODUMP        = BASE + 0x000001000, 
    CONFALT       = BASE + 0x000002000, 
    ENDFILTEE     = BASE + 0x000004000, 
    DISPRELDNE    = BASE + 0x000008000, 
    DISPRELPND    = BASE + 0x000010000, 
    NODIRECT      = BASE + 0x000020000, 
    IGNMULDEF     = BASE + 0x000040000,
    NOKSYMS       = BASE + 0x000080000,
    NOHDR         = BASE + 0x000100000,
    EDITED        = BASE + 0x000200000, 
    NORELOC       = BASE + 0x000400000,
    SYMINTPOSE    = BASE + 0x000800000, 
    GLOBAUDIT     = BASE + 0x001000000, 
    SINGLETON     = BASE + 0x002000000, 
    PIE           = BASE + 0x008000000, 
    KMOD          = BASE + 0x010000000,
    WEAKFILTER    = BASE + 0x020000000,
    NOCOMMON      = BASE + 0x040000000,
  };
  // clang-format on
 
  using flags_list_t = std::vector<FLAG>;
 
  public:
  using DynamicEntry::DynamicEntry;
  DynamicEntryFlags() = delete;
 
  static DynamicEntryFlags create_dt_flag(uint64_t value) {
    return {DynamicEntry::TAG::FLAGS, value};
  }
 
  static DynamicEntryFlags create_dt_flag_1(uint64_t value) {
    return {DynamicEntry::TAG::FLAGS_1, value};
  }
 
  DynamicEntryFlags& operator=(const DynamicEntryFlags&) = default;
  DynamicEntryFlags(const DynamicEntryFlags&) = default;
 
  std::unique_ptr<DynamicEntry> clone() const override {
    return std::make_unique<DynamicEntryFlags>(*this);
  }

  bool has(FLAG f) const;

  flags_list_t flags() const;
 
  uint64_t raw_flags() const {
    flags_list_t flags = this->flags();
    return std::accumulate(flags.begin(), flags.end(), uint64_t(0),
                           [](uint64_t value, FLAG f) {
                             return value + (uint64_t)f;
                           });
  }

  void add(FLAG f);

  void remove(FLAG f);
 
  DynamicEntryFlags& operator+=(FLAG f) {
    add(f);
    return *this;
  }
 
  DynamicEntryFlags& operator-=(FLAG f) {
    remove(f);
    return *this;
  }
 
  void accept(Visitor& visitor) const override;
 
  static bool classof(const DynamicEntry* entry) {
    return entry->tag() == DynamicEntry::TAG::FLAGS ||
           entry->tag() == DynamicEntry::TAG::FLAGS_1;
  }
 
  ~DynamicEntryFlags() override = default;
 
  std::ostream& print(std::ostream& os) const override;
 
  private:
  DynamicEntryFlags(DynamicEntry::TAG tag, uint64_t flags) :
    DynamicEntry(tag, flags) {}
};
 
LIEF_API const char* to_string(DynamicEntryFlags::FLAG e);
 
}
 
 
#endif