/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Bug Summary

File:	tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
Warning:	line 67, column 29 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name RenderScriptRuntime.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D LLDB_USE_BUILTIN_DEMANGLER -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

→

1//===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10// C Includes
11// C++ Includes
12// Other libraries and framework includes
13#include "llvm/ADT/StringSwitch.h"

15// Project includes
16#include "RenderScriptRuntime.h"
17#include "RenderScriptScriptGroup.h"

19#include "lldb/Breakpoint/StoppointCallbackContext.h"
20#include "lldb/Core/Debugger.h"
21#include "lldb/Core/DumpDataExtractor.h"
22#include "lldb/Core/PluginManager.h"
23#include "lldb/Core/RegisterValue.h"
24#include "lldb/Core/ValueObjectVariable.h"
25#include "lldb/DataFormatters/DumpValueObjectOptions.h"
26#include "lldb/Expression/UserExpression.h"
27#include "lldb/Host/OptionParser.h"
28#include "lldb/Host/StringConvert.h"
29#include "lldb/Interpreter/Args.h"
30#include "lldb/Interpreter/CommandInterpreter.h"
31#include "lldb/Interpreter/CommandObjectMultiword.h"
32#include "lldb/Interpreter/CommandReturnObject.h"
33#include "lldb/Interpreter/Options.h"
34#include "lldb/Symbol/Function.h"
35#include "lldb/Symbol/Symbol.h"
36#include "lldb/Symbol/Type.h"
37#include "lldb/Symbol/VariableList.h"
38#include "lldb/Target/Process.h"
39#include "lldb/Target/RegisterContext.h"
40#include "lldb/Target/SectionLoadList.h"
41#include "lldb/Target/Target.h"
42#include "lldb/Target/Thread.h"
43#include "lldb/Utility/ConstString.h"
44#include "lldb/Utility/DataBufferLLVM.h"
45#include "lldb/Utility/Log.h"
46#include "lldb/Utility/RegularExpression.h"
47#include "lldb/Utility/Status.h"

49using namespace lldb;
50using namespace lldb_private;
51using namespace lldb_renderscript;

53#define FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")" "(%" PRIu32"u" ", %" PRIu32"u" ", %" PRIu32"u" ")"

55namespace {

57// The empirical_type adds a basic level of validation to arbitrary data
58// allowing us to track if data has been discovered and stored or not. An
59// empirical_type will be marked as valid only if it has been explicitly
60// assigned to.
61template <typename type_t> class empirical_type {
62public:
// Ctor. Contents is invalid when constructed.
empirical_type() : valid(false) {}

// Return true and copy contents to out if valid, else return false.
bool get(type_t &out) const {
  if (valid)
    out = data;
  return valid;
}

// Return a pointer to the contents or nullptr if it was not valid.
const type_t *get() const { return valid ? &data : nullptr; }

// Assign data explicitly.
void set(const type_t in) {
  data = in;
  valid = true;
}

// Mark contents as invalid.
void invalidate() { valid = false; }

// Returns true if this type contains valid data.
bool isValid() const { return valid; }

// Assignment operator.
empirical_type<type_t> &operator=(const type_t in) {
  set(in);
  return *this;
}

// Dereference operator returns contents.
// Warning: Will assert if not valid so use only when you know data is valid.
const type_t &operator*() const {
  assert(valid)(static_cast <bool> (valid) ? void (0) : __assert_fail (
"valid", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 97, __extension__ __PRETTY_FUNCTION__));
  return data;
}

101protected:
bool valid;
type_t data;
104};

106// ArgItem is used by the GetArgs() function when reading function arguments
107// from the target.
108struct ArgItem {
enum { ePointer, eInt32, eInt64, eLong, eBool } type;

uint64_t value;

explicit operator uint64_t() const { return value; }
114};

116// Context structure to be passed into GetArgsXXX(), argument reading functions
117// below.
118struct GetArgsCtx {
RegisterContext *reg_ctx;
Process *process;
121};

123bool GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

Status err;

// get the current stack pointer
uint64_t sp = ctx.reg_ctx->GetSP();

for (size_t i = 0; i < num_args; ++i) {
  ArgItem &arg = arg_list[i];
  // advance up the stack by one argument
  sp += sizeof(uint32_t);
  // get the argument type size
  size_t arg_size = sizeof(uint32_t);
  // read the argument from memory
  arg.value = 0;
  Status err;
  size_t read =
      ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), err);
  if (read != arg_size || !err.Success()) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u" " '%s'",
                  __FUNCTION__, uint64_t(i), err.AsCString());
    return false;
  }
}
return true;
150}

152bool GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

// number of arguments passed in registers
static const uint32_t args_in_reg = 6;
// register passing order
static const std::array<const char *, args_in_reg> reg_names{
    {"rdi", "rsi", "rdx", "rcx", "r8", "r9"}};
// argument type to size mapping
static const std::array<size_t, 5> arg_size{{
    8, // ePointer,
    4, // eInt32,
    8, // eInt64,
    8, // eLong,
    4, // eBool,
}};

Status err;

// get the current stack pointer
uint64_t sp = ctx.reg_ctx->GetSP();
// step over the return address
sp += sizeof(uint64_t);

// check the stack alignment was correct (16 byte aligned)
if ((sp & 0xf) != 0x0) {
  if (log)
    log->Printf("%s - stack misaligned", __FUNCTION__);
  return false;
}

// find the start of arguments on the stack
uint64_t sp_offset = 0;
for (uint32_t i = args_in_reg; i < num_args; ++i) {
  sp_offset += arg_size[arg_list[i].type];
}
// round up to multiple of 16
sp_offset = (sp_offset + 0xf) & 0xf;
sp += sp_offset;

for (size_t i = 0; i < num_args; ++i) {
  bool success = false;
  ArgItem &arg = arg_list[i];
  // arguments passed in registers
  if (i < args_in_reg) {
    const RegisterInfo *reg =
        ctx.reg_ctx->GetRegisterInfoByName(reg_names[i]);
    RegisterValue reg_val;
    if (ctx.reg_ctx->ReadRegister(reg, reg_val))
      arg.value = reg_val.GetAsUInt64(0, &success);
  }
  // arguments passed on the stack
  else {
    // get the argument type size
    const size_t size = arg_size[arg_list[i].type];
    // read the argument from memory
    arg.value = 0;
    // note: due to little endian layout reading 4 or 8 bytes will give the
    // correct value.
    size_t read = ctx.process->ReadMemory(sp, &arg.value, size, err);
    success = (err.Success() && read == size);
    // advance past this argument
    sp -= size;
  }
  // fail if we couldn't read this argument
  if (!success) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u" ", reason: %s",
                  __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
    return false;
  }
}
return true;
225}

227bool GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
// number of arguments passed in registers
static const uint32_t args_in_reg = 4;

Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

Status err;

// get the current stack pointer
uint64_t sp = ctx.reg_ctx->GetSP();

for (size_t i = 0; i < num_args; ++i) {
  bool success = false;
  ArgItem &arg = arg_list[i];
  // arguments passed in registers
  if (i < args_in_reg) {
    const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
    RegisterValue reg_val;
    if (ctx.reg_ctx->ReadRegister(reg, reg_val))
      arg.value = reg_val.GetAsUInt32(0, &success);
  }
  // arguments passed on the stack
  else {
    // get the argument type size
    const size_t arg_size = sizeof(uint32_t);
    // clear all 64bits
    arg.value = 0;
    // read this argument from memory
    size_t bytes_read =
        ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
    success = (err.Success() && bytes_read == arg_size);
    // advance the stack pointer
    sp += sizeof(uint32_t);
  }
  // fail if we couldn't read this argument
  if (!success) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u" ", reason: %s",
                  __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
    return false;
  }
}
return true;
270}

272bool GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
// number of arguments passed in registers
static const uint32_t args_in_reg = 8;

Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

for (size_t i = 0; i < num_args; ++i) {
  bool success = false;
  ArgItem &arg = arg_list[i];
  // arguments passed in registers
  if (i < args_in_reg) {
    const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
    RegisterValue reg_val;
    if (ctx.reg_ctx->ReadRegister(reg, reg_val))
      arg.value = reg_val.GetAsUInt64(0, &success);
  }
  // arguments passed on the stack
  else {
    if (log)
      log->Printf("%s - reading arguments spilled to stack not implemented",
                  __FUNCTION__);
  }
  // fail if we couldn't read this argument
  if (!success) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u", __FUNCTION__,
                  uint64_t(i));
    return false;
  }
}
return true;
303}

305bool GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
// number of arguments passed in registers
static const uint32_t args_in_reg = 4;
// register file offset to first argument
static const uint32_t reg_offset = 4;

Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

Status err;

// find offset to arguments on the stack (+16 to skip over a0-a3 shadow space)
uint64_t sp = ctx.reg_ctx->GetSP() + 16;

for (size_t i = 0; i < num_args; ++i) {
  bool success = false;
  ArgItem &arg = arg_list[i];
  // arguments passed in registers
  if (i < args_in_reg) {
    const RegisterInfo *reg =
        ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset);
    RegisterValue reg_val;
    if (ctx.reg_ctx->ReadRegister(reg, reg_val))
      arg.value = reg_val.GetAsUInt64(0, &success);
  }
  // arguments passed on the stack
  else {
    const size_t arg_size = sizeof(uint32_t);
    arg.value = 0;
    size_t bytes_read =
        ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
    success = (err.Success() && bytes_read == arg_size);
    // advance the stack pointer
    sp += arg_size;
  }
  // fail if we couldn't read this argument
  if (!success) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u" ", reason: %s",
                  __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
    return false;
  }
}
return true;
348}

350bool GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
// number of arguments passed in registers
static const uint32_t args_in_reg = 8;
// register file offset to first argument
static const uint32_t reg_offset = 4;

Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

Status err;

// get the current stack pointer
uint64_t sp = ctx.reg_ctx->GetSP();

for (size_t i = 0; i < num_args; ++i) {
  bool success = false;
  ArgItem &arg = arg_list[i];
  // arguments passed in registers
  if (i < args_in_reg) {
    const RegisterInfo *reg =
        ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset);
    RegisterValue reg_val;
    if (ctx.reg_ctx->ReadRegister(reg, reg_val))
      arg.value = reg_val.GetAsUInt64(0, &success);
  }
  // arguments passed on the stack
  else {
    // get the argument type size
    const size_t arg_size = sizeof(uint64_t);
    // clear all 64bits
    arg.value = 0;
    // read this argument from memory
    size_t bytes_read =
        ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
    success = (err.Success() && bytes_read == arg_size);
    // advance the stack pointer
    sp += arg_size;
  }
  // fail if we couldn't read this argument
  if (!success) {
    if (log)
      log->Printf("%s - error reading argument: %" PRIu64"l" "u" ", reason: %s",
                  __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
    return false;
  }
}
return true;
396}

398bool GetArgs(ExecutionContext &exe_ctx, ArgItem *arg_list, size_t num_args) {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

// verify that we have a target
if (!exe_ctx.GetTargetPtr()) {
  if (log)
    log->Printf("%s - invalid target", __FUNCTION__);
  return false;
}

GetArgsCtx ctx = {exe_ctx.GetRegisterContext(), exe_ctx.GetProcessPtr()};
assert(ctx.reg_ctx && ctx.process)(static_cast <bool> (ctx.reg_ctx && ctx.process
) ? void (0) : __assert_fail ("ctx.reg_ctx && ctx.process"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 409, __extension__ __PRETTY_FUNCTION__));

// dispatch based on architecture
switch (exe_ctx.GetTargetPtr()->GetArchitecture().GetMachine()) {
case llvm::Triple::ArchType::x86:
  return GetArgsX86(ctx, arg_list, num_args);

case llvm::Triple::ArchType::x86_64:
  return GetArgsX86_64(ctx, arg_list, num_args);

case llvm::Triple::ArchType::arm:
  return GetArgsArm(ctx, arg_list, num_args);

case llvm::Triple::ArchType::aarch64:
  return GetArgsAarch64(ctx, arg_list, num_args);

case llvm::Triple::ArchType::mipsel:
  return GetArgsMipsel(ctx, arg_list, num_args);

case llvm::Triple::ArchType::mips64el:
  return GetArgsMips64el(ctx, arg_list, num_args);

default:
  // unsupported architecture
  if (log) {
    log->Printf(
        "%s - architecture not supported: '%s'", __FUNCTION__,
        exe_ctx.GetTargetRef().GetArchitecture().GetArchitectureName());
  }
  return false;
}
440}

442bool IsRenderScriptScriptModule(ModuleSP module) {
if (!module)
  return false;
return module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"),
                                              eSymbolTypeData) != nullptr;
447}

449bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) {
// takes an argument of the form 'num[,num][,num]'.
// Where 'coord_s' is a comma separated 1,2 or 3-dimensional coordinate
// with the whitespace trimmed.
// Missing coordinates are defaulted to zero.
// If parsing of any elements fails the contents of &coord are undefined
// and `false` is returned, `true` otherwise

RegularExpression regex;
RegularExpression::Match regex_match(3);

bool matched = false;
if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+),([0-9]+)$")) &&
    regex.Execute(coord_s, &regex_match))
  matched = true;
else if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+)$")) &&
         regex.Execute(coord_s, &regex_match))
  matched = true;
else if (regex.Compile(llvm::StringRef("^([0-9]+)$")) &&
         regex.Execute(coord_s, &regex_match))
  matched = true;

if (!matched)
  return false;

auto get_index = [&](int idx, uint32_t &i) -> bool {
  std::string group;
  errno(*__errno_location ()) = 0;
  if (regex_match.GetMatchAtIndex(coord_s.str().c_str(), idx + 1, group))
    return !llvm::StringRef(group).getAsInteger<uint32_t>(10, i);
  return true;
};

return get_index(0, coord.x) && get_index(1, coord.y) &&
       get_index(2, coord.z);
484}

486bool SkipPrologue(lldb::ModuleSP &module, Address &addr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));
SymbolContext sc;
uint32_t resolved_flags =
    module->ResolveSymbolContextForAddress(addr, eSymbolContextFunction, sc);
if (resolved_flags & eSymbolContextFunction) {
  if (sc.function) {
    const uint32_t offset = sc.function->GetPrologueByteSize();
    ConstString name = sc.GetFunctionName();
    if (offset)
      addr.Slide(offset);
    if (log)
      log->Printf("%s: Prologue offset for %s is %" PRIu32"u", __FUNCTION__,
                  name.AsCString(), offset);
  }
  return true;
} else
  return false;
504}
505} // anonymous namespace

507// The ScriptDetails class collects data associated with a single script
508// instance.
509struct RenderScriptRuntime::ScriptDetails {
~ScriptDetails() = default;

enum ScriptType { eScript, eScriptC };

// The derived type of the script.
empirical_type<ScriptType> type;
// The name of the original source file.
empirical_type<std::string> res_name;
// Path to script .so file on the device.
empirical_type<std::string> shared_lib;
// Directory where kernel objects are cached on device.
empirical_type<std::string> cache_dir;
// Pointer to the context which owns this script.
empirical_type<lldb::addr_t> context;
// Pointer to the script object itself.
empirical_type<lldb::addr_t> script;
526};

528// This Element class represents the Element object in RS, defining the type
529// associated with an Allocation.
530struct RenderScriptRuntime::Element {
// Taken from rsDefines.h
enum DataKind {
  RS_KIND_USER,
  RS_KIND_PIXEL_L = 7,
  RS_KIND_PIXEL_A,
  RS_KIND_PIXEL_LA,
  RS_KIND_PIXEL_RGB,
  RS_KIND_PIXEL_RGBA,
  RS_KIND_PIXEL_DEPTH,
  RS_KIND_PIXEL_YUV,
  RS_KIND_INVALID = 100
};

// Taken from rsDefines.h
enum DataType {
  RS_TYPE_NONE = 0,
  RS_TYPE_FLOAT_16,
  RS_TYPE_FLOAT_32,
  RS_TYPE_FLOAT_64,
  RS_TYPE_SIGNED_8,
  RS_TYPE_SIGNED_16,
  RS_TYPE_SIGNED_32,
  RS_TYPE_SIGNED_64,
  RS_TYPE_UNSIGNED_8,
  RS_TYPE_UNSIGNED_16,
  RS_TYPE_UNSIGNED_32,
  RS_TYPE_UNSIGNED_64,
  RS_TYPE_BOOLEAN,

  RS_TYPE_UNSIGNED_5_6_5,
  RS_TYPE_UNSIGNED_5_5_5_1,
  RS_TYPE_UNSIGNED_4_4_4_4,

  RS_TYPE_MATRIX_4X4,
  RS_TYPE_MATRIX_3X3,
  RS_TYPE_MATRIX_2X2,

  RS_TYPE_ELEMENT = 1000,
  RS_TYPE_TYPE,
  RS_TYPE_ALLOCATION,
  RS_TYPE_SAMPLER,
  RS_TYPE_SCRIPT,
  RS_TYPE_MESH,
  RS_TYPE_PROGRAM_FRAGMENT,
  RS_TYPE_PROGRAM_VERTEX,
  RS_TYPE_PROGRAM_RASTER,
  RS_TYPE_PROGRAM_STORE,
  RS_TYPE_FONT,

  RS_TYPE_INVALID = 10000
};

std::vector<Element> children; // Child Element fields for structs
empirical_type<lldb::addr_t>
    element_ptr; // Pointer to the RS Element of the Type
empirical_type<DataType>
    type; // Type of each data pointer stored by the allocation
empirical_type<DataKind>
    type_kind; // Defines pixel type if Allocation is created from an image
empirical_type<uint32_t>
    type_vec_size; // Vector size of each data point, e.g '4' for uchar4
empirical_type<uint32_t> field_count; // Number of Subelements
empirical_type<uint32_t> datum_size;  // Size of a single Element with padding
empirical_type<uint32_t> padding;     // Number of padding bytes
empirical_type<uint32_t>
    array_size;        // Number of items in array, only needed for strucrs
ConstString type_name; // Name of type, only needed for structs

static const ConstString &
GetFallbackStructName(); // Print this as the type name of a struct Element
                         // If we can't resolve the actual struct name

bool ShouldRefresh() const {
  const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
  const bool valid_type =
      type.isValid() && type_vec_size.isValid() && type_kind.isValid();
  return !valid_ptr || !valid_type || !datum_size.isValid();
}
609};

611// This AllocationDetails class collects data associated with a single
612// allocation instance.
613struct RenderScriptRuntime::AllocationDetails {
struct Dimension {
  uint32_t dim_1;
  uint32_t dim_2;
  uint32_t dim_3;
  uint32_t cube_map;

  Dimension() {
    dim_1 = 0;
    dim_2 = 0;
    dim_3 = 0;
    cube_map = 0;
  }
};

// The FileHeader struct specifies the header we use for writing allocations
// to a binary file. Our format begins with the ASCII characters "RSAD",
// identifying the file as an allocation dump. Member variables dims and
// hdr_size are then written consecutively, immediately followed by an
// instance of the ElementHeader struct. Because Elements can contain
// subelements, there may be more than one instance of the ElementHeader
// struct. With this first instance being the root element, and the other
// instances being the root's descendants. To identify which instances are an
// ElementHeader's children, each struct is immediately followed by a sequence
// of consecutive offsets to the start of its child structs. These offsets are
// 4 bytes in size, and the 0 offset signifies no more children.
struct FileHeader {
  uint8_t ident[4];  // ASCII 'RSAD' identifying the file
  uint32_t dims[3];  // Dimensions
  uint16_t hdr_size; // Header size in bytes, including all element headers
};

struct ElementHeader {
  uint16_t type;         // DataType enum
  uint32_t kind;         // DataKind enum
  uint32_t element_size; // Size of a single element, including padding
  uint16_t vector_size;  // Vector width
  uint32_t array_size;   // Number of elements in array
};

// Monotonically increasing from 1
static uint32_t ID;

// Maps Allocation DataType enum and vector size to printable strings
// using mapping from RenderScript numerical types summary documentation
static const char *RsDataTypeToString[][4];

// Maps Allocation DataKind enum to printable strings
static const char *RsDataKindToString[];

// Maps allocation types to format sizes for printing.
static const uint32_t RSTypeToFormat[][3];

// Give each allocation an ID as a way
// for commands to reference it.
const uint32_t id;

// Allocation Element type
RenderScriptRuntime::Element element;
// Dimensions of the Allocation
empirical_type<Dimension> dimension;
// Pointer to address of the RS Allocation
empirical_type<lldb::addr_t> address;
// Pointer to the data held by the Allocation
empirical_type<lldb::addr_t> data_ptr;
// Pointer to the RS Type of the Allocation
empirical_type<lldb::addr_t> type_ptr;
// Pointer to the RS Context of the Allocation
empirical_type<lldb::addr_t> context;
// Size of the allocation
empirical_type<uint32_t> size;
// Stride between rows of the allocation
empirical_type<uint32_t> stride;

// Give each allocation an id, so we can reference it in user commands.
AllocationDetails() : id(ID++) {}

bool ShouldRefresh() const {
  bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0;
  valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0;
  return !valid_ptrs || !dimension.isValid() || !size.isValid() ||
         element.ShouldRefresh();
}
696};

698const ConstString &RenderScriptRuntime::Element::GetFallbackStructName() {
static const ConstString FallbackStructName("struct");
return FallbackStructName;
701}

703uint32_t RenderScriptRuntime::AllocationDetails::ID = 1;

705const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = {
  "User",       "Undefined",   "Undefined", "Undefined",
  "Undefined",  "Undefined",   "Undefined", // Enum jumps from 0 to 7
  "L Pixel",    "A Pixel",     "LA Pixel",  "RGB Pixel",
  "RGBA Pixel", "Pixel Depth", "YUV Pixel"};

711const char *RenderScriptRuntime::AllocationDetails::RsDataTypeToString[][4] = {
  {"None", "None", "None", "None"},
  {"half", "half2", "half3", "half4"},
  {"float", "float2", "float3", "float4"},
  {"double", "double2", "double3", "double4"},
  {"char", "char2", "char3", "char4"},
  {"short", "short2", "short3", "short4"},
  {"int", "int2", "int3", "int4"},
  {"long", "long2", "long3", "long4"},
  {"uchar", "uchar2", "uchar3", "uchar4"},
  {"ushort", "ushort2", "ushort3", "ushort4"},
  {"uint", "uint2", "uint3", "uint4"},
  {"ulong", "ulong2", "ulong3", "ulong4"},
  {"bool", "bool2", "bool3", "bool4"},
  {"packed_565", "packed_565", "packed_565", "packed_565"},
  {"packed_5551", "packed_5551", "packed_5551", "packed_5551"},
  {"packed_4444", "packed_4444", "packed_4444", "packed_4444"},
  {"rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4"},
  {"rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3"},
  {"rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2"},

  // Handlers
  {"RS Element", "RS Element", "RS Element", "RS Element"},
  {"RS Type", "RS Type", "RS Type", "RS Type"},
  {"RS Allocation", "RS Allocation", "RS Allocation", "RS Allocation"},
  {"RS Sampler", "RS Sampler", "RS Sampler", "RS Sampler"},
  {"RS Script", "RS Script", "RS Script", "RS Script"},

  // Deprecated
  {"RS Mesh", "RS Mesh", "RS Mesh", "RS Mesh"},
  {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment",
   "RS Program Fragment"},
  {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex",
   "RS Program Vertex"},
  {"RS Program Raster", "RS Program Raster", "RS Program Raster",
   "RS Program Raster"},
  {"RS Program Store", "RS Program Store", "RS Program Store",
   "RS Program Store"},
  {"RS Font", "RS Font", "RS Font", "RS Font"}};

751// Used as an index into the RSTypeToFormat array elements
752enum TypeToFormatIndex { eFormatSingle = 0, eFormatVector, eElementSize };

