maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp

2422 lines
77 KiB
C++
Raw Normal View History

Rename the ASTWriter implementation files llvm-svn: 111465
2010-08-19 07:56:31 +08:00
//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//
//===----------------------------------------------------------------------===//
Expose LambdaIntroducer::DefaultLoc in the AST's LambdaExpr. Summary: Source-centric tools need access to the location of a C++11 lambda expression's capture-default ('&' or '=') when it's present. It's possible for them to find it by re-lexing and re-implementing rules that Clang's parser has already applied, but the cost of storing the SourceLocation and making it available to them is 32 bits per LambdaExpr (a small delta, proportionally), and the simplification in client code is significant. Reviewers: rsmith Reviewed By: rsmith CC: cfe-commits, klimek, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1192 llvm-svn: 188121
2013-08-10 07:08:25 +08:00
///
/// \file
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Implements serialization for Statements and Expressions.
Expose LambdaIntroducer::DefaultLoc in the AST's LambdaExpr. Summary: Source-centric tools need access to the location of a C++11 lambda expression's capture-default ('&' or '=') when it's present. It's possible for them to find it by re-lexing and re-implementing rules that Clang's parser has already applied, but the cost of storing the SourceLocation and making it available to them is 32 bits per LambdaExpr (a small delta, proportionally), and the simplification in client code is significant. Reviewers: rsmith Reviewed By: rsmith CC: cfe-commits, klimek, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1192 llvm-svn: 188121
2013-08-10 07:08:25 +08:00
///
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//===----------------------------------------------------------------------===//
Rename PCHWriter.h to ASTWriter.h llvm-svn: 111466
2010-08-19 07:56:37 +08:00
#include "clang/Serialization/ASTWriter.h"
Drop the ASTContext.h include from DeclFriend.h and DeclTemplate.h. llvm-svn: 159723
2012-07-05 04:19:54 +08:00
#include "clang/AST/ASTContext.h"
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
#include "clang/AST/DeclCXX.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
#include "clang/AST/DeclObjC.h"
Introduce a new expression kind, SubstNonTypeTemplateParmPackExpr, that captures the substitution of a non-type template argument pack for a non-type template parameter pack within a pack expansion that cannot be fully expanded. This follows the approach taken by SubstTemplateTypeParmPackType. llvm-svn: 123506
2011-01-15 09:15:58 +08:00
#include "clang/AST/DeclTemplate.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
#include "clang/AST/StmtVisitor.h"
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
#include "clang/Lex/Token.h"
[Bitcode] Move Bitstream to a separate library This moves Bitcode/Bitstream*, Bitcode/BitCodes.h to Bitstream/. This is needed to avoid a circular dependency when using the bitstream code for parsing optimization remarks. Since Bitcode uses Core for the IR part: libLLVMRemarks -> Bitcode -> Core and Core uses libLLVMRemarks to generate remarks (see IR/RemarkStreamer.cpp): Core -> libLLVMRemarks we need to separate the Bitstream and Bitcode part. For clang-doc, it seems that it doesn't need the whole bitcode layer, so I updated the CMake to only use the bitstream part. Differential Revision: https://reviews.llvm.org/D63899 llvm-svn: 365091
2019-07-04 06:40:07 +08:00
#include "llvm/Bitstream/BitstreamWriter.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
using namespace clang;
//===----------------------------------------------------------------------===//
// Statement/expression serialization
//===----------------------------------------------------------------------===//
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 16:49:18 +08:00
namespace clang {
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
ASTRecordWriter Record;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
serialization::StmtCode Code;
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
unsigned AbbrevToUse;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
public:
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
: Writer(Writer), Record(Writer, Record),
Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {}
ASTStmtWriter(const ASTStmtWriter&) = delete;
Minor simplifications. llvm-svn: 265594
2016-04-07 04:12:34 +08:00
uint64_t Emit() {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
assert(Code != serialization::STMT_NULL_PTR &&
"unhandled sub-statement writing AST file");
return Record.EmitStmt(Code, AbbrevToUse);
}
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
const TemplateArgumentLoc *Args);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
void VisitStmt(Stmt *S);
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
#define STMT(Type, Base) \
void Visit##Type(Type *);
#include "clang/AST/StmtNodes.inc"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
void ASTStmtWriter::AddTemplateKWAndArgsInfo(
const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
Record.AddSourceLocation(ArgInfo.LAngleLoc);
Record.AddSourceLocation(ArgInfo.RAngleLoc);
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTemplateArgumentLoc(Args[i]);
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitStmt(Stmt *S) {
[clang][OpeMP] Model OpenMP structured-block in AST (PR40563) Summary: https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf, page 3: ``` structured block For C/C++, an executable statement, possibly compound, with a single entry at the top and a single exit at the bottom, or an OpenMP construct. COMMENT: See Section 2.1 on page 38 for restrictions on structured blocks. ``` ``` 2.1 Directive Format Some executable directives include a structured block. A structured block: • may contain infinite loops where the point of exit is never reached; • may halt due to an IEEE exception; • may contain calls to exit(), _Exit(), quick_exit(), abort() or functions with a _Noreturn specifier (in C) or a noreturn attribute (in C/C++); • may be an expression statement, iteration statement, selection statement, or try block, provided that the corresponding compound statement obtained by enclosing it in { and } would be a structured block; and Restrictions Restrictions to structured blocks are as follows: • Entry to a structured block must not be the result of a branch. • The point of exit cannot be a branch out of the structured block. C / C++ • The point of entry to a structured block must not be a call to setjmp(). • longjmp() and throw() must not violate the entry/exit criteria. ``` Of particular note here is the fact that OpenMP structured blocks are as-if `noexcept`, in the same sense as with the normal `noexcept` functions in C++. I.e. if throw happens, and it attempts to travel out of the `noexcept` function (here: out of the current structured-block), then the program terminates. Now, one of course can say that since it is explicitly prohibited by the Specification, then any and all programs that violate this Specification contain undefined behavior, and are unspecified, and thus no one should care about them. Just don't write broken code /s But i'm not sure this is a reasonable approach. I have personally had oss-fuzz issues of this origin - exception thrown inside of an OpenMP structured-block that is not caught, thus causing program termination. This issue isn't all that hard to catch, it's not any particularly different from diagnosing the same situation with the normal `noexcept` function. Now, clang static analyzer does not presently model exceptions. But clang-tidy has a simplisic [[ https://clang.llvm.org/extra/clang-tidy/checks/bugprone-exception-escape.html | bugprone-exception-escape ]] check, and it is even refactored as a `ExceptionAnalyzer` class for reuse. So it would be trivial to use that analyzer to check for exceptions escaping out of OpenMP structured blocks. (D59466) All that sounds too great to be true. Indeed, there is a caveat. Presently, it's practically impossible to do. To check a OpenMP structured block you need to somehow 'get' the OpenMP structured block, and you can't because it's simply not modelled in AST. `CapturedStmt`/`CapturedDecl` is not it's representation. Now, it is of course possible to write e.g. some AST matcher that would e.g. match every OpenMP executable directive, and then return the whatever `Stmt` is the structured block of said executable directive, if any. But i said //practically//. This isn't practical for the following reasons: 1. This **will** bitrot. That matcher will need to be kept up-to-date, and refreshed with every new OpenMP spec version. 2. Every single piece of code that would want that knowledge would need to have such matcher. Well, okay, if it is an AST matcher, it could be shared. But then you still have `RecursiveASTVisitor` and friends. `2 > 1`, so now you have code duplication. So it would be reasonable (and is fully within clang AST spirit) to not force every single consumer to do that work, but instead store that knowledge in the correct, and appropriate place - AST, class structure. Now, there is another hoop we need to get through. It isn't fully obvious //how// to model this. The best solution would of course be to simply add a `OMPStructuredBlock` transparent node. It would be optimal, it would give us two properties: * Given this `OMPExecutableDirective`, what's it OpenMP structured block? * It is trivial to check whether the `Stmt*` is a OpenMP structured block (`isa<OMPStructuredBlock>(ptr)`) But OpenMP structured block isn't **necessarily** the first, direct child of `OMP*Directive`. (even ignoring the clang's `CapturedStmt`/`CapturedDecl` that were inserted inbetween). So i'm not sure whether or not we could re-create AST statements after they were already created? There would be other costs to a new AST node: https://bugs.llvm.org/show_bug.cgi?id=40563#c12 ``` 1. You will need to break the representation of loops. The body should be replaced by the "structured block" entity. 2. You will need to support serialization/deserialization. 3. You will need to support template instantiation. 4. You will need to support codegen and take this new construct to account in each OpenMP directive. ``` Instead, there **is** an functionally-equivalent, alternative solution, consisting of two parts. Part 1: * Add a member function `isStandaloneDirective()` to the `OMPExecutableDirective` class, that will tell whether this directive is stand-alone or not, as per the spec. We need it because we can't just check for the existance of associated statements, see code comment. * Add a member function `getStructuredBlock()` to the OMPExecutableDirective` class itself, that assert that this is not a stand-alone directive, and either return the correct loop body if this is a loop-like directive, or the captured statement. This way, given an `OMPExecutableDirective`, we can get it's structured block. Also, since the knowledge is ingrained into the clang OpenMP implementation, it will not cause any duplication, and //hopefully// won't bitrot. Great we achieved 1 of 2 properties of `OMPStructuredBlock` approach. Thus, there is a second part needed: * How can we check whether a given `Stmt*` is `OMPStructuredBlock`? Well, we can't really, in general. I can see this workaround: ``` class FunctionASTVisitor : public RecursiveASTVisitor<FunctionASTVisitor> { using Base = RecursiveASTVisitor<FunctionASTVisitor>; public: bool VisitOMPExecDir(OMPExecDir *D) { OmpStructuredStmts.emplace_back(D.getStructuredStmt()); } bool VisitSOMETHINGELSE(???) { if(InOmpStructuredStmt) HI! } bool TraverseStmt(Stmt *Node) { if (!Node) return Base::TraverseStmt(Node); if (OmpStructuredStmts.back() == Node) ++InOmpStructuredStmt; Base::TraverseStmt(Node); if (OmpStructuredStmts.back() == Node) { OmpStructuredStmts.pop_back(); --InOmpStructuredStmt; } return true; } std::vector<Stmt*> OmpStructuredStmts; int InOmpStructuredStmt = 0; }; ``` But i really don't see using it in practice. It's just too intrusive; and again, requires knowledge duplication. .. but no. The solution lies right on the ground. Why don't we simply store this `i'm a openmp structured block` in the bitfield of the `Stmt` itself? This does not appear to have any impact on the memory footprint of the clang AST, since it's just a single extra bit in the bitfield. At least the static assertions don't fail. Thus, indeed, we can achieve both of the properties without a new AST node. We can cheaply set that bit right in sema, at the end of `Sema::ActOnOpenMPExecutableDirective()`, by just calling the `getStructuredBlock()` that we just added. Test coverage that demonstrates all this has been added. This isn't as great with serialization though. Most of it does not use abbrevs, so we do end up paying the full price (4 bytes?) instead of a single bit. That price, of course, can be reclaimed by using abbrevs. In fact, i suspect that //might// not just reclaim these bytes, but pack these PCH significantly. I'm not seeing a third solution. If there is one, it would be interesting to hear about it. ("just don't write code that would require `isa<OMPStructuredBlock>(ptr)`" is not a solution.) Fixes [[ https://bugs.llvm.org/show_bug.cgi?id=40563 | PR40563 ]]. Reviewers: ABataev, rjmccall, hfinkel, rsmith, riccibruno, gribozavr Reviewed By: ABataev, gribozavr Subscribers: mgorny, aaron.ballman, steveire, guansong, jfb, jdoerfert, cfe-commits Tags: #clang, #openmp Differential Revision: https://reviews.llvm.org/D59214 llvm-svn: 356570
2019-03-21 00:32:36 +08:00
Record.push_back(S->StmtBits.IsOMPStructuredBlock);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getSemiLoc());
[AST] Widen the bit-fields of Stmt to 8 bytes. Although some classes are using the tail padding of Stmt, most of them are not. In particular the expression classes are not using it since there is Expr in between, and Expr contains a single pointer. This patch widen the bit-fields to Stmt to 8 bytes and move some data from NullStmt, CompoundStmt, LabelStmt, AttributedStmt, SwitchStmt, WhileStmt, DoStmt, ForStmt, GotoStmt, ContinueStmt, BreakStmt and ReturnStmt to the newly available space. In itself this patch do not achieve much but I plan to go through each of the classes in the statement/expression hierarchy and use this newly available space. A quick estimation gives me that this should shrink the size of the statement/expression hierarchy by >10% when parsing all of Boost. Differential Revision: https://reviews.llvm.org/D53604 Reviewed By: rjmccall llvm-svn: 345459
2018-10-28 02:43:27 +08:00
Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_NULL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Record.push_back(S->size());
[C++11] Replacing CompoundStmt iterators body_begin() and body_end() with iterator_range body(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 204040
2014-03-17 22:19:37 +08:00
for (auto *CS : S->body())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(CS);
Record.AddSourceLocation(S->getLBracLoc());
Record.AddSourceLocation(S->getRBracLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_COMPOUND;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
Record.push_back(Writer.getSwitchCaseID(S));
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getKeywordLoc());
Record.AddSourceLocation(S->getColonLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitSwitchCase(S);
[AST] Don't store data for GNU range case statement if not needed Don't store the data for case statements of the form LHS ... RHS if not needed. This cuts the size of CaseStmt by 1 pointer + 1 SourceLocation in the common case. Also use the newly available space in the bit-fields of Stmt to store the keyword location of SwitchCase and move the small accessor SwitchCase::getSubStmt to the header. Differential Revision: https://reviews.llvm.org/D53609 Reviewed By: rjmccall llvm-svn: 345472
2018-10-28 20:30:53 +08:00
Record.push_back(S->caseStmtIsGNURange());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getLHS());
Record.AddStmt(S->getSubStmt());
[AST] Don't store data for GNU range case statement if not needed Don't store the data for case statements of the form LHS ... RHS if not needed. This cuts the size of CaseStmt by 1 pointer + 1 SourceLocation in the common case. Also use the newly available space in the bit-fields of Stmt to store the keyword location of SwitchCase and move the small accessor SwitchCase::getSubStmt to the header. Differential Revision: https://reviews.llvm.org/D53609 Reviewed By: rjmccall llvm-svn: 345472
2018-10-28 20:30:53 +08:00
if (S->caseStmtIsGNURange()) {
Record.AddStmt(S->getRHS());
Record.AddSourceLocation(S->getEllipsisLoc());
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_CASE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitSwitchCase(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getSubStmt());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_DEFAULT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(S->getDecl());
Record.AddStmt(S->getSubStmt());
Record.AddSourceLocation(S->getIdentLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_LABEL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Add an AttributedStmt type to represent a statement with C++11 attributes attached. Since we do not support any attributes which appertain to a statement (yet), testing of this is necessarily quite minimal. Patch by Alexander Kornienko! llvm-svn: 154723
2012-04-14 08:33:13 +08:00
void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
VisitStmt(S);
Inline storage of attributes in AttributedStmt. llvm-svn: 159925
2012-07-09 18:04:07 +08:00
Record.push_back(S->getAttrs().size());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddAttributes(S->getAttrs());
Record.AddStmt(S->getSubStmt());
Record.AddSourceLocation(S->getAttrLoc());
Add an AttributedStmt type to represent a statement with C++11 attributes attached. Since we do not support any attributes which appertain to a statement (yet), testing of this is necessarily quite minimal. Patch by Alexander Kornienko! llvm-svn: 154723
2012-04-14 08:33:13 +08:00
Code = serialization::STMT_ATTRIBUTED;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
[AST] Only store the needed data in IfStmt Only store the needed data in IfStmt. This cuts the size of IfStmt by up to 3 pointers + 1 SourceLocation. The order of the children is intentionally kept the same even though it would be more convenient to put the optional trailing objects last. Additionally use the newly available space in the bit-fields of Stmt to store the location of the "if". The result of this is that for the common case of an if statement of the form: if (some_cond) some_statement the size of IfStmt is brought down to 8 bytes + 2 pointers, instead of 8 bytes + 5 pointers + 2 SourceLocation. Differential Revision: https://reviews.llvm.org/D53607 Reviewed By: rjmccall llvm-svn: 345464
2018-10-28 05:12:20 +08:00
bool HasElse = S->getElse() != nullptr;
bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
bool HasInit = S->getInit() != nullptr;
Implement p0292r2 (constexpr if), a likely C++1z feature. llvm-svn: 273602
2016-06-24 03:16:49 +08:00
Record.push_back(S->isConstexpr());
[AST] Only store the needed data in IfStmt Only store the needed data in IfStmt. This cuts the size of IfStmt by up to 3 pointers + 1 SourceLocation. The order of the children is intentionally kept the same even though it would be more convenient to put the optional trailing objects last. Additionally use the newly available space in the bit-fields of Stmt to store the location of the "if". The result of this is that for the common case of an if statement of the form: if (some_cond) some_statement the size of IfStmt is brought down to 8 bytes + 2 pointers, instead of 8 bytes + 5 pointers + 2 SourceLocation. Differential Revision: https://reviews.llvm.org/D53607 Reviewed By: rjmccall llvm-svn: 345464
2018-10-28 05:12:20 +08:00
Record.push_back(HasElse);
Record.push_back(HasVar);
Record.push_back(HasInit);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCond());
Record.AddStmt(S->getThen());
[AST] Only store the needed data in IfStmt Only store the needed data in IfStmt. This cuts the size of IfStmt by up to 3 pointers + 1 SourceLocation. The order of the children is intentionally kept the same even though it would be more convenient to put the optional trailing objects last. Additionally use the newly available space in the bit-fields of Stmt to store the location of the "if". The result of this is that for the common case of an if statement of the form: if (some_cond) some_statement the size of IfStmt is brought down to 8 bytes + 2 pointers, instead of 8 bytes + 5 pointers + 2 SourceLocation. Differential Revision: https://reviews.llvm.org/D53607 Reviewed By: rjmccall llvm-svn: 345464
2018-10-28 05:12:20 +08:00
if (HasElse)
Record.AddStmt(S->getElse());
if (HasVar)
Record.AddDeclRef(S->getConditionVariable());
if (HasInit)
Record.AddStmt(S->getInit());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getIfLoc());
[AST] Only store the needed data in IfStmt Only store the needed data in IfStmt. This cuts the size of IfStmt by up to 3 pointers + 1 SourceLocation. The order of the children is intentionally kept the same even though it would be more convenient to put the optional trailing objects last. Additionally use the newly available space in the bit-fields of Stmt to store the location of the "if". The result of this is that for the common case of an if statement of the form: if (some_cond) some_statement the size of IfStmt is brought down to 8 bytes + 2 pointers, instead of 8 bytes + 5 pointers + 2 SourceLocation. Differential Revision: https://reviews.llvm.org/D53607 Reviewed By: rjmccall llvm-svn: 345464
2018-10-28 05:12:20 +08:00
if (HasElse)
Record.AddSourceLocation(S->getElseLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_IF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
[AST] Only store the needed data in SwitchStmt Don't store the data for the init statement and condition variable if not needed. This cuts the size of SwitchStmt by up to 2 pointers. The order of the children is intentionally kept the same. Also use the newly available space in the bit-fields of Stmt to store the bit representing whether all enums have been covered instead of using a PointerIntPair. Differential Revision: https://reviews.llvm.org/D53714 Reviewed By: rjmccall llvm-svn: 345510
2018-10-30 00:12:37 +08:00
bool HasInit = S->getInit() != nullptr;
bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
Record.push_back(HasInit);
Record.push_back(HasVar);
Record.push_back(S->isAllEnumCasesCovered());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCond());
Record.AddStmt(S->getBody());
[AST] Only store the needed data in SwitchStmt Don't store the data for the init statement and condition variable if not needed. This cuts the size of SwitchStmt by up to 2 pointers. The order of the children is intentionally kept the same. Also use the newly available space in the bit-fields of Stmt to store the bit representing whether all enums have been covered instead of using a PointerIntPair. Differential Revision: https://reviews.llvm.org/D53714 Reviewed By: rjmccall llvm-svn: 345510
2018-10-30 00:12:37 +08:00
if (HasInit)
Record.AddStmt(S->getInit());
if (HasVar)
Record.AddDeclRef(S->getConditionVariable());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getSwitchLoc());
[AST] Only store the needed data in SwitchStmt Don't store the data for the init statement and condition variable if not needed. This cuts the size of SwitchStmt by up to 2 pointers. The order of the children is intentionally kept the same. Also use the newly available space in the bit-fields of Stmt to store the bit representing whether all enums have been covered instead of using a PointerIntPair. Differential Revision: https://reviews.llvm.org/D53714 Reviewed By: rjmccall llvm-svn: 345510
2018-10-30 00:12:37 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (SwitchCase *SC = S->getSwitchCaseList(); SC;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
SC = SC->getNextSwitchCase())
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
Record.push_back(Writer.RecordSwitchCaseID(SC));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_SWITCH;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
[AST] Only store the needed data in WhileStmt Don't store the data for the condition variable if not needed. This cuts the size of WhileStmt by up to a pointer. The order of the children is kept the same. Differential Revision: https://reviews.llvm.org/D53715 Reviewed By: rjmccall llvm-svn: 345597
2018-10-30 21:42:41 +08:00
bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
Record.push_back(HasVar);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCond());
Record.AddStmt(S->getBody());
[AST] Only store the needed data in WhileStmt Don't store the data for the condition variable if not needed. This cuts the size of WhileStmt by up to a pointer. The order of the children is kept the same. Differential Revision: https://reviews.llvm.org/D53715 Reviewed By: rjmccall llvm-svn: 345597
2018-10-30 21:42:41 +08:00
if (HasVar)
Record.AddDeclRef(S->getConditionVariable());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getWhileLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_WHILE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCond());
Record.AddStmt(S->getBody());
Record.AddSourceLocation(S->getDoLoc());
Record.AddSourceLocation(S->getWhileLoc());
Record.AddSourceLocation(S->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_DO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitForStmt(ForStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getInit());
Record.AddStmt(S->getCond());
Record.AddDeclRef(S->getConditionVariable());
Record.AddStmt(S->getInc());
Record.AddStmt(S->getBody());
Record.AddSourceLocation(S->getForLoc());
Record.AddSourceLocation(S->getLParenLoc());
Record.AddSourceLocation(S->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_FOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(S->getLabel());
Record.AddSourceLocation(S->getGotoLoc());
Record.AddSourceLocation(S->getLabelLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_GOTO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getGotoLoc());
Record.AddSourceLocation(S->getStarLoc());
Record.AddStmt(S->getTarget());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_INDIRECT_GOTO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getContinueLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_CONTINUE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getBreakLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_BREAK;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
[AST] Only store data for the NRVO candidate in ReturnStmt if needed Only store the NRVO candidate if needed in ReturnStmt. A good chuck of all of the ReturnStmt have no NRVO candidate (more than half when parsing all of Boost). For all of them this saves one pointer. This has no impact on children(). Differential Revision: https://reviews.llvm.org/D53716 Reviewed By: rsmith llvm-svn: 345605
2018-10-30 22:40:49 +08:00
bool HasNRVOCandidate = S->getNRVOCandidate() != nullptr;
Record.push_back(HasNRVOCandidate);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getRetValue());
[AST] Only store data for the NRVO candidate in ReturnStmt if needed Only store the NRVO candidate if needed in ReturnStmt. A good chuck of all of the ReturnStmt have no NRVO candidate (more than half when parsing all of Boost). For all of them this saves one pointer. This has no impact on children(). Differential Revision: https://reviews.llvm.org/D53716 Reviewed By: rsmith llvm-svn: 345605
2018-10-30 22:40:49 +08:00
if (HasNRVOCandidate)
Record.AddDeclRef(S->getNRVOCandidate());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getReturnLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_RETURN;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Port getStartLoc -> getBeginLoc Reviewers: teemperor! Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50349 llvm-svn: 339384
2018-08-10 05:05:56 +08:00
Record.AddSourceLocation(S->getBeginLoc());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getEndLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
DeclGroupRef DG = S->getDeclGroup();
for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(*D);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_DECL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Record.push_back(S->getNumOutputs());
Record.push_back(S->getNumInputs());
Record.push_back(S->getNumClobbers());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getAsmLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(S->isVolatile());
Record.push_back(S->isSimple());
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
}
void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
VisitAsmStmt(S);
Re-check in clang support gun asm goto after fixing tests. llvm-svn: 362410
2019-06-03 23:57:25 +08:00
Record.push_back(S->getNumLabels());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getRParenLoc());
Record.AddStmt(S->getAsmString());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
// Outputs
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddIdentifierRef(S->getOutputIdentifier(I));
Record.AddStmt(S->getOutputConstraintLiteral(I));
Record.AddStmt(S->getOutputExpr(I));
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
// Inputs
for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddIdentifierRef(S->getInputIdentifier(I));
Record.AddStmt(S->getInputConstraintLiteral(I));
Record.AddStmt(S->getInputExpr(I));
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
// Clobbers
for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getClobberStringLiteral(I));
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Re-check in clang support gun asm goto after fixing tests. llvm-svn: 362410
2019-06-03 23:57:25 +08:00
// Labels
for (auto *E : S->labels()) Record.AddStmt(E);
[ms-inline asm] As part of a larger refactoring, rename AsmStmt to GCCAsmStmt. No functional change intended. llvm-svn: 162632
2012-08-25 08:11:56 +08:00
Code = serialization::STMT_GCCASM;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Etch out the code path for MS-style inline assembly. llvm-svn: 158325
2012-06-12 04:47:18 +08:00
void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
VisitAsmStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getLBraceLoc());
Record.AddSourceLocation(S->getEndLoc());
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
Record.push_back(S->getNumAsmToks());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddString(S->getAsmString());
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
// Tokens
for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
// FIXME: Move this to ASTRecordWriter?
Writer.AddToken(S->getAsmToks()[I], Record.getRecordData());
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
}
// Clobbers
for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddString(S->getClobber(I));
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
}
// Outputs
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getOutputExpr(I));
Record.AddString(S->getOutputConstraint(I));
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
}
// Inputs
for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getInputExpr(I));
Record.AddString(S->getInputConstraint(I));
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
}
[ms-inline asm] Update the AST Reader/Writer for MS-style inline asms. llvm-svn: 162629
2012-08-25 07:51:02 +08:00
Code = serialization::STMT_MSASM;
Etch out the code path for MS-style inline assembly. llvm-svn: 158325
2012-06-12 04:47:18 +08:00
}
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) {
VisitStmt(CoroStmt);
Record.push_back(CoroStmt->getParamMoves().size());
for (Stmt *S : CoroStmt->children())
Record.AddStmt(S);
Code = serialization::STMT_COROUTINE_BODY;
[coroutines] Creation of promise object, lookup of operator co_await, building of await_* calls, and AST representation for same. llvm-svn: 251387
2015-10-27 14:02:45 +08:00
}
void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
VisitStmt(S);
Record.AddSourceLocation(S->getKeywordLoc());
Record.AddStmt(S->getOperand());
Record.AddStmt(S->getPromiseCall());
Record.push_back(S->isImplicit());
Code = serialization::STMT_CORETURN;
}
void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
VisitExpr(E);
Record.AddSourceLocation(E->getKeywordLoc());
for (Stmt *S : E->children())
Record.AddStmt(S);
Record.AddStmt(E->getOpaqueValue());
[coroutines] Creation of promise object, lookup of operator co_await, building of await_* calls, and AST representation for same. llvm-svn: 251387
2015-10-27 14:02:45 +08:00
}
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {
VisitCoroutineSuspendExpr(E);
Record.push_back(E->isImplicit());
Code = serialization::EXPR_COAWAIT;
[coroutines] Creation of promise object, lookup of operator co_await, building of await_* calls, and AST representation for same. llvm-svn: 251387
2015-10-27 14:02:45 +08:00
}
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {
VisitCoroutineSuspendExpr(E);
Code = serialization::EXPR_COYIELD;
[coroutines] Add DependentCoawaitExpr and fix re-building CoroutineBodyStmt. Summary: The changes contained in this patch are: 1. Defines a new AST node `CoawaitDependentExpr` for representing co_await expressions while the promise type is still dependent. 2. Correctly detect and transform the 'co_await' operand to `p.await_transform(<expr>)` when possible. 3. Change the initial/final suspend points to build during the initial parse, so they have the correct operator co_await lookup results. 4. Fix transformation of the CoroutineBodyStmt so that it doesn't re-build the final/initial suspends. @rsmith: This change is a little big, but it's not trivial for me to split it up. Please let me know if you would prefer this submitted as multiple patches. Reviewers: rsmith, GorNishanov Reviewed By: rsmith Subscribers: ABataev, rsmith, mehdi_amini, cfe-commits Differential Revision: https://reviews.llvm.org/D26057 llvm-svn: 297093
2017-03-07 07:38:15 +08:00
}
[coroutines] Add serialization/deserialization of coroutines Reviewers: rsmith Reviewed By: rsmith Subscribers: EricWF, cfe-commits Differential Revision: https://reviews.llvm.org/D35383 llvm-svn: 308996
2017-07-26 02:01:49 +08:00
void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
VisitExpr(E);
Record.AddSourceLocation(E->getKeywordLoc());
for (Stmt *S : E->children())
Record.AddStmt(S);
Code = serialization::EXPR_DEPENDENT_COAWAIT;
[coroutines] Creation of promise object, lookup of operator co_await, building of await_* calls, and AST representation for same. llvm-svn: 251387
2015-10-27 14:02:45 +08:00
}
Implement CapturedStmt AST CapturedStmt can be used to implement generic function outlining as described in http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. CapturedStmt is not exposed to the C api. Serialization and template support are pending. Author: Wei Pan <wei.pan@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D370 llvm-svn: 179615
2013-04-17 02:53:08 +08:00
void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
VisitStmt(S);
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
// NumCaptures
Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
Implement template support for CapturedStmt - Sema tests added and CodeGen tests are pending Differential Revision: http://llvm-reviews.chandlerc.com/D728 llvm-svn: 181101
2013-05-04 11:59:06 +08:00
// CapturedDecl and captured region kind
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(S->getCapturedDecl());
Implement template support for CapturedStmt - Sema tests added and CodeGen tests are pending Differential Revision: http://llvm-reviews.chandlerc.com/D728 llvm-svn: 181101
2013-05-04 11:59:06 +08:00
Record.push_back(S->getCapturedRegionKind());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(S->getCapturedRecordDecl());
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
// Capture inits
[C++11] Replacing CapturedStmt iterators capture_init_begin() and capture_init_end() with iterator_range capture_inits(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203959
2014-03-15 03:41:04 +08:00
for (auto *I : S->capture_inits())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
// Body
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCapturedStmt());
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
// Captures
[C++11] Replacing CapturedStmt iterators capture_begin() and capture_end() with iterator_range captures(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203953
2014-03-15 02:08:33 +08:00
for (const auto &I : S->captures()) {
Improved capturing variable-length array types in CapturedStmt. An updated implemnentation of VLA types capturing based on previously committed solution for Lambdas. This version captures the whole VLA type instead of particular variables which are part of VLA size expression and allows to use previusly calculated size of VLA type in captured regions. Required for OpenMP. Differential Revision: http://reviews.llvm.org/D5099 llvm-svn: 220850
2014-10-29 20:21:55 +08:00
if (I.capturesThis() || I.capturesVariableArrayType())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(nullptr);
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
else
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(I.getCapturedVar());
[C++11] Replacing CapturedStmt iterators capture_begin() and capture_end() with iterator_range captures(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203953
2014-03-15 02:08:33 +08:00
Record.push_back(I.getCaptureKind());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(I.getLocation());
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
}
Implement CapturedStmt AST CapturedStmt can be used to implement generic function outlining as described in http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. CapturedStmt is not exposed to the C api. Serialization and template support are pending. Author: Wei Pan <wei.pan@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D370 llvm-svn: 179615
2013-04-17 02:53:08 +08:00
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
Code = serialization::STMT_CAPTURED;
Implement CapturedStmt AST CapturedStmt can be used to implement generic function outlining as described in http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. CapturedStmt is not exposed to the C api. Serialization and template support are pending. Author: Wei Pan <wei.pan@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D370 llvm-svn: 179615
2013-04-17 02:53:08 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitExpr(Expr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeRef(E->getType());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->isTypeDependent());
Record.push_back(E->isValueDependent());
Introduce the notion of instantiation dependence into Clang's AST. A type/expression/template argument/etc. is instantiation-dependent if it somehow involves a template parameter, even if it doesn't meet the requirements for the more common kinds of dependence (dependent type, type-dependent expression, value-dependent expression). When we see an instantiation-dependent type, we know we always need to perform substitution into that instantiation-dependent type. This keeps us from short-circuiting evaluation in places where we shouldn't, and lets us properly implement C++0x [temp.type]p2. In theory, this would also allow us to properly mangle instantiation-dependent-but-not-dependent decltype types per the Itanium C++ ABI, but we aren't quite there because we still mangle based on the canonical type in cases like, e.g., template<unsigned> struct A { }; template<typename T> void f(A<sizeof(sizeof(decltype(T() + T())))>) { } template void f<int>(A<sizeof(sizeof(int))>); and therefore get the wrong answer. llvm-svn: 134225
2011-07-01 09:22:09 +08:00
Record.push_back(E->isInstantiationDependent());
Variadic templates: extend Type, NestedNameSpecifier, TemplateName, and TemplateArgument with an operation that determines whether there are any unexpanded parameter packs within that construct. Use this information to diagnose the appearance of the names of parameter packs that have not been expanded (C++ [temp.variadic]p5). Since this property is checked often (every declaration, ever expression statement, etc.), we extend Type and Expr with a bit storing the result of this computation, rather than walking the AST each time to determine whether any unexpanded parameter packs occur. This commit is deficient in several ways, which will be remedied with future commits: - Expr has a bit to store the presence of an unexpanded parameter pack, but it is never set. - The error messages don't point out where the unexpanded parameter packs were named in the type/expression, but they should. - We don't check for unexpanded parameter packs in all of the places where we should. - Testing is sparse, pending the resolution of the above three issues. llvm-svn: 121724
2010-12-14 06:49:22 +08:00
Record.push_back(E->containsUnexpandedParameterPack());
Calculate the value kind of an expression when it's created and store it on the expression node. Also store an "object kind", which distinguishes ordinary "addressed" l-values (like variable references and pointer dereferences) and bitfield, @property, and vector-component l-values. Currently we're not using these for much, but I aim to switch pretty much everything calculating l-valueness over to them. For now they shouldn't necessarily be trusted. llvm-svn: 119685
2010-11-18 14:31:45 +08:00
Record.push_back(E->getValueKind());
Record.push_back(E->getObjectKind());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Create ConstantExpr class A ConstantExpr class represents a full expression that's in a context where a constant expression is required. This class reflects the path the evaluator took to reach the expression rather than the syntactic context in which the expression occurs. In the future, the class will be expanded to cache the result of the evaluated expression so that it's not needlessly re-evaluated Reviewed By: rsmith Differential Revision: https://reviews.llvm.org/D53475 llvm-svn: 345692
2018-10-31 11:48:47 +08:00
void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
VisitExpr(E);
[clang] Add storage for APValue in ConstantExpr Summary: When using ConstantExpr we often need the result of the expression to be kept in the AST. Currently this is done on a by the node that needs the result and has been done multiple times for enumerator, for constexpr variables... . This patch adds to ConstantExpr the ability to store the result of evaluating the expression. no functional changes expected. Changes: - Add trailling object to ConstantExpr that can hold an APValue or an uint64_t. the uint64_t is here because most ConstantExpr yield integral values so there is an optimized layout for integral values. - Add basic* serialization support for the trailing result. - Move conversion functions from an enum to a fltSemantics from clang::FloatingLiteral to llvm::APFloatBase. this change is to make it usable for serializing APValues. - Add basic* Import support for the trailing result. - ConstantExpr created in CheckConvertedConstantExpression now stores the result in the ConstantExpr Node. - Adapt AST dump to print the result when present. basic* : None, Indeterminate, Int, Float, FixedPoint, ComplexInt, ComplexFloat, the result is not yet used anywhere but for -ast-dump. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: rnkovacs, hiraditya, dexonsmith, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D62399 llvm-svn: 363493
2019-06-15 18:24:47 +08:00
Record.push_back(static_cast<uint64_t>(E->ConstantExprBits.ResultKind));
switch (E->ConstantExprBits.ResultKind) {
case ConstantExpr::RSK_Int64:
Record.push_back(E->Int64Result());
Record.push_back(E->ConstantExprBits.IsUnsigned |
E->ConstantExprBits.BitWidth << 1);
break;
case ConstantExpr::RSK_APValue:
Record.AddAPValue(E->APValueResult());
}
Create ConstantExpr class A ConstantExpr class represents a full expression that's in a context where a constant expression is required. This class reflects the path the evaluator took to reach the expression rather than the syntactic context in which the expression occurs. In the future, the class will be expanded to cache the result of the evaluated expression so that it's not needlessly re-evaluated Reviewed By: rsmith Differential Revision: https://reviews.llvm.org/D53475 llvm-svn: 345692
2018-10-31 11:48:47 +08:00
Record.AddStmt(E->getSubExpr());
Code = serialization::EXPR_CONSTANT;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
[AST] Refactor PredefinedExpr Make the following changes to PredefinedExpr: 1. Move PredefinedExpr below StringLiteral so that it can use its definition. 2. Rename IdentType to IdentKind to be more in line with clang's conventions, and propagate the change to its users. 3. Move the location and the IdentKind into the newly available space of the bit-fields of Stmt. 4. Only store the function name when needed. When parsing all of Boost, of the 1357 PredefinedExpr 919 have no function name. Differential Revision: https://reviews.llvm.org/D53605 Reviewed By: rjmccall llvm-svn: 345460
2018-10-28 03:21:19 +08:00
bool HasFunctionName = E->getFunctionName() != nullptr;
Record.push_back(HasFunctionName);
Record.push_back(E->getIdentKind()); // FIXME: stable encoding
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
[AST] Refactor PredefinedExpr Make the following changes to PredefinedExpr: 1. Move PredefinedExpr below StringLiteral so that it can use its definition. 2. Rename IdentType to IdentKind to be more in line with clang's conventions, and propagate the change to its users. 3. Move the location and the IdentKind into the newly available space of the bit-fields of Stmt. 4. Only store the function name when needed. When parsing all of Boost, of the 1357 PredefinedExpr 919 have no function name. Differential Revision: https://reviews.llvm.org/D53605 Reviewed By: rjmccall llvm-svn: 345460
2018-10-28 03:21:19 +08:00
if (HasFunctionName)
Record.AddStmt(E->getFunctionName());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_PREDEFINED;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 21:09:47 +08:00
Record.push_back(E->hasQualifier());
Add an optional field attached to a DeclRefExpr which points back to the Decl actually found via name lookup & overload resolution when that Decl is different from the ValueDecl which is actually referenced by the expression. This can be used by AST consumers to correctly attribute references to the spelling location of a using declaration, and otherwise gain insight into the name resolution performed by Clang. The public interface to DRE is kept as narrow as possible: we provide a getFoundDecl() which always returns a NamedDecl, either the ValueDecl referenced or the new, more precise NamedDecl if present. This way AST clients can code against getFoundDecl without know when exactly the AST has a split representation. For an example of the data this provides consider: % cat x.cc namespace N1 { struct S {}; void f(const S&); } void test(N1::S s) { f(s); using N1::f; f(s); } % ./bin/clang -fsyntax-only -Xclang -ast-dump x.cc [...] void test(N1::S s) (CompoundStmt 0x5b02010 <x.cc:5:20, line:9:1> (CallExpr 0x5b01df0 <line:6:3, col:6> 'void' (ImplicitCastExpr 0x5b01dd8 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01d80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)')) (ImplicitCastExpr 0x5b01e20 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01d58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S'))) (DeclStmt 0x5b01ee0 <line:7:3, col:14> 0x5b01e40 "UsingN1::;") (CallExpr 0x5b01fc8 <line:8:3, col:6> 'void' (ImplicitCastExpr 0x5b01fb0 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01f80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)' (UsingShadow 0x5b01ea0 'f'))) (ImplicitCastExpr 0x5b01ff8 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01f58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S')))) Now we can tell that the second call is 'using' (no pun intended) the using declaration, and *which* using declaration it sees. Without this, we can mistake calls that go through using declarations for ADL calls, and have no way to attribute names looked up with using declarations to the appropriate UsingDecl. llvm-svn: 130670
2011-05-02 07:48:14 +08:00
Record.push_back(E->getDecl() != E->getFoundDecl());
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
Record.push_back(E->hasTemplateKWAndArgsInfo());
Added a flag to identify resolved overloaded function references. llvm-svn: 141171
2011-10-05 15:56:41 +08:00
Record.push_back(E->hadMultipleCandidates());
Rename RefersToCapturedVariable to RefersToEnclosingVariableOrCapture, NFC llvm-svn: 225624
2015-01-12 18:17:46 +08:00
Record.push_back(E->refersToEnclosingVariableOrCapture());
For DR712: store on a DeclRefExpr whether it constitutes an odr-use. Begin restructuring to support the forms of non-odr-use reference permitted by DR712. llvm-svn: 363086
2019-06-12 01:50:32 +08:00
Record.push_back(E->isNonOdrUse());
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 21:09:47 +08:00
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
if (E->hasTemplateKWAndArgsInfo()) {
Implement proper (de-)serialization for explicit template argument lists with zero template arguments. Fixes some seriously scary crashers in C++ PCH. llvm-svn: 124862
2011-02-04 20:01:24 +08:00
unsigned NumTemplateArgs = E->getNumTemplateArgs();
Record.push_back(NumTemplateArgs);
}
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 21:09:47 +08:00
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
(E->getDecl() == E->getFoundDecl()) &&
For DR712: store on a DeclRefExpr whether it constitutes an odr-use. Begin restructuring to support the forms of non-odr-use reference permitted by DR712. llvm-svn: 363086
2019-06-12 01:50:32 +08:00
nk == DeclarationName::Identifier &&
!E->refersToEnclosingVariableOrCapture() && !E->isNonOdrUse()) {
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
AbbrevToUse = Writer.getDeclRefExprAbbrev();
}
When serializing a DeclRefExpr, always store the number of explicit template arguments at the same offset, since it's needed when creating the empty DeclRefExpr when deserializing. Fixes a memory corruption issue that would lead to random bugs and crashes. llvm-svn: 127125
2011-03-07 02:19:42 +08:00
if (E->hasQualifier())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
When serializing a DeclRefExpr, always store the number of explicit template arguments at the same offset, since it's needed when creating the empty DeclRefExpr when deserializing. Fixes a memory corruption issue that would lead to random bugs and crashes. llvm-svn: 127125
2011-03-07 02:19:42 +08:00
Add an optional field attached to a DeclRefExpr which points back to the Decl actually found via name lookup & overload resolution when that Decl is different from the ValueDecl which is actually referenced by the expression. This can be used by AST consumers to correctly attribute references to the spelling location of a using declaration, and otherwise gain insight into the name resolution performed by Clang. The public interface to DRE is kept as narrow as possible: we provide a getFoundDecl() which always returns a NamedDecl, either the ValueDecl referenced or the new, more precise NamedDecl if present. This way AST clients can code against getFoundDecl without know when exactly the AST has a split representation. For an example of the data this provides consider: % cat x.cc namespace N1 { struct S {}; void f(const S&); } void test(N1::S s) { f(s); using N1::f; f(s); } % ./bin/clang -fsyntax-only -Xclang -ast-dump x.cc [...] void test(N1::S s) (CompoundStmt 0x5b02010 <x.cc:5:20, line:9:1> (CallExpr 0x5b01df0 <line:6:3, col:6> 'void' (ImplicitCastExpr 0x5b01dd8 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01d80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)')) (ImplicitCastExpr 0x5b01e20 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01d58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S'))) (DeclStmt 0x5b01ee0 <line:7:3, col:14> 0x5b01e40 "UsingN1::;") (CallExpr 0x5b01fc8 <line:8:3, col:6> 'void' (ImplicitCastExpr 0x5b01fb0 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01f80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)' (UsingShadow 0x5b01ea0 'f'))) (ImplicitCastExpr 0x5b01ff8 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01f58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S')))) Now we can tell that the second call is 'using' (no pun intended) the using declaration, and *which* using declaration it sees. Without this, we can mistake calls that go through using declarations for ADL calls, and have no way to attribute names looked up with using declarations to the appropriate UsingDecl. llvm-svn: 130670
2011-05-02 07:48:14 +08:00
if (E->getDecl() != E->getFoundDecl())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getFoundDecl());
Add an optional field attached to a DeclRefExpr which points back to the Decl actually found via name lookup & overload resolution when that Decl is different from the ValueDecl which is actually referenced by the expression. This can be used by AST consumers to correctly attribute references to the spelling location of a using declaration, and otherwise gain insight into the name resolution performed by Clang. The public interface to DRE is kept as narrow as possible: we provide a getFoundDecl() which always returns a NamedDecl, either the ValueDecl referenced or the new, more precise NamedDecl if present. This way AST clients can code against getFoundDecl without know when exactly the AST has a split representation. For an example of the data this provides consider: % cat x.cc namespace N1 { struct S {}; void f(const S&); } void test(N1::S s) { f(s); using N1::f; f(s); } % ./bin/clang -fsyntax-only -Xclang -ast-dump x.cc [...] void test(N1::S s) (CompoundStmt 0x5b02010 <x.cc:5:20, line:9:1> (CallExpr 0x5b01df0 <line:6:3, col:6> 'void' (ImplicitCastExpr 0x5b01dd8 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01d80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)')) (ImplicitCastExpr 0x5b01e20 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01d58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S'))) (DeclStmt 0x5b01ee0 <line:7:3, col:14> 0x5b01e40 "UsingN1::;") (CallExpr 0x5b01fc8 <line:8:3, col:6> 'void' (ImplicitCastExpr 0x5b01fb0 <col:3> 'void (*)(const struct N1::S &)' <FunctionToPointerDecay> (DeclRefExpr 0x5b01f80 <col:3> 'void (const struct N1::S &)' lvalue Function 0x5b01a20 'f' 'void (const struct N1::S &)' (UsingShadow 0x5b01ea0 'f'))) (ImplicitCastExpr 0x5b01ff8 <col:5> 'const struct N1::S' lvalue <NoOp> (DeclRefExpr 0x5b01f58 <col:5> 'N1::S':'struct N1::S' lvalue ParmVar 0x5b01b60 's' 'N1::S':'struct N1::S')))) Now we can tell that the second call is 'using' (no pun intended) the using declaration, and *which* using declaration it sees. Without this, we can mistake calls that go through using declarations for ADL calls, and have no way to attribute names looked up with using declarations to the appropriate UsingDecl. llvm-svn: 130670
2011-05-02 07:48:14 +08:00
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
if (E->hasTemplateKWAndArgsInfo())
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
E->getTrailingObjects<TemplateArgumentLoc>());
When serializing a DeclRefExpr, always store the number of explicit template arguments at the same offset, since it's needed when creating the empty DeclRefExpr when deserializing. Fixes a memory corruption issue that would lead to random bugs and crashes. llvm-svn: 127125
2011-03-07 02:19:42 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getDecl());
Record.AddSourceLocation(E->getLocation());
Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_DECL_REF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Record.AddAPInt(E->getValue());
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
if (E->getValue().getBitWidth() == 32) {
AbbrevToUse = Writer.getIntegerLiteralAbbrev();
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_INTEGER_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
[Fixed Point Arithmetic] Fixed Point Precision Bits and Fixed Point Literals This diff includes the logic for setting the precision bits for each primary fixed point type in the target info and logic for initializing a fixed point literal. Fixed point literals are declared using the suffixes ``` hr: short _Fract uhr: unsigned short _Fract r: _Fract ur: unsigned _Fract lr: long _Fract ulr: unsigned long _Fract hk: short _Accum uhk: unsigned short _Accum k: _Accum uk: unsigned _Accum ``` Errors are also thrown for illegal literal values ``` unsigned short _Accum u_short_accum = 256.0uhk; // expected-error{{the integral part of this literal is too large for this unsigned _Accum type}} ``` Differential Revision: https://reviews.llvm.org/D46915 llvm-svn: 335148
2018-06-21 01:19:40 +08:00
void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
VisitExpr(E);
Record.AddSourceLocation(E->getLocation());
Record.AddAPInt(E->getValue());
Code = serialization::EXPR_INTEGER_LITERAL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Switch to APFloat constructor taking fltSemantics. This change also makes the serialisation store the required semantics, fixing an issue where PPC128 was always assumed when re-reading a 128-bit value. llvm-svn: 173139
2013-01-22 17:46:51 +08:00
Record.push_back(E->getRawSemantics());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->isExact());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddAPFloat(E->getValue());
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_FLOATING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_IMAGINARY_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
[AST] Store the string data in StringLiteral in a trailing array of chars Use the newly available space in the bit-fields of Stmt and store the string data in a trailing array of chars after the trailing array of SourceLocation. This cuts the size of StringLiteral by 2 pointers. Also refactor slightly StringLiteral::Create and StringLiteral::CreateEmpty so that StringLiteral::Create is just responsible for the allocation, and the constructor is responsible for doing all the initialization. This match what is done for the other classes in general. This patch should have no other functional changes apart from this. A concern was raised during review about the interaction between this patch and serialization abbreviations. I believe however that there is currently no abbreviation defined for StringLiteral. The only statements/expressions which have abbreviations are currently DeclRefExpr, IntegerLiteral, CharacterLiteral and ImplicitCastExpr. Differential Revision: https://reviews.llvm.org/D54166 Reviewed By: dblaikie, rjmccall llvm-svn: 346969
2018-11-16 01:31:16 +08:00
// Store the various bits of data of StringLiteral.
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->getNumConcatenated());
[AST] Store the string data in StringLiteral in a trailing array of chars Use the newly available space in the bit-fields of Stmt and store the string data in a trailing array of chars after the trailing array of SourceLocation. This cuts the size of StringLiteral by 2 pointers. Also refactor slightly StringLiteral::Create and StringLiteral::CreateEmpty so that StringLiteral::Create is just responsible for the allocation, and the constructor is responsible for doing all the initialization. This match what is done for the other classes in general. This patch should have no other functional changes apart from this. A concern was raised during review about the interaction between this patch and serialization abbreviations. I believe however that there is currently no abbreviation defined for StringLiteral. The only statements/expressions which have abbreviations are currently DeclRefExpr, IntegerLiteral, CharacterLiteral and ImplicitCastExpr. Differential Revision: https://reviews.llvm.org/D54166 Reviewed By: dblaikie, rjmccall llvm-svn: 346969
2018-11-16 01:31:16 +08:00
Record.push_back(E->getLength());
Record.push_back(E->getCharByteWidth());
Add support for C++0x unicode string and character literals, from Craig Topper! llvm-svn: 136210
2011-07-27 13:40:30 +08:00
Record.push_back(E->getKind());
Add a flag to StringLiteral to keep track of whether the string is a pascal string or not. llvm-svn: 129488
2011-04-14 08:40:03 +08:00
Record.push_back(E->isPascal());
[AST] Store the string data in StringLiteral in a trailing array of chars Use the newly available space in the bit-fields of Stmt and store the string data in a trailing array of chars after the trailing array of SourceLocation. This cuts the size of StringLiteral by 2 pointers. Also refactor slightly StringLiteral::Create and StringLiteral::CreateEmpty so that StringLiteral::Create is just responsible for the allocation, and the constructor is responsible for doing all the initialization. This match what is done for the other classes in general. This patch should have no other functional changes apart from this. A concern was raised during review about the interaction between this patch and serialization abbreviations. I believe however that there is currently no abbreviation defined for StringLiteral. The only statements/expressions which have abbreviations are currently DeclRefExpr, IntegerLiteral, CharacterLiteral and ImplicitCastExpr. Differential Revision: https://reviews.llvm.org/D54166 Reviewed By: dblaikie, rjmccall llvm-svn: 346969
2018-11-16 01:31:16 +08:00
// Store the trailing array of SourceLocation.
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getStrTokenLoc(I));
[AST] Store the string data in StringLiteral in a trailing array of chars Use the newly available space in the bit-fields of Stmt and store the string data in a trailing array of chars after the trailing array of SourceLocation. This cuts the size of StringLiteral by 2 pointers. Also refactor slightly StringLiteral::Create and StringLiteral::CreateEmpty so that StringLiteral::Create is just responsible for the allocation, and the constructor is responsible for doing all the initialization. This match what is done for the other classes in general. This patch should have no other functional changes apart from this. A concern was raised during review about the interaction between this patch and serialization abbreviations. I believe however that there is currently no abbreviation defined for StringLiteral. The only statements/expressions which have abbreviations are currently DeclRefExpr, IntegerLiteral, CharacterLiteral and ImplicitCastExpr. Differential Revision: https://reviews.llvm.org/D54166 Reviewed By: dblaikie, rjmccall llvm-svn: 346969
2018-11-16 01:31:16 +08:00
// Store the trailing array of char holding the string data.
StringRef StrData = E->getBytes();
for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)
Record.push_back(StrData[I]);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_STRING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Add support for C++0x unicode string and character literals, from Craig Topper! llvm-svn: 136210
2011-07-27 13:40:30 +08:00
Record.push_back(E->getKind());
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
AbbrevToUse = Writer.getCharacterLiteralAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CHARACTER_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLParen());
Record.AddSourceLocation(E->getRParen());
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_PAREN;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 16:49:18 +08:00
VisitExpr(E);
[AST] Store the expressions in ParenListExpr in a trailing array Use the newly available space in the bit-fields of Stmt and store the expressions in a trailing array. This saves 2 pointer per ParenListExpr. Differential Revision: https://reviews.llvm.org/D54675 Reviewed By: rjmccall llvm-svn: 347320
2018-11-21 00:20:40 +08:00
Record.push_back(E->getNumExprs());
for (auto *SubStmt : E->exprs())
Record.AddStmt(SubStmt);
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_PAREN_LIST;
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 16:49:18 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Clean carriage returns from lib/ and include/. NFC. Summary: Clean carriage returns from lib/ and include/. NFC. (I have to make this change locally in order for `git diff` to show sane output after I edit a file, so I might as well ask for it to be committed. I don't have commit privs myself.) (Without this patch, `git rebase`ing any change involving SemaDeclCXX.cpp is a real nightmare. :( So while I have no right to ask for this to be committed, geez would it make my workflow easier if it were.) Here's the command I used to reformat things. (Requires bash and OSX/FreeBSD sed.) git grep -l $'\r' lib include | xargs sed -i -e $'s/\r//' find lib include -name '*-e' -delete Reviewers: malcolm.parsons Reviewed By: malcolm.parsons Subscribers: emaste, krytarowski, cfe-commits Differential Revision: https://reviews.llvm.org/D45591 Patch by Arthur O'Dwyer. llvm-svn: 330112
2018-04-16 16:31:08 +08:00
Record.AddStmt(E->getSubExpr());
Record.push_back(E->getOpcode()); // FIXME: stable encoding
Record.AddSourceLocation(E->getOperatorLoc());
Record.push_back(E->canOverflow());
Code = serialization::EXPR_UNARY_OPERATOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
VisitExpr(E);
Record.push_back(E->getNumComponents());
Record.push_back(E->getNumExpressions());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
Record.AddSourceLocation(E->getRParenLoc());
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-30 06:31:18 +08:00
const OffsetOfNode &ON = E->getComponent(I);
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
Record.push_back(ON.getKind()); // FIXME: Stable encoding
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(ON.getSourceRange().getBegin());
Record.AddSourceLocation(ON.getSourceRange().getEnd());
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
switch (ON.getKind()) {
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-30 06:31:18 +08:00
case OffsetOfNode::Array:
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
Record.push_back(ON.getArrayExprIndex());
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-30 06:31:18 +08:00
case OffsetOfNode::Field:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(ON.getField());
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-30 06:31:18 +08:00
case OffsetOfNode::Identifier:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddIdentifierRef(ON.getFieldName());
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-30 06:31:18 +08:00
case OffsetOfNode::Base:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddCXXBaseSpecifier(*ON.getBase());
Teach __builtin_offsetof to compute the offsets of members of base classes, since we only warn (not error) on offsetof() for non-POD types. We store the base path within the OffsetOfExpr itself, then evaluate the offsets within the constant evaluator. llvm-svn: 102571
2010-04-29 08:18:15 +08:00
break;
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
}
}
for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getIndexExpr(I));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OFFSETOF;
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
}
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Add support for the OpenCL vec_step operator, by generalising and extending the existing support for sizeof and alignof. Original patch by Guy Benyei. llvm-svn: 127475
2011-03-12 03:24:49 +08:00
Record.push_back(E->getKind());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
if (E->isArgumentType())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
else {
Record.push_back(0);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getArgumentExpr());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_SIZEOF_ALIGN_OF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
Record.AddSourceLocation(E->getRBracketLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_ARRAY_SUBSCRIPT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
[OPENMP 4.0] Initial support for array sections. Adds parsing/sema analysis/serialization/deserialization for array sections in OpenMP constructs (introduced in OpenMP 4.0). Currently it is allowed to use array sections only in OpenMP clauses that accepts list of expressions. Differential Revision: http://reviews.llvm.org/D10732 llvm-svn: 245937
2015-08-25 22:24:04 +08:00
void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddStmt(E->getLowerBound());
Record.AddStmt(E->getLength());
Record.AddSourceLocation(E->getColonLoc());
Record.AddSourceLocation(E->getRBracketLoc());
[OPENMP 4.0] Initial support for array sections. Adds parsing/sema analysis/serialization/deserialization for array sections in OpenMP constructs (introduced in OpenMP 4.0). Currently it is allowed to use array sections only in OpenMP clauses that accepts list of expressions. Differential Revision: http://reviews.llvm.org/D10732 llvm-svn: 245937
2015-08-25 22:24:04 +08:00
Code = serialization::EXPR_OMP_ARRAY_SECTION;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Record.push_back(E->getNumArgs());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getRParenLoc());
Record.AddStmt(E->getCallee());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
Arg != ArgEnd; ++Arg)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*Arg);
[AST] Store "UsesADL" information in CallExpr. Summary: Currently the Clang AST doesn't store information about how the callee of a CallExpr was found. Specifically if it was found using ADL. However, this information is invaluable to tooling. Consider a tool which renames usages of a function. If the originally CallExpr was formed using ADL, then the tooling may need to additionally qualify the replacement. Without information about how the callee was found, the tooling is left scratching it's head. Additionally, we want to be able to match ADL calls as quickly as possible, which means avoiding computing the answer on the fly. This patch changes `CallExpr` to store whether it's callee was found using ADL. It does not change the size of any AST nodes. Reviewers: fowles, rsmith, klimek, shafik Reviewed By: rsmith Subscribers: aaron.ballman, riccibruno, calabrese, titus, cfe-commits Differential Revision: https://reviews.llvm.org/D55534 llvm-svn: 348977
2018-12-13 05:50:55 +08:00
Record.push_back(static_cast<unsigned>(E->getADLCallKind()));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CALL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
Convert MemberExpr creation and serialization to work the same way as most / all other Expr subclasses. This reinstates r362551, reverted in r362597, with a fix to a bug that caused MemberExprs to sometimes have a null FoundDecl after a round-trip through an AST file. llvm-svn: 362756
2019-06-07 07:24:15 +08:00
VisitExpr(E);
Revert "Factor out duplicated code building a MemberExpr and marking it" and "Convert MemberExpr creation and serialization to work the same way as" This reverts commits r362551 and r362563. Crashes during modules selfhost. llvm-svn: 362597
2019-06-05 19:46:57 +08:00
Convert MemberExpr creation and serialization to work the same way as most / all other Expr subclasses. This reinstates r362551, reverted in r362597, with a fix to a bug that caused MemberExprs to sometimes have a null FoundDecl after a round-trip through an AST file. llvm-svn: 362756
2019-06-07 07:24:15 +08:00
bool HasQualifier = E->hasQualifier();
bool HasFoundDecl =
E->hasQualifierOrFoundDecl() &&
(E->getFoundDecl().getDecl() != E->getMemberDecl() ||
E->getFoundDecl().getAccess() != E->getMemberDecl()->getAccess());
bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
unsigned NumTemplateArgs = E->getNumTemplateArgs();
// Write these first for easy access when deserializing, as they affect the
// size of the MemberExpr.
Record.push_back(HasQualifier);
Record.push_back(HasFoundDecl);
Record.push_back(HasTemplateInfo);
Record.push_back(NumTemplateArgs);
Revert "Factor out duplicated code building a MemberExpr and marking it" and "Convert MemberExpr creation and serialization to work the same way as" This reverts commits r362551 and r362563. Crashes during modules selfhost. llvm-svn: 362597
2019-06-05 19:46:57 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddDeclRef(E->getMemberDecl());
Convert MemberExpr creation and serialization to work the same way as most / all other Expr subclasses. This reinstates r362551, reverted in r362597, with a fix to a bug that caused MemberExprs to sometimes have a null FoundDecl after a round-trip through an AST file. llvm-svn: 362756
2019-06-07 07:24:15 +08:00
Record.AddDeclarationNameLoc(E->MemberDNLoc,
E->getMemberDecl()->getDeclName());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getMemberLoc());
Fix a few line endings. NFC. llvm-svn: 236301
2015-05-01 10:04:32 +08:00
Record.push_back(E->isArrow());
Convert MemberExpr creation and serialization to work the same way as most / all other Expr subclasses. This reinstates r362551, reverted in r362597, with a fix to a bug that caused MemberExprs to sometimes have a null FoundDecl after a round-trip through an AST file. llvm-svn: 362756
2019-06-07 07:24:15 +08:00
Record.push_back(E->hadMultipleCandidates());
For DR712: store on a MemberExpr whether it constitutes an odr-use. llvm-svn: 363087
2019-06-12 01:50:36 +08:00
Record.push_back(E->isNonOdrUse());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
Convert MemberExpr creation and serialization to work the same way as most / all other Expr subclasses. This reinstates r362551, reverted in r362597, with a fix to a bug that caused MemberExprs to sometimes have a null FoundDecl after a round-trip through an AST file. llvm-svn: 362756
2019-06-07 07:24:15 +08:00
if (HasFoundDecl) {
DeclAccessPair FoundDecl = E->getFoundDecl();
Record.AddDeclRef(FoundDecl.getDecl());
Record.push_back(FoundDecl.getAccess());
}
if (HasQualifier)
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
if (HasTemplateInfo)
AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
E->getTrailingObjects<TemplateArgumentLoc>());
Fix a few line endings. NFC. llvm-svn: 236301
2015-05-01 10:04:32 +08:00
Code = serialization::EXPR_MEMBER;
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddSourceLocation(E->getIsaMemberLoc());
Record.AddSourceLocation(E->getOpLoc());
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
Record.push_back(E->isArrow());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_ISA;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
void ASTStmtWriter::
VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Record.push_back(E->shouldCopy());
Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
}
void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
VisitExplicitCastExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getBridgeKeywordLoc());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
Code = serialization::EXPR_OBJC_BRIDGED_CAST;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
Record.push_back(E->path_size());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Add a CastKind enum to CastExpr. Right now it's not used for much but it will be :) llvm-svn: 77650
2009-07-31 08:48:10 +08:00
Record.push_back(E->getCastKind()); // FIXME: stable encoding
Store inheritance paths after CastExprs instead of inside them. This takes some trickery since CastExpr has subclasses (and indeed, is abstract). Also, smoosh the CastKind into the bitfield from Expr. Drops two words of storage from Expr in the common case of expressions which don't need inheritance paths. Avoids a separate allocation and another word of overhead in cases needing inheritance paths. Also has the advantage of not leaking memory, since destructors for AST nodes are never run. llvm-svn: 110507
2010-08-07 14:22:56 +08:00
for (CastExpr::path_iterator
PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddCXXBaseSpecifier(**PI);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->getOpcode()); // FIXME: stable encoding
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
Encapsulate FPOptions and use it consistently Sema holds the current FPOptions which is adjusted by 'pragma STDC FP_CONTRACT'. This then gets propagated into expression nodes as they are built. This encapsulates FPOptions so that this propagation happens opaquely rather than directly with the fp_contractable on/off bit. This allows controlled transitioning of fp_contractable to a ternary value (off, on, fast). It will also allow adding more fast-math flags later. This is toward moving fp-contraction=fast from an LLVM TargetOption to a FastMathFlag in order to fix PR25721. Differential Revision: https://reviews.llvm.org/D31166 llvm-svn: 298877
2017-03-28 03:17:25 +08:00
Record.push_back(E->getFPFeatures().getInt());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_BINARY_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitBinaryOperator(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeRef(E->getComputationLHSType());
Record.AddTypeRef(E->getComputationResultType());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getCond());
Record.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
Record.AddSourceLocation(E->getQuestionLoc());
Record.AddSourceLocation(E->getColonLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CONDITIONAL_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Change the representation of GNU ?: expressions to use a different expression class and to bind the shared value using OpaqueValueExpr. This fixes an unnoticed problem with deserialization of these expressions where the deserialized form would lose the vital pointer-equality trait; or rather, it fixes it because this patch also does the right thing for deserializing OVEs. Change OVEs to not be a "temporary object" in the sense that copy elision is permitted. This new representation is not totally unawkward to work with, but I think that's really part and parcel with the semantics we're modelling here. In particular, it's much easier to fix things like the copy elision bug and to make the CFG look right. I've tried to update the analyzer to deal with this in at least some obvious cases, and I think we get a much better CFG out, but the printing of OpaqueValueExprs probably needs some work. llvm-svn: 125744
2011-02-17 18:25:35 +08:00
void
ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getOpaqueValue());
Record.AddStmt(E->getCommon());
Record.AddStmt(E->getCond());
Record.AddStmt(E->getTrueExpr());
Record.AddStmt(E->getFalseExpr());
Record.AddSourceLocation(E->getQuestionLoc());
Record.AddSourceLocation(E->getColonLoc());
Change the representation of GNU ?: expressions to use a different expression class and to bind the shared value using OpaqueValueExpr. This fixes an unnoticed problem with deserialization of these expressions where the deserialized form would lose the vital pointer-equality trait; or rather, it fixes it because this patch also does the right thing for deserializing OVEs. Change OVEs to not be a "temporary object" in the sense that copy elision is permitted. This new representation is not totally unawkward to work with, but I think that's really part and parcel with the semantics we're modelling here. In particular, it's much easier to fix things like the copy elision bug and to make the CFG look right. I've tried to update the analyzer to deal with this in at least some obvious cases, and I think we get a much better CFG out, but the printing of OpaqueValueExprs probably needs some work. llvm-svn: 125744
2011-02-17 18:25:35 +08:00
Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitCastExpr(E);
[AST] Sink 'part of explicit cast' down into ImplicitCastExpr Summary: As discussed in IRC with @rsmith, it is slightly not good to keep that in the `CastExpr` itself: Given the explicit cast, which is represented in AST as an `ExplicitCastExpr` + `ImplicitCastExpr`'s, only the `ImplicitCastExpr`'s will be marked as `PartOfExplicitCast`, but not the `ExplicitCastExpr` itself. Thus, it is only ever `true` for `ImplicitCastExpr`'s, so we don't need to write/read/dump it for `ExplicitCastExpr`'s. We don't need to worry that we write the `PartOfExplicitCast` in PCH after `CastExpr::path_iterator`, since the `ExprImplicitCastAbbrev` is only used when the `NumBaseSpecs == 0`, i.e. there is no 'path'. Reviewers: rsmith, rjmccall, erichkeane, aaron.ballman Reviewed By: rsmith, erichkeane Subscribers: vsk, cfe-commits, rsmith Tags: #clang Differential Revision: https://reviews.llvm.org/D49838 llvm-svn: 338108
2018-07-27 15:27:14 +08:00
Record.push_back(E->isPartOfExplicitCast());
[modules] Add abbreviation for ImplicitCastExpr. This is the most common record type in LLVM's IR module. llvm-svn: 214048
2014-07-27 12:19:32 +08:00
if (E->path_size() == 0)
AbbrevToUse = Writer.getExprImplicitCastAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_IMPLICIT_CAST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitCastExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExplicitCastExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CSTYLE_CAST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddStmt(E->getInitializer());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->isFileScope());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_COMPOUND_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddIdentifierRef(&E->getAccessor());
Record.AddSourceLocation(E->getAccessorLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Allow to pass from syntactic form of InitListExpr to semantic form (just as viceversa). No functionality change. llvm-svn: 167591
2012-11-09 02:41:43 +08:00
// NOTE: only add the (possibly null) syntactic form.
// No need to serialize the isSemanticForm flag and the semantic form.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSyntacticForm());
Record.AddSourceLocation(E->getLBraceLoc());
Record.AddSourceLocation(E->getRBraceLoc());
For double data[20000000] = {0}; we would blow out the memory by creating 20M Exprs to fill out the initializer. To fix this, if the initializer list initializes an array with more elements than there are initializers in the list, have InitListExpr store a single 'ArrayFiller' expression that specifies an expression to be used for value initialization of the rest of the elements. Fixes rdar://9275920. llvm-svn: 129896
2011-04-21 08:27:41 +08:00
bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
Record.push_back(isArrayFiller);
if (isArrayFiller)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getArrayFiller());
For double data[20000000] = {0}; we would blow out the memory by creating 20M Exprs to fill out the initializer. To fix this, if the initializer list initializes an array with more elements than there are initializers in the list, have InitListExpr store a single 'ArrayFiller' expression that specifies an expression to be used for value initialization of the rest of the elements. Fixes rdar://9275920. llvm-svn: 129896
2011-04-21 08:27:41 +08:00
else
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getInitializedFieldInUnion());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->hadArrayRangeDesignator());
For double data[20000000] = { [19999999] = 1 }; Don't serialize the filler multiple times. llvm-svn: 129983
2011-04-22 13:29:30 +08:00
Record.push_back(E->getNumInits());
if (isArrayFiller) {
// ArrayFiller may have filled "holes" due to designated initializer.
// Replace them by 0 to indicate that the filler goes in that place.
Expr *filler = E->getArrayFiller();
for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
For double data[20000000] = { [19999999] = 1 }; Don't serialize the filler multiple times. llvm-svn: 129983
2011-04-22 13:29:30 +08:00
} else {
for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getInit(I));
For double data[20000000] = { [19999999] = 1 }; Don't serialize the filler multiple times. llvm-svn: 129983
2011-04-22 13:29:30 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_INIT_LIST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Record.push_back(E->getNumSubExprs());
for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr(I));
Record.AddSourceLocation(E->getEqualOrColonLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->usesGNUSyntax());
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
for (const DesignatedInitExpr::Designator &D : E->designators()) {
if (D.isFieldDesignator()) {
if (FieldDecl *Field = D.getField()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(serialization::DESIG_FIELD_DECL);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(Field);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
} else {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(serialization::DESIG_FIELD_NAME);
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
Record.AddIdentifierRef(D.getFieldName());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
Record.AddSourceLocation(D.getDotLoc());
Record.AddSourceLocation(D.getFieldLoc());
} else if (D.isArrayDesignator()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(serialization::DESIG_ARRAY);
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
Record.push_back(D.getFirstExprIndex());
Record.AddSourceLocation(D.getLBracketLoc());
Record.AddSourceLocation(D.getRBracketLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
} else {
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
assert(D.isArrayRangeDesignator() && "Unknown designator");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(serialization::DESIG_ARRAY_RANGE);
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
Record.push_back(D.getFirstExprIndex());
Record.AddSourceLocation(D.getLBracketLoc());
Record.AddSourceLocation(D.getEllipsisLoc());
Record.AddSourceLocation(D.getRBracketLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_DESIGNATED_INIT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Implementing C99 partial re-initialization behavior (DR-253) Based on previous discussion on the mailing list, clang currently lacks support for C99 partial re-initialization behavior: Reference: http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-April/029188.html Reference: http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_253.htm This patch attempts to fix this problem. Given the following code snippet, struct P1 { char x[6]; }; struct LP1 { struct P1 p1; }; struct LP1 l = { .p1 = { "foo" }, .p1.x[2] = 'x' }; // this example is adapted from the example for "struct fred x[]" in DR-253; // currently clang produces in l: { "\0\0x" }, // whereas gcc 4.8 produces { "fox" }; // with this fix, clang will also produce: { "fox" }; Differential Review: http://reviews.llvm.org/D5789 llvm-svn: 239446
2015-06-10 08:27:52 +08:00
void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddStmt(E->getUpdater());
Implementing C99 partial re-initialization behavior (DR-253) Based on previous discussion on the mailing list, clang currently lacks support for C99 partial re-initialization behavior: Reference: http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-April/029188.html Reference: http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_253.htm This patch attempts to fix this problem. Given the following code snippet, struct P1 { char x[6]; }; struct LP1 { struct P1 p1; }; struct LP1 l = { .p1 = { "foo" }, .p1.x[2] = 'x' }; // this example is adapted from the example for "struct fred x[]" in DR-253; // currently clang produces in l: { "\0\0x" }, // whereas gcc 4.8 produces { "fox" }; // with this fix, clang will also produce: { "fox" }; Differential Review: http://reviews.llvm.org/D5789 llvm-svn: 239446
2015-06-10 08:27:52 +08:00
Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
}
void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
VisitExpr(E);
Code = serialization::EXPR_NO_INIT;
}
Add two new AST nodes to represent initialization of an array in terms of initialization of each array element: * ArrayInitLoopExpr is a prvalue of array type with two subexpressions: a common expression (an OpaqueValueExpr) that represents the up-front computation of the source of the initialization, and a subexpression representing a per-element initializer * ArrayInitIndexExpr is a prvalue of type size_t representing the current position in the loop This will be used to replace the creation of explicit index variables in lambda capture of arrays and copy/move construction of classes with array elements, and also C++17 structured bindings of arrays by value (which inexplicably allow copying an array by value, unlike all of C++'s other array declarations). No uses of these nodes are introduced by this change, however. llvm-svn: 289413
2016-12-12 10:53:20 +08:00
void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
VisitExpr(E);
Record.AddStmt(E->SubExprs[0]);
Record.AddStmt(E->SubExprs[1]);
Code = serialization::EXPR_ARRAY_INIT_LOOP;
}
void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
VisitExpr(E);
Code = serialization::EXPR_ARRAY_INIT_INDEX;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Support __builtin_ms_va_list. Summary: This change adds support for `__builtin_ms_va_list`, a GCC extension for variadic `ms_abi` functions. The existing `__builtin_va_list` support is inadequate for this because `va_list` is defined differently in the Win64 ABI vs. the System V/AMD64 ABI. Depends on D1622. Reviewers: rsmith, rnk, rjmccall CC: cfe-commits Differential Revision: http://reviews.llvm.org/D1623 llvm-svn: 247941
2015-09-18 04:55:33 +08:00
Record.push_back(E->isMicrosoftABI());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_VA_ARG;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Implement __builtin_LINE() et. al. to support source location capture. Summary: This patch implements the source location builtins `__builtin_LINE(), `__builtin_FUNCTION()`, `__builtin_FILE()` and `__builtin_COLUMN()`. These builtins are needed to implement [`std::experimental::source_location`](https://rawgit.com/cplusplus/fundamentals-ts/v2/main.html#reflection.src_loc.creation). With the exception of `__builtin_COLUMN`, GCC also implements these builtins, and Clangs behavior is intended to match as closely as possible. Reviewers: rsmith, joerg, aaron.ballman, bogner, majnemer, shafik, martong Reviewed By: rsmith Subscribers: rnkovacs, loskutov, riccibruno, mgorny, kunitoki, alexr, majnemer, hfinkel, cfe-commits Differential Revision: https://reviews.llvm.org/D37035 llvm-svn: 360937
2019-05-17 05:04:15 +08:00
void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
VisitExpr(E);
Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
Record.AddSourceLocation(E->getBeginLoc());
Record.AddSourceLocation(E->getEndLoc());
Record.push_back(E->getIdentKind());
Code = serialization::EXPR_SOURCE_LOC;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getAmpAmpLoc());
Record.AddSourceLocation(E->getLabelLoc());
Record.AddDeclRef(E->getLabel());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_ADDR_LABEL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubStmt());
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_STMT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getCond());
Record.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Make IgnoreParens() look through ChooseExprs. This is the same way GenericSelectionExpr works, and it's generally a more consistent approach. A large part of this patch is devoted to caching the value of the condition of a ChooseExpr; it's needed to avoid threading an ASTContext into IgnoreParens(). Fixes <rdar://problem/14438917>. llvm-svn: 186738
2013-07-20 08:40:58 +08:00
Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CHOOSE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getTokenLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_GNU_NULL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Record.push_back(E->getNumSubExprs());
for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getExpr(I));
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_SHUFFLE_VECTOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Add the intrinsic __builtin_convertvector LLVM supports applying conversion instructions to vectors of the same number of elements (fptrunc, fptosi, etc.) but there had been no way for a Clang user to cause such instructions to be generated when using builtin vector types. C-style casting on vectors is already defined in terms of bitcasts, and so cannot be used for these conversions as well (without leading to a very confusing set of semantics). As a result, this adds a __builtin_convertvector intrinsic (patterned after the OpenCL __builtin_astype intrinsic). This is intended to aid the creation of vector intrinsic headers that create generic IR instead of target-dependent intrinsics (in other words, this is a generic _mm_cvtepi32_ps). As noted in the documentation, the action of __builtin_convertvector is defined in terms of the action of a C-style cast on each vector element. llvm-svn: 190915
2013-09-18 11:29:45 +08:00
void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddStmt(E->getSrcExpr());
Add the intrinsic __builtin_convertvector LLVM supports applying conversion instructions to vectors of the same number of elements (fptrunc, fptosi, etc.) but there had been no way for a Clang user to cause such instructions to be generated when using builtin vector types. C-style casting on vectors is already defined in terms of bitcasts, and so cannot be used for these conversions as well (without leading to a very confusing set of semantics). As a result, this adds a __builtin_convertvector intrinsic (patterned after the OpenCL __builtin_astype intrinsic). This is intended to aid the creation of vector intrinsic headers that create generic IR instead of target-dependent intrinsics (in other words, this is a generic _mm_cvtepi32_ps). As noted in the documentation, the action of __builtin_convertvector is defined in terms of the action of a C-style cast on each vector element. llvm-svn: 190915
2013-09-18 11:29:45 +08:00
Code = serialization::EXPR_CONVERT_VECTOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getBlockDecl());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_BLOCK;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
C1X: implement generic selections As an extension, generic selection support has been added for all supported languages. The syntax is the same as for C1X. llvm-svn: 129554
2011-04-15 08:35:48 +08:00
void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
VisitExpr(E);
[AST] Pack GenericSelectionExpr Store the controlling expression, the association expressions and the corresponding TypeSourceInfos as trailing objects. Additionally use the bit-fields of Stmt to store one SourceLocation, saving one additional pointer. This saves 3 pointers in total per GenericSelectionExpr. Differential Revision: https://reviews.llvm.org/D57104 Reviewed By: aaron.ballman Reviewers: aaron.ballman, steveire llvm-svn: 352276
2019-01-26 22:15:10 +08:00
C1X: implement generic selections As an extension, generic selection support has been added for all supported languages. The syntax is the same as for C1X. llvm-svn: 129554
2011-04-15 08:35:48 +08:00
Record.push_back(E->getNumAssocs());
[AST][NFC] Various cleanups to GenericSelectionExpr Various cleanups to GenericSelectionExpr factored out of D57104. In particular: 1. Move the friend declaration to the top. 2. Introduce a constant ResultDependentIndex instead of the magic "-1". 3. clang-format 4. Group the member function together so that they can be removed as one block by D57106. NFC. Differential Revision: https://reviews.llvm.org/D57238 Reviewed By: aaron.ballman llvm-svn: 352275
2019-01-26 21:58:15 +08:00
Record.push_back(E->ResultIndex);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getGenericLoc());
Record.AddSourceLocation(E->getDefaultLoc());
Record.AddSourceLocation(E->getRParenLoc());
[AST] Pack GenericSelectionExpr Store the controlling expression, the association expressions and the corresponding TypeSourceInfos as trailing objects. Additionally use the bit-fields of Stmt to store one SourceLocation, saving one additional pointer. This saves 3 pointers in total per GenericSelectionExpr. Differential Revision: https://reviews.llvm.org/D57104 Reviewed By: aaron.ballman Reviewers: aaron.ballman, steveire llvm-svn: 352276
2019-01-26 22:15:10 +08:00
Stmt **Stmts = E->getTrailingObjects<Stmt *>();
// Add 1 to account for the controlling expression which is the first
// expression in the trailing array of Stmt *. This is not needed for
// the trailing array of TypeSourceInfo *.
for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
Record.AddStmt(Stmts[I]);
TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
Record.AddTypeSourceInfo(TSIs[I]);
C1X: implement generic selections As an extension, generic selection support has been added for all supported languages. The syntax is the same as for C1X. llvm-svn: 129554
2011-04-15 08:35:48 +08:00
Code = serialization::EXPR_GENERIC_SELECTION;
}
Change the AST representation of operations on Objective-C property references to use a new PseudoObjectExpr expression which pairs a syntactic form of the expression with a set of semantic expressions implementing it. This should significantly reduce the complexity required elsewhere in the compiler to deal with these kinds of expressions (e.g. IR generation's special l-value kind, the static analyzer's Message abstraction), at the lower cost of specifically dealing with the odd AST structure of these expressions. It should also greatly simplify efforts to implement similar language features in the future, most notably Managed C++'s properties and indexed properties. Most of the effort here is in dealing with the various clients of the AST. I've gone ahead and simplified the ObjC rewriter's use of properties; other clients, like IR-gen and the static analyzer, have all the old complexity *and* all the new complexity, at least temporarily. Many thanks to Ted for writing and advising on the necessary changes to the static analyzer. I've xfailed a small diagnostics regression in the static analyzer at Ted's request. llvm-svn: 143867
2011-11-06 17:01:30 +08:00
void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
VisitExpr(E);
Record.push_back(E->getNumSemanticExprs());
// Push the result index. Currently, this needs to exactly match
// the encoding used internally for ResultIndex.
unsigned result = E->getResultExprIndex();
result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
Record.push_back(result);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSyntacticForm());
Change the AST representation of operations on Objective-C property references to use a new PseudoObjectExpr expression which pairs a syntactic form of the expression with a set of semantic expressions implementing it. This should significantly reduce the complexity required elsewhere in the compiler to deal with these kinds of expressions (e.g. IR generation's special l-value kind, the static analyzer's Message abstraction), at the lower cost of specifically dealing with the odd AST structure of these expressions. It should also greatly simplify efforts to implement similar language features in the future, most notably Managed C++'s properties and indexed properties. Most of the effort here is in dealing with the various clients of the AST. I've gone ahead and simplified the ObjC rewriter's use of properties; other clients, like IR-gen and the static analyzer, have all the old complexity *and* all the new complexity, at least temporarily. Many thanks to Ted for writing and advising on the necessary changes to the static analyzer. I've xfailed a small diagnostics regression in the static analyzer at Ted's request. llvm-svn: 143867
2011-11-06 17:01:30 +08:00
for (PseudoObjectExpr::semantics_iterator
i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*i);
Change the AST representation of operations on Objective-C property references to use a new PseudoObjectExpr expression which pairs a syntactic form of the expression with a set of semantic expressions implementing it. This should significantly reduce the complexity required elsewhere in the compiler to deal with these kinds of expressions (e.g. IR generation's special l-value kind, the static analyzer's Message abstraction), at the lower cost of specifically dealing with the odd AST structure of these expressions. It should also greatly simplify efforts to implement similar language features in the future, most notably Managed C++'s properties and indexed properties. Most of the effort here is in dealing with the various clients of the AST. I've gone ahead and simplified the ObjC rewriter's use of properties; other clients, like IR-gen and the static analyzer, have all the old complexity *and* all the new complexity, at least temporarily. Many thanks to Ted for writing and advising on the necessary changes to the static analyzer. I've xfailed a small diagnostics regression in the static analyzer at Ted's request. llvm-svn: 143867
2011-11-06 17:01:30 +08:00
}
[PCH] When serializing an PseudoObjectExpr or AtomicExpr, the serialization code must be set otherwise it will crash with asserts on or it will be written as null pointer. llvm-svn: 144626
2011-11-15 14:20:27 +08:00
Code = serialization::EXPR_PSEUDO_OBJECT;
Change the AST representation of operations on Objective-C property references to use a new PseudoObjectExpr expression which pairs a syntactic form of the expression with a set of semantic expressions implementing it. This should significantly reduce the complexity required elsewhere in the compiler to deal with these kinds of expressions (e.g. IR generation's special l-value kind, the static analyzer's Message abstraction), at the lower cost of specifically dealing with the odd AST structure of these expressions. It should also greatly simplify efforts to implement similar language features in the future, most notably Managed C++'s properties and indexed properties. Most of the effort here is in dealing with the various clients of the AST. I've gone ahead and simplified the ObjC rewriter's use of properties; other clients, like IR-gen and the static analyzer, have all the old complexity *and* all the new complexity, at least temporarily. Many thanks to Ted for writing and advising on the necessary changes to the static analyzer. I've xfailed a small diagnostics regression in the static analyzer at Ted's request. llvm-svn: 143867
2011-11-06 17:01:30 +08:00
}
Initial implementation of __atomic_* (everything except __atomic_is_lock_free). llvm-svn: 141632
2011-10-11 10:20:01 +08:00
void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
VisitExpr(E);
Record.push_back(E->getOp());
AtomicExpr: make ASTStmtReader a friend and remove setters. Also fix saving of an uninitialized Stmt* in serialization of __atomic_init and add a test of atomics serialization. llvm-svn: 154448
2012-04-11 06:49:28 +08:00
for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExprs()[I]);
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
[PCH] When serializing an PseudoObjectExpr or AtomicExpr, the serialization code must be set otherwise it will crash with asserts on or it will be written as null pointer. llvm-svn: 144626
2011-11-15 14:20:27 +08:00
Code = serialization::EXPR_ATOMIC;
Initial implementation of __atomic_* (everything except __atomic_is_lock_free). llvm-svn: 141632
2011-10-11 10:20:01 +08:00
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//===----------------------------------------------------------------------===//
// Objective-C Expressions and Statements.
//===----------------------------------------------------------------------===//
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getString());
Record.AddSourceLocation(E->getAtLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_STRING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Implements boxed expressions for Objective-C. <rdar://problem/10194391> llvm-svn: 155082
2012-04-19 08:25:12 +08:00
void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Record.AddDeclRef(E->getBoxingMethod());
Record.AddSourceRange(E->getSourceRange());
Implements boxed expressions for Objective-C. <rdar://problem/10194391> llvm-svn: 155082
2012-04-19 08:25:12 +08:00
Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
}
void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
VisitExpr(E);
Record.push_back(E->getNumElements());
for (unsigned i = 0; i < E->getNumElements(); i++)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getElement(i));
Record.AddDeclRef(E->getArrayWithObjectsMethod());
Record.AddSourceRange(E->getSourceRange());
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
}
void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
VisitExpr(E);
Record.push_back(E->getNumElements());
Record.push_back(E->HasPackExpansions);
for (unsigned i = 0; i < E->getNumElements(); i++) {
ObjCDictionaryElement Element = E->getKeyValueElement(i);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(Element.Key);
Record.AddStmt(Element.Value);
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
if (E->HasPackExpansions) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(Element.EllipsisLoc);
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
unsigned NumExpansions = 0;
if (Element.NumExpansions)
NumExpansions = *Element.NumExpansions + 1;
Record.push_back(NumExpansions);
}
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getDictWithObjectsMethod());
Record.AddSourceRange(E->getSourceRange());
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
Record.AddSourceLocation(E->getAtLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_ENCODE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSelectorRef(E->getSelector());
Record.AddSourceLocation(E->getAtLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getProtocol());
Record.AddSourceLocation(E->getAtLoc());
Record.AddSourceLocation(E->ProtoLoc);
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getDecl());
Record.AddSourceLocation(E->getLocation());
Record.AddSourceLocation(E->getOpLoc());
Record.AddStmt(E->getBase());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Record.push_back(E->isArrow());
Record.push_back(E->isFreeIvar());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Add info to ObjCPropertyRefExpr to indicate whether the dot syntax property reference is going to message the setter, the getter, or both. Having this info on the ObjCPropertyRefExpr node makes it easier for AST clients (like libclang) to reason about the meaning of the property reference. [AST/Sema] -Use 2 bits (with a PointerIntPair) in ObjCPropertyRefExpr to record the above info -Have ObjCPropertyOpBuilder set the info appropriately. [libclang] -When there is an implicit property reference (property syntax using methods) have clang_getCursorReferenced return a cursor for the method. If the property reference is going to result in messaging both the getter and the setter choose to return a cursor for the setter because it is less obvious from source inspection that the setter is getting called. The general idea has the seal of approval by John. rdar://11151621 llvm-svn: 153709
2012-03-30 08:19:18 +08:00
Record.push_back(E->SetterAndMethodRefFlags.getInt());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
Record.push_back(E->isImplicitProperty());
if (E->isImplicitProperty()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getImplicitPropertyGetter());
Record.AddDeclRef(E->getImplicitPropertySetter());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
} else {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getExplicitProperty());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
}
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Record.AddSourceLocation(E->getReceiverLocation());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
if (E->isObjectReceiver()) {
Record.push_back(0);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
} else if (E->isSuperReceiver()) {
Record.push_back(1);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeRef(E->getSuperReceiverType());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
} else {
Record.push_back(2);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getClassReceiver());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 09:19:52 +08:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getRBracket());
Record.AddStmt(E->getBaseExpr());
Record.AddStmt(E->getKeyExpr());
Record.AddDeclRef(E->getAtIndexMethodDecl());
Record.AddDeclRef(E->setAtIndexMethodDecl());
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitExpr(E);
Record.push_back(E->getNumArgs());
Allow getting all source locations of selector identifiers in a ObjCMessageExpr. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: [foo first:1 second:2] -With a space between the arguments: [foo first: 1 second: 2] -For nullary selectors, immediately before ']': [foo release] In such cases we infer the locations instead of storing them. llvm-svn: 140987
2011-10-03 14:36:51 +08:00
Record.push_back(E->getNumStoredSelLocs());
Record.push_back(E->SelLocsKind);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Record.push_back(E->isDelegateInitCall());
Add IsImplicit field in ObjCMessageExpr that is true when the message was constructed, e.g. for a property access. This allows the selector identifier locations machinery for ObjCMessageExpr to function correctly, in that there are not real locations to handle/report for such a message. llvm-svn: 148013
2012-01-12 10:34:39 +08:00
Record.push_back(E->IsImplicit);
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
switch (E->getReceiverKind()) {
case ObjCMessageExpr::Instance:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getInstanceReceiver());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
break;
case ObjCMessageExpr::Class:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
break;
case ObjCMessageExpr::SuperClass:
case ObjCMessageExpr::SuperInstance:
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeRef(E->getSuperType());
Record.AddSourceLocation(E->getSuperLoc());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
break;
}
if (E->getMethodDecl()) {
Record.push_back(1);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getMethodDecl());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
} else {
Record.push_back(0);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Record.AddSelectorRef(E->getSelector());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLeftLoc());
Record.AddSourceLocation(E->getRightLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
Arg != ArgEnd; ++Arg)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*Arg);
Allow getting all source locations of selector identifiers in a ObjCMessageExpr. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: [foo first:1 second:2] -With a space between the arguments: [foo first: 1 second: 2] -For nullary selectors, immediately before ']': [foo release] In such cases we infer the locations instead of storing them. llvm-svn: 140987
2011-10-03 14:36:51 +08:00
SourceLocation *Locs = E->getStoredSelLocs();
for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(Locs[i]);
Allow getting all source locations of selector identifiers in a ObjCMessageExpr. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: [foo first:1 second:2] -With a space between the arguments: [foo first: 1 second: 2] -For nullary selectors, immediately before ']': [foo release] In such cases we infer the locations instead of storing them. llvm-svn: 140987
2011-10-03 14:36:51 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getElement());
Record.AddStmt(S->getCollection());
Record.AddStmt(S->getBody());
Record.AddSourceLocation(S->getForLoc());
Record.AddSourceLocation(S->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_FOR_COLLECTION;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCatchBody());
Record.AddDeclRef(S->getCatchParamDecl());
Record.AddSourceLocation(S->getAtCatchLoc());
Record.AddSourceLocation(S->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_CATCH;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getFinallyBody());
Record.AddSourceLocation(S->getAtFinallyLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_FINALLY;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S); // FIXME: no test coverage.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getSubStmt());
Record.AddSourceLocation(S->getAtLoc());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S);
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
Record.push_back(S->getNumCatchStmts());
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Record.push_back(S->getFinallyStmt() != nullptr);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getTryBody());
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getCatchStmt(I));
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
if (S->getFinallyStmt())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getFinallyStmt());
Record.AddSourceLocation(S->getAtTryLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_AT_TRY;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S); // FIXME: no test coverage.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getSynchExpr());
Record.AddStmt(S->getSynchBody());
Record.AddSourceLocation(S->getAtSynchronizedLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
[NFC][clang][PCH][ObjC] Add some missing `VisitStmt(S);` Summary: These ObjC AST classes inherit from Stmt, but don't call `VisitStmt(S);`. Some were founded with help of existing tests (with `NumStmtFields` bumped to `1`), but some of them don't even have PCH test coverage. :/ Reviewers: arphaman, sammccall, smeenai, aprantl, rsmith, jordan_rose Reviewed By: jordan_rose Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59197 llvm-svn: 355987
2019-03-13 05:31:00 +08:00
VisitStmt(S); // FIXME: no test coverage.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getThrowExpr());
Record.AddSourceLocation(S->getThrowLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_OBJC_AT_THROW;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
VisitExpr(E);
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
Code = serialization::EXPR_OBJC_BOOL_LITERAL;
}
[ObjC] Implement @available in the Parser and AST This patch adds a new AST node: ObjCAvailabilityCheckExpr, and teaches the Parser and Sema to generate it. This node represents an availability check of the form: @available(macos 10.10, *); Which will eventually compile to a runtime check of the host's OS version. This is the first patch of the feature I proposed here: http://lists.llvm.org/pipermail/cfe-dev/2016-July/049851.html Differential Revision: https://reviews.llvm.org/D22171 llvm-svn: 275654
2016-07-16 08:35:23 +08:00
void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
VisitExpr(E);
Record.AddSourceRange(E->getSourceRange());
Record.AddVersionTuple(E->getVersion());
Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK;
}
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
//===----------------------------------------------------------------------===//
// C++ Expressions and Statements.
//===----------------------------------------------------------------------===//
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-23 00:03:56 +08:00
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getCatchLoc());
Record.AddDeclRef(S->getExceptionDecl());
Record.AddStmt(S->getHandlerBlock());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_CXX_CATCH;
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-23 00:03:56 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-23 00:03:56 +08:00
VisitStmt(S);
Record.push_back(S->getNumHandlers());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getTryLoc());
Record.AddStmt(S->getTryBlock());
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-23 00:03:56 +08:00
for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getHandler(i));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::STMT_CXX_TRY;
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-23 00:03:56 +08:00
}
Add support for C++0x's range-based for loops, as specified by the C++11 draft standard (N3291). llvm-svn: 129541
2011-04-15 06:09:26 +08:00
void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getForLoc());
Record.AddSourceLocation(S->getCoawaitLoc());
Record.AddSourceLocation(S->getColonLoc());
Record.AddSourceLocation(S->getRParenLoc());
[cxx2a] P0614R1: Support init-statements in range-based for loops. We don't yet support this for the case where a range-based for loop is implicitly rewritten to an ObjC for..in statement. llvm-svn: 343350
2018-09-29 02:44:09 +08:00
Record.AddStmt(S->getInit());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(S->getRangeStmt());
Record.AddStmt(S->getBeginStmt());
Record.AddStmt(S->getEndStmt());
Record.AddStmt(S->getCond());
Record.AddStmt(S->getInc());
Record.AddStmt(S->getLoopVarStmt());
Record.AddStmt(S->getBody());
Add support for C++0x's range-based for loops, as specified by the C++11 draft standard (N3291). llvm-svn: 129541
2011-04-15 06:09:26 +08:00
Code = serialization::STMT_CXX_FOR_RANGE;
}
Implement support for dependent Microsoft __if_exists/__if_not_exists statements. As noted in the documentation for the AST node, the semantics of __if_exists/__if_not_exists are somewhat different from the way Visual C++ implements them, because our parsed-template representation can't accommodate VC++ semantics without serious contortions. Hopefully this implementation is "good enough". llvm-svn: 142901
2011-10-25 09:33:02 +08:00
void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getKeywordLoc());
Implement support for dependent Microsoft __if_exists/__if_not_exists statements. As noted in the documentation for the AST node, the semantics of __if_exists/__if_not_exists are somewhat different from the way Visual C++ implements them, because our parsed-template representation can't accommodate VC++ semantics without serious contortions. Hopefully this implementation is "good enough". llvm-svn: 142901
2011-10-25 09:33:02 +08:00
Record.push_back(S->isIfExists());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddNestedNameSpecifierLoc(S->getQualifierLoc());
Record.AddDeclarationNameInfo(S->getNameInfo());
Record.AddStmt(S->getSubStmt());
Implement support for dependent Microsoft __if_exists/__if_not_exists statements. As noted in the documentation for the AST node, the semantics of __if_exists/__if_not_exists are somewhat different from the way Visual C++ implements them, because our parsed-template representation can't accommodate VC++ semantics without serious contortions. Hopefully this implementation is "good enough". llvm-svn: 142901
2011-10-25 09:33:02 +08:00
Code = serialization::STMT_MS_DEPENDENT_EXISTS;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
VisitCallExpr(E);
Record.push_back(E->getOperator());
Encapsulate FPOptions and use it consistently Sema holds the current FPOptions which is adjusted by 'pragma STDC FP_CONTRACT'. This then gets propagated into expression nodes as they are built. This encapsulates FPOptions so that this propagation happens opaquely rather than directly with the fp_contractable on/off bit. This allows controlled transitioning of fp_contractable to a ternary value (off, on, fast). It will also allow adding more fast-math flags later. This is toward moving fp-contraction=fast from an LLVM TargetOption to a FastMathFlag in order to fix PR25721. Differential Revision: https://reviews.llvm.org/D31166 llvm-svn: 298877
2017-03-28 03:17:25 +08:00
Record.push_back(E->getFPFeatures().getInt());
[AST][NFC] Pack CXXOperatorCallExpr Use the space available in the bit-fields of Stmt. This saves 8 bytes per CXXOperatorCallExpr. NFC. llvm-svn: 349924
2018-12-22 00:51:57 +08:00
Record.AddSourceRange(E->Range);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_OPERATOR_CALL;
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
pchify CXXMemberCallExpr correctly. Before it would serialize and deserialize as a CallExpr which is close, but ends up deserializing with the wrong stmt class. llvm-svn: 103371
2010-05-09 13:36:05 +08:00
VisitCallExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_MEMBER_CALL;
pchify CXXMemberCallExpr correctly. Before it would serialize and deserialize as a CallExpr which is close, but ends up deserializing with the wrong stmt class. llvm-svn: 103371
2010-05-09 13:36:05 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
VisitExpr(E);
[AST] Store the arguments of CXXConstructExpr in a trailing array Store the arguments of CXXConstructExpr in a trailing array. This is very similar to the CallExpr case in D55771, with the exception that there is only one derived class (CXXTemporaryObjectExpr) and that we compute the offset to the trailing array instead of storing it. This saves one pointer per CXXConstructExpr and CXXTemporaryObjectExpr. Reviewed By: rjmccall Differential Revision: https://reviews.llvm.org/D56022 llvm-svn: 350003
2018-12-22 22:39:30 +08:00
Fix broken de/serialization for a couple of C++ Exprs. llvm-svn: 106726
2010-06-24 16:57:09 +08:00
Record.push_back(E->getNumArgs());
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
Record.push_back(E->isElidable());
Added a flag to identify resolved overloaded function references. llvm-svn: 141171
2011-10-05 15:56:41 +08:00
Record.push_back(E->hadMultipleCandidates());
PR13470: Ensure that copy-list-initialization isntantiates as copy-list-initialization (and doesn't add an additional copy step): Fill in the ListInitialization bit when creating a CXXConstructExpr. Use it when instantiating initializers in order to correctly handle instantiation of copy-list-initialization. Teach TreeTransform that function arguments are initializations, and so need this special treatment too. Finally, remove some hacks which were working around SubstInitializer's shortcomings. llvm-svn: 170489
2012-12-19 09:39:02 +08:00
Record.push_back(E->isListInitialization());
Track the difference between -- a constructor list initialization that unpacked an initializer list into constructor arguments and -- a list initialization that created as std::initializer_list and passed it as the first argument to a constructor in the AST. Use this flag while instantiating templates to provide the right semantics for the resulting initialization. llvm-svn: 213224
2014-07-17 13:12:35 +08:00
Record.push_back(E->isStdInitListInitialization());
When value-initializing a class with no user-defined constructors but with a non-trivial default constructor, zero-initialize the storage and then call the default constructor. Fixes PR5800. llvm-svn: 91548
2009-12-17 02:50:27 +08:00
Record.push_back(E->requiresZeroInitialization());
Recognize when the named return value optimization applies in a "return" statement and mark the corresponding CXXConstructExpr as elidable. Teach CodeGen that eliding a temporary is different from eliding an object construction. This is just a baby step toward NRVO. llvm-svn: 103849
2010-05-15 08:13:29 +08:00
Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
[AST] Store the arguments of CXXConstructExpr in a trailing array Store the arguments of CXXConstructExpr in a trailing array. This is very similar to the CallExpr case in D55771, with the exception that there is only one derived class (CXXTemporaryObjectExpr) and that we compute the offset to the trailing array instead of storing it. This saves one pointer per CXXConstructExpr and CXXTemporaryObjectExpr. Reviewed By: rjmccall Differential Revision: https://reviews.llvm.org/D56022 llvm-svn: 350003
2018-12-22 22:39:30 +08:00
Record.AddSourceLocation(E->getLocation());
Record.AddDeclRef(E->getConstructor());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getParenOrBraceRange());
[AST] Store the arguments of CXXConstructExpr in a trailing array Store the arguments of CXXConstructExpr in a trailing array. This is very similar to the CallExpr case in D55771, with the exception that there is only one derived class (CXXTemporaryObjectExpr) and that we compute the offset to the trailing array instead of storing it. This saves one pointer per CXXConstructExpr and CXXTemporaryObjectExpr. Reviewed By: rjmccall Differential Revision: https://reviews.llvm.org/D56022 llvm-svn: 350003
2018-12-22 22:39:30 +08:00
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
Record.AddStmt(E->getArg(I));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_CONSTRUCT;
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
}
P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991: Replace inheriting constructors implementation with new approach, voted into C++ last year as a DR against C++11. Instead of synthesizing a set of derived class constructors for each inherited base class constructor, we make the constructors of the base class visible to constructor lookup in the derived class, using the normal rules for using-declarations. For constructors, UsingShadowDecl now has a ConstructorUsingShadowDecl derived class that tracks the requisite additional information. We create shadow constructors (not found by name lookup) in the derived class to model the actual initialization, and have a new expression node, CXXInheritedCtorInitExpr, to model the initialization of a base class from such a constructor. (This initialization is special because it performs real perfect forwarding of arguments.) In cases where argument forwarding is not possible (for inalloca calls, variadic calls, and calls with callee parameter cleanup), the shadow inheriting constructor is not emitted and instead we directly emit the initialization code into the caller of the inherited constructor. Note that this new model is not perfectly compatible with the old model in some corner cases. In particular: * if B inherits a private constructor from A, and C uses that constructor to construct a B, then we previously required that A befriends B and B befriends C, but the new rules require A to befriend C directly, and * if a derived class has its own constructors (and so its implicit default constructor is suppressed), it may still inherit a default constructor from a base class llvm-svn: 274049
2016-06-29 03:03:57 +08:00
void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
VisitExpr(E);
Record.AddDeclRef(E->getConstructor());
Record.AddSourceLocation(E->getLocation());
Record.push_back(E->constructsVBase());
Record.push_back(E->inheritedFromVBase());
Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
Add PCH support for the remaining C++ exprs. llvm-svn: 108042
2010-07-10 19:46:15 +08:00
VisitCXXConstructExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
Add PCH support for the remaining C++ exprs. llvm-svn: 108042
2010-07-10 19:46:15 +08:00
}
Introduce basic ASTs for lambda expressions. This covers: - Capturing variables by-reference and by-copy within a lambda - The representation of lambda captures - The creation of the non-static data members in the lambda class that store the captured variables - The initialization of the non-static data members from the captured variables - Pretty-printing lambda expressions There are a number of FIXMEs, both explicit and implied, including: - Creating a field for a capture of 'this' - Improved diagnostics for initialization failures when capturing variables by copy - Dealing with temporaries created during said initialization - Template instantiation - AST (de-)serialization - Binding and returning the lambda expression; turning it into a proper temporary - Lots and lots of semantic constraints - Parameter pack captures llvm-svn: 149977
2012-02-07 18:09:13 +08:00
void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
VisitExpr(E);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Record.push_back(E->NumCaptures);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->IntroducerRange);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Record.push_back(E->CaptureDefault); // FIXME: stable encoding
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->CaptureDefaultLoc);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Record.push_back(E->ExplicitParams);
Record.push_back(E->ExplicitResultType);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->ClosingBrace);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
// Add capture initializers.
for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
CEnd = E->capture_init_end();
C != CEnd; ++C) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*C);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Code = serialization::EXPR_LAMBDA;
Introduce basic ASTs for lambda expressions. This covers: - Capturing variables by-reference and by-copy within a lambda - The representation of lambda captures - The creation of the non-static data members in the lambda class that store the captured variables - The initialization of the non-static data members from the captured variables - Pretty-printing lambda expressions There are a number of FIXMEs, both explicit and implied, including: - Creating a field for a capture of 'this' - Improved diagnostics for initialization failures when capturing variables by copy - Dealing with temporaries created during said initialization - Template instantiation - AST (de-)serialization - Binding and returning the lambda expression; turning it into a proper temporary - Lots and lots of semantic constraints - Parameter pack captures llvm-svn: 149977
2012-02-07 18:09:13 +08:00
}
PR12086, PR15117 Introduce CXXStdInitializerListExpr node, representing the implicit construction of a std::initializer_list<T> object from its underlying array. The AST representation of such an expression goes from an InitListExpr with a flag set, to a CXXStdInitializerListExpr containing a MaterializeTemporaryExpr containing an InitListExpr (possibly wrapped in a CXXBindTemporaryExpr). This more detailed representation has several advantages, the most important of which is that the new MaterializeTemporaryExpr allows us to directly model lifetime extension of the underlying temporary array. Using that, this patch *drastically* simplifies the IR generation of this construct, provides IR generation support for nested global initializer_list objects, fixes several bugs where the destructors for the underlying array would accidentally not get invoked, and provides constant expression evaluation support for std::initializer_list objects. llvm-svn: 183872
2013-06-13 06:31:48 +08:00
void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
PR12086, PR15117 Introduce CXXStdInitializerListExpr node, representing the implicit construction of a std::initializer_list<T> object from its underlying array. The AST representation of such an expression goes from an InitListExpr with a flag set, to a CXXStdInitializerListExpr containing a MaterializeTemporaryExpr containing an InitListExpr (possibly wrapped in a CXXBindTemporaryExpr). This more detailed representation has several advantages, the most important of which is that the new MaterializeTemporaryExpr allows us to directly model lifetime extension of the underlying temporary array. Using that, this patch *drastically* simplifies the IR generation of this construct, provides IR generation support for nested global initializer_list objects, fixes several bugs where the destructors for the underlying array would accidentally not get invoked, and provides constant expression evaluation support for std::initializer_list objects. llvm-svn: 183872
2013-06-13 06:31:48 +08:00
Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitExplicitCastExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
Record.AddSourceRange(E->getAngleBrackets());
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_STATIC_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_DYNAMIC_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_REINTERPRET_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_CONST_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
VisitExplicitCastExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
}
[C++2a] Add __builtin_bit_cast, used to implement std::bit_cast This commit adds a new builtin, __builtin_bit_cast(T, v), which performs a bit_cast from a value v to a type T. This expression can be evaluated at compile time under specific circumstances. The compile time evaluation currently doesn't support bit-fields, but I'm planning on fixing this in a follow up (some of the logic for figuring this out is in CodeGen). I'm also planning follow-ups for supporting some more esoteric types that the constexpr evaluator supports, as well as extending __builtin_memcpy constexpr evaluation to use the same infrastructure. rdar://44987528 Differential revision: https://reviews.llvm.org/D62825 llvm-svn: 364954
2019-07-03 02:28:13 +08:00
void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
VisitExplicitCastExpr(E);
Record.AddSourceLocation(E->getBeginLoc());
Record.AddSourceLocation(E->getEndLoc());
}
AST representation for user-defined literals, plus just enough of semantic analysis to make the AST representation testable. They are represented by a new UserDefinedLiteral AST node, which is a sugared CallExpr. All semantic properties, including full CodeGen support, are achieved for free by this representation. UserDefinedLiterals can never be dependent, so no custom instantiation behavior is required. They are mangled as if they were direct calls to the underlying literal operator. This matches g++'s apparent behavior (but not its actual mangling, which is broken for literal-operator-ids). User-defined *string* literals are now fully-operational, but the semantic analysis is quite hacky and needs more work. No other forms of user-defined literal are created yet, but the AST support for them is present. This patch committed after midnight because we had already hit the quota for new kinds of literal yesterday. llvm-svn: 152211
2012-03-07 16:35:16 +08:00
void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
VisitCallExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->UDSuffixLoc);
AST representation for user-defined literals, plus just enough of semantic analysis to make the AST representation testable. They are represented by a new UserDefinedLiteral AST node, which is a sugared CallExpr. All semantic properties, including full CodeGen support, are achieved for free by this representation. UserDefinedLiterals can never be dependent, so no custom instantiation behavior is required. They are mangled as if they were direct calls to the underlying literal operator. This matches g++'s apparent behavior (but not its actual mangling, which is broken for literal-operator-ids). User-defined *string* literals are now fully-operational, but the semantic analysis is quite hacky and needs more work. No other forms of user-defined literal are created yet, but the AST support for them is present. This patch committed after midnight because we had already hit the quota for new kinds of literal yesterday. llvm-svn: 152211
2012-03-07 16:35:16 +08:00
Code = serialization::EXPR_USER_DEFINED_LITERAL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
VisitExpr(E);
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_BOOL_LITERAL;
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
if (E->isTypeOperand()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_TYPEID_TYPE;
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
} else {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getExprOperand());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_TYPEID_EXPR;
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
}
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getLocation());
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
Record.push_back(E->isImplicit());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_THIS;
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getThrowLoc());
Record.AddStmt(E->getSubExpr());
Properly implement the scope restriction on the NRVO for throw-expressions, such that we don't consider the NRVO when the non-volatile automatic object comes from outside the innermost try scope (C++0x [class.copymove]p13). In C++98/03, our ASTs were incorrect but it didn't matter because IR generation doesn't actually apply the NRVO here. In C++0x, however, we were moving from an object when in fact we should have copied from it. Fixes PR10142 / <rdar://problem/9714312>. llvm-svn: 134548
2011-07-07 06:04:06 +08:00
Record.push_back(E->isThrownVariableInScope());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_THROW;
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getParam());
Implement __builtin_LINE() et. al. to support source location capture. Summary: This patch implements the source location builtins `__builtin_LINE(), `__builtin_FUNCTION()`, `__builtin_FILE()` and `__builtin_COLUMN()`. These builtins are needed to implement [`std::experimental::source_location`](https://rawgit.com/cplusplus/fundamentals-ts/v2/main.html#reflection.src_loc.creation). With the exception of `__builtin_COLUMN`, GCC also implements these builtins, and Clangs behavior is intended to match as closely as possible. Reviewers: rsmith, joerg, aaron.ballman, bogner, majnemer, shafik, martong Reviewed By: rsmith Subscribers: rnkovacs, loskutov, riccibruno, mgorny, kunitoki, alexr, majnemer, hfinkel, cfe-commits Differential Revision: https://reviews.llvm.org/D37035 llvm-svn: 360937
2019-05-17 05:04:15 +08:00
Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getUsedLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_DEFAULT_ARG;
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
}
C++1y: Allow aggregates to have default initializers. Add a CXXDefaultInitExpr, analogous to CXXDefaultArgExpr, and use it both in CXXCtorInitializers and in InitListExprs to represent a default initializer. There's an additional complication here: because the default initializer can refer to the initialized object via its 'this' pointer, we need to make sure that 'this' points to the right thing within the evaluation. llvm-svn: 179958
2013-04-21 06:23:05 +08:00
void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getField());
Implement __builtin_LINE() et. al. to support source location capture. Summary: This patch implements the source location builtins `__builtin_LINE(), `__builtin_FUNCTION()`, `__builtin_FILE()` and `__builtin_COLUMN()`. These builtins are needed to implement [`std::experimental::source_location`](https://rawgit.com/cplusplus/fundamentals-ts/v2/main.html#reflection.src_loc.creation). With the exception of `__builtin_COLUMN`, GCC also implements these builtins, and Clangs behavior is intended to match as closely as possible. Reviewers: rsmith, joerg, aaron.ballman, bogner, majnemer, shafik, martong Reviewed By: rsmith Subscribers: rnkovacs, loskutov, riccibruno, mgorny, kunitoki, alexr, majnemer, hfinkel, cfe-commits Differential Revision: https://reviews.llvm.org/D37035 llvm-svn: 360937
2019-05-17 05:04:15 +08:00
Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getExprLoc());
C++1y: Allow aggregates to have default initializers. Add a CXXDefaultInitExpr, analogous to CXXDefaultArgExpr, and use it both in CXXCtorInitializers and in InitListExprs to represent a default initializer. There's an additional complication here: because the default initializer can refer to the initialized object via its 'this' pointer, we need to make sure that 'this' points to the right thing within the evaluation. llvm-svn: 179958
2013-04-21 06:23:05 +08:00
Code = serialization::EXPR_CXX_DEFAULT_INIT;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddCXXTemporary(E->getTemporary());
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_BIND_TEMPORARY;
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
VisitExpr(E);
[AST] Store some data of CXXNewExpr as trailing objects Store the optional array size expression, optional initialization expression and optional placement new arguments in a trailing array. Additionally store the range for the parenthesized type-id in a trailing object if needed since in the vast majority of cases the type is not parenthesized (not a single new expression in the translation unit of SemaDecl.cpp has a parenthesized type-id). This saves 2 pointers per CXXNewExpr in all cases, and 2 pointers + 8 bytes per CXXNewExpr in the common case where the type is not parenthesized. Differential Revision: https://reviews.llvm.org/D56134 Reviewed By: rjmccall llvm-svn: 350527
2019-01-07 23:04:45 +08:00
Revert "Make CXXNewExpr contain only a single initialier, and not hold the used constructor itself." It leads to a compiler crash in the Bullet benchmark. This reverts commit r12014. llvm-svn: 150684
2012-02-16 19:35:52 +08:00
Record.push_back(E->isArray());
[AST] Store some data of CXXNewExpr as trailing objects Store the optional array size expression, optional initialization expression and optional placement new arguments in a trailing array. Additionally store the range for the parenthesized type-id in a trailing object if needed since in the vast majority of cases the type is not parenthesized (not a single new expression in the translation unit of SemaDecl.cpp has a parenthesized type-id). This saves 2 pointers per CXXNewExpr in all cases, and 2 pointers + 8 bytes per CXXNewExpr in the common case where the type is not parenthesized. Differential Revision: https://reviews.llvm.org/D56134 Reviewed By: rjmccall llvm-svn: 350527
2019-01-07 23:04:45 +08:00
Record.push_back(E->hasInitializer());
Record.push_back(E->getNumPlacementArgs());
Record.push_back(E->isParenTypeId());
Record.push_back(E->isGlobalNew());
Re-commit r283722, reverted in r283750, with a fix for a CUDA-specific use of past-the-end iterator. Original commit message: P0035R4: Semantic analysis and code generation for C++17 overaligned allocation. llvm-svn: 283789
2016-10-11 02:54:32 +08:00
Record.push_back(E->passAlignment());
Revert "Revert "Make CXXNewExpr contain only a single initialier, and not hold the used constructor itself."" This reintroduces commit r150682 with a fix for the Bullet benchmark crash. llvm-svn: 150685
2012-02-16 20:22:20 +08:00
Record.push_back(E->doesUsualArrayDeleteWantSize());
[AST] Store some data of CXXNewExpr as trailing objects Store the optional array size expression, optional initialization expression and optional placement new arguments in a trailing array. Additionally store the range for the parenthesized type-id in a trailing object if needed since in the vast majority of cases the type is not parenthesized (not a single new expression in the translation unit of SemaDecl.cpp has a parenthesized type-id). This saves 2 pointers per CXXNewExpr in all cases, and 2 pointers + 8 bytes per CXXNewExpr in the common case where the type is not parenthesized. Differential Revision: https://reviews.llvm.org/D56134 Reviewed By: rjmccall llvm-svn: 350527
2019-01-07 23:04:45 +08:00
Record.push_back(E->CXXNewExprBits.StoredInitializationStyle);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getOperatorNew());
Record.AddDeclRef(E->getOperatorDelete());
Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
[AST] Store some data of CXXNewExpr as trailing objects Store the optional array size expression, optional initialization expression and optional placement new arguments in a trailing array. Additionally store the range for the parenthesized type-id in a trailing object if needed since in the vast majority of cases the type is not parenthesized (not a single new expression in the translation unit of SemaDecl.cpp has a parenthesized type-id). This saves 2 pointers per CXXNewExpr in all cases, and 2 pointers + 8 bytes per CXXNewExpr in the common case where the type is not parenthesized. Differential Revision: https://reviews.llvm.org/D56134 Reviewed By: rjmccall llvm-svn: 350527
2019-01-07 23:04:45 +08:00
if (E->isParenTypeId())
Record.AddSourceRange(E->getTypeIdParens());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Record.AddSourceRange(E->getDirectInitRange());
[AST] Store some data of CXXNewExpr as trailing objects Store the optional array size expression, optional initialization expression and optional placement new arguments in a trailing array. Additionally store the range for the parenthesized type-id in a trailing object if needed since in the vast majority of cases the type is not parenthesized (not a single new expression in the translation unit of SemaDecl.cpp has a parenthesized type-id). This saves 2 pointers per CXXNewExpr in all cases, and 2 pointers + 8 bytes per CXXNewExpr in the common case where the type is not parenthesized. Differential Revision: https://reviews.llvm.org/D56134 Reviewed By: rjmccall llvm-svn: 350527
2019-01-07 23:04:45 +08:00
for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*I);
Revert "Revert "Make CXXNewExpr contain only a single initialier, and not hold the used constructor itself."" This reintroduces commit r150682 with a fix for the Bullet benchmark crash. llvm-svn: 150685
2012-02-16 20:22:20 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_NEW;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-23 01:07:59 +08:00
VisitExpr(E);
Record.push_back(E->isGlobalDelete());
Record.push_back(E->isArrayForm());
When applying 'delete' on a pointer-to-array type match GCC and EDG behavior and treat it as 'delete[]'. Also offer a fix-it hint adding '[]'. llvm-svn: 113778
2010-09-14 04:15:54 +08:00
Record.push_back(E->isArrayFormAsWritten());
Do a proper recursive lookup when deciding whether a class's usual deallocation function has a two-argument form. Store the result of this check in new[] and delete[] nodes. Fixes rdar://problem/8913519 llvm-svn: 124373
2011-01-27 17:37:56 +08:00
Record.push_back(E->doesUsualArrayDeleteWantSize());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getOperatorDelete());
Record.AddStmt(E->getArgument());
[AST][NFC] Pack CXXDeleteExpr Use the newly available space in the bit-fields of Stmt. This saves 8 bytes per CXXDeleteExpr. NFC. llvm-svn: 348128
2018-12-03 20:32:32 +08:00
Record.AddSourceLocation(E->getBeginLoc());
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_DELETE;
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-23 01:07:59 +08:00
}
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
Record.push_back(E->isArrow());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Record.AddTypeSourceInfo(E->getScopeTypeInfo());
Record.AddSourceLocation(E->getColonColonLoc());
Record.AddSourceLocation(E->getTildeLoc());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
// PseudoDestructorTypeStorage.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
if (E->getDestroyedTypeIdentifier())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getDestroyedTypeLoc());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
else
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
}
Rename CXXExprWithTemporaries -> ExprWithCleanups; there's no theoretical reason this is limited to C++, and it's certainly not limited to temporaries. llvm-svn: 120996
2010-12-06 16:20:24 +08:00
void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
VisitExpr(E);
There's no good reason to track temporaries in ExprWithCleanups, but it is sometimes useful to track blocks. Do so. Also optimize the storage of these expressions. llvm-svn: 144263
2011-11-10 13:35:25 +08:00
Record.push_back(E->getNumObjects());
for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getObject(i));
Re-commit "[Temporary] Add an ExprWithCleanups for each C++ MaterializeTemporaryExpr." Since D21243 fixes relative clang-tidy tests. This reverts commit a71d9fbd41e99def9159af2b01ef6509394eaeed. llvm-svn: 273312
2016-06-22 04:29:17 +08:00
Record.push_back(E->cleanupsHaveSideEffects());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSubExpr());
Rename CXXExprWithTemporaries -> ExprWithCleanups; there's no theoretical reason this is limited to C++, and it's certainly not limited to temporaries. llvm-svn: 120996
2010-12-06 16:20:24 +08:00
Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
}
[AST] Pack CXXDependentScopeMemberExpr Use the newly available space in the bit-fields of Stmt. Additionally store FirstQualifierFoundInScope as a trailing object since it is most of the time null (non-null for 2 of the 35446 CXXDependentScopeMemberExpr when parsing all of Boost). It would be possible to move the data for the nested-name-specifier to a trailing object too to save another 2 pointers, however doing so did actually regress the time taken to parse all of Boost slightly. This saves 8 bytes + 1 pointer per CXXDependentScopeMemberExpr in the vast majority of cases. Differential Revision: https://reviews.llvm.org/D56367 Reviewed By: rjmccall llvm-svn: 350625
2019-01-08 22:17:00 +08:00
void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
CXXDependentScopeMemberExpr *E) {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
[AST] Pack CXXDependentScopeMemberExpr Use the newly available space in the bit-fields of Stmt. Additionally store FirstQualifierFoundInScope as a trailing object since it is most of the time null (non-null for 2 of the 35446 CXXDependentScopeMemberExpr when parsing all of Boost). It would be possible to move the data for the nested-name-specifier to a trailing object too to save another 2 pointers, however doing so did actually regress the time taken to parse all of Boost slightly. This saves 8 bytes + 1 pointer per CXXDependentScopeMemberExpr in the vast majority of cases. Differential Revision: https://reviews.llvm.org/D56367 Reviewed By: rjmccall llvm-svn: 350625
2019-01-08 22:17:00 +08:00
// Don't emit anything here (or if you do you will have to update
// the corresponding deserialization function).
Record.push_back(E->hasTemplateKWAndArgsInfo());
Record.push_back(E->getNumTemplateArgs());
Record.push_back(E->hasFirstQualifierFoundInScope());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
[AST] Pack CXXDependentScopeMemberExpr Use the newly available space in the bit-fields of Stmt. Additionally store FirstQualifierFoundInScope as a trailing object since it is most of the time null (non-null for 2 of the 35446 CXXDependentScopeMemberExpr when parsing all of Boost). It would be possible to move the data for the nested-name-specifier to a trailing object too to save another 2 pointers, however doing so did actually regress the time taken to parse all of Boost slightly. This saves 8 bytes + 1 pointer per CXXDependentScopeMemberExpr in the vast majority of cases. Differential Revision: https://reviews.llvm.org/D56367 Reviewed By: rjmccall llvm-svn: 350625
2019-01-08 22:17:00 +08:00
if (E->hasTemplateKWAndArgsInfo()) {
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
const ASTTemplateKWAndArgsInfo &ArgInfo =
*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
AddTemplateKWAndArgsInfo(ArgInfo,
E->getTrailingObjects<TemplateArgumentLoc>());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
}
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
[AST] Pack CXXDependentScopeMemberExpr Use the newly available space in the bit-fields of Stmt. Additionally store FirstQualifierFoundInScope as a trailing object since it is most of the time null (non-null for 2 of the 35446 CXXDependentScopeMemberExpr when parsing all of Boost). It would be possible to move the data for the nested-name-specifier to a trailing object too to save another 2 pointers, however doing so did actually regress the time taken to parse all of Boost slightly. This saves 8 bytes + 1 pointer per CXXDependentScopeMemberExpr in the vast majority of cases. Differential Revision: https://reviews.llvm.org/D56367 Reviewed By: rjmccall llvm-svn: 350625
2019-01-08 22:17:00 +08:00
Record.push_back(E->isArrow());
Record.AddSourceLocation(E->getOperatorLoc());
Record.AddTypeRef(E->getBaseType());
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
if (!E->isImplicitAccess())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
else
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(nullptr);
[AST] Pack CXXDependentScopeMemberExpr Use the newly available space in the bit-fields of Stmt. Additionally store FirstQualifierFoundInScope as a trailing object since it is most of the time null (non-null for 2 of the 35446 CXXDependentScopeMemberExpr when parsing all of Boost). It would be possible to move the data for the nested-name-specifier to a trailing object too to save another 2 pointers, however doing so did actually regress the time taken to parse all of Boost slightly. This saves 8 bytes + 1 pointer per CXXDependentScopeMemberExpr in the vast majority of cases. Differential Revision: https://reviews.llvm.org/D56367 Reviewed By: rjmccall llvm-svn: 350625
2019-01-08 22:17:00 +08:00
if (E->hasFirstQualifierFoundInScope())
Record.AddDeclRef(E->getFirstQualifierFoundInScope());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclarationNameInfo(E->MemberNameInfo);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
}
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
// Don't emit anything here, HasTemplateKWAndArgsInfo must be
Implement proper (de-)serialization for explicit template argument lists with zero template arguments. Fixes some seriously scary crashers in C++ PCH. llvm-svn: 124862
2011-02-04 20:01:24 +08:00
// emitted first.
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
[AST][NFC] Pack DependentScopeDeclRefExpr and CXXUnresolvedConstructExpr Use the newly available space in the bit-fields of Stmt. This saves 1 pointer per DependentScopeDeclRefExpr/CXXUnresolvedConstructExpr. Additionally rename "TypeSourceInfo *Type;" to "TypeSourceInfo *TSI;" as was done in D56022 (r350003) (but this is an internal detail anyway), and clang-format both classes. NFC. llvm-svn: 350525
2019-01-07 22:27:04 +08:00
Record.push_back(E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
const ASTTemplateKWAndArgsInfo &ArgInfo =
*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
Record.push_back(ArgInfo.NumTemplateArgs);
AddTemplateKWAndArgsInfo(ArgInfo,
E->getTrailingObjects<TemplateArgumentLoc>());
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
}
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Record.AddDeclarationNameInfo(E->NameInfo);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
}
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
VisitExpr(E);
Record.push_back(E->arg_size());
for (CXXUnresolvedConstructExpr::arg_iterator
ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(*ArgI);
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
}
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 17:46:47 +08:00
[AST] Store the results in OverloadExpr in a trailing array Use the newly available space in the bit-fields of Stmt to pack OverloadExpr, UnresolvedLookupExpr and UnresolvedMemberExpr. Additionally store the results in the overload set in a trailing array. This saves 1 pointer + 8 bytes per UnresolvedLookupExpr and UnresolvedMemberExpr. Differential Revision: https://reviews.llvm.org/D56368 Reviewed By: rjmccall llvm-svn: 350732
2019-01-09 23:43:19 +08:00
Record.push_back(E->getNumDecls());
Record.push_back(E->hasTemplateKWAndArgsInfo());
if (E->hasTemplateKWAndArgsInfo()) {
[TrailingObjects] Convert AST classes that had a ASTTemplateKWAndArgsInfo. So, also: - Moved the TemplateArgumentLoc array out of the ASTTemplateKWAndArgsInfo class (making it a simple fixed-size object), to avoid needing to have a variable-length object as part of a variable-length object. Now the objects that have a ASTTemplateKWAndArgsInfo also have some TemplateArgumentLoc objects appended directly. - Removed some internal-use accessors which became simply a wrapper on getTrailingObjects. - Moved MemberNameQualifier out of the MemberExpr class, renamed it MemberExprNameQualifier, because the template can't refer to a class nested within the class it's defining. llvm-svn: 256570
2015-12-30 02:15:14 +08:00
const ASTTemplateKWAndArgsInfo &ArgInfo =
*E->getTrailingASTTemplateKWAndArgsInfo();
Record.push_back(ArgInfo.NumTemplateArgs);
AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
}
[AST] Store the results in OverloadExpr in a trailing array Use the newly available space in the bit-fields of Stmt to pack OverloadExpr, UnresolvedLookupExpr and UnresolvedMemberExpr. Additionally store the results in the overload set in a trailing array. This saves 1 pointer + 8 bytes per UnresolvedLookupExpr and UnresolvedMemberExpr. Differential Revision: https://reviews.llvm.org/D56368 Reviewed By: rjmccall llvm-svn: 350732
2019-01-09 23:43:19 +08:00
for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
OvE = E->decls_end();
OvI != OvE; ++OvI) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(OvI.getDecl());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
Record.push_back(OvI.getAccess());
}
[AST] Store the results in OverloadExpr in a trailing array Use the newly available space in the bit-fields of Stmt to pack OverloadExpr, UnresolvedLookupExpr and UnresolvedMemberExpr. Additionally store the results in the overload set in a trailing array. This saves 1 pointer + 8 bytes per UnresolvedLookupExpr and UnresolvedMemberExpr. Differential Revision: https://reviews.llvm.org/D56368 Reviewed By: rjmccall llvm-svn: 350732
2019-01-09 23:43:19 +08:00
Record.AddDeclarationNameInfo(E->getNameInfo());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
VisitOverloadExpr(E);
Record.push_back(E->isArrow());
Record.push_back(E->hasUnresolvedUsing());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
Record.AddTypeRef(E->getBaseType());
Record.AddSourceLocation(E->getOperatorLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 17:03:34 +08:00
VisitOverloadExpr(E);
Record.push_back(E->requiresADL());
Record.push_back(E->isOverloaded());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getNamingClass());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 17:03:34 +08:00
}
Implement a new type trait __is_trivially_constructible(T, Args...) that provides the behavior of the C++11 library trait std::is_trivially_constructible<T, Args...>, which can't be implemented purely as a library. Since __is_trivially_constructible can have zero or more arguments, I needed to add Yet Another Type Trait Expression Class, this one handling arbitrary arguments. The next step will be to migrate UnaryTypeTrait and BinaryTypeTrait over to this new, more general TypeTrait class. Fixes the Clang side of <rdar://problem/10895483> / PR12038. llvm-svn: 151352
2012-02-24 15:38:34 +08:00
void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
VisitExpr(E);
Record.push_back(E->TypeTraitExprBits.NumArgs);
Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
Record.push_back(E->TypeTraitExprBits.Value);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Implement a new type trait __is_trivially_constructible(T, Args...) that provides the behavior of the C++11 library trait std::is_trivially_constructible<T, Args...>, which can't be implemented purely as a library. Since __is_trivially_constructible can have zero or more arguments, I needed to add Yet Another Type Trait Expression Class, this one handling arbitrary arguments. The next step will be to migrate UnaryTypeTrait and BinaryTypeTrait over to this new, more general TypeTrait class. Fixes the Clang side of <rdar://problem/10895483> / PR12038. llvm-svn: 151352
2012-02-24 15:38:34 +08:00
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getArg(I));
Implement a new type trait __is_trivially_constructible(T, Args...) that provides the behavior of the C++11 library trait std::is_trivially_constructible<T, Args...>, which can't be implemented purely as a library. Since __is_trivially_constructible can have zero or more arguments, I needed to add Yet Another Type Trait Expression Class, this one handling arbitrary arguments. The next step will be to migrate UnaryTypeTrait and BinaryTypeTrait over to this new, more general TypeTrait class. Fixes the Clang side of <rdar://problem/10895483> / PR12038. llvm-svn: 151352
2012-02-24 15:38:34 +08:00
Code = serialization::EXPR_TYPE_TRAIT;
}
Implementation of Embarcadero array type traits Patch authored by John Wiegley. These are array type traits used for parsing code that employs certain features of the Embarcadero C++ compiler: __array_rank(T) and __array_extent(T, Dim). llvm-svn: 130351
2011-04-28 08:16:57 +08:00
void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
VisitExpr(E);
Record.push_back(E->getTrait());
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
[ASTImporter] Implement some expression-related AST node import (part 2) * Some code cleanup * Add tests not present in http://reviews.llvm.org/D14286 * Integrate a test suite from Serge Pavlov (http://reviews.llvm.org/D14224) * ArrayTypeTraitExpr: serialize sub-expression to avoid keeping it undefined * Implement import of some nodes: - ArrayTypeTraitExpr - ExpressionTraitExpr - OpaqueValueExpr - ArraySubscriptExpr - ExplicitCastExpr - ImplicitValueInitExpr - OffsetOfExpr - CXXThisExpr - CXXThrowExpr - CXXNoexceptExpr - CXXDefaultArgExpr - CXXScalarValueInitExpr - CXXBindTemporaryExpr - CXXTemporaryObjectExpr - MaterializeTemporaryExpr - ExprWithCleanups - StaticAssertDecl - FriendDecl - DecayedType Differential Revision: https://reviews.llvm.org/D14326 llvm-svn: 282572
2016-09-28 18:16:56 +08:00
Record.AddStmt(E->getDimensionExpression());
Implementation of Embarcadero array type traits Patch authored by John Wiegley. These are array type traits used for parsing code that employs certain features of the Embarcadero C++ compiler: __array_rank(T) and __array_extent(T, Dim). llvm-svn: 130351
2011-04-28 08:16:57 +08:00
Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
}
t/clang/expr-traits Patch authored by David Abrahams. These two expression traits (__is_lvalue_expr, __is_rvalue_expr) are used for parsing code that employs certain features of the Embarcadero C++ compiler. llvm-svn: 130122
2011-04-25 14:54:41 +08:00
void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
VisitExpr(E);
Record.push_back(E->getTrait());
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Record.AddStmt(E->getQueriedExpression());
t/clang/expr-traits Patch authored by David Abrahams. These two expression traits (__is_lvalue_expr, __is_rvalue_expr) are used for parsing code that employs certain features of the Embarcadero C++ compiler. llvm-svn: 130122
2011-04-25 14:54:41 +08:00
Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
}
Serialization support for CXXNoexceptExpr. llvm-svn: 113627
2010-09-11 04:55:54 +08:00
void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
VisitExpr(E);
Record.push_back(E->getValue());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Record.AddStmt(E->getOperand());
Serialization support for CXXNoexceptExpr. llvm-svn: 113627
2010-09-11 04:55:54 +08:00
Code = serialization::EXPR_CXX_NOEXCEPT;
}
Implement support for pack expansions whose pattern is a non-type template argument (described by an expression, of course). For example: template<int...> struct int_tuple { }; template<int ...Values> struct square { typedef int_tuple<(Values*Values)...> type; }; It also lays the foundation for pack expansions in an initializer-list. llvm-svn: 122751
2011-01-04 01:17:50 +08:00
void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getEllipsisLoc());
Teach PackExpansionExpr to keep track of the number of pack expansions it will expand to, if known. Propagate this information throughout Sema. llvm-svn: 123470
2011-01-15 05:20:45 +08:00
Record.push_back(E->NumExpansions);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getPattern());
Implement support for pack expansions whose pattern is a non-type template argument (described by an expression, of course). For example: template<int...> struct int_tuple { }; template<int ...Values> struct square { typedef int_tuple<(Values*Values)...> type; }; It also lays the foundation for pack expansions in an initializer-list. llvm-svn: 122751
2011-01-04 01:17:50 +08:00
Code = serialization::EXPR_PACK_EXPANSION;
}
Implement the sizeof...(pack) expression to compute the length of a parameter pack. Note that we're missing proper libclang support for the new SizeOfPackExpr expression node. llvm-svn: 122813
2011-01-05 01:33:58 +08:00
void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
VisitExpr(E);
PR14858: Initial support for proper sizeof... handling within alias templates. This doesn't quite get alias template equivalence right yet, but handles the egregious cases where we would silently give the wrong answers. llvm-svn: 248431
2015-09-24 05:41:42 +08:00
Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
: 0);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->OperatorLoc);
Record.AddSourceLocation(E->PackLoc);
Record.AddSourceLocation(E->RParenLoc);
Record.AddDeclRef(E->Pack);
PR14858: Initial support for proper sizeof... handling within alias templates. This doesn't quite get alias template equivalence right yet, but handles the egregious cases where we would silently give the wrong answers. llvm-svn: 248431
2015-09-24 05:41:42 +08:00
if (E->isPartiallySubstituted()) {
for (const auto &TA : E->getPartialArguments())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTemplateArgument(TA);
PR14858: Initial support for proper sizeof... handling within alias templates. This doesn't quite get alias template equivalence right yet, but handles the egregious cases where we would silently give the wrong answers. llvm-svn: 248431
2015-09-24 05:41:42 +08:00
} else if (!E->isValueDependent()) {
Record.push_back(E->getPackLength());
}
Implement the sizeof...(pack) expression to compute the length of a parameter pack. Note that we're missing proper libclang support for the new SizeOfPackExpr expression node. llvm-svn: 122813
2011-01-05 01:33:58 +08:00
Code = serialization::EXPR_SIZEOF_PACK;
}
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
SubstNonTypeTemplateParmExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getParameter());
Record.AddSourceLocation(E->getNameLoc());
Record.AddStmt(E->getReplacement());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
}
Introduce a new expression kind, SubstNonTypeTemplateParmPackExpr, that captures the substitution of a non-type template argument pack for a non-type template parameter pack within a pack expansion that cannot be fully expanded. This follows the approach taken by SubstTemplateTypeParmPackType. llvm-svn: 123506
2011-01-15 09:15:58 +08:00
void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
SubstNonTypeTemplateParmPackExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getParameterPack());
Record.AddTemplateArgument(E->getArgumentPack());
Record.AddSourceLocation(E->getParameterPackLocation());
Introduce a new expression kind, SubstNonTypeTemplateParmPackExpr, that captures the substitution of a non-type template argument pack for a non-type template parameter pack within a pack expansion that cannot be fully expanded. This follows the approach taken by SubstTemplateTypeParmPackType. llvm-svn: 123506
2011-01-15 09:15:58 +08:00
Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
}
PR13811: Add a FunctionParmPackExpr node to handle references to function parameter packs where the reference is not being expanded but the pack has been. Previously, Clang would segfault in such cases. llvm-svn: 163672
2012-09-12 08:56:43 +08:00
void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
VisitExpr(E);
Record.push_back(E->getNumExpansions());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(E->getParameterPack());
Record.AddSourceLocation(E->getParameterPackLocation());
PR13811: Add a FunctionParmPackExpr node to handle references to function parameter packs where the reference is not being expanded but the pack has been. Previously, Clang would segfault in such cases. llvm-svn: 163672
2012-09-12 08:56:43 +08:00
for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
I != End; ++I)
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclRef(*I);
PR13811: Add a FunctionParmPackExpr node to handle references to function parameter packs where the reference is not being expanded but the pack has been. Previously, Clang would segfault in such cases. llvm-svn: 163672
2012-09-12 08:56:43 +08:00
Code = serialization::EXPR_FUNCTION_PARM_PACK;
}
Introduce a new AST node describing reference binding to temporaries. MaterializeTemporaryExpr captures a reference binding to a temporary value, making explicit that the temporary value (a prvalue) needs to be materialized into memory so that its address can be used. The intended AST invariant here is that a reference will always bind to a glvalue, and MaterializeTemporaryExpr will be used to convert prvalues into glvalues for that binding to happen. For example, given const int& r = 1.0; The initializer of "r" will be a MaterializeTemporaryExpr whose subexpression is an implicit conversion from the double literal "1.0" to an integer value. IR generation benefits most from this new node, since it was previously guessing (badly) when to materialize temporaries for the purposes of reference binding. There are likely more refactoring and cleanups we could perform there, but the introduction of MaterializeTemporaryExpr fixes PR9565, a case where IR generation would effectively bind a const reference directly to a bitfield in a struct. Addresses <rdar://problem/9552231>. llvm-svn: 133521
2011-06-22 01:03:29 +08:00
void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getTemporary());
Record.AddDeclRef(E->getExtendingDecl());
AST: Mangle reference temporaries reliably Summary: Previously, we would generate a single name for all reference temporaries and allow LLVM to rename them for us. Instead, number the reference temporaries as we build them in Sema. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D3554 llvm-svn: 207776
2014-05-02 01:50:17 +08:00
Record.push_back(E->getManglingNumber());
Introduce a new AST node describing reference binding to temporaries. MaterializeTemporaryExpr captures a reference binding to a temporary value, making explicit that the temporary value (a prvalue) needs to be materialized into memory so that its address can be used. The intended AST invariant here is that a reference will always bind to a glvalue, and MaterializeTemporaryExpr will be used to convert prvalues into glvalues for that binding to happen. For example, given const int& r = 1.0; The initializer of "r" will be a MaterializeTemporaryExpr whose subexpression is an implicit conversion from the double literal "1.0" to an integer value. IR generation benefits most from this new node, since it was previously guessing (badly) when to materialize temporaries for the purposes of reference binding. There are likely more refactoring and cleanups we could perform there, but the introduction of MaterializeTemporaryExpr fixes PR9565, a case where IR generation would effectively bind a const reference directly to a bitfield in a struct. Addresses <rdar://problem/9552231>. llvm-svn: 133521
2011-06-22 01:03:29 +08:00
Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
}
[c++1z] N4295: fold-expressions. This is a new form of expression of the form: (expr op ... op expr) where one of the exprs is a parameter pack. It expands into (expr1 op (expr2onwards op ... op expr)) (and likewise if the pack is on the right). The non-pack operand can be omitted; in that case, an empty pack gives a fallback value or an error, depending on the operator. llvm-svn: 221573
2014-11-08 13:07:16 +08:00
void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->LParenLoc);
Record.AddSourceLocation(E->EllipsisLoc);
Record.AddSourceLocation(E->RParenLoc);
PR41845: Detect and reject mismatched inner/outer pack expansion sizes in fold expressions rather than crashing. llvm-svn: 360563
2019-05-13 16:31:14 +08:00
Record.push_back(E->NumExpansions);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->SubExprs[0]);
Record.AddStmt(E->SubExprs[1]);
[c++1z] N4295: fold-expressions. This is a new form of expression of the form: (expr op ... op expr) where one of the exprs is a parameter pack. It expands into (expr1 op (expr2onwards op ... op expr)) (and likewise if the pack is on the right). The non-pack operand can be omitted; in that case, an empty pack gives a fallback value or an error, depending on the operator. llvm-svn: 221573
2014-11-08 13:07:16 +08:00
Record.push_back(E->Opcode);
Code = serialization::EXPR_CXX_FOLD;
}
Add a new expression kind, OpaqueValueExpr, which is useful for certain internal type-checking procedures as well as for representing certain implicitly-generated operations. Uses to follow. llvm-svn: 119289
2010-11-16 07:31:06 +08:00
void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getSourceExpr());
Record.AddSourceLocation(E->getLocation());
[CodeGen] Ignore OpaqueValueExprs that are unique references to their source expressions when iterating over a PseudoObjectExpr's semantic subexpression list. Previously the loop in emitPseudoObjectExpr would emit the IR for each OpaqueValueExpr that was in a PseudoObjectExpr's semantic-form expression list and use the result when the OpaqueValueExpr later appeared in other expressions. This caused an assertion failure when AggExprEmitter tried to copy the result of an OpaqueValueExpr and the copied type didn't have trivial copy/move constructors or assignment operators. This patch adds flag IsUnique to OpaqueValueExpr which indicates it is a unique reference to its source expression (it is not used in multiple places). The loop in emitPseudoObjectExpr ignores OpaqueValueExprs that are unique and CodeGen visitors simply traverse the source expressions of such OpaqueValueExprs. rdar://problem/34363596 Differential Revision: https://reviews.llvm.org/D39562 llvm-svn: 327939
2018-03-20 09:47:58 +08:00
Record.push_back(E->isUnique());
Add a new expression kind, OpaqueValueExpr, which is useful for certain internal type-checking procedures as well as for representing certain implicitly-generated operations. Uses to follow. llvm-svn: 119289
2010-11-16 07:31:06 +08:00
Code = serialization::EXPR_OPAQUE_VALUE;
}
Add the initial TypoExpr AST node for delayed typo correction. llvm-svn: 220692
2014-10-28 02:07:20 +08:00
void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
VisitExpr(E);
// TODO: Figure out sane writer behavior for a TypoExpr, if necessary
assert(false) -> llvm_unreachable(). llvm-svn: 259302
2016-01-30 16:03:54 +08:00
llvm_unreachable("Cannot write TypoExpr nodes");
Add the initial TypoExpr AST node for delayed typo correction. llvm-svn: 220692
2014-10-28 02:07:20 +08:00
}
AST, Sema, Serialization: add CUDAKernelCallExpr and related semantic actions llvm-svn: 125217
2011-02-10 05:07:24 +08:00
//===----------------------------------------------------------------------===//
// CUDA Expressions and Statements.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
VisitCallExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getConfig());
AST, Sema, Serialization: add CUDAKernelCallExpr and related semantic actions llvm-svn: 125217
2011-02-10 05:07:24 +08:00
Code = serialization::EXPR_CUDA_KERNEL_CALL;
}
Add support for builtin astype: __builtin_astype(): Used to reinterpreted as another data type of the same size using for both scalar and vector data types. Added test case. llvm-svn: 132612
2011-06-04 08:47:47 +08:00
//===----------------------------------------------------------------------===//
// OpenCL Expressions and Statements.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Record.AddStmt(E->getSrcExpr());
Add support for builtin astype: __builtin_astype(): Used to reinterpreted as another data type of the same size using for both scalar and vector data types. Added test case. llvm-svn: 132612
2011-06-04 08:47:47 +08:00
Code = serialization::EXPR_ASTYPE;
}
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
//===----------------------------------------------------------------------===//
// Microsoft Expressions and Statements.
//===----------------------------------------------------------------------===//
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
VisitExpr(E);
Record.push_back(E->isArrow());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBaseExpr());
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Record.AddSourceLocation(E->getMemberLoc());
Record.AddDeclRef(E->getPropertyDecl());
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
}
[MSVC] 'property' with an empty array in array subscript expression. MSVC supports 'property' attribute and allows to apply it to the declaration of an empty array in a class or structure definition. For example: ``` __declspec(property(get=GetX, put=PutX)) int x[]; ``` The above statement indicates that x[] can be used with one or more array indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and p->x[a][b] = i will be turned into p->PutX(a, b, i); Differential Revision: http://reviews.llvm.org/D13336 llvm-svn: 254067
2015-11-25 20:01:00 +08:00
void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getBase());
Record.AddStmt(E->getIdx());
Record.AddSourceLocation(E->getRBracketLoc());
[MSVC] 'property' with an empty array in array subscript expression. MSVC supports 'property' attribute and allows to apply it to the declaration of an empty array in a class or structure definition. For example: ``` __declspec(property(get=GetX, put=PutX)) int x[]; ``` The above statement indicates that x[] can be used with one or more array indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and p->x[a][b] = i will be turned into p->PutX(a, b, i); Differential Revision: http://reviews.llvm.org/D13336 llvm-svn: 254067
2015-11-25 20:01:00 +08:00
Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
}
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
VisitExpr(E);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceRange(E->getSourceRange());
Record.AddString(E->getUuidStr());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
if (E->isTypeOperand()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::EXPR_CXX_UUIDOF_TYPE;
} else {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getExprOperand());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::EXPR_CXX_UUIDOF_EXPR;
}
}
void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getExceptLoc());
Record.AddStmt(S->getFilterExpr());
Record.AddStmt(S->getBlock());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::STMT_SEH_EXCEPT;
}
void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getFinallyLoc());
Record.AddStmt(S->getBlock());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::STMT_SEH_FINALLY;
}
void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
VisitStmt(S);
Record.push_back(S->getIsCXXTry());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getTryLoc());
Record.AddStmt(S->getTryBlock());
Record.AddStmt(S->getHandler());
Add serialization support for SubstNonTypeTemplateParmExpr. Also add the missing serialization support for SEHTryStmt, SEHFinallyStmt, and SEHExceptStmt, and fix and finish the serialization support for AsTypeExpr. In addition, change the code so that it will no longer link if a Stmt subclass is missing serialization support. llvm-svn: 135258
2011-07-15 15:00:14 +08:00
Code = serialization::STMT_SEH_TRY;
}
Add an AST node for __leave statements, hook it up. Codegen is still missing (and I won't work on that), but __leave is now as implemented as __try and friends. llvm-svn: 212425
2014-07-07 08:12:30 +08:00
void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
VisitStmt(S);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddSourceLocation(S->getLeaveLoc());
Add an AST node for __leave statements, hook it up. Codegen is still missing (and I won't work on that), but __leave is now as implemented as __try and friends. llvm-svn: 212425
2014-07-07 08:12:30 +08:00
Code = serialization::STMT_SEH_LEAVE;
}
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
//===----------------------------------------------------------------------===//
// OpenMP Directives.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
Port getLocStart -> getBeginLoc Reviewers: teemperor! Subscribers: jholewinski, whisperity, jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D50350 llvm-svn: 339385
2018-08-10 05:08:08 +08:00
Record.AddSourceLocation(E->getBeginLoc());
Port getLocEnd -> getEndLoc Reviewers: teemperor! Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50351 llvm-svn: 339386
2018-08-10 05:09:38 +08:00
Record.AddSourceLocation(E->getEndLoc());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
OMPClauseWriter ClauseWriter(Record);
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
for (unsigned i = 0; i < E->getNumClauses(); ++i) {
ClauseWriter.writeClause(E->getClause(i));
}
[OPENMP] Initial parsing and sema analysis of 'taskyield' directive. llvm-svn: 213355
2014-07-18 15:47:19 +08:00
if (E->hasAssociatedStmt())
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(E->getAssociatedStmt());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
}
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
[OPENMP] First changes for Parsing and Sema for 'omp simd' directive support llvm-svn: 202360
2014-02-27 16:29:12 +08:00
VisitStmt(D);
Record.push_back(D->getNumClauses());
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
Record.push_back(D->getCollapsedNumber());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
VisitOMPExecutableDirective(D);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(D->getIterationVariable());
Record.AddStmt(D->getLastIteration());
Record.AddStmt(D->getCalcLastIteration());
Record.AddStmt(D->getPreCond());
Record.AddStmt(D->getCond());
Record.AddStmt(D->getInit());
Record.AddStmt(D->getInc());
Record.AddStmt(D->getPreInits());
[OPENMP] Improved handling of pseudo-captured expressions in OpenMP. Expressions inside 'schedule'|'dist_schedule' clause must be captured in combined directives to avoid possible crash during codegen. Patch improves handling of such constructs llvm-svn: 260954
2016-02-16 19:18:12 +08:00
if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
Reapply r262741 [OPENMP] Codegen for distribute directive This patch provide basic implementation of codegen for teams directive, excluding all clauses except dist_schedule. It also fixes parts of AST reader/writer to enable correct pre-compiled header handling. http://reviews.llvm.org/D17170 llvm-svn: 262832
2016-03-08 00:04:49 +08:00
isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
isOpenMPDistributeDirective(D->getDirectiveKind())) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(D->getIsLastIterVariable());
Record.AddStmt(D->getLowerBoundVariable());
Record.AddStmt(D->getUpperBoundVariable());
Record.AddStmt(D->getStrideVariable());
Record.AddStmt(D->getEnsureUpperBound());
Record.AddStmt(D->getNextLowerBound());
Record.AddStmt(D->getNextUpperBound());
[OPENMP 4.5] Codegen for dacross loop synchronization constructs. OpenMP 4.5 adds support for doacross loop synchronization. Patch implements codegen for this construct. llvm-svn: 270690
2016-05-25 20:36:08 +08:00
Record.AddStmt(D->getNumIterations());
First patch with codegen of the 'omp for' directive. It implements the simplest case, which is used when no chunk_size is specified in the schedule(static) or no 'schedule' clause is specified - the iteration space is divided by the library into chunks that are approximately equal in size, and at most one chunk is distributed to each thread. In this case, we do not need an outer loop in each thread - each thread requests once which iterations range it should handle (using __kmpc_for_static_init runtime call) and then runs the inner loop on this range. Differential Revision: http://reviews.llvm.org/D5865 llvm-svn: 224233
2014-12-15 15:07:06 +08:00
}
Resubmission of http://reviews.llvm.org/D21564 after fixes. [OpenMP] Initial implementation of parse and sema for composite pragma 'distribute parallel for' This patch is an initial implementation for #distribute parallel for. The main differences that affect other pragmas are: The implementation of 'distribute parallel for' requires blocking of the associated loop, where blocks are "distributed" to different teams and iterations within each block are scheduled to parallel threads within each team. To implement blocking, sema creates two additional worksharing directive fields that are used to pass the team assigned block lower and upper bounds through the outlined function resulting from 'parallel'. In this way, scheduling for 'for' to threads can use those bounds. As a consequence of blocking, the stride of 'distribute' is not 1 but it is equal to the blocking size. This is returned by the runtime and sema prepares a DistIncrExpr variable to hold that value. As a consequence of blocking, the global upper bound (EnsureUpperBound) expression of the 'for' is not the original loop upper bound (e.g. in for(i = 0 ; i < N; i++) this is 'N') but it is the team-assigned block upper bound. Sema creates a new expression holding the calculation of the actual upper bound for 'for' as UB = min(UB, PrevUB), where UB is the loop upper bound, and PrevUB is the team-assigned block upper bound. llvm-svn: 273884
2016-06-27 22:55:37 +08:00
if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
Record.AddStmt(D->getPrevLowerBoundVariable());
Record.AddStmt(D->getPrevUpperBoundVariable());
[OpenMP] Prepare Sema for initial implementation for pragma 'distribute parallel for' https://reviews.llvm.org/D29922 This patch adds two fields for use in the implementation of 'distribute parallel for': The increment expression for the distribute loop. As the chunk assigned to a team is executed by multiple threads within the 'parallel for' region, the increment expression has to correspond to the value returned by the related runtime call (for_static_init). The upper bound of the innermost loop ('for' in 'distribute parallel for') is not the globalUB expression normally used for pragma 'for' when found in isolation. It is instead the upper bound of the chunk assigned to the team ('distribute' loop). In this way, we prevent teams from executing chunks assigned to other teams. The use of these two fields can be see in a related explanatory patch: https://reviews.llvm.org/D29508 llvm-svn: 295497
2017-02-18 05:29:13 +08:00
Record.AddStmt(D->getDistInc());
Record.AddStmt(D->getPrevEnsureUpperBound());
[OpenMP] Prepare sema to support combined constructs with omp distribute and omp for https://reviews.llvm.org/D32237 This patch prepares sema with additional fields to support all those composite and combined constructs of OpenMP that include pragma 'distribute' and 'for', such as 'distribute parallel for'. It also extends the regression tests for 'distribute parallel for' and adds a new one. llvm-svn: 300802
2017-04-20 08:39:39 +08:00
Record.AddStmt(D->getCombinedLowerBoundVariable());
Record.AddStmt(D->getCombinedUpperBoundVariable());
Record.AddStmt(D->getCombinedEnsureUpperBound());
Record.AddStmt(D->getCombinedInit());
Record.AddStmt(D->getCombinedCond());
Record.AddStmt(D->getCombinedNextLowerBound());
Record.AddStmt(D->getCombinedNextUpperBound());
[OpenMP][NVPTX] Use single loops when generating code for distribute parallel for Summary: This patch adds a new code generation path for bound sharing directives containing distribute parallel for. The new code generation scheme applies to chunked schedules on distribute and parallel for directives. The scheme simplifies the code that is being generated by eliminating the need for an outer for loop over chunks for both distribute and parallel for directives. In the case of distribute it applies to any sized chunk while in the parallel for case it only applies when chunk size is 1. Reviewers: ABataev, caomhin Reviewed By: ABataev Subscribers: jholewinski, guansong, cfe-commits Differential Revision: https://reviews.llvm.org/D53448 llvm-svn: 345509
2018-10-29 23:45:47 +08:00
Record.AddStmt(D->getCombinedDistCond());
Record.AddStmt(D->getCombinedParForInDistCond());
Resubmission of http://reviews.llvm.org/D21564 after fixes. [OpenMP] Initial implementation of parse and sema for composite pragma 'distribute parallel for' This patch is an initial implementation for #distribute parallel for. The main differences that affect other pragmas are: The implementation of 'distribute parallel for' requires blocking of the associated loop, where blocks are "distributed" to different teams and iterations within each block are scheduled to parallel threads within each team. To implement blocking, sema creates two additional worksharing directive fields that are used to pass the team assigned block lower and upper bounds through the outlined function resulting from 'parallel'. In this way, scheduling for 'for' to threads can use those bounds. As a consequence of blocking, the stride of 'distribute' is not 1 but it is equal to the blocking size. This is returned by the runtime and sema prepares a DistIncrExpr variable to hold that value. As a consequence of blocking, the global upper bound (EnsureUpperBound) expression of the 'for' is not the original loop upper bound (e.g. in for(i = 0 ; i < N; i++) this is 'N') but it is the team-assigned block upper bound. Sema creates a new expression holding the calculation of the actual upper bound for 'for' as UB = min(UB, PrevUB), where UB is the loop upper bound, and PrevUB is the team-assigned block upper bound. llvm-svn: 273884
2016-06-27 22:55:37 +08:00
}
[OPENMP] Loop collapsing and codegen for 'omp simd' directive. This patch implements collapsing of the loops (in particular, in presense of clause 'collapse'). It calculates number of iterations N and expressions nesessary to calculate the nested loops counters values based on new iteration variable (that goes from 0 to N-1) in Sema. It also adds Codegen for 'omp simd', which uses (and tests) this feature. Differential Revision: http://reviews.llvm.org/D5184 llvm-svn: 218743
2014-10-01 14:03:56 +08:00
for (auto I : D->counters()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
[OPENMP] Loop collapsing and codegen for 'omp simd' directive. This patch implements collapsing of the loops (in particular, in presense of clause 'collapse'). It calculates number of iterations N and expressions nesessary to calculate the nested loops counters values based on new iteration variable (that goes from 0 to N-1) in Sema. It also adds Codegen for 'omp simd', which uses (and tests) this feature. Differential Revision: http://reviews.llvm.org/D5184 llvm-svn: 218743
2014-10-01 14:03:56 +08:00
}
[OPENMP 4.1] Allow references in init expression for loop-based constructs. OpenMP 4.1 allows to use variables with reference types in private clauses and, therefore, in init expressions of the cannonical loop forms. llvm-svn: 244209
2015-08-06 20:30:57 +08:00
for (auto I : D->private_counters()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
[OPENMP 4.1] Allow references in init expression for loop-based constructs. OpenMP 4.1 allows to use variables with reference types in private clauses and, therefore, in init expressions of the cannonical loop forms. llvm-svn: 244209
2015-08-06 20:30:57 +08:00
}
[OPENMP] Fix for http://llvm.org/PR24371: Assert failure compiling blender 2.75. blender uses statements expression in condition of the loop under control of the '#pragma omp parallel for'. This condition is used several times in different expressions required for codegen of the loop directive. If there are some variables defined in statement expression, it fires an assert during codegen because of redefinition of the same variables. We have to rebuild several expression to be sure that all variables are unique. llvm-svn: 245041
2015-08-14 20:25:37 +08:00
for (auto I : D->inits()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
[OPENMP] Fix for http://llvm.org/PR24371: Assert failure compiling blender 2.75. blender uses statements expression in condition of the loop under control of the '#pragma omp parallel for'. This condition is used several times in different expressions required for codegen of the loop directive. If there are some variables defined in statement expression, it fires an assert during codegen because of redefinition of the same variables. We have to rebuild several expression to be sure that all variables are unique. llvm-svn: 245041
2015-08-14 20:25:37 +08:00
}
[OPENMP] Loop collapsing and codegen for 'omp simd' directive. This patch implements collapsing of the loops (in particular, in presense of clause 'collapse'). It calculates number of iterations N and expressions nesessary to calculate the nested loops counters values based on new iteration variable (that goes from 0 to N-1) in Sema. It also adds Codegen for 'omp simd', which uses (and tests) this feature. Differential Revision: http://reviews.llvm.org/D5184 llvm-svn: 218743
2014-10-01 14:03:56 +08:00
for (auto I : D->updates()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
[OPENMP] Loop collapsing and codegen for 'omp simd' directive. This patch implements collapsing of the loops (in particular, in presense of clause 'collapse'). It calculates number of iterations N and expressions nesessary to calculate the nested loops counters values based on new iteration variable (that goes from 0 to N-1) in Sema. It also adds Codegen for 'omp simd', which uses (and tests) this feature. Differential Revision: http://reviews.llvm.org/D5184 llvm-svn: 218743
2014-10-01 14:03:56 +08:00
}
for (auto I : D->finals()) {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(I);
[OPENMP] Loop collapsing and codegen for 'omp simd' directive. This patch implements collapsing of the loops (in particular, in presense of clause 'collapse'). It calculates number of iterations N and expressions nesessary to calculate the nested loops counters values based on new iteration variable (that goes from 0 to N-1) in Sema. It also adds Codegen for 'omp simd', which uses (and tests) this feature. Differential Revision: http://reviews.llvm.org/D5184 llvm-svn: 218743
2014-10-01 14:03:56 +08:00
}
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
}
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
[OPENMP] First changes for Parsing and Sema for 'omp simd' directive support llvm-svn: 202360
2014-02-27 16:29:12 +08:00
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
}
void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP] First changes for Parsing and Sema for 'omp simd' directive support llvm-svn: 202360
2014-02-27 16:29:12 +08:00
Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
}
[OPENMP] Initial support for '#pragma omp for' (fixed incompatibility with MSVC). llvm-svn: 211140
2014-06-18 12:14:57 +08:00
void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
VisitOMPLoopDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Initial support for '#pragma omp for' (fixed incompatibility with MSVC). llvm-svn: 211140
2014-06-18 12:14:57 +08:00
Code = serialization::STMT_OMP_FOR_DIRECTIVE;
}
Parsing/Sema of directive omp for simd llvm-svn: 218029
2014-09-18 13:12:34 +08:00
void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
}
[OPENMP] Initial support for 'sections' directive. llvm-svn: 211685
2014-06-25 19:44:49 +08:00
void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Initial support for 'sections' directive. llvm-svn: 211685
2014-06-25 19:44:49 +08:00
Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'section' directive. llvm-svn: 211767
2014-06-26 16:21:58 +08:00
void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Initial parsing and sema analysis for 'section' directive. llvm-svn: 211767
2014-06-26 16:21:58 +08:00
Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'single' directive. llvm-svn: 211774
2014-06-26 20:05:45 +08:00
void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
}
[OPENMP] Parsing/Sema analysis of directive 'master' llvm-svn: 213237
2014-07-17 16:54:58 +08:00
void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
}
[OPENMP] Parsing/Sema of the OpenMP directive 'critical'. llvm-svn: 213510
2014-07-21 17:42:05 +08:00
void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
VisitStmt(D);
[OPENMP 4.5] Parsing/sema for 'hint' clause of 'critical' directive. OpenMP 4.5 adds 'hint' clause to critical directive. Patch adds parsing/semantic analysis for this clause. llvm-svn: 255625
2015-12-15 16:19:24 +08:00
Record.push_back(D->getNumClauses());
[OPENMP] Parsing/Sema of the OpenMP directive 'critical'. llvm-svn: 213510
2014-07-21 17:42:05 +08:00
VisitOMPExecutableDirective(D);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddDeclarationNameInfo(D->getDirectiveName());
[OPENMP] Parsing/Sema of the OpenMP directive 'critical'. llvm-svn: 213510
2014-07-21 17:42:05 +08:00
Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
}
[OPENMP] Added initial support for 'omp parallel for'. llvm-svn: 212453
2014-07-07 21:01:15 +08:00
void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
[OPENMP] Extract common superclass from all the loop directives. No functional changes (having common superclass is convenient for future loop directives CodeGen implementation) llvm-svn: 215975
2014-08-19 19:27:13 +08:00
VisitOMPLoopDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Added initial support for 'omp parallel for'. llvm-svn: 212453
2014-07-07 21:01:15 +08:00
Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
}
[OPENMP] Parsing/Sema of directive omp parallel for simd llvm-svn: 218299
2014-09-23 17:33:00 +08:00
void ASTStmtWriter::VisitOMPParallelForSimdDirective(
OMPParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
}
[OPENMP] Parsing and sema analysis for 'omp parallel sections' directive. llvm-svn: 212516
2014-07-08 16:12:03 +08:00
void ASTStmtWriter::VisitOMPParallelSectionsDirective(
OMPParallelSectionsDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Parsing and sema analysis for 'omp parallel sections' directive. llvm-svn: 212516
2014-07-08 16:12:03 +08:00
Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
}
[OPENMP] Parsing and sema analysis for 'omp task' directive. llvm-svn: 212804
2014-07-11 19:25:16 +08:00
void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
[OPENMP] Emit __kmpc_cancel_barrier() and code for 'cancellation point' only if 'cancel' is found. Patch improves codegen for OpenMP constructs. If the OpenMP region does not have internal 'cancel' construct, a call to 'void __kmpc_barrier()' runtime function is generated for all implicit/explicit barriers. If the region has inner 'cancel' directive, then ``` if (__kmpc_cancel_barrier()) exit from outer construct; ``` code is generated. Also, the code for 'canellation point' directive is not generated if parent directive does not have 'cancel' directive. llvm-svn: 247681
2015-09-15 20:52:43 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OPENMP] Parsing and sema analysis for 'omp task' directive. llvm-svn: 212804
2014-07-11 19:25:16 +08:00
Code = serialization::STMT_OMP_TASK_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'atomic' directive. llvm-svn: 213639
2014-07-22 18:10:35 +08:00
void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Record.AddStmt(D->getX());
Record.AddStmt(D->getV());
Record.AddStmt(D->getExpr());
Record.AddStmt(D->getUpdateExpr());
[OPENMP] Codegen for 'atomic update' construct. Adds atomic update codegen for the following forms of expressions: x binop= expr; x++; ++x; x--; --x; x = x binop expr; x = expr binop x; If x and expr are integer and binop is associative or x is a LHS in a RHS of the assignment expression, and atomics are allowed for type of x on the target platform atomicrmw instruction is emitted. Otherwise compare-and-swap sequence is emitted: bb: ... atomic load <x> cont: <expected> = phi [ <x>, label %bb ], [ <new_failed>, %cont ] <desired> = <expected> binop <expr> <res> = cmpxchg atomic &<x>, desired, expected <new_failed> = <res>.field1; br <res>field2, label %exit, label %cont exit: ... Differential Revision: http://reviews.llvm.org/D8536 llvm-svn: 233513
2015-03-30 13:20:59 +08:00
Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
[OPENMP] Sema analysis for 'atomic capture' construct. Added sema checks for forms of expressions/statements allowed under control of 'atomic capture' directive + generation of helper objects for future codegen. llvm-svn: 233785
2015-04-01 11:33:17 +08:00
Record.push_back(D->isPostfixUpdate() ? 1 : 0);
[OPENMP] Initial parsing and sema analysis for 'atomic' directive. llvm-svn: 213639
2014-07-22 18:10:35 +08:00
Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
}
[OPENMP] Initial parsing/sema analysis of 'target' directive. llvm-svn: 218110
2014-09-19 16:19:49 +08:00
void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
}
Commit for http://reviews.llvm.org/D10765 for OpenMP 4 target data directive parsing and sema. This commit is on behalf of Kelvin Li. llvm-svn: 242785
2015-07-21 21:44:28 +08:00
void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
[OpenMP] Parsing + sema for "target enter data" directive. Patch by Arpith Jacob. Thanks! llvm-svn: 258165
2016-01-20 03:15:56 +08:00
}
void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
OMPTargetEnterDataDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
[OpenMP] Parsing + sema for "target exit data" directive. Patch by Arpith Jacob. Thanks! llvm-svn: 258177
2016-01-20 04:04:50 +08:00
}
void ASTStmtWriter::VisitOMPTargetExitDataDirective(
OMPTargetExitDataDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
Commit for http://reviews.llvm.org/D10765 for OpenMP 4 target data directive parsing and sema. This commit is on behalf of Kelvin Li. llvm-svn: 242785
2015-07-21 21:44:28 +08:00
}
[OpenMP] Parsing + sema for target parallel directive. Summary: This patch adds parsing + sema for the target parallel directive and its clauses along with testcases. Reviewers: ABataev Differential Revision: http://reviews.llvm.org/D16553 Rebased to current trunk and updated test cases. llvm-svn: 258832
2016-01-27 02:48:41 +08:00
void ASTStmtWriter::VisitOMPTargetParallelDirective(
OMPTargetParallelDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
}
[OpenMP] Parsing + sema for target parallel for directive. Summary: This patch adds parsing + sema for the target parallel for directive along with testcases. Reviewers: ABataev Differential Revision: http://reviews.llvm.org/D16759 llvm-svn: 259654
2016-02-03 23:46:42 +08:00
void ASTStmtWriter::VisitOMPTargetParallelForDirective(
OMPTargetParallelForDirective *D) {
VisitOMPLoopDirective(D);
Record.push_back(D->hasCancel() ? 1 : 0);
Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis of 'taskyield' directive. llvm-svn: 213355
2014-07-18 15:47:19 +08:00
void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'barrier' directive. llvm-svn: 213360
2014-07-18 17:11:51 +08:00
void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'taskwait' directive. llvm-svn: 213363
2014-07-18 18:17:07 +08:00
void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
}
[OPENMP] Support for '#pragma omp taskgroup' directive. Added parsing, sema analysis and codegen for '#pragma omp taskgroup' directive (OpenMP 4.0). The code for directive is generated the following way: #pragma omp taskgroup <body> void __kmpc_taskgroup(<loc>, thread_id); <body> void __kmpc_end_taskgroup(<loc>, thread_id); llvm-svn: 240011
2015-06-18 20:14:09 +08:00
void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
VisitStmt(D);
[OPENMP] Initial support for 'task_reduction' clause. Parsing/sema analysis of the 'task_reduction' clause. llvm-svn: 308352
2017-07-19 04:17:46 +08:00
Record.push_back(D->getNumClauses());
[OPENMP] Support for '#pragma omp taskgroup' directive. Added parsing, sema analysis and codegen for '#pragma omp taskgroup' directive (OpenMP 4.0). The code for directive is generated the following way: #pragma omp taskgroup <body> void __kmpc_taskgroup(<loc>, thread_id); <body> void __kmpc_end_taskgroup(<loc>, thread_id); llvm-svn: 240011
2015-06-18 20:14:09 +08:00
VisitOMPExecutableDirective(D);
[OPENMP] Codegen for 'task_reduction' clause. Added codegen for taskgroup directive with task_reduction clause. ``` <body> ``` The next code is emitted: ``` %struct.kmp_task_red_input_t red_init[n]; void *td; call void @__kmpc_taskgroup(%ident_t id, i32 gtid) ... red_init[i].shar = &<item>; red_init[i].size = sizeof(<item>); red_init[i].init = (void*)initializer_function; red_init[i].fini = (void*)destructor_function; red_init[i].comb = (void*)combiner_function; red_init[i].flags = flags; ... td = call i8* @__kmpc_task_reduction_init(i32 gtid, i32 n, i8* (void*)red_init); call void @__kmpc_end_taskgroup(%ident_t id, i32 gtid) void initializer_function(i8* priv) { *(<type>*)priv = <red_init>; ret void; } void destructor_function(i8* priv) { (<type>*)priv->~(); ret void; } void combiner_function(i8* inout, i8* in) { *(<type>*)inout = *(<type>*)inout <red_id> *(<type>*)in; ret void; } ``` llvm-svn: 308979
2017-07-25 23:53:26 +08:00
Record.AddStmt(D->getReductionRef());
[OPENMP] Support for '#pragma omp taskgroup' directive. Added parsing, sema analysis and codegen for '#pragma omp taskgroup' directive (OpenMP 4.0). The code for directive is generated the following way: #pragma omp taskgroup <body> void __kmpc_taskgroup(<loc>, thread_id); <body> void __kmpc_end_taskgroup(<loc>, thread_id); llvm-svn: 240011
2015-06-18 20:14:09 +08:00
Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'flush' directive. llvm-svn: 213512
2014-07-21 19:26:11 +08:00
void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'ordered' directive. llvm-svn: 213616
2014-07-22 14:45:04 +08:00
void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
VisitStmt(D);
[OPENMP 4.1] Add 'threads' clause for '#pragma omp ordered'. OpenMP 4.1 extends format of '#pragma omp ordered'. It adds 3 additional clauses: 'threads', 'simd' and 'depend'. If no clause is specified, the ordered construct behaves as if the threads clause had been specified. If the threads clause is specified, the threads in the team executing the loop region execute ordered regions sequentially in the order of the loop iterations. The loop region to which an ordered region without any clause or with a threads clause binds must have an ordered clause without the parameter specified on the corresponding loop directive. llvm-svn: 248569
2015-09-25 18:37:12 +08:00
Record.push_back(D->getNumClauses());
[OPENMP] Initial parsing and sema analysis for 'ordered' directive. llvm-svn: 213616
2014-07-22 14:45:04 +08:00
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
}
[OPENMP] 'omp teams' directive basic support. Includes parsing and semantic analysis for 'omp teams' directive support from OpenMP 4.0. Adds additional analysis to 'omp target' directive with 'omp teams' directive. llvm-svn: 219385
2014-10-09 12:18:56 +08:00
void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
}
[OPENMP 4.0] Initial support for 'omp cancellation point' construct. Add parsing and sema analysis for 'omp cancellation point' directive. llvm-svn: 241145
2015-07-01 14:57:41 +08:00
void ASTStmtWriter::VisitOMPCancellationPointDirective(
OMPCancellationPointDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Record.push_back(D->getCancelRegion());
Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
}
[OPENMP 4.0] Initial support for 'omp cancel' construct. Implemented parsing/sema analysis + (de)serialization. llvm-svn: 241253
2015-07-02 19:25:17 +08:00
void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
VisitStmt(D);
[OPENMP 4.0] Add 'if' clause for 'cancel' directive. Add parsing, sema analysis and codegen for 'if' clause in 'cancel' directive. llvm-svn: 247976
2015-09-18 16:07:34 +08:00
Record.push_back(D->getNumClauses());
[OPENMP 4.0] Initial support for 'omp cancel' construct. Implemented parsing/sema analysis + (de)serialization. llvm-svn: 241253
2015-07-02 19:25:17 +08:00
VisitOMPExecutableDirective(D);
Record.push_back(D->getCancelRegion());
Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
}
[OPENMP 4.5] Parsing/sema analysis for 'taskloop' directive. Adds initial parsing and semantic analysis for 'taskloop' directive. llvm-svn: 254367
2015-12-01 12:18:41 +08:00
void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
}
[OPENMP 4.5] Parsing/sema support for 'omp taskloop simd' directive. OpenMP 4.5 adds directive 'taskloop simd'. Patch adds parsing/sema analysis for 'taskloop simd' directive and its clauses. llvm-svn: 254597
2015-12-03 17:40:15 +08:00
void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
}
Add parse and sema of OpenMP distribute directive with all clauses except dist_schedule llvm-svn: 255498
2015-12-14 22:51:25 +08:00
void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
}
[OpenMP] Parsing and sema support for target update directive Summary: This patch is to add parsing and sema support for `target update` directive. Support for the `to` and `from` clauses will be added by a different patch. This patch also adds support for other clauses that are already implemented upstream and apply to `target update`, e.g. `device` and `if`. This patch is based on the original post by Kelvin Li. Reviewers: hfinkel, carlo.bertolli, kkwli0, arpith-jacob, ABataev Subscribers: caomhin, cfe-commits Differential Revision: http://reviews.llvm.org/D15944 llvm-svn: 270878
2016-05-27 01:30:50 +08:00
void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
}
Resubmission of http://reviews.llvm.org/D21564 after fixes. [OpenMP] Initial implementation of parse and sema for composite pragma 'distribute parallel for' This patch is an initial implementation for #distribute parallel for. The main differences that affect other pragmas are: The implementation of 'distribute parallel for' requires blocking of the associated loop, where blocks are "distributed" to different teams and iterations within each block are scheduled to parallel threads within each team. To implement blocking, sema creates two additional worksharing directive fields that are used to pass the team assigned block lower and upper bounds through the outlined function resulting from 'parallel'. In this way, scheduling for 'for' to threads can use those bounds. As a consequence of blocking, the stride of 'distribute' is not 1 but it is equal to the blocking size. This is returned by the runtime and sema prepares a DistIncrExpr variable to hold that value. As a consequence of blocking, the global upper bound (EnsureUpperBound) expression of the 'for' is not the original loop upper bound (e.g. in for(i = 0 ; i < N; i++) this is 'N') but it is the team-assigned block upper bound. Sema creates a new expression holding the calculation of the actual upper bound for 'for' as UB = min(UB, PrevUB), where UB is the loop upper bound, and PrevUB is the team-assigned block upper bound. llvm-svn: 273884
2016-06-27 22:55:37 +08:00
void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
OMPDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP] Add support for cancel constructs in [teams] distribute parallel for directives. Added codegen/sema support for cancel constructs in [teams] distribute parallel for directives. llvm-svn: 318872
2017-11-23 04:19:50 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
Resubmission of http://reviews.llvm.org/D21564 after fixes. [OpenMP] Initial implementation of parse and sema for composite pragma 'distribute parallel for' This patch is an initial implementation for #distribute parallel for. The main differences that affect other pragmas are: The implementation of 'distribute parallel for' requires blocking of the associated loop, where blocks are "distributed" to different teams and iterations within each block are scheduled to parallel threads within each team. To implement blocking, sema creates two additional worksharing directive fields that are used to pass the team assigned block lower and upper bounds through the outlined function resulting from 'parallel'. In this way, scheduling for 'for' to threads can use those bounds. As a consequence of blocking, the stride of 'distribute' is not 1 but it is equal to the blocking size. This is returned by the runtime and sema prepares a DistIncrExpr variable to hold that value. As a consequence of blocking, the global upper bound (EnsureUpperBound) expression of the 'for' is not the original loop upper bound (e.g. in for(i = 0 ; i < N; i++) this is 'N') but it is the team-assigned block upper bound. Sema creates a new expression holding the calculation of the actual upper bound for 'for' as UB = min(UB, PrevUB), where UB is the loop upper bound, and PrevUB is the team-assigned block upper bound. llvm-svn: 273884
2016-06-27 22:55:37 +08:00
Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
}
[OpenMP] Sema and parse for 'distribute parallel for simd' Summary: This patch is an implementation of sema and parsing for the OpenMP composite pragma 'distribute parallel for simd'. Differential Revision: http://reviews.llvm.org/D21977 llvm-svn: 274530
2016-07-05 13:00:15 +08:00
void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
OMPDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'distribute simd' pragma Summary: This patch is an implementation of sema and parsing for the OpenMP composite pragma 'distribute simd'. Differential Revision: http://reviews.llvm.org/D22007 llvm-svn: 274604
2016-07-06 12:45:38 +08:00
void ASTStmtWriter::VisitOMPDistributeSimdDirective(
OMPDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target parallel for simd' pragma This patch is to implement sema and parsing for 'target parallel for simd' pragma. Differential Revision: http://reviews.llvm.org/D22096 llvm-svn: 275365
2016-07-14 10:54:56 +08:00
void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
OMPTargetParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target simd' pragma This patch is to implement sema and parsing for 'target simd' pragma. Differential Revision: https://reviews.llvm.org/D22479 llvm-svn: 276203
2016-07-21 06:57:10 +08:00
void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'teams distribute' pragma This patch is to implement sema and parsing for 'teams distribute' pragma. Differential Revision: https://reviews.llvm.org/D23189 llvm-svn: 277818
2016-08-05 22:37:37 +08:00
void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
OMPTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
}
Re-apply patch r279045. llvm-svn: 285066
2016-10-25 20:50:55 +08:00
void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
OMPTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'teams distribute parallel for simd' pragma This patch is to implement sema and parsing for 'teams distribute parallel for simd' pragma. Differential Revision: https://reviews.llvm.org/D27084 llvm-svn: 288294
2016-12-01 07:51:03 +08:00
void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
OMPTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'teams distribute parallel for' pragma This patch is to implement sema and parsing for 'teams distribute parallel for' pragma. Differential Revision: https://reviews.llvm.org/D27345 llvm-svn: 289179
2016-12-09 11:24:30 +08:00
void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
OMPTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP] Add support for cancel constructs in [teams] distribute parallel for directives. Added codegen/sema support for cancel constructs in [teams] distribute parallel for directives. llvm-svn: 318872
2017-11-23 04:19:50 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OpenMP] Sema and parsing for 'teams distribute parallel for' pragma This patch is to implement sema and parsing for 'teams distribute parallel for' pragma. Differential Revision: https://reviews.llvm.org/D27345 llvm-svn: 289179
2016-12-09 11:24:30 +08:00
Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target teams' pragma This patch is to implement sema and parsing for 'target teams' pragma. Differential Revision: https://reviews.llvm.org/D27818 llvm-svn: 290038
2016-12-17 13:48:59 +08:00
void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target teams distribute' pragma This patch is to implement sema and parsing for 'target teams distribute' pragma. Differential Revision: https://reviews.llvm.org/D28015 llvm-svn: 290508
2016-12-25 12:52:54 +08:00
void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
OMPTargetTeamsDistributeDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target teams distribute parallel for’ pragma This patch is to implement sema and parsing for 'target teams distribute parallel for’ pragma. Differential Revision: https://reviews.llvm.org/D28160 llvm-svn: 290725
2016-12-30 06:16:30 +08:00
void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
OMPTargetTeamsDistributeParallelForDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP] Add support for cancel constructs in `target teams distribute parallel for`. Add support for cancel/cancellation point directives inside `target teams distribute parallel for` directives. llvm-svn: 318881
2017-11-23 05:12:03 +08:00
Record.push_back(D->hasCancel() ? 1 : 0);
[OpenMP] Sema and parsing for 'target teams distribute parallel for’ pragma This patch is to implement sema and parsing for 'target teams distribute parallel for’ pragma. Differential Revision: https://reviews.llvm.org/D28160 llvm-svn: 290725
2016-12-30 06:16:30 +08:00
Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target teams distribute parallel for simd’ pragma This patch is to implement sema and parsing for 'target teams distribute parallel for simd’ pragma. Differential Revision: https://reviews.llvm.org/D28202 llvm-svn: 290862
2017-01-03 13:23:48 +08:00
void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
OMPTargetTeamsDistributeParallelForSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::
STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
}
[OpenMP] Sema and parsing for 'target teams distribute simd’ pragma This patch is to implement sema and parsing for 'target teams distribute simd’ pragma. Differential Revision: https://reviews.llvm.org/D28252 llvm-svn: 291579
2017-01-11 02:08:18 +08:00
void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
OMPTargetTeamsDistributeSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//===----------------------------------------------------------------------===//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
// ASTWriter Implementation
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
//===----------------------------------------------------------------------===//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
"SwitchCase recorded twice");
unsigned NextID = SwitchCaseIDs.size();
SwitchCaseIDs[S] = NextID;
return NextID;
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
"SwitchCase hasn't been seen yet");
return SwitchCaseIDs[S];
}
Switch case IDs conflict between chained PCHs; since there is no need to be global, make them local to a decl. llvm-svn: 117540
2010-10-28 17:29:32 +08:00
void ASTWriter::ClearSwitchCaseIDs() {
SwitchCaseIDs.clear();
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Write the given substatement or subexpression to the
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
/// bitstream.
Minor simplifications. llvm-svn: 265594
2016-04-07 04:12:34 +08:00
void ASTWriter::WriteSubStmt(Stmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
RecordData Record;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTStmtWriter Writer(*this, Record);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
++NumStatements;
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
if (!S) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[PCH] When serializing Stmts, keep track of when sub statements are referenced again and in such a case just write out a reference of a previously serialized Stmt, instead of serializing it all over again. This saves memory + space + [de]serializing time, and avoids blowing up memory with pathological cases. rdar://10293911 llvm-svn: 142696
2011-10-22 07:02:28 +08:00
llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
if (I != SubStmtEntries.end()) {
Record.push_back(I->second);
Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
return;
}
#ifndef NDEBUG
assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
struct ParentStmtInserterRAII {
Stmt *S;
llvm::DenseSet<Stmt *> &ParentStmts;
ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
: S(S), ParentStmts(ParentStmts) {
ParentStmts.insert(S);
}
~ParentStmtInserterRAII() {
ParentStmts.erase(S);
}
};
ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
#endif
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
Writer.Visit(S);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Fix order-of-evaluation bug (causing GCC buildbots to fail). llvm-svn: 265598
2016-04-07 04:57:53 +08:00
uint64_t Offset = Writer.Emit();
SubStmtEntries[S] = Offset;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Flush all of the statements that have been added to the
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
/// queue via AddStmt().
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
void ASTRecordWriter::FlushStmts() {
ASTWriter: Cache some DenseMaps we use repeatedly. - This reduces our total # of allocations building a PCH for Cocoa.h by almost a whopping 50%. - A SmallPtrMap would be cleaner, but since we don't have one yet... llvm-svn: 151697
2012-02-29 10:39:13 +08:00
// We expect to be the only consumer of the two temporary statement maps,
// assert that they are empty.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");
[PCH] When serializing Stmts, keep track of when sub statements are referenced again and in such a case just write out a reference of a previously serialized Stmt, instead of serializing it all over again. This saves memory + space + [de]serializing time, and avoids blowing up memory with pathological cases. rdar://10293911 llvm-svn: 142696
2011-10-22 07:02:28 +08:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
Minor simplifications. llvm-svn: 265594
2016-04-07 04:12:34 +08:00
Writer->WriteSubStmt(StmtsToEmit[I]);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
assert(N == StmtsToEmit.size() && "record modified while being written!");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
// Note that we are at the end of a full expression. Any
// expression records that follow this one are part of a different
// expression.
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef<uint32_t>());
Writer->SubStmtEntries.clear();
Writer->ParentStmts.clear();
}
[PCH] When serializing Stmts, keep track of when sub statements are referenced again and in such a case just write out a reference of a previously serialized Stmt, instead of serializing it all over again. This saves memory + space + [de]serializing time, and avoids blowing up memory with pathological cases. rdar://10293911 llvm-svn: 142696
2011-10-22 07:02:28 +08:00
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
StmtsToEmit.clear();
}
void ASTRecordWriter::FlushSubStmts() {
// For a nested statement, write out the substatements in reverse order (so
// that a simple stack machine can be used when loading), and don't emit a
// STMT_STOP after each one.
for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
Minor simplifications. llvm-svn: 265594
2016-04-07 04:12:34 +08:00
Writer->WriteSubStmt(StmtsToEmit[N - I - 1]);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
assert(N == StmtsToEmit.size() && "record modified while being written!");
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 14:20:01 +08:00
StmtsToEmit.clear();
}