DebugProgramInstruction.cpp | Explore in Territory

//=====-- DebugProgramInstruction.cpp - Implement DbgRecords/DbgMarkers --====//
//
// 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/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugProgramInstruction.h"
#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/IntrinsicInst.h"

namespace llvm {

template <typename T>
DbgRecordParamRef<T>::DbgRecordParamRef(const T *Param)
    : … { … }
template <typename T>
DbgRecordParamRef<T>::DbgRecordParamRef(const MDNode *Param)
    : … { … }

template <typename T> T *DbgRecordParamRef<T>::get() const { … }

template class DbgRecordParamRef<DIExpression>;
template class DbgRecordParamRef<DILabel>;
template class DbgRecordParamRef<DILocalVariable>;

DbgVariableRecord::DbgVariableRecord(const DbgVariableIntrinsic *DVI)
    : … { … }

DbgVariableRecord::DbgVariableRecord(const DbgVariableRecord &DVR)
    : … { … }

DbgVariableRecord::DbgVariableRecord(Metadata *Location, DILocalVariable *DV,
                                     DIExpression *Expr, const DILocation *DI,
                                     LocationType Type)
    : … { … }

DbgVariableRecord::DbgVariableRecord(Metadata *Value, DILocalVariable *Variable,
                                     DIExpression *Expression,
                                     DIAssignID *AssignID, Metadata *Address,
                                     DIExpression *AddressExpression,
                                     const DILocation *DI)
    : … { … }

void DbgRecord::deleteRecord() { … }

void DbgRecord::print(raw_ostream &O, bool IsForDebug) const { … }

void DbgRecord::print(raw_ostream &O, ModuleSlotTracker &MST,
                      bool IsForDebug) const { … }

bool DbgRecord::isIdenticalToWhenDefined(const DbgRecord &R) const { … }

bool DbgRecord::isEquivalentTo(const DbgRecord &R) const { … }

DbgInfoIntrinsic *
DbgRecord::createDebugIntrinsic(Module *M, Instruction *InsertBefore) const { … }

DbgLabelRecord::DbgLabelRecord(MDNode *Label, MDNode *DL)
    : … { … }
DbgLabelRecord::DbgLabelRecord(DILabel *Label, DebugLoc DL)
    : … { … }

DbgLabelRecord *DbgLabelRecord::createUnresolvedDbgLabelRecord(MDNode *Label,
                                                               MDNode *DL) { … }

DbgVariableRecord::DbgVariableRecord(DbgVariableRecord::LocationType Type,
                                     Metadata *Val, MDNode *Variable,
                                     MDNode *Expression, MDNode *AssignID,
                                     Metadata *Address,
                                     MDNode *AddressExpression, MDNode *DI)
    : … { … }

DbgVariableRecord *DbgVariableRecord::createUnresolvedDbgVariableRecord(
    DbgVariableRecord::LocationType Type, Metadata *Val, MDNode *Variable,
    MDNode *Expression, MDNode *AssignID, Metadata *Address,
    MDNode *AddressExpression, MDNode *DI) { … }

DbgVariableRecord *
DbgVariableRecord::createDbgVariableRecord(Value *Location, DILocalVariable *DV,
                                           DIExpression *Expr,
                                           const DILocation *DI) { … }

DbgVariableRecord *DbgVariableRecord::createDbgVariableRecord(
    Value *Location, DILocalVariable *DV, DIExpression *Expr,
    const DILocation *DI, DbgVariableRecord &InsertBefore) { … }

DbgVariableRecord *DbgVariableRecord::createDVRDeclare(Value *Address,
                                                       DILocalVariable *DV,
                                                       DIExpression *Expr,
                                                       const DILocation *DI) { … }

DbgVariableRecord *
DbgVariableRecord::createDVRDeclare(Value *Address, DILocalVariable *DV,
                                    DIExpression *Expr, const DILocation *DI,
                                    DbgVariableRecord &InsertBefore) { … }

DbgVariableRecord *DbgVariableRecord::createDVRAssign(
    Value *Val, DILocalVariable *Variable, DIExpression *Expression,
    DIAssignID *AssignID, Value *Address, DIExpression *AddressExpression,
    const DILocation *DI) { … }

DbgVariableRecord *DbgVariableRecord::createLinkedDVRAssign(
    Instruction *LinkedInstr, Value *Val, DILocalVariable *Variable,
    DIExpression *Expression, Value *Address, DIExpression *AddressExpression,
    const DILocation *DI) { … }

iterator_range<DbgVariableRecord::location_op_iterator>
DbgVariableRecord::location_ops() const { … }

unsigned DbgVariableRecord::getNumVariableLocationOps() const { … }

Value *DbgVariableRecord::getVariableLocationOp(unsigned OpIdx) const { … }

static ValueAsMetadata *getAsMetadata(Value *V) { … }

void DbgVariableRecord::replaceVariableLocationOp(Value *OldValue,
                                                  Value *NewValue,
                                                  bool AllowEmpty) { … }

void DbgVariableRecord::replaceVariableLocationOp(unsigned OpIdx,
                                                  Value *NewValue) { … }

void DbgVariableRecord::addVariableLocationOps(ArrayRef<Value *> NewValues,
                                               DIExpression *NewExpr) { … }

void DbgVariableRecord::setKillLocation() { … }

bool DbgVariableRecord::isKillLocation() const { … }

std::optional<DbgVariableFragmentInfo> DbgVariableRecord::getFragment() const { … }

std::optional<uint64_t> DbgVariableRecord::getFragmentSizeInBits() const { … }

DbgRecord *DbgRecord::clone() const { … }

DbgVariableRecord *DbgVariableRecord::clone() const { … }

DbgLabelRecord *DbgLabelRecord::clone() const { … }

DbgVariableIntrinsic *
DbgVariableRecord::createDebugIntrinsic(Module *M,
                                        Instruction *InsertBefore) const { … }

DbgLabelInst *
DbgLabelRecord::createDebugIntrinsic(Module *M,
                                     Instruction *InsertBefore) const { … }

Value *DbgVariableRecord::getAddress() const { … }

DIAssignID *DbgVariableRecord::getAssignID() const { … }

void DbgVariableRecord::setAssignId(DIAssignID *New) { … }

void DbgVariableRecord::setKillAddress() { … }

bool DbgVariableRecord::isKillAddress() const { … }

const Instruction *DbgRecord::getInstruction() const { … }

const BasicBlock *DbgRecord::getParent() const { … }

BasicBlock *DbgRecord::getParent() { … }

BasicBlock *DbgRecord::getBlock() { … }

const BasicBlock *DbgRecord::getBlock() const { … }

Function *DbgRecord::getFunction() { … }

const Function *DbgRecord::getFunction() const { … }

Module *DbgRecord::getModule() { … }

const Module *DbgRecord::getModule() const { … }

LLVMContext &DbgRecord::getContext() { … }

const LLVMContext &DbgRecord::getContext() const { … }

void DbgRecord::insertBefore(DbgRecord *InsertBefore) { … }
void DbgRecord::insertAfter(DbgRecord *InsertAfter) { … }
void DbgRecord::moveBefore(DbgRecord *MoveBefore) { … }
void DbgRecord::moveAfter(DbgRecord *MoveAfter) { … }

///////////////////////////////////////////////////////////////////////////////

// An empty, global, DbgMarker for the purpose of describing empty ranges of
// DbgRecords.
DbgMarker DbgMarker::EmptyDbgMarker;

void DbgMarker::dropDbgRecords() { … }

void DbgMarker::dropOneDbgRecord(DbgRecord *DR) { … }

const BasicBlock *DbgMarker::getParent() const { … }

BasicBlock *DbgMarker::getParent() { … }

void DbgMarker::removeMarker() { … }

void DbgMarker::removeFromParent() { … }

void DbgMarker::eraseFromParent() { … }

iterator_range<DbgRecord::self_iterator> DbgMarker::getDbgRecordRange() { … }
iterator_range<DbgRecord::const_self_iterator>
DbgMarker::getDbgRecordRange() const { … }

void DbgRecord::removeFromParent() { … }

void DbgRecord::eraseFromParent() { … }

void DbgMarker::insertDbgRecord(DbgRecord *New, bool InsertAtHead) { … }
void DbgMarker::insertDbgRecord(DbgRecord *New, DbgRecord *InsertBefore) { … }
void DbgMarker::insertDbgRecordAfter(DbgRecord *New, DbgRecord *InsertAfter) { … }

void DbgMarker::absorbDebugValues(DbgMarker &Src, bool InsertAtHead) { … }

void DbgMarker::absorbDebugValues(
    iterator_range<DbgRecord::self_iterator> Range, DbgMarker &Src,
    bool InsertAtHead) { … }

iterator_range<simple_ilist<DbgRecord>::iterator> DbgMarker::cloneDebugInfoFrom(
    DbgMarker *From, std::optional<simple_ilist<DbgRecord>::iterator> from_here,
    bool InsertAtHead) { … }

} // end namespace llvm
llvm/llvm/lib/IR/DebugProgramInstruction.cpp