754// { format enum of single element, format enum of element vector, size of
755// element}
756const uint32_t RenderScriptRuntime::AllocationDetails::RSTypeToFormat[][3] = {
  // RS_TYPE_NONE
  {eFormatHex, eFormatHex, 1},
  // RS_TYPE_FLOAT_16
  {eFormatFloat, eFormatVectorOfFloat16, 2},
  // RS_TYPE_FLOAT_32
  {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)},
  // RS_TYPE_FLOAT_64
  {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)},
  // RS_TYPE_SIGNED_8
  {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)},
  // RS_TYPE_SIGNED_16
  {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)},
  // RS_TYPE_SIGNED_32
  {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)},
  // RS_TYPE_SIGNED_64
  {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)},
  // RS_TYPE_UNSIGNED_8
  {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)},
  // RS_TYPE_UNSIGNED_16
  {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)},
  // RS_TYPE_UNSIGNED_32
  {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)},
  // RS_TYPE_UNSIGNED_64
  {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)},
  // RS_TYPE_BOOL
  {eFormatBoolean, eFormatBoolean, 1},
  // RS_TYPE_UNSIGNED_5_6_5
  {eFormatHex, eFormatHex, sizeof(uint16_t)},
  // RS_TYPE_UNSIGNED_5_5_5_1
  {eFormatHex, eFormatHex, sizeof(uint16_t)},
  // RS_TYPE_UNSIGNED_4_4_4_4
  {eFormatHex, eFormatHex, sizeof(uint16_t)},
  // RS_TYPE_MATRIX_4X4
  {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16},
  // RS_TYPE_MATRIX_3X3
  {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9},
  // RS_TYPE_MATRIX_2X2
  {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}};

796//------------------------------------------------------------------
797// Static Functions
798//------------------------------------------------------------------
799LanguageRuntime *
800RenderScriptRuntime::CreateInstance(Process *process,
                                  lldb::LanguageType language) {

if (language == eLanguageTypeExtRenderScript)
  return new RenderScriptRuntime(process);
else
  return nullptr;
807}

809// Callback with a module to search for matching symbols. We first check that
810// the module contains RS kernels. Then look for a symbol which matches our
811// kernel name. The breakpoint address is finally set using the address of this
812// symbol.
813Searcher::CallbackReturn
814RSBreakpointResolver::SearchCallback(SearchFilter &filter,
                                   SymbolContext &context, Address *, bool) {
ModuleSP module = context.module_sp;

if (!module || !IsRenderScriptScriptModule(module))
  return Searcher::eCallbackReturnContinue;

// Attempt to set a breakpoint on the kernel name symbol within the module
// library. If it's not found, it's likely debug info is unavailable - try to
// set a breakpoint on <name>.expand.
const Symbol *kernel_sym =
    module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
if (!kernel_sym) {
  std::string kernel_name_expanded(m_kernel_name.AsCString());
  kernel_name_expanded.append(".expand");
  kernel_sym = module->FindFirstSymbolWithNameAndType(
      ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
}

if (kernel_sym) {
  Address bp_addr = kernel_sym->GetAddress();
  if (filter.AddressPasses(bp_addr))
    m_breakpoint->AddLocation(bp_addr);
}

return Searcher::eCallbackReturnContinue;
840}

842Searcher::CallbackReturn
843RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter,
                                         lldb_private::SymbolContext &context,
                                         Address *, bool) {
// We need to have access to the list of reductions currently parsed, as
// reduce names don't actually exist as
// symbols in a module. They are only identifiable by parsing the .rs.info
// packet, or finding the expand symbol. We
// therefore need access to the list of parsed rs modules to properly resolve
// reduction names.
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
ModuleSP module = context.module_sp;

if (!module || !IsRenderScriptScriptModule(module))
  return Searcher::eCallbackReturnContinue;

if (!m_rsmodules)
  return Searcher::eCallbackReturnContinue;

for (const auto &module_desc : *m_rsmodules) {
  if (module_desc->m_module != module)
    continue;

  for (const auto &reduction : module_desc->m_reductions) {
    if (reduction.m_reduce_name != m_reduce_name)
      continue;

    std::array<std::pair<ConstString, int>, 5> funcs{
        {{reduction.m_init_name, eKernelTypeInit},
         {reduction.m_accum_name, eKernelTypeAccum},
         {reduction.m_comb_name, eKernelTypeComb},
         {reduction.m_outc_name, eKernelTypeOutC},
         {reduction.m_halter_name, eKernelTypeHalter}}};

    for (const auto &kernel : funcs) {
      // Skip constituent functions that don't match our spec
      if (!(m_kernel_types & kernel.second))
        continue;

      const auto kernel_name = kernel.first;
      const auto symbol = module->FindFirstSymbolWithNameAndType(
          kernel_name, eSymbolTypeCode);
      if (!symbol)
        continue;

      auto address = symbol->GetAddress();
      if (filter.AddressPasses(address)) {
        bool new_bp;
        if (!SkipPrologue(module, address)) {
          if (log)
            log->Printf("%s: Error trying to skip prologue", __FUNCTION__);
        }
        m_breakpoint->AddLocation(address, &new_bp);
        if (log)
          log->Printf("%s: %s reduction breakpoint on %s in %s", __FUNCTION__,
                      new_bp ? "new" : "existing", kernel_name.GetCString(),
                      address.GetModule()->GetFileSpec().GetCString());
      }
    }
  }
}
return eCallbackReturnContinue;
904}

906Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback(
  SearchFilter &filter, SymbolContext &context, Address *addr,
  bool containing) {

if (!m_breakpoint)
  return eCallbackReturnContinue;

Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
ModuleSP &module = context.module_sp;

if (!module || !IsRenderScriptScriptModule(module))
  return Searcher::eCallbackReturnContinue;

std::vector<std::string> names;
m_breakpoint->GetNames(names);
if (names.empty())
  return eCallbackReturnContinue;

for (auto &name : names) {
  const RSScriptGroupDescriptorSP sg = FindScriptGroup(ConstString(name));
  if (!sg) {
    if (log)
      log->Printf("%s: could not find script group for %s", __FUNCTION__,
                  name.c_str());
    continue;
  }

  if (log)
    log->Printf("%s: Found ScriptGroup for %s", __FUNCTION__, name.c_str());

  for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) {
    if (log) {
      log->Printf("%s: Adding breakpoint for %s", __FUNCTION__,
                  k.m_name.AsCString());
      log->Printf("%s: Kernel address 0x%" PRIx64"l" "x", __FUNCTION__, k.m_addr);
    }

    const lldb_private::Symbol *sym =
        module->FindFirstSymbolWithNameAndType(k.m_name, eSymbolTypeCode);
    if (!sym) {
      if (log)
        log->Printf("%s: Unable to find symbol for %s", __FUNCTION__,
                    k.m_name.AsCString());
      continue;
    }

    if (log) {
      log->Printf("%s: Found symbol name is %s", __FUNCTION__,
                  sym->GetName().AsCString());
    }

    auto address = sym->GetAddress();
    if (!SkipPrologue(module, address)) {
      if (log)
        log->Printf("%s: Error trying to skip prologue", __FUNCTION__);
    }

    bool new_bp;
    m_breakpoint->AddLocation(address, &new_bp);

    if (log)
      log->Printf("%s: Placed %sbreakpoint on %s", __FUNCTION__,
                  new_bp ? "new " : "", k.m_name.AsCString());

    // exit after placing the first breakpoint if we do not intend to stop
    // on all kernels making up this script group
    if (!m_stop_on_all)
      break;
  }
}

return eCallbackReturnContinue;
978}

980void RenderScriptRuntime::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(),
                              "RenderScript language support", CreateInstance,
                              GetCommandObject);
984}

986void RenderScriptRuntime::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
988}

990lldb_private::ConstString RenderScriptRuntime::GetPluginNameStatic() {
static ConstString plugin_name("renderscript");
return plugin_name;
993}

995RenderScriptRuntime::ModuleKind
996RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp) {
if (module_sp) {
  if (IsRenderScriptScriptModule(module_sp))
    return eModuleKindKernelObj;

  // Is this the main RS runtime library
  const ConstString rs_lib("libRS.so");
  if (module_sp->GetFileSpec().GetFilename() == rs_lib) {
    return eModuleKindLibRS;
  }

  const ConstString rs_driverlib("libRSDriver.so");
  if (module_sp->GetFileSpec().GetFilename() == rs_driverlib) {
    return eModuleKindDriver;
  }

  const ConstString rs_cpureflib("libRSCpuRef.so");
  if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib) {
    return eModuleKindImpl;
  }
}
return eModuleKindIgnored;
1018}

1020bool RenderScriptRuntime::IsRenderScriptModule(
  const lldb::ModuleSP &module_sp) {
return GetModuleKind(module_sp) != eModuleKindIgnored;
1023}

1025void RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list) {
std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());

size_t num_modules = module_list.GetSize();
for (size_t i = 0; i < num_modules; i++) {
  auto mod = module_list.GetModuleAtIndex(i);
  if (IsRenderScriptModule(mod)) {
    LoadModule(mod);
  }
}
1035}

1037//------------------------------------------------------------------
1038// PluginInterface protocol
1039//------------------------------------------------------------------
1040lldb_private::ConstString RenderScriptRuntime::GetPluginName() {
return GetPluginNameStatic();
1042}

1044uint32_t RenderScriptRuntime::GetPluginVersion() { return 1; }

1046bool RenderScriptRuntime::IsVTableName(const char *name) { return false; }

1048bool RenderScriptRuntime::GetDynamicTypeAndAddress(
  ValueObject &in_value, lldb::DynamicValueType use_dynamic,
  TypeAndOrName &class_type_or_name, Address &address,
  Value::ValueType &value_type) {
return false;
1053}

1055TypeAndOrName
1056RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
                                    ValueObject &static_value) {
return type_and_or_name;
1059}

1061bool RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
return false;
1063}

1065lldb::BreakpointResolverSP
1066RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bp, bool catch_bp,
                                           bool throw_bp) {
BreakpointResolverSP resolver_sp;
return resolver_sp;
1070}

1072const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] =
  {
      // rsdScript
      {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEP"
                        "NS0_7ScriptCEPKcS7_PKhjj",
       "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_"
       "7ScriptCEPKcS7_PKhmj",
       0, RenderScriptRuntime::eModuleKindDriver,
       &lldb_private::RenderScriptRuntime::CaptureScriptInit},
      {"rsdScriptInvokeForEachMulti",
       "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0"
       "_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall",
       "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0"
       "_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall",
       0, RenderScriptRuntime::eModuleKindDriver,
       &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti},
      {"rsdScriptSetGlobalVar", "_Z21rsdScriptSetGlobalVarPKN7android12render"
                                "script7ContextEPKNS0_6ScriptEjPvj",
       "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_"
       "6ScriptEjPvm",
       0, RenderScriptRuntime::eModuleKindDriver,
       &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar},

      // rsdAllocation
      {"rsdAllocationInit", "_Z17rsdAllocationInitPKN7android12renderscript7C"
                            "ontextEPNS0_10AllocationEb",
       "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_"
       "10AllocationEb",
       0, RenderScriptRuntime::eModuleKindDriver,
       &lldb_private::RenderScriptRuntime::CaptureAllocationInit},
      {"rsdAllocationRead2D",
       "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_"
       "10AllocationEjjj23RsAllocationCubemapFacejjPvjj",
       "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_"
       "10AllocationEjjj23RsAllocationCubemapFacejjPvmm",
       0, RenderScriptRuntime::eModuleKindDriver, nullptr},
      {"rsdAllocationDestroy", "_Z20rsdAllocationDestroyPKN7android12rendersc"
                               "ript7ContextEPNS0_10AllocationE",
       "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_"
       "10AllocationE",
       0, RenderScriptRuntime::eModuleKindDriver,
       &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy},

      // renderscript script groups
      {"rsdDebugHintScriptGroup2", "_ZN7android12renderscript21debugHintScrip"
                                   "tGroup2EPKcjPKPFvPK24RsExpandKernelDriver"
                                   "InfojjjEj",
       "_ZN7android12renderscript21debugHintScriptGroup2EPKcjPKPFvPK24RsExpan"
       "dKernelDriverInfojjjEj",
       0, RenderScriptRuntime::eModuleKindImpl,
       &lldb_private::RenderScriptRuntime::CaptureDebugHintScriptGroup2}};

1124const size_t RenderScriptRuntime::s_runtimeHookCount =
  sizeof(s_runtimeHookDefns) / sizeof(s_runtimeHookDefns[0]);

1127bool RenderScriptRuntime::HookCallback(void *baton,
                                     StoppointCallbackContext *ctx,
                                     lldb::user_id_t break_id,
                                     lldb::user_id_t break_loc_id) {
RuntimeHook *hook = (RuntimeHook *)baton;
ExecutionContext exe_ctx(ctx->exe_ctx_ref);

RenderScriptRuntime *lang_rt =
    (RenderScriptRuntime *)exe_ctx.GetProcessPtr()->GetLanguageRuntime(
        eLanguageTypeExtRenderScript);

lang_rt->HookCallback(hook, exe_ctx);

return false;
1141}

1143void RenderScriptRuntime::HookCallback(RuntimeHook *hook,
                                     ExecutionContext &exe_ctx) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (log)
  log->Printf("%s - '%s'", __FUNCTION__, hook->defn->name);

if (hook->defn->grabber) {
  (this->*(hook->defn->grabber))(hook, exe_ctx);
}
1153}

1155void RenderScriptRuntime::CaptureDebugHintScriptGroup2(
  RuntimeHook *hook_info, ExecutionContext &context) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

enum {
  eGroupName = 0,
  eGroupNameSize,
  eKernel,
  eKernelCount,
};

std::array<ArgItem, 4> args{{
    {ArgItem::ePointer, 0}, // const char         *groupName
    {ArgItem::eInt32, 0},   // const uint32_t      groupNameSize
    {ArgItem::ePointer, 0}, // const ExpandFuncTy *kernel
    {ArgItem::eInt32, 0},   // const uint32_t      kernelCount
}};

if (!GetArgs(context, args.data(), args.size())) {
  if (log)
    log->Printf("%s - Error while reading the function parameters",
                __FUNCTION__);
  return;
} else if (log) {
  log->Printf("%s - groupName    : 0x%" PRIx64"l" "x", __FUNCTION__,
              addr_t(args[eGroupName]));
  log->Printf("%s - groupNameSize: %" PRIu64"l" "u", __FUNCTION__,
              uint64_t(args[eGroupNameSize]));
  log->Printf("%s - kernel       : 0x%" PRIx64"l" "x", __FUNCTION__,
              addr_t(args[eKernel]));
  log->Printf("%s - kernelCount  : %" PRIu64"l" "u", __FUNCTION__,
              uint64_t(args[eKernelCount]));
}

// parse script group name
ConstString group_name;
{
  Status err;
  const uint64_t len = uint64_t(args[eGroupNameSize]);
  std::unique_ptr<char[]> buffer(new char[uint32_t(len + 1)]);
  m_process->ReadMemory(addr_t(args[eGroupName]), buffer.get(), len, err);
  buffer.get()[len] = '\0';
  if (!err.Success()) {
    if (log)
      log->Printf("Error reading scriptgroup name from target");
    return;
  } else {
    if (log)
      log->Printf("Extracted scriptgroup name %s", buffer.get());
  }
  // write back the script group name
  group_name.SetCString(buffer.get());
}

// create or access existing script group
RSScriptGroupDescriptorSP group;
{
  // search for existing script group
  for (auto sg : m_scriptGroups) {
    if (sg->m_name == group_name) {
      group = sg;
      break;
    }
  }
  if (!group) {
    group.reset(new RSScriptGroupDescriptor);
    group->m_name = group_name;
    m_scriptGroups.push_back(group);
  } else {
    // already have this script group
    if (log)
      log->Printf("Attempt to add duplicate script group %s",
                  group_name.AsCString());
    return;
  }
}
assert(group)(static_cast <bool> (group) ? void (0) : __assert_fail (
"group", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 1231, __extension__ __PRETTY_FUNCTION__));

const uint32_t target_ptr_size = m_process->GetAddressByteSize();
std::vector<addr_t> kernels;
// parse kernel addresses in script group
for (uint64_t i = 0; i < uint64_t(args[eKernelCount]); ++i) {
  RSScriptGroupDescriptor::Kernel kernel;
  // extract script group kernel addresses from the target
  const addr_t ptr_addr = addr_t(args[eKernel]) + i * target_ptr_size;
  uint64_t kernel_addr = 0;
  Status err;
  size_t read =
      m_process->ReadMemory(ptr_addr, &kernel_addr, target_ptr_size, err);
  if (!err.Success() || read != target_ptr_size) {
    if (log)
      log->Printf("Error parsing kernel address %" PRIu64"l" "u" " in script group",
                  i);
    return;
  }
  if (log)
    log->Printf("Extracted scriptgroup kernel address - 0x%" PRIx64"l" "x",
                kernel_addr);
  kernel.m_addr = kernel_addr;

  // try to resolve the associated kernel name
  if (!ResolveKernelName(kernel.m_addr, kernel.m_name)) {
    if (log)
      log->Printf("Parsed scriptgroup kernel %" PRIu64"l" "u" " - 0x%" PRIx64"l" "x", i,
                  kernel_addr);
    return;
  }

  // try to find the non '.expand' function
  {
    const llvm::StringRef expand(".expand");
    const llvm::StringRef name_ref = kernel.m_name.GetStringRef();
    if (name_ref.endswith(expand)) {
      const ConstString base_kernel(name_ref.drop_back(expand.size()));
      // verify this function is a valid kernel
      if (IsKnownKernel(base_kernel)) {
        kernel.m_name = base_kernel;
        if (log)
          log->Printf("%s - found non expand version '%s'", __FUNCTION__,
                      base_kernel.GetCString());
      }
    }
  }
  // add to a list of script group kernels we know about
  group->m_kernels.push_back(kernel);
}

// Resolve any pending scriptgroup breakpoints
{
  Target &target = m_process->GetTarget();
  const BreakpointList &list = target.GetBreakpointList();
  const size_t num_breakpoints = list.GetSize();
  if (log)
    log->Printf("Resolving %zu breakpoints", num_breakpoints);
  for (size_t i = 0; i < num_breakpoints; ++i) {
    const BreakpointSP bp = list.GetBreakpointAtIndex(i);
    if (bp) {
      if (bp->MatchesName(group_name.AsCString())) {
        if (log)
          log->Printf("Found breakpoint with name %s",
                      group_name.AsCString());
        bp->ResolveBreakpoint();
      }
    }
  }
}
1301}

1303void RenderScriptRuntime::CaptureScriptInvokeForEachMulti(
  RuntimeHook *hook, ExecutionContext &exe_ctx) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

enum {
  eRsContext = 0,
  eRsScript,
  eRsSlot,
  eRsAIns,
  eRsInLen,
  eRsAOut,
  eRsUsr,
  eRsUsrLen,
  eRsSc,
};

std::array<ArgItem, 9> args{{
    ArgItem{ArgItem::ePointer, 0}, // const Context       *rsc
    ArgItem{ArgItem::ePointer, 0}, // Script              *s
    ArgItem{ArgItem::eInt32, 0},   // uint32_t             slot
    ArgItem{ArgItem::ePointer, 0}, // const Allocation   **aIns
    ArgItem{ArgItem::eInt32, 0},   // size_t               inLen
    ArgItem{ArgItem::ePointer, 0}, // Allocation          *aout
    ArgItem{ArgItem::ePointer, 0}, // const void          *usr
    ArgItem{ArgItem::eInt32, 0},   // size_t               usrLen
    ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall  *sc
}};

bool success = GetArgs(exe_ctx, &args[0], args.size());
if (!success) {
  if (log)
    log->Printf("%s - Error while reading the function parameters",
                __FUNCTION__);
  return;
}

const uint32_t target_ptr_size = m_process->GetAddressByteSize();
Status err;
std::vector<uint64_t> allocs;

// traverse allocation list
for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i) {
  // calculate offest to allocation pointer
  const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size;

  // Note: due to little endian layout, reading 32bits or 64bits into res
  // will give the correct results.
  uint64_t result = 0;
  size_t read = m_process->ReadMemory(addr, &result, target_ptr_size, err);
  if (read != target_ptr_size || !err.Success()) {
    if (log)
      log->Printf(
          "%s - Error while reading allocation list argument %" PRIu64"l" "u",
          __FUNCTION__, i);
  } else {
    allocs.push_back(result);
  }
}

// if there is an output allocation track it
if (uint64_t alloc_out = uint64_t(args[eRsAOut])) {
  allocs.push_back(alloc_out);
}

// for all allocations we have found
for (const uint64_t alloc_addr : allocs) {
  AllocationDetails *alloc = LookUpAllocation(alloc_addr);
  if (!alloc)
    alloc = CreateAllocation(alloc_addr);

  if (alloc) {
    // save the allocation address
    if (alloc->address.isValid()) {
      // check the allocation address we already have matches
      assert(*alloc->address.get() == alloc_addr)(static_cast <bool> (*alloc->address.get() == alloc_addr
) ? void (0) : __assert_fail ("*alloc->address.get() == alloc_addr"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 1377, __extension__ __PRETTY_FUNCTION__));
    } else {
      alloc->address = alloc_addr;
    }

    // save the context
    if (log) {
      if (alloc->context.isValid() &&
          *alloc->context.get() != addr_t(args[eRsContext]))
        log->Printf("%s - Allocation used by multiple contexts",
                    __FUNCTION__);
    }
    alloc->context = addr_t(args[eRsContext]);
  }
}

// make sure we track this script object
if (lldb_private::RenderScriptRuntime::ScriptDetails *script =
        LookUpScript(addr_t(args[eRsScript]), true)) {
  if (log) {
    if (script->context.isValid() &&
        *script->context.get() != addr_t(args[eRsContext]))
      log->Printf("%s - Script used by multiple contexts", __FUNCTION__);
  }
  script->context = addr_t(args[eRsContext]);
}
1403}

1405void RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook,
                                            ExecutionContext &context) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

enum {
  eRsContext,
  eRsScript,
  eRsId,
  eRsData,
  eRsLength,
};

std::array<ArgItem, 5> args{{
    ArgItem{ArgItem::ePointer, 0}, // eRsContext
    ArgItem{ArgItem::ePointer, 0}, // eRsScript
    ArgItem{ArgItem::eInt32, 0},   // eRsId
    ArgItem{ArgItem::ePointer, 0}, // eRsData
    ArgItem{ArgItem::eInt32, 0},   // eRsLength
}};

bool success = GetArgs(context, &args[0], args.size());
if (!success) {
  if (log)
    log->Printf("%s - error reading the function parameters.", __FUNCTION__);
  return;
}

if (log) {
  log->Printf("%s - 0x%" PRIx64"l" "x" ",0x%" PRIx64"l" "x" " slot %" PRIu64"l" "u" " = 0x%" PRIx64"l" "x"
              ":%" PRIu64"l" "u" "bytes.",
              __FUNCTION__, uint64_t(args[eRsContext]),
              uint64_t(args[eRsScript]), uint64_t(args[eRsId]),
              uint64_t(args[eRsData]), uint64_t(args[eRsLength]));

  addr_t script_addr = addr_t(args[eRsScript]);
  if (m_scriptMappings.find(script_addr) != m_scriptMappings.end()) {
    auto rsm = m_scriptMappings[script_addr];
    if (uint64_t(args[eRsId]) < rsm->m_globals.size()) {
      auto rsg = rsm->m_globals[uint64_t(args[eRsId])];
      log->Printf("%s - Setting of '%s' within '%s' inferred", __FUNCTION__,
                  rsg.m_name.AsCString(),
                  rsm->m_module->GetFileSpec().GetFilename().AsCString());
    }
  }
}
1450}

1452void RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook,
                                              ExecutionContext &exe_ctx) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

enum { eRsContext, eRsAlloc, eRsForceZero };

std::array<ArgItem, 3> args{{
    ArgItem{ArgItem::ePointer, 0}, // eRsContext
    ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
    ArgItem{ArgItem::eBool, 0},    // eRsForceZero
}};

bool success = GetArgs(exe_ctx, &args[0], args.size());
if (!success) {
  if (log)
    log->Printf("%s - error while reading the function parameters",
                __FUNCTION__);
  return;
}

