/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp
Warning:	line 1109, column 51 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DWARFExpression.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbExpression/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbExpression/../include -I /usr/src/gnu/usr.bin/clang/liblldbExpression/obj -I /usr/src/gnu/usr.bin/clang/liblldbExpression/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbExpression/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp

/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp

→

1//===-- DWARFExpression.cpp -----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "lldb/Expression/DWARFExpression.h"

11#include <cinttypes>

13#include <vector>

15#include "lldb/Core/Module.h"
16#include "lldb/Core/Value.h"
17#include "lldb/Core/dwarf.h"
18#include "lldb/Utility/DataEncoder.h"
19#include "lldb/Utility/Log.h"
20#include "lldb/Utility/RegisterValue.h"
21#include "lldb/Utility/Scalar.h"
22#include "lldb/Utility/StreamString.h"
23#include "lldb/Utility/VMRange.h"

25#include "lldb/Host/Host.h"
26#include "lldb/Utility/Endian.h"

28#include "lldb/Symbol/Function.h"

30#include "lldb/Target/ABI.h"
31#include "lldb/Target/ExecutionContext.h"
32#include "lldb/Target/Process.h"
33#include "lldb/Target/RegisterContext.h"
34#include "lldb/Target/StackFrame.h"
35#include "lldb/Target/StackID.h"
36#include "lldb/Target/Target.h"
37#include "lldb/Target/Thread.h"

39#include "Plugins/SymbolFile/DWARF/DWARFUnit.h"

41using namespace lldb;
42using namespace lldb_private;

44static lldb::addr_t
45ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
                              uint32_t index) {
uint32_t index_size = dwarf_cu->GetAddressByteSize();
dw_offset_t addr_base = dwarf_cu->GetAddrBase();
lldb::offset_t offset = addr_base + index * index_size;
const DWARFDataExtractor &data =
    dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData();
if (data.ValidOffsetForDataOfSize(offset, index_size))
  return data.GetMaxU64_unchecked(&offset, index_size);
return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
55}

57// DWARFExpression constructor
58DWARFExpression::DWARFExpression() : m_module_wp(), m_data() {}

60DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                               const DataExtractor &data,
                               const DWARFUnit *dwarf_cu)
  : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
    m_reg_kind(eRegisterKindDWARF) {
if (module_sp)
  m_module_wp = module_sp;
67}

69// Destructor
70DWARFExpression::~DWARFExpression() = default;

72bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }

74void DWARFExpression::UpdateValue(uint64_t const_value,
                                lldb::offset_t const_value_byte_size,
                                uint8_t addr_byte_size) {
if (!const_value_byte_size)
  return;

m_data.SetData(
    DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
m_data.SetByteOrder(endian::InlHostByteOrder());
m_data.SetAddressByteSize(addr_byte_size);
84}

86void DWARFExpression::DumpLocation(Stream *s, const DataExtractor &data,
                                 lldb::DescriptionLevel level,
                                 ABI *abi) const {
llvm::DWARFExpression(data.GetAsLLVM(), data.GetAddressByteSize())
    .print(s->AsRawOstream(), llvm::DIDumpOptions(),
           abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr);
92}

94void DWARFExpression::SetLocationListAddresses(addr_t cu_file_addr,
                                             addr_t func_file_addr) {
m_loclist_addresses = LoclistAddresses{cu_file_addr, func_file_addr};
97}

99int DWARFExpression::GetRegisterKind() { return m_reg_kind; }

101void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) {
m_reg_kind = reg_kind;
103}

105bool DWARFExpression::IsLocationList() const {
return bool(m_loclist_addresses);
107}

109namespace {
110/// Implement enough of the DWARFObject interface in order to be able to call
111/// DWARFLocationTable::dumpLocationList. We don't have access to a real
112/// DWARFObject here because DWARFExpression is used in non-DWARF scenarios too.
113class DummyDWARFObject final: public llvm::DWARFObject {
114public:
DummyDWARFObject(bool IsLittleEndian) : IsLittleEndian(IsLittleEndian) {}

bool isLittleEndian() const override { return IsLittleEndian; }

llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec,
                                          uint64_t Pos) const override {
  return llvm::None;
}
123private:
bool IsLittleEndian;
125};
126}

128void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
                                   addr_t location_list_base_addr,
                                   ABI *abi) const {
if (IsLocationList()) {
  // We have a location list
  lldb::offset_t offset = 0;
  std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
      m_dwarf_cu->GetLocationTable(m_data);

  llvm::MCRegisterInfo *MRI = abi ? &abi->GetMCRegisterInfo() : nullptr;
  llvm::DIDumpOptions DumpOpts;
  DumpOpts.RecoverableErrorHandler = [&](llvm::Error E) {
    s->AsRawOstream() << "error: " << toString(std::move(E));
  };
  loctable_up->dumpLocationList(
      &offset, s->AsRawOstream(),
      llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr}, MRI,
      DummyDWARFObject(m_data.GetByteOrder() == eByteOrderLittle), nullptr,
      DumpOpts, s->GetIndentLevel() + 2);
} else {
  // We have a normal location that contains DW_OP location opcodes
  DumpLocation(s, m_data, level, abi);
}
151}

153static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
                                    lldb::RegisterKind reg_kind,
                                    uint32_t reg_num, Status *error_ptr,
                                    Value &value) {
if (reg_ctx == nullptr) {
  if (error_ptr)
    error_ptr->SetErrorString("No register context in frame.\n");
} else {
  uint32_t native_reg =
      reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
  if (native_reg == LLDB_INVALID_REGNUM0xffffffffU) {
    if (error_ptr)
      error_ptr->SetErrorStringWithFormat("Unable to convert register "
                                          "kind=%u reg_num=%u to a native "
                                          "register number.\n",
                                          reg_kind, reg_num);
  } else {
    const RegisterInfo *reg_info =
        reg_ctx->GetRegisterInfoAtIndex(native_reg);
    RegisterValue reg_value;
    if (reg_ctx->ReadRegister(reg_info, reg_value)) {
      if (reg_value.GetScalarValue(value.GetScalar())) {
        value.SetValueType(Value::ValueType::Scalar);
        value.SetContext(Value::ContextType::RegisterInfo,
                         const_cast<RegisterInfo *>(reg_info));
        if (error_ptr)
          error_ptr->Clear();
        return true;
      } else {
        // If we get this error, then we need to implement a value buffer in
        // the dwarf expression evaluation function...
        if (error_ptr)
          error_ptr->SetErrorStringWithFormat(
              "register %s can't be converted to a scalar value",
              reg_info->name);
      }
    } else {
      if (error_ptr)
        error_ptr->SetErrorStringWithFormat("register %s is not available",
                                            reg_info->name);
    }
  }
}
return false;
197}

199/// Return the length in bytes of the set of operands for \p op. No guarantees
200/// are made on the state of \p data after this call.
201static offset_t GetOpcodeDataSize(const DataExtractor &data,
                                const lldb::offset_t data_offset,
                                const uint8_t op) {
lldb::offset_t offset = data_offset;
switch (op) {
case DW_OP_addr:
case DW_OP_call_ref: // 0x9a 1 address sized offset of DIE (DWARF3)
  return data.GetAddressByteSize();

// Opcodes with no arguments
case DW_OP_deref:                // 0x06
case DW_OP_dup:                  // 0x12
case DW_OP_drop:                 // 0x13
case DW_OP_over:                 // 0x14
case DW_OP_swap:                 // 0x16
case DW_OP_rot:                  // 0x17
case DW_OP_xderef:               // 0x18
case DW_OP_abs:                  // 0x19
case DW_OP_and:                  // 0x1a
case DW_OP_div:                  // 0x1b
case DW_OP_minus:                // 0x1c
case DW_OP_mod:                  // 0x1d
case DW_OP_mul:                  // 0x1e
case DW_OP_neg:                  // 0x1f
case DW_OP_not:                  // 0x20
case DW_OP_or:                   // 0x21
case DW_OP_plus:                 // 0x22
case DW_OP_shl:                  // 0x24
case DW_OP_shr:                  // 0x25
case DW_OP_shra:                 // 0x26
case DW_OP_xor:                  // 0x27
case DW_OP_eq:                   // 0x29
case DW_OP_ge:                   // 0x2a
case DW_OP_gt:                   // 0x2b
case DW_OP_le:                   // 0x2c
case DW_OP_lt:                   // 0x2d
case DW_OP_ne:                   // 0x2e
case DW_OP_lit0:                 // 0x30
case DW_OP_lit1:                 // 0x31
case DW_OP_lit2:                 // 0x32
case DW_OP_lit3:                 // 0x33
case DW_OP_lit4:                 // 0x34
case DW_OP_lit5:                 // 0x35
case DW_OP_lit6:                 // 0x36
case DW_OP_lit7:                 // 0x37
case DW_OP_lit8:                 // 0x38
case DW_OP_lit9:                 // 0x39
case DW_OP_lit10:                // 0x3A
case DW_OP_lit11:                // 0x3B
case DW_OP_lit12:                // 0x3C
case DW_OP_lit13:                // 0x3D
case DW_OP_lit14:                // 0x3E
case DW_OP_lit15:                // 0x3F
case DW_OP_lit16:                // 0x40
case DW_OP_lit17:                // 0x41
case DW_OP_lit18:                // 0x42
case DW_OP_lit19:                // 0x43
case DW_OP_lit20:                // 0x44
case DW_OP_lit21:                // 0x45
case DW_OP_lit22:                // 0x46
case DW_OP_lit23:                // 0x47
case DW_OP_lit24:                // 0x48
case DW_OP_lit25:                // 0x49
case DW_OP_lit26:                // 0x4A
case DW_OP_lit27:                // 0x4B
case DW_OP_lit28:                // 0x4C
case DW_OP_lit29:                // 0x4D
case DW_OP_lit30:                // 0x4E
case DW_OP_lit31:                // 0x4f
case DW_OP_reg0:                 // 0x50
case DW_OP_reg1:                 // 0x51
case DW_OP_reg2:                 // 0x52
case DW_OP_reg3:                 // 0x53
case DW_OP_reg4:                 // 0x54
case DW_OP_reg5:                 // 0x55
case DW_OP_reg6:                 // 0x56
case DW_OP_reg7:                 // 0x57
case DW_OP_reg8:                 // 0x58
case DW_OP_reg9:                 // 0x59
case DW_OP_reg10:                // 0x5A
case DW_OP_reg11:                // 0x5B
case DW_OP_reg12:                // 0x5C
case DW_OP_reg13:                // 0x5D
case DW_OP_reg14:                // 0x5E
case DW_OP_reg15:                // 0x5F
case DW_OP_reg16:                // 0x60
case DW_OP_reg17:                // 0x61
case DW_OP_reg18:                // 0x62
case DW_OP_reg19:                // 0x63
case DW_OP_reg20:                // 0x64
case DW_OP_reg21:                // 0x65
case DW_OP_reg22:                // 0x66
case DW_OP_reg23:                // 0x67
case DW_OP_reg24:                // 0x68
case DW_OP_reg25:                // 0x69
case DW_OP_reg26:                // 0x6A
case DW_OP_reg27:                // 0x6B
case DW_OP_reg28:                // 0x6C
case DW_OP_reg29:                // 0x6D
case DW_OP_reg30:                // 0x6E
case DW_OP_reg31:                // 0x6F
case DW_OP_nop:                  // 0x96
case DW_OP_push_object_address:  // 0x97 DWARF3
case DW_OP_form_tls_address:     // 0x9b DWARF3
case DW_OP_call_frame_cfa:       // 0x9c DWARF3
case DW_OP_stack_value:          // 0x9f DWARF4
case DW_OP_GNU_push_tls_address: // 0xe0 GNU extension
  return 0;

// Opcodes with a single 1 byte arguments
case DW_OP_const1u:     // 0x08 1 1-byte constant
case DW_OP_const1s:     // 0x09 1 1-byte constant
case DW_OP_pick:        // 0x15 1 1-byte stack index
case DW_OP_deref_size:  // 0x94 1 1-byte size of data retrieved
case DW_OP_xderef_size: // 0x95 1 1-byte size of data retrieved
  return 1;

// Opcodes with a single 2 byte arguments
case DW_OP_const2u: // 0x0a 1 2-byte constant
case DW_OP_const2s: // 0x0b 1 2-byte constant
case DW_OP_skip:    // 0x2f 1 signed 2-byte constant
case DW_OP_bra:     // 0x28 1 signed 2-byte constant
case DW_OP_call2:   // 0x98 1 2-byte offset of DIE (DWARF3)
  return 2;

// Opcodes with a single 4 byte arguments
case DW_OP_const4u: // 0x0c 1 4-byte constant
case DW_OP_const4s: // 0x0d 1 4-byte constant
case DW_OP_call4:   // 0x99 1 4-byte offset of DIE (DWARF3)
  return 4;

// Opcodes with a single 8 byte arguments
case DW_OP_const8u: // 0x0e 1 8-byte constant
case DW_OP_const8s: // 0x0f 1 8-byte constant
  return 8;

// All opcodes that have a single ULEB (signed or unsigned) argument
case DW_OP_addrx:           // 0xa1 1 ULEB128 index
case DW_OP_constu:          // 0x10 1 ULEB128 constant
case DW_OP_consts:          // 0x11 1 SLEB128 constant
case DW_OP_plus_uconst:     // 0x23 1 ULEB128 addend
case DW_OP_breg0:           // 0x70 1 ULEB128 register
case DW_OP_breg1:           // 0x71 1 ULEB128 register
case DW_OP_breg2:           // 0x72 1 ULEB128 register
case DW_OP_breg3:           // 0x73 1 ULEB128 register
case DW_OP_breg4:           // 0x74 1 ULEB128 register
case DW_OP_breg5:           // 0x75 1 ULEB128 register
case DW_OP_breg6:           // 0x76 1 ULEB128 register
case DW_OP_breg7:           // 0x77 1 ULEB128 register
case DW_OP_breg8:           // 0x78 1 ULEB128 register
case DW_OP_breg9:           // 0x79 1 ULEB128 register
case DW_OP_breg10:          // 0x7a 1 ULEB128 register
case DW_OP_breg11:          // 0x7b 1 ULEB128 register
case DW_OP_breg12:          // 0x7c 1 ULEB128 register
case DW_OP_breg13:          // 0x7d 1 ULEB128 register
case DW_OP_breg14:          // 0x7e 1 ULEB128 register
case DW_OP_breg15:          // 0x7f 1 ULEB128 register
case DW_OP_breg16:          // 0x80 1 ULEB128 register
case DW_OP_breg17:          // 0x81 1 ULEB128 register
case DW_OP_breg18:          // 0x82 1 ULEB128 register
case DW_OP_breg19:          // 0x83 1 ULEB128 register
case DW_OP_breg20:          // 0x84 1 ULEB128 register
case DW_OP_breg21:          // 0x85 1 ULEB128 register
case DW_OP_breg22:          // 0x86 1 ULEB128 register
case DW_OP_breg23:          // 0x87 1 ULEB128 register
case DW_OP_breg24:          // 0x88 1 ULEB128 register
case DW_OP_breg25:          // 0x89 1 ULEB128 register
case DW_OP_breg26:          // 0x8a 1 ULEB128 register
case DW_OP_breg27:          // 0x8b 1 ULEB128 register
case DW_OP_breg28:          // 0x8c 1 ULEB128 register
case DW_OP_breg29:          // 0x8d 1 ULEB128 register
case DW_OP_breg30:          // 0x8e 1 ULEB128 register
case DW_OP_breg31:          // 0x8f 1 ULEB128 register
case DW_OP_regx:            // 0x90 1 ULEB128 register
case DW_OP_fbreg:           // 0x91 1 SLEB128 offset
case DW_OP_piece:           // 0x93 1 ULEB128 size of piece addressed
case DW_OP_GNU_addr_index:  // 0xfb 1 ULEB128 index
case DW_OP_GNU_const_index: // 0xfc 1 ULEB128 index
  data.Skip_LEB128(&offset);
  return offset - data_offset;

// All opcodes that have a 2 ULEB (signed or unsigned) arguments
case DW_OP_bregx:     // 0x92 2 ULEB128 register followed by SLEB128 offset
case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
  data.Skip_LEB128(&offset);
  data.Skip_LEB128(&offset);
  return offset - data_offset;

case DW_OP_implicit_value: // 0x9e ULEB128 size followed by block of that size
                           // (DWARF4)
{
  uint64_t block_len = data.Skip_LEB128(&offset);
  offset += block_len;
  return offset - data_offset;
}

case DW_OP_GNU_entry_value:
case DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length block
{
  uint64_t subexpr_len = data.GetULEB128(&offset);
  return (offset - data_offset) + subexpr_len;
}

default:
  break;
}
return LLDB_INVALID_OFFSET0xffffffffffffffffULL;
408}

410lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx,
                                                   bool &error) const {
error = false;
if (IsLocationList())
  return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
lldb::offset_t offset = 0;
uint32_t curr_op_addr_idx = 0;
while (m_data.ValidOffset(offset)) {
  const uint8_t op = m_data.GetU8(&offset);

  if (op == DW_OP_addr) {
    const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
    if (curr_op_addr_idx == op_addr_idx)
      return op_file_addr;
    else
      ++curr_op_addr_idx;
  } else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) {
    uint64_t index = m_data.GetULEB128(&offset);
    if (curr_op_addr_idx == op_addr_idx) {
      if (!m_dwarf_cu) {
        error = true;
        break;
      }

      return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
    } else
      ++curr_op_addr_idx;
  } else {
    const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
    if (op_arg_size == LLDB_INVALID_OFFSET0xffffffffffffffffULL) {
      error = true;
      break;
    }
    offset += op_arg_size;
  }
}
return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
447}

449bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) {
if (IsLocationList())
  return false;
lldb::offset_t offset = 0;
while (m_data.ValidOffset(offset)) {
  const uint8_t op = m_data.GetU8(&offset);

  if (op == DW_OP_addr) {
    const uint32_t addr_byte_size = m_data.GetAddressByteSize();
    // We have to make a copy of the data as we don't know if this data is
    // from a read only memory mapped buffer, so we duplicate all of the data
    // first, then modify it, and if all goes well, we then replace the data
    // for this expression

    // So first we copy the data into a heap buffer
    std::unique_ptr<DataBufferHeap> head_data_up(
        new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize()));

    // Make en encoder so we can write the address into the buffer using the
    // correct byte order (endianness)
    DataEncoder encoder(head_data_up->GetBytes(), head_data_up->GetByteSize(),
                        m_data.GetByteOrder(), addr_byte_size);

    // Replace the address in the new buffer
    if (encoder.PutUnsigned(offset, addr_byte_size, file_addr) == UINT32_MAX0xffffffffU)
      return false;

    // All went well, so now we can reset the data using a shared pointer to
    // the heap data so "m_data" will now correctly manage the heap data.
    m_data.SetData(DataBufferSP(head_data_up.release()));
    return true;
  } else {
    const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
    if (op_arg_size == LLDB_INVALID_OFFSET0xffffffffffffffffULL)
      break;
    offset += op_arg_size;
  }
}
return false;
488}

490bool DWARFExpression::ContainsThreadLocalStorage() const {
// We are assuming for now that any thread local variable will not have a
// location list. This has been true for all thread local variables we have
// seen so far produced by any compiler.
if (IsLocationList())
  return false;
lldb::offset_t offset = 0;
while (m_data.ValidOffset(offset)) {
  const uint8_t op = m_data.GetU8(&offset);

  if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address)
    return true;
  const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
  if (op_arg_size == LLDB_INVALID_OFFSET0xffffffffffffffffULL)
    return false;
  else
    offset += op_arg_size;
}
return false;
509}
510bool DWARFExpression::LinkThreadLocalStorage(
  lldb::ModuleSP new_module_sp,
  std::function<lldb::addr_t(lldb::addr_t file_addr)> const
      &link_address_callback) {
// We are assuming for now that any thread local variable will not have a
// location list. This has been true for all thread local variables we have
// seen so far produced by any compiler.
if (IsLocationList())
  return false;

const uint32_t addr_byte_size = m_data.GetAddressByteSize();
// We have to make a copy of the data as we don't know if this data is from a
// read only memory mapped buffer, so we duplicate all of the data first,
// then modify it, and if all goes well, we then replace the data for this
// expression

// So first we copy the data into a heap buffer
std::shared_ptr<DataBufferHeap> heap_data_sp(
    new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize()));

// Make en encoder so we can write the address into the buffer using the
// correct byte order (endianness)
DataEncoder encoder(heap_data_sp->GetBytes(), heap_data_sp->GetByteSize(),
                    m_data.GetByteOrder(), addr_byte_size);

