Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 1 | //===--- StmtDumper.cpp - Dumping implementation for Stmt ASTs ------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the Stmt::dump/Stmt::print methods, which dump out the |
| 11 | // AST in a form that exposes type details and other fields. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "clang/AST/StmtVisitor.h" |
Ted Kremenek | 91d1d7a | 2007-10-17 18:36:42 +0000 | [diff] [blame] | 16 | #include "clang/AST/DeclObjC.h" |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 17 | #include "clang/AST/DeclCXX.h" |
Douglas Gregor | d249e1d1f | 2009-05-29 20:38:28 +0000 | [diff] [blame] | 18 | #include "clang/AST/PrettyPrinter.h" |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 19 | #include "clang/Basic/SourceManager.h" |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 20 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 21 | using namespace clang; |
| 22 | |
| 23 | //===----------------------------------------------------------------------===// |
| 24 | // StmtDumper Visitor |
| 25 | //===----------------------------------------------------------------------===// |
| 26 | |
| 27 | namespace { |
Benjamin Kramer | 770b4a8 | 2009-11-28 19:03:38 +0000 | [diff] [blame] | 28 | class StmtDumper : public StmtVisitor<StmtDumper> { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 29 | SourceManager *SM; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 30 | raw_ostream &OS; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 31 | unsigned IndentLevel; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 32 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 33 | /// MaxDepth - When doing a normal dump (not dumpAll) we only want to dump |
| 34 | /// the first few levels of an AST. This keeps track of how many ast levels |
| 35 | /// are left. |
| 36 | unsigned MaxDepth; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 37 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 38 | /// LastLocFilename/LastLocLine - Keep track of the last location we print |
| 39 | /// out so that we can print out deltas from then on out. |
| 40 | const char *LastLocFilename; |
| 41 | unsigned LastLocLine; |
Douglas Gregor | d249e1d1f | 2009-05-29 20:38:28 +0000 | [diff] [blame] | 42 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 43 | public: |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 44 | StmtDumper(SourceManager *sm, raw_ostream &os, unsigned maxDepth) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 45 | : SM(sm), OS(os), IndentLevel(0-1), MaxDepth(maxDepth) { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 46 | LastLocFilename = ""; |
| 47 | LastLocLine = ~0U; |
| 48 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 49 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 50 | void DumpSubTree(Stmt *S) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 51 | // Prune the recursion if not using dump all. |
| 52 | if (MaxDepth == 0) return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 53 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 54 | ++IndentLevel; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 55 | if (S) { |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 56 | if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) |
| 57 | VisitDeclStmt(DS); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 58 | else { |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 59 | Visit(S); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 60 | |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 61 | // Print out children. |
John McCall | 7502c1d | 2011-02-13 04:07:26 +0000 | [diff] [blame] | 62 | Stmt::child_range CI = S->children(); |
| 63 | if (CI) { |
| 64 | while (CI) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 65 | OS << '\n'; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 66 | DumpSubTree(*CI++); |
| 67 | } |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 68 | } |
| 69 | } |
Chris Lattner | a46325e | 2010-05-25 17:56:43 +0000 | [diff] [blame] | 70 | OS << ')'; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 71 | } else { |
| 72 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 73 | OS << "<<<NULL>>>"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 74 | } |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 75 | --IndentLevel; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 76 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 77 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 78 | void DumpDeclarator(Decl *D); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 79 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 80 | void Indent() const { |
| 81 | for (int i = 0, e = IndentLevel; i < e; ++i) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 82 | OS << " "; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 83 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 84 | |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 85 | void DumpType(QualType T) { |
John McCall | 49f4e1c | 2010-12-10 11:01:00 +0000 | [diff] [blame] | 86 | SplitQualType T_split = T.split(); |
| 87 | OS << "'" << QualType::getAsString(T_split) << "'"; |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 88 | |
Douglas Gregor | 61366e9 | 2008-12-24 00:01:03 +0000 | [diff] [blame] | 89 | if (!T.isNull()) { |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 90 | // If the type is sugared, also dump a (shallow) desugared type. |
John McCall | 49f4e1c | 2010-12-10 11:01:00 +0000 | [diff] [blame] | 91 | SplitQualType D_split = T.getSplitDesugaredType(); |
| 92 | if (T_split != D_split) |
| 93 | OS << ":'" << QualType::getAsString(D_split) << "'"; |
Chris Lattner | bad3785 | 2008-04-02 05:06:23 +0000 | [diff] [blame] | 94 | } |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 95 | } |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 96 | void DumpDeclRef(Decl *node); |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 97 | void DumpStmt(const Stmt *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 98 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 99 | OS << "(" << Node->getStmtClassName() |
| 100 | << " " << (void*)Node; |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 101 | DumpSourceRange(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 102 | } |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 103 | void DumpValueKind(ExprValueKind K) { |
| 104 | switch (K) { |
| 105 | case VK_RValue: break; |
| 106 | case VK_LValue: OS << " lvalue"; break; |
| 107 | case VK_XValue: OS << " xvalue"; break; |
| 108 | } |
| 109 | } |
| 110 | void DumpObjectKind(ExprObjectKind K) { |
| 111 | switch (K) { |
| 112 | case OK_Ordinary: break; |
| 113 | case OK_BitField: OS << " bitfield"; break; |
| 114 | case OK_ObjCProperty: OS << " objcproperty"; break; |
| 115 | case OK_VectorComponent: OS << " vectorcomponent"; break; |
| 116 | } |
| 117 | } |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 118 | void DumpExpr(const Expr *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 119 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 120 | OS << ' '; |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 121 | DumpType(Node->getType()); |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 122 | DumpValueKind(Node->getValueKind()); |
| 123 | DumpObjectKind(Node->getObjectKind()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 124 | } |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 125 | void DumpSourceRange(const Stmt *Node); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 126 | void DumpLocation(SourceLocation Loc); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 127 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 128 | // Stmts. |
Chris Lattner | c5598cb | 2007-08-21 04:04:25 +0000 | [diff] [blame] | 129 | void VisitStmt(Stmt *Node); |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 130 | void VisitDeclStmt(DeclStmt *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 131 | void VisitLabelStmt(LabelStmt *Node); |
| 132 | void VisitGotoStmt(GotoStmt *Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 133 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 134 | // Exprs |
| 135 | void VisitExpr(Expr *Node); |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 136 | void VisitCastExpr(CastExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 137 | void VisitDeclRefExpr(DeclRefExpr *Node); |
Chris Lattner | d9f6910 | 2008-08-10 01:53:14 +0000 | [diff] [blame] | 138 | void VisitPredefinedExpr(PredefinedExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 139 | void VisitCharacterLiteral(CharacterLiteral *Node); |
| 140 | void VisitIntegerLiteral(IntegerLiteral *Node); |
| 141 | void VisitFloatingLiteral(FloatingLiteral *Node); |
| 142 | void VisitStringLiteral(StringLiteral *Str); |
| 143 | void VisitUnaryOperator(UnaryOperator *Node); |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 144 | void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 145 | void VisitMemberExpr(MemberExpr *Node); |
Nate Begeman | 213541a | 2008-04-18 23:10:10 +0000 | [diff] [blame] | 146 | void VisitExtVectorElementExpr(ExtVectorElementExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 147 | void VisitBinaryOperator(BinaryOperator *Node); |
| 148 | void VisitCompoundAssignOperator(CompoundAssignOperator *Node); |
| 149 | void VisitAddrLabelExpr(AddrLabelExpr *Node); |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 150 | void VisitBlockExpr(BlockExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 151 | |
| 152 | // C++ |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 153 | void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 154 | void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node); |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 155 | void VisitCXXThisExpr(CXXThisExpr *Node); |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 156 | void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 157 | void VisitCXXConstructExpr(CXXConstructExpr *Node); |
| 158 | void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node); |
John McCall | 4765fa0 | 2010-12-06 08:20:24 +0000 | [diff] [blame] | 159 | void VisitExprWithCleanups(ExprWithCleanups *Node); |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 160 | void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 161 | void DumpCXXTemporary(CXXTemporary *Temporary); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 162 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 163 | // ObjC |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 164 | void VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 165 | void VisitObjCEncodeExpr(ObjCEncodeExpr *Node); |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 166 | void VisitObjCMessageExpr(ObjCMessageExpr* Node); |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 167 | void VisitObjCSelectorExpr(ObjCSelectorExpr *Node); |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 168 | void VisitObjCProtocolExpr(ObjCProtocolExpr *Node); |
Daniel Dunbar | 7f8ea5c | 2008-08-30 05:35:15 +0000 | [diff] [blame] | 169 | void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node); |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 170 | void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 171 | }; |
| 172 | } |
| 173 | |
| 174 | //===----------------------------------------------------------------------===// |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 175 | // Utilities |
| 176 | //===----------------------------------------------------------------------===// |
| 177 | |
| 178 | void StmtDumper::DumpLocation(SourceLocation Loc) { |
Chris Lattner | df7c17a | 2009-01-16 07:00:02 +0000 | [diff] [blame] | 179 | SourceLocation SpellingLoc = SM->getSpellingLoc(Loc); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 180 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 181 | // The general format we print out is filename:line:col, but we drop pieces |
| 182 | // that haven't changed since the last loc printed. |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 183 | PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc); |
| 184 | |
Douglas Gregor | cb7b1e1 | 2010-11-12 07:15:47 +0000 | [diff] [blame] | 185 | if (PLoc.isInvalid()) { |
| 186 | OS << "<invalid sloc>"; |
| 187 | return; |
| 188 | } |
| 189 | |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 190 | if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 191 | OS << PLoc.getFilename() << ':' << PLoc.getLine() |
| 192 | << ':' << PLoc.getColumn(); |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 193 | LastLocFilename = PLoc.getFilename(); |
| 194 | LastLocLine = PLoc.getLine(); |
| 195 | } else if (PLoc.getLine() != LastLocLine) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 196 | OS << "line" << ':' << PLoc.getLine() |
| 197 | << ':' << PLoc.getColumn(); |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 198 | LastLocLine = PLoc.getLine(); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 199 | } else { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 200 | OS << "col" << ':' << PLoc.getColumn(); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 201 | } |
| 202 | } |
| 203 | |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 204 | void StmtDumper::DumpSourceRange(const Stmt *Node) { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 205 | // Can't translate locations if a SourceManager isn't available. |
| 206 | if (SM == 0) return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 207 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 208 | // TODO: If the parent expression is available, we can print a delta vs its |
| 209 | // location. |
| 210 | SourceRange R = Node->getSourceRange(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 211 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 212 | OS << " <"; |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 213 | DumpLocation(R.getBegin()); |
| 214 | if (R.getBegin() != R.getEnd()) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 215 | OS << ", "; |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 216 | DumpLocation(R.getEnd()); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 217 | } |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 218 | OS << ">"; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 219 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 220 | // <t2.c:123:421[blah], t2.c:412:321> |
| 221 | |
| 222 | } |
| 223 | |
| 224 | |
| 225 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 226 | // Stmt printing methods. |
| 227 | //===----------------------------------------------------------------------===// |
| 228 | |
| 229 | void StmtDumper::VisitStmt(Stmt *Node) { |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 230 | DumpStmt(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 231 | } |
| 232 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 233 | void StmtDumper::DumpDeclarator(Decl *D) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 234 | // FIXME: Need to complete/beautify this... this code simply shows the |
| 235 | // nodes are where they need to be. |
| 236 | if (TypedefDecl *localType = dyn_cast<TypedefDecl>(D)) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 237 | OS << "\"typedef " << localType->getUnderlyingType().getAsString() |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 238 | << ' ' << localType << '"'; |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 239 | } else if (TypeAliasDecl *localType = dyn_cast<TypeAliasDecl>(D)) { |
| 240 | OS << "\"using " << localType << " = " |
| 241 | << localType->getUnderlyingType().getAsString() << '"'; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 242 | } else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 243 | OS << "\""; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 244 | // Emit storage class for vardecls. |
| 245 | if (VarDecl *V = dyn_cast<VarDecl>(VD)) { |
John McCall | d931b08 | 2010-08-26 03:08:43 +0000 | [diff] [blame] | 246 | if (V->getStorageClass() != SC_None) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 247 | OS << VarDecl::getStorageClassSpecifierString(V->getStorageClass()) |
| 248 | << " "; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 249 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 250 | |
Chris Lattner | 39f34e9 | 2008-11-24 04:00:27 +0000 | [diff] [blame] | 251 | std::string Name = VD->getNameAsString(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 252 | VD->getType().getAsStringInternal(Name, |
Chris Lattner | e4f2142 | 2009-06-30 01:26:17 +0000 | [diff] [blame] | 253 | PrintingPolicy(VD->getASTContext().getLangOptions())); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 254 | OS << Name; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 255 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 256 | // If this is a vardecl with an initializer, emit it. |
| 257 | if (VarDecl *V = dyn_cast<VarDecl>(VD)) { |
| 258 | if (V->getInit()) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 259 | OS << " =\n"; |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 260 | DumpSubTree(V->getInit()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 261 | } |
| 262 | } |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 263 | OS << '"'; |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 264 | } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { |
| 265 | // print a free standing tag decl (e.g. "struct x;"). |
| 266 | const char *tagname; |
| 267 | if (const IdentifierInfo *II = TD->getIdentifier()) |
Daniel Dunbar | e013d68 | 2009-10-18 20:26:12 +0000 | [diff] [blame] | 268 | tagname = II->getNameStart(); |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 269 | else |
| 270 | tagname = "<anonymous>"; |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 271 | OS << '"' << TD->getKindName() << ' ' << tagname << ";\""; |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 272 | // FIXME: print tag bodies. |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 273 | } else if (UsingDirectiveDecl *UD = dyn_cast<UsingDirectiveDecl>(D)) { |
| 274 | // print using-directive decl (e.g. "using namespace x;") |
| 275 | const char *ns; |
| 276 | if (const IdentifierInfo *II = UD->getNominatedNamespace()->getIdentifier()) |
Daniel Dunbar | e013d68 | 2009-10-18 20:26:12 +0000 | [diff] [blame] | 277 | ns = II->getNameStart(); |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 278 | else |
| 279 | ns = "<anonymous>"; |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 280 | OS << '"' << UD->getDeclKindName() << ns << ";\""; |
Sebastian Redl | 0ca4359 | 2010-05-04 10:20:17 +0000 | [diff] [blame] | 281 | } else if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) { |
| 282 | // print using decl (e.g. "using std::string;") |
| 283 | const char *tn = UD->isTypeName() ? "typename " : ""; |
| 284 | OS << '"' << UD->getDeclKindName() << tn; |
Douglas Gregor | dc35571 | 2011-02-25 00:36:19 +0000 | [diff] [blame] | 285 | UD->getQualifier()->print(OS, |
| 286 | PrintingPolicy(UD->getASTContext().getLangOptions())); |
Sebastian Redl | 0ca4359 | 2010-05-04 10:20:17 +0000 | [diff] [blame] | 287 | OS << ";\""; |
Chris Lattner | 4ae493c | 2011-02-18 02:08:43 +0000 | [diff] [blame] | 288 | } else if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) { |
| 289 | OS << "label " << LD->getNameAsString(); |
Peter Collingbourne | 28ac87e | 2011-03-16 18:37:27 +0000 | [diff] [blame] | 290 | } else if (StaticAssertDecl *SAD = dyn_cast<StaticAssertDecl>(D)) { |
| 291 | OS << "\"static_assert(\n"; |
| 292 | DumpSubTree(SAD->getAssertExpr()); |
| 293 | OS << ",\n"; |
| 294 | DumpSubTree(SAD->getMessage()); |
| 295 | OS << ");\""; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 296 | } else { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 297 | llvm_unreachable("Unexpected decl"); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 298 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 299 | } |
| 300 | |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 301 | void StmtDumper::VisitDeclStmt(DeclStmt *Node) { |
| 302 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 303 | OS << "\n"; |
Ted Kremenek | 04a72b7 | 2008-10-06 18:38:35 +0000 | [diff] [blame] | 304 | for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end(); |
| 305 | DI != DE; ++DI) { |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 306 | Decl* D = *DI; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 307 | ++IndentLevel; |
| 308 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 309 | OS << (void*) D << " "; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 310 | DumpDeclarator(D); |
Chris Lattner | f279725 | 2009-03-29 16:04:50 +0000 | [diff] [blame] | 311 | if (DI+1 != DE) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 312 | OS << "\n"; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 313 | --IndentLevel; |
| 314 | } |
| 315 | } |
| 316 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 317 | void StmtDumper::VisitLabelStmt(LabelStmt *Node) { |
| 318 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 319 | OS << " '" << Node->getName() << "'"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 320 | } |
| 321 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 322 | void StmtDumper::VisitGotoStmt(GotoStmt *Node) { |
| 323 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 324 | OS << " '" << Node->getLabel()->getName() |
| 325 | << "':" << (void*)Node->getLabel(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 326 | } |
| 327 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 328 | //===----------------------------------------------------------------------===// |
| 329 | // Expr printing methods. |
| 330 | //===----------------------------------------------------------------------===// |
| 331 | |
| 332 | void StmtDumper::VisitExpr(Expr *Node) { |
| 333 | DumpExpr(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 334 | } |
| 335 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 336 | static void DumpBasePath(raw_ostream &OS, CastExpr *Node) { |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 337 | if (Node->path_empty()) |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 338 | return; |
| 339 | |
| 340 | OS << " ("; |
| 341 | bool First = true; |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 342 | for (CastExpr::path_iterator |
| 343 | I = Node->path_begin(), E = Node->path_end(); I != E; ++I) { |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 344 | const CXXBaseSpecifier *Base = *I; |
| 345 | if (!First) |
| 346 | OS << " -> "; |
| 347 | |
| 348 | const CXXRecordDecl *RD = |
| 349 | cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); |
| 350 | |
| 351 | if (Base->isVirtual()) |
| 352 | OS << "virtual "; |
| 353 | OS << RD->getName(); |
| 354 | First = false; |
| 355 | } |
| 356 | |
| 357 | OS << ')'; |
| 358 | } |
| 359 | |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 360 | void StmtDumper::VisitCastExpr(CastExpr *Node) { |
| 361 | DumpExpr(Node); |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 362 | OS << " <" << Node->getCastKindName(); |
| 363 | DumpBasePath(OS, Node); |
| 364 | OS << ">"; |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 365 | } |
| 366 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 367 | void StmtDumper::VisitDeclRefExpr(DeclRefExpr *Node) { |
| 368 | DumpExpr(Node); |
Ted Kremenek | eb641f9 | 2007-09-10 17:32:55 +0000 | [diff] [blame] | 369 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 370 | OS << " "; |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 371 | DumpDeclRef(Node->getDecl()); |
Chandler Carruth | 3aa8140 | 2011-05-01 23:48:14 +0000 | [diff] [blame] | 372 | if (Node->getDecl() != Node->getFoundDecl()) { |
| 373 | OS << " ("; |
| 374 | DumpDeclRef(Node->getFoundDecl()); |
| 375 | OS << ")"; |
| 376 | } |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | void StmtDumper::DumpDeclRef(Decl *d) { |
| 380 | OS << d->getDeclKindName() << ' ' << (void*) d; |
| 381 | |
| 382 | if (NamedDecl *nd = dyn_cast<NamedDecl>(d)) { |
| 383 | OS << " '"; |
| 384 | nd->getDeclName().printName(OS); |
| 385 | OS << "'"; |
Ted Kremenek | eb641f9 | 2007-09-10 17:32:55 +0000 | [diff] [blame] | 386 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 387 | |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 388 | if (ValueDecl *vd = dyn_cast<ValueDecl>(d)) { |
| 389 | OS << ' '; DumpType(vd->getType()); |
| 390 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 391 | } |
| 392 | |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 393 | void StmtDumper::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) { |
| 394 | DumpExpr(Node); |
| 395 | OS << " ("; |
| 396 | if (!Node->requiresADL()) OS << "no "; |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 397 | OS << "ADL) = '" << Node->getName() << '\''; |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 398 | |
| 399 | UnresolvedLookupExpr::decls_iterator |
| 400 | I = Node->decls_begin(), E = Node->decls_end(); |
| 401 | if (I == E) OS << " empty"; |
| 402 | for (; I != E; ++I) |
| 403 | OS << " " << (void*) *I; |
| 404 | } |
| 405 | |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 406 | void StmtDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) { |
Steve Naroff | 466c2e3 | 2008-05-23 00:59:14 +0000 | [diff] [blame] | 407 | DumpExpr(Node); |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 408 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 409 | OS << " " << Node->getDecl()->getDeclKindName() |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 410 | << "Decl='" << Node->getDecl() |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 411 | << "' " << (void*)Node->getDecl(); |
Steve Naroff | 218543b | 2008-05-23 22:01:24 +0000 | [diff] [blame] | 412 | if (Node->isFreeIvar()) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 413 | OS << " isFreeIvar"; |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 414 | } |
| 415 | |
Chris Lattner | d9f6910 | 2008-08-10 01:53:14 +0000 | [diff] [blame] | 416 | void StmtDumper::VisitPredefinedExpr(PredefinedExpr *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 417 | DumpExpr(Node); |
| 418 | switch (Node->getIdentType()) { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 419 | default: llvm_unreachable("unknown case"); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 420 | case PredefinedExpr::Func: OS << " __func__"; break; |
| 421 | case PredefinedExpr::Function: OS << " __FUNCTION__"; break; |
| 422 | case PredefinedExpr::PrettyFunction: OS << " __PRETTY_FUNCTION__";break; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 423 | } |
| 424 | } |
| 425 | |
| 426 | void StmtDumper::VisitCharacterLiteral(CharacterLiteral *Node) { |
Chris Lattner | a0df31a | 2007-08-09 01:04:32 +0000 | [diff] [blame] | 427 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 428 | OS << Node->getValue(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | void StmtDumper::VisitIntegerLiteral(IntegerLiteral *Node) { |
| 432 | DumpExpr(Node); |
| 433 | |
| 434 | bool isSigned = Node->getType()->isSignedIntegerType(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 435 | OS << " " << Node->getValue().toString(10, isSigned); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 436 | } |
| 437 | void StmtDumper::VisitFloatingLiteral(FloatingLiteral *Node) { |
| 438 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 439 | OS << " " << Node->getValueAsApproximateDouble(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 440 | } |
Chris Lattner | 5d66145 | 2007-08-26 03:42:43 +0000 | [diff] [blame] | 441 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 442 | void StmtDumper::VisitStringLiteral(StringLiteral *Str) { |
Chris Lattner | a0df31a | 2007-08-09 01:04:32 +0000 | [diff] [blame] | 443 | DumpExpr(Str); |
| 444 | // FIXME: this doesn't print wstrings right. |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 445 | OS << " "; |
Douglas Gregor | 5cee119 | 2011-07-27 05:40:30 +0000 | [diff] [blame] | 446 | switch (Str->getKind()) { |
| 447 | case StringLiteral::Ascii: break; // No prefix |
| 448 | case StringLiteral::Wide: OS << 'L'; break; |
| 449 | case StringLiteral::UTF8: OS << "u8"; break; |
| 450 | case StringLiteral::UTF16: OS << 'u'; break; |
| 451 | case StringLiteral::UTF32: OS << 'U'; break; |
| 452 | } |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 453 | OS << '"'; |
Benjamin Kramer | 2f4eaef | 2010-08-17 12:54:38 +0000 | [diff] [blame] | 454 | OS.write_escaped(Str->getString()); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 455 | OS << '"'; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 456 | } |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 457 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 458 | void StmtDumper::VisitUnaryOperator(UnaryOperator *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 459 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 460 | OS << " " << (Node->isPostfix() ? "postfix" : "prefix") |
| 461 | << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 462 | } |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 463 | void StmtDumper::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 464 | DumpExpr(Node); |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 465 | switch(Node->getKind()) { |
| 466 | case UETT_SizeOf: |
| 467 | OS << " sizeof "; |
| 468 | break; |
| 469 | case UETT_AlignOf: |
| 470 | OS << " __alignof "; |
| 471 | break; |
| 472 | case UETT_VecStep: |
| 473 | OS << " vec_step "; |
| 474 | break; |
| 475 | } |
Sebastian Redl | 0518999 | 2008-11-11 17:56:53 +0000 | [diff] [blame] | 476 | if (Node->isArgumentType()) |
| 477 | DumpType(Node->getArgumentType()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 478 | } |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 479 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 480 | void StmtDumper::VisitMemberExpr(MemberExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 481 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 482 | OS << " " << (Node->isArrow() ? "->" : ".") |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 483 | << Node->getMemberDecl() << ' ' |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 484 | << (void*)Node->getMemberDecl(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 485 | } |
Nate Begeman | 213541a | 2008-04-18 23:10:10 +0000 | [diff] [blame] | 486 | void StmtDumper::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 487 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 488 | OS << " " << Node->getAccessor().getNameStart(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 489 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 490 | void StmtDumper::VisitBinaryOperator(BinaryOperator *Node) { |
| 491 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 492 | OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; |
Chris Lattner | eb14fe8 | 2007-08-25 02:00:02 +0000 | [diff] [blame] | 493 | } |
| 494 | void StmtDumper::VisitCompoundAssignOperator(CompoundAssignOperator *Node) { |
| 495 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 496 | OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) |
| 497 | << "' ComputeLHSTy="; |
Eli Friedman | ab3a852 | 2009-03-28 01:22:36 +0000 | [diff] [blame] | 498 | DumpType(Node->getComputationLHSType()); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 499 | OS << " ComputeResultTy="; |
Eli Friedman | ab3a852 | 2009-03-28 01:22:36 +0000 | [diff] [blame] | 500 | DumpType(Node->getComputationResultType()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 501 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 502 | |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 503 | void StmtDumper::VisitBlockExpr(BlockExpr *Node) { |
| 504 | DumpExpr(Node); |
| 505 | |
| 506 | IndentLevel++; |
| 507 | BlockDecl *block = Node->getBlockDecl(); |
| 508 | if (block->capturesCXXThis()) { |
| 509 | OS << '\n'; Indent(); OS << "(capture this)"; |
| 510 | } |
| 511 | for (BlockDecl::capture_iterator |
| 512 | i = block->capture_begin(), e = block->capture_end(); i != e; ++i) { |
| 513 | OS << '\n'; |
| 514 | Indent(); |
| 515 | OS << "(capture "; |
| 516 | if (i->isByRef()) OS << "byref "; |
| 517 | if (i->isNested()) OS << "nested "; |
| 518 | DumpDeclRef(i->getVariable()); |
| 519 | if (i->hasCopyExpr()) DumpSubTree(i->getCopyExpr()); |
| 520 | OS << ")"; |
| 521 | } |
| 522 | IndentLevel--; |
| 523 | |
| 524 | DumpSubTree(block->getBody()); |
| 525 | } |
| 526 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 527 | // GNU extensions. |
| 528 | |
| 529 | void StmtDumper::VisitAddrLabelExpr(AddrLabelExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 530 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 531 | OS << " " << Node->getLabel()->getName() |
| 532 | << " " << (void*)Node->getLabel(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 533 | } |
| 534 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 535 | //===----------------------------------------------------------------------===// |
| 536 | // C++ Expressions |
| 537 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 538 | |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 539 | void StmtDumper::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 540 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 541 | OS << " " << Node->getCastName() |
| 542 | << "<" << Node->getTypeAsWritten().getAsString() << ">" |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 543 | << " <" << Node->getCastKindName(); |
| 544 | DumpBasePath(OS, Node); |
| 545 | OS << ">"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 546 | } |
| 547 | |
| 548 | void StmtDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 549 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 550 | OS << " " << (Node->getValue() ? "true" : "false"); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 551 | } |
| 552 | |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 553 | void StmtDumper::VisitCXXThisExpr(CXXThisExpr *Node) { |
| 554 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 555 | OS << " this"; |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 556 | } |
| 557 | |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 558 | void StmtDumper::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) { |
| 559 | DumpExpr(Node); |
Eli Friedman | cc2fca2 | 2011-09-02 17:38:59 +0000 | [diff] [blame] | 560 | OS << " functional cast to " << Node->getTypeAsWritten().getAsString() |
| 561 | << " <" << Node->getCastKindName() << ">"; |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 562 | } |
| 563 | |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 564 | void StmtDumper::VisitCXXConstructExpr(CXXConstructExpr *Node) { |
| 565 | DumpExpr(Node); |
John McCall | d4bbdfe | 2010-02-02 19:03:45 +0000 | [diff] [blame] | 566 | CXXConstructorDecl *Ctor = Node->getConstructor(); |
| 567 | DumpType(Ctor->getType()); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 568 | if (Node->isElidable()) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 569 | OS << " elidable"; |
John McCall | f8cf0b0 | 2010-08-07 06:38:55 +0000 | [diff] [blame] | 570 | if (Node->requiresZeroInitialization()) |
| 571 | OS << " zeroing"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 572 | } |
| 573 | |
| 574 | void StmtDumper::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) { |
| 575 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 576 | OS << " "; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 577 | DumpCXXTemporary(Node->getTemporary()); |
| 578 | } |
| 579 | |
John McCall | 4765fa0 | 2010-12-06 08:20:24 +0000 | [diff] [blame] | 580 | void StmtDumper::VisitExprWithCleanups(ExprWithCleanups *Node) { |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 581 | DumpExpr(Node); |
| 582 | ++IndentLevel; |
| 583 | for (unsigned i = 0, e = Node->getNumTemporaries(); i != e; ++i) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 584 | OS << "\n"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 585 | Indent(); |
| 586 | DumpCXXTemporary(Node->getTemporary(i)); |
| 587 | } |
| 588 | --IndentLevel; |
| 589 | } |
| 590 | |
| 591 | void StmtDumper::DumpCXXTemporary(CXXTemporary *Temporary) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 592 | OS << "(CXXTemporary " << (void *)Temporary << ")"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 593 | } |
| 594 | |
Anders Carlsson | 5508518 | 2007-08-21 17:43:55 +0000 | [diff] [blame] | 595 | //===----------------------------------------------------------------------===// |
| 596 | // Obj-C Expressions |
| 597 | //===----------------------------------------------------------------------===// |
| 598 | |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 599 | void StmtDumper::VisitObjCMessageExpr(ObjCMessageExpr* Node) { |
| 600 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 601 | OS << " selector=" << Node->getSelector().getAsString(); |
Douglas Gregor | 04badcf | 2010-04-21 00:45:42 +0000 | [diff] [blame] | 602 | switch (Node->getReceiverKind()) { |
| 603 | case ObjCMessageExpr::Instance: |
| 604 | break; |
| 605 | |
| 606 | case ObjCMessageExpr::Class: |
| 607 | OS << " class="; |
| 608 | DumpType(Node->getClassReceiver()); |
| 609 | break; |
| 610 | |
| 611 | case ObjCMessageExpr::SuperInstance: |
| 612 | OS << " super (instance)"; |
| 613 | break; |
| 614 | |
| 615 | case ObjCMessageExpr::SuperClass: |
| 616 | OS << " super (class)"; |
| 617 | break; |
| 618 | } |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 619 | } |
| 620 | |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 621 | void StmtDumper::VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node) { |
| 622 | DumpStmt(Node); |
Douglas Gregor | c00d8e1 | 2010-04-26 16:46:50 +0000 | [diff] [blame] | 623 | if (VarDecl *CatchParam = Node->getCatchParamDecl()) { |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 624 | OS << " catch parm = "; |
| 625 | DumpDeclarator(CatchParam); |
| 626 | } else { |
| 627 | OS << " catch all"; |
| 628 | } |
| 629 | } |
| 630 | |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 631 | void StmtDumper::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) { |
| 632 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 633 | OS << " "; |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 634 | DumpType(Node->getEncodedType()); |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 635 | } |
| 636 | |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 637 | void StmtDumper::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) { |
| 638 | DumpExpr(Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 639 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 640 | OS << " " << Node->getSelector().getAsString(); |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 641 | } |
| 642 | |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 643 | void StmtDumper::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) { |
| 644 | DumpExpr(Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 645 | |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 646 | OS << ' ' << Node->getProtocol(); |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 647 | } |
Daniel Dunbar | 7f8ea5c | 2008-08-30 05:35:15 +0000 | [diff] [blame] | 648 | |
| 649 | void StmtDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) { |
| 650 | DumpExpr(Node); |
John McCall | 12f78a6 | 2010-12-02 01:19:52 +0000 | [diff] [blame] | 651 | if (Node->isImplicitProperty()) { |
Fariborz Jahanian | 99130e5 | 2010-12-22 19:46:35 +0000 | [diff] [blame] | 652 | OS << " Kind=MethodRef Getter=\""; |
| 653 | if (Node->getImplicitPropertyGetter()) |
| 654 | OS << Node->getImplicitPropertyGetter()->getSelector().getAsString(); |
| 655 | else |
| 656 | OS << "(null)"; |
| 657 | |
| 658 | OS << "\" Setter=\""; |
John McCall | 12f78a6 | 2010-12-02 01:19:52 +0000 | [diff] [blame] | 659 | if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter()) |
| 660 | OS << Setter->getSelector().getAsString(); |
| 661 | else |
| 662 | OS << "(null)"; |
| 663 | OS << "\""; |
| 664 | } else { |
| 665 | OS << " Kind=PropertyRef Property=\"" << Node->getExplicitProperty() << '"'; |
| 666 | } |
Fariborz Jahanian | 5daf570 | 2008-11-22 18:39:36 +0000 | [diff] [blame] | 667 | |
Fariborz Jahanian | 8ac2d44 | 2010-10-14 16:04:05 +0000 | [diff] [blame] | 668 | if (Node->isSuperReceiver()) |
| 669 | OS << " super"; |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 670 | } |
| 671 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 672 | //===----------------------------------------------------------------------===// |
| 673 | // Stmt method implementations |
| 674 | //===----------------------------------------------------------------------===// |
| 675 | |
| 676 | /// dump - This does a local dump of the specified AST fragment. It dumps the |
| 677 | /// specified node and a few nodes underneath it, but not the whole subtree. |
| 678 | /// This is useful in a debugger. |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 679 | void Stmt::dump(SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 680 | dump(llvm::errs(), SM); |
| 681 | } |
| 682 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 683 | void Stmt::dump(raw_ostream &OS, SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 684 | StmtDumper P(&SM, OS, 4); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 685 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 686 | OS << "\n"; |
Chris Lattner | 0c727a3 | 2007-08-30 00:40:08 +0000 | [diff] [blame] | 687 | } |
| 688 | |
| 689 | /// dump - This does a local dump of the specified AST fragment. It dumps the |
| 690 | /// specified node and a few nodes underneath it, but not the whole subtree. |
| 691 | /// This is useful in a debugger. |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 692 | void Stmt::dump() const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 693 | StmtDumper P(0, llvm::errs(), 4); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 694 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 695 | llvm::errs() << "\n"; |
Chris Lattner | 0c727a3 | 2007-08-30 00:40:08 +0000 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | /// dumpAll - This does a dump of the specified AST fragment and all subtrees. |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 699 | void Stmt::dumpAll(SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 700 | StmtDumper P(&SM, llvm::errs(), ~0U); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 701 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 702 | llvm::errs() << "\n"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 703 | } |
| 704 | |
| 705 | /// dumpAll - This does a dump of the specified AST fragment and all subtrees. |
| 706 | void Stmt::dumpAll() const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 707 | StmtDumper P(0, llvm::errs(), ~0U); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 708 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 709 | llvm::errs() << "\n"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 710 | } |