if (log)
  log->Printf("%s - 0x%" PRIx64"l" "x" ",0x%" PRIx64"l" "x" ",0x%" PRIx64"l" "x" " .",
              __FUNCTION__, uint64_t(args[eRsContext]),
              uint64_t(args[eRsAlloc]), uint64_t(args[eRsForceZero]));

AllocationDetails *alloc = CreateAllocation(uint64_t(args[eRsAlloc]));
if (alloc)
  alloc->context = uint64_t(args[eRsContext]);
1480}

1482void RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook,
                                                 ExecutionContext &exe_ctx) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

enum {
  eRsContext,
  eRsAlloc,
};

std::array<ArgItem, 2> args{{
    ArgItem{ArgItem::ePointer, 0}, // eRsContext
    ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
}};

bool success = GetArgs(exe_ctx, &args[0], args.size());
if (!success) {
  if (log)
    log->Printf("%s - error while reading the function parameters.",
                __FUNCTION__);
  return;
}

if (log)
  log->Printf("%s - 0x%" PRIx64"l" "x" ", 0x%" PRIx64"l" "x" ".", __FUNCTION__,
              uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc]));

for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter) {
  auto &allocation_ap = *iter; // get the unique pointer
  if (allocation_ap->address.isValid() &&
      *allocation_ap->address.get() == addr_t(args[eRsAlloc])) {
    m_allocations.erase(iter);
    if (log)
      log->Printf("%s - deleted allocation entry.", __FUNCTION__);
    return;
  }
}

if (log)
  log->Printf("%s - couldn't find destroyed allocation.", __FUNCTION__);
1521}

1523void RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook,
                                          ExecutionContext &exe_ctx) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

Status err;
Process *process = exe_ctx.GetProcessPtr();

enum { eRsContext, eRsScript, eRsResNamePtr, eRsCachedDirPtr };

std::array<ArgItem, 4> args{
    {ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0},
     ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}};
bool success = GetArgs(exe_ctx, &args[0], args.size());
if (!success) {
  if (log)
    log->Printf("%s - error while reading the function parameters.",
                __FUNCTION__);
  return;
}

std::string res_name;
process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), res_name, err);
if (err.Fail()) {
  if (log)
    log->Printf("%s - error reading res_name: %s.", __FUNCTION__,
                err.AsCString());
}

std::string cache_dir;
process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cache_dir, err);
if (err.Fail()) {
  if (log)
    log->Printf("%s - error reading cache_dir: %s.", __FUNCTION__,
                err.AsCString());
}

if (log)
  log->Printf("%s - 0x%" PRIx64"l" "x" ",0x%" PRIx64"l" "x" " => '%s' at '%s' .",
              __FUNCTION__, uint64_t(args[eRsContext]),
              uint64_t(args[eRsScript]), res_name.c_str(), cache_dir.c_str());

if (res_name.size() > 0) {
  StreamString strm;
  strm.Printf("librs.%s.so", res_name.c_str());

  ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true);
  if (script) {
    script->type = ScriptDetails::eScriptC;
    script->cache_dir = cache_dir;
    script->res_name = res_name;
    script->shared_lib = strm.GetString();
    script->context = addr_t(args[eRsContext]);
  }

  if (log)
    log->Printf("%s - '%s' tagged with context 0x%" PRIx64"l" "x"
                " and script 0x%" PRIx64"l" "x" ".",
                __FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]),
                uint64_t(args[eRsScript]));
} else if (log) {
  log->Printf("%s - resource name invalid, Script not tagged.", __FUNCTION__);
}
1585}

1587void RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module,
                                         ModuleKind kind) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!module) {
  return;
}

Target &target = GetProcess()->GetTarget();
const llvm::Triple::ArchType machine = target.GetArchitecture().GetMachine();

if (machine != llvm::Triple::ArchType::x86 &&
    machine != llvm::Triple::ArchType::arm &&
    machine != llvm::Triple::ArchType::aarch64 &&
    machine != llvm::Triple::ArchType::mipsel &&
    machine != llvm::Triple::ArchType::mips64el &&
    machine != llvm::Triple::ArchType::x86_64) {
  if (log)
    log->Printf("%s - unable to hook runtime functions.", __FUNCTION__);
  return;
}

const uint32_t target_ptr_size =
    target.GetArchitecture().GetAddressByteSize();

std::array<bool, s_runtimeHookCount> hook_placed;
hook_placed.fill(false);

for (size_t idx = 0; idx < s_runtimeHookCount; idx++) {
  const HookDefn *hook_defn = &s_runtimeHookDefns[idx];
  if (hook_defn->kind != kind) {
    continue;
  }

  const char *symbol_name = (target_ptr_size == 4)
                                ? hook_defn->symbol_name_m32
                                : hook_defn->symbol_name_m64;

  const Symbol *sym = module->FindFirstSymbolWithNameAndType(
      ConstString(symbol_name), eSymbolTypeCode);
  if (!sym) {
    if (log) {
      log->Printf("%s - symbol '%s' related to the function %s not found",
                  __FUNCTION__, symbol_name, hook_defn->name);
    }
    continue;
  }

  addr_t addr = sym->GetLoadAddress(&target);
  if (addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
    if (log)
      log->Printf("%s - unable to resolve the address of hook function '%s' "
                  "with symbol '%s'.",
                  __FUNCTION__, hook_defn->name, symbol_name);
    continue;
  } else {
    if (log)
      log->Printf("%s - function %s, address resolved at 0x%" PRIx64"l" "x",
                  __FUNCTION__, hook_defn->name, addr);
  }

  RuntimeHookSP hook(new RuntimeHook());
  hook->address = addr;
  hook->defn = hook_defn;
  hook->bp_sp = target.CreateBreakpoint(addr, true, false);
  hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
  m_runtimeHooks[addr] = hook;
  if (log) {
    log->Printf("%s - successfully hooked '%s' in '%s' version %" PRIu64"l" "u"
                " at 0x%" PRIx64"l" "x" ".",
                __FUNCTION__, hook_defn->name,
                module->GetFileSpec().GetFilename().AsCString(),
                (uint64_t)hook_defn->version, (uint64_t)addr);
  }
  hook_placed[idx] = true;
}

// log any unhooked function
if (log) {
  for (size_t i = 0; i < hook_placed.size(); ++i) {
    if (hook_placed[i])
      continue;
    const HookDefn &hook_defn = s_runtimeHookDefns[i];
    if (hook_defn.kind != kind)
      continue;
    log->Printf("%s - function %s was not hooked", __FUNCTION__,
                hook_defn.name);
  }
}
1676}

1678void RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp) {
if (!rsmodule_sp)
1
Taking false branch→
  return;

Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

const ModuleSP module = rsmodule_sp->m_module;
const FileSpec &file = module->GetPlatformFileSpec();

// Iterate over all of the scripts that we currently know of.
// Note: We cant push or pop to m_scripts here or it may invalidate rs_script.
for (const auto &rs_script : m_scripts) {
  // Extract the expected .so file path for this script.
  std::string shared_lib;
  if (!rs_script->shared_lib.get(shared_lib))
2
←
Taking true branch→
4
←
Taking true branch→
6
←
Taking false branch→
34
←
Taking false branch→
    continue;
3
←
 Execution continues on line 1689→
5
←
 Execution continues on line 1689→

  // Only proceed if the module that has loaded corresponds to this script.
  if (file.GetFilename() != ConstString(shared_lib.c_str()))
7
←
Taking false branch→
35
←
Taking false branch→
    continue;

  // Obtain the script address which we use as a key.
  lldb::addr_t script;
  if (!rs_script->script.get(script))
8
←
Taking false branch→
36
←
Taking false branch→
    continue;

  // If we have a script mapping for the current script.
  if (m_scriptMappings.find(script) != m_scriptMappings.end()) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
37
←
Assuming the condition is false→
38
←
Taking false branch→
    // if the module we have stored is different to the one we just received.
    if (m_scriptMappings[script] != rsmodule_sp) {
      if (log)
        log->Printf(
            "%s - script %" PRIx64"l" "x" " wants reassigned to new rsmodule '%s'.",
            __FUNCTION__, (uint64_t)script,
            rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
    }
  }
  // We don't have a script mapping for the current script.
  else {
    // Obtain the script resource name.
    std::string res_name;
    if (rs_script->res_name.get(res_name))
11
←
Taking false branch→
39
←
Taking false branch→
      // Set the modules resource name.
      rsmodule_sp->m_resname = res_name;
    // Add Script/Module pair to map.
    m_scriptMappings[script] = rsmodule_sp;
12
←
Calling defaulted copy assignment operator for 'shared_ptr'→
31
←
Returning; memory was released→
40
←
Calling defaulted copy assignment operator for 'shared_ptr'→
    if (log)
32
←
Assuming 'log' is null→
33
←
Taking false branch→
      log->Printf(
          "%s - script %" PRIx64"l" "x" " associated with rsmodule '%s'.",
          __FUNCTION__, (uint64_t)script,
          rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
  }
}
1731}

1733// Uses the Target API to evaluate the expression passed as a parameter to the
1734// function The result of that expression is returned an unsigned 64 bit int,
1735// via the result* parameter. Function returns true on success, and false on
1736// failure
1737bool RenderScriptRuntime::EvalRSExpression(const char *expr,
                                         StackFrame *frame_ptr,
                                         uint64_t *result) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));
if (log)
  log->Printf("%s(%s)", __FUNCTION__, expr);

ValueObjectSP expr_result;
EvaluateExpressionOptions options;
options.SetLanguage(lldb::eLanguageTypeC_plus_plus);
// Perform the actual expression evaluation
auto &target = GetProcess()->GetTarget();
target.EvaluateExpression(expr, frame_ptr, expr_result, options);

if (!expr_result) {
  if (log)
    log->Printf("%s: couldn't evaluate expression.", __FUNCTION__);
  return false;
}

// The result of the expression is invalid
if (!expr_result->GetError().Success()) {
  Status err = expr_result->GetError();
  // Expression returned is void, so this is actually a success
  if (err.GetError() == UserExpression::kNoResult) {
    if (log)
      log->Printf("%s - expression returned void.", __FUNCTION__);

    result = nullptr;
    return true;
  }

  if (log)
    log->Printf("%s - error evaluating expression result: %s", __FUNCTION__,
                err.AsCString());
  return false;
}

bool success = false;
// We only read the result as an uint32_t.
*result = expr_result->GetValueAsUnsigned(0, &success);

if (!success) {
  if (log)
    log->Printf("%s - couldn't convert expression result to uint32_t",
                __FUNCTION__);
  return false;
}

return true;
1787}

1789namespace {
1790// Used to index expression format strings
1791enum ExpressionStrings {
eExprGetOffsetPtr = 0,
eExprAllocGetType,
eExprTypeDimX,
eExprTypeDimY,
eExprTypeDimZ,
eExprTypeElemPtr,
eExprElementType,
eExprElementKind,
eExprElementVec,
eExprElementFieldCount,
eExprSubelementsId,
eExprSubelementsName,
eExprSubelementsArrSize,

_eExprLast // keep at the end, implicit size of the array runtime_expressions
1807};

1809// max length of an expanded expression
1810const int jit_max_expr_size = 512;

1812// Retrieve the string to JIT for the given expression
1813#define JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); " "void* ctxt = (void*)rsDebugGetContextWrapper(0x%" PRIx64"l" "x" "); "
1814const char *JITTemplate(ExpressionStrings e) {
// Format strings containing the expressions we may need to evaluate.
static std::array<const char *, _eExprLast> runtime_expressions = {
    {// Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap)
     "(int*)_"
     "Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocation"
     "CubemapFace"
     "(0x%" PRIx64"l" "x" ", %" PRIu32"u" ", %" PRIu32"u" ", %" PRIu32"u" ", 0, 0)", // eExprGetOffsetPtr

     // Type* rsaAllocationGetType(Context*, Allocation*)
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); " "(void*)rsaAllocationGetType(ctxt, 0x%" PRIx64"l" "x" ")", // eExprAllocGetType

     // rsaTypeGetNativeData(Context*, Type*, void* typeData, size) Pack the
     // data in the following way mHal.state.dimX; mHal.state.dimY;
     // mHal.state.dimZ; mHal.state.lodCount; mHal.state.faces; mElement; into
     // typeData Need to specify 32 or 64 bit for uint_t since this differs
     // between devices
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint%" PRIu32"u" "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 6); data[0]", // eExprTypeDimX
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint%" PRIu32"u" "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 6); data[1]", // eExprTypeDimY
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint%" PRIu32"u" "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 6); data[2]", // eExprTypeDimZ
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint%" PRIu32"u" "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 6); data[5]", // eExprTypeElemPtr

     // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
     // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into
     // elemData
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 5); data[0]", // eExprElementType
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 5); data[1]", // eExprElementKind
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 5); data[3]", // eExprElementVec
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); "
     "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
     ", 0x%" PRIx64"l" "x" ", data, 5); data[4]", // eExprElementFieldCount

     // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t
     // *ids, const char **names, size_t *arraySizes, uint32_t dataSize)
     // Needed for Allocations of structs to gather details about
     // fields/Subelements Element* of field
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); " "void* ids[%" PRIu32"u" "]; const char* names[%" PRIu32"u"
     "]; size_t arr_size[%" PRIu32"u" "];"
     "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64"l" "x"
     ", ids, names, arr_size, %" PRIu32"u" "); ids[%" PRIu32"u" "]", // eExprSubelementsId

     // Name of field
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); " "void* ids[%" PRIu32"u" "]; const char* names[%" PRIu32"u"
     "]; size_t arr_size[%" PRIu32"u" "];"
     "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64"l" "x"
     ", ids, names, arr_size, %" PRIu32"u" "); names[%" PRIu32"u" "]", // eExprSubelementsName

     // Array size of field
     JIT_TEMPLATE_CONTEXT"void* ctxt = (void*)rsDebugGetContextWrapper(0x%" "l" "x" "); " "void* ids[%" PRIu32"u" "]; const char* names[%" PRIu32"u"
     "]; size_t arr_size[%" PRIu32"u" "];"
     "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64"l" "x"
     ", ids, names, arr_size, %" PRIu32"u" "); arr_size[%" PRIu32"u" "]"}}; // eExprSubelementsArrSize

return runtime_expressions[e];
1882}
1883} // end of the anonymous namespace

1885// JITs the RS runtime for the internal data pointer of an allocation. Is passed
1886// x,y,z coordinates for the pointer to a specific element. Then sets the
1887// data_ptr member in Allocation with the result. Returns true on success, false
1888// otherwise
1889bool RenderScriptRuntime::JITDataPointer(AllocationDetails *alloc,
                                       StackFrame *frame_ptr, uint32_t x,
                                       uint32_t y, uint32_t z) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!alloc->address.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
char expr_buf[jit_max_expr_size];

int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
                       *alloc->address.get(), x, y, z);
if (written < 0) {
  if (log)
    log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
  return false;
} else if (written >= jit_max_expr_size) {
  if (log)
    log->Printf("%s - expression too long.", __FUNCTION__);
  return false;
}

uint64_t result = 0;
if (!EvalRSExpression(expr_buf, frame_ptr, &result))
  return false;

addr_t data_ptr = static_cast<lldb::addr_t>(result);
alloc->data_ptr = data_ptr;

return true;
1923}

1925// JITs the RS runtime for the internal pointer to the RS Type of an allocation
1926// Then sets the type_ptr member in Allocation with the result. Returns true on
1927// success, false otherwise
1928bool RenderScriptRuntime::JITTypePointer(AllocationDetails *alloc,
                                       StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!alloc->address.isValid() || !alloc->context.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

const char *fmt_str = JITTemplate(eExprAllocGetType);
char expr_buf[jit_max_expr_size];

int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
                       *alloc->context.get(), *alloc->address.get());
if (written < 0) {
  if (log)
    log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
  return false;
} else if (written >= jit_max_expr_size) {
  if (log)
    log->Printf("%s - expression too long.", __FUNCTION__);
  return false;
}

uint64_t result = 0;
if (!EvalRSExpression(expr_buf, frame_ptr, &result))
  return false;

addr_t type_ptr = static_cast<lldb::addr_t>(result);
alloc->type_ptr = type_ptr;

return true;
1961}

1963// JITs the RS runtime for information about the dimensions and type of an
1964// allocation Then sets dimension and element_ptr members in Allocation with the
1965// result. Returns true on success, false otherwise
1966bool RenderScriptRuntime::JITTypePacked(AllocationDetails *alloc,
                                      StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!alloc->type_ptr.isValid() || !alloc->context.isValid()) {
  if (log)
    log->Printf("%s - Failed to find allocation details.", __FUNCTION__);
  return false;
}

// Expression is different depending on if device is 32 or 64 bit
uint32_t target_ptr_size =
    GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
const uint32_t bits = target_ptr_size == 4 ? 32 : 64;

// We want 4 elements from packed data
const uint32_t num_exprs = 4;
assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) &&(static_cast <bool> (num_exprs == (eExprTypeElemPtr - eExprTypeDimX
 + 1) && "Invalid number of expressions") ? void (0) :
 __assert_fail ("num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 1984, __extension__ __PRETTY_FUNCTION__))
       "Invalid number of expressions")(static_cast <bool> (num_exprs == (eExprTypeElemPtr - eExprTypeDimX
 + 1) && "Invalid number of expressions") ? void (0) :
 __assert_fail ("num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 1984, __extension__ __PRETTY_FUNCTION__));

char expr_bufs[num_exprs][jit_max_expr_size];
uint64_t results[num_exprs];

for (uint32_t i = 0; i < num_exprs; ++i) {
  const char *fmt_str = JITTemplate(ExpressionStrings(eExprTypeDimX + i));
  int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str,
                         *alloc->context.get(), bits, *alloc->type_ptr.get());
  if (written < 0) {
    if (log)
      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
    return false;
  } else if (written >= jit_max_expr_size) {
    if (log)
      log->Printf("%s - expression too long.", __FUNCTION__);
    return false;
  }

  // Perform expression evaluation
  if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i]))
    return false;
}

// Assign results to allocation members
AllocationDetails::Dimension dims;
dims.dim_1 = static_cast<uint32_t>(results[0]);
dims.dim_2 = static_cast<uint32_t>(results[1]);
dims.dim_3 = static_cast<uint32_t>(results[2]);
alloc->dimension = dims;

addr_t element_ptr = static_cast<lldb::addr_t>(results[3]);
alloc->element.element_ptr = element_ptr;

if (log)
  log->Printf("%s - dims (%" PRIu32"u" ", %" PRIu32"u" ", %" PRIu32"u"
              ") Element*: 0x%" PRIx64"l" "x" ".",
              __FUNCTION__, dims.dim_1, dims.dim_2, dims.dim_3, element_ptr);

return true;
2024}

2026// JITs the RS runtime for information about the Element of an allocation Then
2027// sets type, type_vec_size, field_count and type_kind members in Element with
2028// the result. Returns true on success, false otherwise
2029bool RenderScriptRuntime::JITElementPacked(Element &elem,
                                         const lldb::addr_t context,
                                         StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!elem.element_ptr.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

// We want 4 elements from packed data
const uint32_t num_exprs = 4;
assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1) &&(static_cast <bool> (num_exprs == (eExprElementFieldCount
 - eExprElementType + 1) && "Invalid number of expressions"
) ? void (0) : __assert_fail ("num_exprs == (eExprElementFieldCount - eExprElementType + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2043, __extension__ __PRETTY_FUNCTION__))
       "Invalid number of expressions")(static_cast <bool> (num_exprs == (eExprElementFieldCount
 - eExprElementType + 1) && "Invalid number of expressions"
) ? void (0) : __assert_fail ("num_exprs == (eExprElementFieldCount - eExprElementType + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2043, __extension__ __PRETTY_FUNCTION__));

char expr_bufs[num_exprs][jit_max_expr_size];
uint64_t results[num_exprs];

for (uint32_t i = 0; i < num_exprs; i++) {
  const char *fmt_str = JITTemplate(ExpressionStrings(eExprElementType + i));
  int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, context,
                         *elem.element_ptr.get());
  if (written < 0) {
    if (log)
      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
    return false;
  } else if (written >= jit_max_expr_size) {
    if (log)
      log->Printf("%s - expression too long.", __FUNCTION__);
    return false;
  }

  // Perform expression evaluation
  if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i]))
    return false;
}

// Assign results to allocation members
elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]);
elem.type_kind =
    static_cast<RenderScriptRuntime::Element::DataKind>(results[1]);
elem.type_vec_size = static_cast<uint32_t>(results[2]);
elem.field_count = static_cast<uint32_t>(results[3]);

if (log)
  log->Printf("%s - data type %" PRIu32"u" ", pixel type %" PRIu32"u"
              ", vector size %" PRIu32"u" ", field count %" PRIu32"u",
              __FUNCTION__, *elem.type.get(), *elem.type_kind.get(),
              *elem.type_vec_size.get(), *elem.field_count.get());

// If this Element has subelements then JIT rsaElementGetSubElements() for
// details about its fields
if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr))
  return false;

return true;
2086}

2088// JITs the RS runtime for information about the subelements/fields of a struct
2089// allocation This is necessary for infering the struct type so we can pretty
2090// print the allocation's contents. Returns true on success, false otherwise
2091bool RenderScriptRuntime::JITSubelements(Element &elem,
                                       const lldb::addr_t context,
                                       StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!elem.element_ptr.isValid() || !elem.field_count.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

const short num_exprs = 3;
assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) &&(static_cast <bool> (num_exprs == (eExprSubelementsArrSize
 - eExprSubelementsId + 1) && "Invalid number of expressions"
) ? void (0) : __assert_fail ("num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2104, __extension__ __PRETTY_FUNCTION__))
       "Invalid number of expressions")(static_cast <bool> (num_exprs == (eExprSubelementsArrSize
 - eExprSubelementsId + 1) && "Invalid number of expressions"
) ? void (0) : __assert_fail ("num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) && \"Invalid number of expressions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2104, __extension__ __PRETTY_FUNCTION__));

char expr_buffer[jit_max_expr_size];
uint64_t results;

// Iterate over struct fields.
const uint32_t field_count = *elem.field_count.get();
for (uint32_t field_index = 0; field_index < field_count; ++field_index) {
  Element child;
  for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index) {
    const char *fmt_str =
        JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index));
    int written = snprintf(expr_buffer, jit_max_expr_size, fmt_str,
                           context, field_count, field_count, field_count,
                           *elem.element_ptr.get(), field_count, field_index);
    if (written < 0) {
      if (log)
        log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
      return false;
    } else if (written >= jit_max_expr_size) {
      if (log)
        log->Printf("%s - expression too long.", __FUNCTION__);
      return false;
    }

    // Perform expression evaluation
    if (!EvalRSExpression(expr_buffer, frame_ptr, &results))
      return false;

    if (log)
      log->Printf("%s - expr result 0x%" PRIx64"l" "x" ".", __FUNCTION__, results);

    switch (expr_index) {
    case 0: // Element* of child
      child.element_ptr = static_cast<addr_t>(results);
      break;
    case 1: // Name of child
    {
      lldb::addr_t address = static_cast<addr_t>(results);
      Status err;
      std::string name;
      GetProcess()->ReadCStringFromMemory(address, name, err);
      if (!err.Fail())
        child.type_name = ConstString(name);
      else {
        if (log)
          log->Printf("%s - warning: Couldn't read field name.",
                      __FUNCTION__);
      }
      break;
    }
    case 2: // Array size of child
      child.array_size = static_cast<uint32_t>(results);
      break;
    }
  }

  // We need to recursively JIT each Element field of the struct since
  // structs can be nested inside structs.
  if (!JITElementPacked(child, context, frame_ptr))
    return false;
  elem.children.push_back(child);
}

// Try to infer the name of the struct type so we can pretty print the
// allocation contents.
FindStructTypeName(elem, frame_ptr);

return true;
2173}