lldb::offset_t offset = 0;
lldb::offset_t const_offset = 0;
lldb::addr_t const_value = 0;
size_t const_byte_size = 0;
while (m_data.ValidOffset(offset)) {
  const uint8_t op = m_data.GetU8(&offset);

  bool decoded_data = false;
  switch (op) {
  case DW_OP_const4u:
    // Remember the const offset in case we later have a
    // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
    const_offset = offset;
    const_value = m_data.GetU32(&offset);
    decoded_data = true;
    const_byte_size = 4;
    break;

  case DW_OP_const8u:
    // Remember the const offset in case we later have a
    // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
    const_offset = offset;
    const_value = m_data.GetU64(&offset);
    decoded_data = true;
    const_byte_size = 8;
    break;

  case DW_OP_form_tls_address:
  case DW_OP_GNU_push_tls_address:
    // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded
    // by a file address on the stack. We assume that DW_OP_const4u or
    // DW_OP_const8u is used for these values, and we check that the last
    // opcode we got before either of these was DW_OP_const4u or
    // DW_OP_const8u. If so, then we can link the value accodingly. For
    // Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file
    // address of a structure that contains a function pointer, the pthread
    // key and the offset into the data pointed to by the pthread key. So we
    // must link this address and also set the module of this expression to
    // the new_module_sp so we can resolve the file address correctly
    if (const_byte_size > 0) {
      lldb::addr_t linked_file_addr = link_address_callback(const_value);
      if (linked_file_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
        return false;
      // Replace the address in the new buffer
      if (encoder.PutUnsigned(const_offset, const_byte_size,
                              linked_file_addr) == UINT32_MAX0xffffffffU)
        return false;
    }
    break;

  default:
    const_offset = 0;
    const_value = 0;
    const_byte_size = 0;
    break;
  }

  if (!decoded_data) {
    const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
    if (op_arg_size == LLDB_INVALID_OFFSET0xffffffffffffffffULL)
      return false;
    else
      offset += op_arg_size;
  }
}

// If we linked the TLS address correctly, update the module so that when the
// expression is evaluated it can resolve the file address to a load address
// and read the
// TLS data
m_module_wp = new_module_sp;
m_data.SetData(heap_data_sp);
return true;
608}

610bool DWARFExpression::LocationListContainsAddress(addr_t func_load_addr,
                                                lldb::addr_t addr) const {
if (func_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL || addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
  return false;

if (!IsLocationList())
  return false;

return GetLocationExpression(func_load_addr, addr) != llvm::None;
619}

621bool DWARFExpression::DumpLocationForAddress(Stream *s,
                                           lldb::DescriptionLevel level,
                                           addr_t func_load_addr,
                                           addr_t address, ABI *abi) {
if (!IsLocationList()) {
  DumpLocation(s, m_data, level, abi);
  return true;
}
if (llvm::Optional<DataExtractor> expr =
        GetLocationExpression(func_load_addr, address)) {
  DumpLocation(s, *expr, level, abi);
  return true;
}
return false;
635}

637static bool Evaluate_DW_OP_entry_value(std::vector<Value> &stack,
                                     ExecutionContext *exe_ctx,
                                     RegisterContext *reg_ctx,
                                     const DataExtractor &opcodes,
                                     lldb::offset_t &opcode_offset,
                                     Status *error_ptr, Log *log) {
// DW_OP_entry_value(sub-expr) describes the location a variable had upon
// function entry: this variable location is presumed to be optimized out at
// the current PC value.  The caller of the function may have call site
// information that describes an alternate location for the variable (e.g. a
// constant literal, or a spilled stack value) in the parent frame.
//
// Example (this is pseudo-code & pseudo-DWARF, but hopefully illustrative):
//
//     void child(int &sink, int x) {
//       ...
//       /* "x" gets optimized out. */
//
//       /* The location of "x" here is: DW_OP_entry_value($reg2). */
//       ++sink;
//     }
//
//     void parent() {
//       int sink;
//
//       /*
//        * The callsite information emitted here is:
//        *
//        * DW_TAG_call_site
//        *   DW_AT_return_pc ... (for "child(sink, 123);")
//        *   DW_TAG_call_site_parameter (for "sink")
//        *     DW_AT_location   ($reg1)
//        *     DW_AT_call_value ($SP - 8)
//        *   DW_TAG_call_site_parameter (for "x")
//        *     DW_AT_location   ($reg2)
//        *     DW_AT_call_value ($literal 123)
//        *
//        * DW_TAG_call_site
//        *   DW_AT_return_pc ... (for "child(sink, 456);")
//        *   ...
//        */
//       child(sink, 123);
//       child(sink, 456);
//     }
//
// When the program stops at "++sink" within `child`, the debugger determines
// the call site by analyzing the return address. Once the call site is found,
// the debugger determines which parameter is referenced by DW_OP_entry_value
// and evaluates the corresponding location for that parameter in `parent`.

// 1. Find the function which pushed the current frame onto the stack.
if ((!exe_ctx || !exe_ctx->HasTargetScope()) || !reg_ctx) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no exe/reg context")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no exe/reg context")
; } while (0);
  return false;
}

StackFrame *current_frame = exe_ctx->GetFramePtr();
Thread *thread = exe_ctx->GetThreadPtr();
if (!current_frame || !thread) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no current frame/thread")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no current frame/thread"
); } while (0);
  return false;
}

Target &target = exe_ctx->GetTargetRef();
StackFrameSP parent_frame = nullptr;
addr_t return_pc = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
uint32_t current_frame_idx = current_frame->GetFrameIndex();
uint32_t num_frames = thread->GetStackFrameCount();
for (uint32_t parent_frame_idx = current_frame_idx + 1;
     parent_frame_idx < num_frames; ++parent_frame_idx) {
  parent_frame = thread->GetStackFrameAtIndex(parent_frame_idx);
  // Require a valid sequence of frames.
  if (!parent_frame)
    break;

  // Record the first valid return address, even if this is an inlined frame,
  // in order to look up the associated call edge in the first non-inlined
  // parent frame.
  if (return_pc == LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
    return_pc = parent_frame->GetFrameCodeAddress().GetLoadAddress(&target);
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}"
, return_pc); } while (0)
             "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}"
, return_pc); } while (0)
             return_pc)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}"
, return_pc); } while (0);
  }

  // If we've found an inlined frame, skip it (these have no call site
  // parameters).
  if (parent_frame->IsInlined())
    continue;

  // We've found the first non-inlined parent frame.
  break;
}
if (!parent_frame || !parent_frame->GetRegisterContext()) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent frame with reg ctx")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no parent frame with reg ctx"
); } while (0);
  return false;
}

Function *parent_func =
    parent_frame->GetSymbolContext(eSymbolContextFunction).function;
if (!parent_func) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent function")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no parent function")
; } while (0);
  return false;
}

// 2. Find the call edge in the parent function responsible for creating the
//    current activation.
Function *current_func =
    current_frame->GetSymbolContext(eSymbolContextFunction).function;
if (!current_func) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no current function")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no current function"
); } while (0);
  return false;
}

CallEdge *call_edge = nullptr;
ModuleList &modlist = target.GetImages();
ExecutionContext parent_exe_ctx = *exe_ctx;
parent_exe_ctx.SetFrameSP(parent_frame);
if (!parent_frame->IsArtificial()) {
  // If the parent frame is not artificial, the current activation may be
  // produced by an ambiguous tail call. In this case, refuse to proceed.
  call_edge = parent_func->GetCallEdgeForReturnAddress(return_pc, target);
  if (!call_edge) {
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} "
 "in parent frame {1}", return_pc, parent_func->GetName())
; } while (0)
             "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} "
 "in parent frame {1}", return_pc, parent_func->GetName())
; } while (0)
             "in parent frame {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} "
 "in parent frame {1}", return_pc, parent_func->GetName())
; } while (0)
             return_pc, parent_func->GetName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} "
 "in parent frame {1}", return_pc, parent_func->GetName())
; } while (0);
    return false;
  }
  Function *callee_func = call_edge->GetCallee(modlist, parent_exe_ctx);
  if (callee_func != current_func) {
    LLDB_LOG(log, "Evaluate_DW_OP_entry_value: ambiguous call sequence, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: ambiguous call sequence, "
 "can't find real parent frame"); } while (0)
                  "can't find real parent frame")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: ambiguous call sequence, "
 "can't find real parent frame"); } while (0);
    return false;
  }
} else {
  // The StackFrameList solver machinery has deduced that an unambiguous tail
  // call sequence that produced the current activation.  The first edge in
  // the parent that points to the current function must be valid.
  for (auto &edge : parent_func->GetTailCallingEdges()) {
    if (edge->GetCallee(modlist, parent_exe_ctx) == current_func) {
      call_edge = edge.get();
      break;
    }
  }
}
if (!call_edge) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no unambiguous edge from parent "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no unambiguous edge from parent "
 "to current function"); } while (0)
                "to current function")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no unambiguous edge from parent "
 "to current function"); } while (0);
  return false;
}

// 3. Attempt to locate the DW_OP_entry_value expression in the set of
//    available call site parameters. If found, evaluate the corresponding
//    parameter in the context of the parent frame.
const uint32_t subexpr_len = opcodes.GetULEB128(&opcode_offset);
const void *subexpr_data = opcodes.GetData(&opcode_offset, subexpr_len);
if (!subexpr_data) {
  LLDB_LOG(log, "Evaluate_DW_OP_entry_value: subexpr could not be read")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: subexpr could not be read"
); } while (0);
  return false;
}

const CallSiteParameter *matched_param = nullptr;
for (const CallSiteParameter &param : call_edge->GetCallSiteParameters()) {
  DataExtractor param_subexpr_extractor;
  if (!param.LocationInCallee.GetExpressionData(param_subexpr_extractor))
    continue;
  lldb::offset_t param_subexpr_offset = 0;
  const void *param_subexpr_data =
      param_subexpr_extractor.GetData(&param_subexpr_offset, subexpr_len);
  if (!param_subexpr_data ||
      param_subexpr_extractor.BytesLeft(param_subexpr_offset) != 0)
    continue;

  // At this point, the DW_OP_entry_value sub-expression and the callee-side
  // expression in the call site parameter are known to have the same length.
  // Check whether they are equal.
  //
  // Note that an equality check is sufficient: the contents of the
  // DW_OP_entry_value subexpression are only used to identify the right call
  // site parameter in the parent, and do not require any special handling.
  if (memcmp(subexpr_data, param_subexpr_data, subexpr_len) == 0) {
    matched_param = &param;
    break;
  }
}
if (!matched_param) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no matching call site param found"
); } while (0)
           "Evaluate_DW_OP_entry_value: no matching call site param found")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: no matching call site param found"
); } while (0);
  return false;
}

// TODO: Add support for DW_OP_push_object_address within a DW_OP_entry_value
// subexpresion whenever llvm does.
Value result;
const DWARFExpression &param_expr = matched_param->LocationInCaller;
if (!param_expr.Evaluate(&parent_exe_ctx,
                         parent_frame->GetRegisterContext().get(),
                         /*loclist_base_addr=*/LLDB_INVALID_ADDRESS0xffffffffffffffffULL,
                         /*initial_value_ptr=*/nullptr,
                         /*object_address_ptr=*/nullptr, result, error_ptr)) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: call site param evaluation failed"
); } while (0)
           "Evaluate_DW_OP_entry_value: call site param evaluation failed")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_entry_value: call site param evaluation failed"
); } while (0);
  return false;
}

stack.push_back(result);
return true;
845}

847bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
                             lldb::addr_t loclist_base_load_addr,
                             const Value *initial_value_ptr,
                             const Value *object_address_ptr, Value &result,
                             Status *error_ptr) const {
ExecutionContext exe_ctx(exe_scope);
return Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, initial_value_ptr,
                object_address_ptr, result, error_ptr);
855}

857bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
                             RegisterContext *reg_ctx,
                             lldb::addr_t func_load_addr,
                             const Value *initial_value_ptr,
                             const Value *object_address_ptr, Value &result,
                             Status *error_ptr) const {
ModuleSP module_sp = m_module_wp.lock();

if (IsLocationList()) {
  addr_t pc;
  StackFrame *frame = nullptr;
  if (reg_ctx)
    pc = reg_ctx->GetPC();
  else {
    frame = exe_ctx->GetFramePtr();
    if (!frame)
      return false;
    RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
    if (!reg_ctx_sp)
      return false;
    pc = reg_ctx_sp->GetPC();
  }

  if (func_load_addr != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
    if (pc == LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
      if (error_ptr)
        error_ptr->SetErrorString("Invalid PC in frame.");
      return false;
    }

    if (llvm::Optional<DataExtractor> expr =
            GetLocationExpression(func_load_addr, pc)) {
      return DWARFExpression::Evaluate(
          exe_ctx, reg_ctx, module_sp, *expr, m_dwarf_cu, m_reg_kind,
          initial_value_ptr, object_address_ptr, result, error_ptr);
    }
  }
  if (error_ptr)
    error_ptr->SetErrorString("variable not available");
  return false;
}

// Not a location list, just a single expression.
return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, m_data,
                                 m_dwarf_cu, m_reg_kind, initial_value_ptr,
                                 object_address_ptr, result, error_ptr);
903}

905namespace {
906/// The location description kinds described by the DWARF v5
907/// specification.  Composite locations are handled out-of-band and
908/// thus aren't part of the enum.
909enum LocationDescriptionKind {
Empty,
Memory,
Register,
Implicit
/* Composite*/
915};
916/// Adjust value's ValueType according to the kind of location description.
917void UpdateValueTypeFromLocationDescription(Log *log, const DWARFUnit *dwarf_cu,
                                          LocationDescriptionKind kind,
                                          Value *value = nullptr) {
// Note that this function is conflating DWARF expressions with
// DWARF location descriptions. Perhaps it would be better to define
// a wrapper for DWARFExpresssion::Eval() that deals with DWARF
// location descriptions (which consist of one or more DWARF
// expressions). But doing this would mean we'd also need factor the
// handling of DW_OP_(bit_)piece out of this function.
if (dwarf_cu && dwarf_cu->GetVersion() >= 4) {
  const char *log_msg = "DWARF location description kind: %s";
  switch (kind) {
  case Empty:
    LLDB_LOGF(log, log_msg, "Empty")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf(log_msg, "Empty"); } while (0);
    break;
  case Memory:
    LLDB_LOGF(log, log_msg, "Memory")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf(log_msg, "Memory"); } while (0);
    if (value->GetValueType() == Value::ValueType::Scalar)
      value->SetValueType(Value::ValueType::LoadAddress);
    break;
  case Register:
    LLDB_LOGF(log, log_msg, "Register")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf(log_msg, "Register"); } while (0);
    value->SetValueType(Value::ValueType::Scalar);
    break;
  case Implicit:
    LLDB_LOGF(log, log_msg, "Implicit")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf(log_msg, "Implicit"); } while (0);
    if (value->GetValueType() == Value::ValueType::LoadAddress)
      value->SetValueType(Value::ValueType::Scalar);
    break;
  }
}
948}
949} // namespace

951bool DWARFExpression::Evaluate(
  ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
  lldb::ModuleSP module_sp, const DataExtractor &opcodes,
  const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind,
  const Value *initial_value_ptr, const Value *object_address_ptr,
  Value &result, Status *error_ptr) {

if (opcodes.GetByteSize() == 0) {
1
Assuming the condition is false→
2
←
Taking false branch→
  if (error_ptr)
    error_ptr->SetErrorString(
        "no location, value may have been optimized out");
  return false;
}
std::vector<Value> stack;

Process *process = nullptr;
StackFrame *frame = nullptr;

if (exe_ctx) {
3
←
Assuming 'exe_ctx' is null→
4
←
Taking false branch→
  process = exe_ctx->GetProcessPtr();
  frame = exe_ctx->GetFramePtr();
}
if (reg_ctx == nullptr && frame)
5
←
Assuming the condition is false→
  reg_ctx = frame->GetRegisterContext().get();

if (initial_value_ptr)
6
←
Assuming 'initial_value_ptr' is null→
7
←
Taking false branch→
  stack.push_back(*initial_value_ptr);

lldb::offset_t offset = 0;
Value tmp;
uint32_t reg_num;

/// Insertion point for evaluating multi-piece expression.
uint64_t op_piece_offset = 0;
Value pieces; // Used for DW_OP_piece

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
// A generic type is "an integral type that has the size of an address and an
// unspecified signedness". For now, just use the signedness of the operand.
// TODO: Implement a real typed stack, and store the genericness of the value
// there.
auto to_generic = [&](auto v) {
  bool is_signed = std::is_signed<decltype(v)>::value;
  return Scalar(llvm::APSInt(
      llvm::APInt(8 * opcodes.GetAddressByteSize(), v, is_signed),
      !is_signed));
};

// The default kind is a memory location. This is updated by any
// operation that changes this, such as DW_OP_stack_value, and reset
// by composition operations like DW_OP_piece.
LocationDescriptionKind dwarf4_location_description_kind = Memory;

while (opcodes.ValidOffset(offset)) {
8
←
Calling 'DataExtractor::ValidOffset'→
10
←
Returning from 'DataExtractor::ValidOffset'→
11
←
Loop condition is true.  Entering loop body→
  const lldb::offset_t op_offset = offset;
  const uint8_t op = opcodes.GetU8(&offset);

  if (log && log->GetVerbose()) {
12
←
Assuming 'log' is null→
    size_t count = stack.size();
    LLDB_LOGF(log, "Stack before operation has %" PRIu64 " values:",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Stack before operation has %" "llu"
 " values:", (uint64_t)count); } while (0)
              (uint64_t)count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Stack before operation has %" "llu"
 " values:", (uint64_t)count); } while (0);
    for (size_t i = 0; i < count; ++i) {
      StreamString new_value;
      new_value.Printf("[%" PRIu64"llu" "]", (uint64_t)i);
      stack[i].Dump(&new_value);
      LLDB_LOGF(log, "  %s", new_value.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("  %s", new_value.GetData()); } while
 (0);
    }
    LLDB_LOGF(log, "0x%8.8" PRIx64 ": %s", op_offset,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%8.8" "llx" ": %s", op_offset, DW_OP_value_to_name
(op)); } while (0)
              DW_OP_value_to_name(op))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%8.8" "llx" ": %s", op_offset, DW_OP_value_to_name
