106f32e7eSjoerg //===- DebugInfo.cpp - Debug Information Helper Classes -------------------===//
206f32e7eSjoerg //
306f32e7eSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
406f32e7eSjoerg // See https://llvm.org/LICENSE.txt for license information.
506f32e7eSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
606f32e7eSjoerg //
706f32e7eSjoerg //===----------------------------------------------------------------------===//
806f32e7eSjoerg //
906f32e7eSjoerg // This file implements the helper classes used to build and interpret debug
1006f32e7eSjoerg // information in LLVM IR form.
1106f32e7eSjoerg //
1206f32e7eSjoerg //===----------------------------------------------------------------------===//
1306f32e7eSjoerg
1406f32e7eSjoerg #include "llvm-c/DebugInfo.h"
1506f32e7eSjoerg #include "llvm/ADT/DenseMap.h"
1606f32e7eSjoerg #include "llvm/ADT/DenseSet.h"
1706f32e7eSjoerg #include "llvm/ADT/None.h"
1806f32e7eSjoerg #include "llvm/ADT/STLExtras.h"
1906f32e7eSjoerg #include "llvm/ADT/SmallPtrSet.h"
2006f32e7eSjoerg #include "llvm/ADT/SmallVector.h"
2106f32e7eSjoerg #include "llvm/ADT/StringRef.h"
2206f32e7eSjoerg #include "llvm/IR/BasicBlock.h"
2306f32e7eSjoerg #include "llvm/IR/Constants.h"
2406f32e7eSjoerg #include "llvm/IR/DebugInfoMetadata.h"
2506f32e7eSjoerg #include "llvm/IR/DebugLoc.h"
2606f32e7eSjoerg #include "llvm/IR/DebugInfo.h"
2706f32e7eSjoerg #include "llvm/IR/DIBuilder.h"
2806f32e7eSjoerg #include "llvm/IR/Function.h"
2906f32e7eSjoerg #include "llvm/IR/GVMaterializer.h"
3006f32e7eSjoerg #include "llvm/IR/Instruction.h"
3106f32e7eSjoerg #include "llvm/IR/IntrinsicInst.h"
3206f32e7eSjoerg #include "llvm/IR/LLVMContext.h"
3306f32e7eSjoerg #include "llvm/IR/Metadata.h"
3406f32e7eSjoerg #include "llvm/IR/Module.h"
3506f32e7eSjoerg #include "llvm/Support/Casting.h"
3606f32e7eSjoerg #include <algorithm>
3706f32e7eSjoerg #include <cassert>
3806f32e7eSjoerg #include <utility>
3906f32e7eSjoerg
4006f32e7eSjoerg using namespace llvm;
4106f32e7eSjoerg using namespace llvm::dwarf;
4206f32e7eSjoerg
43*da58b97aSjoerg /// Finds all intrinsics declaring local variables as living in the memory that
44*da58b97aSjoerg /// 'V' points to. This may include a mix of dbg.declare and
45*da58b97aSjoerg /// dbg.addr intrinsics.
FindDbgAddrUses(Value * V)46*da58b97aSjoerg TinyPtrVector<DbgVariableIntrinsic *> llvm::FindDbgAddrUses(Value *V) {
47*da58b97aSjoerg // This function is hot. Check whether the value has any metadata to avoid a
48*da58b97aSjoerg // DenseMap lookup.
49*da58b97aSjoerg if (!V->isUsedByMetadata())
50*da58b97aSjoerg return {};
51*da58b97aSjoerg auto *L = LocalAsMetadata::getIfExists(V);
52*da58b97aSjoerg if (!L)
53*da58b97aSjoerg return {};
54*da58b97aSjoerg auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L);
55*da58b97aSjoerg if (!MDV)
56*da58b97aSjoerg return {};
57*da58b97aSjoerg
58*da58b97aSjoerg TinyPtrVector<DbgVariableIntrinsic *> Declares;
59*da58b97aSjoerg for (User *U : MDV->users()) {
60*da58b97aSjoerg if (auto *DII = dyn_cast<DbgVariableIntrinsic>(U))
61*da58b97aSjoerg if (DII->isAddressOfVariable())
62*da58b97aSjoerg Declares.push_back(DII);
63*da58b97aSjoerg }
64*da58b97aSjoerg
65*da58b97aSjoerg return Declares;
66*da58b97aSjoerg }
67*da58b97aSjoerg
FindDbgDeclareUses(Value * V)68*da58b97aSjoerg TinyPtrVector<DbgDeclareInst *> llvm::FindDbgDeclareUses(Value *V) {
69*da58b97aSjoerg TinyPtrVector<DbgDeclareInst *> DDIs;
70*da58b97aSjoerg for (DbgVariableIntrinsic *DVI : FindDbgAddrUses(V))
71*da58b97aSjoerg if (auto *DDI = dyn_cast<DbgDeclareInst>(DVI))
72*da58b97aSjoerg DDIs.push_back(DDI);
73*da58b97aSjoerg return DDIs;
74*da58b97aSjoerg }
75*da58b97aSjoerg
findDbgValues(SmallVectorImpl<DbgValueInst * > & DbgValues,Value * V)76*da58b97aSjoerg void llvm::findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V) {
77*da58b97aSjoerg // This function is hot. Check whether the value has any metadata to avoid a
78*da58b97aSjoerg // DenseMap lookup.
79*da58b97aSjoerg if (!V->isUsedByMetadata())
80*da58b97aSjoerg return;
81*da58b97aSjoerg // TODO: If this value appears multiple times in a DIArgList, we should still
82*da58b97aSjoerg // only add the owning DbgValueInst once; use this set to track ArgListUsers.
83*da58b97aSjoerg // This behaviour can be removed when we can automatically remove duplicates.
84*da58b97aSjoerg SmallPtrSet<DbgValueInst *, 4> EncounteredDbgValues;
85*da58b97aSjoerg if (auto *L = LocalAsMetadata::getIfExists(V)) {
86*da58b97aSjoerg if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L)) {
87*da58b97aSjoerg for (User *U : MDV->users())
88*da58b97aSjoerg if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
89*da58b97aSjoerg DbgValues.push_back(DVI);
90*da58b97aSjoerg }
91*da58b97aSjoerg for (Metadata *AL : L->getAllArgListUsers()) {
92*da58b97aSjoerg if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), AL)) {
93*da58b97aSjoerg for (User *U : MDV->users())
94*da58b97aSjoerg if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
95*da58b97aSjoerg if (EncounteredDbgValues.insert(DVI).second)
96*da58b97aSjoerg DbgValues.push_back(DVI);
97*da58b97aSjoerg }
98*da58b97aSjoerg }
99*da58b97aSjoerg }
100*da58b97aSjoerg }
101*da58b97aSjoerg
findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic * > & DbgUsers,Value * V)102*da58b97aSjoerg void llvm::findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers,
103*da58b97aSjoerg Value *V) {
104*da58b97aSjoerg // This function is hot. Check whether the value has any metadata to avoid a
105*da58b97aSjoerg // DenseMap lookup.
106*da58b97aSjoerg if (!V->isUsedByMetadata())
107*da58b97aSjoerg return;
108*da58b97aSjoerg // TODO: If this value appears multiple times in a DIArgList, we should still
109*da58b97aSjoerg // only add the owning DbgValueInst once; use this set to track ArgListUsers.
110*da58b97aSjoerg // This behaviour can be removed when we can automatically remove duplicates.
111*da58b97aSjoerg SmallPtrSet<DbgVariableIntrinsic *, 4> EncounteredDbgValues;
112*da58b97aSjoerg if (auto *L = LocalAsMetadata::getIfExists(V)) {
113*da58b97aSjoerg if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L)) {
114*da58b97aSjoerg for (User *U : MDV->users())
115*da58b97aSjoerg if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
116*da58b97aSjoerg DbgUsers.push_back(DII);
117*da58b97aSjoerg }
118*da58b97aSjoerg for (Metadata *AL : L->getAllArgListUsers()) {
119*da58b97aSjoerg if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), AL)) {
120*da58b97aSjoerg for (User *U : MDV->users())
121*da58b97aSjoerg if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
122*da58b97aSjoerg if (EncounteredDbgValues.insert(DII).second)
123*da58b97aSjoerg DbgUsers.push_back(DII);
124*da58b97aSjoerg }
125*da58b97aSjoerg }
126*da58b97aSjoerg }
127*da58b97aSjoerg }
128*da58b97aSjoerg
getDISubprogram(const MDNode * Scope)12906f32e7eSjoerg DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
13006f32e7eSjoerg if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
13106f32e7eSjoerg return LocalScope->getSubprogram();
13206f32e7eSjoerg return nullptr;
13306f32e7eSjoerg }
13406f32e7eSjoerg
13506f32e7eSjoerg //===----------------------------------------------------------------------===//
13606f32e7eSjoerg // DebugInfoFinder implementations.
13706f32e7eSjoerg //===----------------------------------------------------------------------===//
13806f32e7eSjoerg
reset()13906f32e7eSjoerg void DebugInfoFinder::reset() {
14006f32e7eSjoerg CUs.clear();
14106f32e7eSjoerg SPs.clear();
14206f32e7eSjoerg GVs.clear();
14306f32e7eSjoerg TYs.clear();
14406f32e7eSjoerg Scopes.clear();
14506f32e7eSjoerg NodesSeen.clear();
14606f32e7eSjoerg }
14706f32e7eSjoerg
processModule(const Module & M)14806f32e7eSjoerg void DebugInfoFinder::processModule(const Module &M) {
14906f32e7eSjoerg for (auto *CU : M.debug_compile_units())
15006f32e7eSjoerg processCompileUnit(CU);
15106f32e7eSjoerg for (auto &F : M.functions()) {
15206f32e7eSjoerg if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
15306f32e7eSjoerg processSubprogram(SP);
15406f32e7eSjoerg // There could be subprograms from inlined functions referenced from
15506f32e7eSjoerg // instructions only. Walk the function to find them.
15606f32e7eSjoerg for (const BasicBlock &BB : F)
15706f32e7eSjoerg for (const Instruction &I : BB)
15806f32e7eSjoerg processInstruction(M, I);
15906f32e7eSjoerg }
16006f32e7eSjoerg }
16106f32e7eSjoerg
processCompileUnit(DICompileUnit * CU)16206f32e7eSjoerg void DebugInfoFinder::processCompileUnit(DICompileUnit *CU) {
16306f32e7eSjoerg if (!addCompileUnit(CU))
16406f32e7eSjoerg return;
16506f32e7eSjoerg for (auto DIG : CU->getGlobalVariables()) {
16606f32e7eSjoerg if (!addGlobalVariable(DIG))
16706f32e7eSjoerg continue;
16806f32e7eSjoerg auto *GV = DIG->getVariable();
16906f32e7eSjoerg processScope(GV->getScope());
17006f32e7eSjoerg processType(GV->getType());
17106f32e7eSjoerg }
17206f32e7eSjoerg for (auto *ET : CU->getEnumTypes())
17306f32e7eSjoerg processType(ET);
17406f32e7eSjoerg for (auto *RT : CU->getRetainedTypes())
17506f32e7eSjoerg if (auto *T = dyn_cast<DIType>(RT))
17606f32e7eSjoerg processType(T);
17706f32e7eSjoerg else
17806f32e7eSjoerg processSubprogram(cast<DISubprogram>(RT));
17906f32e7eSjoerg for (auto *Import : CU->getImportedEntities()) {
18006f32e7eSjoerg auto *Entity = Import->getEntity();
18106f32e7eSjoerg if (auto *T = dyn_cast<DIType>(Entity))
18206f32e7eSjoerg processType(T);
18306f32e7eSjoerg else if (auto *SP = dyn_cast<DISubprogram>(Entity))
18406f32e7eSjoerg processSubprogram(SP);
18506f32e7eSjoerg else if (auto *NS = dyn_cast<DINamespace>(Entity))
18606f32e7eSjoerg processScope(NS->getScope());
18706f32e7eSjoerg else if (auto *M = dyn_cast<DIModule>(Entity))
18806f32e7eSjoerg processScope(M->getScope());
18906f32e7eSjoerg }
19006f32e7eSjoerg }
19106f32e7eSjoerg
processInstruction(const Module & M,const Instruction & I)19206f32e7eSjoerg void DebugInfoFinder::processInstruction(const Module &M,
19306f32e7eSjoerg const Instruction &I) {
194*da58b97aSjoerg if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I))
195*da58b97aSjoerg processVariable(M, *DVI);
19606f32e7eSjoerg
19706f32e7eSjoerg if (auto DbgLoc = I.getDebugLoc())
19806f32e7eSjoerg processLocation(M, DbgLoc.get());
19906f32e7eSjoerg }
20006f32e7eSjoerg
processLocation(const Module & M,const DILocation * Loc)20106f32e7eSjoerg void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
20206f32e7eSjoerg if (!Loc)
20306f32e7eSjoerg return;
20406f32e7eSjoerg processScope(Loc->getScope());
20506f32e7eSjoerg processLocation(M, Loc->getInlinedAt());
20606f32e7eSjoerg }
20706f32e7eSjoerg
processType(DIType * DT)20806f32e7eSjoerg void DebugInfoFinder::processType(DIType *DT) {
20906f32e7eSjoerg if (!addType(DT))
21006f32e7eSjoerg return;
21106f32e7eSjoerg processScope(DT->getScope());
21206f32e7eSjoerg if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
21306f32e7eSjoerg for (DIType *Ref : ST->getTypeArray())
21406f32e7eSjoerg processType(Ref);
21506f32e7eSjoerg return;
21606f32e7eSjoerg }
21706f32e7eSjoerg if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
21806f32e7eSjoerg processType(DCT->getBaseType());
21906f32e7eSjoerg for (Metadata *D : DCT->getElements()) {
22006f32e7eSjoerg if (auto *T = dyn_cast<DIType>(D))
22106f32e7eSjoerg processType(T);
22206f32e7eSjoerg else if (auto *SP = dyn_cast<DISubprogram>(D))
22306f32e7eSjoerg processSubprogram(SP);
22406f32e7eSjoerg }
22506f32e7eSjoerg return;
22606f32e7eSjoerg }
22706f32e7eSjoerg if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
22806f32e7eSjoerg processType(DDT->getBaseType());
22906f32e7eSjoerg }
23006f32e7eSjoerg }
23106f32e7eSjoerg
processScope(DIScope * Scope)23206f32e7eSjoerg void DebugInfoFinder::processScope(DIScope *Scope) {
23306f32e7eSjoerg if (!Scope)
23406f32e7eSjoerg return;
23506f32e7eSjoerg if (auto *Ty = dyn_cast<DIType>(Scope)) {
23606f32e7eSjoerg processType(Ty);
23706f32e7eSjoerg return;
23806f32e7eSjoerg }
23906f32e7eSjoerg if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
24006f32e7eSjoerg addCompileUnit(CU);
24106f32e7eSjoerg return;
24206f32e7eSjoerg }
24306f32e7eSjoerg if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
24406f32e7eSjoerg processSubprogram(SP);
24506f32e7eSjoerg return;
24606f32e7eSjoerg }
24706f32e7eSjoerg if (!addScope(Scope))
24806f32e7eSjoerg return;
24906f32e7eSjoerg if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
25006f32e7eSjoerg processScope(LB->getScope());
25106f32e7eSjoerg } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
25206f32e7eSjoerg processScope(NS->getScope());
25306f32e7eSjoerg } else if (auto *M = dyn_cast<DIModule>(Scope)) {
25406f32e7eSjoerg processScope(M->getScope());
25506f32e7eSjoerg }
25606f32e7eSjoerg }
25706f32e7eSjoerg
processSubprogram(DISubprogram * SP)25806f32e7eSjoerg void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
25906f32e7eSjoerg if (!addSubprogram(SP))
26006f32e7eSjoerg return;
26106f32e7eSjoerg processScope(SP->getScope());
26206f32e7eSjoerg // Some of the users, e.g. CloneFunctionInto / CloneModule, need to set up a
26306f32e7eSjoerg // ValueMap containing identity mappings for all of the DICompileUnit's, not
26406f32e7eSjoerg // just DISubprogram's, referenced from anywhere within the Function being
26506f32e7eSjoerg // cloned prior to calling MapMetadata / RemapInstruction to avoid their
26606f32e7eSjoerg // duplication later as DICompileUnit's are also directly referenced by
26706f32e7eSjoerg // llvm.dbg.cu list. Thefore we need to collect DICompileUnit's here as well.
26806f32e7eSjoerg // Also, DICompileUnit's may reference DISubprogram's too and therefore need
26906f32e7eSjoerg // to be at least looked through.
27006f32e7eSjoerg processCompileUnit(SP->getUnit());
27106f32e7eSjoerg processType(SP->getType());
27206f32e7eSjoerg for (auto *Element : SP->getTemplateParams()) {
27306f32e7eSjoerg if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
27406f32e7eSjoerg processType(TType->getType());
27506f32e7eSjoerg } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
27606f32e7eSjoerg processType(TVal->getType());
27706f32e7eSjoerg }
27806f32e7eSjoerg }
27906f32e7eSjoerg }
28006f32e7eSjoerg
processVariable(const Module & M,const DbgVariableIntrinsic & DVI)281*da58b97aSjoerg void DebugInfoFinder::processVariable(const Module &M,
282*da58b97aSjoerg const DbgVariableIntrinsic &DVI) {
283*da58b97aSjoerg auto *N = dyn_cast<MDNode>(DVI.getVariable());
28406f32e7eSjoerg if (!N)
28506f32e7eSjoerg return;
28606f32e7eSjoerg
28706f32e7eSjoerg auto *DV = dyn_cast<DILocalVariable>(N);
28806f32e7eSjoerg if (!DV)
28906f32e7eSjoerg return;
29006f32e7eSjoerg
29106f32e7eSjoerg if (!NodesSeen.insert(DV).second)
29206f32e7eSjoerg return;
29306f32e7eSjoerg processScope(DV->getScope());
29406f32e7eSjoerg processType(DV->getType());
29506f32e7eSjoerg }
29606f32e7eSjoerg
addType(DIType * DT)29706f32e7eSjoerg bool DebugInfoFinder::addType(DIType *DT) {
29806f32e7eSjoerg if (!DT)
29906f32e7eSjoerg return false;
30006f32e7eSjoerg
30106f32e7eSjoerg if (!NodesSeen.insert(DT).second)
30206f32e7eSjoerg return false;
30306f32e7eSjoerg
30406f32e7eSjoerg TYs.push_back(const_cast<DIType *>(DT));
30506f32e7eSjoerg return true;
30606f32e7eSjoerg }
30706f32e7eSjoerg
addCompileUnit(DICompileUnit * CU)30806f32e7eSjoerg bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
30906f32e7eSjoerg if (!CU)
31006f32e7eSjoerg return false;
31106f32e7eSjoerg if (!NodesSeen.insert(CU).second)
31206f32e7eSjoerg return false;
31306f32e7eSjoerg
31406f32e7eSjoerg CUs.push_back(CU);
31506f32e7eSjoerg return true;
31606f32e7eSjoerg }
31706f32e7eSjoerg
addGlobalVariable(DIGlobalVariableExpression * DIG)31806f32e7eSjoerg bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
31906f32e7eSjoerg if (!NodesSeen.insert(DIG).second)
32006f32e7eSjoerg return false;
32106f32e7eSjoerg
32206f32e7eSjoerg GVs.push_back(DIG);
32306f32e7eSjoerg return true;
32406f32e7eSjoerg }
32506f32e7eSjoerg
addSubprogram(DISubprogram * SP)32606f32e7eSjoerg bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
32706f32e7eSjoerg if (!SP)
32806f32e7eSjoerg return false;
32906f32e7eSjoerg
33006f32e7eSjoerg if (!NodesSeen.insert(SP).second)
33106f32e7eSjoerg return false;
33206f32e7eSjoerg
33306f32e7eSjoerg SPs.push_back(SP);
33406f32e7eSjoerg return true;
33506f32e7eSjoerg }
33606f32e7eSjoerg
addScope(DIScope * Scope)33706f32e7eSjoerg bool DebugInfoFinder::addScope(DIScope *Scope) {
33806f32e7eSjoerg if (!Scope)
33906f32e7eSjoerg return false;
34006f32e7eSjoerg // FIXME: Ocaml binding generates a scope with no content, we treat it
34106f32e7eSjoerg // as null for now.
34206f32e7eSjoerg if (Scope->getNumOperands() == 0)
34306f32e7eSjoerg return false;
34406f32e7eSjoerg if (!NodesSeen.insert(Scope).second)
34506f32e7eSjoerg return false;
34606f32e7eSjoerg Scopes.push_back(Scope);
34706f32e7eSjoerg return true;
34806f32e7eSjoerg }
34906f32e7eSjoerg
updateLoopMetadataDebugLocationsImpl(MDNode * OrigLoopID,function_ref<DILocation * (const DILocation &)> Updater)350*da58b97aSjoerg static MDNode *updateLoopMetadataDebugLocationsImpl(
351*da58b97aSjoerg MDNode *OrigLoopID,
352*da58b97aSjoerg function_ref<DILocation *(const DILocation &)> Updater) {
353*da58b97aSjoerg assert(OrigLoopID && OrigLoopID->getNumOperands() > 0 &&
354*da58b97aSjoerg "Loop ID needs at least one operand");
355*da58b97aSjoerg assert(OrigLoopID && OrigLoopID->getOperand(0).get() == OrigLoopID &&
356*da58b97aSjoerg "Loop ID should refer to itself");
357*da58b97aSjoerg
358*da58b97aSjoerg // Save space for the self-referential LoopID.
359*da58b97aSjoerg SmallVector<Metadata *, 4> MDs = {nullptr};
360*da58b97aSjoerg
361*da58b97aSjoerg for (unsigned i = 1; i < OrigLoopID->getNumOperands(); ++i) {
362*da58b97aSjoerg Metadata *MD = OrigLoopID->getOperand(i);
363*da58b97aSjoerg if (DILocation *DL = dyn_cast<DILocation>(MD)) {
364*da58b97aSjoerg if (DILocation *NewDL = Updater(*DL))
365*da58b97aSjoerg MDs.push_back(NewDL);
366*da58b97aSjoerg } else
367*da58b97aSjoerg MDs.push_back(MD);
368*da58b97aSjoerg }
369*da58b97aSjoerg
370*da58b97aSjoerg MDNode *NewLoopID = MDNode::getDistinct(OrigLoopID->getContext(), MDs);
371*da58b97aSjoerg // Insert the self-referential LoopID.
372*da58b97aSjoerg NewLoopID->replaceOperandWith(0, NewLoopID);
373*da58b97aSjoerg return NewLoopID;
374*da58b97aSjoerg }
375*da58b97aSjoerg
updateLoopMetadataDebugLocations(Instruction & I,function_ref<DILocation * (const DILocation &)> Updater)376*da58b97aSjoerg void llvm::updateLoopMetadataDebugLocations(
377*da58b97aSjoerg Instruction &I, function_ref<DILocation *(const DILocation &)> Updater) {
378*da58b97aSjoerg MDNode *OrigLoopID = I.getMetadata(LLVMContext::MD_loop);
379*da58b97aSjoerg if (!OrigLoopID)
380*da58b97aSjoerg return;
381*da58b97aSjoerg MDNode *NewLoopID = updateLoopMetadataDebugLocationsImpl(OrigLoopID, Updater);
382*da58b97aSjoerg I.setMetadata(LLVMContext::MD_loop, NewLoopID);
383*da58b97aSjoerg }
384*da58b97aSjoerg
stripDebugLocFromLoopID(MDNode * N)38506f32e7eSjoerg static MDNode *stripDebugLocFromLoopID(MDNode *N) {
38606f32e7eSjoerg assert(!N->operands().empty() && "Missing self reference?");
38706f32e7eSjoerg
38806f32e7eSjoerg // if there is no debug location, we do not have to rewrite this MDNode.
38906f32e7eSjoerg if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
39006f32e7eSjoerg return isa<DILocation>(Op.get());
39106f32e7eSjoerg }))
39206f32e7eSjoerg return N;
39306f32e7eSjoerg
39406f32e7eSjoerg // If there is only the debug location without any actual loop metadata, we
39506f32e7eSjoerg // can remove the metadata.
39606f32e7eSjoerg if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
39706f32e7eSjoerg return !isa<DILocation>(Op.get());
39806f32e7eSjoerg }))
39906f32e7eSjoerg return nullptr;
40006f32e7eSjoerg
401*da58b97aSjoerg auto dropDebugLoc = [](const DILocation &) -> DILocation * {
402*da58b97aSjoerg return nullptr;
403*da58b97aSjoerg };
404*da58b97aSjoerg return updateLoopMetadataDebugLocationsImpl(N, dropDebugLoc);
40506f32e7eSjoerg }
40606f32e7eSjoerg
stripDebugInfo(Function & F)40706f32e7eSjoerg bool llvm::stripDebugInfo(Function &F) {
40806f32e7eSjoerg bool Changed = false;
40906f32e7eSjoerg if (F.hasMetadata(LLVMContext::MD_dbg)) {
41006f32e7eSjoerg Changed = true;
41106f32e7eSjoerg F.setSubprogram(nullptr);
41206f32e7eSjoerg }
41306f32e7eSjoerg
41406f32e7eSjoerg DenseMap<MDNode*, MDNode*> LoopIDsMap;
41506f32e7eSjoerg for (BasicBlock &BB : F) {
41606f32e7eSjoerg for (auto II = BB.begin(), End = BB.end(); II != End;) {
41706f32e7eSjoerg Instruction &I = *II++; // We may delete the instruction, increment now.
41806f32e7eSjoerg if (isa<DbgInfoIntrinsic>(&I)) {
41906f32e7eSjoerg I.eraseFromParent();
42006f32e7eSjoerg Changed = true;
42106f32e7eSjoerg continue;
42206f32e7eSjoerg }
42306f32e7eSjoerg if (I.getDebugLoc()) {
42406f32e7eSjoerg Changed = true;
42506f32e7eSjoerg I.setDebugLoc(DebugLoc());
42606f32e7eSjoerg }
427*da58b97aSjoerg if (auto *LoopID = I.getMetadata(LLVMContext::MD_loop)) {
42806f32e7eSjoerg auto *NewLoopID = LoopIDsMap.lookup(LoopID);
42906f32e7eSjoerg if (!NewLoopID)
43006f32e7eSjoerg NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
43106f32e7eSjoerg if (NewLoopID != LoopID)
432*da58b97aSjoerg I.setMetadata(LLVMContext::MD_loop, NewLoopID);
433*da58b97aSjoerg }
434*da58b97aSjoerg // Strip heapallocsite attachments, they point into the DIType system.
435*da58b97aSjoerg if (I.hasMetadataOtherThanDebugLoc())
436*da58b97aSjoerg I.setMetadata("heapallocsite", nullptr);
43706f32e7eSjoerg }
43806f32e7eSjoerg }
43906f32e7eSjoerg return Changed;
44006f32e7eSjoerg }
44106f32e7eSjoerg
StripDebugInfo(Module & M)44206f32e7eSjoerg bool llvm::StripDebugInfo(Module &M) {
44306f32e7eSjoerg bool Changed = false;
44406f32e7eSjoerg
445*da58b97aSjoerg for (NamedMDNode &NMD : llvm::make_early_inc_range(M.named_metadata())) {
44606f32e7eSjoerg // We're stripping debug info, and without them, coverage information
44706f32e7eSjoerg // doesn't quite make sense.
448*da58b97aSjoerg if (NMD.getName().startswith("llvm.dbg.") ||
449*da58b97aSjoerg NMD.getName() == "llvm.gcov") {
450*da58b97aSjoerg NMD.eraseFromParent();
45106f32e7eSjoerg Changed = true;
45206f32e7eSjoerg }
45306f32e7eSjoerg }
45406f32e7eSjoerg
45506f32e7eSjoerg for (Function &F : M)
45606f32e7eSjoerg Changed |= stripDebugInfo(F);
45706f32e7eSjoerg
45806f32e7eSjoerg for (auto &GV : M.globals()) {
45906f32e7eSjoerg Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
46006f32e7eSjoerg }
46106f32e7eSjoerg
46206f32e7eSjoerg if (GVMaterializer *Materializer = M.getMaterializer())
46306f32e7eSjoerg Materializer->setStripDebugInfo();
46406f32e7eSjoerg
46506f32e7eSjoerg return Changed;
46606f32e7eSjoerg }
46706f32e7eSjoerg
46806f32e7eSjoerg namespace {
46906f32e7eSjoerg
47006f32e7eSjoerg /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
47106f32e7eSjoerg class DebugTypeInfoRemoval {
47206f32e7eSjoerg DenseMap<Metadata *, Metadata *> Replacements;
47306f32e7eSjoerg
47406f32e7eSjoerg public:
47506f32e7eSjoerg /// The (void)() type.
47606f32e7eSjoerg MDNode *EmptySubroutineType;
47706f32e7eSjoerg
47806f32e7eSjoerg private:
47906f32e7eSjoerg /// Remember what linkage name we originally had before stripping. If we end
48006f32e7eSjoerg /// up making two subprograms identical who originally had different linkage
48106f32e7eSjoerg /// names, then we need to make one of them distinct, to avoid them getting
48206f32e7eSjoerg /// uniqued. Maps the new node to the old linkage name.
48306f32e7eSjoerg DenseMap<DISubprogram *, StringRef> NewToLinkageName;
48406f32e7eSjoerg
48506f32e7eSjoerg // TODO: Remember the distinct subprogram we created for a given linkage name,
48606f32e7eSjoerg // so that we can continue to unique whenever possible. Map <newly created
48706f32e7eSjoerg // node, old linkage name> to the first (possibly distinct) mdsubprogram
48806f32e7eSjoerg // created for that combination. This is not strictly needed for correctness,
48906f32e7eSjoerg // but can cut down on the number of MDNodes and let us diff cleanly with the
49006f32e7eSjoerg // output of -gline-tables-only.
49106f32e7eSjoerg
49206f32e7eSjoerg public:
DebugTypeInfoRemoval(LLVMContext & C)49306f32e7eSjoerg DebugTypeInfoRemoval(LLVMContext &C)
49406f32e7eSjoerg : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
49506f32e7eSjoerg MDNode::get(C, {}))) {}
49606f32e7eSjoerg
map(Metadata * M)49706f32e7eSjoerg Metadata *map(Metadata *M) {
49806f32e7eSjoerg if (!M)
49906f32e7eSjoerg return nullptr;
50006f32e7eSjoerg auto Replacement = Replacements.find(M);
50106f32e7eSjoerg if (Replacement != Replacements.end())
50206f32e7eSjoerg return Replacement->second;
50306f32e7eSjoerg
50406f32e7eSjoerg return M;
50506f32e7eSjoerg }
mapNode(Metadata * N)50606f32e7eSjoerg MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
50706f32e7eSjoerg
50806f32e7eSjoerg /// Recursively remap N and all its referenced children. Does a DF post-order
50906f32e7eSjoerg /// traversal, so as to remap bottoms up.
traverseAndRemap(MDNode * N)51006f32e7eSjoerg void traverseAndRemap(MDNode *N) { traverse(N); }
51106f32e7eSjoerg
51206f32e7eSjoerg private:
51306f32e7eSjoerg // Create a new DISubprogram, to replace the one given.
getReplacementSubprogram(DISubprogram * MDS)51406f32e7eSjoerg DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
51506f32e7eSjoerg auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
51606f32e7eSjoerg StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
51706f32e7eSjoerg DISubprogram *Declaration = nullptr;
51806f32e7eSjoerg auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
51906f32e7eSjoerg DIType *ContainingType =
52006f32e7eSjoerg cast_or_null<DIType>(map(MDS->getContainingType()));
52106f32e7eSjoerg auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
52206f32e7eSjoerg auto Variables = nullptr;
52306f32e7eSjoerg auto TemplateParams = nullptr;
52406f32e7eSjoerg
52506f32e7eSjoerg // Make a distinct DISubprogram, for situations that warrent it.
52606f32e7eSjoerg auto distinctMDSubprogram = [&]() {
52706f32e7eSjoerg return DISubprogram::getDistinct(
52806f32e7eSjoerg MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
52906f32e7eSjoerg FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
53006f32e7eSjoerg ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
53106f32e7eSjoerg MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
53206f32e7eSjoerg Variables);
53306f32e7eSjoerg };
53406f32e7eSjoerg
53506f32e7eSjoerg if (MDS->isDistinct())
53606f32e7eSjoerg return distinctMDSubprogram();
53706f32e7eSjoerg
53806f32e7eSjoerg auto *NewMDS = DISubprogram::get(
53906f32e7eSjoerg MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
54006f32e7eSjoerg FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(), ContainingType,
54106f32e7eSjoerg MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
54206f32e7eSjoerg MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
54306f32e7eSjoerg
54406f32e7eSjoerg StringRef OldLinkageName = MDS->getLinkageName();
54506f32e7eSjoerg
54606f32e7eSjoerg // See if we need to make a distinct one.
54706f32e7eSjoerg auto OrigLinkage = NewToLinkageName.find(NewMDS);
54806f32e7eSjoerg if (OrigLinkage != NewToLinkageName.end()) {
54906f32e7eSjoerg if (OrigLinkage->second == OldLinkageName)
55006f32e7eSjoerg // We're good.
55106f32e7eSjoerg return NewMDS;
55206f32e7eSjoerg
55306f32e7eSjoerg // Otherwise, need to make a distinct one.
55406f32e7eSjoerg // TODO: Query the map to see if we already have one.
55506f32e7eSjoerg return distinctMDSubprogram();
55606f32e7eSjoerg }
55706f32e7eSjoerg
55806f32e7eSjoerg NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
55906f32e7eSjoerg return NewMDS;
56006f32e7eSjoerg }
56106f32e7eSjoerg
56206f32e7eSjoerg /// Create a new compile unit, to replace the one given
getReplacementCU(DICompileUnit * CU)56306f32e7eSjoerg DICompileUnit *getReplacementCU(DICompileUnit *CU) {
56406f32e7eSjoerg // Drop skeleton CUs.
56506f32e7eSjoerg if (CU->getDWOId())
56606f32e7eSjoerg return nullptr;
56706f32e7eSjoerg
56806f32e7eSjoerg auto *File = cast_or_null<DIFile>(map(CU->getFile()));
56906f32e7eSjoerg MDTuple *EnumTypes = nullptr;
57006f32e7eSjoerg MDTuple *RetainedTypes = nullptr;
57106f32e7eSjoerg MDTuple *GlobalVariables = nullptr;
57206f32e7eSjoerg MDTuple *ImportedEntities = nullptr;
57306f32e7eSjoerg return DICompileUnit::getDistinct(
57406f32e7eSjoerg CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
57506f32e7eSjoerg CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
57606f32e7eSjoerg CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
57706f32e7eSjoerg RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
57806f32e7eSjoerg CU->getDWOId(), CU->getSplitDebugInlining(),
57906f32e7eSjoerg CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
580*da58b97aSjoerg CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK());
58106f32e7eSjoerg }
58206f32e7eSjoerg
getReplacementMDLocation(DILocation * MLD)58306f32e7eSjoerg DILocation *getReplacementMDLocation(DILocation *MLD) {
58406f32e7eSjoerg auto *Scope = map(MLD->getScope());
58506f32e7eSjoerg auto *InlinedAt = map(MLD->getInlinedAt());
58606f32e7eSjoerg if (MLD->isDistinct())
58706f32e7eSjoerg return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
58806f32e7eSjoerg MLD->getColumn(), Scope, InlinedAt);
58906f32e7eSjoerg return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
59006f32e7eSjoerg Scope, InlinedAt);
59106f32e7eSjoerg }
59206f32e7eSjoerg
59306f32e7eSjoerg /// Create a new generic MDNode, to replace the one given
getReplacementMDNode(MDNode * N)59406f32e7eSjoerg MDNode *getReplacementMDNode(MDNode *N) {
59506f32e7eSjoerg SmallVector<Metadata *, 8> Ops;
59606f32e7eSjoerg Ops.reserve(N->getNumOperands());
59706f32e7eSjoerg for (auto &I : N->operands())
59806f32e7eSjoerg if (I)
59906f32e7eSjoerg Ops.push_back(map(I));
60006f32e7eSjoerg auto *Ret = MDNode::get(N->getContext(), Ops);
60106f32e7eSjoerg return Ret;
60206f32e7eSjoerg }
60306f32e7eSjoerg
60406f32e7eSjoerg /// Attempt to re-map N to a newly created node.
remap(MDNode * N)60506f32e7eSjoerg void remap(MDNode *N) {
60606f32e7eSjoerg if (Replacements.count(N))
60706f32e7eSjoerg return;
60806f32e7eSjoerg
60906f32e7eSjoerg auto doRemap = [&](MDNode *N) -> MDNode * {
61006f32e7eSjoerg if (!N)
61106f32e7eSjoerg return nullptr;
61206f32e7eSjoerg if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
61306f32e7eSjoerg remap(MDSub->getUnit());
61406f32e7eSjoerg return getReplacementSubprogram(MDSub);
61506f32e7eSjoerg }
61606f32e7eSjoerg if (isa<DISubroutineType>(N))
61706f32e7eSjoerg return EmptySubroutineType;
61806f32e7eSjoerg if (auto *CU = dyn_cast<DICompileUnit>(N))
61906f32e7eSjoerg return getReplacementCU(CU);
62006f32e7eSjoerg if (isa<DIFile>(N))
62106f32e7eSjoerg return N;
62206f32e7eSjoerg if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
62306f32e7eSjoerg // Remap to our referenced scope (recursively).
62406f32e7eSjoerg return mapNode(MDLB->getScope());
62506f32e7eSjoerg if (auto *MLD = dyn_cast<DILocation>(N))
62606f32e7eSjoerg return getReplacementMDLocation(MLD);
62706f32e7eSjoerg
62806f32e7eSjoerg // Otherwise, if we see these, just drop them now. Not strictly necessary,
62906f32e7eSjoerg // but this speeds things up a little.
63006f32e7eSjoerg if (isa<DINode>(N))
63106f32e7eSjoerg return nullptr;
63206f32e7eSjoerg
63306f32e7eSjoerg return getReplacementMDNode(N);
63406f32e7eSjoerg };
63506f32e7eSjoerg Replacements[N] = doRemap(N);
63606f32e7eSjoerg }
63706f32e7eSjoerg
63806f32e7eSjoerg /// Do the remapping traversal.
63906f32e7eSjoerg void traverse(MDNode *);
64006f32e7eSjoerg };
64106f32e7eSjoerg
64206f32e7eSjoerg } // end anonymous namespace
64306f32e7eSjoerg
traverse(MDNode * N)64406f32e7eSjoerg void DebugTypeInfoRemoval::traverse(MDNode *N) {
64506f32e7eSjoerg if (!N || Replacements.count(N))
64606f32e7eSjoerg return;
64706f32e7eSjoerg
64806f32e7eSjoerg // To avoid cycles, as well as for efficiency sake, we will sometimes prune
64906f32e7eSjoerg // parts of the graph.
65006f32e7eSjoerg auto prune = [](MDNode *Parent, MDNode *Child) {
65106f32e7eSjoerg if (auto *MDS = dyn_cast<DISubprogram>(Parent))
65206f32e7eSjoerg return Child == MDS->getRetainedNodes().get();
65306f32e7eSjoerg return false;
65406f32e7eSjoerg };
65506f32e7eSjoerg
65606f32e7eSjoerg SmallVector<MDNode *, 16> ToVisit;
65706f32e7eSjoerg DenseSet<MDNode *> Opened;
65806f32e7eSjoerg
65906f32e7eSjoerg // Visit each node starting at N in post order, and map them.
66006f32e7eSjoerg ToVisit.push_back(N);
66106f32e7eSjoerg while (!ToVisit.empty()) {
66206f32e7eSjoerg auto *N = ToVisit.back();
66306f32e7eSjoerg if (!Opened.insert(N).second) {
66406f32e7eSjoerg // Close it.
66506f32e7eSjoerg remap(N);
66606f32e7eSjoerg ToVisit.pop_back();
66706f32e7eSjoerg continue;
66806f32e7eSjoerg }
66906f32e7eSjoerg for (auto &I : N->operands())
67006f32e7eSjoerg if (auto *MDN = dyn_cast_or_null<MDNode>(I))
67106f32e7eSjoerg if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
67206f32e7eSjoerg !isa<DICompileUnit>(MDN))
67306f32e7eSjoerg ToVisit.push_back(MDN);
67406f32e7eSjoerg }
67506f32e7eSjoerg }
67606f32e7eSjoerg
stripNonLineTableDebugInfo(Module & M)67706f32e7eSjoerg bool llvm::stripNonLineTableDebugInfo(Module &M) {
67806f32e7eSjoerg bool Changed = false;
67906f32e7eSjoerg
68006f32e7eSjoerg // First off, delete the debug intrinsics.
68106f32e7eSjoerg auto RemoveUses = [&](StringRef Name) {
68206f32e7eSjoerg if (auto *DbgVal = M.getFunction(Name)) {
68306f32e7eSjoerg while (!DbgVal->use_empty())
68406f32e7eSjoerg cast<Instruction>(DbgVal->user_back())->eraseFromParent();
68506f32e7eSjoerg DbgVal->eraseFromParent();
68606f32e7eSjoerg Changed = true;
68706f32e7eSjoerg }
68806f32e7eSjoerg };
689*da58b97aSjoerg RemoveUses("llvm.dbg.addr");
69006f32e7eSjoerg RemoveUses("llvm.dbg.declare");
691*da58b97aSjoerg RemoveUses("llvm.dbg.label");
69206f32e7eSjoerg RemoveUses("llvm.dbg.value");
69306f32e7eSjoerg
69406f32e7eSjoerg // Delete non-CU debug info named metadata nodes.
69506f32e7eSjoerg for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
69606f32e7eSjoerg NMI != NME;) {
69706f32e7eSjoerg NamedMDNode *NMD = &*NMI;
69806f32e7eSjoerg ++NMI;
69906f32e7eSjoerg // Specifically keep dbg.cu around.
70006f32e7eSjoerg if (NMD->getName() == "llvm.dbg.cu")
70106f32e7eSjoerg continue;
70206f32e7eSjoerg }
70306f32e7eSjoerg
70406f32e7eSjoerg // Drop all dbg attachments from global variables.
70506f32e7eSjoerg for (auto &GV : M.globals())
70606f32e7eSjoerg GV.eraseMetadata(LLVMContext::MD_dbg);
70706f32e7eSjoerg
70806f32e7eSjoerg DebugTypeInfoRemoval Mapper(M.getContext());
70906f32e7eSjoerg auto remap = [&](MDNode *Node) -> MDNode * {
71006f32e7eSjoerg if (!Node)
71106f32e7eSjoerg return nullptr;
71206f32e7eSjoerg Mapper.traverseAndRemap(Node);
71306f32e7eSjoerg auto *NewNode = Mapper.mapNode(Node);
71406f32e7eSjoerg Changed |= Node != NewNode;
71506f32e7eSjoerg Node = NewNode;
71606f32e7eSjoerg return NewNode;
71706f32e7eSjoerg };
71806f32e7eSjoerg
71906f32e7eSjoerg // Rewrite the DebugLocs to be equivalent to what
72006f32e7eSjoerg // -gline-tables-only would have created.
72106f32e7eSjoerg for (auto &F : M) {
72206f32e7eSjoerg if (auto *SP = F.getSubprogram()) {
72306f32e7eSjoerg Mapper.traverseAndRemap(SP);
72406f32e7eSjoerg auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
72506f32e7eSjoerg Changed |= SP != NewSP;
72606f32e7eSjoerg F.setSubprogram(NewSP);
72706f32e7eSjoerg }
72806f32e7eSjoerg for (auto &BB : F) {
72906f32e7eSjoerg for (auto &I : BB) {
730*da58b97aSjoerg auto remapDebugLoc = [&](const DebugLoc &DL) -> DebugLoc {
73106f32e7eSjoerg auto *Scope = DL.getScope();
73206f32e7eSjoerg MDNode *InlinedAt = DL.getInlinedAt();
73306f32e7eSjoerg Scope = remap(Scope);
73406f32e7eSjoerg InlinedAt = remap(InlinedAt);
735*da58b97aSjoerg return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(),
736*da58b97aSjoerg Scope, InlinedAt);
73706f32e7eSjoerg };
73806f32e7eSjoerg
73906f32e7eSjoerg if (I.getDebugLoc() != DebugLoc())
74006f32e7eSjoerg I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
74106f32e7eSjoerg
742*da58b97aSjoerg // Remap DILocations in llvm.loop attachments.
743*da58b97aSjoerg updateLoopMetadataDebugLocations(I, [&](const DILocation &Loc) {
744*da58b97aSjoerg return remapDebugLoc(&Loc).get();
745*da58b97aSjoerg });
746*da58b97aSjoerg
747*da58b97aSjoerg // Strip heapallocsite attachments, they point into the DIType system.
748*da58b97aSjoerg if (I.hasMetadataOtherThanDebugLoc())
749*da58b97aSjoerg I.setMetadata("heapallocsite", nullptr);
75006f32e7eSjoerg }
75106f32e7eSjoerg }
75206f32e7eSjoerg }
75306f32e7eSjoerg
75406f32e7eSjoerg // Create a new llvm.dbg.cu, which is equivalent to the one
75506f32e7eSjoerg // -gline-tables-only would have created.
75606f32e7eSjoerg for (auto &NMD : M.getNamedMDList()) {
75706f32e7eSjoerg SmallVector<MDNode *, 8> Ops;
75806f32e7eSjoerg for (MDNode *Op : NMD.operands())
75906f32e7eSjoerg Ops.push_back(remap(Op));
76006f32e7eSjoerg
76106f32e7eSjoerg if (!Changed)
76206f32e7eSjoerg continue;
76306f32e7eSjoerg
76406f32e7eSjoerg NMD.clearOperands();
76506f32e7eSjoerg for (auto *Op : Ops)
76606f32e7eSjoerg if (Op)
76706f32e7eSjoerg NMD.addOperand(Op);
76806f32e7eSjoerg }
76906f32e7eSjoerg return Changed;
77006f32e7eSjoerg }
77106f32e7eSjoerg
getDebugMetadataVersionFromModule(const Module & M)77206f32e7eSjoerg unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
77306f32e7eSjoerg if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
77406f32e7eSjoerg M.getModuleFlag("Debug Info Version")))
77506f32e7eSjoerg return Val->getZExtValue();
77606f32e7eSjoerg return 0;
77706f32e7eSjoerg }
77806f32e7eSjoerg
applyMergedLocation(const DILocation * LocA,const DILocation * LocB)77906f32e7eSjoerg void Instruction::applyMergedLocation(const DILocation *LocA,
78006f32e7eSjoerg const DILocation *LocB) {
78106f32e7eSjoerg setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
78206f32e7eSjoerg }
78306f32e7eSjoerg
updateLocationAfterHoist()784*da58b97aSjoerg void Instruction::updateLocationAfterHoist() { dropLocation(); }
785*da58b97aSjoerg
dropLocation()786*da58b97aSjoerg void Instruction::dropLocation() {
787*da58b97aSjoerg const DebugLoc &DL = getDebugLoc();
788*da58b97aSjoerg if (!DL)
789*da58b97aSjoerg return;
790*da58b97aSjoerg
791*da58b97aSjoerg // If this isn't a call, drop the location to allow a location from a
792*da58b97aSjoerg // preceding instruction to propagate.
793*da58b97aSjoerg if (!isa<CallBase>(this)) {
794*da58b97aSjoerg setDebugLoc(DebugLoc());
795*da58b97aSjoerg return;
796*da58b97aSjoerg }
797*da58b97aSjoerg
798*da58b97aSjoerg // Set a line 0 location for calls to preserve scope information in case
799*da58b97aSjoerg // inlining occurs.
800*da58b97aSjoerg DISubprogram *SP = getFunction()->getSubprogram();
801*da58b97aSjoerg if (SP)
802*da58b97aSjoerg // If a function scope is available, set it on the line 0 location. When
803*da58b97aSjoerg // hoisting a call to a predecessor block, using the function scope avoids
804*da58b97aSjoerg // making it look like the callee was reached earlier than it should be.
805*da58b97aSjoerg setDebugLoc(DILocation::get(getContext(), 0, 0, SP));
806*da58b97aSjoerg else
807*da58b97aSjoerg // The parent function has no scope. Go ahead and drop the location. If
808*da58b97aSjoerg // the parent function is inlined, and the callee has a subprogram, the
809*da58b97aSjoerg // inliner will attach a location to the call.
810*da58b97aSjoerg //
811*da58b97aSjoerg // One alternative is to set a line 0 location with the existing scope and
812*da58b97aSjoerg // inlinedAt info. The location might be sensitive to when inlining occurs.
813*da58b97aSjoerg setDebugLoc(DebugLoc());
814*da58b97aSjoerg }
815*da58b97aSjoerg
81606f32e7eSjoerg //===----------------------------------------------------------------------===//
81706f32e7eSjoerg // LLVM C API implementations.
81806f32e7eSjoerg //===----------------------------------------------------------------------===//
81906f32e7eSjoerg
map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)82006f32e7eSjoerg static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
82106f32e7eSjoerg switch (lang) {
82206f32e7eSjoerg #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
82306f32e7eSjoerg case LLVMDWARFSourceLanguage##NAME: \
82406f32e7eSjoerg return ID;
82506f32e7eSjoerg #include "llvm/BinaryFormat/Dwarf.def"
82606f32e7eSjoerg #undef HANDLE_DW_LANG
82706f32e7eSjoerg }
82806f32e7eSjoerg llvm_unreachable("Unhandled Tag");
82906f32e7eSjoerg }
83006f32e7eSjoerg
unwrapDI(LLVMMetadataRef Ref)83106f32e7eSjoerg template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
83206f32e7eSjoerg return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
83306f32e7eSjoerg }
83406f32e7eSjoerg
map_from_llvmDIFlags(LLVMDIFlags Flags)83506f32e7eSjoerg static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags) {
83606f32e7eSjoerg return static_cast<DINode::DIFlags>(Flags);
83706f32e7eSjoerg }
83806f32e7eSjoerg
map_to_llvmDIFlags(DINode::DIFlags Flags)83906f32e7eSjoerg static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags) {
84006f32e7eSjoerg return static_cast<LLVMDIFlags>(Flags);
84106f32e7eSjoerg }
84206f32e7eSjoerg
84306f32e7eSjoerg static DISubprogram::DISPFlags
pack_into_DISPFlags(bool IsLocalToUnit,bool IsDefinition,bool IsOptimized)84406f32e7eSjoerg pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
84506f32e7eSjoerg return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
84606f32e7eSjoerg }
84706f32e7eSjoerg
LLVMDebugMetadataVersion()84806f32e7eSjoerg unsigned LLVMDebugMetadataVersion() {
84906f32e7eSjoerg return DEBUG_METADATA_VERSION;
85006f32e7eSjoerg }
85106f32e7eSjoerg
LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M)85206f32e7eSjoerg LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M) {
85306f32e7eSjoerg return wrap(new DIBuilder(*unwrap(M), false));
85406f32e7eSjoerg }
85506f32e7eSjoerg
LLVMCreateDIBuilder(LLVMModuleRef M)85606f32e7eSjoerg LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M) {
85706f32e7eSjoerg return wrap(new DIBuilder(*unwrap(M)));
85806f32e7eSjoerg }
85906f32e7eSjoerg
LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M)86006f32e7eSjoerg unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M) {
86106f32e7eSjoerg return getDebugMetadataVersionFromModule(*unwrap(M));
86206f32e7eSjoerg }
86306f32e7eSjoerg
LLVMStripModuleDebugInfo(LLVMModuleRef M)86406f32e7eSjoerg LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M) {
86506f32e7eSjoerg return StripDebugInfo(*unwrap(M));
86606f32e7eSjoerg }
86706f32e7eSjoerg
LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)86806f32e7eSjoerg void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder) {
86906f32e7eSjoerg delete unwrap(Builder);
87006f32e7eSjoerg }
87106f32e7eSjoerg
LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)87206f32e7eSjoerg void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder) {
87306f32e7eSjoerg unwrap(Builder)->finalize();
87406f32e7eSjoerg }
87506f32e7eSjoerg
LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Builder,LLVMDWARFSourceLanguage Lang,LLVMMetadataRef FileRef,const char * Producer,size_t ProducerLen,LLVMBool isOptimized,const char * Flags,size_t FlagsLen,unsigned RuntimeVer,const char * SplitName,size_t SplitNameLen,LLVMDWARFEmissionKind Kind,unsigned DWOId,LLVMBool SplitDebugInlining,LLVMBool DebugInfoForProfiling,const char * SysRoot,size_t SysRootLen,const char * SDK,size_t SDKLen)87606f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
87706f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
87806f32e7eSjoerg LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
87906f32e7eSjoerg LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
88006f32e7eSjoerg unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
88106f32e7eSjoerg LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
882*da58b97aSjoerg LLVMBool DebugInfoForProfiling, const char *SysRoot, size_t SysRootLen,
883*da58b97aSjoerg const char *SDK, size_t SDKLen) {
88406f32e7eSjoerg auto File = unwrapDI<DIFile>(FileRef);
88506f32e7eSjoerg
88606f32e7eSjoerg return wrap(unwrap(Builder)->createCompileUnit(
88706f32e7eSjoerg map_from_llvmDWARFsourcelanguage(Lang), File,
888*da58b97aSjoerg StringRef(Producer, ProducerLen), isOptimized, StringRef(Flags, FlagsLen),
889*da58b97aSjoerg RuntimeVer, StringRef(SplitName, SplitNameLen),
89006f32e7eSjoerg static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
891*da58b97aSjoerg SplitDebugInlining, DebugInfoForProfiling,
892*da58b97aSjoerg DICompileUnit::DebugNameTableKind::Default, false,
893*da58b97aSjoerg StringRef(SysRoot, SysRootLen), StringRef(SDK, SDKLen)));
89406f32e7eSjoerg }
89506f32e7eSjoerg
89606f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder,const char * Filename,size_t FilenameLen,const char * Directory,size_t DirectoryLen)89706f32e7eSjoerg LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
89806f32e7eSjoerg size_t FilenameLen, const char *Directory,
89906f32e7eSjoerg size_t DirectoryLen) {
90006f32e7eSjoerg return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
90106f32e7eSjoerg StringRef(Directory, DirectoryLen)));
90206f32e7eSjoerg }
90306f32e7eSjoerg
90406f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder,LLVMMetadataRef ParentScope,const char * Name,size_t NameLen,const char * ConfigMacros,size_t ConfigMacrosLen,const char * IncludePath,size_t IncludePathLen,const char * APINotesFile,size_t APINotesFileLen)90506f32e7eSjoerg LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope,
90606f32e7eSjoerg const char *Name, size_t NameLen,
90706f32e7eSjoerg const char *ConfigMacros, size_t ConfigMacrosLen,
90806f32e7eSjoerg const char *IncludePath, size_t IncludePathLen,
909*da58b97aSjoerg const char *APINotesFile, size_t APINotesFileLen) {
91006f32e7eSjoerg return wrap(unwrap(Builder)->createModule(
91106f32e7eSjoerg unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
91206f32e7eSjoerg StringRef(ConfigMacros, ConfigMacrosLen),
91306f32e7eSjoerg StringRef(IncludePath, IncludePathLen),
914*da58b97aSjoerg StringRef(APINotesFile, APINotesFileLen)));
91506f32e7eSjoerg }
91606f32e7eSjoerg
LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder,LLVMMetadataRef ParentScope,const char * Name,size_t NameLen,LLVMBool ExportSymbols)91706f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder,
91806f32e7eSjoerg LLVMMetadataRef ParentScope,
91906f32e7eSjoerg const char *Name, size_t NameLen,
92006f32e7eSjoerg LLVMBool ExportSymbols) {
92106f32e7eSjoerg return wrap(unwrap(Builder)->createNameSpace(
92206f32e7eSjoerg unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
92306f32e7eSjoerg }
92406f32e7eSjoerg
LLVMDIBuilderCreateFunction(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,const char * LinkageName,size_t LinkageNameLen,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Ty,LLVMBool IsLocalToUnit,LLVMBool IsDefinition,unsigned ScopeLine,LLVMDIFlags Flags,LLVMBool IsOptimized)92506f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateFunction(
92606f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
92706f32e7eSjoerg size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
92806f32e7eSjoerg LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
92906f32e7eSjoerg LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
93006f32e7eSjoerg unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
93106f32e7eSjoerg return wrap(unwrap(Builder)->createFunction(
93206f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
93306f32e7eSjoerg unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
93406f32e7eSjoerg map_from_llvmDIFlags(Flags),
93506f32e7eSjoerg pack_into_DISPFlags(IsLocalToUnit, IsDefinition, IsOptimized), nullptr,
93606f32e7eSjoerg nullptr, nullptr));
93706f32e7eSjoerg }
93806f32e7eSjoerg
93906f32e7eSjoerg
LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef File,unsigned Line,unsigned Col)94006f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
94106f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
94206f32e7eSjoerg LLVMMetadataRef File, unsigned Line, unsigned Col) {
94306f32e7eSjoerg return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
94406f32e7eSjoerg unwrapDI<DIFile>(File),
94506f32e7eSjoerg Line, Col));
94606f32e7eSjoerg }
94706f32e7eSjoerg
94806f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef File,unsigned Discriminator)94906f32e7eSjoerg LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
95006f32e7eSjoerg LLVMMetadataRef Scope,
95106f32e7eSjoerg LLVMMetadataRef File,
95206f32e7eSjoerg unsigned Discriminator) {
95306f32e7eSjoerg return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
95406f32e7eSjoerg unwrapDI<DIFile>(File),
95506f32e7eSjoerg Discriminator));
95606f32e7eSjoerg }
95706f32e7eSjoerg
95806f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef NS,LLVMMetadataRef File,unsigned Line)95906f32e7eSjoerg LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder,
96006f32e7eSjoerg LLVMMetadataRef Scope,
96106f32e7eSjoerg LLVMMetadataRef NS,
96206f32e7eSjoerg LLVMMetadataRef File,
96306f32e7eSjoerg unsigned Line) {
96406f32e7eSjoerg return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
96506f32e7eSjoerg unwrapDI<DINamespace>(NS),
96606f32e7eSjoerg unwrapDI<DIFile>(File),
96706f32e7eSjoerg Line));
96806f32e7eSjoerg }
96906f32e7eSjoerg
97006f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef ImportedEntity,LLVMMetadataRef File,unsigned Line)97106f32e7eSjoerg LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,
97206f32e7eSjoerg LLVMMetadataRef Scope,
97306f32e7eSjoerg LLVMMetadataRef ImportedEntity,
97406f32e7eSjoerg LLVMMetadataRef File,
97506f32e7eSjoerg unsigned Line) {
97606f32e7eSjoerg return wrap(unwrap(Builder)->createImportedModule(
97706f32e7eSjoerg unwrapDI<DIScope>(Scope),
97806f32e7eSjoerg unwrapDI<DIImportedEntity>(ImportedEntity),
97906f32e7eSjoerg unwrapDI<DIFile>(File), Line));
98006f32e7eSjoerg }
98106f32e7eSjoerg
98206f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef M,LLVMMetadataRef File,unsigned Line)98306f32e7eSjoerg LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,
98406f32e7eSjoerg LLVMMetadataRef Scope,
98506f32e7eSjoerg LLVMMetadataRef M,
98606f32e7eSjoerg LLVMMetadataRef File,
98706f32e7eSjoerg unsigned Line) {
98806f32e7eSjoerg return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
98906f32e7eSjoerg unwrapDI<DIModule>(M),
99006f32e7eSjoerg unwrapDI<DIFile>(File),
99106f32e7eSjoerg Line));
99206f32e7eSjoerg }
99306f32e7eSjoerg
99406f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,LLVMMetadataRef Decl,LLVMMetadataRef File,unsigned Line,const char * Name,size_t NameLen)99506f32e7eSjoerg LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,
99606f32e7eSjoerg LLVMMetadataRef Scope,
99706f32e7eSjoerg LLVMMetadataRef Decl,
99806f32e7eSjoerg LLVMMetadataRef File,
99906f32e7eSjoerg unsigned Line,
100006f32e7eSjoerg const char *Name, size_t NameLen) {
100106f32e7eSjoerg return wrap(unwrap(Builder)->createImportedDeclaration(
100206f32e7eSjoerg unwrapDI<DIScope>(Scope),
100306f32e7eSjoerg unwrapDI<DINode>(Decl),
100406f32e7eSjoerg unwrapDI<DIFile>(File), Line, {Name, NameLen}));
100506f32e7eSjoerg }
100606f32e7eSjoerg
100706f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx,unsigned Line,unsigned Column,LLVMMetadataRef Scope,LLVMMetadataRef InlinedAt)100806f32e7eSjoerg LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
100906f32e7eSjoerg unsigned Column, LLVMMetadataRef Scope,
101006f32e7eSjoerg LLVMMetadataRef InlinedAt) {
101106f32e7eSjoerg return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
101206f32e7eSjoerg unwrap(InlinedAt)));
101306f32e7eSjoerg }
101406f32e7eSjoerg
LLVMDILocationGetLine(LLVMMetadataRef Location)101506f32e7eSjoerg unsigned LLVMDILocationGetLine(LLVMMetadataRef Location) {
101606f32e7eSjoerg return unwrapDI<DILocation>(Location)->getLine();
101706f32e7eSjoerg }
101806f32e7eSjoerg
LLVMDILocationGetColumn(LLVMMetadataRef Location)101906f32e7eSjoerg unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location) {
102006f32e7eSjoerg return unwrapDI<DILocation>(Location)->getColumn();
102106f32e7eSjoerg }
102206f32e7eSjoerg
LLVMDILocationGetScope(LLVMMetadataRef Location)102306f32e7eSjoerg LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location) {
102406f32e7eSjoerg return wrap(unwrapDI<DILocation>(Location)->getScope());
102506f32e7eSjoerg }
102606f32e7eSjoerg
LLVMDILocationGetInlinedAt(LLVMMetadataRef Location)102706f32e7eSjoerg LLVMMetadataRef LLVMDILocationGetInlinedAt(LLVMMetadataRef Location) {
102806f32e7eSjoerg return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
102906f32e7eSjoerg }
103006f32e7eSjoerg
LLVMDIScopeGetFile(LLVMMetadataRef Scope)103106f32e7eSjoerg LLVMMetadataRef LLVMDIScopeGetFile(LLVMMetadataRef Scope) {
103206f32e7eSjoerg return wrap(unwrapDI<DIScope>(Scope)->getFile());
103306f32e7eSjoerg }
103406f32e7eSjoerg
LLVMDIFileGetDirectory(LLVMMetadataRef File,unsigned * Len)103506f32e7eSjoerg const char *LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len) {
103606f32e7eSjoerg auto Dir = unwrapDI<DIFile>(File)->getDirectory();
103706f32e7eSjoerg *Len = Dir.size();
103806f32e7eSjoerg return Dir.data();
103906f32e7eSjoerg }
104006f32e7eSjoerg
LLVMDIFileGetFilename(LLVMMetadataRef File,unsigned * Len)104106f32e7eSjoerg const char *LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len) {
104206f32e7eSjoerg auto Name = unwrapDI<DIFile>(File)->getFilename();
104306f32e7eSjoerg *Len = Name.size();
104406f32e7eSjoerg return Name.data();
104506f32e7eSjoerg }
104606f32e7eSjoerg
LLVMDIFileGetSource(LLVMMetadataRef File,unsigned * Len)104706f32e7eSjoerg const char *LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len) {
104806f32e7eSjoerg if (auto Src = unwrapDI<DIFile>(File)->getSource()) {
104906f32e7eSjoerg *Len = Src->size();
105006f32e7eSjoerg return Src->data();
105106f32e7eSjoerg }
105206f32e7eSjoerg *Len = 0;
105306f32e7eSjoerg return "";
105406f32e7eSjoerg }
105506f32e7eSjoerg
LLVMDIBuilderCreateMacro(LLVMDIBuilderRef Builder,LLVMMetadataRef ParentMacroFile,unsigned Line,LLVMDWARFMacinfoRecordType RecordType,const char * Name,size_t NameLen,const char * Value,size_t ValueLen)105606f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateMacro(LLVMDIBuilderRef Builder,
105706f32e7eSjoerg LLVMMetadataRef ParentMacroFile,
105806f32e7eSjoerg unsigned Line,
105906f32e7eSjoerg LLVMDWARFMacinfoRecordType RecordType,
106006f32e7eSjoerg const char *Name, size_t NameLen,
106106f32e7eSjoerg const char *Value, size_t ValueLen) {
106206f32e7eSjoerg return wrap(
106306f32e7eSjoerg unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
106406f32e7eSjoerg static_cast<MacinfoRecordType>(RecordType),
106506f32e7eSjoerg {Name, NameLen}, {Value, ValueLen}));
106606f32e7eSjoerg }
106706f32e7eSjoerg
106806f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder,LLVMMetadataRef ParentMacroFile,unsigned Line,LLVMMetadataRef File)106906f32e7eSjoerg LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder,
107006f32e7eSjoerg LLVMMetadataRef ParentMacroFile, unsigned Line,
107106f32e7eSjoerg LLVMMetadataRef File) {
107206f32e7eSjoerg return wrap(unwrap(Builder)->createTempMacroFile(
107306f32e7eSjoerg unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
107406f32e7eSjoerg }
107506f32e7eSjoerg
LLVMDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder,const char * Name,size_t NameLen,int64_t Value,LLVMBool IsUnsigned)107606f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder,
107706f32e7eSjoerg const char *Name, size_t NameLen,
107806f32e7eSjoerg int64_t Value,
107906f32e7eSjoerg LLVMBool IsUnsigned) {
108006f32e7eSjoerg return wrap(unwrap(Builder)->createEnumerator({Name, NameLen}, Value,
108106f32e7eSjoerg IsUnsigned != 0));
108206f32e7eSjoerg }
108306f32e7eSjoerg
LLVMDIBuilderCreateEnumerationType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,uint64_t SizeInBits,uint32_t AlignInBits,LLVMMetadataRef * Elements,unsigned NumElements,LLVMMetadataRef ClassTy)108406f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(
108506f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
108606f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
108706f32e7eSjoerg uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
108806f32e7eSjoerg unsigned NumElements, LLVMMetadataRef ClassTy) {
108906f32e7eSjoerg auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
109006f32e7eSjoerg NumElements});
109106f32e7eSjoerg return wrap(unwrap(Builder)->createEnumerationType(
109206f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
109306f32e7eSjoerg LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
109406f32e7eSjoerg }
109506f32e7eSjoerg
LLVMDIBuilderCreateUnionType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,uint64_t SizeInBits,uint32_t AlignInBits,LLVMDIFlags Flags,LLVMMetadataRef * Elements,unsigned NumElements,unsigned RunTimeLang,const char * UniqueId,size_t UniqueIdLen)109606f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateUnionType(
109706f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
109806f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
109906f32e7eSjoerg uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
110006f32e7eSjoerg LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
110106f32e7eSjoerg const char *UniqueId, size_t UniqueIdLen) {
110206f32e7eSjoerg auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
110306f32e7eSjoerg NumElements});
110406f32e7eSjoerg return wrap(unwrap(Builder)->createUnionType(
110506f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
110606f32e7eSjoerg LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
110706f32e7eSjoerg Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
110806f32e7eSjoerg }
110906f32e7eSjoerg
111006f32e7eSjoerg
111106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder,uint64_t Size,uint32_t AlignInBits,LLVMMetadataRef Ty,LLVMMetadataRef * Subscripts,unsigned NumSubscripts)111206f32e7eSjoerg LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size,
111306f32e7eSjoerg uint32_t AlignInBits, LLVMMetadataRef Ty,
111406f32e7eSjoerg LLVMMetadataRef *Subscripts,
111506f32e7eSjoerg unsigned NumSubscripts) {
111606f32e7eSjoerg auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
111706f32e7eSjoerg NumSubscripts});
111806f32e7eSjoerg return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
111906f32e7eSjoerg unwrapDI<DIType>(Ty), Subs));
112006f32e7eSjoerg }
112106f32e7eSjoerg
112206f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder,uint64_t Size,uint32_t AlignInBits,LLVMMetadataRef Ty,LLVMMetadataRef * Subscripts,unsigned NumSubscripts)112306f32e7eSjoerg LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, uint64_t Size,
112406f32e7eSjoerg uint32_t AlignInBits, LLVMMetadataRef Ty,
112506f32e7eSjoerg LLVMMetadataRef *Subscripts,
112606f32e7eSjoerg unsigned NumSubscripts) {
112706f32e7eSjoerg auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
112806f32e7eSjoerg NumSubscripts});
112906f32e7eSjoerg return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
113006f32e7eSjoerg unwrapDI<DIType>(Ty), Subs));
113106f32e7eSjoerg }
113206f32e7eSjoerg
113306f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder,const char * Name,size_t NameLen,uint64_t SizeInBits,LLVMDWARFTypeEncoding Encoding,LLVMDIFlags Flags)113406f32e7eSjoerg LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
113506f32e7eSjoerg size_t NameLen, uint64_t SizeInBits,
113606f32e7eSjoerg LLVMDWARFTypeEncoding Encoding,
113706f32e7eSjoerg LLVMDIFlags Flags) {
113806f32e7eSjoerg return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
113906f32e7eSjoerg SizeInBits, Encoding,
114006f32e7eSjoerg map_from_llvmDIFlags(Flags)));
114106f32e7eSjoerg }
114206f32e7eSjoerg
LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Builder,LLVMMetadataRef PointeeTy,uint64_t SizeInBits,uint32_t AlignInBits,unsigned AddressSpace,const char * Name,size_t NameLen)114306f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreatePointerType(
114406f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
114506f32e7eSjoerg uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
114606f32e7eSjoerg const char *Name, size_t NameLen) {
114706f32e7eSjoerg return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
114806f32e7eSjoerg SizeInBits, AlignInBits,
114906f32e7eSjoerg AddressSpace, {Name, NameLen}));
115006f32e7eSjoerg }
115106f32e7eSjoerg
LLVMDIBuilderCreateStructType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,uint64_t SizeInBits,uint32_t AlignInBits,LLVMDIFlags Flags,LLVMMetadataRef DerivedFrom,LLVMMetadataRef * Elements,unsigned NumElements,unsigned RunTimeLang,LLVMMetadataRef VTableHolder,const char * UniqueId,size_t UniqueIdLen)115206f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateStructType(
115306f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
115406f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
115506f32e7eSjoerg uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
115606f32e7eSjoerg LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
115706f32e7eSjoerg unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
115806f32e7eSjoerg const char *UniqueId, size_t UniqueIdLen) {
115906f32e7eSjoerg auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
116006f32e7eSjoerg NumElements});
116106f32e7eSjoerg return wrap(unwrap(Builder)->createStructType(
116206f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
116306f32e7eSjoerg LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
116406f32e7eSjoerg unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
116506f32e7eSjoerg unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
116606f32e7eSjoerg }
116706f32e7eSjoerg
LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNo,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,LLVMDIFlags Flags,LLVMMetadataRef Ty)116806f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateMemberType(
116906f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
117006f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
117106f32e7eSjoerg uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
117206f32e7eSjoerg LLVMMetadataRef Ty) {
117306f32e7eSjoerg return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
117406f32e7eSjoerg {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
117506f32e7eSjoerg OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
117606f32e7eSjoerg }
117706f32e7eSjoerg
117806f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder,const char * Name,size_t NameLen)117906f32e7eSjoerg LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name,
118006f32e7eSjoerg size_t NameLen) {
118106f32e7eSjoerg return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
118206f32e7eSjoerg }
118306f32e7eSjoerg
118406f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateStaticMemberType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,LLVMMetadataRef Type,LLVMDIFlags Flags,LLVMValueRef ConstantVal,uint32_t AlignInBits)118506f32e7eSjoerg LLVMDIBuilderCreateStaticMemberType(
118606f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
118706f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
118806f32e7eSjoerg LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
118906f32e7eSjoerg uint32_t AlignInBits) {
119006f32e7eSjoerg return wrap(unwrap(Builder)->createStaticMemberType(
119106f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen},
119206f32e7eSjoerg unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
119306f32e7eSjoerg map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
119406f32e7eSjoerg AlignInBits));
119506f32e7eSjoerg }
119606f32e7eSjoerg
119706f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNo,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,LLVMDIFlags Flags,LLVMMetadataRef Ty,LLVMMetadataRef PropertyNode)119806f32e7eSjoerg LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder,
119906f32e7eSjoerg const char *Name, size_t NameLen,
120006f32e7eSjoerg LLVMMetadataRef File, unsigned LineNo,
120106f32e7eSjoerg uint64_t SizeInBits, uint32_t AlignInBits,
120206f32e7eSjoerg uint64_t OffsetInBits, LLVMDIFlags Flags,
120306f32e7eSjoerg LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
120406f32e7eSjoerg return wrap(unwrap(Builder)->createObjCIVar(
120506f32e7eSjoerg {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
120606f32e7eSjoerg SizeInBits, AlignInBits, OffsetInBits,
120706f32e7eSjoerg map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
120806f32e7eSjoerg unwrapDI<MDNode>(PropertyNode)));
120906f32e7eSjoerg }
121006f32e7eSjoerg
121106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNo,const char * GetterName,size_t GetterNameLen,const char * SetterName,size_t SetterNameLen,unsigned PropertyAttributes,LLVMMetadataRef Ty)121206f32e7eSjoerg LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder,
121306f32e7eSjoerg const char *Name, size_t NameLen,
121406f32e7eSjoerg LLVMMetadataRef File, unsigned LineNo,
121506f32e7eSjoerg const char *GetterName, size_t GetterNameLen,
121606f32e7eSjoerg const char *SetterName, size_t SetterNameLen,
121706f32e7eSjoerg unsigned PropertyAttributes,
121806f32e7eSjoerg LLVMMetadataRef Ty) {
121906f32e7eSjoerg return wrap(unwrap(Builder)->createObjCProperty(
122006f32e7eSjoerg {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
122106f32e7eSjoerg {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
122206f32e7eSjoerg PropertyAttributes, unwrapDI<DIType>(Ty)));
122306f32e7eSjoerg }
122406f32e7eSjoerg
122506f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder,LLVMMetadataRef Type)122606f32e7eSjoerg LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder,
122706f32e7eSjoerg LLVMMetadataRef Type) {
122806f32e7eSjoerg return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
122906f32e7eSjoerg }
123006f32e7eSjoerg
123106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder,LLVMMetadataRef Type,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Scope,uint32_t AlignInBits)123206f32e7eSjoerg LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
123306f32e7eSjoerg const char *Name, size_t NameLen,
123406f32e7eSjoerg LLVMMetadataRef File, unsigned LineNo,
1235*da58b97aSjoerg LLVMMetadataRef Scope, uint32_t AlignInBits) {
123606f32e7eSjoerg return wrap(unwrap(Builder)->createTypedef(
1237*da58b97aSjoerg unwrapDI<DIType>(Type), {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1238*da58b97aSjoerg unwrapDI<DIScope>(Scope), AlignInBits));
123906f32e7eSjoerg }
124006f32e7eSjoerg
124106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder,LLVMMetadataRef Ty,LLVMMetadataRef BaseTy,uint64_t BaseOffset,uint32_t VBPtrOffset,LLVMDIFlags Flags)124206f32e7eSjoerg LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder,
124306f32e7eSjoerg LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
124406f32e7eSjoerg uint64_t BaseOffset, uint32_t VBPtrOffset,
124506f32e7eSjoerg LLVMDIFlags Flags) {
124606f32e7eSjoerg return wrap(unwrap(Builder)->createInheritance(
124706f32e7eSjoerg unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
124806f32e7eSjoerg BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
124906f32e7eSjoerg }
125006f32e7eSjoerg
125106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateForwardDecl(LLVMDIBuilderRef Builder,unsigned Tag,const char * Name,size_t NameLen,LLVMMetadataRef Scope,LLVMMetadataRef File,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint32_t AlignInBits,const char * UniqueIdentifier,size_t UniqueIdentifierLen)125206f32e7eSjoerg LLVMDIBuilderCreateForwardDecl(
125306f32e7eSjoerg LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
125406f32e7eSjoerg size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
125506f32e7eSjoerg unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
125606f32e7eSjoerg const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
125706f32e7eSjoerg return wrap(unwrap(Builder)->createForwardDecl(
125806f32e7eSjoerg Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
125906f32e7eSjoerg unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
126006f32e7eSjoerg AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
126106f32e7eSjoerg }
126206f32e7eSjoerg
126306f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateReplaceableCompositeType(LLVMDIBuilderRef Builder,unsigned Tag,const char * Name,size_t NameLen,LLVMMetadataRef Scope,LLVMMetadataRef File,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint32_t AlignInBits,LLVMDIFlags Flags,const char * UniqueIdentifier,size_t UniqueIdentifierLen)126406f32e7eSjoerg LLVMDIBuilderCreateReplaceableCompositeType(
126506f32e7eSjoerg LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
126606f32e7eSjoerg size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
126706f32e7eSjoerg unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
126806f32e7eSjoerg LLVMDIFlags Flags, const char *UniqueIdentifier,
126906f32e7eSjoerg size_t UniqueIdentifierLen) {
127006f32e7eSjoerg return wrap(unwrap(Builder)->createReplaceableCompositeType(
127106f32e7eSjoerg Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
127206f32e7eSjoerg unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
127306f32e7eSjoerg AlignInBits, map_from_llvmDIFlags(Flags),
127406f32e7eSjoerg {UniqueIdentifier, UniqueIdentifierLen}));
127506f32e7eSjoerg }
127606f32e7eSjoerg
127706f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder,unsigned Tag,LLVMMetadataRef Type)127806f32e7eSjoerg LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
127906f32e7eSjoerg LLVMMetadataRef Type) {
128006f32e7eSjoerg return wrap(unwrap(Builder)->createQualifiedType(Tag,
128106f32e7eSjoerg unwrapDI<DIType>(Type)));
128206f32e7eSjoerg }
128306f32e7eSjoerg
128406f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder,unsigned Tag,LLVMMetadataRef Type)128506f32e7eSjoerg LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag,
128606f32e7eSjoerg LLVMMetadataRef Type) {
128706f32e7eSjoerg return wrap(unwrap(Builder)->createReferenceType(Tag,
128806f32e7eSjoerg unwrapDI<DIType>(Type)));
128906f32e7eSjoerg }
129006f32e7eSjoerg
129106f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)129206f32e7eSjoerg LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder) {
129306f32e7eSjoerg return wrap(unwrap(Builder)->createNullPtrType());
129406f32e7eSjoerg }
129506f32e7eSjoerg
129606f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder,LLVMMetadataRef PointeeType,LLVMMetadataRef ClassType,uint64_t SizeInBits,uint32_t AlignInBits,LLVMDIFlags Flags)129706f32e7eSjoerg LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder,
129806f32e7eSjoerg LLVMMetadataRef PointeeType,
129906f32e7eSjoerg LLVMMetadataRef ClassType,
130006f32e7eSjoerg uint64_t SizeInBits,
130106f32e7eSjoerg uint32_t AlignInBits,
130206f32e7eSjoerg LLVMDIFlags Flags) {
130306f32e7eSjoerg return wrap(unwrap(Builder)->createMemberPointerType(
130406f32e7eSjoerg unwrapDI<DIType>(PointeeType),
130506f32e7eSjoerg unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
130606f32e7eSjoerg map_from_llvmDIFlags(Flags)));
130706f32e7eSjoerg }
130806f32e7eSjoerg
130906f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,uint64_t SizeInBits,uint64_t OffsetInBits,uint64_t StorageOffsetInBits,LLVMDIFlags Flags,LLVMMetadataRef Type)131006f32e7eSjoerg LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder,
131106f32e7eSjoerg LLVMMetadataRef Scope,
131206f32e7eSjoerg const char *Name, size_t NameLen,
131306f32e7eSjoerg LLVMMetadataRef File, unsigned LineNumber,
131406f32e7eSjoerg uint64_t SizeInBits,
131506f32e7eSjoerg uint64_t OffsetInBits,
131606f32e7eSjoerg uint64_t StorageOffsetInBits,
131706f32e7eSjoerg LLVMDIFlags Flags, LLVMMetadataRef Type) {
131806f32e7eSjoerg return wrap(unwrap(Builder)->createBitFieldMemberType(
131906f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen},
132006f32e7eSjoerg unwrapDI<DIFile>(File), LineNumber,
132106f32e7eSjoerg SizeInBits, OffsetInBits, StorageOffsetInBits,
132206f32e7eSjoerg map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
132306f32e7eSjoerg }
132406f32e7eSjoerg
LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNumber,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,LLVMDIFlags Flags,LLVMMetadataRef DerivedFrom,LLVMMetadataRef * Elements,unsigned NumElements,LLVMMetadataRef VTableHolder,LLVMMetadataRef TemplateParamsNode,const char * UniqueIdentifier,size_t UniqueIdentifierLen)132506f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder,
132606f32e7eSjoerg LLVMMetadataRef Scope, const char *Name, size_t NameLen,
132706f32e7eSjoerg LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
132806f32e7eSjoerg uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
132906f32e7eSjoerg LLVMMetadataRef DerivedFrom,
133006f32e7eSjoerg LLVMMetadataRef *Elements, unsigned NumElements,
133106f32e7eSjoerg LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
133206f32e7eSjoerg const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
133306f32e7eSjoerg auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
133406f32e7eSjoerg NumElements});
133506f32e7eSjoerg return wrap(unwrap(Builder)->createClassType(
133606f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen},
133706f32e7eSjoerg unwrapDI<DIFile>(File), LineNumber,
133806f32e7eSjoerg SizeInBits, AlignInBits, OffsetInBits,
133906f32e7eSjoerg map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
134006f32e7eSjoerg Elts, unwrapDI<DIType>(VTableHolder),
134106f32e7eSjoerg unwrapDI<MDNode>(TemplateParamsNode),
134206f32e7eSjoerg {UniqueIdentifier, UniqueIdentifierLen}));
134306f32e7eSjoerg }
134406f32e7eSjoerg
134506f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,LLVMMetadataRef Type)134606f32e7eSjoerg LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,
134706f32e7eSjoerg LLVMMetadataRef Type) {
134806f32e7eSjoerg return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
134906f32e7eSjoerg }
135006f32e7eSjoerg
LLVMDITypeGetName(LLVMMetadataRef DType,size_t * Length)135106f32e7eSjoerg const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
135206f32e7eSjoerg StringRef Str = unwrap<DIType>(DType)->getName();
135306f32e7eSjoerg *Length = Str.size();
135406f32e7eSjoerg return Str.data();
135506f32e7eSjoerg }
135606f32e7eSjoerg
LLVMDITypeGetSizeInBits(LLVMMetadataRef DType)135706f32e7eSjoerg uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType) {
135806f32e7eSjoerg return unwrapDI<DIType>(DType)->getSizeInBits();
135906f32e7eSjoerg }
136006f32e7eSjoerg
LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)136106f32e7eSjoerg uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType) {
136206f32e7eSjoerg return unwrapDI<DIType>(DType)->getOffsetInBits();
136306f32e7eSjoerg }
136406f32e7eSjoerg
LLVMDITypeGetAlignInBits(LLVMMetadataRef DType)136506f32e7eSjoerg uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType) {
136606f32e7eSjoerg return unwrapDI<DIType>(DType)->getAlignInBits();
136706f32e7eSjoerg }
136806f32e7eSjoerg
LLVMDITypeGetLine(LLVMMetadataRef DType)136906f32e7eSjoerg unsigned LLVMDITypeGetLine(LLVMMetadataRef DType) {
137006f32e7eSjoerg return unwrapDI<DIType>(DType)->getLine();
137106f32e7eSjoerg }
137206f32e7eSjoerg
LLVMDITypeGetFlags(LLVMMetadataRef DType)137306f32e7eSjoerg LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType) {
137406f32e7eSjoerg return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
137506f32e7eSjoerg }
137606f32e7eSjoerg
LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder,LLVMMetadataRef * Types,size_t Length)137706f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder,
137806f32e7eSjoerg LLVMMetadataRef *Types,
137906f32e7eSjoerg size_t Length) {
138006f32e7eSjoerg return wrap(
138106f32e7eSjoerg unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
138206f32e7eSjoerg }
138306f32e7eSjoerg
138406f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,LLVMMetadataRef File,LLVMMetadataRef * ParameterTypes,unsigned NumParameterTypes,LLVMDIFlags Flags)138506f32e7eSjoerg LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
138606f32e7eSjoerg LLVMMetadataRef File,
138706f32e7eSjoerg LLVMMetadataRef *ParameterTypes,
138806f32e7eSjoerg unsigned NumParameterTypes,
138906f32e7eSjoerg LLVMDIFlags Flags) {
139006f32e7eSjoerg auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
139106f32e7eSjoerg NumParameterTypes});
139206f32e7eSjoerg return wrap(unwrap(Builder)->createSubroutineType(
139306f32e7eSjoerg Elts, map_from_llvmDIFlags(Flags)));
139406f32e7eSjoerg }
139506f32e7eSjoerg
LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,int64_t * Addr,size_t Length)139606f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,
139706f32e7eSjoerg int64_t *Addr, size_t Length) {
139806f32e7eSjoerg return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
139906f32e7eSjoerg Length)));
140006f32e7eSjoerg }
140106f32e7eSjoerg
140206f32e7eSjoerg LLVMMetadataRef
LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,int64_t Value)140306f32e7eSjoerg LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,
140406f32e7eSjoerg int64_t Value) {
140506f32e7eSjoerg return wrap(unwrap(Builder)->createConstantValueExpression(Value));
140606f32e7eSjoerg }
140706f32e7eSjoerg
LLVMDIBuilderCreateGlobalVariableExpression(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,const char * Linkage,size_t LinkLen,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Ty,LLVMBool LocalToUnit,LLVMMetadataRef Expr,LLVMMetadataRef Decl,uint32_t AlignInBits)140806f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(
140906f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
141006f32e7eSjoerg size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
141106f32e7eSjoerg unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
141206f32e7eSjoerg LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {
141306f32e7eSjoerg return wrap(unwrap(Builder)->createGlobalVariableExpression(
141406f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
141506f32e7eSjoerg unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1416*da58b97aSjoerg true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
141706f32e7eSjoerg nullptr, AlignInBits));
141806f32e7eSjoerg }
141906f32e7eSjoerg
LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE)142006f32e7eSjoerg LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE) {
142106f32e7eSjoerg return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
142206f32e7eSjoerg }
142306f32e7eSjoerg
LLVMDIGlobalVariableExpressionGetExpression(LLVMMetadataRef GVE)142406f32e7eSjoerg LLVMMetadataRef LLVMDIGlobalVariableExpressionGetExpression(
142506f32e7eSjoerg LLVMMetadataRef GVE) {
142606f32e7eSjoerg return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
142706f32e7eSjoerg }
142806f32e7eSjoerg
LLVMDIVariableGetFile(LLVMMetadataRef Var)142906f32e7eSjoerg LLVMMetadataRef LLVMDIVariableGetFile(LLVMMetadataRef Var) {
143006f32e7eSjoerg return wrap(unwrapDI<DIVariable>(Var)->getFile());
143106f32e7eSjoerg }
143206f32e7eSjoerg
LLVMDIVariableGetScope(LLVMMetadataRef Var)143306f32e7eSjoerg LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var) {
143406f32e7eSjoerg return wrap(unwrapDI<DIVariable>(Var)->getScope());
143506f32e7eSjoerg }
143606f32e7eSjoerg
LLVMDIVariableGetLine(LLVMMetadataRef Var)143706f32e7eSjoerg unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var) {
143806f32e7eSjoerg return unwrapDI<DIVariable>(Var)->getLine();
143906f32e7eSjoerg }
144006f32e7eSjoerg
LLVMTemporaryMDNode(LLVMContextRef Ctx,LLVMMetadataRef * Data,size_t Count)144106f32e7eSjoerg LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data,
144206f32e7eSjoerg size_t Count) {
144306f32e7eSjoerg return wrap(
144406f32e7eSjoerg MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
144506f32e7eSjoerg }
144606f32e7eSjoerg
LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)144706f32e7eSjoerg void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode) {
144806f32e7eSjoerg MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
144906f32e7eSjoerg }
145006f32e7eSjoerg
LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata,LLVMMetadataRef Replacement)145106f32e7eSjoerg void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata,
145206f32e7eSjoerg LLVMMetadataRef Replacement) {
145306f32e7eSjoerg auto *Node = unwrapDI<MDNode>(TargetMetadata);
145406f32e7eSjoerg Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
145506f32e7eSjoerg MDNode::deleteTemporary(Node);
145606f32e7eSjoerg }
145706f32e7eSjoerg
LLVMDIBuilderCreateTempGlobalVariableFwdDecl(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,const char * Linkage,size_t LnkLen,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Ty,LLVMBool LocalToUnit,LLVMMetadataRef Decl,uint32_t AlignInBits)145806f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl(
145906f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
146006f32e7eSjoerg size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
146106f32e7eSjoerg unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
146206f32e7eSjoerg LLVMMetadataRef Decl, uint32_t AlignInBits) {
146306f32e7eSjoerg return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
146406f32e7eSjoerg unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
146506f32e7eSjoerg unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
146606f32e7eSjoerg unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
146706f32e7eSjoerg }
146806f32e7eSjoerg
146906f32e7eSjoerg LLVMValueRef
LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder,LLVMValueRef Storage,LLVMMetadataRef VarInfo,LLVMMetadataRef Expr,LLVMMetadataRef DL,LLVMValueRef Instr)147006f32e7eSjoerg LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage,
147106f32e7eSjoerg LLVMMetadataRef VarInfo, LLVMMetadataRef Expr,
147206f32e7eSjoerg LLVMMetadataRef DL, LLVMValueRef Instr) {
147306f32e7eSjoerg return wrap(unwrap(Builder)->insertDeclare(
147406f32e7eSjoerg unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
147506f32e7eSjoerg unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
147606f32e7eSjoerg unwrap<Instruction>(Instr)));
147706f32e7eSjoerg }
147806f32e7eSjoerg
LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder,LLVMValueRef Storage,LLVMMetadataRef VarInfo,LLVMMetadataRef Expr,LLVMMetadataRef DL,LLVMBasicBlockRef Block)147906f32e7eSjoerg LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(
148006f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
148106f32e7eSjoerg LLVMMetadataRef Expr, LLVMMetadataRef DL, LLVMBasicBlockRef Block) {
148206f32e7eSjoerg return wrap(unwrap(Builder)->insertDeclare(
148306f32e7eSjoerg unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
148406f32e7eSjoerg unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
148506f32e7eSjoerg unwrap(Block)));
148606f32e7eSjoerg }
148706f32e7eSjoerg
LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder,LLVMValueRef Val,LLVMMetadataRef VarInfo,LLVMMetadataRef Expr,LLVMMetadataRef DebugLoc,LLVMValueRef Instr)148806f32e7eSjoerg LLVMValueRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder,
148906f32e7eSjoerg LLVMValueRef Val,
149006f32e7eSjoerg LLVMMetadataRef VarInfo,
149106f32e7eSjoerg LLVMMetadataRef Expr,
149206f32e7eSjoerg LLVMMetadataRef DebugLoc,
149306f32e7eSjoerg LLVMValueRef Instr) {
149406f32e7eSjoerg return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
149506f32e7eSjoerg unwrap(Val), unwrap<DILocalVariable>(VarInfo),
149606f32e7eSjoerg unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
149706f32e7eSjoerg unwrap<Instruction>(Instr)));
149806f32e7eSjoerg }
149906f32e7eSjoerg
LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,LLVMValueRef Val,LLVMMetadataRef VarInfo,LLVMMetadataRef Expr,LLVMMetadataRef DebugLoc,LLVMBasicBlockRef Block)150006f32e7eSjoerg LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,
150106f32e7eSjoerg LLVMValueRef Val,
150206f32e7eSjoerg LLVMMetadataRef VarInfo,
150306f32e7eSjoerg LLVMMetadataRef Expr,
150406f32e7eSjoerg LLVMMetadataRef DebugLoc,
150506f32e7eSjoerg LLVMBasicBlockRef Block) {
150606f32e7eSjoerg return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
150706f32e7eSjoerg unwrap(Val), unwrap<DILocalVariable>(VarInfo),
150806f32e7eSjoerg unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
150906f32e7eSjoerg unwrap(Block)));
151006f32e7eSjoerg }
151106f32e7eSjoerg
LLVMDIBuilderCreateAutoVariable(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Ty,LLVMBool AlwaysPreserve,LLVMDIFlags Flags,uint32_t AlignInBits)151206f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
151306f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
151406f32e7eSjoerg size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
151506f32e7eSjoerg LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
151606f32e7eSjoerg return wrap(unwrap(Builder)->createAutoVariable(
151706f32e7eSjoerg unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
151806f32e7eSjoerg LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
151906f32e7eSjoerg map_from_llvmDIFlags(Flags), AlignInBits));
152006f32e7eSjoerg }
152106f32e7eSjoerg
LLVMDIBuilderCreateParameterVariable(LLVMDIBuilderRef Builder,LLVMMetadataRef Scope,const char * Name,size_t NameLen,unsigned ArgNo,LLVMMetadataRef File,unsigned LineNo,LLVMMetadataRef Ty,LLVMBool AlwaysPreserve,LLVMDIFlags Flags)152206f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
152306f32e7eSjoerg LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
152406f32e7eSjoerg size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
152506f32e7eSjoerg LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
152606f32e7eSjoerg return wrap(unwrap(Builder)->createParameterVariable(
152706f32e7eSjoerg unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
152806f32e7eSjoerg LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
152906f32e7eSjoerg map_from_llvmDIFlags(Flags)));
153006f32e7eSjoerg }
153106f32e7eSjoerg
LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder,int64_t Lo,int64_t Count)153206f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder,
153306f32e7eSjoerg int64_t Lo, int64_t Count) {
153406f32e7eSjoerg return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
153506f32e7eSjoerg }
153606f32e7eSjoerg
LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,LLVMMetadataRef * Data,size_t Length)153706f32e7eSjoerg LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,
153806f32e7eSjoerg LLVMMetadataRef *Data,
153906f32e7eSjoerg size_t Length) {
154006f32e7eSjoerg Metadata **DataValue = unwrap(Data);
154106f32e7eSjoerg return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
154206f32e7eSjoerg }
154306f32e7eSjoerg
LLVMGetSubprogram(LLVMValueRef Func)154406f32e7eSjoerg LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func) {
154506f32e7eSjoerg return wrap(unwrap<Function>(Func)->getSubprogram());
154606f32e7eSjoerg }
154706f32e7eSjoerg
LLVMSetSubprogram(LLVMValueRef Func,LLVMMetadataRef SP)154806f32e7eSjoerg void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
154906f32e7eSjoerg unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
155006f32e7eSjoerg }
155106f32e7eSjoerg
LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram)155206f32e7eSjoerg unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram) {
155306f32e7eSjoerg return unwrapDI<DISubprogram>(Subprogram)->getLine();
155406f32e7eSjoerg }
155506f32e7eSjoerg
LLVMInstructionGetDebugLoc(LLVMValueRef Inst)155606f32e7eSjoerg LLVMMetadataRef LLVMInstructionGetDebugLoc(LLVMValueRef Inst) {
155706f32e7eSjoerg return wrap(unwrap<Instruction>(Inst)->getDebugLoc().getAsMDNode());
155806f32e7eSjoerg }
155906f32e7eSjoerg
LLVMInstructionSetDebugLoc(LLVMValueRef Inst,LLVMMetadataRef Loc)156006f32e7eSjoerg void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc) {
156106f32e7eSjoerg if (Loc)
156206f32e7eSjoerg unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc(unwrap<MDNode>(Loc)));
156306f32e7eSjoerg else
156406f32e7eSjoerg unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc());
156506f32e7eSjoerg }
156606f32e7eSjoerg
LLVMGetMetadataKind(LLVMMetadataRef Metadata)156706f32e7eSjoerg LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata) {
156806f32e7eSjoerg switch(unwrap(Metadata)->getMetadataID()) {
156906f32e7eSjoerg #define HANDLE_METADATA_LEAF(CLASS) \
157006f32e7eSjoerg case Metadata::CLASS##Kind: \
157106f32e7eSjoerg return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
157206f32e7eSjoerg #include "llvm/IR/Metadata.def"
157306f32e7eSjoerg default:
157406f32e7eSjoerg return (LLVMMetadataKind)LLVMGenericDINodeMetadataKind;
157506f32e7eSjoerg }
157606f32e7eSjoerg }
1577