2175// JITs the RS runtime for the address of the last element in the allocation.
2176// The `elem_size` parameter represents the size of a single element, including
2177// padding. Which is needed as an offset from the last element pointer. Using
2178// this offset minus the starting address we can calculate the size of the
2179// allocation. Returns true on success, false otherwise
2180bool RenderScriptRuntime::JITAllocationSize(AllocationDetails *alloc,
                                          StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!alloc->address.isValid() || !alloc->dimension.isValid() ||
    !alloc->data_ptr.isValid() || !alloc->element.datum_size.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

// Find dimensions
uint32_t dim_x = alloc->dimension.get()->dim_1;
uint32_t dim_y = alloc->dimension.get()->dim_2;
uint32_t dim_z = alloc->dimension.get()->dim_3;

// Our plan of jitting the last element address doesn't seem to work for
// struct Allocations` Instead try to infer the size ourselves without any
// inter element padding.
if (alloc->element.children.size() > 0) {
  if (dim_x == 0)
    dim_x = 1;
  if (dim_y == 0)
    dim_y = 1;
  if (dim_z == 0)
    dim_z = 1;

  alloc->size = dim_x * dim_y * dim_z * *alloc->element.datum_size.get();

  if (log)
    log->Printf("%s - inferred size of struct allocation %" PRIu32"u" ".",
                __FUNCTION__, *alloc->size.get());
  return true;
}

const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
char expr_buf[jit_max_expr_size];

// Calculate last element
dim_x = dim_x == 0 ? 0 : dim_x - 1;
dim_y = dim_y == 0 ? 0 : dim_y - 1;
dim_z = dim_z == 0 ? 0 : dim_z - 1;

int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
                       *alloc->address.get(), dim_x, dim_y, dim_z);
if (written < 0) {
  if (log)
    log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
  return false;
} else if (written >= jit_max_expr_size) {
  if (log)
    log->Printf("%s - expression too long.", __FUNCTION__);
  return false;
}

uint64_t result = 0;
if (!EvalRSExpression(expr_buf, frame_ptr, &result))
  return false;

addr_t mem_ptr = static_cast<lldb::addr_t>(result);
// Find pointer to last element and add on size of an element
alloc->size = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()) +
              *alloc->element.datum_size.get();

return true;
2245}

2247// JITs the RS runtime for information about the stride between rows in the
2248// allocation. This is done to detect padding, since allocated memory is 16-byte
2249// aligned.
2250// Returns true on success, false otherwise
2251bool RenderScriptRuntime::JITAllocationStride(AllocationDetails *alloc,
                                            StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!alloc->address.isValid() || !alloc->data_ptr.isValid()) {
  if (log)
    log->Printf("%s - failed to find allocation details.", __FUNCTION__);
  return false;
}

const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
char expr_buf[jit_max_expr_size];

int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
                       *alloc->address.get(), 0, 1, 0);
if (written < 0) {
  if (log)
    log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
  return false;
} else if (written >= jit_max_expr_size) {
  if (log)
    log->Printf("%s - expression too long.", __FUNCTION__);
  return false;
}

uint64_t result = 0;
if (!EvalRSExpression(expr_buf, frame_ptr, &result))
  return false;

addr_t mem_ptr = static_cast<lldb::addr_t>(result);
alloc->stride = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get());

return true;
2284}

2286// JIT all the current runtime info regarding an allocation
2287bool RenderScriptRuntime::RefreshAllocation(AllocationDetails *alloc,
                                          StackFrame *frame_ptr) {
// GetOffsetPointer()
if (!JITDataPointer(alloc, frame_ptr))
  return false;

// rsaAllocationGetType()
if (!JITTypePointer(alloc, frame_ptr))
  return false;

// rsaTypeGetNativeData()
if (!JITTypePacked(alloc, frame_ptr))
  return false;

// rsaElementGetNativeData()
if (!JITElementPacked(alloc->element, *alloc->context.get(), frame_ptr))
  return false;

// Sets the datum_size member in Element
SetElementSize(alloc->element);

// Use GetOffsetPointer() to infer size of the allocation
if (!JITAllocationSize(alloc, frame_ptr))
  return false;

return true;
2313}

2315// Function attempts to set the type_name member of the paramaterised Element
2316// object.
2317// This string should be the name of the struct type the Element represents.
2318// We need this string for pretty printing the Element to users.
2319void RenderScriptRuntime::FindStructTypeName(Element &elem,
                                           StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!elem.type_name.IsEmpty()) // Name already set
  return;
else
  elem.type_name = Element::GetFallbackStructName(); // Default type name if
                                                     // we don't succeed

// Find all the global variables from the script rs modules
VariableList var_list;
for (auto module_sp : m_rsmodules)
  module_sp->m_module->FindGlobalVariables(
      RegularExpression(llvm::StringRef(".")), true, UINT32_MAX(4294967295U), var_list);

// Iterate over all the global variables looking for one with a matching type
// to the Element.
// We make the assumption a match exists since there needs to be a global
// variable to reflect the struct type back into java host code.
for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
  const VariableSP var_sp(var_list.GetVariableAtIndex(i));
  if (!var_sp)
    continue;

  ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp);
  if (!valobj_sp)
    continue;

  // Find the number of variable fields.
  // If it has no fields, or more fields than our Element, then it can't be
  // the struct we're looking for.
  // Don't check for equality since RS can add extra struct members for
  // padding.
  size_t num_children = valobj_sp->GetNumChildren();
  if (num_children > elem.children.size() || num_children == 0)
    continue;

  // Iterate over children looking for members with matching field names.
  // If all the field names match, this is likely the struct we want.
  //   TODO: This could be made more robust by also checking children data
  //   sizes, or array size
  bool found = true;
  for (size_t i = 0; i < num_children; ++i) {
    ValueObjectSP child = valobj_sp->GetChildAtIndex(i, true);
    if (!child || (child->GetName() != elem.children[i].type_name)) {
      found = false;
      break;
    }
  }

  // RS can add extra struct members for padding in the format
  // '#rs_padding_[0-9]+'
  if (found && num_children < elem.children.size()) {
    const uint32_t size_diff = elem.children.size() - num_children;
    if (log)
      log->Printf("%s - %" PRIu32"u" " padding struct entries", __FUNCTION__,
                  size_diff);

    for (uint32_t i = 0; i < size_diff; ++i) {
      const ConstString &name = elem.children[num_children + i].type_name;
      if (strcmp(name.AsCString(), "#rs_padding") < 0)
        found = false;
    }
  }

  // We've found a global variable with matching type
  if (found) {
    // Dereference since our Element type isn't a pointer.
    if (valobj_sp->IsPointerType()) {
      Status err;
      ValueObjectSP deref_valobj = valobj_sp->Dereference(err);
      if (!err.Fail())
        valobj_sp = deref_valobj;
    }

    // Save name of variable in Element.
    elem.type_name = valobj_sp->GetTypeName();
    if (log)
      log->Printf("%s - element name set to %s", __FUNCTION__,
                  elem.type_name.AsCString());

    return;
  }
}
2404}

2406// Function sets the datum_size member of Element. Representing the size of a
2407// single instance including padding.
2408// Assumes the relevant allocation information has already been jitted.
2409void RenderScriptRuntime::SetElementSize(Element &elem) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));
const Element::DataType type = *elem.type.get();
assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT &&(static_cast <bool> (type >= Element::RS_TYPE_NONE &&
 type <= Element::RS_TYPE_FONT && "Invalid allocation type"
) ? void (0) : __assert_fail ("type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && \"Invalid allocation type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2413, __extension__ __PRETTY_FUNCTION__))
       "Invalid allocation type")(static_cast <bool> (type >= Element::RS_TYPE_NONE &&
 type <= Element::RS_TYPE_FONT && "Invalid allocation type"
) ? void (0) : __assert_fail ("type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && \"Invalid allocation type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2413, __extension__ __PRETTY_FUNCTION__));

const uint32_t vec_size = *elem.type_vec_size.get();
uint32_t data_size = 0;
uint32_t padding = 0;

// Element is of a struct type, calculate size recursively.
if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0)) {
  for (Element &child : elem.children) {
    SetElementSize(child);
    const uint32_t array_size =
        child.array_size.isValid() ? *child.array_size.get() : 1;
    data_size += *child.datum_size.get() * array_size;
  }
}
// These have been packed already
else if (type == Element::RS_TYPE_UNSIGNED_5_6_5 ||
         type == Element::RS_TYPE_UNSIGNED_5_5_5_1 ||
         type == Element::RS_TYPE_UNSIGNED_4_4_4_4) {
  data_size = AllocationDetails::RSTypeToFormat[type][eElementSize];
} else if (type < Element::RS_TYPE_ELEMENT) {
  data_size =
      vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize];
  if (vec_size == 3)
    padding = AllocationDetails::RSTypeToFormat[type][eElementSize];
} else
  data_size =
      GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();

elem.padding = padding;
elem.datum_size = data_size + padding;
if (log)
  log->Printf("%s - element size set to %" PRIu32"u", __FUNCTION__,
              data_size + padding);
2447}

2449// Given an allocation, this function copies the allocation contents from device
2450// into a buffer on the heap.
2451// Returning a shared pointer to the buffer containing the data.
2452std::shared_ptr<uint8_t>
2453RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc,
                                     StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

// JIT all the allocation details
if (alloc->ShouldRefresh()) {
  if (log)
    log->Printf("%s - allocation details not calculated yet, jitting info",
                __FUNCTION__);

  if (!RefreshAllocation(alloc, frame_ptr)) {
    if (log)
      log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
    return nullptr;
  }
}

assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 "Allocation information not available") ? void (0) : __assert_fail
 ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2472, __extension__ __PRETTY_FUNCTION__))
       alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 "Allocation information not available") ? void (0) : __assert_fail
 ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2472, __extension__ __PRETTY_FUNCTION__))
       "Allocation information not available")(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 "Allocation information not available") ? void (0) : __assert_fail
 ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2472, __extension__ __PRETTY_FUNCTION__));

// Allocate a buffer to copy data into
const uint32_t size = *alloc->size.get();
std::shared_ptr<uint8_t> buffer(new uint8_t[size]);
if (!buffer) {
  if (log)
    log->Printf("%s - couldn't allocate a %" PRIu32"u" " byte buffer",
                __FUNCTION__, size);
  return nullptr;
}

// Read the inferior memory
Status err;
lldb::addr_t data_ptr = *alloc->data_ptr.get();
GetProcess()->ReadMemory(data_ptr, buffer.get(), size, err);
if (err.Fail()) {
  if (log)
    log->Printf("%s - '%s' Couldn't read %" PRIu32"u"
                " bytes of allocation data from 0x%" PRIx64"l" "x",
                __FUNCTION__, err.AsCString(), size, data_ptr);
  return nullptr;
}

return buffer;
2497}

2499// Function copies data from a binary file into an allocation.
2500// There is a header at the start of the file, FileHeader, before the data
2501// content itself.
2502// Information from this header is used to display warnings to the user about
2503// incompatibilities
2504bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
                                       const char *path,
                                       StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

// Find allocation with the given id
AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
if (!alloc)
  return false;

if (log)
  log->Printf("%s - found allocation 0x%" PRIx64"l" "x", __FUNCTION__,
              *alloc->address.get());

// JIT all the allocation details
if (alloc->ShouldRefresh()) {
  if (log)
    log->Printf("%s - allocation details not calculated yet, jitting info.",
                __FUNCTION__);

  if (!RefreshAllocation(alloc, frame_ptr)) {
    if (log)
      log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
    return false;
  }
}

assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 alloc->element.datum_size.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && alloc->element.datum_size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2534, __extension__ __PRETTY_FUNCTION__))
       alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 alloc->element.datum_size.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && alloc->element.datum_size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2534, __extension__ __PRETTY_FUNCTION__))
       alloc->element.datum_size.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 alloc->element.datum_size.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && alloc->element.datum_size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2534, __extension__ __PRETTY_FUNCTION__))
       "Allocation information not available")(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->size.isValid() &&
 alloc->element.datum_size.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->size.isValid() && alloc->element.datum_size.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2534, __extension__ __PRETTY_FUNCTION__));

// Check we can read from file
FileSpec file(path, true);
if (!file.Exists()) {
  strm.Printf("Error: File %s does not exist", path);
  strm.EOL();
  return false;
}

if (!file.Readable()) {
  strm.Printf("Error: File %s does not have readable permissions", path);
  strm.EOL();
  return false;
}

// Read file into data buffer
auto data_sp = DataBufferLLVM::CreateFromPath(file.GetPath());

// Cast start of buffer to FileHeader and use pointer to read metadata
void *file_buf = data_sp->GetBytes();
if (file_buf == nullptr ||
    data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) +
                              sizeof(AllocationDetails::ElementHeader))) {
  strm.Printf("Error: File %s does not contain enough data for header", path);
  strm.EOL();
  return false;
}
const AllocationDetails::FileHeader *file_header =
    static_cast<AllocationDetails::FileHeader *>(file_buf);

// Check file starts with ascii characters "RSAD"
if (memcmp(file_header->ident, "RSAD", 4)) {
  strm.Printf("Error: File doesn't contain identifier for an RS allocation "
              "dump. Are you sure this is the correct file?");
  strm.EOL();
  return false;
}

// Look at the type of the root element in the header
AllocationDetails::ElementHeader root_el_hdr;
memcpy(&root_el_hdr, static_cast<uint8_t *>(file_buf) +
                         sizeof(AllocationDetails::FileHeader),
       sizeof(AllocationDetails::ElementHeader));

if (log)
  log->Printf("%s - header type %" PRIu32"u" ", element size %" PRIu32"u",
              __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size);

// Check if the target allocation and file both have the same number of bytes
// for an Element
if (*alloc->element.datum_size.get() != root_el_hdr.element_size) {
  strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32"u"
              " bytes, allocation %" PRIu32"u" " bytes",
              root_el_hdr.element_size, *alloc->element.datum_size.get());
  strm.EOL();
}

// Check if the target allocation and file both have the same type
const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get());
const uint32_t file_type = root_el_hdr.type;

if (file_type > Element::RS_TYPE_FONT) {
  strm.Printf("Warning: File has unknown allocation type");
  strm.EOL();
} else if (alloc_type != file_type) {
  // Enum value isn't monotonous, so doesn't always index RsDataTypeToString
  // array
  uint32_t target_type_name_idx = alloc_type;
  uint32_t head_type_name_idx = file_type;
  if (alloc_type >= Element::RS_TYPE_ELEMENT &&
      alloc_type <= Element::RS_TYPE_FONT)
    target_type_name_idx = static_cast<Element::DataType>(
        (alloc_type - Element::RS_TYPE_ELEMENT) +
        Element::RS_TYPE_MATRIX_2X2 + 1);

  if (file_type >= Element::RS_TYPE_ELEMENT &&
      file_type <= Element::RS_TYPE_FONT)
    head_type_name_idx = static_cast<Element::DataType>(
        (file_type - Element::RS_TYPE_ELEMENT) + Element::RS_TYPE_MATRIX_2X2 +
        1);

  const char *head_type_name =
      AllocationDetails::RsDataTypeToString[head_type_name_idx][0];
  const char *target_type_name =
      AllocationDetails::RsDataTypeToString[target_type_name_idx][0];

  strm.Printf(
      "Warning: Mismatched Types - file '%s' type, allocation '%s' type",
      head_type_name, target_type_name);
  strm.EOL();
}

// Advance buffer past header
file_buf = static_cast<uint8_t *>(file_buf) + file_header->hdr_size;

// Calculate size of allocation data in file
size_t size = data_sp->GetByteSize() - file_header->hdr_size;

// Check if the target allocation and file both have the same total data size.
const uint32_t alloc_size = *alloc->size.get();
if (alloc_size != size) {
  strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64"l" "x"
              " bytes, allocation 0x%" PRIx32"x" " bytes",
              (uint64_t)size, alloc_size);
  strm.EOL();
  // Set length to copy to minimum
  size = alloc_size < size ? alloc_size : size;
}

// Copy file data from our buffer into the target allocation.
lldb::addr_t alloc_data = *alloc->data_ptr.get();
Status err;
size_t written = GetProcess()->WriteMemory(alloc_data, file_buf, size, err);
if (!err.Success() || written != size) {
  strm.Printf("Error: Couldn't write data to allocation %s", err.AsCString());
  strm.EOL();
  return false;
}

strm.Printf("Contents of file '%s' read into allocation %" PRIu32"u", path,
            alloc->id);
strm.EOL();

return true;
2659}

2661// Function takes as parameters a byte buffer, which will eventually be written
2662// to file as the element header, an offset into that buffer, and an Element
2663// that will be saved into the buffer at the parametrised offset.
2664// Return value is the new offset after writing the element into the buffer.
2665// Elements are saved to the file as the ElementHeader struct followed by
2666// offsets to the structs of all the element's children.
2667size_t RenderScriptRuntime::PopulateElementHeaders(
  const std::shared_ptr<uint8_t> header_buffer, size_t offset,
  const Element &elem) {
// File struct for an element header with all the relevant details copied from
// elem. We assume members are valid already.
AllocationDetails::ElementHeader elem_header;
elem_header.type = *elem.type.get();
elem_header.kind = *elem.type_kind.get();
elem_header.element_size = *elem.datum_size.get();
elem_header.vector_size = *elem.type_vec_size.get();
elem_header.array_size =
    elem.array_size.isValid() ? *elem.array_size.get() : 0;
const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader);

// Copy struct into buffer and advance offset
// We assume that header_buffer has been checked for nullptr before this
// method is called
memcpy(header_buffer.get() + offset, &elem_header, elem_header_size);
offset += elem_header_size;

// Starting offset of child ElementHeader struct
size_t child_offset =
    offset + ((elem.children.size() + 1) * sizeof(uint32_t));
for (const RenderScriptRuntime::Element &child : elem.children) {
  // Recursively populate the buffer with the element header structs of
  // children. Then save the offsets where they were set after the parent
  // element header.
  memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t));
  offset += sizeof(uint32_t);

  child_offset = PopulateElementHeaders(header_buffer, child_offset, child);
}

// Zero indicates no more children
memset(header_buffer.get() + offset, 0, sizeof(uint32_t));

return child_offset;
2704}

2706// Given an Element object this function returns the total size needed in the
2707// file header to store the element's details. Taking into account the size of
2708// the element header struct, plus the offsets to all the element's children.
2709// Function is recursive so that the size of all ancestors is taken into
2710// account.
2711size_t RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem) {
// Offsets to children plus zero terminator
size_t size = (elem.children.size() + 1) * sizeof(uint32_t);
// Size of header struct with type details
size += sizeof(AllocationDetails::ElementHeader);

// Calculate recursively for all descendants
for (const Element &child : elem.children)
  size += CalculateElementHeaderSize(child);

return size;
2722}

2724// Function copies allocation contents into a binary file. This file can then be
2725// loaded later into a different allocation. There is a header, FileHeader,
2726// before the allocation data containing meta-data.
2727bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
                                       const char *path,
                                       StackFrame *frame_ptr) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

// Find allocation with the given id
AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
if (!alloc)
  return false;

if (log)
  log->Printf("%s - found allocation 0x%" PRIx64"l" "x" ".", __FUNCTION__,
              *alloc->address.get());

// JIT all the allocation details
if (alloc->ShouldRefresh()) {
  if (log)
    log->Printf("%s - allocation details not calculated yet, jitting info.",
                __FUNCTION__);

  if (!RefreshAllocation(alloc, frame_ptr)) {
    if (log)
      log->Printf("%s - couldn't JIT allocation details.", __FUNCTION__);
    return false;
  }
}

assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->element.datum_size
.get() && alloc->element.type_kind.isValid() &&
 alloc->dimension.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2758, __extension__ __PRETTY_FUNCTION__))
       alloc->element.type_vec_size.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->element.datum_size
.get() && alloc->element.type_kind.isValid() &&
 alloc->dimension.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2758, __extension__ __PRETTY_FUNCTION__))
       alloc->element.datum_size.get() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->element.datum_size
.get() && alloc->element.type_kind.isValid() &&
 alloc->dimension.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2758, __extension__ __PRETTY_FUNCTION__))
       alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->element.datum_size
.get() && alloc->element.type_kind.isValid() &&
 alloc->dimension.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2758, __extension__ __PRETTY_FUNCTION__))
       "Allocation information not available")(static_cast <bool> (alloc->data_ptr.isValid() &&
 alloc->element.type.isValid() && alloc->element
.type_vec_size.isValid() && alloc->element.datum_size
.get() && alloc->element.type_kind.isValid() &&
 alloc->dimension.isValid() && "Allocation information not available"
) ? void (0) : __assert_fail ("alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() && \"Allocation information not available\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2758, __extension__ __PRETTY_FUNCTION__));

// Check we can create writable file
FileSpec file_spec(path, true);
File file(file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate |
                         File::eOpenOptionTruncate);
if (!file) {
  strm.Printf("Error: Failed to open '%s' for writing", path);
  strm.EOL();
  return false;
}

// Read allocation into buffer of heap memory
const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
if (!buffer) {
  strm.Printf("Error: Couldn't read allocation data into buffer");
  strm.EOL();
  return false;
}

// Create the file header
AllocationDetails::FileHeader head;
memcpy(head.ident, "RSAD", 4);
head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1);
head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2);
head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3);

