llvm/mlir/lib/Target/LLVMIR/DebugImporter.cpp

//===- DebugImporter.cpp - LLVM to MLIR Debug conversion ------------------===//
//
// 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 "DebugImporter.h"
#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/Location.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SetOperations.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Metadata.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"

usingnamespacemlir;
usingnamespacemlir::LLVM;
usingnamespacemlir::LLVM::detail;

DebugImporter::DebugImporter(ModuleOp mlirModule,
                             bool dropDICompositeTypeElements)
    :{}

Location DebugImporter::translateFuncLocation(llvm::Function *func) {}

//===----------------------------------------------------------------------===//
// Attributes
//===----------------------------------------------------------------------===//

DIBasicTypeAttr DebugImporter::translateImpl(llvm::DIBasicType *node) {}

DICompileUnitAttr DebugImporter::translateImpl(llvm::DICompileUnit *node) {}

DICompositeTypeAttr DebugImporter::translateImpl(llvm::DICompositeType *node) {}

DIDerivedTypeAttr DebugImporter::translateImpl(llvm::DIDerivedType *node) {}

DIStringTypeAttr DebugImporter::translateImpl(llvm::DIStringType *node) {}

DIFileAttr DebugImporter::translateImpl(llvm::DIFile *node) {}

DILabelAttr DebugImporter::translateImpl(llvm::DILabel *node) {}

DILexicalBlockAttr DebugImporter::translateImpl(llvm::DILexicalBlock *node) {}

DILexicalBlockFileAttr
DebugImporter::translateImpl(llvm::DILexicalBlockFile *node) {}

DIGlobalVariableAttr
DebugImporter::translateImpl(llvm::DIGlobalVariable *node) {}

DILocalVariableAttr DebugImporter::translateImpl(llvm::DILocalVariable *node) {}

DIVariableAttr DebugImporter::translateImpl(llvm::DIVariable *node) {}

DIScopeAttr DebugImporter::translateImpl(llvm::DIScope *node) {}

DIModuleAttr DebugImporter::translateImpl(llvm::DIModule *node) {}

DINamespaceAttr DebugImporter::translateImpl(llvm::DINamespace *node) {}

DIImportedEntityAttr
DebugImporter::translateImpl(llvm::DIImportedEntity *node) {}

DISubprogramAttr DebugImporter::translateImpl(llvm::DISubprogram *node) {}

DISubrangeAttr DebugImporter::translateImpl(llvm::DISubrange *node) {}

DISubroutineTypeAttr
DebugImporter::translateImpl(llvm::DISubroutineType *node) {}

DITypeAttr DebugImporter::translateImpl(llvm::DIType *node) {}

DINodeAttr DebugImporter::translate(llvm::DINode *node) {}

/// Get the `getRecSelf` constructor for the translated type of `node` if its
/// translated DITypeAttr supports recursion. Otherwise, returns nullptr.
static function_ref<DIRecursiveTypeAttrInterface(DistinctAttr)>
getRecSelfConstructor(llvm::DINode *node) {}

std::optional<DINodeAttr> DebugImporter::createRecSelf(llvm::DINode *node) {}

//===----------------------------------------------------------------------===//
// Locations
//===----------------------------------------------------------------------===//

Location DebugImporter::translateLoc(llvm::DILocation *loc) {}

DIExpressionAttr DebugImporter::translateExpression(llvm::DIExpression *node) {}

DIGlobalVariableExpressionAttr DebugImporter::translateGlobalVariableExpression(
    llvm::DIGlobalVariableExpression *node) {}

StringAttr DebugImporter::getStringAttrOrNull(llvm::MDString *stringNode) {}

DistinctAttr DebugImporter::getOrCreateDistinctID(llvm::DINode *node) {}