X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FAsmWriter.cpp;h=d1beb166a184559b79345a81ac3eed32363398f8;hb=e37f2a0dc69326363cbe0b1e7a4120e71814deaf;hp=215332b82562f271935e936f1547554e3734613b;hpb=d64096265605491a623ad566db9459e42dbe9ae7;p=oota-llvm.git

diff --git a/lib/IR/AsmWriter.cpp b/lib/IR/AsmWriter.cpp
index 215332b8256..d1beb166a18 100644
--- a/lib/IR/AsmWriter.cpp
+++ b/lib/IR/AsmWriter.cpp
@@ -1286,13 +1286,55 @@ raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
 }
 } // end namespace
 
+static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
+                                   TypePrinting *TypePrinter,
+                                   SlotTracker *Machine,
+                                   const Module *Context) {
+  if (!MD) {
+    Out << "null";
+    return;
+  }
+  WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
+}
+
+static void writeTag(raw_ostream &Out, FieldSeparator &FS, const DebugNode *N) {
+  Out << FS << "tag: ";
+  if (const char *Tag = dwarf::TagString(N->getTag()))
+    Out << Tag;
+  else
+    Out << N->getTag();
+}
+
+static void writeGenericDebugNode(raw_ostream &Out, const GenericDebugNode *N,
+                                  TypePrinting *TypePrinter,
+                                  SlotTracker *Machine, const Module *Context) {
+  Out << "!GenericDebugNode(";
+  FieldSeparator FS;
+  writeTag(Out, FS, N);
+  if (!N->getHeader().empty()) {
+    Out << FS << "header: \"";
+    PrintEscapedString(N->getHeader(), Out);
+    Out << "\"";
+  }
+  if (N->getNumDwarfOperands()) {
+    Out << FS << "operands: {";
+    FieldSeparator IFS;
+    for (auto &I : N->dwarf_operands()) {
+      Out << IFS;
+      writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
+    }
+    Out << "}";
+  }
+  Out << ")";
+}
+
 static void writeMDLocation(raw_ostream &Out, const MDLocation *DL,
                             TypePrinting *TypePrinter, SlotTracker *Machine,
                             const Module *Context) {
   Out << "!MDLocation(";
   FieldSeparator FS;
-  if (DL->getLine())
-    Out << FS << "line: " << DL->getLine();
+  // Always output the line, since 0 is a relevant and important value for it.
+  Out << FS << "line: " << DL->getLine();
   if (DL->getColumn())
     Out << FS << "column: " << DL->getColumn();
   Out << FS << "scope: ";
@@ -1305,22 +1347,108 @@ static void writeMDLocation(raw_ostream &Out, const MDLocation *DL,
   Out << ")";
 }
 
+static void writeMDSubrange(raw_ostream &, const MDSubrange *, TypePrinting *,
+                            SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDEnumerator(raw_ostream &, const MDEnumerator *,
+                              TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDBasicType(raw_ostream &, const MDBasicType *, TypePrinting *,
+                             SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDDerivedType(raw_ostream &, const MDDerivedType *,
+                               TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDCompositeType(raw_ostream &, const MDCompositeType *,
+                                 TypePrinting *, SlotTracker *,
+                                 const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDSubroutineType(raw_ostream &, const MDSubroutineType *,
+                                  TypePrinting *, SlotTracker *,
+                                  const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDFile(raw_ostream &, const MDFile *, TypePrinting *,
+                        SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDCompileUnit(raw_ostream &, const MDCompileUnit *,
+                               TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDSubprogram(raw_ostream &, const MDSubprogram *,
+                              TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDLexicalBlock(raw_ostream &, const MDLexicalBlock *,
+                                TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDLexicalBlockFile(raw_ostream &, const MDLexicalBlockFile *,
+                                    TypePrinting *, SlotTracker *,
+                                    const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDNamespace(raw_ostream &, const MDNamespace *, TypePrinting *,
+                             SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDTemplateTypeParameter(raw_ostream &,
+                                         const MDTemplateTypeParameter *,
+                                         TypePrinting *, SlotTracker *,
+                                         const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDTemplateValueParameter(raw_ostream &,
+                                          const MDTemplateValueParameter *,
+                                          TypePrinting *, SlotTracker *,
+                                          const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDGlobalVariable(raw_ostream &, const MDGlobalVariable *,
+                                  TypePrinting *, SlotTracker *,
+                                  const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDLocalVariable(raw_ostream &, const MDLocalVariable *,
+                                 TypePrinting *, SlotTracker *,
+                                 const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDExpression(raw_ostream &, const MDExpression *,
+                              TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDObjCProperty(raw_ostream &, const MDObjCProperty *,
+                                TypePrinting *, SlotTracker *, const Module *) {
+  llvm_unreachable("write not implemented");
+}
+static void writeMDImportedEntity(raw_ostream &, const MDImportedEntity *,
+                                  TypePrinting *, SlotTracker *,
+                                  const Module *) {
+  llvm_unreachable("write not implemented");
+}
+
 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
                                     TypePrinting *TypePrinter,
                                     SlotTracker *Machine,
                                     const Module *Context) {
-  assert(isa<UniquableMDNode>(Node) && "Expected uniquable MDNode");
+  assert(!Node->isTemporary() && "Unexpected forward declaration");
 
-  auto *Uniquable = cast<UniquableMDNode>(Node);
-  if (Uniquable->isDistinct())
+  if (Node->isDistinct())
     Out << "distinct ";
 
-  switch (Uniquable->getMetadataID()) {
+  switch (Node->getMetadataID()) {
   default:
     llvm_unreachable("Expected uniquable MDNode");
-#define HANDLE_UNIQUABLE_LEAF(CLASS)                                           \
+#define HANDLE_MDNODE_LEAF(CLASS)                                              \
   case Metadata::CLASS##Kind:                                                  \
-    write##CLASS(Out, cast<CLASS>(Uniquable), TypePrinter, Machine, Context);  \
+    write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context);       \
     break;
 #include "llvm/IR/Metadata.def"
   }