const size_t element_header_size = CalculateElementHeaderSize(alloc->element);
assert((sizeof(AllocationDetails::FileHeader) + element_header_size) <(static_cast <bool> ((sizeof(AllocationDetails::FileHeader
) + element_header_size) < (65535) && "Element header too large"
) ? void (0) : __assert_fail ("(sizeof(AllocationDetails::FileHeader) + element_header_size) < UINT16_MAX && \"Element header too large\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2788, __extension__ __PRETTY_FUNCTION__))
           UINT16_MAX &&(static_cast <bool> ((sizeof(AllocationDetails::FileHeader
) + element_header_size) < (65535) && "Element header too large"
) ? void (0) : __assert_fail ("(sizeof(AllocationDetails::FileHeader) + element_header_size) < UINT16_MAX && \"Element header too large\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2788, __extension__ __PRETTY_FUNCTION__))
       "Element header too large")(static_cast <bool> ((sizeof(AllocationDetails::FileHeader
) + element_header_size) < (65535) && "Element header too large"
) ? void (0) : __assert_fail ("(sizeof(AllocationDetails::FileHeader) + element_header_size) < UINT16_MAX && \"Element header too large\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 2788, __extension__ __PRETTY_FUNCTION__));
head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) +
                                      element_header_size);

// Write the file header
size_t num_bytes = sizeof(AllocationDetails::FileHeader);
if (log)
  log->Printf("%s - writing File Header, 0x%" PRIx64"l" "x" " bytes", __FUNCTION__,
              (uint64_t)num_bytes);

Status err = file.Write(&head, num_bytes);
if (!err.Success()) {
  strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
  strm.EOL();
  return false;
}

// Create the headers describing the element type of the allocation.
std::shared_ptr<uint8_t> element_header_buffer(
    new uint8_t[element_header_size]);
if (element_header_buffer == nullptr) {
  strm.Printf("Internal Error: Couldn't allocate %" PRIu64"l" "u"
              " bytes on the heap",
              (uint64_t)element_header_size);
  strm.EOL();
  return false;
}

PopulateElementHeaders(element_header_buffer, 0, alloc->element);

// Write headers for allocation element type to file
num_bytes = element_header_size;
if (log)
  log->Printf("%s - writing element headers, 0x%" PRIx64"l" "x" " bytes.",
              __FUNCTION__, (uint64_t)num_bytes);

err = file.Write(element_header_buffer.get(), num_bytes);
if (!err.Success()) {
  strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
  strm.EOL();
  return false;
}

// Write allocation data to file
num_bytes = static_cast<size_t>(*alloc->size.get());
if (log)
  log->Printf("%s - writing 0x%" PRIx64"l" "x" " bytes", __FUNCTION__,
              (uint64_t)num_bytes);

err = file.Write(buffer.get(), num_bytes);
if (!err.Success()) {
  strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
  strm.EOL();
  return false;
}

strm.Printf("Allocation written to file '%s'", path);
strm.EOL();
return true;
2847}

2849bool RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (module_sp) {
  for (const auto &rs_module : m_rsmodules) {
    if (rs_module->m_module == module_sp) {
      // Check if the user has enabled automatically breaking on
      // all RS kernels.
      if (m_breakAllKernels)
        BreakOnModuleKernels(rs_module);

      return false;
    }
  }
  bool module_loaded = false;
  switch (GetModuleKind(module_sp)) {
  case eModuleKindKernelObj: {
    RSModuleDescriptorSP module_desc;
    module_desc.reset(new RSModuleDescriptor(module_sp));
    if (module_desc->ParseRSInfo()) {
      m_rsmodules.push_back(module_desc);
      module_desc->WarnIfVersionMismatch(GetProcess()
                                             ->GetTarget()
                                             .GetDebugger()
                                             .GetAsyncOutputStream()
                                             .get());
      module_loaded = true;
    }
    if (module_loaded) {
      FixupScriptDetails(module_desc);
    }
    break;
  }
  case eModuleKindDriver: {
    if (!m_libRSDriver) {
      m_libRSDriver = module_sp;
      LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver);
    }
    break;
  }
  case eModuleKindImpl: {
    if (!m_libRSCpuRef) {
      m_libRSCpuRef = module_sp;
      LoadRuntimeHooks(m_libRSCpuRef, RenderScriptRuntime::eModuleKindImpl);
    }
    break;
  }
  case eModuleKindLibRS: {
    if (!m_libRS) {
      m_libRS = module_sp;
      static ConstString gDbgPresentStr("gDebuggerPresent");
      const Symbol *debug_present = m_libRS->FindFirstSymbolWithNameAndType(
          gDbgPresentStr, eSymbolTypeData);
      if (debug_present) {
        Status err;
        uint32_t flag = 0x00000001U;
        Target &target = GetProcess()->GetTarget();
        addr_t addr = debug_present->GetLoadAddress(&target);
        GetProcess()->WriteMemory(addr, &flag, sizeof(flag), err);
        if (err.Success()) {
          if (log)
            log->Printf("%s - debugger present flag set on debugee.",
                        __FUNCTION__);

          m_debuggerPresentFlagged = true;
        } else if (log) {
          log->Printf("%s - error writing debugger present flags '%s' ",
                      __FUNCTION__, err.AsCString());
        }
      } else if (log) {
        log->Printf(
            "%s - error writing debugger present flags - symbol not found",
            __FUNCTION__);
      }
    }
    break;
  }
  default:
    break;
  }
  if (module_loaded)
    Update();
  return module_loaded;
}
return false;
2934}

2936void RenderScriptRuntime::Update() {
if (m_rsmodules.size() > 0) {
  if (!m_initiated) {
    Initiate();
  }
}
2942}

2944void RSModuleDescriptor::WarnIfVersionMismatch(lldb_private::Stream *s) const {
if (!s)
  return;

if (m_slang_version.empty() || m_bcc_version.empty()) {
  s->PutCString("WARNING: Unknown bcc or slang (llvm-rs-cc) version; debug "
                "experience may be unreliable");
  s->EOL();
} else if (m_slang_version != m_bcc_version) {
  s->Printf("WARNING: The debug info emitted by the slang frontend "
            "(llvm-rs-cc) used to build this module (%s) does not match the "
            "version of bcc used to generate the debug information (%s). "
            "This is an unsupported configuration and may result in a poor "
            "debugging experience; proceed with caution",
            m_slang_version.c_str(), m_bcc_version.c_str());
  s->EOL();
}
2961}

2963bool RSModuleDescriptor::ParsePragmaCount(llvm::StringRef *lines,
                                        size_t n_lines) {
// Skip the pragma prototype line
++lines;
for (; n_lines--; ++lines) {
  const auto kv_pair = lines->split(" - ");
  m_pragmas[kv_pair.first.trim().str()] = kv_pair.second.trim().str();
}
return true;
2972}

2974bool RSModuleDescriptor::ParseExportReduceCount(llvm::StringRef *lines,
                                              size_t n_lines) {
// The list of reduction kernels in the `.rs.info` symbol is of the form
// "signature - accumulatordatasize - reduction_name - initializer_name -
// accumulator_name - combiner_name -
// outconverter_name - halter_name"
// Where a function is not explicitly named by the user, or is not generated
// by the compiler, it is named "." so the
// dash separated list should always be 8 items long
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));
// Skip the exportReduceCount line
++lines;
for (; n_lines--; ++lines) {
  llvm::SmallVector<llvm::StringRef, 8> spec;
  lines->split(spec, " - ");
  if (spec.size() != 8) {
    if (spec.size() < 8) {
      if (log)
        log->Error("Error parsing RenderScript reduction spec. wrong number "
                   "of fields");
      return false;
    } else if (log)
      log->Warning("Extraneous members in reduction spec: '%s'",
                   lines->str().c_str());
  }

  const auto sig_s = spec[0];
  uint32_t sig;
  if (sig_s.getAsInteger(10, sig)) {
    if (log)
      log->Error("Error parsing Renderscript reduction spec: invalid kernel "
                 "signature: '%s'",
                 sig_s.str().c_str());
    return false;
  }

  const auto accum_data_size_s = spec[1];
  uint32_t accum_data_size;
  if (accum_data_size_s.getAsInteger(10, accum_data_size)) {
    if (log)
      log->Error("Error parsing Renderscript reduction spec: invalid "
                 "accumulator data size %s",
                 accum_data_size_s.str().c_str());
    return false;
  }

  if (log)
    log->Printf("Found RenderScript reduction '%s'", spec[2].str().c_str());

  m_reductions.push_back(RSReductionDescriptor(this, sig, accum_data_size,
                                               spec[2], spec[3], spec[4],
                                               spec[5], spec[6], spec[7]));
}
return true;
3028}

3030bool RSModuleDescriptor::ParseVersionInfo(llvm::StringRef *lines,
                                        size_t n_lines) {
// Skip the versionInfo line
++lines;
for (; n_lines--; ++lines) {
  // We're only interested in bcc and slang versions, and ignore all other
  // versionInfo lines
  const auto kv_pair = lines->split(" - ");
  if (kv_pair.first == "slang")
    m_slang_version = kv_pair.second.str();
  else if (kv_pair.first == "bcc")
    m_bcc_version = kv_pair.second.str();
}
return true;
3044}

3046bool RSModuleDescriptor::ParseExportForeachCount(llvm::StringRef *lines,
                                               size_t n_lines) {
// Skip the exportForeachCount line
++lines;
for (; n_lines--; ++lines) {
  uint32_t slot;
  // `forEach` kernels are listed in the `.rs.info` packet as a "slot - name"
  // pair per line
  const auto kv_pair = lines->split(" - ");
  if (kv_pair.first.getAsInteger(10, slot))
    return false;
  m_kernels.push_back(RSKernelDescriptor(this, kv_pair.second, slot));
}
return true;
3060}

3062bool RSModuleDescriptor::ParseExportVarCount(llvm::StringRef *lines,
                                           size_t n_lines) {
// Skip the ExportVarCount line
++lines;
for (; n_lines--; ++lines)
  m_globals.push_back(RSGlobalDescriptor(this, *lines));
return true;
3069}

3071// The .rs.info symbol in renderscript modules contains a string which needs to
3072// be parsed.
3073// The string is basic and is parsed on a line by line basis.
3074bool RSModuleDescriptor::ParseRSInfo() {
assert(m_module)(static_cast <bool> (m_module) ? void (0) : __assert_fail
 ("m_module", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3075, __extension__ __PRETTY_FUNCTION__));
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));
const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(
    ConstString(".rs.info"), eSymbolTypeData);
if (!info_sym)
  return false;

const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
if (addr == LLDB_INVALID_ADDRESS(18446744073709551615UL))
  return false;

const addr_t size = info_sym->GetByteSize();
const FileSpec fs = m_module->GetFileSpec();

auto buffer = DataBufferLLVM::CreateSliceFromPath(fs.GetPath(), size, addr);
if (!buffer)
  return false;

// split rs.info. contents into lines
llvm::SmallVector<llvm::StringRef, 128> info_lines;
{
  const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes());
  raw_rs_info.split(info_lines, '\n');
  if (log)
    log->Printf("'.rs.info symbol for '%s':\n%s",
                m_module->GetFileSpec().GetCString(),
                raw_rs_info.str().c_str());
}

enum {
  eExportVar,
  eExportForEach,
  eExportReduce,
  ePragma,
  eBuildChecksum,
  eObjectSlot,
  eVersionInfo,
};

const auto rs_info_handler = [](llvm::StringRef name) -> int {
  return llvm::StringSwitch<int>(name)
      // The number of visible global variables in the script
      .Case("exportVarCount", eExportVar)
      // The number of RenderScrip `forEach` kernels __attribute__((kernel))
      .Case("exportForEachCount", eExportForEach)
      // The number of generalreductions: This marked in the script by
      // `#pragma reduce()`
      .Case("exportReduceCount", eExportReduce)
      // Total count of all RenderScript specific `#pragmas` used in the
      // script
      .Case("pragmaCount", ePragma)
      .Case("objectSlotCount", eObjectSlot)
      .Case("versionInfo", eVersionInfo)
      .Default(-1);
};

// parse all text lines of .rs.info
for (auto line = info_lines.begin(); line != info_lines.end(); ++line) {
  const auto kv_pair = line->split(": ");
  const auto key = kv_pair.first;
  const auto val = kv_pair.second.trim();

  const auto handler = rs_info_handler(key);
  if (handler == -1)
    continue;
  // getAsInteger returns `true` on an error condition - we're only interested
  // in numeric fields at the moment
  uint64_t n_lines;
  if (val.getAsInteger(10, n_lines)) {
    LLDB_LOGV(log, "Failed to parse non-numeric '.rs.info' section {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
 && log_private->GetVerbose()) log_private->Format
("/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, __func__, "Failed to parse non-numeric '.rs.info' section {0}"
, line->str()); } while (0)
              line->str())do { ::lldb_private::Log *log_private = (log); if (log_private
 && log_private->GetVerbose()) log_private->Format
("/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, __func__, "Failed to parse non-numeric '.rs.info' section {0}"
, line->str()); } while (0);
    continue;
  }
  if (info_lines.end() - (line + 1) < (ptrdiff_t)n_lines)
    return false;

  bool success = false;
  switch (handler) {
  case eExportVar:
    success = ParseExportVarCount(line, n_lines);
    break;
  case eExportForEach:
    success = ParseExportForeachCount(line, n_lines);
    break;
  case eExportReduce:
    success = ParseExportReduceCount(line, n_lines);
    break;
  case ePragma:
    success = ParsePragmaCount(line, n_lines);
    break;
  case eVersionInfo:
    success = ParseVersionInfo(line, n_lines);
    break;
  default: {
    if (log)
      log->Printf("%s - skipping .rs.info field '%s'", __FUNCTION__,
                  line->str().c_str());
    continue;
  }
  }
  if (!success)
    return false;
  line += n_lines;
}
return info_lines.size() > 0;
3180}

3182void RenderScriptRuntime::DumpStatus(Stream &strm) const {
if (m_libRS) {
  strm.Printf("Runtime Library discovered.");
  strm.EOL();
}
if (m_libRSDriver) {
  strm.Printf("Runtime Driver discovered.");
  strm.EOL();
}
if (m_libRSCpuRef) {
  strm.Printf("CPU Reference Implementation discovered.");
  strm.EOL();
}

if (m_runtimeHooks.size()) {
  strm.Printf("Runtime functions hooked:");
  strm.EOL();
  for (auto b : m_runtimeHooks) {
    strm.Indent(b.second->defn->name);
    strm.EOL();
  }
} else {
  strm.Printf("Runtime is not hooked.");
  strm.EOL();
}
3207}

3209void RenderScriptRuntime::DumpContexts(Stream &strm) const {
strm.Printf("Inferred RenderScript Contexts:");
strm.EOL();
strm.IndentMore();

std::map<addr_t, uint64_t> contextReferences;

// Iterate over all of the currently discovered scripts.
// Note: We cant push or pop from m_scripts inside this loop or it may
// invalidate script.
for (const auto &script : m_scripts) {
  if (!script->context.isValid())
    continue;
  lldb::addr_t context = *script->context;

  if (contextReferences.find(context) != contextReferences.end()) {
    contextReferences[context]++;
  } else {
    contextReferences[context] = 1;
  }
}

for (const auto &cRef : contextReferences) {
  strm.Printf("Context 0x%" PRIx64"l" "x" ": %" PRIu64"l" "u" " script instances",
              cRef.first, cRef.second);
  strm.EOL();
}
strm.IndentLess();
3237}

3239void RenderScriptRuntime::DumpKernels(Stream &strm) const {
strm.Printf("RenderScript Kernels:");
strm.EOL();
strm.IndentMore();
for (const auto &module : m_rsmodules) {
  strm.Printf("Resource '%s':", module->m_resname.c_str());
  strm.EOL();
  for (const auto &kernel : module->m_kernels) {
    strm.Indent(kernel.m_name.AsCString());
    strm.EOL();
  }
}
strm.IndentLess();
3252}

3254RenderScriptRuntime::AllocationDetails *
3255RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id) {
AllocationDetails *alloc = nullptr;

// See if we can find allocation using id as an index;
if (alloc_id <= m_allocations.size() && alloc_id != 0 &&
    m_allocations[alloc_id - 1]->id == alloc_id) {
  alloc = m_allocations[alloc_id - 1].get();
  return alloc;
}

// Fallback to searching
for (const auto &a : m_allocations) {
  if (a->id == alloc_id) {
    alloc = a.get();
    break;
  }
}

if (alloc == nullptr) {
  strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32"u",
              alloc_id);
  strm.EOL();
}

return alloc;
3280}

3282// Prints the contents of an allocation to the output stream, which may be a
3283// file
3284bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr,
                                       const uint32_t id) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

// Check we can find the desired allocation
AllocationDetails *alloc = FindAllocByID(strm, id);
if (!alloc)
  return false; // FindAllocByID() will print error message for us here

if (log)
  log->Printf("%s - found allocation 0x%" PRIx64"l" "x", __FUNCTION__,
              *alloc->address.get());

// Check we have information about the allocation, if not calculate it
if (alloc->ShouldRefresh()) {
  if (log)
    log->Printf("%s - allocation details not calculated yet, jitting info.",
                __FUNCTION__);

  // JIT all the allocation information
  if (!RefreshAllocation(alloc, frame_ptr)) {
    strm.Printf("Error: Couldn't JIT allocation details");
    strm.EOL();
    return false;
  }
}

// Establish format and size of each data element
const uint32_t vec_size = *alloc->element.type_vec_size.get();
const Element::DataType type = *alloc->element.type.get();

assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT &&(static_cast <bool> (type >= Element::RS_TYPE_NONE &&
 type <= Element::RS_TYPE_FONT && "Invalid allocation type"
) ? void (0) : __assert_fail ("type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && \"Invalid allocation type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3316, __extension__ __PRETTY_FUNCTION__))
       "Invalid allocation type")(static_cast <bool> (type >= Element::RS_TYPE_NONE &&
 type <= Element::RS_TYPE_FONT && "Invalid allocation type"
) ? void (0) : __assert_fail ("type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && \"Invalid allocation type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3316, __extension__ __PRETTY_FUNCTION__));

lldb::Format format;
if (type >= Element::RS_TYPE_ELEMENT)
  format = eFormatHex;
else
  format = vec_size == 1
               ? static_cast<lldb::Format>(
                     AllocationDetails::RSTypeToFormat[type][eFormatSingle])
               : static_cast<lldb::Format>(
                     AllocationDetails::RSTypeToFormat[type][eFormatVector]);

const uint32_t data_size = *alloc->element.datum_size.get();

if (log)
  log->Printf("%s - element size %" PRIu32"u" " bytes, including padding",
              __FUNCTION__, data_size);

// Allocate a buffer to copy data into
std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
if (!buffer) {
  strm.Printf("Error: Couldn't read allocation data");
  strm.EOL();
  return false;
}

// Calculate stride between rows as there may be padding at end of rows since
// allocated memory is 16-byte aligned
if (!alloc->stride.isValid()) {
  if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension
    alloc->stride = 0;
  else if (!JITAllocationStride(alloc, frame_ptr)) {
    strm.Printf("Error: Couldn't calculate allocation row stride");
    strm.EOL();
    return false;
  }
}
const uint32_t stride = *alloc->stride.get();
const uint32_t size = *alloc->size.get(); // Size of whole allocation
const uint32_t padding =
    alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0;
if (log)
  log->Printf("%s - stride %" PRIu32"u" " bytes, size %" PRIu32"u"
              " bytes, padding %" PRIu32"u",
              __FUNCTION__, stride, size, padding);

// Find dimensions used to index loops, so need to be non-zero
uint32_t dim_x = alloc->dimension.get()->dim_1;
dim_x = dim_x == 0 ? 1 : dim_x;

uint32_t dim_y = alloc->dimension.get()->dim_2;
dim_y = dim_y == 0 ? 1 : dim_y;

uint32_t dim_z = alloc->dimension.get()->dim_3;
dim_z = dim_z == 0 ? 1 : dim_z;

// Use data extractor to format output
const uint32_t target_ptr_size =
    GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(),
                         target_ptr_size);

uint32_t offset = 0;   // Offset in buffer to next element to be printed
uint32_t prev_row = 0; // Offset to the start of the previous row

// Iterate over allocation dimensions, printing results to user
strm.Printf("Data (X, Y, Z):");
for (uint32_t z = 0; z < dim_z; ++z) {
  for (uint32_t y = 0; y < dim_y; ++y) {
    // Use stride to index start of next row.
    if (!(y == 0 && z == 0))
      offset = prev_row + stride;
    prev_row = offset;

    // Print each element in the row individually
    for (uint32_t x = 0; x < dim_x; ++x) {
      strm.Printf("\n(%" PRIu32"u" ", %" PRIu32"u" ", %" PRIu32"u" ") = ", x, y, z);
      if ((type == Element::RS_TYPE_NONE) &&
          (alloc->element.children.size() > 0) &&
          (alloc->element.type_name != Element::GetFallbackStructName())) {
        // Here we are dumping an Element of struct type.
        // This is done using expression evaluation with the name of the
        // struct type and pointer to element.
        // Don't print the name of the resulting expression, since this will
        // be '$[0-9]+'
        DumpValueObjectOptions expr_options;
        expr_options.SetHideName(true);

        // Setup expression as derefrencing a pointer cast to element address.
        char expr_char_buffer[jit_max_expr_size];
        int written =
            snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64"l" "x",
                     alloc->element.type_name.AsCString(),
                     *alloc->data_ptr.get() + offset);

        if (written < 0 || written >= jit_max_expr_size) {
          if (log)
            log->Printf("%s - error in snprintf().", __FUNCTION__);
          continue;
        }

        // Evaluate expression
        ValueObjectSP expr_result;
        GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer,
                                                     frame_ptr, expr_result);

        // Print the results to our stream.
        expr_result->Dump(strm, expr_options);
      } else {
        DumpDataExtractor(alloc_data, &strm, offset, format,
                          data_size - padding, 1, 1, LLDB_INVALID_ADDRESS(18446744073709551615UL), 0,
                          0);
      }
      offset += data_size;
    }
  }
}
strm.EOL();

return true;
3436}

3438// Function recalculates all our cached information about allocations by jitting
3439// the RS runtime regarding each allocation we know about. Returns true if all
3440// allocations could be recomputed, false otherwise.
3441bool RenderScriptRuntime::RecomputeAllAllocations(Stream &strm,
                                                StackFrame *frame_ptr) {
bool success = true;
for (auto &alloc : m_allocations) {
  // JIT current allocation information
  if (!RefreshAllocation(alloc.get(), frame_ptr)) {
    strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32"u"
                "\n",
                alloc->id);
    success = false;
  }
}

if (success)
  strm.Printf("All allocations successfully recomputed");
strm.EOL();

return success;
3459}

3461// Prints information regarding currently loaded allocations. These details are
3462// gathered by jitting the runtime, which has as latency. Index parameter
3463// specifies a single allocation ID to print, or a zero value to print them all
3464void RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr,
                                        const uint32_t index) {
strm.Printf("RenderScript Allocations:");
strm.EOL();
strm.IndentMore();

for (auto &alloc : m_allocations) {
  // index will only be zero if we want to print all allocations
  if (index != 0 && index != alloc->id)
    continue;

  // JIT current allocation information
  if (alloc->ShouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr)) {
    strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32"u",
                alloc->id);
    strm.EOL();
    continue;
  }

  strm.Printf("%" PRIu32"u" ":", alloc->id);
  strm.EOL();
  strm.IndentMore();

  strm.Indent("Context: ");
  if (!alloc->context.isValid())
    strm.Printf("unknown\n");
  else
    strm.Printf("0x%" PRIx64"l" "x" "\n", *alloc->context.get());

  strm.Indent("Address: ");
  if (!alloc->address.isValid())
    strm.Printf("unknown\n");
  else
    strm.Printf("0x%" PRIx64"l" "x" "\n", *alloc->address.get());

  strm.Indent("Data pointer: ");
  if (!alloc->data_ptr.isValid())
    strm.Printf("unknown\n");
  else
    strm.Printf("0x%" PRIx64"l" "x" "\n", *alloc->data_ptr.get());

  strm.Indent("Dimensions: ");
  if (!alloc->dimension.isValid())
    strm.Printf("unknown\n");
  else
    strm.Printf("(%" PRId32"d" ", %" PRId32"d" ", %" PRId32"d" ")\n",
                alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2,
                alloc->dimension.get()->dim_3);

  strm.Indent("Data Type: ");
  if (!alloc->element.type.isValid() ||
      !alloc->element.type_vec_size.isValid())
    strm.Printf("unknown\n");
  else {
    const int vector_size = *alloc->element.type_vec_size.get();
    Element::DataType type = *alloc->element.type.get();

    if (!alloc->element.type_name.IsEmpty())
      strm.Printf("%s\n", alloc->element.type_name.AsCString());
    else {
      // Enum value isn't monotonous, so doesn't always index
      // RsDataTypeToString array
      if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT)
        type =
            static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) +
                                           Element::RS_TYPE_MATRIX_2X2 + 1);

      if (type >= (sizeof(AllocationDetails::RsDataTypeToString) /
                   sizeof(AllocationDetails::RsDataTypeToString[0])) ||
          vector_size > 4 || vector_size < 1)
        strm.Printf("invalid type\n");
      else
        strm.Printf(
            "%s\n",
            AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)]
                                                 [vector_size - 1]);
    }
  }

  strm.Indent("Data Kind: ");
  if (!alloc->element.type_kind.isValid())
    strm.Printf("unknown\n");
  else {
    const Element::DataKind kind = *alloc->element.type_kind.get();
    if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV)
      strm.Printf("invalid kind\n");
    else
      strm.Printf(
          "%s\n",
          AllocationDetails::RsDataKindToString[static_cast<uint32_t>(kind)]);
  }

  strm.EOL();
  strm.IndentLess();
}
strm.IndentLess();
3560}

3562// Set breakpoints on every kernel found in RS module
3563void RenderScriptRuntime::BreakOnModuleKernels(
  const RSModuleDescriptorSP rsmodule_sp) {
for (const auto &kernel : rsmodule_sp->m_kernels) {
  // Don't set breakpoint on 'root' kernel
  if (strcmp(kernel.m_name.AsCString(), "root") == 0)
    continue;

  CreateKernelBreakpoint(kernel.m_name);
}
3572}

3574// Method is internally called by the 'kernel breakpoint all' command to enable
3575// or disable breaking on all kernels. When do_break is true we want to enable
3576// this functionality. When do_break is false we want to disable it.
3577void RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target) {
Log *log(
    GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));

InitSearchFilter(target);

// Set breakpoints on all the kernels
if (do_break && !m_breakAllKernels) {
  m_breakAllKernels = true;

  for (const auto &module : m_rsmodules)
    BreakOnModuleKernels(module);

  if (log)
    log->Printf("%s(True) - breakpoints set on all currently loaded kernels.",
                __FUNCTION__);
} else if (!do_break &&
           m_breakAllKernels) // Breakpoints won't be set on any new kernels.
{
  m_breakAllKernels = false;

  if (log)
    log->Printf("%s(False) - breakpoints no longer automatically set.",
                __FUNCTION__);
}
3602}