(op)); } while (0);
  }

  switch (op) {
13
←
Control jumps to 'case DW_OP_deref:'  at line 1078→
  // The DW_OP_addr operation has a single operand that encodes a machine
  // address and whose size is the size of an address on the target machine.
  case DW_OP_addr:
    stack.push_back(Scalar(opcodes.GetAddress(&offset)));
    stack.back().SetValueType(Value::ValueType::FileAddress);
    // Convert the file address to a load address, so subsequent
    // DWARF operators can operate on it.
    if (frame)
      stack.back().ConvertToLoadAddress(module_sp.get(),
                                        frame->CalculateTarget().get());
    break;

  // The DW_OP_addr_sect_offset4 is used for any location expressions in
  // shared libraries that have a location like:
  //  DW_OP_addr(0x1000)
  // If this address resides in a shared library, then this virtual address
  // won't make sense when it is evaluated in the context of a running
  // process where shared libraries have been slid. To account for this, this
  // new address type where we can store the section pointer and a 4 byte
  // offset.
  //      case DW_OP_addr_sect_offset4:
  //          {
  //              result_type = eResultTypeFileAddress;
  //              lldb::Section *sect = (lldb::Section
  //              *)opcodes.GetMaxU64(&offset, sizeof(void *));
  //              lldb::addr_t sect_offset = opcodes.GetU32(&offset);
  //
  //              Address so_addr (sect, sect_offset);
  //              lldb::addr_t load_addr = so_addr.GetLoadAddress();
  //              if (load_addr != LLDB_INVALID_ADDRESS)
  //              {
  //                  // We successfully resolve a file address to a load
  //                  // address.
  //                  stack.push_back(load_addr);
  //                  break;
  //              }
  //              else
  //              {
  //                  // We were able
  //                  if (error_ptr)
  //                      error_ptr->SetErrorStringWithFormat ("Section %s in
  //                      %s is not currently loaded.\n",
  //                      sect->GetName().AsCString(),
  //                      sect->GetModule()->GetFileSpec().GetFilename().AsCString());
  //                  return false;
  //              }
  //          }
  //          break;

  // OPCODE: DW_OP_deref
  // OPERANDS: none
  // DESCRIPTION: Pops the top stack entry and treats it as an address.
  // The value retrieved from that address is pushed. The size of the data
  // retrieved from the dereferenced address is the size of an address on the
  // target machine.
  case DW_OP_deref: {
    if (stack.empty()) {
14
←
Assuming the condition is false→
15
←
Taking false branch→
      if (error_ptr)
        error_ptr->SetErrorString("Expression stack empty for DW_OP_deref.");
      return false;
    }
    Value::ValueType value_type = stack.back().GetValueType();
    switch (value_type) {
16
←
Control jumps to 'case FileAddress:'  at line 1093→
    case Value::ValueType::HostAddress: {
      void *src = (void *)stack.back().GetScalar().ULongLong();
      intptr_t ptr;
      ::memcpy(&ptr, src, sizeof(void *));
      stack.back().GetScalar() = ptr;
      stack.back().ClearContext();
    } break;
    case Value::ValueType::FileAddress: {
      auto file_addr = stack.back().GetScalar().ULongLong(
          LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
      if (!module_sp) {
17
←
Calling 'shared_ptr::operator bool'→
20
←
Returning from 'shared_ptr::operator bool'→
21
←
Taking false branch→
        if (error_ptr)
          error_ptr->SetErrorString(
              "need module to resolve file address for DW_OP_deref");
        return false;
      }
      Address so_addr;
      if (!module_sp->ResolveFileAddress(file_addr, so_addr)) {
22
←
Assuming the condition is false→
23
←
Taking false branch→
        if (error_ptr)
          error_ptr->SetErrorString(
              "failed to resolve file address in module");
        return false;
      }
      addr_t load_Addr = so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
24
←
Called C++ object pointer is null
      if (load_Addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
        if (error_ptr)
          error_ptr->SetErrorString("failed to resolve load address");
        return false;
      }
      stack.back().GetScalar() = load_Addr;
      // Fall through to load address promotion code below.
    } LLVM_FALLTHROUGH[[gnu::fallthrough]];
    case Value::ValueType::Scalar:
      // Promote Scalar to LoadAddress and fall through.
      stack.back().SetValueType(Value::ValueType::LoadAddress);
      LLVM_FALLTHROUGH[[gnu::fallthrough]];
    case Value::ValueType::LoadAddress:
      if (exe_ctx) {
        if (process) {
          lldb::addr_t pointer_addr =
              stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
          Status error;
          lldb::addr_t pointer_value =
              process->ReadPointerFromMemory(pointer_addr, error);
          if (pointer_value != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
            if (ABISP abi_sp = process->GetABI())
              pointer_value = abi_sp->FixCodeAddress(pointer_value);
            stack.back().GetScalar() = pointer_value;
            stack.back().ClearContext();
          } else {
            if (error_ptr)
              error_ptr->SetErrorStringWithFormat(
                  "Failed to dereference pointer from 0x%" PRIx64"llx"
                  " for DW_OP_deref: %s\n",
                  pointer_addr, error.AsCString());
            return false;
          }
        } else {
          if (error_ptr)
            error_ptr->SetErrorString("NULL process for DW_OP_deref.\n");
          return false;
        }
      } else {
        if (error_ptr)
          error_ptr->SetErrorString(
              "NULL execution context for DW_OP_deref.\n");
        return false;
      }
      break;

    case Value::ValueType::Invalid:
      if (error_ptr)
        error_ptr->SetErrorString("Invalid value type for DW_OP_deref.\n");
      return false;
    }

  } break;

  // OPCODE: DW_OP_deref_size
  // OPERANDS: 1
  //  1 - uint8_t that specifies the size of the data to dereference.
  // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top
  // stack entry and treats it as an address. The value retrieved from that
  // address is pushed. In the DW_OP_deref_size operation, however, the size
  // in bytes of the data retrieved from the dereferenced address is
  // specified by the single operand. This operand is a 1-byte unsigned
  // integral constant whose value may not be larger than the size of an
  // address on the target machine. The data retrieved is zero extended to
  // the size of an address on the target machine before being pushed on the
  // expression stack.
  case DW_OP_deref_size: {
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack empty for DW_OP_deref_size.");
      return false;
    }
    uint8_t size = opcodes.GetU8(&offset);
    Value::ValueType value_type = stack.back().GetValueType();
    switch (value_type) {
    case Value::ValueType::HostAddress: {
      void *src = (void *)stack.back().GetScalar().ULongLong();
      intptr_t ptr;
      ::memcpy(&ptr, src, sizeof(void *));
      // I can't decide whether the size operand should apply to the bytes in
      // their
      // lldb-host endianness or the target endianness.. I doubt this'll ever
      // come up but I'll opt for assuming big endian regardless.
      switch (size) {
      case 1:
        ptr = ptr & 0xff;
        break;
      case 2:
        ptr = ptr & 0xffff;
        break;
      case 3:
        ptr = ptr & 0xffffff;
        break;
      case 4:
        ptr = ptr & 0xffffffff;
        break;
      // the casts are added to work around the case where intptr_t is a 32
      // bit quantity;
      // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this
      // program.
      case 5:
        ptr = (intptr_t)ptr & 0xffffffffffULL;
        break;
      case 6:
        ptr = (intptr_t)ptr & 0xffffffffffffULL;
        break;
      case 7:
        ptr = (intptr_t)ptr & 0xffffffffffffffULL;
        break;
      default:
        break;
      }
      stack.back().GetScalar() = ptr;
      stack.back().ClearContext();
    } break;
    case Value::ValueType::Scalar:
    case Value::ValueType::LoadAddress:
      if (exe_ctx) {
        if (process) {
          lldb::addr_t pointer_addr =
              stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
          uint8_t addr_bytes[sizeof(lldb::addr_t)];
          Status error;
          if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
              size) {
            DataExtractor addr_data(addr_bytes, sizeof(addr_bytes),
                                    process->GetByteOrder(), size);
            lldb::offset_t addr_data_offset = 0;
            switch (size) {
            case 1:
              stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset);
              break;
            case 2:
              stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset);
              break;
            case 4:
              stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset);
              break;
            case 8:
              stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset);
              break;
            default:
              stack.back().GetScalar() =
                  addr_data.GetAddress(&addr_data_offset);
            }
            stack.back().ClearContext();
          } else {
            if (error_ptr)
              error_ptr->SetErrorStringWithFormat(
                  "Failed to dereference pointer from 0x%" PRIx64"llx"
                  " for DW_OP_deref: %s\n",
                  pointer_addr, error.AsCString());
            return false;
          }
        } else {
          if (error_ptr)
            error_ptr->SetErrorString("NULL process for DW_OP_deref_size.\n");
          return false;
        }
      } else {
        if (error_ptr)
          error_ptr->SetErrorString(
              "NULL execution context for DW_OP_deref_size.\n");
        return false;
      }
      break;

    case Value::ValueType::FileAddress:
    case Value::ValueType::Invalid:
      if (error_ptr)
        error_ptr->SetErrorString("Invalid value for DW_OP_deref_size.\n");
      return false;
    }

  } break;

  // OPCODE: DW_OP_xderef_size
  // OPERANDS: 1
  //  1 - uint8_t that specifies the size of the data to dereference.
  // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at
  // the top of the stack is treated as an address. The second stack entry is
  // treated as an "address space identifier" for those architectures that
  // support multiple address spaces. The top two stack elements are popped,
  // a data item is retrieved through an implementation-defined address
  // calculation and pushed as the new stack top. In the DW_OP_xderef_size
  // operation, however, the size in bytes of the data retrieved from the
  // dereferenced address is specified by the single operand. This operand is
  // a 1-byte unsigned integral constant whose value may not be larger than
  // the size of an address on the target machine. The data retrieved is zero
  // extended to the size of an address on the target machine before being
  // pushed on the expression stack.
  case DW_OP_xderef_size:
    if (error_ptr)
      error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size.");
    return false;
  // OPCODE: DW_OP_xderef
  // OPERANDS: none
  // DESCRIPTION: Provides an extended dereference mechanism. The entry at
  // the top of the stack is treated as an address. The second stack entry is
  // treated as an "address space identifier" for those architectures that
  // support multiple address spaces. The top two stack elements are popped,
  // a data item is retrieved through an implementation-defined address
  // calculation and pushed as the new stack top. The size of the data
  // retrieved from the dereferenced address is the size of an address on the
  // target machine.
  case DW_OP_xderef:
    if (error_ptr)
      error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef.");
    return false;

  // All DW_OP_constXXX opcodes have a single operand as noted below:
  //
  // Opcode           Operand 1
  // DW_OP_const1u    1-byte unsigned integer constant
  // DW_OP_const1s    1-byte signed integer constant
  // DW_OP_const2u    2-byte unsigned integer constant
  // DW_OP_const2s    2-byte signed integer constant
  // DW_OP_const4u    4-byte unsigned integer constant
  // DW_OP_const4s    4-byte signed integer constant
  // DW_OP_const8u    8-byte unsigned integer constant
  // DW_OP_const8s    8-byte signed integer constant
  // DW_OP_constu     unsigned LEB128 integer constant
  // DW_OP_consts     signed LEB128 integer constant
  case DW_OP_const1u:
    stack.push_back(to_generic(opcodes.GetU8(&offset)));
    break;
  case DW_OP_const1s:
    stack.push_back(to_generic((int8_t)opcodes.GetU8(&offset)));
    break;
  case DW_OP_const2u:
    stack.push_back(to_generic(opcodes.GetU16(&offset)));
    break;
  case DW_OP_const2s:
    stack.push_back(to_generic((int16_t)opcodes.GetU16(&offset)));
    break;
  case DW_OP_const4u:
    stack.push_back(to_generic(opcodes.GetU32(&offset)));
    break;
  case DW_OP_const4s:
    stack.push_back(to_generic((int32_t)opcodes.GetU32(&offset)));
    break;
  case DW_OP_const8u:
    stack.push_back(to_generic(opcodes.GetU64(&offset)));
    break;
  case DW_OP_const8s:
    stack.push_back(to_generic((int64_t)opcodes.GetU64(&offset)));
    break;
  // These should also use to_generic, but we can't do that due to a
  // producer-side bug in llvm. See llvm.org/pr48087.
  case DW_OP_constu:
    stack.push_back(Scalar(opcodes.GetULEB128(&offset)));
    break;
  case DW_OP_consts:
    stack.push_back(Scalar(opcodes.GetSLEB128(&offset)));
    break;

  // OPCODE: DW_OP_dup
  // OPERANDS: none
  // DESCRIPTION: duplicates the value at the top of the stack
  case DW_OP_dup:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString("Expression stack empty for DW_OP_dup.");
      return false;
    } else
      stack.push_back(stack.back());
    break;

  // OPCODE: DW_OP_drop
  // OPERANDS: none
  // DESCRIPTION: pops the value at the top of the stack
  case DW_OP_drop:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString("Expression stack empty for DW_OP_drop.");
      return false;
    } else
      stack.pop_back();
    break;

  // OPCODE: DW_OP_over
  // OPERANDS: none
  // DESCRIPTION: Duplicates the entry currently second in the stack at
  // the top of the stack.
  case DW_OP_over:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_over.");
      return false;
    } else
      stack.push_back(stack[stack.size() - 2]);
    break;

  // OPCODE: DW_OP_pick
  // OPERANDS: uint8_t index into the current stack
  // DESCRIPTION: The stack entry with the specified index (0 through 255,
  // inclusive) is pushed on the stack
  case DW_OP_pick: {
    uint8_t pick_idx = opcodes.GetU8(&offset);
    if (pick_idx < stack.size())
      stack.push_back(stack[stack.size() - 1 - pick_idx]);
    else {
      if (error_ptr)
        error_ptr->SetErrorStringWithFormat(
            "Index %u out of range for DW_OP_pick.\n", pick_idx);
      return false;
    }
  } break;

  // OPCODE: DW_OP_swap
  // OPERANDS: none
  // DESCRIPTION: swaps the top two stack entries. The entry at the top
  // of the stack becomes the second stack entry, and the second entry
  // becomes the top of the stack
  case DW_OP_swap:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_swap.");
      return false;
    } else {
      tmp = stack.back();
      stack.back() = stack[stack.size() - 2];
      stack[stack.size() - 2] = tmp;
    }
    break;

  // OPCODE: DW_OP_rot
  // OPERANDS: none
  // DESCRIPTION: Rotates the first three stack entries. The entry at
  // the top of the stack becomes the third stack entry, the second entry
  // becomes the top of the stack, and the third entry becomes the second
  // entry.
  case DW_OP_rot:
    if (stack.size() < 3) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 3 items for DW_OP_rot.");
      return false;
    } else {
      size_t last_idx = stack.size() - 1;
      Value old_top = stack[last_idx];
      stack[last_idx] = stack[last_idx - 1];
      stack[last_idx - 1] = stack[last_idx - 2];
      stack[last_idx - 2] = old_top;
    }
    break;

  // OPCODE: DW_OP_abs
  // OPERANDS: none
  // DESCRIPTION: pops the top stack entry, interprets it as a signed
  // value and pushes its absolute value. If the absolute value can not be
  // represented, the result is undefined.
  case DW_OP_abs:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_abs.");
      return false;
    } else if (!stack.back().ResolveValue(exe_ctx).AbsoluteValue()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Failed to take the absolute value of the first stack item.");
      return false;
    }
    break;

  // OPCODE: DW_OP_and
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, performs a bitwise and
  // operation on the two, and pushes the result.
  case DW_OP_and:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_and.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) & tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_div
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, divides the former second
  // entry by the former top of the stack using signed division, and pushes
  // the result.
  case DW_OP_div:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_div.");
      return false;
    } else {
      tmp = stack.back();
      if (tmp.ResolveValue(exe_ctx).IsZero()) {
        if (error_ptr)
          error_ptr->SetErrorString("Divide by zero.");
        return false;
      } else {
        stack.pop_back();
        stack.back() =
            stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx);
        if (!stack.back().ResolveValue(exe_ctx).IsValid()) {
          if (error_ptr)
            error_ptr->SetErrorString("Divide failed.");
          return false;
        }
      }
    }
    break;

  // OPCODE: DW_OP_minus
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, subtracts the former top
  // of the stack from the former second entry, and pushes the result.
  case DW_OP_minus:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_minus.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) - tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_mod
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values and pushes the result of
  // the calculation: former second stack entry modulo the former top of the
  // stack.
  case DW_OP_mod:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_mod.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) % tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_mul
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, multiplies them
  // together, and pushes the result.
  case DW_OP_mul:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_mul.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) * tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_neg
  // OPERANDS: none
  // DESCRIPTION: pops the top stack entry, and pushes its negation.
  case DW_OP_neg:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_neg.");
      return false;
    } else {
      if (!stack.back().ResolveValue(exe_ctx).UnaryNegate()) {
        if (error_ptr)
          error_ptr->SetErrorString("Unary negate failed.");
        return false;
      }
    }
    break;

  // OPCODE: DW_OP_not
  // OPERANDS: none
  // DESCRIPTION: pops the top stack entry, and pushes its bitwise
  // complement
  case DW_OP_not:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_not.");
      return false;
    } else {
      if (!stack.back().ResolveValue(exe_ctx).OnesComplement()) {
        if (error_ptr)
          error_ptr->SetErrorString("Logical NOT failed.");
        return false;
      }
    }
    break;

  // OPCODE: DW_OP_or
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, performs a bitwise or
  // operation on the two, and pushes the result.
  case DW_OP_or:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_or.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) | tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_plus
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, adds them together, and
  // pushes the result.
  case DW_OP_plus:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_plus.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().GetScalar() += tmp.GetScalar();
    }
    break;

  // OPCODE: DW_OP_plus_uconst
  // OPERANDS: none
  // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128
  // constant operand and pushes the result.
  case DW_OP_plus_uconst:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_plus_uconst.");
      return false;
    } else {
      const uint64_t uconst_value = opcodes.GetULEB128(&offset);
      // Implicit conversion from a UINT to a Scalar...
      stack.back().GetScalar() += uconst_value;
      if (!stack.back().GetScalar().IsValid()) {
        if (error_ptr)
          error_ptr->SetErrorString("DW_OP_plus_uconst failed.");
        return false;
      }
    }
    break;

  // OPCODE: DW_OP_shl
  // OPERANDS: none
  // DESCRIPTION:  pops the top two stack entries, shifts the former
  // second entry left by the number of bits specified by the former top of
  // the stack, and pushes the result.
  case DW_OP_shl:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_shl.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) <<= tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_shr
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, shifts the former second
  // entry right logically (filling with zero bits) by the number of bits
  // specified by the former top of the stack, and pushes the result.
  case DW_OP_shr:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_shr.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      if (!stack.back().ResolveValue(exe_ctx).ShiftRightLogical(
              tmp.ResolveValue(exe_ctx))) {
        if (error_ptr)
          error_ptr->SetErrorString("DW_OP_shr failed.");
        return false;
      }
    }
    break;

  // OPCODE: DW_OP_shra
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, shifts the former second
  // entry right arithmetically (divide the magnitude by 2, keep the same
  // sign for the result) by the number of bits specified by the former top
  // of the stack, and pushes the result.
  case DW_OP_shra:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_shra.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) >>= tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_xor
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack entries, performs the bitwise
  // exclusive-or operation on the two, and pushes the result.
  case DW_OP_xor:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_xor.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) ^ tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_skip
  // OPERANDS: int16_t
  // DESCRIPTION:  An unconditional branch. Its single operand is a 2-byte
  // signed integer constant. The 2-byte constant is the number of bytes of
  // the DWARF expression to skip forward or backward from the current
  // operation, beginning after the 2-byte constant.
  case DW_OP_skip: {
    int16_t skip_offset = (int16_t)opcodes.GetU16(&offset);
    lldb::offset_t new_offset = offset + skip_offset;
    if (opcodes.ValidOffset(new_offset))
      offset = new_offset;
    else {
      if (error_ptr)
        error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip.");
      return false;
    }
  } break;

  // OPCODE: DW_OP_bra
  // OPERANDS: int16_t
  // DESCRIPTION: A conditional branch. Its single operand is a 2-byte
  // signed integer constant. This operation pops the top of stack. If the
  // value popped is not the constant 0, the 2-byte constant operand is the
  // number of bytes of the DWARF expression to skip forward or backward from
  // the current operation, beginning after the 2-byte constant.
  case DW_OP_bra:
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_bra.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      int16_t bra_offset = (int16_t)opcodes.GetU16(&offset);
      Scalar zero(0);
      if (tmp.ResolveValue(exe_ctx) != zero) {
        lldb::offset_t new_offset = offset + bra_offset;
        if (opcodes.ValidOffset(new_offset))
          offset = new_offset;
        else {
          if (error_ptr)
            error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra.");
          return false;
        }
      }
    }
    break;

  // OPCODE: DW_OP_eq
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // equals (==) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_eq:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_eq.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) == tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_ge
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // greater than or equal to (>=) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_ge:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_ge.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) >= tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_gt
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // greater than (>) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_gt:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_gt.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) > tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_le
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // less than or equal to (<=) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_le:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_le.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) <= tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_lt
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // less than (<) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_lt:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_lt.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) < tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_ne
  // OPERANDS: none
  // DESCRIPTION: pops the top two stack values, compares using the
  // not equal (!=) operator.
  // STACK RESULT: push the constant value 1 onto the stack if the result
  // of the operation is true or the constant value 0 if the result of the
  // operation is false.
  case DW_OP_ne:
    if (stack.size() < 2) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 2 items for DW_OP_ne.");
      return false;
    } else {
      tmp = stack.back();
      stack.pop_back();
      stack.back().ResolveValue(exe_ctx) =
          stack.back().ResolveValue(exe_ctx) != tmp.ResolveValue(exe_ctx);
    }
    break;

  // OPCODE: DW_OP_litn
  // OPERANDS: none
  // DESCRIPTION: encode the unsigned literal values from 0 through 31.
  // STACK RESULT: push the unsigned literal constant value onto the top
  // of the stack.
  case DW_OP_lit0:
  case DW_OP_lit1:
  case DW_OP_lit2:
  case DW_OP_lit3:
  case DW_OP_lit4:
  case DW_OP_lit5:
  case DW_OP_lit6:
  case DW_OP_lit7:
  case DW_OP_lit8:
  case DW_OP_lit9:
  case DW_OP_lit10:
  case DW_OP_lit11:
  case DW_OP_lit12:
  case DW_OP_lit13:
  case DW_OP_lit14:
  case DW_OP_lit15:
  case DW_OP_lit16:
  case DW_OP_lit17:
  case DW_OP_lit18:
  case DW_OP_lit19:
  case DW_OP_lit20:
  case DW_OP_lit21:
  case DW_OP_lit22:
  case DW_OP_lit23:
  case DW_OP_lit24:
  case DW_OP_lit25:
  case DW_OP_lit26:
  case DW_OP_lit27:
  case DW_OP_lit28:
  case DW_OP_lit29:
  case DW_OP_lit30:
  case DW_OP_lit31:
    stack.push_back(to_generic(op - DW_OP_lit0));
    break;

  // OPCODE: DW_OP_regN
  // OPERANDS: none
  // DESCRIPTION: Push the value in register n on the top of the stack.
  case DW_OP_reg0:
  case DW_OP_reg1:
  case DW_OP_reg2:
  case DW_OP_reg3:
  case DW_OP_reg4:
  case DW_OP_reg5:
  case DW_OP_reg6:
  case DW_OP_reg7:
  case DW_OP_reg8:
  case DW_OP_reg9:
  case DW_OP_reg10:
  case DW_OP_reg11:
  case DW_OP_reg12:
  case DW_OP_reg13:
  case DW_OP_reg14:
  case DW_OP_reg15:
  case DW_OP_reg16:
  case DW_OP_reg17:
  case DW_OP_reg18:
  case DW_OP_reg19:
  case DW_OP_reg20:
  case DW_OP_reg21:
  case DW_OP_reg22:
  case DW_OP_reg23:
  case DW_OP_reg24:
  case DW_OP_reg25:
  case DW_OP_reg26:
  case DW_OP_reg27:
  case DW_OP_reg28:
  case DW_OP_reg29:
  case DW_OP_reg30:
  case DW_OP_reg31: {
    dwarf4_location_description_kind = Register;
    reg_num = op - DW_OP_reg0;

    if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp))
      stack.push_back(tmp);
    else
      return false;
  } break;
  // OPCODE: DW_OP_regx
  // OPERANDS:
  //      ULEB128 literal operand that encodes the register.
  // DESCRIPTION: Push the value in register on the top of the stack.
  case DW_OP_regx: {
    dwarf4_location_description_kind = Register;
    reg_num = opcodes.GetULEB128(&offset);
    if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp))
      stack.push_back(tmp);
    else
      return false;
  } break;

  // OPCODE: DW_OP_bregN
  // OPERANDS:
  //      SLEB128 offset from register N
  // DESCRIPTION: Value is in memory at the address specified by register
  // N plus an offset.
  case DW_OP_breg0:
  case DW_OP_breg1:
  case DW_OP_breg2:
  case DW_OP_breg3:
  case DW_OP_breg4:
  case DW_OP_breg5:
  case DW_OP_breg6:
  case DW_OP_breg7:
  case DW_OP_breg8:
  case DW_OP_breg9:
  case DW_OP_breg10:
  case DW_OP_breg11:
  case DW_OP_breg12:
  case DW_OP_breg13:
  case DW_OP_breg14:
  case DW_OP_breg15:
  case DW_OP_breg16:
  case DW_OP_breg17:
  case DW_OP_breg18:
  case DW_OP_breg19:
  case DW_OP_breg20:
  case DW_OP_breg21:
  case DW_OP_breg22:
  case DW_OP_breg23:
  case DW_OP_breg24:
  case DW_OP_breg25:
  case DW_OP_breg26:
  case DW_OP_breg27:
  case DW_OP_breg28:
  case DW_OP_breg29:
  case DW_OP_breg30:
  case DW_OP_breg31: {
    reg_num = op - DW_OP_breg0;

    if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
                                  tmp)) {
      int64_t breg_offset = opcodes.GetSLEB128(&offset);
      tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
      tmp.ClearContext();
      stack.push_back(tmp);
      stack.back().SetValueType(Value::ValueType::LoadAddress);
    } else
      return false;
  } break;
  // OPCODE: DW_OP_bregx
  // OPERANDS: 2
  //      ULEB128 literal operand that encodes the register.
  //      SLEB128 offset from register N
  // DESCRIPTION: Value is in memory at the address specified by register
  // N plus an offset.
  case DW_OP_bregx: {
    reg_num = opcodes.GetULEB128(&offset);

    if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
                                  tmp)) {
      int64_t breg_offset = opcodes.GetSLEB128(&offset);
      tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
      tmp.ClearContext();
      stack.push_back(tmp);
      stack.back().SetValueType(Value::ValueType::LoadAddress);
    } else
      return false;
  } break;

  case DW_OP_fbreg:
    if (exe_ctx) {
      if (frame) {
        Scalar value;
        if (frame->GetFrameBaseValue(value, error_ptr)) {
          int64_t fbreg_offset = opcodes.GetSLEB128(&offset);
          value += fbreg_offset;
          stack.push_back(value);
          stack.back().SetValueType(Value::ValueType::LoadAddress);
        } else
          return false;
      } else {
        if (error_ptr)
          error_ptr->SetErrorString(
              "Invalid stack frame in context for DW_OP_fbreg opcode.");
        return false;
      }
    } else {
      if (error_ptr)
        error_ptr->SetErrorString(
            "NULL execution context for DW_OP_fbreg.\n");
      return false;
    }

    break;

  // OPCODE: DW_OP_nop
  // OPERANDS: none
  // DESCRIPTION: A place holder. It has no effect on the location stack
  // or any of its values.
  case DW_OP_nop:
    break;

  // OPCODE: DW_OP_piece
  // OPERANDS: 1
  //      ULEB128: byte size of the piece
  // DESCRIPTION: The operand describes the size in bytes of the piece of
  // the object referenced by the DWARF expression whose result is at the top
  // of the stack. If the piece is located in a register, but does not occupy
  // the entire register, the placement of the piece within that register is
  // defined by the ABI.
  //
  // Many compilers store a single variable in sets of registers, or store a
  // variable partially in memory and partially in registers. DW_OP_piece
  // provides a way of describing how large a part of a variable a particular
  // DWARF expression refers to.
  case DW_OP_piece: {
    LocationDescriptionKind piece_locdesc = dwarf4_location_description_kind;
    // Reset for the next piece.
    dwarf4_location_description_kind = Memory;

    const uint64_t piece_byte_size = opcodes.GetULEB128(&offset);

    if (piece_byte_size > 0) {
      Value curr_piece;

      if (stack.empty()) {
        UpdateValueTypeFromLocationDescription(
            log, dwarf_cu, LocationDescriptionKind::Empty);
        // In a multi-piece expression, this means that the current piece is
        // not available. Fill with zeros for now by resizing the data and
        // appending it
        curr_piece.ResizeData(piece_byte_size);
        // Note that "0" is not a correct value for the unknown bits.
        // It would be better to also return a mask of valid bits together
        // with the expression result, so the debugger can print missing
        // members as "<optimized out>" or something.
        ::memset(curr_piece.GetBuffer().GetBytes(), 0, piece_byte_size);
        pieces.AppendDataToHostBuffer(curr_piece);
      } else {
        Status error;
        // Extract the current piece into "curr_piece"
        Value curr_piece_source_value(stack.back());
        stack.pop_back();
        UpdateValueTypeFromLocationDescription(log, dwarf_cu, piece_locdesc,
                                               &curr_piece_source_value);

        const Value::ValueType curr_piece_source_value_type =
            curr_piece_source_value.GetValueType();
        switch (curr_piece_source_value_type) {
        case Value::ValueType::Invalid:
          return false;
        case Value::ValueType::LoadAddress:
          if (process) {
            if (curr_piece.ResizeData(piece_byte_size) == piece_byte_size) {
              lldb::addr_t load_addr =
                  curr_piece_source_value.GetScalar().ULongLong(
                      LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
              if (process->ReadMemory(
                      load_addr, curr_piece.GetBuffer().GetBytes(),
                      piece_byte_size, error) != piece_byte_size) {
                if (error_ptr)
                  error_ptr->SetErrorStringWithFormat(
                      "failed to read memory DW_OP_piece(%" PRIu64"llu"
                      ") from 0x%" PRIx64"llx",
                      piece_byte_size, load_addr);
                return false;
              }
            } else {
              if (error_ptr)
                error_ptr->SetErrorStringWithFormat(
                    "failed to resize the piece memory buffer for "
                    "DW_OP_piece(%" PRIu64"llu" ")",
                    piece_byte_size);
              return false;
            }
          }
          break;

        case Value::ValueType::FileAddress:
        case Value::ValueType::HostAddress:
          if (error_ptr) {
            lldb::addr_t addr = curr_piece_source_value.GetScalar().ULongLong(
                LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
            error_ptr->SetErrorStringWithFormat(
                "failed to read memory DW_OP_piece(%" PRIu64"llu"
                ") from %s address 0x%" PRIx64"llx",
                piece_byte_size, curr_piece_source_value.GetValueType() ==
                                         Value::ValueType::FileAddress
                                     ? "file"
                                     : "host",
                addr);
          }
          return false;

        case Value::ValueType::Scalar: {
          uint32_t bit_size = piece_byte_size * 8;
          uint32_t bit_offset = 0;
          Scalar &scalar = curr_piece_source_value.GetScalar();
          if (!scalar.ExtractBitfield(
                  bit_size, bit_offset)) {
            if (error_ptr)
              error_ptr->SetErrorStringWithFormat(
                  "unable to extract %" PRIu64"llu" " bytes from a %" PRIu64"llu"
                  " byte scalar value.",
                  piece_byte_size,
                  (uint64_t)curr_piece_source_value.GetScalar()
                      .GetByteSize());
            return false;
          }
          // Create curr_piece with bit_size. By default Scalar
          // grows to the nearest host integer type.
          llvm::APInt fail_value(1, 0, false);
          llvm::APInt ap_int = scalar.UInt128(fail_value);
          assert(ap_int.getBitWidth() >= bit_size)((void)0);
          llvm::ArrayRef<uint64_t> buf{ap_int.getRawData(),
                                       ap_int.getNumWords()};
          curr_piece.GetScalar() = Scalar(llvm::APInt(bit_size, buf));
        } break;
        }

        // Check if this is the first piece?
        if (op_piece_offset == 0) {
          // This is the first piece, we should push it back onto the stack
          // so subsequent pieces will be able to access this piece and add
          // to it.
          if (pieces.AppendDataToHostBuffer(curr_piece) == 0) {
            if (error_ptr)
              error_ptr->SetErrorString("failed to append piece data");
            return false;
          }
        } else {
          // If this is the second or later piece there should be a value on
          // the stack.
          if (pieces.GetBuffer().GetByteSize() != op_piece_offset) {
            if (error_ptr)
              error_ptr->SetErrorStringWithFormat(
                  "DW_OP_piece for offset %" PRIu64"llu"
                  " but top of stack is of size %" PRIu64"llu",
                  op_piece_offset, pieces.GetBuffer().GetByteSize());
            return false;
          }

          if (pieces.AppendDataToHostBuffer(curr_piece) == 0) {
            if (error_ptr)
              error_ptr->SetErrorString("failed to append piece data");
            return false;
          }
        }
      }
      op_piece_offset += piece_byte_size;
    }
  } break;

  case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
    if (stack.size() < 1) {
      UpdateValueTypeFromLocationDescription(log, dwarf_cu,
                                             LocationDescriptionKind::Empty);
      // Reset for the next piece.
      dwarf4_location_description_kind = Memory;
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_bit_piece.");
      return false;
    } else {
      UpdateValueTypeFromLocationDescription(
          log, dwarf_cu, dwarf4_location_description_kind, &stack.back());
      // Reset for the next piece.
      dwarf4_location_description_kind = Memory;
      const uint64_t piece_bit_size = opcodes.GetULEB128(&offset);
      const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset);
      switch (stack.back().GetValueType()) {
      case Value::ValueType::Invalid:
        return false;
      case Value::ValueType::Scalar: {
        if (!stack.back().GetScalar().ExtractBitfield(piece_bit_size,
                                                      piece_bit_offset)) {
          if (error_ptr)
            error_ptr->SetErrorStringWithFormat(
                "unable to extract %" PRIu64"llu" " bit value with %" PRIu64"llu"
                " bit offset from a %" PRIu64"llu" " bit scalar value.",
                piece_bit_size, piece_bit_offset,
                (uint64_t)(stack.back().GetScalar().GetByteSize() * 8));
          return false;
        }
      } break;

      case Value::ValueType::FileAddress:
      case Value::ValueType::LoadAddress:
      case Value::ValueType::HostAddress:
        if (error_ptr) {
          error_ptr->SetErrorStringWithFormat(
              "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64"llu"
              ", bit_offset = %" PRIu64"llu" ") from an address value.",
              piece_bit_size, piece_bit_offset);
        }
        return false;
      }
    }
    break;

  // OPCODE: DW_OP_implicit_value
  // OPERANDS: 2
  //      ULEB128  size of the value block in bytes
  //      uint8_t* block bytes encoding value in target's memory
  //      representation
  // DESCRIPTION: Value is immediately stored in block in the debug info with
  // the memory representation of the target.
  case DW_OP_implicit_value: {
    dwarf4_location_description_kind = Implicit;

    const uint32_t len = opcodes.GetULEB128(&offset);
    const void *data = opcodes.GetData(&offset, len);

    if (!data) {
      LLDB_LOG(log, "Evaluate_DW_OP_implicit_value: could not be read data")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "Evaluate_DW_OP_implicit_value: could not be read data"
); } while (0);
      LLDB_ERRORF(error_ptr, "Could not evaluate %s.",do { if (error_ptr) { (error_ptr)->SetErrorStringWithFormat
(("Could not evaluate %s."), DW_OP_value_to_name(op)); } } while
 (0);
                  DW_OP_value_to_name(op))do { if (error_ptr) { (error_ptr)->SetErrorStringWithFormat
(("Could not evaluate %s."), DW_OP_value_to_name(op)); } } while
 (0);;
      return false;
    }

    Value result(data, len);
    stack.push_back(result);
    break;
  }

  case DW_OP_implicit_pointer: {
    dwarf4_location_description_kind = Implicit;
    LLDB_ERRORF(error_ptr, "Could not evaluate %s.", DW_OP_value_to_name(op))do { if (error_ptr) { (error_ptr)->SetErrorStringWithFormat
(("Could not evaluate %s."), DW_OP_value_to_name(op)); } } while
 (0);;
    return false;
  }

  // OPCODE: DW_OP_push_object_address
  // OPERANDS: none
  // DESCRIPTION: Pushes the address of the object currently being
  // evaluated as part of evaluation of a user presented expression. This
  // object may correspond to an independent variable described by its own
  // DIE or it may be a component of an array, structure, or class whose
  // address has been dynamically determined by an earlier step during user
  // expression evaluation.
  case DW_OP_push_object_address:
    if (object_address_ptr)
      stack.push_back(*object_address_ptr);
    else {
      if (error_ptr)
        error_ptr->SetErrorString("DW_OP_push_object_address used without "
                                  "specifying an object address");
      return false;
    }
    break;

  // OPCODE: DW_OP_call2
  // OPERANDS:
  //      uint16_t compile unit relative offset of a DIE
  // DESCRIPTION: Performs subroutine calls during evaluation
  // of a DWARF expression. The operand is the 2-byte unsigned offset of a
  // debugging information entry in the current compilation unit.
  //
  // Operand interpretation is exactly like that for DW_FORM_ref2.
  //
  // This operation transfers control of DWARF expression evaluation to the
  // DW_AT_location attribute of the referenced DIE. If there is no such
  // attribute, then there is no effect. Execution of the DWARF expression of
  // a DW_AT_location attribute may add to and/or remove from values on the
  // stack. Execution returns to the point following the call when the end of
  // the attribute is reached. Values on the stack at the time of the call
  // may be used as parameters by the called expression and values left on
  // the stack by the called expression may be used as return values by prior
  // agreement between the calling and called expressions.
  case DW_OP_call2:
    if (error_ptr)
      error_ptr->SetErrorString("Unimplemented opcode DW_OP_call2.");
    return false;
  // OPCODE: DW_OP_call4
  // OPERANDS: 1
  //      uint32_t compile unit relative offset of a DIE
  // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF
  // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset of
  // a debugging information entry in  the current compilation unit.
  //
  // Operand interpretation DW_OP_call4 is exactly like that for
  // DW_FORM_ref4.
  //
  // This operation transfers control of DWARF expression evaluation to the
  // DW_AT_location attribute of the referenced DIE. If there is no such
  // attribute, then there is no effect. Execution of the DWARF expression of
  // a DW_AT_location attribute may add to and/or remove from values on the
  // stack. Execution returns to the point following the call when the end of
  // the attribute is reached. Values on the stack at the time of the call
  // may be used as parameters by the called expression and values left on
  // the stack by the called expression may be used as return values by prior
  // agreement between the calling and called expressions.
  case DW_OP_call4:
    if (error_ptr)
      error_ptr->SetErrorString("Unimplemented opcode DW_OP_call4.");
    return false;

  // OPCODE: DW_OP_stack_value
  // OPERANDS: None
  // DESCRIPTION: Specifies that the object does not exist in memory but
  // rather is a constant value.  The value from the top of the stack is the
  // value to be used.  This is the actual object value and not the location.
  case DW_OP_stack_value:
    dwarf4_location_description_kind = Implicit;
    if (stack.empty()) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_stack_value.");
      return false;
    }
    stack.back().SetValueType(Value::ValueType::Scalar);
    break;

  // OPCODE: DW_OP_convert
  // OPERANDS: 1
  //      A ULEB128 that is either a DIE offset of a
  //      DW_TAG_base_type or 0 for the generic (pointer-sized) type.
  //
  // DESCRIPTION: Pop the top stack element, convert it to a
  // different type, and push the result.
  case DW_OP_convert: {
    if (stack.size() < 1) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "Expression stack needs at least 1 item for DW_OP_convert.");
      return false;
    }
    const uint64_t die_offset = opcodes.GetULEB128(&offset);
    uint64_t bit_size;
    bool sign;
    if (die_offset == 0) {
      // The generic type has the size of an address on the target
      // machine and an unspecified signedness. Scalar has no
      // "unspecified signedness", so we use unsigned types.
      if (!module_sp) {
        if (error_ptr)
          error_ptr->SetErrorString("No module");
        return false;
      }
      sign = false;
      bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8;
      if (!bit_size) {
        if (error_ptr)
          error_ptr->SetErrorString("unspecified architecture");
        return false;
      }
    } else {
      // Retrieve the type DIE that the value is being converted to.
      // FIXME: the constness has annoying ripple effects.
      DWARFDIE die = const_cast<DWARFUnit *>(dwarf_cu)->GetDIE(die_offset);
      if (!die) {
        if (error_ptr)
          error_ptr->SetErrorString("Cannot resolve DW_OP_convert type DIE");
        return false;
      }
      uint64_t encoding =
          die.GetAttributeValueAsUnsigned(DW_AT_encoding, DW_ATE_hi_user);
      bit_size = die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
      if (!bit_size)
        bit_size = die.GetAttributeValueAsUnsigned(DW_AT_bit_size, 0);
      if (!bit_size) {
        if (error_ptr)
          error_ptr->SetErrorString("Unsupported type size in DW_OP_convert");
        return false;
      }
      switch (encoding) {
      case DW_ATE_signed:
      case DW_ATE_signed_char:
        sign = true;
        break;
      case DW_ATE_unsigned:
      case DW_ATE_unsigned_char:
        sign = false;
        break;
      default:
        if (error_ptr)
          error_ptr->SetErrorString("Unsupported encoding in DW_OP_convert");
        return false;
      }
    }
    Scalar &top = stack.back().ResolveValue(exe_ctx);
    top.TruncOrExtendTo(bit_size, sign);
    break;
  }

  // OPCODE: DW_OP_call_frame_cfa
  // OPERANDS: None
  // DESCRIPTION: Specifies a DWARF expression that pushes the value of
  // the canonical frame address consistent with the call frame information
  // located in .debug_frame (or in the FDEs of the eh_frame section).
  case DW_OP_call_frame_cfa:
    if (frame) {
      // Note that we don't have to parse FDEs because this DWARF expression
      // is commonly evaluated with a valid stack frame.
      StackID id = frame->GetStackID();
      addr_t cfa = id.GetCallFrameAddress();
      if (cfa != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
        stack.push_back(Scalar(cfa));
        stack.back().SetValueType(Value::ValueType::LoadAddress);
      } else if (error_ptr)
        error_ptr->SetErrorString("Stack frame does not include a canonical "
                                  "frame address for DW_OP_call_frame_cfa "
                                  "opcode.");
    } else {
      if (error_ptr)
        error_ptr->SetErrorString("Invalid stack frame in context for "
                                  "DW_OP_call_frame_cfa opcode.");
      return false;
    }
    break;

  // OPCODE: DW_OP_form_tls_address (or the old pre-DWARFv3 vendor extension
  // opcode, DW_OP_GNU_push_tls_address)
  // OPERANDS: none
  // DESCRIPTION: Pops a TLS offset from the stack, converts it to
  // an address in the current thread's thread-local storage block, and
  // pushes it on the stack.
  case DW_OP_form_tls_address:
  case DW_OP_GNU_push_tls_address: {
    if (stack.size() < 1) {
      if (error_ptr) {
        if (op == DW_OP_form_tls_address)
          error_ptr->SetErrorString(
              "DW_OP_form_tls_address needs an argument.");
        else
          error_ptr->SetErrorString(
              "DW_OP_GNU_push_tls_address needs an argument.");
      }
      return false;
    }

    if (!exe_ctx || !module_sp) {
      if (error_ptr)
        error_ptr->SetErrorString("No context to evaluate TLS within.");
      return false;
    }

    Thread *thread = exe_ctx->GetThreadPtr();
    if (!thread) {
      if (error_ptr)
        error_ptr->SetErrorString("No thread to evaluate TLS within.");
      return false;
    }

    // Lookup the TLS block address for this thread and module.
    const addr_t tls_file_addr =
        stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
    const addr_t tls_load_addr =
        thread->GetThreadLocalData(module_sp, tls_file_addr);

    if (tls_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
      if (error_ptr)
        error_ptr->SetErrorString(
            "No TLS data currently exists for this thread.");
      return false;
    }

    stack.back().GetScalar() = tls_load_addr;
    stack.back().SetValueType(Value::ValueType::LoadAddress);
  } break;

  // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.)
  // OPERANDS: 1
  //      ULEB128: index to the .debug_addr section
  // DESCRIPTION: Pushes an address to the stack from the .debug_addr
  // section with the base address specified by the DW_AT_addr_base attribute
  // and the 0 based index is the ULEB128 encoded index.
  case DW_OP_addrx:
  case DW_OP_GNU_addr_index: {
    if (!dwarf_cu) {
      if (error_ptr)
        error_ptr->SetErrorString("DW_OP_GNU_addr_index found without a "
                                  "compile unit being specified");
      return false;
    }
    uint64_t index = opcodes.GetULEB128(&offset);
    lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index);
    stack.push_back(Scalar(value));
    stack.back().SetValueType(Value::ValueType::FileAddress);
  } break;

  // OPCODE: DW_OP_GNU_const_index
  // OPERANDS: 1
  //      ULEB128: index to the .debug_addr section
  // DESCRIPTION: Pushes an constant with the size of a machine address to
  // the stack from the .debug_addr section with the base address specified
  // by the DW_AT_addr_base attribute and the 0 based index is the ULEB128
  // encoded index.
  case DW_OP_GNU_const_index: {
    if (!dwarf_cu) {
      if (error_ptr)
        error_ptr->SetErrorString("DW_OP_GNU_const_index found without a "
                                  "compile unit being specified");
      return false;
    }
    uint64_t index = opcodes.GetULEB128(&offset);
    lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index);
    stack.push_back(Scalar(value));
  } break;

  case DW_OP_GNU_entry_value:
  case DW_OP_entry_value: {
    if (!Evaluate_DW_OP_entry_value(stack, exe_ctx, reg_ctx, opcodes, offset,
                                    error_ptr, log)) {
      LLDB_ERRORF(error_ptr, "Could not evaluate %s.",do { if (error_ptr) { (error_ptr)->SetErrorStringWithFormat
(("Could not evaluate %s."), DW_OP_value_to_name(op)); } } while
 (0);
                  DW_OP_value_to_name(op))do { if (error_ptr) { (error_ptr)->SetErrorStringWithFormat
(("Could not evaluate %s."), DW_OP_value_to_name(op)); } } while
 (0);;
      return false;
    }
    break;
  }

  default:
    if (error_ptr)
      error_ptr->SetErrorStringWithFormatv(
          "Unhandled opcode {0} in DWARFExpression", LocationAtom(op));
    return false;
  }
}

