llvm/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

//===- llvm/CodeGen/DwarfExpression.cpp - Dwarf Debug Framework -----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file contains support for writing dwarf debug info into asm files.
//
//===----------------------------------------------------------------------===//

#include "DwarfExpression.h"
#include "DwarfCompileUnit.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/CodeGen/Register.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>

usingnamespacellvm;

#define DEBUG_TYPE …

void DwarfExpression::emitConstu(uint64_t Value) { … }

void DwarfExpression::addReg(int64_t DwarfReg, const char *Comment) { … }

void DwarfExpression::addBReg(int64_t DwarfReg, int64_t Offset) { … }

void DwarfExpression::addFBReg(int64_t Offset) { … }

void DwarfExpression::addOpPiece(unsigned SizeInBits, unsigned OffsetInBits) { … }

void DwarfExpression::addShr(unsigned ShiftBy) { … }

void DwarfExpression::addAnd(unsigned Mask) { … }

bool DwarfExpression::addMachineReg(const TargetRegisterInfo &TRI,
                                    llvm::Register MachineReg,
                                    unsigned MaxSize) { … }

void DwarfExpression::addStackValue() { … }

void DwarfExpression::addSignedConstant(int64_t Value) { … }

void DwarfExpression::addUnsignedConstant(uint64_t Value) { … }

void DwarfExpression::addUnsignedConstant(const APInt &Value) { … }

void DwarfExpression::addConstantFP(const APFloat &APF, const AsmPrinter &AP) { … }

bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
                                              DIExpressionCursor &ExprCursor,
                                              llvm::Register MachineReg,
                                              unsigned FragmentOffsetInBits) { … }

void DwarfExpression::setEntryValueFlags(const MachineLocation &Loc) { … }

void DwarfExpression::setLocation(const MachineLocation &Loc,
                                  const DIExpression *DIExpr) { … }

void DwarfExpression::beginEntryValueExpression(
    DIExpressionCursor &ExprCursor) { … }

void DwarfExpression::finalizeEntryValue() { … }

void DwarfExpression::cancelEntryValue() { … }

unsigned DwarfExpression::getOrCreateBaseType(unsigned BitSize,
                                              dwarf::TypeKind Encoding) { … }

/// Assuming a well-formed expression, match "DW_OP_deref*
/// DW_OP_LLVM_fragment?".
static bool isMemoryLocation(DIExpressionCursor ExprCursor) { … }

void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor) { … }

bool DwarfExpression::addExpression(
    DIExpressionCursor &&ExprCursor,
    llvm::function_ref<bool(unsigned, DIExpressionCursor &)> InsertArg) { … }

/// add masking operations to stencil out a subregister.
void DwarfExpression::maskSubRegister() { … }

void DwarfExpression::finalize() { … }

void DwarfExpression::addFragmentOffset(const DIExpression *Expr) { … }

void DwarfExpression::emitLegacySExt(unsigned FromBits) { … }

void DwarfExpression::emitLegacyZExt(unsigned FromBits) { … }

void DwarfExpression::addWasmLocation(unsigned Index, uint64_t Offset) { … }