3604// Given the name of a kernel this function creates a breakpoint using our
3605// own breakpoint resolver, and returns the Breakpoint shared pointer.
3606BreakpointSP
3607RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name) {
Log *log(
    GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));

if (!m_filtersp) {
  if (log)
    log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
  return nullptr;
}

BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name));
Target &target = GetProcess()->GetTarget();
BreakpointSP bp = target.CreateBreakpoint(
    m_filtersp, resolver_sp, false, false, false);

// Give RS breakpoints a specific name, so the user can manipulate them as a
// group.
Status err;
target.AddNameToBreakpoint(bp, "RenderScriptKernel", err);
if (err.Fail() && log)
  if (log)
    log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
                err.AsCString());

return bp;
3632}

3634BreakpointSP
3635RenderScriptRuntime::CreateReductionBreakpoint(const ConstString &name,
                                             int kernel_types) {
Log *log(
    GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));

if (!m_filtersp) {
  if (log)
    log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
  return nullptr;
}

BreakpointResolverSP resolver_sp(new RSReduceBreakpointResolver(
    nullptr, name, &m_rsmodules, kernel_types));
Target &target = GetProcess()->GetTarget();
BreakpointSP bp = target.CreateBreakpoint(
    m_filtersp, resolver_sp, false, false, false);

// Give RS breakpoints a specific name, so the user can manipulate them as a
// group.
Status err;
target.AddNameToBreakpoint(bp, "RenderScriptReduction", err);
if (err.Fail() && log)
    log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
                err.AsCString());

return bp;
3661}

3663// Given an expression for a variable this function tries to calculate the
3664// variable's value. If this is possible it returns true and sets the uint64_t
3665// parameter to the variables unsigned value. Otherwise function returns false.
3666bool RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp,
                                              const char *var_name,
                                              uint64_t &val) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));
Status err;
VariableSP var_sp;

// Find variable in stack frame
ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath(
    var_name, eNoDynamicValues,
    StackFrame::eExpressionPathOptionCheckPtrVsMember |
        StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
    var_sp, err));
if (!err.Success()) {
  if (log)
    log->Printf("%s - error, couldn't find '%s' in frame", __FUNCTION__,
                var_name);
  return false;
}

// Find the uint32_t value for the variable
bool success = false;
val = value_sp->GetValueAsUnsigned(0, &success);
if (!success) {
  if (log)
    log->Printf("%s - error, couldn't parse '%s' as an uint32_t.",
                __FUNCTION__, var_name);
  return false;
}

return true;
3697}

3699// Function attempts to find the current coordinate of a kernel invocation by
3700// investigating the values of frame variables in the .expand function. These
3701// coordinates are returned via the coord array reference parameter. Returns
3702// true if the coordinates could be found, and false otherwise.
3703bool RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord,
                                            Thread *thread_ptr) {
static const char *const x_expr = "rsIndex";
static const char *const y_expr = "p->current.y";
static const char *const z_expr = "p->current.z";

Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28)));

if (!thread_ptr) {
  if (log)
    log->Printf("%s - Error, No thread pointer", __FUNCTION__);

  return false;
}

// Walk the call stack looking for a function whose name has the suffix
// '.expand' and contains the variables we're looking for.
for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i) {
  if (!thread_ptr->SetSelectedFrameByIndex(i))
    continue;

  StackFrameSP frame_sp = thread_ptr->GetSelectedFrame();
  if (!frame_sp)
    continue;

  // Find the function name
  const SymbolContext sym_ctx = frame_sp->GetSymbolContext(false);
  const ConstString func_name = sym_ctx.GetFunctionName();
  if (!func_name)
    continue;

  if (log)
    log->Printf("%s - Inspecting function '%s'", __FUNCTION__,
                func_name.GetCString());

  // Check if function name has .expand suffix
  if (!func_name.GetStringRef().endswith(".expand"))
    continue;

  if (log)
    log->Printf("%s - Found .expand function '%s'", __FUNCTION__,
                func_name.GetCString());

  // Get values for variables in .expand frame that tell us the current kernel
  // invocation
  uint64_t x, y, z;
  bool found = GetFrameVarAsUnsigned(frame_sp, x_expr, x) &&
               GetFrameVarAsUnsigned(frame_sp, y_expr, y) &&
               GetFrameVarAsUnsigned(frame_sp, z_expr, z);

  if (found) {
    // The RenderScript runtime uses uint32_t for these vars. If they're not
    // within bounds, our frame parsing is garbage
    assert(x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX)(static_cast <bool> (x <= (4294967295U) && y
 <= (4294967295U) && z <= (4294967295U)) ? void
 (0) : __assert_fail ("x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3756, __extension__ __PRETTY_FUNCTION__));
    coord.x = (uint32_t)x;
    coord.y = (uint32_t)y;
    coord.z = (uint32_t)z;
    return true;
  }
}
return false;
3764}

3766// Callback when a kernel breakpoint hits and we're looking for a specific
3767// coordinate. Baton parameter contains a pointer to the target coordinate we
3768// want to break on.
3769// Function then checks the .expand frame for the current coordinate and breaks
3770// to user if it matches.
3771// Parameter 'break_id' is the id of the Breakpoint which made the callback.
3772// Parameter 'break_loc_id' is the id for the BreakpointLocation which was hit,
3773// a single logical breakpoint can have multiple addresses.
3774bool RenderScriptRuntime::KernelBreakpointHit(void *baton,
                                            StoppointCallbackContext *ctx,
                                            user_id_t break_id,
                                            user_id_t break_loc_id) {
Log *log(
    GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));

assert(baton &&(static_cast <bool> (baton && "Error: null baton in conditional kernel breakpoint callback"
) ? void (0) : __assert_fail ("baton && \"Error: null baton in conditional kernel breakpoint callback\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3782, __extension__ __PRETTY_FUNCTION__))
       "Error: null baton in conditional kernel breakpoint callback")(static_cast <bool> (baton && "Error: null baton in conditional kernel breakpoint callback"
) ? void (0) : __assert_fail ("baton && \"Error: null baton in conditional kernel breakpoint callback\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3782, __extension__ __PRETTY_FUNCTION__));

// Coordinate we want to stop on
RSCoordinate target_coord = *static_cast<RSCoordinate *>(baton);

if (log)
  log->Printf("%s - Break ID %" PRIu64"l" "u" ", " FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")", __FUNCTION__, break_id,
              target_coord.x, target_coord.y, target_coord.z);

// Select current thread
ExecutionContext context(ctx->exe_ctx_ref);
Thread *thread_ptr = context.GetThreadPtr();
assert(thread_ptr && "Null thread pointer")(static_cast <bool> (thread_ptr && "Null thread pointer"
) ? void (0) : __assert_fail ("thread_ptr && \"Null thread pointer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3794, __extension__ __PRETTY_FUNCTION__));

// Find current kernel invocation from .expand frame variables
RSCoordinate current_coord{};
if (!GetKernelCoordinate(current_coord, thread_ptr)) {
  if (log)
    log->Printf("%s - Error, couldn't select .expand stack frame",
                __FUNCTION__);
  return false;
}

if (log)
  log->Printf("%s - " FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")", __FUNCTION__, current_coord.x,
              current_coord.y, current_coord.z);

// Check if the current kernel invocation coordinate matches our target
// coordinate
if (target_coord == current_coord) {
  if (log)
    log->Printf("%s, BREAKING " FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")", __FUNCTION__, current_coord.x,
                current_coord.y, current_coord.z);

  BreakpointSP breakpoint_sp =
      context.GetTargetPtr()->GetBreakpointByID(break_id);
  assert(breakpoint_sp != nullptr &&(static_cast <bool> (breakpoint_sp != nullptr &&
 "Error: Couldn't find breakpoint matching break id for callback"
) ? void (0) : __assert_fail ("breakpoint_sp != nullptr && \"Error: Couldn't find breakpoint matching break id for callback\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3819, __extension__ __PRETTY_FUNCTION__))
         "Error: Couldn't find breakpoint matching break id for callback")(static_cast <bool> (breakpoint_sp != nullptr &&
 "Error: Couldn't find breakpoint matching break id for callback"
) ? void (0) : __assert_fail ("breakpoint_sp != nullptr && \"Error: Couldn't find breakpoint matching break id for callback\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 3819, __extension__ __PRETTY_FUNCTION__));
  breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint
                                    // should only be hit once.
  return true;
}

// No match on coordinate
return false;
3827}

3829void RenderScriptRuntime::SetConditional(BreakpointSP bp, Stream &messages,
                                       const RSCoordinate &coord) {
messages.Printf("Conditional kernel breakpoint on coordinate " FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")",
                coord.x, coord.y, coord.z);
messages.EOL();

// Allocate memory for the baton, and copy over coordinate
RSCoordinate *baton = new RSCoordinate(coord);

// Create a callback that will be invoked every time the breakpoint is hit.
// The baton object passed to the handler is the target coordinate we want to
// break on.
bp->SetCallback(KernelBreakpointHit, baton, true);

// Store a shared pointer to the baton, so the memory will eventually be
// cleaned up after destruction
m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton);
3846}

3848// Tries to set a breakpoint on the start of a kernel, resolved using the kernel
3849// name. Argument 'coords', represents a three dimensional coordinate which can
3850// be
3851// used to specify a single kernel instance to break on. If this is set then we
3852// add a callback
3853// to the breakpoint.
3854bool RenderScriptRuntime::PlaceBreakpointOnKernel(TargetSP target,
                                                Stream &messages,
                                                const char *name,
                                                const RSCoordinate *coord) {
if (!name)
  return false;

InitSearchFilter(target);

ConstString kernel_name(name);
BreakpointSP bp = CreateKernelBreakpoint(kernel_name);
if (!bp)
  return false;

// We have a conditional breakpoint on a specific coordinate
if (coord)
  SetConditional(bp, messages, *coord);

bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);

return true;
3875}

3877BreakpointSP
3878RenderScriptRuntime::CreateScriptGroupBreakpoint(const ConstString &name,
                                               bool stop_on_all) {
Log *log(
    GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28) | LIBLLDB_LOG_BREAKPOINTS(1u << 5)));

if (!m_filtersp) {
  if (log)
    log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
  return nullptr;
}

BreakpointResolverSP resolver_sp(new RSScriptGroupBreakpointResolver(
    nullptr, name, m_scriptGroups, stop_on_all));
Target &target = GetProcess()->GetTarget();
BreakpointSP bp = target.CreateBreakpoint(
    m_filtersp, resolver_sp, false, false, false);
// Give RS breakpoints a specific name, so the user can manipulate them as a
// group.
Status err;
target.AddNameToBreakpoint(bp, name.GetCString(), err);
if (err.Fail() && log)
  log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
              err.AsCString());
// ask the breakpoint to resolve itself
bp->ResolveBreakpoint();
return bp;
3904}

3906bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target,
                                                     Stream &strm,
                                                     const ConstString &name,
                                                     bool multi) {
InitSearchFilter(target);
BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi);
if (bp)
  bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
return bool(bp);
3915}

3917bool RenderScriptRuntime::PlaceBreakpointOnReduction(TargetSP target,
                                                   Stream &messages,
                                                   const char *reduce_name,
                                                   const RSCoordinate *coord,
                                                   int kernel_types) {
if (!reduce_name)
  return false;

InitSearchFilter(target);
BreakpointSP bp =
    CreateReductionBreakpoint(ConstString(reduce_name), kernel_types);
if (!bp)
  return false;

if (coord)
  SetConditional(bp, messages, *coord);

bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);

return true;
3937}

3939void RenderScriptRuntime::DumpModules(Stream &strm) const {
strm.Printf("RenderScript Modules:");
strm.EOL();
strm.IndentMore();
for (const auto &module : m_rsmodules) {
  module->Dump(strm);
}
strm.IndentLess();
3947}

3949RenderScriptRuntime::ScriptDetails *
3950RenderScriptRuntime::LookUpScript(addr_t address, bool create) {
for (const auto &s : m_scripts) {
  if (s->script.isValid())
    if (*s->script == address)
      return s.get();
}
if (create) {
  std::unique_ptr<ScriptDetails> s(new ScriptDetails);
  s->script = address;
  m_scripts.push_back(std::move(s));
  return m_scripts.back().get();
}
return nullptr;
3963}

3965RenderScriptRuntime::AllocationDetails *
3966RenderScriptRuntime::LookUpAllocation(addr_t address) {
for (const auto &a : m_allocations) {
  if (a->address.isValid())
    if (*a->address == address)
      return a.get();
}
return nullptr;
3973}

3975RenderScriptRuntime::AllocationDetails *
3976RenderScriptRuntime::CreateAllocation(addr_t address) {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE(1u << 28));

// Remove any previous allocation which contains the same address
auto it = m_allocations.begin();
while (it != m_allocations.end()) {
  if (*((*it)->address) == address) {
    if (log)
      log->Printf("%s - Removing allocation id: %d, address: 0x%" PRIx64"l" "x",
                  __FUNCTION__, (*it)->id, address);

    it = m_allocations.erase(it);
  } else {
    it++;
  }
}

std::unique_ptr<AllocationDetails> a(new AllocationDetails);
a->address = address;
m_allocations.push_back(std::move(a));
return m_allocations.back().get();
3997}

3999bool RenderScriptRuntime::ResolveKernelName(lldb::addr_t kernel_addr,
                                          ConstString &name) {
Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS(1u << 20));

Target &target = GetProcess()->GetTarget();
Address resolved;
// RenderScript module
if (!target.GetSectionLoadList().ResolveLoadAddress(kernel_addr, resolved)) {
  if (log)
    log->Printf("%s: unable to resolve 0x%" PRIx64"l" "x" " to a loaded symbol",
                __FUNCTION__, kernel_addr);
  return false;
}

Symbol *sym = resolved.CalculateSymbolContextSymbol();
if (!sym)
  return false;

name = sym->GetName();
assert(IsRenderScriptModule(resolved.CalculateSymbolContextModule()))(static_cast <bool> (IsRenderScriptModule(resolved.CalculateSymbolContextModule
())) ? void (0) : __assert_fail ("IsRenderScriptModule(resolved.CalculateSymbolContextModule())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 4018, __extension__ __PRETTY_FUNCTION__));
if (log)
  log->Printf("%s: 0x%" PRIx64"l" "x" " resolved to the symbol '%s'", __FUNCTION__,
              kernel_addr, name.GetCString());
return true;
4023}

4025void RSModuleDescriptor::Dump(Stream &strm) const {
int indent = strm.GetIndentLevel();

strm.Indent();
m_module->GetFileSpec().Dump(&strm);
strm.Indent(m_module->GetNumCompileUnits() ? "Debug info loaded."
                                           : "Debug info does not exist.");
strm.EOL();
strm.IndentMore();

strm.Indent();
strm.Printf("Globals: %" PRIu64"l" "u", static_cast<uint64_t>(m_globals.size()));
strm.EOL();
strm.IndentMore();
for (const auto &global : m_globals) {
  global.Dump(strm);
}
strm.IndentLess();

strm.Indent();
strm.Printf("Kernels: %" PRIu64"l" "u", static_cast<uint64_t>(m_kernels.size()));
strm.EOL();
strm.IndentMore();
for (const auto &kernel : m_kernels) {
  kernel.Dump(strm);
}
strm.IndentLess();

strm.Indent();
strm.Printf("Pragmas: %" PRIu64"l" "u", static_cast<uint64_t>(m_pragmas.size()));
strm.EOL();
strm.IndentMore();
for (const auto &key_val : m_pragmas) {
  strm.Indent();
  strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str());
  strm.EOL();
}
strm.IndentLess();

strm.Indent();
strm.Printf("Reductions: %" PRIu64"l" "u",
            static_cast<uint64_t>(m_reductions.size()));
strm.EOL();
strm.IndentMore();
for (const auto &reduction : m_reductions) {
  reduction.Dump(strm);
}

strm.SetIndentLevel(indent);
4074}

4076void RSGlobalDescriptor::Dump(Stream &strm) const {
strm.Indent(m_name.AsCString());
VariableList var_list;
m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list);
if (var_list.GetSize() == 1) {
  auto var = var_list.GetVariableAtIndex(0);
  auto type = var->GetType();
  if (type) {
    strm.Printf(" - ");
    type->DumpTypeName(&strm);
  } else {
    strm.Printf(" - Unknown Type");
  }
} else {
  strm.Printf(" - variable identified, but not found in binary");
  const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(
      m_name, eSymbolTypeData);
  if (s) {
    strm.Printf(" (symbol exists) ");
  }
}

strm.EOL();
4099}

4101void RSKernelDescriptor::Dump(Stream &strm) const {
strm.Indent(m_name.AsCString());
strm.EOL();
4104}

4106void RSReductionDescriptor::Dump(lldb_private::Stream &stream) const {
stream.Indent(m_reduce_name.AsCString());
stream.IndentMore();
stream.EOL();
stream.Indent();
stream.Printf("accumulator: %s", m_accum_name.AsCString());
stream.EOL();
stream.Indent();
stream.Printf("initializer: %s", m_init_name.AsCString());
stream.EOL();
stream.Indent();
stream.Printf("combiner: %s", m_comb_name.AsCString());
stream.EOL();
stream.Indent();
stream.Printf("outconverter: %s", m_outc_name.AsCString());
stream.EOL();
// XXX This is currently unspecified by RenderScript, and unused
// stream.Indent();
// stream.Printf("halter: '%s'", m_init_name.AsCString());
// stream.EOL();
stream.IndentLess();
4127}

4129class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed {
4130public:
CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript module dump",
          "Dumps renderscript specific information for all modules.",
          "renderscript module dump",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeModuleDump() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime =
      (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript);
  runtime->DumpModules(result.GetOutputStream());
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}
4148};

4150class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword {
4151public:
CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "renderscript module",
                             "Commands that deal with RenderScript modules.",
                             nullptr) {
  LoadSubCommand(
      "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump(
                  interpreter)));
}

~CommandObjectRenderScriptRuntimeModule() override = default;
4162};

4164class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed {
4165public:
CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript kernel list",
          "Lists renderscript kernel names and associated script resources.",
          "renderscript kernel list",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeKernelList() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime =
      (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript);
  runtime->DumpKernels(result.GetOutputStream());
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}
4183};

4185static OptionDefinition g_renderscript_reduction_bp_set_options[] = {
  {LLDB_OPT_SET_1(1U << 0), false, "function-role", 't',
   OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner,
   "Break on a comma separated set of reduction kernel types "
   "(accumulator,outcoverter,combiner,initializer"},
  {LLDB_OPT_SET_1(1U << 0), false, "coordinate", 'c', OptionParser::eRequiredArgument,
   nullptr, nullptr, 0, eArgTypeValue,
   "Set a breakpoint on a single invocation of the kernel with specified "
   "coordinate.\n"
   "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
   "integers representing kernel dimensions. "
   "Any unset dimensions will be defaulted to zero."}};

4198class CommandObjectRenderScriptRuntimeReductionBreakpointSet
  : public CommandObjectParsed {
4200public:
CommandObjectRenderScriptRuntimeReductionBreakpointSet(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript reduction breakpoint set",
          "Set a breakpoint on named RenderScript general reductions",
          "renderscript reduction breakpoint set  <kernel_name> [-t "
          "<reduction_kernel_type,...>]",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched |
              eCommandProcessMustBePaused),
      m_options(){};

class CommandOptions : public Options {
public:
  CommandOptions()
      : Options(),
        m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *exe_ctx) override {
    Status err;
    StreamString err_str;
    const int short_option = m_getopt_table[option_idx].val;
    switch (short_option) {
    case 't':
      if (!ParseReductionTypes(option_arg, err_str))
        err.SetErrorStringWithFormat(
            "Unable to deduce reduction types for %s: %s",
            option_arg.str().c_str(), err_str.GetData());
      break;
    case 'c': {
      auto coord = RSCoordinate{};
      if (!ParseCoordinate(option_arg, coord))
        err.SetErrorStringWithFormat("unable to parse coordinate for %s",
                                     option_arg.str().c_str());
      else {
        m_have_coord = true;
        m_coord = coord;
      }
      break;
    }
    default:
      err.SetErrorStringWithFormat("Invalid option '-%c'", short_option);
    }
    return err;
  }

  void OptionParsingStarting(ExecutionContext *exe_ctx) override {
    m_have_coord = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_renderscript_reduction_bp_set_options);
  }

  bool ParseReductionTypes(llvm::StringRef option_val,
                           StreamString &err_str) {
    m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone;
    const auto reduce_name_to_type = [](llvm::StringRef name) -> int {
      return llvm::StringSwitch<int>(name)
          .Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum)
          .Case("initializer", RSReduceBreakpointResolver::eKernelTypeInit)
          .Case("outconverter", RSReduceBreakpointResolver::eKernelTypeOutC)
          .Case("combiner", RSReduceBreakpointResolver::eKernelTypeComb)
          .Case("all", RSReduceBreakpointResolver::eKernelTypeAll)
          // Currently not exposed by the runtime
          // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter)
          .Default(0);
    };

    // Matching a comma separated list of known words is fairly
    // straightforward with PCRE, but we're
    // using ERE, so we end up with a little ugliness...
    RegularExpression::Match match(/* max_matches */ 5);
    RegularExpression match_type_list(
        llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$"));

    assert(match_type_list.IsValid())(static_cast <bool> (match_type_list.IsValid()) ? void (
0) : __assert_fail ("match_type_list.IsValid()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 4279, __extension__ __PRETTY_FUNCTION__));

    if (!match_type_list.Execute(option_val, &match)) {
      err_str.PutCString(
          "a comma-separated list of kernel types is required");
      return false;
    }

    // splitting on commas is much easier with llvm::StringRef than regex
    llvm::SmallVector<llvm::StringRef, 5> type_names;
    llvm::StringRef(option_val).split(type_names, ',');

    for (const auto &name : type_names) {
      const int type = reduce_name_to_type(name);
      if (!type) {
        err_str.Printf("unknown kernel type name %s", name.str().c_str());
        return false;
      }
      m_kernel_types |= type;
    }

    return true;
  }

  int m_kernel_types;
  llvm::StringRef m_reduce_name;
  RSCoordinate m_coord;
  bool m_have_coord;
};

Options *GetOptions() override { return &m_options; }

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc < 1) {
    result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, "
                                 "and an optional kernel type list",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  auto &outstream = result.GetOutputStream();
  auto name = command.GetArgumentAtIndex(0);
  auto &target = m_exe_ctx.GetTargetSP();
  auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
  if (!runtime->PlaceBreakpointOnReduction(target, outstream, name, coord,
                                           m_options.m_kernel_types)) {
    result.SetStatus(eReturnStatusFailed);
    result.AppendError("Error: unable to place breakpoint on reduction");
    return false;
  }
  result.AppendMessage("Breakpoint(s) created");
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}

4340private:
CommandOptions m_options;
4342};

4344static OptionDefinition g_renderscript_kernel_bp_set_options[] = {
  {LLDB_OPT_SET_1(1U << 0), false, "coordinate", 'c', OptionParser::eRequiredArgument,
   nullptr, nullptr, 0, eArgTypeValue,
   "Set a breakpoint on a single invocation of the kernel with specified "
   "coordinate.\n"
   "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
   "integers representing kernel dimensions. "
   "Any unset dimensions will be defaulted to zero."}};

