SBData.cpp | Explore in Territory

//===-- SBData.cpp --------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/API/SBData.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Instrumentation.h"

#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"

#include <cinttypes>
#include <memory>

usingnamespacelldb;
usingnamespacelldb_private;

SBData::SBData() : … { … }

SBData::SBData(const lldb::DataExtractorSP &data_sp) : … { … }

SBData::SBData(const SBData &rhs) : … { … }

const SBData &SBData::operator=(const SBData &rhs) { … }

SBData::~SBData() = default;

void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) { … }

lldb_private::DataExtractor *SBData::get() const { … }

lldb_private::DataExtractor *SBData::operator->() const { … }

lldb::DataExtractorSP &SBData::operator*() { … }

const lldb::DataExtractorSP &SBData::operator*() const { … }

bool SBData::IsValid() { … }
operator bool()

uint8_t SBData::GetAddressByteSize() { … }

void SBData::SetAddressByteSize(uint8_t addr_byte_size) { … }

void SBData::Clear() { … }

size_t SBData::GetByteSize() { … }

lldb::ByteOrder SBData::GetByteOrder() { … }

void SBData::SetByteOrder(lldb::ByteOrder endian) { … }

float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { … }

double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { … }

long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) { … }

lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { … }

uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) { … }

uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) { … }

uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) { … }

uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) { … }

int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) { … }

int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) { … }

int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) { … }

int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) { … }

const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) { … }

bool SBData::GetDescription(lldb::SBStream &description,
                            lldb::addr_t base_addr) { … }

size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
                           void *buf, size_t size) { … }

void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
                     lldb::ByteOrder endian, uint8_t addr_size) { … }

void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
                                  size_t size, lldb::ByteOrder endian,
                                  uint8_t addr_size) { … }

bool SBData::Append(const SBData &rhs) { … }

lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
                                           uint32_t addr_byte_size,
                                           const char *data) { … }

lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
                                               uint32_t addr_byte_size,
                                               uint64_t *array,
                                               size_t array_len) { … }

lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
                                               uint32_t addr_byte_size,
                                               uint32_t *array,
                                               size_t array_len) { … }

lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
                                               uint32_t addr_byte_size,
                                               int64_t *array,
                                               size_t array_len) { … }

lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
                                               uint32_t addr_byte_size,
                                               int32_t *array,
                                               size_t array_len) { … }

lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
                                               uint32_t addr_byte_size,
                                               double *array,
                                               size_t array_len) { … }

bool SBData::SetDataFromCString(const char *data) { … }

bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { … }

bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { … }

bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { … }

bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { … }

bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { … }
llvm/lldb/source/API/SBData.cpp
