LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DebugIR.cpp
Go to the documentation of this file.
1 //===--- DebugIR.cpp - Transform debug metadata to allow debugging IR -----===//
2 //
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 // A Module transform pass that emits a succinct version of the IR and replaces
11 // the source file metadata to allow debuggers to step through the IR.
12 //
13 // FIXME: instead of replacing debug metadata, this pass should allow for
14 // additional metadata to be used to point capable debuggers to the IR file
15 // without destroying the mapping to the original source file.
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #define DEBUG_TYPE "debug-ir"
20 
21 #include "llvm/ADT/ValueMap.h"
23 #include "llvm/DebugInfo.h"
24 #include "llvm/DIBuilder.h"
25 #include "llvm/InstVisitor.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/Instruction.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/Module.h"
32 #include "llvm/Support/Debug.h"
36 #include "llvm/Support/Path.h"
37 
38 #include "DebugIR.h"
39 
40 #include <string>
41 
42 #define STR_HELPER(x) #x
43 #define STR(x) STR_HELPER(x)
44 
45 using namespace llvm;
46 
47 namespace {
48 
49 /// Builds a map of Value* to line numbers on which the Value appears in a
50 /// textual representation of the IR by plugging into the AssemblyWriter by
51 /// masquerading as an AssemblyAnnotationWriter.
52 class ValueToLineMap : public AssemblyAnnotationWriter {
55 
56  void addEntry(const Value *V, formatted_raw_ostream &Out) {
57  Out.flush();
58  Lines.insert(std::make_pair(V, Out.getLine() + 1));
59  }
60 
61 public:
62 
63  /// Prints Module to a null buffer in order to build the map of Value pointers
64  /// to line numbers.
65  ValueToLineMap(const Module *M) {
66  raw_null_ostream ThrowAway;
67  M->print(ThrowAway, this);
68  }
69 
70  // This function is called after an Instruction, GlobalValue, or GlobalAlias
71  // is printed.
72  void printInfoComment(const Value &V, formatted_raw_ostream &Out) {
73  addEntry(&V, Out);
74  }
75 
76  void emitFunctionAnnot(const Function *F, formatted_raw_ostream &Out) {
77  addEntry(F, Out);
78  }
79 
80  /// If V appears on a line in the textual IR representation, sets Line to the
81  /// line number and returns true, otherwise returns false.
82  bool getLine(const Value *V, unsigned int &Line) const {
83  LineIter i = Lines.find(V);
84  if (i != Lines.end()) {
85  Line = i->second;
86  return true;
87  }
88  return false;
89  }
90 };
91 
92 /// Removes debug intrisncs like llvm.dbg.declare and llvm.dbg.value.
93 class DebugIntrinsicsRemover : public InstVisitor<DebugIntrinsicsRemover> {
94  void remove(Instruction &I) { I.eraseFromParent(); }
95 
96 public:
97  static void process(Module &M) {
98  DebugIntrinsicsRemover Remover;
99  Remover.visit(&M);
100  }
101  void visitDbgDeclareInst(DbgDeclareInst &I) { remove(I); }
102  void visitDbgValueInst(DbgValueInst &I) { remove(I); }
103  void visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { remove(I); }
104 };
105 
106 /// Removes debug metadata (!dbg) nodes from all instructions, and optionally
107 /// metadata named "llvm.dbg.cu" if RemoveNamedInfo is true.
108 class DebugMetadataRemover : public InstVisitor<DebugMetadataRemover> {
109  bool RemoveNamedInfo;
110 
111 public:
112  static void process(Module &M, bool RemoveNamedInfo = true) {
113  DebugMetadataRemover Remover(RemoveNamedInfo);
114  Remover.run(&M);
115  }
116 
117  DebugMetadataRemover(bool RemoveNamedInfo)
118  : RemoveNamedInfo(RemoveNamedInfo) {}
119 
120  void visitInstruction(Instruction &I) {
123  }
124 
125  void run(Module *M) {
126  // Remove debug metadata attached to instructions
127  visit(M);
128 
129  if (RemoveNamedInfo) {
130  // Remove CU named metadata (and all children nodes)
131  NamedMDNode *Node = M->getNamedMetadata("llvm.dbg.cu");
132  if (Node)
133  M->eraseNamedMetadata(Node);
134  }
135  }
136 };
137 
138 /// Updates debug metadata in a Module:
139 /// - changes Filename/Directory to values provided on construction
140 /// - adds/updates line number (DebugLoc) entries associated with each
141 /// instruction to reflect the instruction's location in an LLVM IR file
142 class DIUpdater : public InstVisitor<DIUpdater> {
143  /// Builder of debug information
144  DIBuilder Builder;
145 
146  /// Helper for type attributes/sizes/etc
147  DataLayout Layout;
148 
149  /// Map of Value* to line numbers
150  const ValueToLineMap LineTable;
151 
152  /// Map of Value* (in original Module) to Value* (in optional cloned Module)
153  const ValueToValueMapTy *VMap;
154 
155  /// Directory of debug metadata
156  DebugInfoFinder Finder;
157 
158  /// Source filename and directory
159  StringRef Filename;
160  StringRef Directory;
161 
162  // CU nodes needed when creating DI subprograms
163  MDNode *FileNode;
164  MDNode *LexicalBlockFileNode;
165  const MDNode *CUNode;
166 
167  ValueMap<const Function *, MDNode *> SubprogramDescriptors;
168  DenseMap<const Type *, MDNode *> TypeDescriptors;
169 
170 public:
171  DIUpdater(Module &M, StringRef Filename = StringRef(),
172  StringRef Directory = StringRef(), const Module *DisplayM = 0,
173  const ValueToValueMapTy *VMap = 0)
174  : Builder(M), Layout(&M), LineTable(DisplayM ? DisplayM : &M), VMap(VMap),
175  Finder(), Filename(Filename), Directory(Directory), FileNode(0),
176  LexicalBlockFileNode(0), CUNode(0) {
177  Finder.processModule(M);
178  visit(&M);
179  }
180 
181  ~DIUpdater() { Builder.finalize(); }
182 
183  void visitModule(Module &M) {
184  if (Finder.compile_unit_count() > 1)
185  report_fatal_error("DebugIR pass supports only a signle compile unit per "
186  "Module.");
187  createCompileUnit(
188  Finder.compile_unit_count() == 1 ? *Finder.compile_unit_begin() : 0);
189  }
190 
191  void visitFunction(Function &F) {
192  if (F.isDeclaration() || findDISubprogram(&F))
193  return;
194 
195  StringRef MangledName = F.getName();
196  DICompositeType Sig = createFunctionSignature(&F);
197 
198  // find line of function declaration
199  unsigned Line = 0;
200  if (!findLine(&F, Line)) {
201  DEBUG(dbgs() << "WARNING: No line for Function " << F.getName().str()
202  << "\n");
203  return;
204  }
205 
206  Instruction *FirstInst = F.begin()->begin();
207  unsigned ScopeLine = 0;
208  if (!findLine(FirstInst, ScopeLine)) {
209  DEBUG(dbgs() << "WARNING: No line for 1st Instruction in Function "
210  << F.getName().str() << "\n");
211  return;
212  }
213 
214  bool Local = F.hasInternalLinkage();
215  bool IsDefinition = !F.isDeclaration();
216  bool IsOptimized = false;
217 
218  int FuncFlags = llvm::DIDescriptor::FlagPrototyped;
219  assert(CUNode && FileNode);
220  DISubprogram Sub = Builder.createFunction(
221  DICompileUnit(CUNode), F.getName(), MangledName, DIFile(FileNode), Line,
222  Sig, Local, IsDefinition, ScopeLine, FuncFlags, IsOptimized, &F);
223  assert(Sub.isSubprogram());
224  DEBUG(dbgs() << "create subprogram mdnode " << *Sub << ": "
225  << "\n");
226 
227  SubprogramDescriptors.insert(std::make_pair(&F, Sub));
228  }
229 
230  void visitInstruction(Instruction &I) {
231  DebugLoc Loc(I.getDebugLoc());
232 
233  /// If a ValueToValueMap is provided, use it to get the real instruction as
234  /// the line table was generated on a clone of the module on which we are
235  /// operating.
236  Value *RealInst = 0;
237  if (VMap)
238  RealInst = VMap->lookup(&I);
239 
240  if (!RealInst)
241  RealInst = &I;
242 
243  unsigned Col = 0; // FIXME: support columns
244  unsigned Line;
245  if (!LineTable.getLine(RealInst, Line)) {
246  // Instruction has no line, it may have been removed (in the module that
247  // will be passed to the debugger) so there is nothing to do here.
248  DEBUG(dbgs() << "WARNING: no LineTable entry for instruction " << RealInst
249  << "\n");
250  DEBUG(RealInst->dump());
251  return;
252  }
253 
254  DebugLoc NewLoc;
255  if (!Loc.isUnknown())
256  // I had a previous debug location: re-use the DebugLoc
257  NewLoc = DebugLoc::get(Line, Col, Loc.getScope(RealInst->getContext()),
258  Loc.getInlinedAt(RealInst->getContext()));
259  else if (MDNode *scope = findScope(&I))
260  NewLoc = DebugLoc::get(Line, Col, scope, 0);
261  else {
262  DEBUG(dbgs() << "WARNING: no valid scope for instruction " << &I
263  << ". no DebugLoc will be present."
264  << "\n");
265  return;
266  }
267 
268  addDebugLocation(I, NewLoc);
269  }
270 
271 private:
272 
273  void createCompileUnit(MDNode *CUToReplace) {
274  std::string Flags;
275  bool IsOptimized = false;
276  StringRef Producer;
277  unsigned RuntimeVersion(0);
278  StringRef SplitName;
279 
280  if (CUToReplace) {
281  // save fields from existing CU to re-use in the new CU
282  DICompileUnit ExistingCU(CUToReplace);
283  Producer = ExistingCU.getProducer();
284  IsOptimized = ExistingCU.isOptimized();
285  Flags = ExistingCU.getFlags();
286  RuntimeVersion = ExistingCU.getRunTimeVersion();
287  SplitName = ExistingCU.getSplitDebugFilename();
288  } else {
289  Producer =
290  "LLVM Version " STR(LLVM_VERSION_MAJOR) "." STR(LLVM_VERSION_MINOR);
291  }
292 
293  CUNode =
294  Builder.createCompileUnit(dwarf::DW_LANG_C99, Filename, Directory,
295  Producer, IsOptimized, Flags, RuntimeVersion);
296 
297  if (CUToReplace)
298  CUToReplace->replaceAllUsesWith(const_cast<MDNode *>(CUNode));
299 
300  DICompileUnit CU(CUNode);
301  FileNode = Builder.createFile(Filename, Directory);
302  LexicalBlockFileNode = Builder.createLexicalBlockFile(CU, DIFile(FileNode));
303  }
304 
305  /// Returns the MDNode* that represents the DI scope to associate with I
306  MDNode *findScope(const Instruction *I) {
307  const Function *F = I->getParent()->getParent();
308  if (MDNode *ret = findDISubprogram(F))
309  return ret;
310 
311  DEBUG(dbgs() << "WARNING: Using fallback lexical block file scope "
312  << LexicalBlockFileNode << " as scope for instruction " << I
313  << "\n");
314  return LexicalBlockFileNode;
315  }
316 
317  /// Returns the MDNode* that is the descriptor for F
318  MDNode *findDISubprogram(const Function *F) {
320  FuncNodeIter i = SubprogramDescriptors.find(F);
321  if (i != SubprogramDescriptors.end())
322  return i->second;
323 
324  DEBUG(dbgs() << "searching for DI scope node for Function " << F
325  << " in a list of " << Finder.subprogram_count()
326  << " subprogram nodes"
327  << "\n");
328 
329  for (DebugInfoFinder::iterator i = Finder.subprogram_begin(),
330  e = Finder.subprogram_end();
331  i != e; ++i) {
332  DISubprogram S(*i);
333  if (S.getFunction() == F) {
334  DEBUG(dbgs() << "Found DISubprogram " << *i << " for function "
335  << S.getFunction() << "\n");
336  return *i;
337  }
338  }
339  DEBUG(dbgs() << "unable to find DISubprogram node for function "
340  << F->getName().str() << "\n");
341  return 0;
342  }
343 
344  /// Sets Line to the line number on which V appears and returns true. If a
345  /// line location for V is not found, returns false.
346  bool findLine(const Value *V, unsigned &Line) {
347  if (LineTable.getLine(V, Line))
348  return true;
349 
350  if (VMap) {
351  Value *mapped = VMap->lookup(V);
352  if (mapped && LineTable.getLine(mapped, Line))
353  return true;
354  }
355  return false;
356  }
357 
358  std::string getTypeName(Type *T) {
359  std::string TypeName;
360  raw_string_ostream TypeStream(TypeName);
361  T->print(TypeStream);
362  TypeStream.flush();
363  return TypeName;
364  }
365 
366  /// Returns the MDNode that represents type T if it is already created, or 0
367  /// if it is not.
368  MDNode *getType(const Type *T) {
370  TypeNodeIter i = TypeDescriptors.find(T);
371  if (i != TypeDescriptors.end())
372  return i->second;
373  return 0;
374  }
375 
376  /// Returns a DebugInfo type from an LLVM type T.
377  DIDerivedType getOrCreateType(Type *T) {
378  MDNode *N = getType(T);
379  if (N)
380  return DIDerivedType(N);
381  else if (T->isVoidTy())
382  return DIDerivedType(0);
383  else if (T->isStructTy()) {
384  N = Builder.createStructType(
385  DIScope(LexicalBlockFileNode), T->getStructName(), DIFile(FileNode),
386  0, Layout.getTypeSizeInBits(T), Layout.getABITypeAlignment(T), 0,
387  DIType(0), DIArray(0)); // filled in later
388 
389  // N is added to the map (early) so that element search below can find it,
390  // so as to avoid infinite recursion for structs that contain pointers to
391  // their own type.
392  TypeDescriptors[T] = N;
393  DICompositeType StructDescriptor(N);
394 
395  SmallVector<Value *, 4> Elements;
396  for (unsigned i = 0; i < T->getStructNumElements(); ++i)
397  Elements.push_back(getOrCreateType(T->getStructElementType(i)));
398 
399  // set struct elements
400  StructDescriptor.setTypeArray(Builder.getOrCreateArray(Elements));
401  } else if (T->isPointerTy()) {
402  Type *PointeeTy = T->getPointerElementType();
403  if (!(N = getType(PointeeTy)))
404  N = Builder.createPointerType(
405  getOrCreateType(PointeeTy), Layout.getPointerTypeSizeInBits(T),
406  Layout.getPrefTypeAlignment(T), getTypeName(T));
407  } else if (T->isArrayTy()) {
408  SmallVector<Value *, 1> Subrange;
409  Subrange.push_back(
410  Builder.getOrCreateSubrange(0, T->getArrayNumElements() - 1));
411 
412  N = Builder.createArrayType(Layout.getTypeSizeInBits(T),
413  Layout.getPrefTypeAlignment(T),
414  getOrCreateType(T->getArrayElementType()),
415  Builder.getOrCreateArray(Subrange));
416  } else {
417  int encoding = llvm::dwarf::DW_ATE_signed;
418  if (T->isIntegerTy())
419  encoding = llvm::dwarf::DW_ATE_unsigned;
420  else if (T->isFloatingPointTy())
421  encoding = llvm::dwarf::DW_ATE_float;
422 
423  N = Builder.createBasicType(getTypeName(T), T->getPrimitiveSizeInBits(),
424  0, encoding);
425  }
426  TypeDescriptors[T] = N;
427  return DIDerivedType(N);
428  }
429 
430  /// Returns a DebugInfo type that represents a function signature for Func.
431  DICompositeType createFunctionSignature(const Function *Func) {
433  DIDerivedType ReturnType(getOrCreateType(Func->getReturnType()));
434  Params.push_back(ReturnType);
435 
436  const Function::ArgumentListType &Args(Func->getArgumentList());
437  for (Function::ArgumentListType::const_iterator i = Args.begin(),
438  e = Args.end();
439  i != e; ++i) {
440  Type *T(i->getType());
441  Params.push_back(getOrCreateType(T));
442  }
443 
444  DIArray ParamArray = Builder.getOrCreateArray(Params);
445  return Builder.createSubroutineType(DIFile(FileNode), ParamArray);
446  }
447 
448  /// Associates Instruction I with debug location Loc.
449  void addDebugLocation(Instruction &I, DebugLoc Loc) {
450  MDNode *MD = Loc.getAsMDNode(I.getContext());
452  }
453 };
454 
455 /// Sets Filename/Directory from the Module identifier and returns true, or
456 /// false if source information is not present.
457 bool getSourceInfoFromModule(const Module &M, std::string &Directory,
458  std::string &Filename) {
459  std::string PathStr(M.getModuleIdentifier());
460  if (PathStr.length() == 0 || PathStr == "<stdin>")
461  return false;
462 
463  Filename = sys::path::filename(PathStr);
464  SmallVector<char, 16> Path(PathStr.begin(), PathStr.end());
466  Directory = StringRef(Path.data(), Path.size());
467  return true;
468 }
469 
470 // Sets Filename/Directory from debug information in M and returns true, or
471 // false if no debug information available, or cannot be parsed.
472 bool getSourceInfoFromDI(const Module &M, std::string &Directory,
473  std::string &Filename) {
474  NamedMDNode *CUNode = M.getNamedMetadata("llvm.dbg.cu");
475  if (!CUNode || CUNode->getNumOperands() == 0)
476  return false;
477 
478  DICompileUnit CU(CUNode->getOperand(0));
479  if (!CU.Verify())
480  return false;
481 
482  Filename = CU.getFilename();
483  Directory = CU.getDirectory();
484  return true;
485 }
486 
487 } // anonymous namespace
488 
489 namespace llvm {
490 
491 bool DebugIR::getSourceInfo(const Module &M) {
492  ParsedPath = getSourceInfoFromDI(M, Directory, Filename) ||
493  getSourceInfoFromModule(M, Directory, Filename);
494  return ParsedPath;
495 }
496 
497 bool DebugIR::updateExtension(StringRef NewExtension) {
498  size_t dot = Filename.find_last_of(".");
499  if (dot == std::string::npos)
500  return false;
501 
502  Filename.erase(dot);
503  Filename += NewExtension.str();
504  return true;
505 }
506 
507 void DebugIR::generateFilename(OwningPtr<int> &fd) {
508  SmallVector<char, 16> PathVec;
509  fd.reset(new int);
510  sys::fs::createTemporaryFile("debug-ir", "ll", *fd, PathVec);
511  StringRef Path(PathVec.data(), PathVec.size());
512  Filename = sys::path::filename(Path);
514  Directory = StringRef(PathVec.data(), PathVec.size());
515 
516  GeneratedPath = true;
517 }
518 
519 std::string DebugIR::getPath() {
521  sys::path::append(Path, Directory, Filename);
522  Path.resize(Filename.size() + Directory.size() + 2);
523  Path[Filename.size() + Directory.size() + 1] = '\0';
524  return std::string(Path.data());
525 }
526 
527 void DebugIR::writeDebugBitcode(const Module *M, int *fd) {
529  std::string error;
530 
531  if (!fd) {
532  std::string Path = getPath();
533  Out.reset(new raw_fd_ostream(Path.c_str(), error));
534  DEBUG(dbgs() << "WRITING debug bitcode from Module " << M << " to file "
535  << Path << "\n");
536  } else {
537  DEBUG(dbgs() << "WRITING debug bitcode from Module " << M << " to fd "
538  << *fd << "\n");
539  Out.reset(new raw_fd_ostream(*fd, true));
540  }
541 
542  M->print(*Out, 0);
543  Out->close();
544 }
545 
546 void DebugIR::createDebugInfo(Module &M, OwningPtr<Module> &DisplayM) {
547  if (M.getFunctionList().size() == 0)
548  // no functions -- no debug info needed
549  return;
550 
552 
553  if (WriteSourceToDisk && (HideDebugIntrinsics || HideDebugMetadata)) {
554  VMap.reset(new ValueToValueMapTy);
555  DisplayM.reset(CloneModule(&M, *VMap));
556 
557  if (HideDebugIntrinsics)
558  DebugIntrinsicsRemover::process(*DisplayM);
559 
560  if (HideDebugMetadata)
561  DebugMetadataRemover::process(*DisplayM);
562  }
563 
564  DIUpdater R(M, Filename, Directory, DisplayM.get(), VMap.get());
565 }
566 
567 bool DebugIR::isMissingPath() { return Filename.empty() || Directory.empty(); }
568 
570  OwningPtr<int> fd;
571 
572  if (isMissingPath() && !getSourceInfo(M)) {
573  if (!WriteSourceToDisk)
574  report_fatal_error("DebugIR unable to determine file name in input. "
575  "Ensure Module contains an identifier, a valid "
576  "DICompileUnit, or construct DebugIR with "
577  "non-empty Filename/Directory parameters.");
578  else
579  generateFilename(fd);
580  }
581 
582  if (!GeneratedPath && WriteSourceToDisk)
583  updateExtension(".debug-ll");
584 
585  // Clear line numbers. Keep debug info (if any) if we were able to read the
586  // file name from the DICompileUnit descriptor.
587  DebugMetadataRemover::process(M, !ParsedPath);
588 
589  OwningPtr<Module> DisplayM;
590  createDebugInfo(M, DisplayM);
591  if (WriteSourceToDisk) {
592  Module *OutputM = DisplayM.get() ? DisplayM.get() : &M;
593  writeDebugBitcode(OutputM, fd.get());
594  }
595 
596  DEBUG(M.dump());
597  return true;
598 }
599 
600 bool DebugIR::runOnModule(Module &M, std::string &Path) {
601  bool result = runOnModule(M);
602  Path = getPath();
603  return result;
604 }
605 
606 } // llvm namespace
607 
608 char DebugIR::ID = 0;
609 INITIALIZE_PASS(DebugIR, "debug-ir", "Enable debugging IR", false, false)
610 
611 ModulePass *llvm::createDebugIRPass(bool HideDebugIntrinsics,
612  bool HideDebugMetadata, StringRef Directory,
613  StringRef Filename) {
614  return new DebugIR(HideDebugIntrinsics, HideDebugMetadata, Directory,
615  Filename);
616 }
617 
unsigned getStructNumElements() const
Definition: Type.cpp:198
Base class for instruction visitors.
Definition: InstVisitor.h:81
bool isSubprogram() const
Definition: DebugInfo.cpp:225
Module * CloneModule(const Module *M)
Definition: CloneModule.cpp:27
The main container class for the LLVM Intermediate Representation.
Definition: Module.h:112
StringRef getFlags() const
Definition: DebugInfo.h:413
raw_null_ostream - A raw_ostream that discards all output.
Definition: raw_ostream.h:478
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:181
Type * getReturnType() const
Definition: Function.cpp:179
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:116
MDNode * getAsMDNode(const LLVMContext &Ctx) const
Definition: DebugLoc.cpp:100
MDNode - a tuple of other values.
Definition: Metadata.h:69
F(f)
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Definition: Function.cpp:657
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Type * getPointerElementType() const
Definition: Type.h:373
StringRef getName() const
Definition: Value.cpp:167
DIArray - This descriptor holds an array of descriptors.
Definition: DebugInfo.h:167
void print(raw_ostream &O) const
Definition: AsmWriter.cpp:2146
void setTypeArray(DIArray Elements, DIArray TParams=DIArray())
Set the array of member DITypes.
Definition: DebugInfo.cpp:643
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:372
void remove_filename(SmallVectorImpl< char > &path)
Remove the last component from path unless it is the root dir.
Definition: Path.cpp:427
void eraseNamedMetadata(NamedMDNode *NMD)
Definition: Module.cpp:308
Type * getArrayElementType() const
Definition: Type.h:368
bool hasInternalLinkage() const
Definition: GlobalValue.h:205
StringRef getStructName() const
Definition: Type.cpp:194
ID
LLVM Calling Convention Representation.
Definition: CallingConv.h:26
const std::string & getModuleIdentifier() const
Definition: Module.h:228
DISubprogram - This is a wrapper for a subprogram (e.g. a function).
Definition: DebugInfo.h:429
#define T
unsigned getLine()
getLine - Return the line number
bool isFloatingPointTy() const
Definition: Type.h:162
void replaceAllUsesWith(Value *V)
Definition: Value.cpp:303
bool isArrayTy() const
Definition: Type.h:216
DIFile - This is a wrapper for a file.
Definition: DebugInfo.h:392
iterator begin()
Definition: Function.h:395
ModulePass * createDebugIRPass(bool HideDebugIntrinsics, bool HideDebugMetadata, StringRef Directory=StringRef(), StringRef Filename=StringRef())
Definition: DebugIR.cpp:611
Function * getFunction() const
Definition: DebugInfo.h:482
StringRef getFilename() const
Definition: DebugInfo.cpp:773
Generic base class which exposes information about an operating system process.
Definition: Process.h:51
void reset(T *P=0)
Definition: OwningPtr.h:51
size_type LLVM_ATTRIBUTE_UNUSED_RESULT size() const
Definition: ilist.h:539
const DebugLoc & getDebugLoc() const
getDebugLoc - Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:178
MDNode * getOperand(unsigned i) const
getOperand - Return specified operand.
Definition: Metadata.cpp:545
#define STR(x)
Definition: DebugIR.cpp:43
bool isPointerTy() const
Definition: Type.h:220
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:517
error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath)
Create a file in the system temporary directory.
Definition: Path.cpp:678
void setMetadata(unsigned KindID, MDNode *Node)
Definition: Metadata.cpp:589
T * get() const
Definition: OwningPtr.h:72
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const
Definition: AsmWriter.cpp:2132
DIScope - A base class for various scopes.
Definition: DebugInfo.h:197
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:153
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:492
See the file comment.
Definition: ValueMap.h:75
MDNode * getMetadata(unsigned KindID) const
Definition: Instruction.h:140
raw_ostream & dbgs()
dbgs - Return a circular-buffered debug stream.
Definition: Debug.cpp:101
bool isIntegerTy() const
Definition: Type.h:196
bool runOnModule(llvm::Module &M, std::string &Path)
Run pass on M and set Path to the source file path in the output module.
Definition: DebugIR.cpp:600
bool isStructTy() const
Definition: Type.h:212
static DebugLoc get(unsigned Line, unsigned Col, MDNode *Scope, MDNode *InlinedAt=0)
Definition: DebugLoc.cpp:74
NamedMDNode * getNamedMetadata(const Twine &Name) const
Definition: Module.cpp:286
pointer data()
data - Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:135
bool isDeclaration() const
Definition: Globals.cpp:66
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
unsigned getRunTimeVersion() const
Definition: DebugInfo.h:414
void resize(unsigned N)
Definition: SmallVector.h:401
uint64_t getArrayNumElements() const
Definition: Type.cpp:210
unsigned getPrimitiveSizeInBits() const
Definition: Type.cpp:117
bool isOptimized() const
Definition: DebugInfo.h:412
LLVM Value Representation.
Definition: Value.h:66
const ArgumentListType & getArgumentList() const
Definition: Function.h:362
unsigned getNumOperands() const
getNumOperands - Return the number of NamedMDNode operands.
Definition: Metadata.cpp:540
#define DEBUG(X)
Definition: Debug.h:97
Type * getStructElementType(unsigned N) const
Definition: Type.cpp:202
const StringRef filename(StringRef path)
Get filename.
Definition: Path.cpp:467
DICompileUnit - A wrapper for a compile unit.
Definition: DebugInfo.h:402
iterator find(const KeyT &Val)
Definition: DenseMap.h:108
StringRef getProducer() const
Definition: DebugInfo.h:410
void dump() const
Dump the module to stderr (for debugging).
Definition: AsmWriter.cpp:2218
const BasicBlock * getParent() const
Definition: Instruction.h:52
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:140
StringRef getSplitDebugFilename() const
Definition: DebugInfo.h:422