if (stack.empty()) {
  // Nothing on the stack, check if we created a piece value from DW_OP_piece
  // or DW_OP_bit_piece opcodes
  if (pieces.GetBuffer().GetByteSize()) {
    result = pieces;
    return true;
  }
  if (error_ptr)
    error_ptr->SetErrorString("Stack empty after evaluation.");
  return false;
}

UpdateValueTypeFromLocationDescription(
    log, dwarf_cu, dwarf4_location_description_kind, &stack.back());

if (log && log->GetVerbose()) {
  size_t count = stack.size();
  LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Stack after operation has %" "llu" " values:"
, (uint64_t)count); } while (0)
            "Stack after operation has %" PRIu64 " values:", (uint64_t)count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Stack after operation has %" "llu" " values:"
, (uint64_t)count); } while (0);
  for (size_t i = 0; i < count; ++i) {
    StreamString new_value;
    new_value.Printf("[%" PRIu64"llu" "]", (uint64_t)i);
    stack[i].Dump(&new_value);
    LLDB_LOGF(log, "  %s", new_value.GetData())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("  %s", new_value.GetData()); } while
 (0);
  }
}
result = stack.back();
return true; // Return true on success
2671}

2673static DataExtractor ToDataExtractor(const llvm::DWARFLocationExpression &loc,
                                   ByteOrder byte_order, uint32_t addr_size) {
auto buffer_sp =
    std::make_shared<DataBufferHeap>(loc.Expr.data(), loc.Expr.size());
return DataExtractor(buffer_sp, byte_order, addr_size);
2678}