4353class CommandObjectRenderScriptRuntimeKernelBreakpointSet
  : public CommandObjectParsed {
4355public:
CommandObjectRenderScriptRuntimeKernelBreakpointSet(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript kernel breakpoint set",
          "Sets a breakpoint on a renderscript kernel.",
          "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched |
              eCommandProcessMustBePaused),
      m_options() {}

~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default;

Options *GetOptions() override { return &m_options; }

class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *exe_ctx) override {
    Status err;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'c': {
      auto coord = RSCoordinate{};
      if (!ParseCoordinate(option_arg, coord))
        err.SetErrorStringWithFormat(
            "Couldn't parse coordinate '%s', should be in format 'x,y,z'.",
            option_arg.str().c_str());
      else {
        m_have_coord = true;
        m_coord = coord;
      }
      break;
    }
    default:
      err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
      break;
    }
    return err;
  }

  void OptionParsingStarting(ExecutionContext *exe_ctx) override {
    m_have_coord = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options);
  }

  RSCoordinate m_coord;
  bool m_have_coord;
};

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc < 1) {
    result.AppendErrorWithFormat(
        "'%s' takes 1 argument of kernel name, and an optional coordinate.",
        m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime =
      (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript);

  auto &outstream = result.GetOutputStream();
  auto &target = m_exe_ctx.GetTargetSP();
  auto name = command.GetArgumentAtIndex(0);
  auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
  if (!runtime->PlaceBreakpointOnKernel(target, outstream, name, coord)) {
    result.SetStatus(eReturnStatusFailed);
    result.AppendErrorWithFormat(
        "Error: unable to set breakpoint on kernel '%s'", name);
    return false;
  }

  result.AppendMessage("Breakpoint(s) created");
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}

4443private:
CommandOptions m_options;
4445};

4447class CommandObjectRenderScriptRuntimeKernelBreakpointAll
  : public CommandObjectParsed {
4449public:
CommandObjectRenderScriptRuntimeKernelBreakpointAll(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript kernel breakpoint all",
          "Automatically sets a breakpoint on all renderscript kernels that "
          "are or will be loaded.\n"
          "Disabling option means breakpoints will no longer be set on any "
          "kernels loaded in the future, "
          "but does not remove currently set breakpoints.",
          "renderscript kernel breakpoint all <enable/disable>",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched |
              eCommandProcessMustBePaused) {}

~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc != 1) {
    result.AppendErrorWithFormat(
        "'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  bool do_break = false;
  const char *argument = command.GetArgumentAtIndex(0);
  if (strcmp(argument, "enable") == 0) {
    do_break = true;
    result.AppendMessage("Breakpoints will be set on all kernels.");
  } else if (strcmp(argument, "disable") == 0) {
    do_break = false;
    result.AppendMessage("Breakpoints will not be set on any new kernels.");
  } else {
    result.AppendErrorWithFormat(
        "Argument must be either 'enable' or 'disable'");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP());

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}
4498};

4500class CommandObjectRenderScriptRuntimeReductionBreakpoint
  : public CommandObjectMultiword {
4502public:
CommandObjectRenderScriptRuntimeReductionBreakpoint(
    CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "renderscript reduction breakpoint",
                             "Commands that manipulate breakpoints on "
                             "renderscript general reductions.",
                             nullptr) {
  LoadSubCommand(
      "set", CommandObjectSP(
                 new CommandObjectRenderScriptRuntimeReductionBreakpointSet(
                     interpreter)));
}

~CommandObjectRenderScriptRuntimeReductionBreakpoint() override = default;
4516};

4518class CommandObjectRenderScriptRuntimeKernelCoordinate
  : public CommandObjectParsed {
4520public:
CommandObjectRenderScriptRuntimeKernelCoordinate(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript kernel coordinate",
          "Shows the (x,y,z) coordinate of the current kernel invocation.",
          "renderscript kernel coordinate",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched |
              eCommandProcessMustBePaused) {}

~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RSCoordinate coord{};
  bool success = RenderScriptRuntime::GetKernelCoordinate(
      coord, m_exe_ctx.GetThreadPtr());
  Stream &stream = result.GetOutputStream();

  if (success) {
    stream.Printf("Coordinate: " FMT_COORD"(%" "u" ", %" "u" ", %" "u" ")", coord.x, coord.y, coord.z);
    stream.EOL();
    result.SetStatus(eReturnStatusSuccessFinishResult);
  } else {
    stream.Printf("Error: Coordinate could not be found.");
    stream.EOL();
    result.SetStatus(eReturnStatusFailed);
  }
  return true;
}
4549};

4551class CommandObjectRenderScriptRuntimeKernelBreakpoint
  : public CommandObjectMultiword {
4553public:
CommandObjectRenderScriptRuntimeKernelBreakpoint(
    CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "renderscript kernel",
          "Commands that generate breakpoints on renderscript kernels.",
          nullptr) {
  LoadSubCommand(
      "set",
      CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet(
          interpreter)));
  LoadSubCommand(
      "all",
      CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll(
          interpreter)));
}

~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default;
4571};

4573class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword {
4574public:
CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "renderscript kernel",
                             "Commands that deal with RenderScript kernels.",
                             nullptr) {
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList(
                  interpreter)));
  LoadSubCommand(
      "coordinate",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter)));
  LoadSubCommand(
      "breakpoint",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter)));
}

~CommandObjectRenderScriptRuntimeKernel() override = default;
4593};

4595class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed {
4596public:
CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "renderscript context dump",
                          "Dumps renderscript context information.",
                          "renderscript context dump",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeContextDump() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime =
      (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript);
  runtime->DumpContexts(result.GetOutputStream());
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}
4614};

4616static OptionDefinition g_renderscript_runtime_alloc_dump_options[] = {
  {LLDB_OPT_SET_1(1U << 0), false, "file", 'f', OptionParser::eRequiredArgument,
   nullptr, nullptr, 0, eArgTypeFilename,
   "Print results to specified file instead of command line."}};

4621class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword {
4622public:
CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "renderscript context",
                             "Commands that deal with RenderScript contexts.",
                             nullptr) {
  LoadSubCommand(
      "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(
                  interpreter)));
}

~CommandObjectRenderScriptRuntimeContext() override = default;
4633};

4635class CommandObjectRenderScriptRuntimeAllocationDump
  : public CommandObjectParsed {
4637public:
CommandObjectRenderScriptRuntimeAllocationDump(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "renderscript allocation dump",
                          "Displays the contents of a particular allocation",
                          "renderscript allocation dump <ID>",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched),
      m_options() {}

~CommandObjectRenderScriptRuntimeAllocationDump() override = default;

Options *GetOptions() override { return &m_options; }

class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *exe_ctx) override {
    Status err;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'f':
      m_outfile.SetFile(option_arg, true);
      if (m_outfile.Exists()) {
        m_outfile.Clear();
        err.SetErrorStringWithFormat("file already exists: '%s'",
                                     option_arg.str().c_str());
      }
      break;
    default:
      err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
      break;
    }
    return err;
  }

  void OptionParsingStarting(ExecutionContext *exe_ctx) override {
    m_outfile.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_renderscript_runtime_alloc_dump_options);
  }

  FileSpec m_outfile;
};

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc < 1) {
    result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. "
                                 "As well as an optional -f argument",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  const char *id_cstr = command.GetArgumentAtIndex(0);
  bool success = false;
  const uint32_t id =
      StringConvert::ToUInt32(id_cstr, UINT32_MAX(4294967295U), 0, &success);
  if (!success) {
    result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                 id_cstr);
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  Stream *output_strm = nullptr;
  StreamFile outfile_stream;
  const FileSpec &outfile_spec =
      m_options.m_outfile; // Dump allocation to file instead
  if (outfile_spec) {
    // Open output file
    char path[256];
    outfile_spec.GetPath(path, sizeof(path));
    if (outfile_stream.GetFile()
            .Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate)
            .Success()) {
      output_strm = &outfile_stream;
      result.GetOutputStream().Printf("Results written to '%s'", path);
      result.GetOutputStream().EOL();
    } else {
      result.AppendErrorWithFormat("Couldn't open file '%s'", path);
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
  } else
    output_strm = &result.GetOutputStream();

  assert(output_strm != nullptr)(static_cast <bool> (output_strm != nullptr) ? void (0)
 : __assert_fail ("output_strm != nullptr", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 4736, __extension__ __PRETTY_FUNCTION__));
  bool dumped =
      runtime->DumpAllocation(*output_strm, m_exe_ctx.GetFramePtr(), id);

  if (dumped)
    result.SetStatus(eReturnStatusSuccessFinishResult);
  else
    result.SetStatus(eReturnStatusFailed);

  return true;
}

4748private:
CommandOptions m_options;
4750};

4752static OptionDefinition g_renderscript_runtime_alloc_list_options[] = {
  {LLDB_OPT_SET_1(1U << 0), false, "id", 'i', OptionParser::eRequiredArgument, nullptr,
   nullptr, 0, eArgTypeIndex,
   "Only show details of a single allocation with specified id."}};

4757class CommandObjectRenderScriptRuntimeAllocationList
  : public CommandObjectParsed {
4759public:
CommandObjectRenderScriptRuntimeAllocationList(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript allocation list",
          "List renderscript allocations and their information.",
          "renderscript allocation list",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched),
      m_options() {}

~CommandObjectRenderScriptRuntimeAllocationList() override = default;

Options *GetOptions() override { return &m_options; }

class CommandOptions : public Options {
public:
  CommandOptions() : Options(), m_id(0) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *exe_ctx) override {
    Status err;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'i':
      if (option_arg.getAsInteger(0, m_id))
        err.SetErrorStringWithFormat("invalid integer value for option '%c'",
                                     short_option);
      break;
    default:
      err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
      break;
    }
    return err;
  }

  void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options);
  }

  uint32_t m_id;
};

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));
  runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(),
                           m_options.m_id);
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}

4816private:
CommandOptions m_options;
4818};

4820class CommandObjectRenderScriptRuntimeAllocationLoad
  : public CommandObjectParsed {
4822public:
CommandObjectRenderScriptRuntimeAllocationLoad(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "renderscript allocation load",
          "Loads renderscript allocation contents from a file.",
          "renderscript allocation load <ID> <filename>",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeAllocationLoad() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc != 2) {
    result.AppendErrorWithFormat(
        "'%s' takes 2 arguments, an allocation ID and filename to read from.",
        m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  const char *id_cstr = command.GetArgumentAtIndex(0);
  bool success = false;
  const uint32_t id =
      StringConvert::ToUInt32(id_cstr, UINT32_MAX(4294967295U), 0, &success);
  if (!success) {
    result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                 id_cstr);
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  const char *path = command.GetArgumentAtIndex(1);
  bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path,
                                        m_exe_ctx.GetFramePtr());

  if (loaded)
    result.SetStatus(eReturnStatusSuccessFinishResult);
  else
    result.SetStatus(eReturnStatusFailed);

  return true;
}
4869};

4871class CommandObjectRenderScriptRuntimeAllocationSave
  : public CommandObjectParsed {
4873public:
CommandObjectRenderScriptRuntimeAllocationSave(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "renderscript allocation save",
                          "Write renderscript allocation contents to a file.",
                          "renderscript allocation save <ID> <filename>",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeAllocationSave() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();
  if (argc != 2) {
    result.AppendErrorWithFormat(
        "'%s' takes 2 arguments, an allocation ID and filename to read from.",
        m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  const char *id_cstr = command.GetArgumentAtIndex(0);
  bool success = false;
  const uint32_t id =
      StringConvert::ToUInt32(id_cstr, UINT32_MAX(4294967295U), 0, &success);
  if (!success) {
    result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                 id_cstr);
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  const char *path = command.GetArgumentAtIndex(1);
  bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path,
                                       m_exe_ctx.GetFramePtr());

  if (saved)
    result.SetStatus(eReturnStatusSuccessFinishResult);
  else
    result.SetStatus(eReturnStatusFailed);

  return true;
}
4920};

4922class CommandObjectRenderScriptRuntimeAllocationRefresh
  : public CommandObjectParsed {
4924public:
CommandObjectRenderScriptRuntimeAllocationRefresh(
    CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "renderscript allocation refresh",
                          "Recomputes the details of all allocations.",
                          "renderscript allocation refresh",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
      m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript));

  bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(),
                                                  m_exe_ctx.GetFramePtr());

  if (success) {
    result.SetStatus(eReturnStatusSuccessFinishResult);
    return true;
  } else {
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}
4951};

4953class CommandObjectRenderScriptRuntimeAllocation
  : public CommandObjectMultiword {
4955public:
CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "renderscript allocation",
          "Commands that deal with RenderScript allocations.", nullptr) {
  LoadSubCommand(
      "list",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeAllocationList(interpreter)));
  LoadSubCommand(
      "dump",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeAllocationDump(interpreter)));
  LoadSubCommand(
      "save",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeAllocationSave(interpreter)));
  LoadSubCommand(
      "load",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter)));
  LoadSubCommand(
      "refresh",
      CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh(
          interpreter)));
}

~CommandObjectRenderScriptRuntimeAllocation() override = default;
4983};

4985class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed {
4986public:
CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "renderscript status",
                          "Displays current RenderScript runtime status.",
                          "renderscript status",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched) {}

~CommandObjectRenderScriptRuntimeStatus() override = default;

bool DoExecute(Args &command, CommandReturnObject &result) override {
  RenderScriptRuntime *runtime =
      (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
          eLanguageTypeExtRenderScript);
  runtime->DumpStatus(result.GetOutputStream());
  result.SetStatus(eReturnStatusSuccessFinishResult);
  return true;
}
5004};

5006class CommandObjectRenderScriptRuntimeReduction
  : public CommandObjectMultiword {
5008public:
CommandObjectRenderScriptRuntimeReduction(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "renderscript reduction",
                             "Commands that handle general reduction kernels",
                             nullptr) {
  LoadSubCommand(
      "breakpoint",
      CommandObjectSP(new CommandObjectRenderScriptRuntimeReductionBreakpoint(
          interpreter)));
}
~CommandObjectRenderScriptRuntimeReduction() override = default;
5019};

5021class CommandObjectRenderScriptRuntime : public CommandObjectMultiword {
5022public:
CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "renderscript",
          "Commands for operating on the RenderScript runtime.",
          "renderscript <subcommand> [<subcommand-options>]") {
  LoadSubCommand(
      "module", CommandObjectSP(
                    new CommandObjectRenderScriptRuntimeModule(interpreter)));
  LoadSubCommand(
      "status", CommandObjectSP(
                    new CommandObjectRenderScriptRuntimeStatus(interpreter)));
  LoadSubCommand(
      "kernel", CommandObjectSP(
                    new CommandObjectRenderScriptRuntimeKernel(interpreter)));
  LoadSubCommand("context",
                 CommandObjectSP(new CommandObjectRenderScriptRuntimeContext(
                     interpreter)));
  LoadSubCommand(
      "allocation",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeAllocation(interpreter)));
  LoadSubCommand("scriptgroup",
                 NewCommandObjectRenderScriptScriptGroup(interpreter));
  LoadSubCommand(
      "reduction",
      CommandObjectSP(
          new CommandObjectRenderScriptRuntimeReduction(interpreter)));
}

~CommandObjectRenderScriptRuntime() override = default;
5053};

5055void RenderScriptRuntime::Initiate() { assert(!m_initiated)(static_cast <bool> (!m_initiated) ? void (0) : __assert_fail
 ("!m_initiated", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp"
, 5055, __extension__ __PRETTY_FUNCTION__)); }

5057RenderScriptRuntime::RenderScriptRuntime(Process *process)
  : lldb_private::CPPLanguageRuntime(process), m_initiated(false),
    m_debuggerPresentFlagged(false), m_breakAllKernels(false),
    m_ir_passes(nullptr) {
ModulesDidLoad(process->GetTarget().GetImages());
5062}

5064lldb::CommandObjectSP RenderScriptRuntime::GetCommandObject(
  lldb_private::CommandInterpreter &interpreter) {
return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter));
5067}

5069RenderScriptRuntime::~RenderScriptRuntime() = default;

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/shared_ptr.h

→

1// shared_ptr and weak_ptr implementation -*- C++ -*-

3// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_H1
50#define _SHARED_PTR_H1 1

52#include <bits/shared_ptr_base.h>

54namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
55{
56_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

/// 20.7.2.2.11 shared_ptr I/O
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
  inline std::basic_ostream<_Ch, _Tr>&
  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
      const __shared_ptr<_Tp, _Lp>& __p)
  {
    __os << __p.get();
    return __os;
  }

/// 20.7.2.2.10 shared_ptr get_deleter
template<typename _Del, typename _Tp, _Lock_policy _Lp>
  inline _Del*
  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
  {
78#if __cpp_rtti199711
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
80#else
    return 0;
82#endif
  }


/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 *  The object pointed to is deleted when the last shared_ptr pointing to
 *  it is destroyed or reset.
*/
template<typename _Tp>
  class shared_ptr : public __shared_ptr<_Tp>
  {
    template<typename... _Args>
using _Constructible = typename enable_if<
 is_constructible<__shared_ptr<_Tp>, _Args...>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
>::type;

  public:

    using element_type = typename __shared_ptr<_Tp>::element_type;

109#if __cplusplus201103L > 201402L
110# define __cpp_lib_shared_ptr_weak_type 201606
    using weak_type = weak_ptr<_Tp>;
112#endif
    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count()==0 && get()==0
     */
    constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

    shared_ptr(const shared_ptr&) noexcept = default;

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
     *  @param  __p  A pointer that is convertible to element_type*.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
     */
    template<typename _Yp, typename = _Constructible<_Yp*>>
explicit
shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter,
      typename = _Constructible<_Yp*, _Deleter>>
shared_ptr(_Yp* __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _Constructible<_Yp*, _Deleter, _Alloc>>
shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    // Aliasing constructor

    /**
     *  @brief  Constructs a %shared_ptr instance that stores @a __p
     *          and shares ownership with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @param  __p  A pointer that will remain valid while @a *__r is valid.
     *  @post   get() == __p && use_count() == __r.use_count()
     *
     *  This can be used to construct a @c shared_ptr to a sub-object
     *  of an object managed by an existing @c shared_ptr.
     *
     * @code
     * shared_ptr< pair<int,int> > pii(new pair<int,int>());
     * shared_ptr<int> pi(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }

    /**
     *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
     *          otherwise construct a %shared_ptr that shares ownership
     *          with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @post   get() == __r.get() && use_count() == __r.use_count()
     */
    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
shared_ptr(const shared_ptr<_Yp>& __r) noexcept
      : __shared_ptr<_Tp>(__r) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    shared_ptr(shared_ptr&& __r) noexcept
    : __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
shared_ptr(shared_ptr<_Yp>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
     *          and stores a copy of the pointer stored in @a __r.
     *  @param  __r  A weak_ptr.
     *  @post   use_count() == __r.use_count()
     *  @throw  bad_weak_ptr when __r.expired(),
     *          in which case the constructor has no effect.
     */
    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __shared_ptr<_Tp>(__r) { }

268#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
271#endif

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2399. shared_ptr's constructor from unique_ptr should be constrained
    template<typename _Yp, typename _Del,
      typename = _Constructible<unique_ptr<_Yp, _Del>>>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }

280#if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1
    // This non-standard constructor exists to support conversions that
    // were possible in C++11 and C++14 but are ill-formed in C++17.
    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
_Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
288#endif

    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count() == 0 && get() == nullptr
     */
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

    shared_ptr& operator=(const shared_ptr&) noexcept = default;
13
←
Calling defaulted copy assignment operator for '__shared_ptr'→
30
←
Returning; memory was released→
41
←
Calling defaulted copy assignment operator for '__shared_ptr'→

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(__r);
 return *this;
}

306#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
314#endif

    shared_ptr&
    operator=(shared_ptr&& __r) noexcept
    {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
    }

    template<class _Yp>
_Assignable<shared_ptr<_Yp>>
operator=(shared_ptr<_Yp>&& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    template<typename _Yp, typename _Del>
_Assignable<unique_ptr<_Yp, _Del>>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

  private:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
   _Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }

    template<typename _Yp, typename _Alloc, typename... _Args>
friend shared_ptr<_Yp>
allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is non-standard, it is used by weak_ptr::lock().
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
    : __shared_ptr<_Tp>(__r, std::nothrow) { }

    friend class weak_ptr<_Tp>;
  };

358#if __cpp_deduction_guides >= 201606
template<typename _Tp>
  shared_ptr(weak_ptr<_Tp>) ->  shared_ptr<_Tp>;
template<typename _Tp, typename _Del>
  shared_ptr(unique_ptr<_Tp, _Del>) ->  shared_ptr<_Tp>;
363#endif

// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp, typename _Up>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp>
  inline bool
  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp>
  inline bool
  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    using _Up_elt = typename shared_ptr<_Up>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp>
  inline bool
  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp, typename _Up>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  inline bool
  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, typename _Up>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp>
  inline bool
  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp, typename _Up>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp>
  inline bool
  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts.
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

504#if __cplusplus201103L > 201402L
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
512#endif

/**
 *  @brief  A smart pointer with weak semantics.
 *
 *  With forwarding constructors and assignment operators.
 */
template<typename _Tp>
  class weak_ptr : public __weak_ptr<_Tp>
  {
    template<typename _Arg>
using _Constructible = typename enable_if<
 is_constructible<__weak_ptr<_Tp>, _Arg>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
>::type;

  public:
    constexpr weak_ptr() noexcept = default;

    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(const weak_ptr&) noexcept = default;

    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
weak_ptr(const weak_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(weak_ptr&&) noexcept = default;

    template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }

    weak_ptr&
    operator=(const weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<const weak_ptr<_Yp>&>
operator=(const weak_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    weak_ptr&
    operator=(weak_ptr&& __r) noexcept = default;

    template<typename _Yp>
_Assignable<weak_ptr<_Yp>>
operator=(weak_ptr<_Yp>&& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    shared_ptr<_Tp>
    lock() const noexcept
    { return shared_ptr<_Tp>(*this, std::nothrow); }
  };

587#if __cpp_deduction_guides >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
590#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }


/// Primary template owner_less
template<typename _Tp = void>
  struct owner_less;

/// Void specialization of owner_less
template<>
  struct owner_less<void> : _Sp_owner_less<void, void>
  { };

/// Partial specialization of owner_less for shared_ptr.
template<typename _Tp>
  struct owner_less<shared_ptr<_Tp>>
  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
  { };

/// Partial specialization of owner_less for weak_ptr.
template<typename _Tp>
  struct owner_less<weak_ptr<_Tp>>
  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
  { };

/**
 *  @brief Base class allowing use of member function shared_from_this.
 */
template<typename _Tp>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept { }

    enable_shared_from_this(const enable_shared_from_this&) noexcept { }

    enable_shared_from_this&
    operator=(const enable_shared_from_this&) noexcept
    { return *this; }

    ~enable_shared_from_this() { }

  public:
    shared_ptr<_Tp>
    shared_from_this()
    { return shared_ptr<_Tp>(this->_M_weak_this); }

    shared_ptr<const _Tp>
    shared_from_this() const
    { return shared_ptr<const _Tp>(this->_M_weak_this); }

646#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
647#define __cpp_lib_enable_shared_from_this 201603
    weak_ptr<_Tp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    weak_ptr<const _Tp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
655#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    // Found by ADL when this is an associated class.
    friend const enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<>&,
		     const enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable weak_ptr<_Tp>  _M_weak_this;
  };

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __a     An allocator.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  An exception thrown from @a _Alloc::allocate or from the
 *          constructor of @a _Tp.
 *
 *  A copy of @a __a will be used to allocate memory for the shared_ptr
 *  and the new object.
 */
template<typename _Tp, typename _Alloc, typename... _Args>
  inline shared_ptr<_Tp>
  allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
	     std::forward<_Args>(__args)...);
  }

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  std::bad_alloc, or an exception thrown from the
 *          constructor of @a _Tp.
 */
template<typename _Tp, typename... _Args>
  inline shared_ptr<_Tp>
  make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
		       std::forward<_Args>(__args)...);
  }

/// std::hash specialization for shared_ptr.
template<typename _Tp>
  struct hash<shared_ptr<_Tp>>
  : public __hash_base<size_t, shared_ptr<_Tp>>
  {
    size_t
    operator()(const shared_ptr<_Tp>& __s) const noexcept
    {
return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
    }
  };

// @} group pointer_abstractions

724_GLIBCXX_END_NAMESPACE_VERSION
725} // namespace

727#endif // _SHARED_PTR_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/shared_ptr_base.h

