Scalar.cpp | Explore in Territory

//===-- Scalar.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/Utility/Scalar.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"

#include <cinttypes>
#include <cstdio>

usingnamespacelldb;
usingnamespacelldb_private;

APFloat;
APInt;
APSInt;

Scalar::PromotionKey Scalar::GetPromoKey() const { … }

Scalar::PromotionKey Scalar::GetFloatPromoKey(const llvm::fltSemantics &sem) { … }

// Promote to max type currently follows the ANSI C rule for type promotion in
// expressions.
Scalar::Type Scalar::PromoteToMaxType(Scalar &lhs, Scalar &rhs) { … }

bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const { … }

void Scalar::GetBytes(llvm::MutableArrayRef<uint8_t> storage) const { … }

size_t Scalar::GetByteSize() const { … }

bool Scalar::IsZero() const { … }

void Scalar::GetValue(Stream &s, bool show_type) const { … }

void Scalar::TruncOrExtendTo(uint16_t bits, bool sign) { … }

bool Scalar::IntegralPromote(uint16_t bits, bool sign) { … }

bool Scalar::FloatPromote(const llvm::fltSemantics &semantics) { … }

const char *Scalar::GetValueTypeAsCString(Scalar::Type type) { … }

bool Scalar::IsSigned() const { … }

bool Scalar::MakeSigned() { … }

bool Scalar::MakeUnsigned() { … }

static llvm::APInt ToAPInt(const llvm::APFloat &f, unsigned bits,
                           bool is_unsigned) { … }

template <typename T> T Scalar::GetAs(T fail_value) const { … }

signed char Scalar::SChar(signed char fail_value) const { … }

unsigned char Scalar::UChar(unsigned char fail_value) const { … }

short Scalar::SShort(short fail_value) const { … }

unsigned short Scalar::UShort(unsigned short fail_value) const { … }

int Scalar::SInt(int fail_value) const { … }

unsigned int Scalar::UInt(unsigned int fail_value) const { … }

long Scalar::SLong(long fail_value) const { … }

unsigned long Scalar::ULong(unsigned long fail_value) const { … }

long long Scalar::SLongLong(long long fail_value) const { … }

unsigned long long Scalar::ULongLong(unsigned long long fail_value) const { … }

llvm::APInt Scalar::SInt128(const llvm::APInt &fail_value) const { … }

llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const { … }

float Scalar::Float(float fail_value) const { … }

double Scalar::Double(double fail_value) const { … }

long double Scalar::LongDouble(long double fail_value) const { … }

Scalar &Scalar::operator+=(Scalar rhs) { … }

Scalar &Scalar::operator<<=(const Scalar &rhs) { … }

bool Scalar::ShiftRightLogical(const Scalar &rhs) { … }

Scalar &Scalar::operator>>=(const Scalar &rhs) { … }

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

bool Scalar::AbsoluteValue() { … }

bool Scalar::UnaryNegate() { … }

bool Scalar::OnesComplement() { … }

const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) { … }

const Scalar lldb_private::operator-(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator/(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator*(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator&(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator|(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator%(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator^(Scalar lhs, Scalar rhs) { … }

const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) { … }

const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) { … }

Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
                                   size_t byte_size) { … }

Status Scalar::SetValueFromData(const DataExtractor &data,
                                lldb::Encoding encoding, size_t byte_size) { … }

bool Scalar::SignExtend(uint32_t sign_bit_pos) { … }

size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
                               lldb::ByteOrder dst_byte_order,
                               Status &error) const { … }

bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) { … }

llvm::APFloat Scalar::CreateAPFloatFromAPSInt(lldb::BasicType basic_type) { … }

llvm::APFloat Scalar::CreateAPFloatFromAPFloat(lldb::BasicType basic_type) { … }

APFloat::cmpResult lldb_private::compare(Scalar lhs, Scalar rhs) { … }

bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) { … }

bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) { … }

bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) { … }

bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) { … }

bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) { … }

bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) { … }

bool Scalar::ClearBit(uint32_t bit) { … }

bool Scalar::SetBit(uint32_t bit) { … }

llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) { … }
llvm/lldb/source/Utility/Scalar.cpp