2680llvm::Optional<DataExtractor>
2681DWARFExpression::GetLocationExpression(addr_t load_function_start,
                                     addr_t addr) const {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8));

std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
    m_dwarf_cu->GetLocationTable(m_data);
llvm::Optional<DataExtractor> result;
uint64_t offset = 0;
auto lookup_addr =
    [&](uint32_t index) -> llvm::Optional<llvm::object::SectionedAddress> {
  addr_t address = ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
  if (address == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
    return llvm::None;
  return llvm::object::SectionedAddress{address};
};
auto process_list = [&](llvm::Expected<llvm::DWARFLocationExpression> loc) {
  if (!loc) {
    LLDB_LOG_ERROR(log, loc.takeError(), "{0}")do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (loc.takeError()); if (log_private && error_private
) { log_private->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "{0}"); } else ::llvm::consumeError(::std::move(error_private
)); } while (0);
    return true;
  }
  if (loc->Range) {
    // This relocates low_pc and high_pc by adding the difference between the
    // function file address, and the actual address it is loaded in memory.
    addr_t slide = load_function_start - m_loclist_addresses->func_file_addr;
    loc->Range->LowPC += slide;
    loc->Range->HighPC += slide;

    if (loc->Range->LowPC <= addr && addr < loc->Range->HighPC)
      result = ToDataExtractor(*loc, m_data.GetByteOrder(),
                               m_data.GetAddressByteSize());
  }
  return !result;
};
llvm::Error E = loctable_up->visitAbsoluteLocationList(
    offset, llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr},
    lookup_addr, process_list);
if (E)
  LLDB_LOG_ERROR(log, std::move(E), "{0}")do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (std::move(E)); if (log_private && error_private) {
 log_private->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/source/Expression/DWARFExpression.cpp"
, __func__, "{0}"); } else ::llvm::consumeError(::std::move(error_private
)); } while (0);
return result;
2720}

2722bool DWARFExpression::MatchesOperand(StackFrame &frame,
                                   const Instruction::Operand &operand) {
using namespace OperandMatchers;

RegisterContextSP reg_ctx_sp = frame.GetRegisterContext();
if (!reg_ctx_sp) {
  return false;
}

DataExtractor opcodes;
if (IsLocationList()) {
  SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction);
  if (!sc.function)
    return false;

  addr_t load_function_start =
      sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
  if (load_function_start == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
    return false;

  addr_t pc = frame.GetFrameCodeAddress().GetLoadAddress(
      frame.CalculateTarget().get());

  if (llvm::Optional<DataExtractor> expr = GetLocationExpression(load_function_start, pc))
    opcodes = std::move(*expr);
  else
    return false;
} else
  opcodes = m_data;


lldb::offset_t op_offset = 0;
uint8_t opcode = opcodes.GetU8(&op_offset);

if (opcode == DW_OP_fbreg) {
  int64_t offset = opcodes.GetSLEB128(&op_offset);

  DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr);
  if (!fb_expr) {
    return false;
  }

  auto recurse = [&frame, fb_expr](const Instruction::Operand &child) {
    return fb_expr->MatchesOperand(frame, child);
  };

  if (!offset &&
      MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
                   recurse)(operand)) {
    return true;
  }

  return MatchUnaryOp(
      MatchOpType(Instruction::Operand::Type::Dereference),
      MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
                    MatchImmOp(offset), recurse))(operand);
}

bool dereference = false;
const RegisterInfo *reg = nullptr;
int64_t offset = 0;

if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) {
  reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_reg0);
} else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) {
  offset = opcodes.GetSLEB128(&op_offset);
  reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_breg0);
} else if (opcode == DW_OP_regx) {
  uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
  reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
} else if (opcode == DW_OP_bregx) {
  uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
  offset = opcodes.GetSLEB128(&op_offset);
  reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
} else {
  return false;
}

if (!reg) {
  return false;
}

if (dereference) {
  if (!offset &&
      MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
                   MatchRegOp(*reg))(operand)) {
    return true;
  }

  return MatchUnaryOp(
      MatchOpType(Instruction::Operand::Type::Dereference),
      MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
                    MatchRegOp(*reg),
                    MatchImmOp(offset)))(operand);
} else {
  return MatchRegOp(*reg)(operand);
}
2819}


←

/usr/src/gnu/usr.bin/clang/liblldbExpression/../../../llvm/lldb/include/lldb/Utility/DataExtractor.h

→

1//===-- DataExtractor.h -----------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#ifndef LLDB_UTILITY_DATAEXTRACTOR_H
10#define LLDB_UTILITY_DATAEXTRACTOR_H

12#include "lldb/Utility/Endian.h"
13#include "lldb/lldb-defines.h"
14#include "lldb/lldb-enumerations.h"
15#include "lldb/lldb-forward.h"
16#include "lldb/lldb-types.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/Support/DataExtractor.h"
19#include "llvm/Support/SwapByteOrder.h"

21#include <cassert>
22#include <cstdint>
23#include <cstring>

25namespace lldb_private {
26class Log;
27class Stream;
28}
29namespace llvm {
30template <typename T> class SmallVectorImpl;
31}