→

1// shared_ptr and weak_ptr implementation details -*- C++ -*-

3// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file bits/shared_ptr_base.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_BASE_H1
50#define _SHARED_PTR_BASE_H1 1

52#if __cpp_rtti199711
53# include <typeinfo>
54#endif
55#include <bits/allocated_ptr.h>
56#include <bits/refwrap.h>
57#include <bits/stl_function.h>
58#include <ext/aligned_buffer.h>

60namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
61{
62_GLIBCXX_BEGIN_NAMESPACE_VERSION

64#if _GLIBCXX_USE_DEPRECATED1
template<typename> class auto_ptr;
66#endif

/**
 *  @brief  Exception possibly thrown by @c shared_ptr.
 *  @ingroup exceptions
 */
class bad_weak_ptr : public std::exception
{
public:
  virtual char const* what() const noexcept;

  virtual ~bad_weak_ptr() noexcept;
};

// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
inline void
__throw_bad_weak_ptr()
{ _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(__builtin_abort()); }

using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;

// Empty helper class except when the template argument is _S_mutex.
template<_Lock_policy _Lp>
  class _Mutex_base
  {
  protected:
    // The atomic policy uses fully-fenced builtins, single doesn't care.
    enum { _S_need_barriers = 0 };
  };

template<>
  class _Mutex_base<_S_mutex>
  : public __gnu_cxx::__mutex
  {
  protected:
    // This policy is used when atomic builtins are not available.
    // The replacement atomic operations might not have the necessary
    // memory barriers.
    enum { _S_need_barriers = 1 };
  };

template<_Lock_policy _Lp = __default_lock_policy>
  class _Sp_counted_base
  : public _Mutex_base<_Lp>
  {
  public:
    _Sp_counted_base() noexcept
    : _M_use_count(1), _M_weak_count(1) { }

    virtual
    ~_Sp_counted_base() noexcept
    { }

    // Called when _M_use_count drops to zero, to release the resources
    // managed by *this.
    virtual void
    _M_dispose() noexcept = 0;

    // Called when _M_weak_count drops to zero.
    virtual void
    _M_destroy() noexcept
    { delete this; }
26
←
Memory is released→

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept = 0;

    void
    _M_add_ref_copy()
    { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

    void
    _M_add_ref_lock();

    bool
    _M_add_ref_lock_nothrow();

    void
    _M_release() noexcept
    {
      // Be race-detector-friendly.  For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
20
←
Assuming the condition is true→
21
←
Taking true branch→
47
←
Calling '__exchange_and_add_dispatch'→
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
   _M_dispose();
   // There must be a memory barrier between dispose() and destroy()
   // to ensure that the effects of dispose() are observed in the
   // thread that runs destroy().
   // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
   if (_Mutex_base<_Lp>::_S_need_barriers)
22
←
Taking false branch→
     {
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }

          // Be race-detector-friendly.  For more info see bits/c++config.
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
23
←
Assuming the condition is true→
24
←
Taking true branch→
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
25
←
Calling '_Sp_counted_base::_M_destroy'→
27
←
Returning; memory was released→
            }
 }
    }

    void
    _M_weak_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

    void
    _M_weak_release() noexcept
    {
      // Be race-detector-friendly. For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
       // See _M_release(),
       // destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }
   _M_destroy();
 }
    }

    long
    _M_get_use_count() const noexcept
    {
      // No memory barrier is used here so there is no synchronization
      // with other threads.
      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0);
    }

  private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  };

template<>
  inline void
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock()
  {
    if (_M_use_count == 0)
__throw_bad_weak_ptr();
    ++_M_use_count;
  }

template<>
  inline void
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 __throw_bad_weak_ptr();
}
  }

template<>
  inline void
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   __throw_bad_weak_ptr();
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
  }

template<>
  inline bool
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock_nothrow()
  {
    if (_M_use_count == 0)
return false;
    ++_M_use_count;
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock_nothrow()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 return false;
}
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock_nothrow()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   return false;
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
    return true;
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_add_ref_copy()
  { ++_M_use_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_release() noexcept
  {
    if (--_M_use_count == 0)
      {
        _M_dispose();
        if (--_M_weak_count == 0)
          _M_destroy();
      }
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
  { ++_M_weak_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_release() noexcept
  {
    if (--_M_weak_count == 0)
      _M_destroy();
  }

template<>
  inline long
  _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
  { return _M_use_count; }


// Forward declarations.
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __shared_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __weak_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __enable_shared_from_this;

template<typename _Tp>
  class shared_ptr;

template<typename _Tp>
  class weak_ptr;

template<typename _Tp>
  struct owner_less;

template<typename _Tp>
  class enable_shared_from_this;

template<_Lock_policy _Lp = __default_lock_policy>
  class __weak_count;

template<_Lock_policy _Lp = __default_lock_policy>
  class __shared_count;


// Counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
  class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  {
  public:
    explicit
    _Sp_counted_ptr(_Ptr __p) noexcept
    : _M_ptr(__p) { }

    virtual void
    _M_dispose() noexcept
    { delete _M_ptr; }

    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept
    { return nullptr; }

    _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
    _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

  private:
    _Ptr             _M_ptr;
  };

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

template<int _Nm, typename _Tp,
  bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
  struct _Sp_ebo_helper;

/// Specialization using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
  };

/// Specialization not using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, false>
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh)
    { return __eboh._M_tp; }

  private:
    _Tp _M_tp;
  };

// Support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;

    public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
{ }

_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

_Ptr _M_ptr;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
    : _M_impl(__p, std::move(__d), _Alloc()) { }

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
    : _M_impl(__p, std::move(__d), __a) { }

    ~_Sp_counted_deleter() noexcept { }

    virtual void
    _M_dispose() noexcept
    { _M_impl._M_del()(_M_impl._M_ptr); }

    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
    }

    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
483#if __cpp_rtti199711
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
489#else
      return nullptr;
491#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag { };

template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Alloc>	_A_base;

    public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

    template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070.  allocate_shared should use allocator_traits<A>::construct
 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
     std::forward<_Args>(__args)...); // might throw
}

    ~_Sp_counted_ptr_inplace() noexcept { }

    virtual void
    _M_dispose() noexcept
    {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
    }

    // Override because the allocator needs to know the dynamic type
    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
    }

    // Sneaky trick so __shared_ptr can get the managed pointer
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
551#if __cpp_rtti199711
if (__ti == typeid(_Sp_make_shared_tag))
 return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
554#endif
return nullptr;
    }

  private:
    _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

    _Impl _M_impl;
  };

// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
{
  template<typename _Yp>
    void operator()(_Yp* __p) const { delete[] __p; }
};

template<_Lock_policy _Lp>
  class __shared_count
  {
  public:
    constexpr __shared_count() noexcept : _M_pi(0)
    { }

    template<typename _Ptr>
      explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
 __tryif (true)
   {
     _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
   }
 __catch(...)if (false)
   {
     delete __p;
     __throw_exception_again;
   }
}

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
{ }

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 __tryif (true)
   {
     typename _Sp_cd_type::__allocator_type __a2(__a);
     auto __guard = std::__allocate_guarded(__a2);
     _Sp_cd_type* __mem = __guard.get();
     ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
     _M_pi = __mem;
     __guard = nullptr;
   }
 __catch(...)if (false)
   {
     __d(__p); // Call _Deleter on __p.
     __throw_exception_again;
   }
}

    template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
       _Args&&... __args)
: _M_pi(0)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a);
 auto __guard = std::__allocate_guarded(__a2);
 _Sp_cp_type* __mem = __guard.get();
 ::new (__mem) _Sp_cp_type(std::move(__a),
		    std::forward<_Args>(__args)...);
 _M_pi = __mem;
 __guard = nullptr;
}

643#if _GLIBCXX_USE_DEPRECATED1
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
648#endif

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
      explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2415. Inconsistency between unique_ptr and shared_ptr
 if (__r.get() == nullptr)
   return;

 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
 using _Del2 = typename conditional<is_reference<_Del>::value,
     reference_wrapper<typename remove_reference<_Del>::type>,
     _Del>::type;
 using _Sp_cd_type
   = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
 using _Alloc = allocator<_Sp_cd_type>;
 using _Alloc_traits = allocator_traits<_Alloc>;
 _Alloc __a;
 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
 _Alloc_traits::construct(__a, __mem, __r.release(),
		   __r.get_deleter());  // non-throwing
 _M_pi = __mem;
}

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

    ~__shared_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_release();
    }

    __shared_count(const __shared_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != 0)
 _M_pi->_M_add_ref_copy();
    }

    __shared_count&
    operator=(const __shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
15
←
Taking true branch→
43
←
Taking true branch→
 {
   if (__tmp != 0)
16
←
Assuming '__tmp' is equal to null→
17
←
Taking false branch→
44
←
Taking false branch→
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
18
←
Taking true branch→
45
←
Taking true branch→
     _M_pi->_M_release();
19
←
Calling '_Sp_counted_base::_M_release'→
28
←
Returning; memory was released→
46
←
Calling '_Sp_counted_base::_M_release'→
   _M_pi = __tmp;
 }
return *this;
    }

    void
    _M_swap(__shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool
    _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __weak_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };


template<_Lock_policy _Lp>
  class __weak_count
  {
  public:
    constexpr __weak_count() noexcept : _M_pi(nullptr)
    { }

    __weak_count(const __shared_count<_Lp>& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(const __weak_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(__weak_count&& __r) noexcept
    : _M_pi(__r._M_pi)
    { __r._M_pi = nullptr; }

    ~__weak_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
    }

    __weak_count&
    operator=(const __shared_count<_Lp>& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(const __weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(__weak_count&& __r) noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __r._M_pi;
      __r._M_pi = nullptr;
return *this;
    }

    void
    _M_swap(__weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_less(const __weak_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __shared_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
    else
__throw_bad_weak_ptr();
  }

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::
  __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
  }

869#define __cpp_lib_shared_ptr_arrays201603 201603

// Helper traits for shared_ptr of array:

// A pointer type Y* is said to be compatible with a pointer type T* when
// either Y* is convertible to T* or Y is U[N] and T is U cv [].
template<typename _Yp_ptr, typename _Tp_ptr>
  struct __sp_compatible_with
  : false_type
  { };

template<typename _Yp, typename _Tp>
  struct __sp_compatible_with<_Yp*, _Tp*>
  : is_convertible<_Yp*, _Tp*>::type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
  : true_type
  { };

// Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
template<typename _Up, size_t _Nm, typename _Yp, typename = void>
  struct __sp_is_constructible_arrN
  : false_type
  { };

template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
  : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
  { };

// Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
template<typename _Up, typename _Yp, typename = void>
  struct __sp_is_constructible_arr
  : false_type
  { };

template<typename _Up, typename _Yp>
  struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
  : is_convertible<_Yp(*)[], _Up(*)[]>::type
  { };

// Trait to check if shared_ptr<T> can be constructed from Y*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible;

// When T is U[N], Y(*)[N] shall be convertible to T*;
template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible<_Up[_Nm], _Yp>
  : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
  { };

// when T is U[], Y(*)[] shall be convertible to T*;
template<typename _Up, typename _Yp>
  struct __sp_is_constructible<_Up[], _Yp>
  : __sp_is_constructible_arr<_Up, _Yp>::type
  { };

// otherwise, Y* shall be convertible to T*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible
  : is_convertible<_Yp*, _Tp*>::type
  { };


// Define operator* and operator-> for shared_ptr<T>.
template<typename _Tp, _Lock_policy _Lp,
  bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
  class __shared_ptr_access
  {
  public:
    using element_type = _Tp;

    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

// Define operator-> for shared_ptr<cv void>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, false, true>
  {
  public:
    using element_type = _Tp;

    element_type*
    operator->() const noexcept
    {
auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
_GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
return __ptr;
    }
  };

// Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, true, false>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

1001#if __cplusplus201103L <= 201402L
    [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }
1017#endif

    element_type&
    operator[](ptrdiff_t __i) const
    {
__glibcxx_assert(_M_get() != nullptr);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value);
return _M_get()[__i];
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr
  : public __shared_ptr_access<_Tp, _Lp>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

  private:
    // Constraint for taking ownership of a pointer of type _Yp*:
    template<typename _Yp>
using _SafeConv
 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

    // Constraint for construction from shared_ptr and weak_ptr:
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __shared_ptr&>;

    // Constraint for construction from unique_ptr:
    template<typename _Yp, typename _Del, typename _Res = void,
      typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
using _UniqCompatible = typename enable_if<__and_<
 __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
 >::value, _Res>::type;

    // Constraint for assignment from unique_ptr:
    template<typename _Yp, typename _Del>
using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

  public:

1068#if __cplusplus201103L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1070#endif

    constexpr __shared_ptr() noexcept
    : _M_ptr(0), _M_refcount()
    { }

    template<typename _Yp, typename = _SafeConv<_Yp>>
explicit
__shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
{
 static_assert( !is_void<_Yp>::value, "incomplete type" );
 static_assert( sizeof(_Yp) > 0, "incomplete type" );
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, std::move(__d))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, std::move(__d))
{ }

    template<typename _Deleter, typename _Alloc>
      __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
{ }

    template<typename _Yp>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
14
←
Calling copy assignment operator for '__shared_count'→
29
←
Returning; memory was released→
42
←
Calling copy assignment operator for '__shared_count'→
    ~__shared_ptr() = default;

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __shared_ptr(__shared_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount()
    {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
    }

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    template<typename _Yp, typename = _Compatible<_Yp>>
explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
: _M_refcount(__r._M_refcount) // may throw
{
 // It is now safe to copy __r._M_ptr, as
 // _M_refcount(__r._M_refcount) did not throw.
 _M_ptr = __r._M_ptr;
}

    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
      typename = _UniqCompatible<_Yp, _Del>>
__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1165#if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1
  protected:
    // If an exception is thrown this constructor has no effect.
    template<typename _Tp1, typename _Del,
      typename enable_if<__and_<
 __not_<is_array<_Tp>>, is_array<_Tp1>,
        is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
      >::value, bool>::type = true>
__shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1181#endif

1183#if _GLIBCXX_USE_DEPRECATED1
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1187#endif

    constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 return *this;
}

1200#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1208#endif

    __shared_ptr&
    operator=(__shared_ptr&& __r) noexcept
    {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
    }

    template<class _Yp>
_Assignable<_Yp>
operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    template<typename _Yp, typename _Del>
_UniqAssignable<_Yp, _Del>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    void
    reset() noexcept
    { __shared_ptr().swap(*this); }

    template<typename _Yp>
_SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
 // Catch self-reset errors.
 __glibcxx_assert(__p == 0 || __p != _M_ptr);
 __shared_ptr(__p).swap(*this);
}

    template<typename _Yp, typename _Deleter>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d)
{ __shared_ptr(__p, std::move(__d)).swap(*this); }

    template<typename _Yp, typename _Deleter, typename _Alloc>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d, _Alloc __a)
      { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }

    element_type*
    get() const noexcept
    { return _M_ptr; }

    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

1288#if __cpp_rtti199711
  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
		std::forward<_Args>(__args)...)
{
 // _M_ptr needs to point to the newly constructed object.
 // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
 void* __p = _M_refcount._M_get_deleter(typeid(__tag));
 _M_ptr = static_cast<_Tp*>(__p);
 _M_enable_shared_from_this_with(_M_ptr);
}
1303#else
    template<typename _Alloc>
      struct _Deleter
      {
        void operator()(typename _Alloc::value_type* __ptr)
        {
   __allocated_ptr<_Alloc> __guard{ _M_alloc, __ptr };
   allocator_traits<_Alloc>::destroy(_M_alloc, __guard.get());
        }
        _Alloc _M_alloc;
      };

    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount()
{
 typedef typename allocator_traits<_Alloc>::template
   rebind_traits<typename std::remove_cv<_Tp>::type> __traits;
 _Deleter<typename __traits::allocator_type> __del = { __a };
 auto __guard = std::__allocate_guarded(__del._M_alloc);
 auto __ptr = __guard.get();
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070. allocate_shared should use allocator_traits<A>::construct
 __traits::construct(__del._M_alloc, __ptr,
	      std::forward<_Args>(__args)...);
 __guard = nullptr;
 __shared_count<_Lp> __count(__ptr, __del, __del._M_alloc);
 _M_refcount._M_swap(__count);
 _M_ptr = __ptr;
 _M_enable_shared_from_this_with(_M_ptr);
}
1335#endif

    template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
      typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is used by __weak_ptr::lock() and
    // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
    : _M_refcount(__r._M_refcount, std::nothrow)
    {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }

    friend class __weak_ptr<_Tp, _Lp>;

  private:

    template<typename _Yp>
using __esft_base_t = decltype(__enable_shared_from_this_base(
     std::declval<const __shared_count<_Lp>&>(),
     std::declval<_Yp*>()));

    // Detect an accessible and unambiguous enable_shared_from_this base.
    template<typename _Yp, typename = void>
struct __has_esft_base
: false_type { };

    template<typename _Yp>
struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
: __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
   __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_refcount._M_get_deleter(__ti); }

    template<typename _Tp1>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }

    template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

    template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

    element_type*	   _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.
  };


// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !__a; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a,
     const __shared_ptr<_Up, _Lp>& __b) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp1, _Lp>& __a,
     const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Sp>
  struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  {
    bool
    operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
    {
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
    }
  };

template<typename _Tp, _Lock_policy _Lp>
  struct less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// static_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// const_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// dynamic_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

1579#if __cplusplus201103L > 201402L
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
1587#endif

template<typename _Tp, _Lock_policy _Lp>
  class __weak_ptr
  {
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __weak_ptr&>;

  public:
    using element_type = typename remove_extent<_Tp>::type;

    constexpr __weak_ptr() noexcept
    : _M_ptr(nullptr), _M_refcount()
    { }

    __weak_ptr(const __weak_ptr&) noexcept = default;

    ~__weak_ptr() = default;

    // The "obvious" converting constructor implementation:
    //
    //  template<typename _Tp1>
    //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
    //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
    //    { }
    //
    // has a serious problem.
    //
    //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
    //  conversion may require access to *__r._M_ptr (virtual inheritance).
    //
    // It is not possible to avoid spurious access violations since
    // in multithreaded programs __r._M_ptr may be invalidated at any point.
    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
      { _M_ptr = __r.lock().get(); }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __weak_ptr(__weak_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
    { __r._M_ptr = nullptr; }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

    __weak_ptr&
    operator=(const __weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = __r._M_refcount;
 return *this;
}

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount;
 return *this;
}

    __weak_ptr&
    operator=(__weak_ptr&& __r) noexcept
    {
_M_ptr = __r._M_ptr;
_M_refcount = std::move(__r._M_refcount);
__r._M_ptr = nullptr;
return *this;
    }

    template<typename _Yp>
_Assignable<_Yp>
operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
}

    __shared_ptr<_Tp, _Lp>
    lock() const noexcept
    { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    bool
    expired() const noexcept
    { return _M_refcount._M_get_use_count() == 0; }

    template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    void
    reset() noexcept
    { __weak_ptr().swap(*this); }

    void
    swap(__weak_ptr& __s) noexcept
    {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
    }

  private:
    // Used by __enable_shared_from_this.
    void
    _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    {
if (use_count() == 0)
 {
   _M_ptr = __ptr;
   _M_refcount = __refcount;
 }
    }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    friend class __enable_shared_from_this<_Tp, _Lp>;
    friend class enable_shared_from_this<_Tp>;

    element_type*	 _M_ptr;         // Contained pointer.
    __weak_count<_Lp>  _M_refcount;    // Reference counter.
  };

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

template<typename _Tp, typename _Tp1>
  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  {
    bool
    operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }
  };

template<>
  struct _Sp_owner_less<void, void>
  {
    template<typename _Tp, typename _Up>
auto
operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
-> decltype(__lhs.owner_before(__rhs))
{ return __lhs.owner_before(__rhs); }

    using is_transparent = void;
  };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  { };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__weak_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  { };


template<typename _Tp, _Lock_policy _Lp>
  class __enable_shared_from_this
  {
  protected:
    constexpr __enable_shared_from_this() noexcept { }

    __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

    __enable_shared_from_this&
    operator=(const __enable_shared_from_this&) noexcept
    { return *this; }

    ~__enable_shared_from_this() { }

  public:
    __shared_ptr<_Tp, _Lp>
    shared_from_this()
    { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

    __shared_ptr<const _Tp, _Lp>
    shared_from_this() const
    { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

1806#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
    __weak_ptr<_Tp, _Lp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    __weak_ptr<const _Tp, _Lp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
1814#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    friend const __enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<_Lp>&,
		     const __enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  };

template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
			      std::forward<_Args>(__args)...);
  }

/// std::hash specialization for __shared_ptr.
template<typename _Tp, _Lock_policy _Lp>
  struct hash<__shared_ptr<_Tp, _Lp>>
  : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  {
    size_t
    operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
    {
return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
   __s.get());
    }
  };

1863_GLIBCXX_END_NAMESPACE_VERSION
1864} // namespace

1866#endif // _SHARED_PTR_BASE_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ext/atomicity.h

1// Support for atomic operations -*- C++ -*-
2 
3// Copyright (C) 2004-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10 
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.
15 
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19 
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.
24 
25/** @file ext/atomicity.h
26 *  This file is a GNU extension to the Standard C++ Library.
27 */
28 
29#ifndef _GLIBCXX_ATOMICITY_H1
30#define _GLIBCXX_ATOMICITY_H1	1
31 
32#pragma GCC system_header
33 
34#include <bits/c++config.h>
35#include <bits/gthr.h>
36#include <bits/atomic_word.h>
37 
38namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION
41 
42  // Functions for portable atomic access.
43  // To abstract locking primitives across all thread policies, use:
44  // __exchange_and_add_dispatch
45  // __atomic_add_dispatch
46#ifdef _GLIBCXX_ATOMIC_BUILTINS1
47  static inline _Atomic_word 
48  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
49  { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
50 
51  static inline void
52  __atomic_add(volatile _Atomic_word* __mem, int __val)
53  { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
54#else
55  _Atomic_word
56  __attribute__ ((__unused__))
57  __exchange_and_add(volatile _Atomic_word*, int) throw ();
58 
59  void
60  __attribute__ ((__unused__))
61  __atomic_add(volatile _Atomic_word*, int) throw ();
62#endif
63 
64  static inline _Atomic_word
65  __exchange_and_add_single(_Atomic_word* __mem, int __val)
66  {
67    _Atomic_word __result = *__mem;
50
←
Use of memory after it is freed
68    *__mem += __val;
69    return __result;
70  }
71 
72  static inline void
73  __atomic_add_single(_Atomic_word* __mem, int __val)
74  { *__mem += __val; }
75 
76  static inline _Atomic_word
77  __attribute__ ((__unused__))
78  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
79  {
80#ifdef __GTHREADS1
81    if (__gthread_active_p())
48
←
Taking false branch→
82      return __exchange_and_add(__mem, __val);
83    else
84      return __exchange_and_add_single(__mem, __val);
49
←
Calling '__exchange_and_add_single'→
85#else
86    return __exchange_and_add_single(__mem, __val);
87#endif
88  }
89 
90  static inline void
91  __attribute__ ((__unused__))
92  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
93  {
94#ifdef __GTHREADS1
95    if (__gthread_active_p())
96      __atomic_add(__mem, __val);
97    else
98      __atomic_add_single(__mem, __val);
99#else
100    __atomic_add_single(__mem, __val);
101#endif
102  }
103 
104_GLIBCXX_END_NAMESPACE_VERSION
105} // namespace
106 
107// Even if the CPU doesn't need a memory barrier, we need to ensure
108// that the compiler doesn't reorder memory accesses across the
109// barriers.
110#ifndef _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2)
111#define _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2) __atomic_thread_fence (__ATOMIC_ACQUIRE2)
112#endif
113#ifndef _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3)
114#define _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3) __atomic_thread_fence (__ATOMIC_RELEASE3)
115#endif
116 
117#endif 