llvm/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

//===-- DWARFExpression.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 "llvm/DebugInfo/DWARF/DWARFExpression.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
#include "llvm/Support/Format.h"
#include <cassert>
#include <cstdint>
#include <vector>

usingnamespacellvm;
usingnamespacedwarf;

namespace llvm {

Op;
Desc;

static std::vector<Desc> getOpDescriptions() { … }

static Desc getDescImpl(ArrayRef<Desc> Descriptions, unsigned Opcode) { … }

static Desc getOpDesc(unsigned Opcode) { … }

static std::vector<Desc> getSubOpDescriptions() { … }

static Desc getSubOpDesc(unsigned Opcode, unsigned SubOpcode) { … }

bool DWARFExpression::Operation::extract(DataExtractor Data,
                                         uint8_t AddressSize, uint64_t Offset,
                                         std::optional<DwarfFormat> Format) { … }

static void prettyPrintBaseTypeRef(DWARFUnit *U, raw_ostream &OS,
                                   DIDumpOptions DumpOpts,
                                   ArrayRef<uint64_t> Operands,
                                   unsigned Operand) { … }

bool DWARFExpression::prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
                                            DIDumpOptions DumpOpts,
                                            uint8_t Opcode,
                                            ArrayRef<uint64_t> Operands) { … }

std::optional<unsigned> DWARFExpression::Operation::getSubCode() const { … }

bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
                                       const DWARFExpression *Expr,
                                       DWARFUnit *U) const { … }

void DWARFExpression::print(raw_ostream &OS, DIDumpOptions DumpOpts,
                            DWARFUnit *U, bool IsEH) const { … }

bool DWARFExpression::Operation::verify(const Operation &Op, DWARFUnit *U) { … }

bool DWARFExpression::verify(DWARFUnit *U) { … }

/// A user-facing string representation of a DWARF expression. This might be an
/// Address expression, in which case it will be implicitly dereferenced, or a
/// Value expression.
struct PrintedExpr { … };

static bool printCompactDWARFExpr(
    raw_ostream &OS, DWARFExpression::iterator I,
    const DWARFExpression::iterator E,
    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg =
        nullptr) { … }

bool DWARFExpression::printCompact(
    raw_ostream &OS,
    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) { … }

bool DWARFExpression::operator==(const DWARFExpression &RHS) const { … }

} // namespace llvm