blob: d1ff54571782d10d89b0129e1593fc7bc144cd0f [file] [log] [blame]
Eugene Zelenkof53a7b42017-05-05 22:30:37 +00001//===- DebugInfo.cpp - Debug Information Helper Classes -------------------===//
Bill Wendling523bea82013-11-08 08:13:15 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the helper classes used to build and interpret debug
11// information in LLVM IR form.
12//
13//===----------------------------------------------------------------------===//
14
whitequark789164d2017-11-01 22:18:52 +000015#include "llvm-c/DebugInfo.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000016#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/DenseSet.h"
18#include "llvm/ADT/None.h"
whitequark789164d2017-11-01 22:18:52 +000019#include "llvm/ADT/STLExtras.h"
Bill Wendling523bea82013-11-08 08:13:15 +000020#include "llvm/ADT/SmallPtrSet.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000021#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/IR/BasicBlock.h"
Bill Wendling523bea82013-11-08 08:13:15 +000024#include "llvm/IR/Constants.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000025#include "llvm/IR/DebugInfoMetadata.h"
26#include "llvm/IR/DebugLoc.h"
whitequark789164d2017-11-01 22:18:52 +000027#include "llvm/IR/DebugInfo.h"
28#include "llvm/IR/DIBuilder.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000029#include "llvm/IR/Function.h"
Mehdi Aminib550cb12016-04-18 09:17:29 +000030#include "llvm/IR/GVMaterializer.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000031#include "llvm/IR/Instruction.h"
Bill Wendling523bea82013-11-08 08:13:15 +000032#include "llvm/IR/IntrinsicInst.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000033#include "llvm/IR/LLVMContext.h"
34#include "llvm/IR/Metadata.h"
Bill Wendling523bea82013-11-08 08:13:15 +000035#include "llvm/IR/Module.h"
Eugene Zelenkof53a7b42017-05-05 22:30:37 +000036#include "llvm/Support/Casting.h"
37#include <algorithm>
38#include <cassert>
39#include <utility>
40
Bill Wendling523bea82013-11-08 08:13:15 +000041using namespace llvm;
42using namespace llvm::dwarf;
43
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +000044DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
45 if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
Duncan P. N. Exon Smithdd77af82015-03-31 02:06:28 +000046 return LocalScope->getSubprogram();
47 return nullptr;
Bill Wendling523bea82013-11-08 08:13:15 +000048}
49
Bill Wendling523bea82013-11-08 08:13:15 +000050//===----------------------------------------------------------------------===//
51// DebugInfoFinder implementations.
52//===----------------------------------------------------------------------===//
53
54void DebugInfoFinder::reset() {
55 CUs.clear();
56 SPs.clear();
57 GVs.clear();
58 TYs.clear();
59 Scopes.clear();
60 NodesSeen.clear();
Bill Wendling523bea82013-11-08 08:13:15 +000061}
62
Bill Wendling523bea82013-11-08 08:13:15 +000063void DebugInfoFinder::processModule(const Module &M) {
Roman Tereshindab10b52018-04-13 21:23:11 +000064 for (auto *CU : M.debug_compile_units())
65 processCompileUnit(CU);
Keno Fischer30779772017-04-11 13:32:11 +000066 for (auto &F : M.functions()) {
Adrian Prantl75819ae2016-04-15 15:57:41 +000067 if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
68 processSubprogram(SP);
Keno Fischer30779772017-04-11 13:32:11 +000069 // There could be subprograms from inlined functions referenced from
70 // instructions only. Walk the function to find them.
Roman Tereshindab10b52018-04-13 21:23:11 +000071 for (const BasicBlock &BB : F)
72 for (const Instruction &I : BB)
73 processInstruction(M, I);
Keno Fischer30779772017-04-11 13:32:11 +000074 }
Bill Wendling523bea82013-11-08 08:13:15 +000075}
76
Roman Tereshind769eb32018-04-13 21:22:24 +000077void DebugInfoFinder::processCompileUnit(DICompileUnit *CU) {
78 if (!addCompileUnit(CU))
79 return;
80 for (auto DIG : CU->getGlobalVariables()) {
81 if (!addGlobalVariable(DIG))
82 continue;
83 auto *GV = DIG->getVariable();
84 processScope(GV->getScope());
85 processType(GV->getType().resolve());
86 }
87 for (auto *ET : CU->getEnumTypes())
88 processType(ET);
89 for (auto *RT : CU->getRetainedTypes())
90 if (auto *T = dyn_cast<DIType>(RT))
91 processType(T);
92 else
93 processSubprogram(cast<DISubprogram>(RT));
94 for (auto *Import : CU->getImportedEntities()) {
95 auto *Entity = Import->getEntity().resolve();
96 if (auto *T = dyn_cast<DIType>(Entity))
97 processType(T);
98 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
99 processSubprogram(SP);
100 else if (auto *NS = dyn_cast<DINamespace>(Entity))
101 processScope(NS->getScope());
102 else if (auto *M = dyn_cast<DIModule>(Entity))
103 processScope(M->getScope());
Roman Tereshind769eb32018-04-13 21:22:24 +0000104 }
105}
106
Roman Tereshindab10b52018-04-13 21:23:11 +0000107void DebugInfoFinder::processInstruction(const Module &M,
108 const Instruction &I) {
109 if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
110 processDeclare(M, DDI);
111 else if (auto *DVI = dyn_cast<DbgValueInst>(&I))
112 processValue(M, DVI);
113
114 if (auto DbgLoc = I.getDebugLoc())
115 processLocation(M, DbgLoc.get());
116}
117
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000118void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
Bill Wendling523bea82013-11-08 08:13:15 +0000119 if (!Loc)
120 return;
Duncan P. N. Exon Smithb7e221b2015-04-14 01:35:55 +0000121 processScope(Loc->getScope());
122 processLocation(M, Loc->getInlinedAt());
Bill Wendling523bea82013-11-08 08:13:15 +0000123}
124
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000125void DebugInfoFinder::processType(DIType *DT) {
Bill Wendling523bea82013-11-08 08:13:15 +0000126 if (!addType(DT))
127 return;
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000128 processScope(DT->getScope().resolve());
Duncan P. N. Exon Smith260fa8a2015-07-24 20:56:10 +0000129 if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
130 for (DITypeRef Ref : ST->getTypeArray())
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000131 processType(Ref.resolve());
Duncan P. N. Exon Smith260fa8a2015-07-24 20:56:10 +0000132 return;
133 }
134 if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000135 processType(DCT->getBaseType().resolve());
Anders Waldenborg1433fd42015-04-14 09:18:17 +0000136 for (Metadata *D : DCT->getElements()) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000137 if (auto *T = dyn_cast<DIType>(D))
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000138 processType(T);
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000139 else if (auto *SP = dyn_cast<DISubprogram>(D))
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000140 processSubprogram(SP);
Bill Wendling523bea82013-11-08 08:13:15 +0000141 }
Duncan P. N. Exon Smith260fa8a2015-07-24 20:56:10 +0000142 return;
143 }
144 if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000145 processType(DDT->getBaseType().resolve());
Bill Wendling523bea82013-11-08 08:13:15 +0000146 }
147}
148
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000149void DebugInfoFinder::processScope(DIScope *Scope) {
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000150 if (!Scope)
151 return;
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000152 if (auto *Ty = dyn_cast<DIType>(Scope)) {
Bill Wendling523bea82013-11-08 08:13:15 +0000153 processType(Ty);
154 return;
155 }
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000156 if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000157 addCompileUnit(CU);
Bill Wendling523bea82013-11-08 08:13:15 +0000158 return;
159 }
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000160 if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000161 processSubprogram(SP);
Bill Wendling523bea82013-11-08 08:13:15 +0000162 return;
163 }
164 if (!addScope(Scope))
165 return;
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000166 if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000167 processScope(LB->getScope());
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000168 } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
Duncan P. N. Exon Smith20caafb2015-04-14 03:01:27 +0000169 processScope(NS->getScope());
Adrian Prantlab1243f2015-06-29 23:03:47 +0000170 } else if (auto *M = dyn_cast<DIModule>(Scope)) {
171 processScope(M->getScope());
Bill Wendling523bea82013-11-08 08:13:15 +0000172 }
173}
174
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000175void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
Bill Wendling523bea82013-11-08 08:13:15 +0000176 if (!addSubprogram(SP))
177 return;
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000178 processScope(SP->getScope().resolve());
Roman Tereshind769eb32018-04-13 21:22:24 +0000179 // Some of the users, e.g. CloneFunctionInto / CloneModule, need to set up a
180 // ValueMap containing identity mappings for all of the DICompileUnit's, not
181 // just DISubprogram's, referenced from anywhere within the Function being
182 // cloned prior to calling MapMetadata / RemapInstruction to avoid their
183 // duplication later as DICompileUnit's are also directly referenced by
184 // llvm.dbg.cu list. Thefore we need to collect DICompileUnit's here as well.
185 // Also, DICompileUnit's may reference DISubprogram's too and therefore need
186 // to be at least looked through.
187 processCompileUnit(SP->getUnit());
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000188 processType(SP->getType());
189 for (auto *Element : SP->getTemplateParams()) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000190 if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000191 processType(TType->getType().resolve());
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000192 } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000193 processType(TVal->getType().resolve());
Bill Wendling523bea82013-11-08 08:13:15 +0000194 }
195 }
196}
197
Manman Ren2085ccc2013-11-17 18:42:37 +0000198void DebugInfoFinder::processDeclare(const Module &M,
199 const DbgDeclareInst *DDI) {
Duncan P. N. Exon Smithed557b52015-04-17 23:20:10 +0000200 auto *N = dyn_cast<MDNode>(DDI->getVariable());
Bill Wendling523bea82013-11-08 08:13:15 +0000201 if (!N)
202 return;
203
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000204 auto *DV = dyn_cast<DILocalVariable>(N);
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000205 if (!DV)
Bill Wendling523bea82013-11-08 08:13:15 +0000206 return;
207
David Blaikie70573dc2014-11-19 07:49:26 +0000208 if (!NodesSeen.insert(DV).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000209 return;
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000210 processScope(DV->getScope());
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000211 processType(DV->getType().resolve());
Bill Wendling523bea82013-11-08 08:13:15 +0000212}
213
Manman Ren2085ccc2013-11-17 18:42:37 +0000214void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
Duncan P. N. Exon Smithed557b52015-04-17 23:20:10 +0000215 auto *N = dyn_cast<MDNode>(DVI->getVariable());
Bill Wendling523bea82013-11-08 08:13:15 +0000216 if (!N)
217 return;
218
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000219 auto *DV = dyn_cast<DILocalVariable>(N);
Duncan P. N. Exon Smith9d1cf4c2015-04-06 23:18:49 +0000220 if (!DV)
Bill Wendling523bea82013-11-08 08:13:15 +0000221 return;
222
David Blaikie70573dc2014-11-19 07:49:26 +0000223 if (!NodesSeen.insert(DV).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000224 return;
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000225 processScope(DV->getScope());
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000226 processType(DV->getType().resolve());
Bill Wendling523bea82013-11-08 08:13:15 +0000227}
228
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000229bool DebugInfoFinder::addType(DIType *DT) {
Bill Wendling523bea82013-11-08 08:13:15 +0000230 if (!DT)
231 return false;
232
David Blaikie70573dc2014-11-19 07:49:26 +0000233 if (!NodesSeen.insert(DT).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000234 return false;
235
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000236 TYs.push_back(const_cast<DIType *>(DT));
Bill Wendling523bea82013-11-08 08:13:15 +0000237 return true;
238}
239
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000240bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
Bill Wendling523bea82013-11-08 08:13:15 +0000241 if (!CU)
242 return false;
David Blaikie70573dc2014-11-19 07:49:26 +0000243 if (!NodesSeen.insert(CU).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000244 return false;
245
246 CUs.push_back(CU);
247 return true;
248}
249
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000250bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
David Blaikie70573dc2014-11-19 07:49:26 +0000251 if (!NodesSeen.insert(DIG).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000252 return false;
253
254 GVs.push_back(DIG);
255 return true;
256}
257
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000258bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
Bill Wendling523bea82013-11-08 08:13:15 +0000259 if (!SP)
260 return false;
261
David Blaikie70573dc2014-11-19 07:49:26 +0000262 if (!NodesSeen.insert(SP).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000263 return false;
264
265 SPs.push_back(SP);
266 return true;
267}
268
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000269bool DebugInfoFinder::addScope(DIScope *Scope) {
Bill Wendling523bea82013-11-08 08:13:15 +0000270 if (!Scope)
271 return false;
272 // FIXME: Ocaml binding generates a scope with no content, we treat it
273 // as null for now.
274 if (Scope->getNumOperands() == 0)
275 return false;
David Blaikie70573dc2014-11-19 07:49:26 +0000276 if (!NodesSeen.insert(Scope).second)
Bill Wendling523bea82013-11-08 08:13:15 +0000277 return false;
278 Scopes.push_back(Scope);
279 return true;
280}
281
Eugene Zelenkof53a7b42017-05-05 22:30:37 +0000282static MDNode *stripDebugLocFromLoopID(MDNode *N) {
Matthias Braun9fd397b2018-10-31 00:23:23 +0000283 assert(!empty(N->operands()) && "Missing self reference?");
Daniel Sandersb96a9452017-01-28 11:22:05 +0000284
Teresa Johnson9b4b8c82017-03-19 13:54:57 +0000285 // if there is no debug location, we do not have to rewrite this MDNode.
286 if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
287 return isa<DILocation>(Op.get());
288 }))
Daniel Sandersb96a9452017-01-28 11:22:05 +0000289 return N;
290
Teresa Johnson9b4b8c82017-03-19 13:54:57 +0000291 // If there is only the debug location without any actual loop metadata, we
Daniel Sandersb96a9452017-01-28 11:22:05 +0000292 // can remove the metadata.
Teresa Johnson9b4b8c82017-03-19 13:54:57 +0000293 if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
294 return !isa<DILocation>(Op.get());
295 }))
Daniel Sandersb96a9452017-01-28 11:22:05 +0000296 return nullptr;
297
298 SmallVector<Metadata *, 4> Args;
299 // Reserve operand 0 for loop id self reference.
300 auto TempNode = MDNode::getTemporary(N->getContext(), None);
301 Args.push_back(TempNode.get());
Teresa Johnson9b4b8c82017-03-19 13:54:57 +0000302 // Add all non-debug location operands back.
303 for (auto Op = N->op_begin() + 1; Op != N->op_end(); Op++) {
304 if (!isa<DILocation>(*Op))
305 Args.push_back(*Op);
306 }
Daniel Sandersb96a9452017-01-28 11:22:05 +0000307
308 // Set the first operand to itself.
309 MDNode *LoopID = MDNode::get(N->getContext(), Args);
310 LoopID->replaceOperandWith(0, LoopID);
311 return LoopID;
312}
313
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000314bool llvm::stripDebugInfo(Function &F) {
315 bool Changed = false;
Benjamin Kramer0deb9a92018-05-31 13:29:58 +0000316 if (F.hasMetadata(LLVMContext::MD_dbg)) {
Peter Collingbourned4bff302015-11-05 22:03:56 +0000317 Changed = true;
318 F.setSubprogram(nullptr);
319 }
Mehdi Amini581f0e12016-05-07 04:10:52 +0000320
Eugene Zelenkof53a7b42017-05-05 22:30:37 +0000321 DenseMap<MDNode*, MDNode*> LoopIDsMap;
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000322 for (BasicBlock &BB : F) {
Mehdi Amini581f0e12016-05-07 04:10:52 +0000323 for (auto II = BB.begin(), End = BB.end(); II != End;) {
324 Instruction &I = *II++; // We may delete the instruction, increment now.
Mehdi Aminidb8dd552016-05-14 04:58:35 +0000325 if (isa<DbgInfoIntrinsic>(&I)) {
326 I.eraseFromParent();
Mehdi Amini581f0e12016-05-07 04:10:52 +0000327 Changed = true;
Mehdi Aminibbedb142016-05-07 05:07:47 +0000328 continue;
Mehdi Amini581f0e12016-05-07 04:10:52 +0000329 }
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000330 if (I.getDebugLoc()) {
331 Changed = true;
332 I.setDebugLoc(DebugLoc());
333 }
334 }
Daniel Sandersb96a9452017-01-28 11:22:05 +0000335
336 auto *TermInst = BB.getTerminator();
Justin Bognerb29bebe2017-08-18 21:38:03 +0000337 if (!TermInst)
338 // This is invalid IR, but we may not have run the verifier yet
339 continue;
Daniel Sandersb96a9452017-01-28 11:22:05 +0000340 if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
341 auto *NewLoopID = LoopIDsMap.lookup(LoopID);
342 if (!NewLoopID)
343 NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
344 if (NewLoopID != LoopID)
345 TermInst->setMetadata(LLVMContext::MD_loop, NewLoopID);
346 }
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000347 }
348 return Changed;
349}
350
Manman Rencb14bbc2013-11-22 22:06:31 +0000351bool llvm::StripDebugInfo(Module &M) {
Manman Rencb14bbc2013-11-22 22:06:31 +0000352 bool Changed = false;
353
Manman Rencb14bbc2013-11-22 22:06:31 +0000354 for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
355 NME = M.named_metadata_end(); NMI != NME;) {
Duncan P. N. Exon Smith52888a62015-10-08 23:49:46 +0000356 NamedMDNode *NMD = &*NMI;
Manman Rencb14bbc2013-11-22 22:06:31 +0000357 ++NMI;
Davide Italiano84bd58e2016-10-17 20:05:35 +0000358
359 // We're stripping debug info, and without them, coverage information
360 // doesn't quite make sense.
361 if (NMD->getName().startswith("llvm.dbg.") ||
362 NMD->getName() == "llvm.gcov") {
Manman Rencb14bbc2013-11-22 22:06:31 +0000363 NMD->eraseFromParent();
364 Changed = true;
365 }
366 }
367
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000368 for (Function &F : M)
369 Changed |= stripDebugInfo(F);
370
Adrian Prantl3bfe1092016-10-10 17:53:33 +0000371 for (auto &GV : M.globals()) {
Benjamin Kramer0deb9a92018-05-31 13:29:58 +0000372 Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
Adrian Prantl3bfe1092016-10-10 17:53:33 +0000373 }
374
Rafael Espindola468b8682015-04-01 14:44:59 +0000375 if (GVMaterializer *Materializer = M.getMaterializer())
Rafael Espindola0d68b4c2015-03-30 21:36:43 +0000376 Materializer->setStripDebugInfo();
Manman Rencb14bbc2013-11-22 22:06:31 +0000377
378 return Changed;
379}
Manman Ren8b4306c2013-12-02 21:29:56 +0000380
Michael Ilsemane5428042016-10-25 18:44:13 +0000381namespace {
382
383/// Helper class to downgrade -g metadata to -gline-tables-only metadata.
384class DebugTypeInfoRemoval {
385 DenseMap<Metadata *, Metadata *> Replacements;
386
387public:
388 /// The (void)() type.
389 MDNode *EmptySubroutineType;
390
391private:
392 /// Remember what linkage name we originally had before stripping. If we end
393 /// up making two subprograms identical who originally had different linkage
394 /// names, then we need to make one of them distinct, to avoid them getting
395 /// uniqued. Maps the new node to the old linkage name.
396 DenseMap<DISubprogram *, StringRef> NewToLinkageName;
397
398 // TODO: Remember the distinct subprogram we created for a given linkage name,
399 // so that we can continue to unique whenever possible. Map <newly created
400 // node, old linkage name> to the first (possibly distinct) mdsubprogram
401 // created for that combination. This is not strictly needed for correctness,
402 // but can cut down on the number of MDNodes and let us diff cleanly with the
403 // output of -gline-tables-only.
404
405public:
406 DebugTypeInfoRemoval(LLVMContext &C)
407 : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
408 MDNode::get(C, {}))) {}
409
410 Metadata *map(Metadata *M) {
411 if (!M)
412 return nullptr;
413 auto Replacement = Replacements.find(M);
414 if (Replacement != Replacements.end())
415 return Replacement->second;
416
417 return M;
418 }
419 MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
420
421 /// Recursively remap N and all its referenced children. Does a DF post-order
422 /// traversal, so as to remap bottoms up.
423 void traverseAndRemap(MDNode *N) { traverse(N); }
424
425private:
426 // Create a new DISubprogram, to replace the one given.
427 DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
428 auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
429 StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
430 DISubprogram *Declaration = nullptr;
431 auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
432 DITypeRef ContainingType(map(MDS->getContainingType()));
433 auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
434 auto Variables = nullptr;
435 auto TemplateParams = nullptr;
436
437 // Make a distinct DISubprogram, for situations that warrent it.
438 auto distinctMDSubprogram = [&]() {
439 return DISubprogram::getDistinct(
440 MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
Paul Robinsoncda54212018-11-19 18:29:28 +0000441 FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
442 ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
443 MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
444 Variables);
Michael Ilsemane5428042016-10-25 18:44:13 +0000445 };
446
447 if (MDS->isDistinct())
448 return distinctMDSubprogram();
449
450 auto *NewMDS = DISubprogram::get(
451 MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
Paul Robinsoncda54212018-11-19 18:29:28 +0000452 FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(), ContainingType,
453 MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
454 MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
Michael Ilsemane5428042016-10-25 18:44:13 +0000455
456 StringRef OldLinkageName = MDS->getLinkageName();
457
458 // See if we need to make a distinct one.
459 auto OrigLinkage = NewToLinkageName.find(NewMDS);
460 if (OrigLinkage != NewToLinkageName.end()) {
461 if (OrigLinkage->second == OldLinkageName)
462 // We're good.
463 return NewMDS;
464
465 // Otherwise, need to make a distinct one.
466 // TODO: Query the map to see if we already have one.
467 return distinctMDSubprogram();
468 }
469
470 NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
471 return NewMDS;
472 }
473
474 /// Create a new compile unit, to replace the one given
475 DICompileUnit *getReplacementCU(DICompileUnit *CU) {
476 // Drop skeleton CUs.
477 if (CU->getDWOId())
478 return nullptr;
479
480 auto *File = cast_or_null<DIFile>(map(CU->getFile()));
481 MDTuple *EnumTypes = nullptr;
482 MDTuple *RetainedTypes = nullptr;
483 MDTuple *GlobalVariables = nullptr;
484 MDTuple *ImportedEntities = nullptr;
485 return DICompileUnit::getDistinct(
486 CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
487 CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
488 CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
489 RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
Dehao Chen0944a8c2017-02-01 22:45:09 +0000490 CU->getDWOId(), CU->getSplitDebugInlining(),
David Blaikiebb279112018-11-13 20:08:10 +0000491 CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
492 CU->getRangesBaseAddress());
Michael Ilsemane5428042016-10-25 18:44:13 +0000493 }
494
495 DILocation *getReplacementMDLocation(DILocation *MLD) {
496 auto *Scope = map(MLD->getScope());
497 auto *InlinedAt = map(MLD->getInlinedAt());
498 if (MLD->isDistinct())
499 return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
500 MLD->getColumn(), Scope, InlinedAt);
501 return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
502 Scope, InlinedAt);
503 }
504
505 /// Create a new generic MDNode, to replace the one given
506 MDNode *getReplacementMDNode(MDNode *N) {
507 SmallVector<Metadata *, 8> Ops;
508 Ops.reserve(N->getNumOperands());
509 for (auto &I : N->operands())
510 if (I)
511 Ops.push_back(map(I));
512 auto *Ret = MDNode::get(N->getContext(), Ops);
513 return Ret;
514 }
515
516 /// Attempt to re-map N to a newly created node.
517 void remap(MDNode *N) {
518 if (Replacements.count(N))
519 return;
520
521 auto doRemap = [&](MDNode *N) -> MDNode * {
522 if (!N)
523 return nullptr;
524 if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
525 remap(MDSub->getUnit());
526 return getReplacementSubprogram(MDSub);
527 }
528 if (isa<DISubroutineType>(N))
529 return EmptySubroutineType;
530 if (auto *CU = dyn_cast<DICompileUnit>(N))
531 return getReplacementCU(CU);
532 if (isa<DIFile>(N))
533 return N;
534 if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
535 // Remap to our referenced scope (recursively).
536 return mapNode(MDLB->getScope());
537 if (auto *MLD = dyn_cast<DILocation>(N))
538 return getReplacementMDLocation(MLD);
539
540 // Otherwise, if we see these, just drop them now. Not strictly necessary,
541 // but this speeds things up a little.
542 if (isa<DINode>(N))
543 return nullptr;
544
545 return getReplacementMDNode(N);
546 };
547 Replacements[N] = doRemap(N);
548 }
549
550 /// Do the remapping traversal.
551 void traverse(MDNode *);
552};
553
Eugene Zelenkof53a7b42017-05-05 22:30:37 +0000554} // end anonymous namespace
Michael Ilsemane5428042016-10-25 18:44:13 +0000555
556void DebugTypeInfoRemoval::traverse(MDNode *N) {
557 if (!N || Replacements.count(N))
558 return;
559
560 // To avoid cycles, as well as for efficiency sake, we will sometimes prune
561 // parts of the graph.
562 auto prune = [](MDNode *Parent, MDNode *Child) {
563 if (auto *MDS = dyn_cast<DISubprogram>(Parent))
Shiva Chen2c864552018-05-09 02:40:45 +0000564 return Child == MDS->getRetainedNodes().get();
Michael Ilsemane5428042016-10-25 18:44:13 +0000565 return false;
566 };
567
568 SmallVector<MDNode *, 16> ToVisit;
569 DenseSet<MDNode *> Opened;
570
571 // Visit each node starting at N in post order, and map them.
572 ToVisit.push_back(N);
573 while (!ToVisit.empty()) {
574 auto *N = ToVisit.back();
575 if (!Opened.insert(N).second) {
576 // Close it.
577 remap(N);
578 ToVisit.pop_back();
579 continue;
580 }
581 for (auto &I : N->operands())
582 if (auto *MDN = dyn_cast_or_null<MDNode>(I))
583 if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
584 !isa<DICompileUnit>(MDN))
585 ToVisit.push_back(MDN);
586 }
587}
588
589bool llvm::stripNonLineTableDebugInfo(Module &M) {
590 bool Changed = false;
591
592 // First off, delete the debug intrinsics.
593 auto RemoveUses = [&](StringRef Name) {
594 if (auto *DbgVal = M.getFunction(Name)) {
595 while (!DbgVal->use_empty())
596 cast<Instruction>(DbgVal->user_back())->eraseFromParent();
597 DbgVal->eraseFromParent();
598 Changed = true;
599 }
600 };
601 RemoveUses("llvm.dbg.declare");
602 RemoveUses("llvm.dbg.value");
603
604 // Delete non-CU debug info named metadata nodes.
605 for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
606 NMI != NME;) {
607 NamedMDNode *NMD = &*NMI;
608 ++NMI;
609 // Specifically keep dbg.cu around.
610 if (NMD->getName() == "llvm.dbg.cu")
611 continue;
612 }
613
614 // Drop all dbg attachments from global variables.
615 for (auto &GV : M.globals())
616 GV.eraseMetadata(LLVMContext::MD_dbg);
617
618 DebugTypeInfoRemoval Mapper(M.getContext());
Eugene Zelenkof53a7b42017-05-05 22:30:37 +0000619 auto remap = [&](MDNode *Node) -> MDNode * {
Michael Ilsemane5428042016-10-25 18:44:13 +0000620 if (!Node)
621 return nullptr;
622 Mapper.traverseAndRemap(Node);
623 auto *NewNode = Mapper.mapNode(Node);
624 Changed |= Node != NewNode;
625 Node = NewNode;
626 return NewNode;
627 };
628
629 // Rewrite the DebugLocs to be equivalent to what
630 // -gline-tables-only would have created.
631 for (auto &F : M) {
632 if (auto *SP = F.getSubprogram()) {
633 Mapper.traverseAndRemap(SP);
634 auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
635 Changed |= SP != NewSP;
636 F.setSubprogram(NewSP);
637 }
638 for (auto &BB : F) {
639 for (auto &I : BB) {
Adrian Prantl346dcaf2017-03-30 20:10:56 +0000640 auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
641 auto *Scope = DL.getScope();
642 MDNode *InlinedAt = DL.getInlinedAt();
643 Scope = remap(Scope);
644 InlinedAt = remap(InlinedAt);
645 return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
646 };
Michael Ilsemane5428042016-10-25 18:44:13 +0000647
Adrian Prantl346dcaf2017-03-30 20:10:56 +0000648 if (I.getDebugLoc() != DebugLoc())
649 I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
650
651 // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
652 SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
653 I.getAllMetadata(MDs);
654 for (auto Attachment : MDs)
655 if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
656 for (unsigned N = 0; N < T->getNumOperands(); ++N)
657 if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
658 if (Loc != DebugLoc())
659 T->replaceOperandWith(N, remapDebugLoc(Loc));
Michael Ilsemane5428042016-10-25 18:44:13 +0000660 }
661 }
662 }
663
664 // Create a new llvm.dbg.cu, which is equivalent to the one
665 // -gline-tables-only would have created.
666 for (auto &NMD : M.getNamedMDList()) {
667 SmallVector<MDNode *, 8> Ops;
668 for (MDNode *Op : NMD.operands())
669 Ops.push_back(remap(Op));
Bjorn Petterssonaa025802018-07-03 12:39:52 +0000670
Michael Ilsemane5428042016-10-25 18:44:13 +0000671 if (!Changed)
672 continue;
Bjorn Petterssonaa025802018-07-03 12:39:52 +0000673
Michael Ilsemane5428042016-10-25 18:44:13 +0000674 NMD.clearOperands();
675 for (auto *Op : Ops)
676 if (Op)
677 NMD.addOperand(Op);
678 }
679 return Changed;
680}
681
Manman Renbd4daf82013-12-03 00:12:14 +0000682unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
David Majnemere7a9cdb2015-02-16 06:04:53 +0000683 if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
Duncan P. N. Exon Smith5bf8fef2014-12-09 18:38:53 +0000684 M.getModuleFlag("Debug Info Version")))
685 return Val->getZExtValue();
686 return 0;
Manman Ren8b4306c2013-12-02 21:29:56 +0000687}
Dehao Chenf4646272017-10-02 18:13:14 +0000688
689void Instruction::applyMergedLocation(const DILocation *LocA,
690 const DILocation *LocB) {
David Blaikie2a813ef2018-08-23 22:35:58 +0000691 setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
Dehao Chenf4646272017-10-02 18:13:14 +0000692}
whitequark789164d2017-11-01 22:18:52 +0000693
694//===----------------------------------------------------------------------===//
695// LLVM C API implementations.
696//===----------------------------------------------------------------------===//
697
698static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
699 switch (lang) {
700#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
701case LLVMDWARFSourceLanguage##NAME: return ID;
702#include "llvm/BinaryFormat/Dwarf.def"
703#undef HANDLE_DW_LANG
704 }
705 llvm_unreachable("Unhandled Tag");
706}
707
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000708template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
709 return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
710}
711
712static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags) {
713 return static_cast<DINode::DIFlags>(Flags);
714}
715
Robert Widmann260b5812018-05-10 18:23:55 +0000716static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags) {
717 return static_cast<LLVMDIFlags>(Flags);
718}
719
Paul Robinsoncda54212018-11-19 18:29:28 +0000720static DISubprogram::DISPFlags
721pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
722 return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
723}
724
whitequark789164d2017-11-01 22:18:52 +0000725unsigned LLVMDebugMetadataVersion() {
726 return DEBUG_METADATA_VERSION;
727}
728
729LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M) {
730 return wrap(new DIBuilder(*unwrap(M), false));
731}
732
733LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M) {
734 return wrap(new DIBuilder(*unwrap(M)));
735}
736
737unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M) {
738 return getDebugMetadataVersionFromModule(*unwrap(M));
739}
740
741LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M) {
742 return StripDebugInfo(*unwrap(M));
743}
744
745void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder) {
746 delete unwrap(Builder);
747}
748
749void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder) {
750 unwrap(Builder)->finalize();
751}
752
753LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
754 LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
755 LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
756 LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
757 unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
758 LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
759 LLVMBool DebugInfoForProfiling) {
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000760 auto File = unwrapDI<DIFile>(FileRef);
whitequark789164d2017-11-01 22:18:52 +0000761
762 return wrap(unwrap(Builder)->createCompileUnit(
763 map_from_llvmDWARFsourcelanguage(Lang), File,
764 StringRef(Producer, ProducerLen), isOptimized,
765 StringRef(Flags, FlagsLen), RuntimeVer,
766 StringRef(SplitName, SplitNameLen),
767 static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
768 SplitDebugInlining, DebugInfoForProfiling));
769}
770
771LLVMMetadataRef
772LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
773 size_t FilenameLen, const char *Directory,
774 size_t DirectoryLen) {
775 return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
776 StringRef(Directory, DirectoryLen)));
777}
778
Robert Widmannb02fe642018-04-23 13:51:43 +0000779LLVMMetadataRef
780LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope,
781 const char *Name, size_t NameLen,
782 const char *ConfigMacros, size_t ConfigMacrosLen,
783 const char *IncludePath, size_t IncludePathLen,
784 const char *ISysRoot, size_t ISysRootLen) {
785 return wrap(unwrap(Builder)->createModule(
786 unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
787 StringRef(ConfigMacros, ConfigMacrosLen),
788 StringRef(IncludePath, IncludePathLen),
789 StringRef(ISysRoot, ISysRootLen)));
790}
791
792LLVMMetadataRef LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder,
793 LLVMMetadataRef ParentScope,
794 const char *Name, size_t NameLen,
795 LLVMBool ExportSymbols) {
796 return wrap(unwrap(Builder)->createNameSpace(
797 unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
798}
799
Robert Widmannf53050f2018-04-07 06:07:55 +0000800LLVMMetadataRef LLVMDIBuilderCreateFunction(
801 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
802 size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
803 LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
804 LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
805 unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
806 return wrap(unwrap(Builder)->createFunction(
807 unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
Paul Robinsoncda54212018-11-19 18:29:28 +0000808 unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
809 map_from_llvmDIFlags(Flags),
810 pack_into_DISPFlags(IsLocalToUnit, IsDefinition, IsOptimized), nullptr,
811 nullptr, nullptr));
Robert Widmannf53050f2018-04-07 06:07:55 +0000812}
813
814
815LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
816 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
817 LLVMMetadataRef File, unsigned Line, unsigned Col) {
818 return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
819 unwrapDI<DIFile>(File),
820 Line, Col));
821}
822
823LLVMMetadataRef
824LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
825 LLVMMetadataRef Scope,
826 LLVMMetadataRef File,
827 unsigned Discriminator) {
828 return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
829 unwrapDI<DIFile>(File),
830 Discriminator));
831}
832
whitequark789164d2017-11-01 22:18:52 +0000833LLVMMetadataRef
Robert Widmannaec494f32018-04-28 22:32:07 +0000834LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder,
835 LLVMMetadataRef Scope,
836 LLVMMetadataRef NS,
837 LLVMMetadataRef File,
838 unsigned Line) {
839 return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
840 unwrapDI<DINamespace>(NS),
841 unwrapDI<DIFile>(File),
842 Line));
843}
844
845LLVMMetadataRef
846LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,
847 LLVMMetadataRef Scope,
848 LLVMMetadataRef ImportedEntity,
849 LLVMMetadataRef File,
850 unsigned Line) {
851 return wrap(unwrap(Builder)->createImportedModule(
852 unwrapDI<DIScope>(Scope),
853 unwrapDI<DIImportedEntity>(ImportedEntity),
854 unwrapDI<DIFile>(File), Line));
855}
856
857LLVMMetadataRef
858LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,
859 LLVMMetadataRef Scope,
860 LLVMMetadataRef M,
861 LLVMMetadataRef File,
862 unsigned Line) {
863 return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
864 unwrapDI<DIModule>(M),
865 unwrapDI<DIFile>(File),
866 Line));
867}
868
869LLVMMetadataRef
870LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,
871 LLVMMetadataRef Scope,
872 LLVMMetadataRef Decl,
873 LLVMMetadataRef File,
874 unsigned Line,
875 const char *Name, size_t NameLen) {
876 return wrap(unwrap(Builder)->createImportedDeclaration(
877 unwrapDI<DIScope>(Scope),
878 unwrapDI<DINode>(Decl),
879 unwrapDI<DIFile>(File), Line, {Name, NameLen}));
880}
881
882LLVMMetadataRef
whitequark789164d2017-11-01 22:18:52 +0000883LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
884 unsigned Column, LLVMMetadataRef Scope,
885 LLVMMetadataRef InlinedAt) {
886 return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
887 unwrap(InlinedAt)));
888}
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000889
Robert Widmann260b5812018-05-10 18:23:55 +0000890unsigned LLVMDILocationGetLine(LLVMMetadataRef Location) {
891 return unwrapDI<DILocation>(Location)->getLine();
892}
893
894unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location) {
895 return unwrapDI<DILocation>(Location)->getColumn();
896}
897
898LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location) {
899 return wrap(unwrapDI<DILocation>(Location)->getScope());
900}
901
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000902LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(
903 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
904 size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000905 uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000906 unsigned NumElements, LLVMMetadataRef ClassTy) {
907auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
908 NumElements});
909return wrap(unwrap(Builder)->createEnumerationType(
910 unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
911 LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
912}
913
914LLVMMetadataRef LLVMDIBuilderCreateUnionType(
915 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
916 size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000917 uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000918 LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
919 const char *UniqueId, size_t UniqueIdLen) {
920 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
921 NumElements});
922 return wrap(unwrap(Builder)->createUnionType(
923 unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
924 LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
925 Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
926}
927
928
929LLVMMetadataRef
Robert Widmann2d2698c2018-04-28 18:13:39 +0000930LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size,
931 uint32_t AlignInBits, LLVMMetadataRef Ty,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000932 LLVMMetadataRef *Subscripts,
933 unsigned NumSubscripts) {
934 auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
935 NumSubscripts});
936 return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
937 unwrapDI<DIType>(Ty), Subs));
938}
939
940LLVMMetadataRef
Robert Widmann2d2698c2018-04-28 18:13:39 +0000941LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, uint64_t Size,
942 uint32_t AlignInBits, LLVMMetadataRef Ty,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000943 LLVMMetadataRef *Subscripts,
944 unsigned NumSubscripts) {
945 auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
946 NumSubscripts});
947 return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
948 unwrapDI<DIType>(Ty), Subs));
949}
950
951LLVMMetadataRef
952LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000953 size_t NameLen, uint64_t SizeInBits,
whitequarkb56a4d32018-08-19 23:39:47 +0000954 LLVMDWARFTypeEncoding Encoding,
955 LLVMDIFlags Flags) {
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000956 return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
whitequarkb56a4d32018-08-19 23:39:47 +0000957 SizeInBits, Encoding,
958 map_from_llvmDIFlags(Flags)));
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000959}
960
961LLVMMetadataRef LLVMDIBuilderCreatePointerType(
962 LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000963 uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000964 const char *Name, size_t NameLen) {
965 return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
966 SizeInBits, AlignInBits,
967 AddressSpace, {Name, NameLen}));
968}
969
970LLVMMetadataRef LLVMDIBuilderCreateStructType(
971 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
972 size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000973 uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000974 LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
975 unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
976 const char *UniqueId, size_t UniqueIdLen) {
977 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
978 NumElements});
979 return wrap(unwrap(Builder)->createStructType(
980 unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
981 LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
982 unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
983 unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
984}
985
986LLVMMetadataRef LLVMDIBuilderCreateMemberType(
987 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
Robert Widmann2d2698c2018-04-28 18:13:39 +0000988 size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
989 uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +0000990 LLVMMetadataRef Ty) {
991 return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
992 {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
993 OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
994}
995
996LLVMMetadataRef
997LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name,
998 size_t NameLen) {
999 return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
1000}
1001
1002LLVMMetadataRef
1003LLVMDIBuilderCreateStaticMemberType(
1004 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1005 size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1006 LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
Robert Widmann2d2698c2018-04-28 18:13:39 +00001007 uint32_t AlignInBits) {
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001008 return wrap(unwrap(Builder)->createStaticMemberType(
1009 unwrapDI<DIScope>(Scope), {Name, NameLen},
1010 unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1011 map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
1012 AlignInBits));
1013}
1014
1015LLVMMetadataRef
Robert Widmann38fa7502018-05-21 16:27:35 +00001016LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder,
1017 const char *Name, size_t NameLen,
1018 LLVMMetadataRef File, unsigned LineNo,
1019 uint64_t SizeInBits, uint32_t AlignInBits,
1020 uint64_t OffsetInBits, LLVMDIFlags Flags,
1021 LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
1022 return wrap(unwrap(Builder)->createObjCIVar(
1023 {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1024 SizeInBits, AlignInBits, OffsetInBits,
1025 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1026 unwrapDI<MDNode>(PropertyNode)));
1027}
1028
1029LLVMMetadataRef
1030LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder,
1031 const char *Name, size_t NameLen,
1032 LLVMMetadataRef File, unsigned LineNo,
1033 const char *GetterName, size_t GetterNameLen,
1034 const char *SetterName, size_t SetterNameLen,
1035 unsigned PropertyAttributes,
1036 LLVMMetadataRef Ty) {
1037 return wrap(unwrap(Builder)->createObjCProperty(
1038 {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1039 {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1040 PropertyAttributes, unwrapDI<DIType>(Ty)));
1041}
1042
1043LLVMMetadataRef
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001044LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder,
1045 LLVMMetadataRef Type) {
1046 return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1047}
1048
1049LLVMMetadataRef
Robert Widmann4b0084b2018-05-10 21:10:06 +00001050LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
1051 const char *Name, size_t NameLen,
1052 LLVMMetadataRef File, unsigned LineNo,
1053 LLVMMetadataRef Scope) {
1054 return wrap(unwrap(Builder)->createTypedef(
1055 unwrapDI<DIType>(Type), {Name, NameLen},
1056 unwrapDI<DIFile>(File), LineNo,
1057 unwrapDI<DIScope>(Scope)));
1058}
1059
1060LLVMMetadataRef
Robert Widmann38fa7502018-05-21 16:27:35 +00001061LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder,
1062 LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
1063 uint64_t BaseOffset, uint32_t VBPtrOffset,
1064 LLVMDIFlags Flags) {
1065 return wrap(unwrap(Builder)->createInheritance(
1066 unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1067 BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
1068}
1069
1070LLVMMetadataRef
Robert Widmannb02fe642018-04-23 13:51:43 +00001071LLVMDIBuilderCreateForwardDecl(
1072 LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1073 size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
Robert Widmann2d2698c2018-04-28 18:13:39 +00001074 unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
Robert Widmannb02fe642018-04-23 13:51:43 +00001075 const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1076 return wrap(unwrap(Builder)->createForwardDecl(
1077 Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1078 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1079 AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1080}
1081
1082LLVMMetadataRef
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001083LLVMDIBuilderCreateReplaceableCompositeType(
Harlan Haskinsbee4b582018-04-02 19:11:44 +00001084 LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1085 size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
Robert Widmann2d2698c2018-04-28 18:13:39 +00001086 unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001087 LLVMDIFlags Flags, const char *UniqueIdentifier,
Harlan Haskinsbee4b582018-04-02 19:11:44 +00001088 size_t UniqueIdentifierLen) {
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001089 return wrap(unwrap(Builder)->createReplaceableCompositeType(
1090 Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1091 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1092 AlignInBits, map_from_llvmDIFlags(Flags),
1093 {UniqueIdentifier, UniqueIdentifierLen}));
1094}
1095
1096LLVMMetadataRef
1097LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
1098 LLVMMetadataRef Type) {
1099 return wrap(unwrap(Builder)->createQualifiedType(Tag,
1100 unwrapDI<DIType>(Type)));
1101}
1102
1103LLVMMetadataRef
1104LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag,
1105 LLVMMetadataRef Type) {
1106 return wrap(unwrap(Builder)->createReferenceType(Tag,
1107 unwrapDI<DIType>(Type)));
1108}
1109
1110LLVMMetadataRef
1111LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder) {
1112 return wrap(unwrap(Builder)->createNullPtrType());
1113}
1114
1115LLVMMetadataRef
1116LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder,
1117 LLVMMetadataRef PointeeType,
1118 LLVMMetadataRef ClassType,
Robert Widmann2d2698c2018-04-28 18:13:39 +00001119 uint64_t SizeInBits,
1120 uint32_t AlignInBits,
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001121 LLVMDIFlags Flags) {
1122 return wrap(unwrap(Builder)->createMemberPointerType(
1123 unwrapDI<DIType>(PointeeType),
1124 unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1125 map_from_llvmDIFlags(Flags)));
1126}
1127
1128LLVMMetadataRef
Robert Widmann2d2698c2018-04-28 18:13:39 +00001129LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder,
1130 LLVMMetadataRef Scope,
1131 const char *Name, size_t NameLen,
1132 LLVMMetadataRef File, unsigned LineNumber,
1133 uint64_t SizeInBits,
1134 uint64_t OffsetInBits,
1135 uint64_t StorageOffsetInBits,
1136 LLVMDIFlags Flags, LLVMMetadataRef Type) {
1137 return wrap(unwrap(Builder)->createBitFieldMemberType(
1138 unwrapDI<DIScope>(Scope), {Name, NameLen},
1139 unwrapDI<DIFile>(File), LineNumber,
1140 SizeInBits, OffsetInBits, StorageOffsetInBits,
1141 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1142}
1143
1144LLVMMetadataRef LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder,
1145 LLVMMetadataRef Scope, const char *Name, size_t NameLen,
1146 LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1147 uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1148 LLVMMetadataRef DerivedFrom,
1149 LLVMMetadataRef *Elements, unsigned NumElements,
1150 LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
1151 const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1152 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1153 NumElements});
1154 return wrap(unwrap(Builder)->createClassType(
1155 unwrapDI<DIScope>(Scope), {Name, NameLen},
1156 unwrapDI<DIFile>(File), LineNumber,
1157 SizeInBits, AlignInBits, OffsetInBits,
1158 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1159 Elts, unwrapDI<DIType>(VTableHolder),
1160 unwrapDI<MDNode>(TemplateParamsNode),
1161 {UniqueIdentifier, UniqueIdentifierLen}));
1162}
1163
1164LLVMMetadataRef
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001165LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,
1166 LLVMMetadataRef Type) {
1167 return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1168}
1169
Robert Widmann260b5812018-05-10 18:23:55 +00001170const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
1171 StringRef Str = unwrap<DIType>(DType)->getName();
1172 *Length = Str.size();
1173 return Str.data();
1174}
1175
1176uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType) {
1177 return unwrapDI<DIType>(DType)->getSizeInBits();
1178}
1179
1180uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType) {
1181 return unwrapDI<DIType>(DType)->getOffsetInBits();
1182}
1183
1184uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType) {
1185 return unwrapDI<DIType>(DType)->getAlignInBits();
1186}
1187
1188unsigned LLVMDITypeGetLine(LLVMMetadataRef DType) {
1189 return unwrapDI<DIType>(DType)->getLine();
1190}
1191
1192LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType) {
1193 return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1194}
1195
Robert Widmann6978db72018-04-23 14:29:33 +00001196LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder,
1197 LLVMMetadataRef *Types,
1198 size_t Length) {
1199 return wrap(
1200 unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
1201}
1202
Harlan Haskinsb7881bb2018-04-02 00:17:40 +00001203LLVMMetadataRef
1204LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
1205 LLVMMetadataRef File,
1206 LLVMMetadataRef *ParameterTypes,
1207 unsigned NumParameterTypes,
1208 LLVMDIFlags Flags) {
1209 auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
1210 NumParameterTypes});
1211 return wrap(unwrap(Builder)->createSubroutineType(
1212 Elts, map_from_llvmDIFlags(Flags)));
1213}
Robert Widmannf53050f2018-04-07 06:07:55 +00001214
Robert Widmann12e367b2018-04-22 19:24:44 +00001215LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,
1216 int64_t *Addr, size_t Length) {
1217 return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
1218 Length)));
1219}
1220
Robert Widmann21fc15d2018-04-23 22:31:49 +00001221LLVMMetadataRef
1222LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,
1223 int64_t Value) {
1224 return wrap(unwrap(Builder)->createConstantValueExpression(Value));
1225}
1226
Matthew Vossf8ab35a2018-10-03 18:44:53 +00001227LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(
1228 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1229 size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
1230 unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1231 LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {
Robert Widmann21fc15d2018-04-23 22:31:49 +00001232 return wrap(unwrap(Builder)->createGlobalVariableExpression(
Matthew Vossf8ab35a2018-10-03 18:44:53 +00001233 unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
1234 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1235 unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1236 nullptr, AlignInBits));
Robert Widmann21fc15d2018-04-23 22:31:49 +00001237}
1238
Robert Widmanna428eba2018-05-10 18:09:53 +00001239LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data,
1240 size_t Count) {
1241 return wrap(
1242 MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
1243}
1244
1245void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode) {
1246 MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1247}
1248
1249void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata,
1250 LLVMMetadataRef Replacement) {
1251 auto *Node = unwrapDI<MDNode>(TargetMetadata);
1252 Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
1253 MDNode::deleteTemporary(Node);
1254}
1255
Matthew Vossf8ab35a2018-10-03 18:44:53 +00001256LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl(
1257 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1258 size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
1259 unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1260 LLVMMetadataRef Decl, uint32_t AlignInBits) {
Robert Widmann21fc15d2018-04-23 22:31:49 +00001261 return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
Matthew Vossf8ab35a2018-10-03 18:44:53 +00001262 unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
1263 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1264 unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
Robert Widmann21fc15d2018-04-23 22:31:49 +00001265}
1266
Matthew Vossf8ab35a2018-10-03 18:44:53 +00001267LLVMValueRef
1268LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage,
1269 LLVMMetadataRef VarInfo, LLVMMetadataRef Expr,
1270 LLVMMetadataRef DL, LLVMValueRef Instr) {
Robert Widmann12e367b2018-04-22 19:24:44 +00001271 return wrap(unwrap(Builder)->insertDeclare(
1272 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1273 unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1274 unwrap<Instruction>(Instr)));
1275}
1276
1277LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(
1278 LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
1279 LLVMMetadataRef Expr, LLVMMetadataRef DL, LLVMBasicBlockRef Block) {
1280 return wrap(unwrap(Builder)->insertDeclare(
1281 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1282 unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1283 unwrap(Block)));
1284}
1285
Robert Widmann21fc15d2018-04-23 22:31:49 +00001286LLVMValueRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder,
1287 LLVMValueRef Val,
1288 LLVMMetadataRef VarInfo,
1289 LLVMMetadataRef Expr,
1290 LLVMMetadataRef DebugLoc,
1291 LLVMValueRef Instr) {
1292 return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1293 unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1294 unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1295 unwrap<Instruction>(Instr)));
1296}
1297
1298LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,
1299 LLVMValueRef Val,
1300 LLVMMetadataRef VarInfo,
1301 LLVMMetadataRef Expr,
1302 LLVMMetadataRef DebugLoc,
1303 LLVMBasicBlockRef Block) {
1304 return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1305 unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1306 unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1307 unwrap(Block)));
1308}
1309
Robert Widmann12e367b2018-04-22 19:24:44 +00001310LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
1311 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1312 size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
1313 LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
1314 return wrap(unwrap(Builder)->createAutoVariable(
1315 unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
1316 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1317 map_from_llvmDIFlags(Flags), AlignInBits));
1318}
1319
1320LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
1321 LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1322 size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
1323 LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
1324 return wrap(unwrap(Builder)->createParameterVariable(
Robert Widmann106eab02018-08-25 19:54:39 +00001325 unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
Robert Widmann12e367b2018-04-22 19:24:44 +00001326 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1327 map_from_llvmDIFlags(Flags)));
1328}
1329
Robert Widmann6978db72018-04-23 14:29:33 +00001330LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder,
1331 int64_t Lo, int64_t Count) {
1332 return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
1333}
1334
1335LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,
1336 LLVMMetadataRef *Data,
1337 size_t Length) {
1338 Metadata **DataValue = unwrap(Data);
1339 return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
1340}
1341
Robert Widmannf53050f2018-04-07 06:07:55 +00001342LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func) {
1343 return wrap(unwrap<Function>(Func)->getSubprogram());
1344}
1345
1346void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
1347 unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1348}
Robert Widmannabda7ee2018-10-01 13:15:09 +00001349
1350LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata) {
1351 switch(unwrap(Metadata)->getMetadataID()) {
1352#define HANDLE_METADATA_LEAF(CLASS) \
1353 case Metadata::CLASS##Kind: \
1354 return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1355#include "llvm/IR/Metadata.def"
1356 default:
1357 return (LLVMMetadataKind)LLVMGenericDINodeMetadataKind;
1358 }
1359}