34namespace lldb_private {

36/// \class DataExtractor DataExtractor.h "lldb/Core/DataExtractor.h" An data
37/// extractor class.
38///
39/// DataExtractor is a class that can extract data (swapping if needed) from a
40/// data buffer. The data buffer can be caller owned, or can be shared data
41/// that can be shared between multiple DataExtractor instances. Multiple
42/// DataExtractor objects can share the same data, yet extract values in
43/// different address sizes and byte order modes. Each object can have a
44/// unique position in the shared data and extract data from different
45/// offsets.
46///
47/// \see DataBuffer
48class DataExtractor {
49public:
/// \typedef DataExtractor::Type
/// Type enumerations used in the dump routines.
enum Type {
  TypeUInt8,   ///< Format output as unsigned 8 bit integers
  TypeChar,    ///< Format output as characters
  TypeUInt16,  ///< Format output as unsigned 16 bit integers
  TypeUInt32,  ///< Format output as unsigned 32 bit integers
  TypeUInt64,  ///< Format output as unsigned 64 bit integers
  TypePointer, ///< Format output as pointers
  TypeULEB128, ///< Format output as ULEB128 numbers
  TypeSLEB128  ///< Format output as SLEB128 numbers
};

/// Default constructor.
///
/// Initialize all members to a default empty state.
DataExtractor();

/// Construct with a buffer that is owned by the caller.
///
/// This constructor allows us to use data that is owned by the caller. The
/// data must stay around as long as this object is valid.
///
/// \param[in] data
///     A pointer to caller owned data.
///
/// \param[in] data_length
///     The length in bytes of \a data.
///
/// \param[in] byte_order
///     A byte order of the data that we are extracting from.
///
/// \param[in] addr_size
///     A new address byte size value.
///
/// \param[in] target_byte_size
///     A size of a target byte in 8-bit host bytes
DataExtractor(const void *data, lldb::offset_t data_length,
              lldb::ByteOrder byte_order, uint32_t addr_size,
              uint32_t target_byte_size = 1);

/// Construct with shared data.
///
/// Copies the data shared pointer which adds a reference to the contained
/// in \a data_sp. The shared data reference is reference counted to ensure
/// the data lives as long as anyone still has a valid shared pointer to the
/// data in \a data_sp.
///
/// \param[in] data_sp
///     A shared pointer to data.
///
/// \param[in] byte_order
///     A byte order of the data that we are extracting from.
///
/// \param[in] addr_size
///     A new address byte size value.
///
/// \param[in] target_byte_size
///     A size of a target byte in 8-bit host bytes
DataExtractor(const lldb::DataBufferSP &data_sp, lldb::ByteOrder byte_order,
              uint32_t addr_size, uint32_t target_byte_size = 1);

/// Construct with a subset of \a data.
///
/// Initialize this object with a subset of the data bytes in \a data. If \a
/// data contains shared data, then a reference to the shared data will be
/// added to ensure the shared data stays around as long as any objects have
/// references to the shared data. The byte order value and the address size
/// settings are copied from \a data. If \a offset is not a valid offset in
/// \a data, then no reference to the shared data will be added. If there
/// are not \a length bytes available in \a data starting at \a offset, the
/// length will be truncated to contain as many bytes as possible.
///
/// \param[in] data
///     Another DataExtractor object that contains data.
///
/// \param[in] offset
///     The offset into \a data at which the subset starts.
///
/// \param[in] length
///     The length in bytes of the subset of data.
///
/// \param[in] target_byte_size
///     A size of a target byte in 8-bit host bytes
DataExtractor(const DataExtractor &data, lldb::offset_t offset,
              lldb::offset_t length, uint32_t target_byte_size = 1);

DataExtractor(const DataExtractor &rhs);

/// Assignment operator.
///
/// Copies all data, byte order and address size settings from \a rhs into
/// this object. If \a rhs contains shared data, a reference to that shared
/// data will be added.
///
/// \param[in] rhs
///     Another DataExtractor object to copy.
///
/// \return
///     A const reference to this object.
const DataExtractor &operator=(const DataExtractor &rhs);

/// Destructor
///
/// If this object contains a valid shared data reference, the reference
/// count on the data will be decremented, and if zero, the data will be
/// freed.
virtual ~DataExtractor();

uint32_t getTargetByteSize() const { return m_target_byte_size; }

/// Clears the object state.
///
/// Clears the object contents back to a default invalid state, and release
/// any references to shared data that this object may contain.
void Clear();

/// Dumps the binary data as \a type objects to stream \a s (or to Log() if
/// \a s is nullptr) starting \a offset bytes into the data and stopping
/// after dumping \a length bytes. The offset into the data is displayed at
/// the beginning of each line and can be offset by base address \a
/// base_addr. \a num_per_line objects will be displayed on each line.
///
/// \param[in] log
///     The log to dump the output to.
///
/// \param[in] offset
///     The offset into the data at which to start dumping.
///
/// \param[in] length
///     The number of bytes to dump.
///
/// \param[in] base_addr
///     The base address that gets added to the offset displayed on
///     each line.
///
/// \param[in] num_per_line
///     The number of \a type objects to display on each line.
///
/// \param[in] type
///     The type of objects to use when dumping data from this
///     object. See DataExtractor::Type.
///
/// \return
///     The offset at which dumping ended.
lldb::offset_t PutToLog(Log *log, lldb::offset_t offset,
                        lldb::offset_t length, uint64_t base_addr,
                        uint32_t num_per_line, Type type) const;

/// Extract an arbitrary number of bytes in the specified byte order.
///
/// Attemps to extract \a length bytes starting at \a offset bytes into this
/// data in the requested byte order (\a dst_byte_order) and place the
/// results in \a dst. \a dst must be at least \a length bytes long.
///
/// \param[in] offset
///     The offset in bytes into the contained data at which to
///     start extracting.
///
/// \param[in] length
///     The number of bytes to extract.
///
/// \param[in] dst_byte_order
///     A byte order of the data that we want when the value in
///     copied to \a dst.
///
/// \param[out] dst
///     The buffer that will receive the extracted value if there
///     are enough bytes available in the current data.
///
/// \return
///     The number of bytes that were extracted which will be \a
///     length when the value is successfully extracted, or zero
///     if there aren't enough bytes at the specified offset.
size_t ExtractBytes(lldb::offset_t offset, lldb::offset_t length,
                    lldb::ByteOrder dst_byte_order, void *dst) const;

/// Extract an address from \a *offset_ptr.
///
/// Extract a single address from the data and update the offset pointed to
/// by \a offset_ptr. The size of the extracted address comes from the \a
/// m_addr_size member variable and should be set correctly prior to
/// extracting any address values.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted address value.
uint64_t GetAddress(lldb::offset_t *offset_ptr) const;

uint64_t GetAddress_unchecked(lldb::offset_t *offset_ptr) const;

/// Get the current address size.
///
/// Return the size in bytes of any address values this object will extract.
///
/// \return
///     The size in bytes of address values that will be extracted.
uint32_t GetAddressByteSize() const { return m_addr_size; }

/// Get the number of bytes contained in this object.
///
/// \return
///     The total number of bytes of data this object refers to.
uint64_t GetByteSize() const { return m_end - m_start; }

/// Extract a C string from \a *offset_ptr.
///
/// Returns a pointer to a C String from the data at the offset pointed to
/// by \a offset_ptr. A variable length NULL terminated C string will be
/// extracted and the \a offset_ptr will be updated with the offset of the
/// byte that follows the NULL terminator byte.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     A pointer to the C string value in the data. If the offset
///     pointed to by \a offset_ptr is out of bounds, or if the
///     offset plus the length of the C string is out of bounds,
///     nullptr will be returned.
const char *GetCStr(lldb::offset_t *offset_ptr) const;

/// Extract a C string from \a *offset_ptr with field size \a len.
///
/// Returns a pointer to a C String from the data at the offset pointed to
/// by \a offset_ptr, with a field length of \a len.
/// A NULL terminated C string will be extracted and the \a offset_ptr
/// will be updated with the offset of the byte that follows the fixed
/// length field.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     A pointer to the C string value in the data. If the offset
///     pointed to by \a offset_ptr is out of bounds, or if the
///     offset plus the length of the field is out of bounds, or if
///     the field does not contain a NULL terminator byte, nullptr will
///     be returned.
const char *GetCStr(lldb::offset_t *offset_ptr, lldb::offset_t len) const;

/// Extract \a length bytes from \a *offset_ptr.
///
/// Returns a pointer to a bytes in this object's data at the offset pointed
/// to by \a offset_ptr. If \a length is zero or too large, then the offset
/// pointed to by \a offset_ptr will not be updated and nullptr will be
/// returned.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] length
///     The optional length of a string to extract. If the value is
///     zero, a NULL terminated C string will be extracted.
///
/// \return
///     A pointer to the bytes in this object's data if the offset
///     and length are valid, or nullptr otherwise.
const void *GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const {
  const uint8_t *ptr = PeekData(*offset_ptr, length);
  if (ptr)
    *offset_ptr += length;
  return ptr;
}

/// Copy \a length bytes from \a *offset, without swapping bytes.
///
/// \param[in] offset
///     The offset into this data from which to start copying
///
/// \param[in] length
///     The length of the data to copy from this object
///
/// \param[out] dst
///     The buffer to place the output data.
///
/// \return
///     Returns the number of bytes that were copied, or zero if
///     anything goes wrong.
lldb::offset_t CopyData(lldb::offset_t offset, lldb::offset_t length,
                        void *dst) const;

/// Copy \a dst_len bytes from \a *offset_ptr and ensure the copied data is
/// treated as a value that can be swapped to match the specified byte
/// order.
///
/// For values that are larger than the supported integer sizes, this
/// function can be used to extract data in a specified byte order. It can
/// also be used to copy a smaller integer value from to a larger value. The
/// extra bytes left over will be padded correctly according to the byte
/// order of this object and the \a dst_byte_order. This can be very handy
/// when say copying a partial data value into a register.
///
/// \param[in] src_offset
///     The offset into this data from which to start copying an endian
///     entity
///
/// \param[in] src_len
///     The length of the endian data to copy from this object into the \a
///     dst object
///
/// \param[out] dst
///     The buffer where to place the endian data. The data might need to be
///     byte swapped (and appropriately padded with zeroes if \a src_len !=
///     \a dst_len) if \a dst_byte_order does not match the byte order in
///     this object.
///
/// \param[in] dst_len
///     The length number of bytes that the endian value will occupy is \a
///     dst.
///
/// \param[in] dst_byte_order
///     The byte order that the endian value should be in the \a dst buffer.
///
/// \return
///     Returns the number of bytes that were copied, or zero if anything
///     goes wrong.
lldb::offset_t CopyByteOrderedData(lldb::offset_t src_offset,
                                   lldb::offset_t src_len, void *dst,
                                   lldb::offset_t dst_len,
                                   lldb::ByteOrder dst_byte_order) const;

/// Get the data end pointer.
///
/// \return
///     Returns a pointer to the next byte contained in this
///     object's data, or nullptr of there is no data in this object.
const uint8_t *GetDataEnd() const { return m_end; }

/// Get the shared data offset.
///
/// Get the offset of the first byte of data in the shared data (if any).
///
/// \return
///     If this object contains shared data, this function returns
///     the offset in bytes into that shared data, zero otherwise.
size_t GetSharedDataOffset() const;

/// Get the data start pointer.
///
/// \return
///     Returns a pointer to the first byte contained in this
///     object's data, or nullptr of there is no data in this object.
const uint8_t *GetDataStart() const { return m_start; }

/// Extract a float from \a *offset_ptr.
///
/// Extract a single float value.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The floating value that was extracted, or zero on failure.
float GetFloat(lldb::offset_t *offset_ptr) const;

double GetDouble(lldb::offset_t *offset_ptr) const;

long double GetLongDouble(lldb::offset_t *offset_ptr) const;

/// Extract an integer of size \a byte_size from \a *offset_ptr.
///
/// Extract a single integer value and update the offset pointed to by \a
/// offset_ptr. The size of the extracted integer is specified by the \a
/// byte_size argument. \a byte_size must have a value >= 1 and <= 4 since
/// the return value is only 32 bits wide.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] byte_size
///     The size in byte of the integer to extract.
///
/// \return
///     The integer value that was extracted, or zero on failure.
uint32_t GetMaxU32(lldb::offset_t *offset_ptr, size_t byte_size) const;

/// Extract an unsigned integer of size \a byte_size from \a *offset_ptr.
///
/// Extract a single unsigned integer value and update the offset pointed to
/// by \a offset_ptr. The size of the extracted integer is specified by the
/// \a byte_size argument. \a byte_size must have a value greater than or
/// equal to one and less than or equal to eight since the return value is
/// 64 bits wide.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] byte_size
///     The size in byte of the integer to extract.
///
/// \return
///     The unsigned integer value that was extracted, or zero on
///     failure.
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const;

uint64_t GetMaxU64_unchecked(lldb::offset_t *offset_ptr,
                             size_t byte_size) const;

/// Extract an signed integer of size \a byte_size from \a *offset_ptr.
///
/// Extract a single signed integer value (sign extending if required) and
/// update the offset pointed to by \a offset_ptr. The size of the extracted
/// integer is specified by the \a byte_size argument. \a byte_size must
/// have a value greater than or equal to one and less than or equal to
/// eight since the return value is 64 bits wide.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] byte_size
///     The size in byte of the integer to extract.
///
/// \return
///     The sign extended signed integer value that was extracted,
///     or zero on failure.
int64_t GetMaxS64(lldb::offset_t *offset_ptr, size_t byte_size) const;

/// Extract an unsigned integer of size \a byte_size from \a *offset_ptr,
/// then extract the bitfield from this value if \a bitfield_bit_size is
/// non-zero.
///
/// Extract a single unsigned integer value and update the offset pointed to
/// by \a offset_ptr. The size of the extracted integer is specified by the
/// \a byte_size argument. \a byte_size must have a value greater than or
/// equal to one and less than or equal to 8 since the return value is 64
/// bits wide.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] size
///     The size in byte of the integer to extract.
///
/// \param[in] bitfield_bit_size
///     The size in bits of the bitfield value to extract, or zero
///     to just extract the entire integer value.
///
/// \param[in] bitfield_bit_offset
///     The bit offset of the bitfield value in the extracted
///     integer.  For little-endian data, this is the offset of
///     the LSB of the bitfield from the LSB of the integer.
///     For big-endian data, this is the offset of the MSB of the
///     bitfield from the MSB of the integer.
///
/// \return
///     The unsigned bitfield integer value that was extracted, or
///     zero on failure.
uint64_t GetMaxU64Bitfield(lldb::offset_t *offset_ptr, size_t size,
                           uint32_t bitfield_bit_size,
                           uint32_t bitfield_bit_offset) const;

/// Extract an signed integer of size \a size from \a *offset_ptr, then
/// extract and sign-extend the bitfield from this value if \a
/// bitfield_bit_size is non-zero.
///
/// Extract a single signed integer value (sign-extending if required) and
/// update the offset pointed to by \a offset_ptr. The size of the extracted
/// integer is specified by the \a size argument. \a size must
/// have a value greater than or equal to one and less than or equal to
/// eight since the return value is 64 bits wide.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[in] size
///     The size in bytes of the integer to extract.
///
/// \param[in] bitfield_bit_size
///     The size in bits of the bitfield value to extract, or zero
///     to just extract the entire integer value.
///
/// \param[in] bitfield_bit_offset
///     The bit offset of the bitfield value in the extracted
///     integer.  For little-endian data, this is the offset of
///     the LSB of the bitfield from the LSB of the integer.
///     For big-endian data, this is the offset of the MSB of the
///     bitfield from the MSB of the integer.
///
/// \return
///     The signed bitfield integer value that was extracted, or
///     zero on failure.
int64_t GetMaxS64Bitfield(lldb::offset_t *offset_ptr, size_t size,
                          uint32_t bitfield_bit_size,
                          uint32_t bitfield_bit_offset) const;

/// Get the current byte order value.
///
/// \return
///     The current byte order value from this object's internal
///     state.
lldb::ByteOrder GetByteOrder() const { return m_byte_order; }

/// Extract a uint8_t value from \a *offset_ptr.
///
/// Extract a single uint8_t from the binary data at the offset pointed to
/// by \a offset_ptr, and advance the offset on success.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted uint8_t value.
uint8_t GetU8(lldb::offset_t *offset_ptr) const;

uint8_t GetU8_unchecked(lldb::offset_t *offset_ptr) const {
  uint8_t val = m_start[*offset_ptr];
  *offset_ptr += 1;
  return val;
}

uint16_t GetU16_unchecked(lldb::offset_t *offset_ptr) const;

uint32_t GetU32_unchecked(lldb::offset_t *offset_ptr) const;

uint64_t GetU64_unchecked(lldb::offset_t *offset_ptr) const;
/// Extract \a count uint8_t values from \a *offset_ptr.
///
/// Extract \a count uint8_t values from the binary data at the offset
/// pointed to by \a offset_ptr, and advance the offset on success. The
/// extracted values are copied into \a dst.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[out] dst
///     A buffer to copy \a count uint8_t values into. \a dst must
///     be large enough to hold all requested data.
///
/// \param[in] count
///     The number of uint8_t values to extract.
///
/// \return
///     \a dst if all values were properly extracted and copied,
///     nullptr otherwise.
void *GetU8(lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;

/// Extract a uint16_t value from \a *offset_ptr.
///
/// Extract a single uint16_t from the binary data at the offset pointed to
/// by \a offset_ptr, and update the offset on success.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted uint16_t value.
uint16_t GetU16(lldb::offset_t *offset_ptr) const;

/// Extract \a count uint16_t values from \a *offset_ptr.
///
/// Extract \a count uint16_t values from the binary data at the offset
/// pointed to by \a offset_ptr, and advance the offset on success. The
/// extracted values are copied into \a dst.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[out] dst
///     A buffer to copy \a count uint16_t values into. \a dst must
///     be large enough to hold all requested data.
///
/// \param[in] count
///     The number of uint16_t values to extract.
///
/// \return
///     \a dst if all values were properly extracted and copied,
///     nullptr otherwise.
void *GetU16(lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;

/// Extract a uint32_t value from \a *offset_ptr.
///
/// Extract a single uint32_t from the binary data at the offset pointed to
/// by \a offset_ptr, and update the offset on success.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted uint32_t value.
uint32_t GetU32(lldb::offset_t *offset_ptr) const;

/// Extract \a count uint32_t values from \a *offset_ptr.
///
/// Extract \a count uint32_t values from the binary data at the offset
/// pointed to by \a offset_ptr, and advance the offset on success. The
/// extracted values are copied into \a dst.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[out] dst
///     A buffer to copy \a count uint32_t values into. \a dst must
///     be large enough to hold all requested data.
///
/// \param[in] count
///     The number of uint32_t values to extract.
///
/// \return
///     \a dst if all values were properly extracted and copied,
///     nullptr otherwise.
void *GetU32(lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;

/// Extract a uint64_t value from \a *offset_ptr.
///
/// Extract a single uint64_t from the binary data at the offset pointed to
/// by \a offset_ptr, and update the offset on success.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted uint64_t value.
uint64_t GetU64(lldb::offset_t *offset_ptr) const;

/// Extract \a count uint64_t values from \a *offset_ptr.
///
/// Extract \a count uint64_t values from the binary data at the offset
/// pointed to by \a offset_ptr, and advance the offset on success. The
/// extracted values are copied into \a dst.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \param[out] dst
///     A buffer to copy \a count uint64_t values into. \a dst must
///     be large enough to hold all requested data.
///
/// \param[in] count
///     The number of uint64_t values to extract.
///
/// \return
///     \a dst if all values were properly extracted and copied,
///     nullptr otherwise.
void *GetU64(lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;

/// Extract a signed LEB128 value from \a *offset_ptr.
///
/// Extracts an signed LEB128 number from this object's data starting at the
/// offset pointed to by \a offset_ptr. The offset pointed to by \a
/// offset_ptr will be updated with the offset of the byte following the
/// last extracted byte.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted signed integer value.
int64_t GetSLEB128(lldb::offset_t *offset_ptr) const;

/// Extract a unsigned LEB128 value from \a *offset_ptr.
///
/// Extracts an unsigned LEB128 number from this object's data starting at
/// the offset pointed to by \a offset_ptr. The offset pointed to by \a
/// offset_ptr will be updated with the offset of the byte following the
/// last extracted byte.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The extracted unsigned integer value.
uint64_t GetULEB128(lldb::offset_t *offset_ptr) const;

lldb::DataBufferSP &GetSharedDataBuffer() { return m_data_sp; }

/// Peek at a C string at \a offset.
///
/// Peeks at a string in the contained data. No verification is done to make
/// sure the entire string lies within the bounds of this object's data,
/// only \a offset is verified to be a valid offset.
///
/// \param[in] offset
///     An offset into the data.
///
/// \return
///     A non-nullptr C string pointer if \a offset is a valid offset,
///     nullptr otherwise.
const char *PeekCStr(lldb::offset_t offset) const;

/// Peek at a bytes at \a offset.
///
/// Returns a pointer to \a length bytes at \a offset as long as there are
/// \a length bytes available starting at \a offset.
///
/// \return
///     A non-nullptr data pointer if \a offset is a valid offset and
///     there are \a length bytes available at that offset, nullptr
///     otherwise.
const uint8_t *PeekData(lldb::offset_t offset, lldb::offset_t length) const {
  if (ValidOffsetForDataOfSize(offset, length))
    return m_start + offset;
  return nullptr;
}

/// Set the address byte size.
///
/// Set the size in bytes that will be used when extracting any address and
/// pointer values from data contained in this object.
///
/// \param[in] addr_size
///     The size in bytes to use when extracting addresses.
void SetAddressByteSize(uint32_t addr_size) {
835#ifdef LLDB_CONFIGURATION_DEBUG
  assert(addr_size == 4 || addr_size == 8)((void)0);
837#endif
  m_addr_size = addr_size;
}

/// Set data with a buffer that is caller owned.
///
/// Use data that is owned by the caller when extracting values. The data
/// must stay around as long as this object, or any object that copies a
/// subset of this object's data, is valid. If \a bytes is nullptr, or \a
/// length is zero, this object will contain no data.
///
/// \param[in] bytes
///     A pointer to caller owned data.
///
/// \param[in] length
///     The length in bytes of \a bytes.
///
/// \param[in] byte_order
///     A byte order of the data that we are extracting from.
///
/// \return
///     The number of bytes that this object now contains.
lldb::offset_t SetData(const void *bytes, lldb::offset_t length,
                       lldb::ByteOrder byte_order);

/// Adopt a subset of \a data.
///
/// Set this object's data to be a subset of the data bytes in \a data. If
/// \a data contains shared data, then a reference to the shared data will
/// be added to ensure the shared data stays around as long as any objects
/// have references to the shared data. The byte order and the address size
/// settings are copied from \a data. If \a offset is not a valid offset in
/// \a data, then no reference to the shared data will be added. If there
/// are not \a length bytes available in \a data starting at \a offset, the
/// length will be truncated to contains as many bytes as possible.
///
/// \param[in] data
///     Another DataExtractor object that contains data.
///
/// \param[in] offset
///     The offset into \a data at which the subset starts.
///
/// \param[in] length
///     The length in bytes of the subset of \a data.
///
/// \return
///     The number of bytes that this object now contains.
lldb::offset_t SetData(const DataExtractor &data, lldb::offset_t offset,
                       lldb::offset_t length);

/// Adopt a subset of shared data in \a data_sp.
///
/// Copies the data shared pointer which adds a reference to the contained
/// in \a data_sp. The shared data reference is reference counted to ensure
/// the data lives as long as anyone still has a valid shared pointer to the
/// data in \a data_sp. The byte order and address byte size settings remain
/// the same. If \a offset is not a valid offset in \a data_sp, then no
/// reference to the shared data will be added. If there are not \a length
/// bytes available in \a data starting at \a offset, the length will be
/// truncated to contains as many bytes as possible.
///
/// \param[in] data_sp
///     A shared pointer to data.
///
/// \param[in] offset
///     The offset into \a data_sp at which the subset starts.
///
/// \param[in] length
///     The length in bytes of the subset of \a data_sp.
///
/// \return
///     The number of bytes that this object now contains.
lldb::offset_t SetData(const lldb::DataBufferSP &data_sp,
                       lldb::offset_t offset = 0,
                       lldb::offset_t length = LLDB_INVALID_OFFSET0xffffffffffffffffULL);

/// Set the byte_order value.
///
/// Sets the byte order of the data to extract. Extracted values will be
/// swapped if necessary when decoding.
///
/// \param[in] byte_order
///     The byte order value to use when extracting data.
void SetByteOrder(lldb::ByteOrder byte_order) { m_byte_order = byte_order; }

/// Skip an LEB128 number at \a *offset_ptr.
///
/// Skips a LEB128 number (signed or unsigned) from this object's data
/// starting at the offset pointed to by \a offset_ptr. The offset pointed
/// to by \a offset_ptr will be updated with the offset of the byte
/// following the last extracted byte.
///
/// \param[in,out] offset_ptr
///     A pointer to an offset within the data that will be advanced
///     by the appropriate number of bytes if the value is extracted
///     correctly. If the offset is out of bounds or there are not
///     enough bytes to extract this value, the offset will be left
///     unmodified.
///
/// \return
///     The number of bytes consumed during the extraction.
uint32_t Skip_LEB128(lldb::offset_t *offset_ptr) const;

/// Test the validity of \a offset.
///
/// \return
///     true if \a offset is a valid offset into the data in this object,
///     false otherwise.
bool ValidOffset(lldb::offset_t offset) const {
  return offset < GetByteSize();
9
←
Returning the value 1, which participates in a condition later→
}

/// Test the availability of \a length bytes of data from \a offset.
///
/// \return
///     true if \a offset is a valid offset and there are \a
///     length bytes available at that offset, false otherwise.
bool ValidOffsetForDataOfSize(lldb::offset_t offset,
                              lldb::offset_t length) const {
  return length <= BytesLeft(offset);
}

size_t Copy(DataExtractor &dest_data) const;

bool Append(DataExtractor &rhs);

bool Append(void *bytes, lldb::offset_t length);

lldb::offset_t BytesLeft(lldb::offset_t offset) const {
  const lldb::offset_t size = GetByteSize();
  if (size > offset)
    return size - offset;
  return 0;
}

void Checksum(llvm::SmallVectorImpl<uint8_t> &dest, uint64_t max_data = 0);

llvm::ArrayRef<uint8_t> GetData() const {
  return {GetDataStart(), size_t(GetByteSize())};
}

llvm::DataExtractor GetAsLLVM() const {
  return {GetData(), GetByteOrder() == lldb::eByteOrderLittle,
          uint8_t(GetAddressByteSize())};
}

983protected:
template <typename T> T Get(lldb::offset_t *offset_ptr, T fail_value) const {
  constexpr size_t src_size = sizeof(T);
  T val = fail_value;

  const T *src = static_cast<const T *>(GetData(offset_ptr, src_size));
  if (!src)
    return val;

  memcpy(&val, src, src_size);
  if (m_byte_order != endian::InlHostByteOrder())
    llvm::sys::swapByteOrder(val);

  return val;
}

// Member variables
const uint8_t *m_start = nullptr; ///< A pointer to the first byte of data.
const uint8_t *m_end =
    nullptr; ///< A pointer to the byte that is past the end of the data.
lldb::ByteOrder
    m_byte_order;     ///< The byte order of the data we are extracting from.
uint32_t m_addr_size; ///< The address size to use when extracting addresses.
/// The shared pointer to data that can be shared among multiple instances
lldb::DataBufferSP m_data_sp;
const uint32_t m_target_byte_size = 1;
1009};

1011} // namespace lldb_private

1013#endif // LLDB_UTILITY_DATAEXTRACTOR_H

←

/usr/include/c++/v1/__memory/shared_ptr.h

1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9 
10#ifndef _LIBCPP___MEMORY_SHARED_PTR_H
11#define _LIBCPP___MEMORY_SHARED_PTR_H
12 
13#include <__availability>
14#include <__config>
15#include <__functional_base>
16#include <__functional/binary_function.h>
17#include <__functional/operations.h>
18#include <__functional/reference_wrapper.h>
19#include <__memory/addressof.h>
20#include <__memory/allocation_guard.h>
21#include <__memory/allocator_traits.h>
22#include <__memory/allocator.h>
23#include <__memory/compressed_pair.h>
24#include <__memory/pointer_traits.h>
25#include <__memory/unique_ptr.h>
26#include <__utility/forward.h>
27#include <cstddef>
28#include <cstdlib> // abort
29#include <iosfwd>
30#include <stdexcept>
31#include <typeinfo>
32#include <type_traits>
33#include <utility>
34#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
35#  include <atomic>
36#endif
37 
38#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
39#   include <__memory/auto_ptr.h>
40#endif
41 
42#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
43#pragma GCC system_header
44#endif
45 
46_LIBCPP_PUSH_MACROSpush_macro("min")
 push_macro("max")
47#include <__undef_macros>
48 
49_LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 {
50 
51template <class _Alloc>
52class __allocator_destructor
53{
54    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) allocator_traits<_Alloc> __alloc_traits;
55public:
56    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __alloc_traits::pointer pointer;
57    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __alloc_traits::size_type size_type;
58private:
59    _Alloc& __alloc_;
60    size_type __s_;
61public:
62    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) __allocator_destructor(_Alloc& __a, size_type __s)
63             _NOEXCEPTnoexcept
64        : __alloc_(__a), __s_(__s) {}
65    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
66    void operator()(pointer __p) _NOEXCEPTnoexcept
67        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
68};
69 
70// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
71// should be sufficient for thread safety.
72// See https://llvm.org/PR22803
73#if defined(__clang__1) && __has_builtin(__atomic_add_fetch)1          \
74                       && defined(__ATOMIC_RELAXED0)                  \
75                       && defined(__ATOMIC_ACQ_REL4)
76#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
77#elif defined(_LIBCPP_COMPILER_GCC)
78#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
79#endif
80 
81template <class _ValueType>
82inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
83_ValueType __libcpp_relaxed_load(_ValueType const* __value) {
84#if !defined(_LIBCPP_HAS_NO_THREADS) && \
85    defined(__ATOMIC_RELAXED0) &&        \
86    (__has_builtin(__atomic_load_n)1 || defined(_LIBCPP_COMPILER_GCC))
87    return __atomic_load_n(__value, __ATOMIC_RELAXED0);
88#else
89    return *__value;
90#endif
91}
92 
93template <class _ValueType>
94inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
95_ValueType __libcpp_acquire_load(_ValueType const* __value) {
96#if !defined(_LIBCPP_HAS_NO_THREADS) && \
97    defined(__ATOMIC_ACQUIRE2) &&        \
98    (__has_builtin(__atomic_load_n)1 || defined(_LIBCPP_COMPILER_GCC))
99    return __atomic_load_n(__value, __ATOMIC_ACQUIRE2);
100#else
101    return *__value;
102#endif
103}
104 
105template <class _Tp>
106inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _Tp
107__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPTnoexcept
108{
109#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
110    return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED0);
111#else
112    return __t += 1;
113#endif
114}
115 
116template <class _Tp>
117inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _Tp
118__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPTnoexcept
119{
120#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
121    return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL4);
122#else
123    return __t -= 1;
124#endif
125}
126 
127class _LIBCPP_EXCEPTION_ABI__attribute__ ((__visibility__("default"))) bad_weak_ptr
128    : public std::exception
129{
130public:
131    bad_weak_ptr() _NOEXCEPTnoexcept = default;
132    bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPTnoexcept = default;
133    virtual ~bad_weak_ptr() _NOEXCEPTnoexcept;
134    virtual const char* what() const  _NOEXCEPTnoexcept;
135};
136 
137_LIBCPP_NORETURN[[noreturn]] inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
138void __throw_bad_weak_ptr()
139{
140#ifndef _LIBCPP_NO_EXCEPTIONS
141    throw bad_weak_ptr();
142#else
143    _VSTDstd::__1::abort();
144#endif
145}
146 
147template<class _Tp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
148 
149class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __shared_count
150{
151    __shared_count(const __shared_count&);
152    __shared_count& operator=(const __shared_count&);
153 
154protected:
155    long __shared_owners_;
156    virtual ~__shared_count();
157private:
158    virtual void __on_zero_shared() _NOEXCEPTnoexcept = 0;
159 
160public:
161    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
162    explicit __shared_count(long __refs = 0) _NOEXCEPTnoexcept
163        : __shared_owners_(__refs) {}
164 
165#if defined(_LIBCPP_BUILDING_LIBRARY) && \
166    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
167    void __add_shared() _NOEXCEPTnoexcept;
168    bool __release_shared() _NOEXCEPTnoexcept;
169#else
170    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
171    void __add_shared() _NOEXCEPTnoexcept {
172      __libcpp_atomic_refcount_increment(__shared_owners_);
173    }
174    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
175    bool __release_shared() _NOEXCEPTnoexcept {
176      if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
177        __on_zero_shared();
178        return true;
179      }
180      return false;
181    }
182#endif
183    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
184    long use_count() const _NOEXCEPTnoexcept {
185        return __libcpp_relaxed_load(&__shared_owners_) + 1;
186    }
187};
188 
189class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __shared_weak_count
190    : private __shared_count
191{
192    long __shared_weak_owners_;
193 
194public:
195    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
196    explicit __shared_weak_count(long __refs = 0) _NOEXCEPTnoexcept
197        : __shared_count(__refs),
198          __shared_weak_owners_(__refs) {}
199protected:
200    virtual ~__shared_weak_count();
201 
202public:
203#if defined(_LIBCPP_BUILDING_LIBRARY) && \
204    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
205    void __add_shared() _NOEXCEPTnoexcept;
206    void __add_weak() _NOEXCEPTnoexcept;
207    void __release_shared() _NOEXCEPTnoexcept;
208#else
209    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
210    void __add_shared() _NOEXCEPTnoexcept {
211      __shared_count::__add_shared();
212    }
213    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
214    void __add_weak() _NOEXCEPTnoexcept {
215      __libcpp_atomic_refcount_increment(__shared_weak_owners_);
216    }
217    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
218    void __release_shared() _NOEXCEPTnoexcept {
219      if (__shared_count::__release_shared())
220        __release_weak();
221    }
222#endif
223    void __release_weak() _NOEXCEPTnoexcept;
224    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
225    long use_count() const _NOEXCEPTnoexcept {return __shared_count::use_count();}
226    __shared_weak_count* lock() _NOEXCEPTnoexcept;
227 
228    virtual const void* __get_deleter(const type_info&) const _NOEXCEPTnoexcept;
229private:
230    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept = 0;
231};
232 
233template <class _Tp, class _Dp, class _Alloc>
234class __shared_ptr_pointer
235    : public __shared_weak_count
236{
237    __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
238public:
239    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
240    __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
241        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTDstd::__1::move(__d)), _VSTDstd::__1::move(__a)) {}
242 
243#ifndef _LIBCPP_NO_RTTI
244    virtual const void* __get_deleter(const type_info&) const _NOEXCEPTnoexcept;
245#endif
246 
247private:
248    virtual void __on_zero_shared() _NOEXCEPTnoexcept;
249    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept;
250};
251 
252#ifndef _LIBCPP_NO_RTTI
253 
254template <class _Tp, class _Dp, class _Alloc>
255const void*
256__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPTnoexcept
257{
258    return __t == typeid(_Dp) ? _VSTDstd::__1::addressof(__data_.first().second()) : nullptr;
259}
260 
261#endif // _LIBCPP_NO_RTTI
262 
263template <class _Tp, class _Dp, class _Alloc>
264void
265__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPTnoexcept
266{
267    __data_.first().second()(__data_.first().first());
268    __data_.first().second().~_Dp();
269}
270 
271template <class _Tp, class _Dp, class _Alloc>
272void
273__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPTnoexcept
274{
275    typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
276    typedef allocator_traits<_Al> _ATraits;
277    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
278 
279    _Al __a(__data_.second());
280    __data_.second().~_Alloc();
281    __a.deallocate(_PTraits::pointer_to(*this), 1);
282}
283 
284template <class _Tp, class _Alloc>
285struct __shared_ptr_emplace
286    : __shared_weak_count
287{
288    template<class ..._Args>
289    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
290    explicit __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
291        : __storage_(_VSTDstd::__1::move(__a))
292    {
293#if _LIBCPP_STD_VER14 > 17
294        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
295        _TpAlloc __tmp(*__get_alloc());
296        allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), _VSTDstd::__1::forward<_Args>(__args)...);
297#else
298        ::new ((void*)__get_elem()) _Tp(_VSTDstd::__1::forward<_Args>(__args)...);
299#endif
300    }
301 
302    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
303    _Alloc* __get_alloc() _NOEXCEPTnoexcept { return __storage_.__get_alloc(); }
304 
305    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
306    _Tp* __get_elem() _NOEXCEPTnoexcept { return __storage_.__get_elem(); }
307 
308private:
309    virtual void __on_zero_shared() _NOEXCEPTnoexcept {
310#if _LIBCPP_STD_VER14 > 17
311        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
312        _TpAlloc __tmp(*__get_alloc());
313        allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
314#else
315        __get_elem()->~_Tp();
316#endif
317    }
318 
319    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept {
320        using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
321        using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
322        _ControlBlockAlloc __tmp(*__get_alloc());
323        __storage_.~_Storage();
324        allocator_traits<_ControlBlockAlloc>::deallocate(__tmp,
325            pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
326    }
327 
328    // This class implements the control block for non-array shared pointers created
329    // through `std::allocate_shared` and `std::make_shared`.
330    //
331    // In previous versions of the library, we used a compressed pair to store
332    // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
333    // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
334    // we now use a properly aligned char buffer while making sure that we maintain
335    // the same layout that we had when we used a compressed pair.
336    using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
337    struct _ALIGNAS_TYPE(_CompressedPair)alignas(_CompressedPair) _Storage {
338        char __blob_[sizeof(_CompressedPair)];
339 
340        _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) explicit _Storage(_Alloc&& __a) {
341            ::new ((void*)__get_alloc()) _Alloc(_VSTDstd::__1::move(__a));
342        }
343        _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) ~_Storage() {
344            __get_alloc()->~_Alloc();
345        }
346        _Alloc* __get_alloc() _NOEXCEPTnoexcept {
347            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
348            typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair);
349            _Alloc *__alloc = reinterpret_cast<_Alloc*>(__first);
350            return __alloc;
351        }
352        _LIBCPP_NO_CFI__attribute__((__no_sanitize__("cfi"))) _Tp* __get_elem() _NOEXCEPTnoexcept {
353            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
354            typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
355            _Tp *__elem = reinterpret_cast<_Tp*>(__second);
356            return __elem;
357        }
358    };
359 
360    static_assert(_LIBCPP_ALIGNOF(_Storage)alignof(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair)alignof(_CompressedPair), "");
361    static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
362    _Storage __storage_;
363};
364 
365struct __shared_ptr_dummy_rebind_allocator_type;
366template <>
367class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) allocator<__shared_ptr_dummy_rebind_allocator_type>
368{
369public:
370    template <class _Other>
371    struct rebind
372    {
373        typedef allocator<_Other> other;
374    };
375};
376 
377template<class _Tp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_shared_from_this;
378 
379template<class _Tp, class _Up>
380struct __compatible_with
381#if _LIBCPP_STD_VER14 > 14
382    : is_convertible<remove_extent_t<_Tp>*, remove_extent_t<_Up>*> {};
383#else
384    : is_convertible<_Tp*, _Up*> {};
385#endif // _LIBCPP_STD_VER > 14
386 
387template <class _Ptr, class = void>
388struct __is_deletable : false_type { };
389template <class _Ptr>
390struct __is_deletable<_Ptr, decltype(delete declval<_Ptr>())> : true_type { };
391 
392template <class _Ptr, class = void>
393struct __is_array_deletable : false_type { };
394template <class _Ptr>
395struct __is_array_deletable<_Ptr, decltype(delete[] declval<_Ptr>())> : true_type { };
396 
397template <class _Dp, class _Pt,
398    class = decltype(declval<_Dp>()(declval<_Pt>()))>
399static true_type __well_formed_deleter_test(int);
400 
401template <class, class>
402static false_type __well_formed_deleter_test(...);
403 
404template <class _Dp, class _Pt>
405struct __well_formed_deleter : decltype(__well_formed_deleter_test<_Dp, _Pt>(0)) {};
406 
407template<class _Dp, class _Tp, class _Yp>
408struct __shared_ptr_deleter_ctor_reqs
409{
410    static const bool value = __compatible_with<_Tp, _Yp>::value &&
411                              is_move_constructible<_Dp>::value &&
412                              __well_formed_deleter<_Dp, _Tp*>::value;
413};
414 
415#if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
416#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
417#else
418#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
419#endif
420 
421template<class _Tp>
422class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr
423{
424public:
425#if _LIBCPP_STD_VER14 > 14
426    typedef weak_ptr<_Tp> weak_type;
427    typedef remove_extent_t<_Tp> element_type;
428#else
429    typedef _Tp element_type;
430#endif
431 
432private:
433    element_type*      __ptr_;
434    __shared_weak_count* __cntrl_;
435 
436    struct __nat {int __for_bool_;};
437public:
438    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
439    _LIBCPP_CONSTEXPRconstexpr shared_ptr() _NOEXCEPTnoexcept;
440    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
441    _LIBCPP_CONSTEXPRconstexpr shared_ptr(nullptr_t) _NOEXCEPTnoexcept;
442 
443    template<class _Yp, class = _EnableIf<
444        _And<
445            __compatible_with<_Yp, _Tp>
446            // In C++03 we get errors when trying to do SFINAE with the
447            // delete operator, so we always pretend that it's deletable.
448            // The same happens on GCC.
449#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_COMPILER_GCC)
450            , _If<is_array<_Tp>::value, __is_array_deletable<_Yp*>, __is_deletable<_Yp*> >
451#endif
452        >::value
453    > >
454    explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
455        unique_ptr<_Yp> __hold(__p);
456        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
457        typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk;
458        __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
459        __hold.release();
460        __enable_weak_this(__p, __p);
461    }
462 
463    template<class _Yp, class _Dp>
464        shared_ptr(_Yp* __p, _Dp __d,
465                   typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type = __nat());
466    template<class _Yp, class _Dp, class _Alloc>
467        shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
468                   typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type = __nat());
469    template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
470    template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
471    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPTnoexcept;
472    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
473    shared_ptr(const shared_ptr& __r) _NOEXCEPTnoexcept;
474    template<class _Yp>
475        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
476        shared_ptr(const shared_ptr<_Yp>& __r,
477                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
478                       _NOEXCEPTnoexcept;
479    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
480    shared_ptr(shared_ptr&& __r) _NOEXCEPTnoexcept;
481    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))  shared_ptr(shared_ptr<_Yp>&& __r,
482                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
483                       _NOEXCEPTnoexcept;
484    template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
485                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat());
486#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
487    template<class _Yp>
488        shared_ptr(auto_ptr<_Yp>&& __r,
489                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
490#endif
491    template <class _Yp, class _Dp>
492        shared_ptr(unique_ptr<_Yp, _Dp>&&,
493                   typename enable_if
494                   <
495                       !is_lvalue_reference<_Dp>::value &&
496                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
497                       __nat
498                   >::type = __nat());
499    template <class _Yp, class _Dp>
500        shared_ptr(unique_ptr<_Yp, _Dp>&&,
501                   typename enable_if
502                   <
503                       is_lvalue_reference<_Dp>::value &&
504                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
505                       __nat
506                   >::type = __nat());
507 
508    ~shared_ptr();
509 
510    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
511    shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPTnoexcept;
512    template<class _Yp>
513        typename enable_if
514        <
515            __compatible_with<_Yp, element_type>::value,
516            shared_ptr&
517        >::type
518        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
519        operator=(const shared_ptr<_Yp>& __r) _NOEXCEPTnoexcept;
520    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
521    shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPTnoexcept;
522    template<class _Yp>
523        typename enable_if
524        <
525            __compatible_with<_Yp, element_type>::value,
526            shared_ptr&
527        >::type
528        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
529        operator=(shared_ptr<_Yp>&& __r);
530#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
531    template<class _Yp>
532        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
533        typename enable_if
534        <
535            !is_array<_Yp>::value &&
536            is_convertible<_Yp*, element_type*>::value,
537            shared_ptr
538        >::type&
539        operator=(auto_ptr<_Yp>&& __r);
540#endif
541    template <class _Yp, class _Dp>
542        typename enable_if
543        <
544            is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
545            shared_ptr&
546        >::type
547        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
548        operator=(unique_ptr<_Yp, _Dp>&& __r);
549 
550    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
551    void swap(shared_ptr& __r) _NOEXCEPTnoexcept;
552    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
553    void reset() _NOEXCEPTnoexcept;
554    template<class _Yp>
555        typename enable_if
556        <
557            __compatible_with<_Yp, element_type>::value,
558            void
559        >::type
560        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
561        reset(_Yp* __p);
562    template<class _Yp, class _Dp>
563        typename enable_if
564        <
565            __compatible_with<_Yp, element_type>::value,
566            void
567        >::type
568        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
569        reset(_Yp* __p, _Dp __d);
570    template<class _Yp, class _Dp, class _Alloc>
571        typename enable_if
572        <
573            __compatible_with<_Yp, element_type>::value,
574            void
575        >::type
576        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
577        reset(_Yp* __p, _Dp __d, _Alloc __a);
578 
579    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
580    element_type* get() const _NOEXCEPTnoexcept {return __ptr_;}
581    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
582    typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPTnoexcept
583        {return *__ptr_;}
584    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
585    element_type* operator->() const _NOEXCEPTnoexcept
586    {
587        static_assert(!is_array<_Tp>::value,
588                      "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
589        return __ptr_;
590    }
591    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
592    long use_count() const _NOEXCEPTnoexcept {return __cntrl_ ? __cntrl_->use_count() : 0;}
593    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
594    bool unique() const _NOEXCEPTnoexcept {return use_count() == 1;}
595    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
596    explicit operator bool() const _NOEXCEPTnoexcept {return get() != nullptr;}
18
←
Assuming the condition is true→
19
←
Returning the value 1, which participates in a condition later→
597    template <class _Up>
598        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
599        bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPTnoexcept
600        {return __cntrl_ < __p.__cntrl_;}
601    template <class _Up>
602        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
603        bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPTnoexcept
604        {return __cntrl_ < __p.__cntrl_;}
605    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
606    bool
607    __owner_equivalent(const shared_ptr& __p) const
608        {return __cntrl_ == __p.__cntrl_;}
609 
610#if _LIBCPP_STD_VER14 > 14
611    typename add_lvalue_reference<element_type>::type
612    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
613    operator[](ptrdiff_t __i) const
614    {
615            static_assert(is_array<_Tp>::value,
616                          "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
617            return __ptr_[__i];
618    }
619#endif
620 
621#ifndef _LIBCPP_NO_RTTI
622    template <class _Dp>
623        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
624        _Dp* __get_deleter() const _NOEXCEPTnoexcept
625            {return static_cast<_Dp*>(__cntrl_
626                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
627                      : nullptr);}
628#endif // _LIBCPP_NO_RTTI
629 
630    template<class _Yp, class _CntrlBlk>
631    static shared_ptr<_Tp>
632    __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPTnoexcept
633    {
634        shared_ptr<_Tp> __r;
635        __r.__ptr_ = __p;
636        __r.__cntrl_ = __cntrl;
637        __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
638        return __r;
639    }
640 
641private:
642    template <class _Yp, bool = is_function<_Yp>::value>
643        struct __shared_ptr_default_allocator
644        {
645            typedef allocator<_Yp> type;
646        };
647 
648    template <class _Yp>
649        struct __shared_ptr_default_allocator<_Yp, true>
650        {
651            typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
652        };
653 
654    template <class _Yp, class _OrigPtr>
655        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
656        typename enable_if<is_convertible<_OrigPtr*,
657                                          const enable_shared_from_this<_Yp>*
658        >::value,
659            void>::type
660        __enable_weak_this(const enable_shared_from_this<_Yp>* __e,
661                           _OrigPtr* __ptr) _NOEXCEPTnoexcept
662        {
663            typedef typename remove_cv<_Yp>::type _RawYp;
664            if (__e && __e->__weak_this_.expired())
665            {
666                __e->__weak_this_ = shared_ptr<_RawYp>(*this,
667                    const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
668            }
669        }
670 
671    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) void __enable_weak_this(...) _NOEXCEPTnoexcept {}
672 
673    template <class, class _Yp>
674        struct __shared_ptr_default_delete
675            : default_delete<_Yp> {};
676 
677    template <class _Yp, class _Un, size_t _Sz>
678        struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
679            : default_delete<_Yp[]> {};
680 
681    template <class _Yp, class _Un>
682        struct __shared_ptr_default_delete<_Yp[], _Un>
683            : default_delete<_Yp[]> {};
684 
685    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr;
686    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
687};
688 
689#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
690template<class _Tp>
691shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
692template<class _Tp, class _Dp>
693shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
694#endif
695 
696template<class _Tp>
697inline
698_LIBCPP_CONSTEXPRconstexpr
699shared_ptr<_Tp>::shared_ptr() _NOEXCEPTnoexcept
700    : __ptr_(nullptr),
701      __cntrl_(nullptr)
702{
703}
704 
705template<class _Tp>
706inline
707_LIBCPP_CONSTEXPRconstexpr
708shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPTnoexcept
709    : __ptr_(nullptr),
710      __cntrl_(nullptr)
711{
712}
713 
714template<class _Tp>
715template<class _Yp, class _Dp>
716shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
717                            typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type)
718    : __ptr_(__p)
719{
720#ifndef _LIBCPP_NO_EXCEPTIONS
721    try
722    {
723#endif // _LIBCPP_NO_EXCEPTIONS
724        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
725        typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
726#ifndef _LIBCPP_CXX03_LANG
727        __cntrl_ = new _CntrlBlk(__p, _VSTDstd::__1::move(__d), _AllocT());
728#else
729        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
730#endif // not _LIBCPP_CXX03_LANG
731        __enable_weak_this(__p, __p);
732#ifndef _LIBCPP_NO_EXCEPTIONS
733    }
734    catch (...)
735    {
736        __d(__p);
737        throw;
738    }
739#endif // _LIBCPP_NO_EXCEPTIONS
740}
741 
742template<class _Tp>
743template<class _Dp>
744shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
745    : __ptr_(nullptr)
746{
747#ifndef _LIBCPP_NO_EXCEPTIONS
748    try
749    {
750#endif // _LIBCPP_NO_EXCEPTIONS
751        typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
752        typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk;
753#ifndef _LIBCPP_CXX03_LANG
754        __cntrl_ = new _CntrlBlk(__p, _VSTDstd::__1::move(__d), _AllocT());
755#else
756        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
757#endif // not _LIBCPP_CXX03_LANG
758#ifndef _LIBCPP_NO_EXCEPTIONS
759    }
760    catch (...)
761    {
762        __d(__p);
763        throw;
764    }
765#endif // _LIBCPP_NO_EXCEPTIONS
766}
767 
768template<class _Tp>
769template<class _Yp, class _Dp, class _Alloc>
770shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
771                            typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type)
772    : __ptr_(__p)
773{
774#ifndef _LIBCPP_NO_EXCEPTIONS
775    try
776    {
777#endif // _LIBCPP_NO_EXCEPTIONS
778        typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
779        typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
780        typedef __allocator_destructor<_A2> _D2;
781        _A2 __a2(__a);
782        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
783        ::new ((void*)_VSTDstd::__1::addressof(*__hold2.get()))
784#ifndef _LIBCPP_CXX03_LANG
785            _CntrlBlk(__p, _VSTDstd::__1::move(__d), __a);
786#else
787            _CntrlBlk(__p, __d, __a);
788#endif // not _LIBCPP_CXX03_LANG
789        __cntrl_ = _VSTDstd::__1::addressof(*__hold2.release());
790        __enable_weak_this(__p, __p);
791#ifndef _LIBCPP_NO_EXCEPTIONS
792    }
793    catch (...)
794    {
795        __d(__p);
796        throw;
797    }
798#endif // _LIBCPP_NO_EXCEPTIONS
799}
800 
801template<class _Tp>
802template<class _Dp, class _Alloc>
803shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
804    : __ptr_(nullptr)
805{
806#ifndef _LIBCPP_NO_EXCEPTIONS
807    try
808    {
809#endif // _LIBCPP_NO_EXCEPTIONS
810        typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
811        typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
812        typedef __allocator_destructor<_A2> _D2;
813        _A2 __a2(__a);
814        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
815        ::new ((void*)_VSTDstd::__1::addressof(*__hold2.get()))
816#ifndef _LIBCPP_CXX03_LANG
817            _CntrlBlk(__p, _VSTDstd::__1::move(__d), __a);
818#else
819            _CntrlBlk(__p, __d, __a);
820#endif // not _LIBCPP_CXX03_LANG
821        __cntrl_ = _VSTDstd::__1::addressof(*__hold2.release());
822#ifndef _LIBCPP_NO_EXCEPTIONS
823    }
824    catch (...)
825    {
826        __d(__p);
827        throw;
828    }
829#endif // _LIBCPP_NO_EXCEPTIONS
830}
831 
832template<class _Tp>
833template<class _Yp>
834inline
835shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPTnoexcept
836    : __ptr_(__p),
837      __cntrl_(__r.__cntrl_)
838{
839    if (__cntrl_)
840        __cntrl_->__add_shared();
841}
842 
843template<class _Tp>
844inline
845shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPTnoexcept
846    : __ptr_(__r.__ptr_),
847      __cntrl_(__r.__cntrl_)
848{
849    if (__cntrl_)
850        __cntrl_->__add_shared();
851}
852 
853template<class _Tp>
854template<class _Yp>
855inline
856shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
857                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
858         _NOEXCEPTnoexcept
859    : __ptr_(__r.__ptr_),
860      __cntrl_(__r.__cntrl_)
861{
862    if (__cntrl_)
863        __cntrl_->__add_shared();
864}
865 
866template<class _Tp>
867inline
868shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPTnoexcept
869    : __ptr_(__r.__ptr_),
870      __cntrl_(__r.__cntrl_)
871{
872    __r.__ptr_ = nullptr;
873    __r.__cntrl_ = nullptr;
874}
875 
876template<class _Tp>
877template<class _Yp>
878inline
879shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
880                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
881         _NOEXCEPTnoexcept
882    : __ptr_(__r.__ptr_),
883      __cntrl_(__r.__cntrl_)
884{
885    __r.__ptr_ = nullptr;
886    __r.__cntrl_ = nullptr;
887}
888 
889#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
890template<class _Tp>
891template<class _Yp>
892shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r,
893                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
894    : __ptr_(__r.get())
895{
896    typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
897    __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
898    __enable_weak_this(__r.get(), __r.get());
899    __r.release();
900}
901#endif
902 
903template<class _Tp>
904template <class _Yp, class _Dp>
905shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
906                            typename enable_if
907                            <
908                                !is_lvalue_reference<_Dp>::value &&
909                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
910                                __nat
911                            >::type)
912    : __ptr_(__r.get())
913{
914#if _LIBCPP_STD_VER14 > 11
915    if (__ptr_ == nullptr)
916        __cntrl_ = nullptr;
917    else
918#endif
919    {
920        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
921        typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT > _CntrlBlk;
922        __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT());
923        __enable_weak_this(__r.get(), __r.get());
924    }
925    __r.release();
926}
927 
928template<class _Tp>
929template <class _Yp, class _Dp>
930shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
931                            typename enable_if
932                            <
933                                is_lvalue_reference<_Dp>::value &&
934                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
935                                __nat
936                            >::type)
937    : __ptr_(__r.get())
938{
939#if _LIBCPP_STD_VER14 > 11
940    if (__ptr_ == nullptr)
941        __cntrl_ = nullptr;
942    else
943#endif
944    {
945        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
946        typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
947                                     reference_wrapper<typename remove_reference<_Dp>::type>,
948                                     _AllocT > _CntrlBlk;
949        __cntrl_ = new _CntrlBlk(__r.get(), _VSTDstd::__1::ref(__r.get_deleter()), _AllocT());
950        __enable_weak_this(__r.get(), __r.get());
951    }
952    __r.release();
953}
954 
955template<class _Tp>
956shared_ptr<_Tp>::~shared_ptr()
957{
958    if (__cntrl_)
959        __cntrl_->__release_shared();
960}
961 
962template<class _Tp>
963inline
964shared_ptr<_Tp>&
965shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPTnoexcept
966{
967    shared_ptr(__r).swap(*this);
968    return *this;
969}
970 
971template<class _Tp>
972template<class _Yp>
973inline
974typename enable_if
975<
976    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
977    shared_ptr<_Tp>&
978>::type
979shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPTnoexcept
980{
981    shared_ptr(__r).swap(*this);
982    return *this;
983}
984 
985template<class _Tp>
986inline
987shared_ptr<_Tp>&
988shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPTnoexcept
989{
990    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
991    return *this;
992}
993 
994template<class _Tp>
995template<class _Yp>
996inline
997typename enable_if
998<
999    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1000    shared_ptr<_Tp>&
1001>::type
1002shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
1003{
1004    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1005    return *this;
1006}
1007 
1008#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
1009template<class _Tp>
1010template<class _Yp>
1011inline
1012typename enable_if
1013<
1014    !is_array<_Yp>::value &&
1015    is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
1016    shared_ptr<_Tp>
1017>::type&
1018shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
1019{
1020    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1021    return *this;
1022}
1023#endif
1024 
1025template<class _Tp>
1026template <class _Yp, class _Dp>
1027inline
1028typename enable_if
1029<
1030    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
1031                   typename shared_ptr<_Tp>::element_type*>::value,
1032    shared_ptr<_Tp>&
1033>::type
1034shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
1035{
1036    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1037    return *this;
1038}
1039 
1040template<class _Tp>
1041inline
1042void
1043shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPTnoexcept
1044{
1045    _VSTDstd::__1::swap(__ptr_, __r.__ptr_);
1046    _VSTDstd::__1::swap(__cntrl_, __r.__cntrl_);
1047}
1048 
1049template<class _Tp>
1050inline
1051void
1052shared_ptr<_Tp>::reset() _NOEXCEPTnoexcept
1053{
1054    shared_ptr().swap(*this);
1055}
1056 
1057template<class _Tp>
1058template<class _Yp>
1059inline
1060typename enable_if
1061<
1062    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1063    void
1064>::type
1065shared_ptr<_Tp>::reset(_Yp* __p)
1066{
1067    shared_ptr(__p).swap(*this);
1068}
1069 
1070template<class _Tp>
1071template<class _Yp, class _Dp>
1072inline
1073typename enable_if
1074<
1075    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1076    void
1077>::type
1078shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
1079{
1080    shared_ptr(__p, __d).swap(*this);
1081}
1082 
1083template<class _Tp>
1084template<class _Yp, class _Dp, class _Alloc>
1085inline
1086typename enable_if
1087<
1088    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1089    void
1090>::type
1091shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
1092{
1093    shared_ptr(__p, __d, __a).swap(*this);
1094}
1095 
1096//
1097// std::allocate_shared and std::make_shared
1098//
1099template<class _Tp, class _Alloc, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> >
1100_LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1101shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&& ...__args)
1102{
1103    using _ControlBlock = __shared_ptr_emplace<_Tp, _Alloc>;
1104    using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
1105    __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
1106    ::new ((void*)_VSTDstd::__1::addressof(*__guard.__get())) _ControlBlock(__a, _VSTDstd::__1::forward<_Args>(__args)...);
1107    auto __control_block = __guard.__release_ptr();
1108    return shared_ptr<_Tp>::__create_with_control_block((*__control_block).__get_elem(), _VSTDstd::__1::addressof(*__control_block));
1109}
1110 
1111template<class _Tp, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> >
1112_LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1113shared_ptr<_Tp> make_shared(_Args&& ...__args)
1114{
1115    return _VSTDstd::__1::allocate_shared<_Tp>(allocator<_Tp>(), _VSTDstd::__1::forward<_Args>(__args)...);
1116}
1117 
1118template<class _Tp, class _Up>
1119inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1120bool
1121operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1122{
1123    return __x.get() == __y.get();
1124}
1125 
1126template<class _Tp, class _Up>
1127inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1128bool
1129operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1130{
1131    return !(__x == __y);
1132}
1133 
1134template<class _Tp, class _Up>
1135inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1136bool
1137operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1138{
1139#if _LIBCPP_STD_VER14 <= 11
1140    typedef typename common_type<_Tp*, _Up*>::type _Vp;
1141    return less<_Vp>()(__x.get(), __y.get());
1142#else
1143    return less<>()(__x.get(), __y.get());
1144#endif
1145 
1146}
1147 
1148template<class _Tp, class _Up>
1149inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1150bool
1151operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1152{
1153    return __y < __x;
1154}
1155 
1156template<class _Tp, class _Up>
1157inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1158bool
1159operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1160{
1161    return !(__y < __x);
1162}
1163 
1164template<class _Tp, class _Up>
1165inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1166bool
1167operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1168{
1169    return !(__x < __y);
1170}
1171 
1172template<class _Tp>
1173inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1174bool
1175operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1176{
1177    return !__x;
1178}
1179 
1180template<class _Tp>
1181inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1182bool
1183operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1184{
1185    return !__x;
1186}
1187 
1188template<class _Tp>
1189inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1190bool
1191operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1192{
1193    return static_cast<bool>(__x);
1194}
1195 
1196template<class _Tp>
1197inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1198bool
1199operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1200{
1201    return static_cast<bool>(__x);
1202}
1203 
1204template<class _Tp>
1205inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1206bool
1207operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1208{
1209    return less<_Tp*>()(__x.get(), nullptr);
1210}
1211 
1212template<class _Tp>
1213inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1214bool
1215operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1216{
1217    return less<_Tp*>()(nullptr, __x.get());
1218}
1219 
1220template<class _Tp>
1221inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1222bool
1223operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1224{
1225    return nullptr < __x;
1226}
1227 
1228template<class _Tp>
1229inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1230bool
1231operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1232{
1233    return __x < nullptr;
1234}
1235 
1236template<class _Tp>
1237inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1238bool
1239operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1240{
1241    return !(nullptr < __x);
1242}
1243 
1244template<class _Tp>
1245inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1246bool
1247operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1248{
1249    return !(__x < nullptr);
1250}
1251 
1252template<class _Tp>
1253inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1254bool
1255operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1256{
1257    return !(__x < nullptr);
1258}
1259 
1260template<class _Tp>
1261inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1262bool
1263operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1264{
1265    return !(nullptr < __x);
1266}
1267 
1268template<class _Tp>
1269inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1270void
1271swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPTnoexcept
1272{
1273    __x.swap(__y);
1274}
1275 
1276template<class _Tp, class _Up>
1277inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1278shared_ptr<_Tp>
1279static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1280{
1281    return shared_ptr<_Tp>(__r,
1282                           static_cast<
1283                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
1284}
1285 
1286template<class _Tp, class _Up>
1287inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1288shared_ptr<_Tp>
1289dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1290{
1291    typedef typename shared_ptr<_Tp>::element_type _ET;
1292    _ET* __p = dynamic_cast<_ET*>(__r.get());
1293    return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
1294}
1295 
1296template<class _Tp, class _Up>
1297shared_ptr<_Tp>
1298const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1299{
1300    typedef typename shared_ptr<_Tp>::element_type _RTp;
1301    return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
1302}
1303 
1304template<class _Tp, class _Up>
1305shared_ptr<_Tp>
1306reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1307{
1308    return shared_ptr<_Tp>(__r,
1309                           reinterpret_cast<
1310                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
1311}
1312 
1313#ifndef _LIBCPP_NO_RTTI
1314 
1315template<class _Dp, class _Tp>
1316inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1317_Dp*
1318get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPTnoexcept
1319{
1320    return __p.template __get_deleter<_Dp>();
1321}
1322 
1323#endif // _LIBCPP_NO_RTTI
1324 
1325template<class _Tp>
1326class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr
1327{
1328public:
1329    typedef _Tp element_type;
1330private:
1331    element_type*        __ptr_;
1332    __shared_weak_count* __cntrl_;
1333 
1334public:
1335    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1336    _LIBCPP_CONSTEXPRconstexpr weak_ptr() _NOEXCEPTnoexcept;
1337    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(shared_ptr<_Yp> const& __r,
1338                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1339                        _NOEXCEPTnoexcept;
1340    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1341    weak_ptr(weak_ptr const& __r) _NOEXCEPTnoexcept;
1342    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(weak_ptr<_Yp> const& __r,
1343                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1344                         _NOEXCEPTnoexcept;
1345 
1346    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1347    weak_ptr(weak_ptr&& __r) _NOEXCEPTnoexcept;
1348    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(weak_ptr<_Yp>&& __r,
1349                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1350                         _NOEXCEPTnoexcept;
1351    ~weak_ptr();
1352 
1353    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1354    weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPTnoexcept;
1355    template<class _Yp>
1356        typename enable_if
1357        <
1358            is_convertible<_Yp*, element_type*>::value,
1359            weak_ptr&
1360        >::type
1361        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1362        operator=(weak_ptr<_Yp> const& __r) _NOEXCEPTnoexcept;
1363 
1364    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1365    weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPTnoexcept;
1366    template<class _Yp>
1367        typename enable_if
1368        <
1369            is_convertible<_Yp*, element_type*>::value,
1370            weak_ptr&
1371        >::type
1372        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1373        operator=(weak_ptr<_Yp>&& __r) _NOEXCEPTnoexcept;
1374 
1375    template<class _Yp>
1376        typename enable_if
1377        <
1378            is_convertible<_Yp*, element_type*>::value,
1379            weak_ptr&
1380        >::type
1381        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1382        operator=(shared_ptr<_Yp> const& __r) _NOEXCEPTnoexcept;
1383 
1384    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1385    void swap(weak_ptr& __r) _NOEXCEPTnoexcept;
1386    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1387    void reset() _NOEXCEPTnoexcept;
1388 
1389    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1390    long use_count() const _NOEXCEPTnoexcept
1391        {return __cntrl_ ? __cntrl_->use_count() : 0;}
1392    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1393    bool expired() const _NOEXCEPTnoexcept
1394        {return __cntrl_ == nullptr || __cntrl_->use_count() == 0;}
1395    shared_ptr<_Tp> lock() const _NOEXCEPTnoexcept;
1396    template<class _Up>
1397        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1398        bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPTnoexcept
1399        {return __cntrl_ < __r.__cntrl_;}
1400    template<class _Up>
1401        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1402        bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPTnoexcept
1403        {return __cntrl_ < __r.__cntrl_;}
1404 
1405    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
1406    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr;
1407};
1408 
1409#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1410template<class _Tp>
1411weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
1412#endif
1413 
1414template<class _Tp>
1415inline
1416_LIBCPP_CONSTEXPRconstexpr
1417weak_ptr<_Tp>::weak_ptr() _NOEXCEPTnoexcept
1418    : __ptr_(nullptr),
1419      __cntrl_(nullptr)
1420{
1421}
1422 
1423template<class _Tp>
1424inline
1425weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPTnoexcept
1426    : __ptr_(__r.__ptr_),
1427      __cntrl_(__r.__cntrl_)
1428{
1429    if (__cntrl_)
1430        __cntrl_->__add_weak();
1431}
1432 
1433template<class _Tp>
1434template<class _Yp>
1435inline
1436weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
1437                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1438                         _NOEXCEPTnoexcept
1439    : __ptr_(__r.__ptr_),
1440      __cntrl_(__r.__cntrl_)
1441{
1442    if (__cntrl_)
1443        __cntrl_->__add_weak();
1444}
1445 
1446template<class _Tp>
1447template<class _Yp>
1448inline
1449weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
1450                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1451         _NOEXCEPTnoexcept
1452    : __ptr_(__r.__ptr_),
1453      __cntrl_(__r.__cntrl_)
1454{
1455    if (__cntrl_)
1456        __cntrl_->__add_weak();
1457}
1458 
1459template<class _Tp>
1460inline
1461weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPTnoexcept
1462    : __ptr_(__r.__ptr_),
1463      __cntrl_(__r.__cntrl_)
1464{
1465    __r.__ptr_ = nullptr;
1466    __r.__cntrl_ = nullptr;
1467}
1468 
1469template<class _Tp>
1470template<class _Yp>
1471inline
1472weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
1473                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1474         _NOEXCEPTnoexcept
1475    : __ptr_(__r.__ptr_),
1476      __cntrl_(__r.__cntrl_)
1477{
1478    __r.__ptr_ = nullptr;
1479    __r.__cntrl_ = nullptr;
1480}
1481 
1482template<class _Tp>
1483weak_ptr<_Tp>::~weak_ptr()
1484{
1485    if (__cntrl_)
1486        __cntrl_->__release_weak();
1487}
1488 
1489template<class _Tp>
1490inline
1491weak_ptr<_Tp>&
1492weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPTnoexcept
1493{
1494    weak_ptr(__r).swap(*this);
1495    return *this;
1496}
1497 
1498template<class _Tp>
1499template<class _Yp>
1500inline
1501typename enable_if
1502<
1503    is_convertible<_Yp*, _Tp*>::value,
1504    weak_ptr<_Tp>&
1505>::type
1506weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPTnoexcept
1507{
1508    weak_ptr(__r).swap(*this);
1509    return *this;
1510}
1511 
1512template<class _Tp>
1513inline
1514weak_ptr<_Tp>&
1515weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPTnoexcept
1516{
1517    weak_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1518    return *this;
1519}
1520 
1521template<class _Tp>
1522template<class _Yp>
1523inline
1524typename enable_if
1525<
1526    is_convertible<_Yp*, _Tp*>::value,
1527    weak_ptr<_Tp>&
1528>::type
1529weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPTnoexcept
1530{
1531    weak_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1532    return *this;
1533}
1534 
1535template<class _Tp>
1536template<class _Yp>
1537inline
1538typename enable_if
1539<
1540    is_convertible<_Yp*, _Tp*>::value,
1541    weak_ptr<_Tp>&
1542>::type
1543weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPTnoexcept
1544{
1545    weak_ptr(__r).swap(*this);
1546    return *this;
1547}
1548 
1549template<class _Tp>
1550inline
1551void
1552weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPTnoexcept
1553{
1554    _VSTDstd::__1::swap(__ptr_, __r.__ptr_);
1555    _VSTDstd::__1::swap(__cntrl_, __r.__cntrl_);
1556}
1557 
1558template<class _Tp>
1559inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1560void
1561swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPTnoexcept
1562{
1563    __x.swap(__y);
1564}
1565 
1566template<class _Tp>
1567inline
1568void
1569weak_ptr<_Tp>::reset() _NOEXCEPTnoexcept
1570{
1571    weak_ptr().swap(*this);
1572}
1573 
1574template<class _Tp>
1575template<class _Yp>
1576shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
1577                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
1578    : __ptr_(__r.__ptr_),
1579      __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
1580{
1581    if (__cntrl_ == nullptr)
1582        __throw_bad_weak_ptr();
1583}
1584 
1585template<class _Tp>
1586shared_ptr<_Tp>
1587weak_ptr<_Tp>::lock() const _NOEXCEPTnoexcept
1588{
1589    shared_ptr<_Tp> __r;
1590    __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
1591    if (__r.__cntrl_)
1592        __r.__ptr_ = __ptr_;
1593    return __r;
1594}
1595 
1596#if _LIBCPP_STD_VER14 > 14
1597template <class _Tp = void> struct owner_less;
1598#else
1599template <class _Tp> struct owner_less;
1600#endif
1601 
1602 
1603_LIBCPP_SUPPRESS_DEPRECATED_PUSHGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated"
 GCC
 diagnostic ignored "-Wdeprecated-declarations"
1604template <class _Tp>
1605struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<shared_ptr<_Tp> >
1606#if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
1607    : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
1608#endif
1609{
1610_LIBCPP_SUPPRESS_DEPRECATED_POPGCC diagnostic pop
1611#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1612    _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type;
1613    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> first_argument_type;
1614    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> second_argument_type;
1615#endif
1616    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1617    bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1618        {return __x.owner_before(__y);}
1619    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1620    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1621        {return __x.owner_before(__y);}
1622    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1623    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1624        {return __x.owner_before(__y);}
1625};
1626 
1627_LIBCPP_SUPPRESS_DEPRECATED_PUSHGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated"
 GCC
 diagnostic ignored "-Wdeprecated-declarations"
1628template <class _Tp>
1629struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<weak_ptr<_Tp> >
1630#if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
1631    : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
1632#endif
1633{
1634_LIBCPP_SUPPRESS_DEPRECATED_POPGCC diagnostic pop
1635#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1636    _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type;
1637    _LIBCPP_DEPRECATED_IN_CXX17 typedef weak_ptr<_Tp> first_argument_type;
1638    _LIBCPP_DEPRECATED_IN_CXX17 typedef weak_ptr<_Tp> second_argument_type;
1639#endif
1640    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1641    bool operator()(  weak_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1642        {return __x.owner_before(__y);}
1643    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1644    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1645        {return __x.owner_before(__y);}
1646    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1647    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1648        {return __x.owner_before(__y);}
1649};
1650 
1651#if _LIBCPP_STD_VER14 > 14
1652template <>
1653struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<void>
1654{
1655    template <class _Tp, class _Up>
1656    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1657    bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1658        {return __x.owner_before(__y);}
1659    template <class _Tp, class _Up>
1660    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1661    bool operator()( shared_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1662        {return __x.owner_before(__y);}
1663    template <class _Tp, class _Up>
1664    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1665    bool operator()(   weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1666        {return __x.owner_before(__y);}
1667    template <class _Tp, class _Up>
1668    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1669    bool operator()(   weak_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1670        {return __x.owner_before(__y);}
1671    typedef void is_transparent;
1672};
1673#endif
1674 
1675template<class _Tp>
1676class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_shared_from_this
1677{
1678    mutable weak_ptr<_Tp> __weak_this_;
1679protected:
1680    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _LIBCPP_CONSTEXPRconstexpr
1681    enable_shared_from_this() _NOEXCEPTnoexcept {}
1682    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1683    enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPTnoexcept {}
1684    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1685    enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPTnoexcept
1686        {return *this;}
1687    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1688    ~enable_shared_from_this() {}
1689public:
1690    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1691    shared_ptr<_Tp> shared_from_this()
1692        {return shared_ptr<_Tp>(__weak_this_);}
1693    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1694    shared_ptr<_Tp const> shared_from_this() const
1695        {return shared_ptr<const _Tp>(__weak_this_);}
1696 
1697#if _LIBCPP_STD_VER14 > 14
1698    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1699    weak_ptr<_Tp> weak_from_this() _NOEXCEPTnoexcept
1700       { return __weak_this_; }
1701 
1702    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1703    weak_ptr<const _Tp> weak_from_this() const _NOEXCEPTnoexcept
1704        { return __weak_this_; }
1705#endif // _LIBCPP_STD_VER > 14
1706 
1707    template <class _Up> friend class shared_ptr;
1708};
1709 
1710template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash;
1711 
1712template <class _Tp>
1713struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash<shared_ptr<_Tp> >
1714{
1715#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1716    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
1717    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t          result_type;
1718#endif
1719 
1720    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1721    size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPTnoexcept
1722    {
1723        return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
1724    }
1725};
1726 
1727template<class _CharT, class _Traits, class _Yp>
1728inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1729basic_ostream<_CharT, _Traits>&
1730operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
1731 
1732 
1733#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
1734 
1735class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __sp_mut
1736{
1737    void* __lx;
1738public:
1739    void lock() _NOEXCEPTnoexcept;
1740    void unlock() _NOEXCEPTnoexcept;
1741 
1742private:
1743    _LIBCPP_CONSTEXPRconstexpr __sp_mut(void*) _NOEXCEPTnoexcept;
1744    __sp_mut(const __sp_mut&);
1745    __sp_mut& operator=(const __sp_mut&);
1746 
1747    friend _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) __sp_mut& __get_sp_mut(const void*);
1748};
1749 
1750_LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1751__sp_mut& __get_sp_mut(const void*);
1752 
1753template <class _Tp>
1754inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1755bool
1756atomic_is_lock_free(const shared_ptr<_Tp>*)
1757{
1758    return false;
1759}
1760 
1761template <class _Tp>
1762_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1763shared_ptr<_Tp>
1764atomic_load(const shared_ptr<_Tp>* __p)
1765{
1766    __sp_mut& __m = __get_sp_mut(__p);
1767    __m.lock();
1768    shared_ptr<_Tp> __q = *__p;
1769    __m.unlock();
1770    return __q;
1771}
1772 
1773template <class _Tp>
1774inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1775_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1776shared_ptr<_Tp>
1777atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
1778{
1779    return atomic_load(__p);
1780}
1781 
1782template <class _Tp>
1783_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1784void
1785atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1786{
1787    __sp_mut& __m = __get_sp_mut(__p);
1788    __m.lock();
1789    __p->swap(__r);
1790    __m.unlock();
1791}
1792 
1793template <class _Tp>
1794inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1795_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1796void
1797atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
1798{
1799    atomic_store(__p, __r);
1800}
1801 
1802template <class _Tp>
1803_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1804shared_ptr<_Tp>
1805atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1806{
1807    __sp_mut& __m = __get_sp_mut(__p);
1808    __m.lock();
1809    __p->swap(__r);
1810    __m.unlock();
1811    return __r;
1812}
1813 
1814template <class _Tp>
1815inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1816_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1817shared_ptr<_Tp>
1818atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
1819{
1820    return atomic_exchange(__p, __r);
1821}
1822 
1823template <class _Tp>
1824_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1825bool
1826atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
1827{
1828    shared_ptr<_Tp> __temp;
1829    __sp_mut& __m = __get_sp_mut(__p);
1830    __m.lock();
1831    if (__p->__owner_equivalent(*__v))
1832    {
1833        _VSTDstd::__1::swap(__temp, *__p);
1834        *__p = __w;
1835        __m.unlock();
1836        return true;
1837    }
1838    _VSTDstd::__1::swap(__temp, *__v);
1839    *__v = *__p;
1840    __m.unlock();
1841    return false;
1842}
1843 
1844template <class _Tp>
1845inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1846_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1847bool
1848atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
1849{
1850    return atomic_compare_exchange_strong(__p, __v, __w);
1851}
1852 
1853template <class _Tp>
1854inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1855_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1856bool
1857atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
1858                                        shared_ptr<_Tp> __w, memory_order, memory_order)
1859{
1860    return atomic_compare_exchange_strong(__p, __v, __w);
1861}
1862 
1863template <class _Tp>
1864inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1865_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1866bool
1867atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
1868                                      shared_ptr<_Tp> __w, memory_order, memory_order)
1869{
1870    return atomic_compare_exchange_weak(__p, __v, __w);
1871}
1872 
1873#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
1874 
1875_LIBCPP_END_NAMESPACE_STD} }
1876 
1877_LIBCPP_POP_MACROSpop_macro("min")
 pop_macro("max")
1878 
1879#endif // _LIBCPP___MEMORY_SHARED_PTR_H