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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2700 lines
87 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
//===----------------------------------------------------------------------===//
[OPENMP50]Codegen for iterator construct. Implemented codegen for the iterator expression in the depend clauses. Iterator construct is emitted the following way: iterator(cnt1, cnt2, ...), in : <dep> <TotalNumDeps> = <cnt1_size> * <cnt2_size> * ...; kmp_depend_t deps[<TotalNumDeps>]; deps_counter = 0; for (cnt1) { for (cnt2) { ... deps[deps_counter].base_addr = &<dep>; deps[deps_counter].size = sizeof(<dep>); deps[deps_counter].flags = in; deps_counter += 1; ... } } For depobj construct the codegen is very similar, but the memory is allocated dynamically and added extra first item reserved for internal use.
2020-04-06 23:21:43 +08:00
#include "clang/AST/ExprOpenMP.h"
Move ASTRecordWriter into its own header; NFC. Similar motivations to the movement of ASTRecordReader: AbstractBasicWriter.h already has quite a few dependencies, and it's going to get pretty large as we generate more and more into it. Meanwhile, most clients don't depend on this detail of the implementation and shouldn't need to be recompiled. I've also made OMPClauseWriter private, like it belongs.
2019-12-14 16:17:03 +08:00
#include "clang/Serialization/ASTRecordWriter.h"
[Concepts] Requires Expressions Implement support for C++2a requires-expressions. Re-commit after compilation failure on some platforms due to alignment issues with PointerIntPair. Differential Revision: https://reviews.llvm.org/D50360
2020-01-18 15:11:43 +08:00
#include "clang/Sema/DeclSpec.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) {
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);
[Windows SEH]: HARDWARE EXCEPTION HANDLING (MSVC -EHa) - Part 1 This patch is the Part-1 (FE Clang) implementation of HW Exception handling. This new feature adds the support of Hardware Exception for Microsoft Windows SEH (Structured Exception Handling). This is the first step of this project; only X86_64 target is enabled in this patch. Compiler options: For clang-cl.exe, the option is -EHa, the same as MSVC. For clang.exe, the extra option is -fasync-exceptions, plus -triple x86_64-windows -fexceptions and -fcxx-exceptions as usual. NOTE:: Without the -EHa or -fasync-exceptions, this patch is a NO-DIFF change. The rules for C code: For C-code, one way (MSVC approach) to achieve SEH -EHa semantic is to follow three rules: * First, no exception can move in or out of _try region., i.e., no "potential faulty instruction can be moved across _try boundary. * Second, the order of exceptions for instructions 'directly' under a _try must be preserved (not applied to those in callees). * Finally, global states (local/global/heap variables) that can be read outside of _try region must be updated in memory (not just in register) before the subsequent exception occurs. The impact to C++ code: Although SEH is a feature for C code, -EHa does have a profound effect on C++ side. When a C++ function (in the same compilation unit with option -EHa ) is called by a SEH C function, a hardware exception occurs in C++ code can also be handled properly by an upstream SEH _try-handler or a C++ catch(...). As such, when that happens in the middle of an object's life scope, the dtor must be invoked the same way as C++ Synchronous Exception during unwinding process. Design: A natural way to achieve the rules above in LLVM today is to allow an EH edge added on memory/computation instruction (previous iload/istore idea) so that exception path is modeled in Flow graph preciously. However, tracking every single memory instruction and potential faulty instruction can create many Invokes, complicate flow graph and possibly result in negative performance impact for downstream optimization and code generation. Making all optimizations be aware of the new semantic is also substantial. This design does not intend to model exception path at instruction level. Instead, the proposed design tracks and reports EH state at BLOCK-level to reduce the complexity of flow graph and minimize the performance-impact on CPP code under -EHa option. One key element of this design is the ability to compute State number at block-level. Our algorithm is based on the following rationales: A _try scope is always a SEME (Single Entry Multiple Exits) region as jumping into a _try is not allowed. The single entry must start with a seh_try_begin() invoke with a correct State number that is the initial state of the SEME. Through control-flow, state number is propagated into all blocks. Side exits marked by seh_try_end() will unwind to parent state based on existing SEHUnwindMap[]. Note side exits can ONLY jump into parent scopes (lower state number). Thus, when a block succeeds various states from its predecessors, the lowest State triumphs others. If some exits flow to unreachable, propagation on those paths terminate, not affecting remaining blocks. For CPP code, object lifetime region is usually a SEME as SEH _try. However there is one rare exception: jumping into a lifetime that has Dtor but has no Ctor is warned, but allowed: Warning: jump bypasses variable with a non-trivial destructor In that case, the region is actually a MEME (multiple entry multiple exits). Our solution is to inject a eha_scope_begin() invoke in the side entry block to ensure a correct State. Implementation: Part-1: Clang implementation described below. Two intrinsic are created to track CPP object scopes; eha_scope_begin() and eha_scope_end(). _scope_begin() is immediately added after ctor() is called and EHStack is pushed. So it must be an invoke, not a call. With that it's also guaranteed an EH-cleanup-pad is created regardless whether there exists a call in this scope. _scope_end is added before dtor(). These two intrinsics make the computation of Block-State possible in downstream code gen pass, even in the presence of ctor/dtor inlining. Two intrinsic, seh_try_begin() and seh_try_end(), are added for C-code to mark _try boundary and to prevent from exceptions being moved across _try boundary. All memory instructions inside a _try are considered as 'volatile' to assure 2nd and 3rd rules for C-code above. This is a little sub-optimized. But it's acceptable as the amount of code directly under _try is very small. Part-2 (will be in Part-2 patch): LLVM implementation described below. For both C++ & C-code, the state of each block is computed at the same place in BE (WinEHPreparing pass) where all other EH tables/maps are calculated. In addition to _scope_begin & _scope_end, the computation of block state also rely on the existing State tracking code (UnwindMap and InvokeStateMap). For both C++ & C-code, the state of each block with potential trap instruction is marked and reported in DAG Instruction Selection pass, the same place where the state for -EHsc (synchronous exceptions) is done. If the first instruction in a reported block scope can trap, a Nop is injected before this instruction. This nop is needed to accommodate LLVM Windows EH implementation, in which the address in IPToState table is offset by +1. (note the purpose of that is to ensure the return address of a call is in the same scope as the call address. The handler for catch(...) for -EHa must handle HW exception. So it is 'adjective' flag is reset (it cannot be IsStdDotDot (0x40) that only catches C++ exceptions). Suppress push/popTerminate() scope (from noexcept/noTHrow) so that HW exceptions can be passed through. Original llvm-dev [RFC] discussions can be found in these two threads below: https://lists.llvm.org/pipermail/llvm-dev/2020-March/140541.html https://lists.llvm.org/pipermail/llvm-dev/2020-April/141338.html Differential Revision: https://reviews.llvm.org/D80344/new/
2021-05-18 13:06:32 +08:00
Record.push_back(S->isSideEntry());
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;
Record.push_back(HasElse);
Record.push_back(HasVar);
Record.push_back(HasInit);
Implement if consteval (P1938) Modify the IfStmt node to suppoort constant evaluated expressions. Add a new ExpressionEvaluationContext::ImmediateFunctionContext to keep track of immediate function contexts. This proved easier/better/probably more efficient than walking the AST backward as it allows diagnosing nested if consteval statements.
2021-10-05 20:02:53 +08:00
Record.push_back(static_cast<uint64_t>(S->getStatementKind()));
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] add parenthesis locations for IfStmt and SwitchStmt Differential Revision: https://reviews.llvm.org/D85696
2020-08-11 07:29:33 +08:00
Record.AddSourceLocation(S->getLParenLoc());
Record.AddSourceLocation(S->getRParenLoc());
[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] add parenthesis locations for IfStmt and SwitchStmt Differential Revision: https://reviews.llvm.org/D85696
2020-08-11 07:29:33 +08:00
Record.AddSourceLocation(S->getLParenLoc());
Record.AddSourceLocation(S->getRParenLoc());
[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());
Summary: [clang] Provide a way for WhileStmt to report the location of its LParen and RParen. Summary: This helps avoiding hacks downstream. Reviewers: shafik Subscribers: martong, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D83529
2020-07-10 11:19:06 +08:00
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_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
}
[Concepts] Requires Expressions Implement support for C++2a requires-expressions. Re-commit after compilation failure on some platforms due to alignment issues with PointerIntPair. Differential Revision: https://reviews.llvm.org/D50360
2020-01-18 15:11:43 +08:00
static void
addConstraintSatisfaction(ASTRecordWriter &Record,
const ASTConstraintSatisfaction &Satisfaction) {
[Concepts] Constraint Enforcement & Diagnostics Part of the C++20 concepts implementation effort. - Associated constraints (requires clauses, currently) are now enforced when instantiating/specializing templates and when considering partial specializations and function overloads. - Elaborated diagnostics give helpful insight as to why the constraints were not satisfied. Phabricator: D41569 Re-commit, after fixing some memory bugs.
2019-12-06 07:30:21 +08:00
Record.push_back(Satisfaction.IsSatisfied);
if (!Satisfaction.IsSatisfied) {
Record.push_back(Satisfaction.NumRecords);
for (const auto &DetailRecord : Satisfaction) {
Record.AddStmt(const_cast<Expr *>(DetailRecord.first));
auto *E = DetailRecord.second.dyn_cast<Expr *>();
Record.push_back(E == nullptr);
if (E)
Record.AddStmt(E);
else {
auto *Diag = DetailRecord.second.get<std::pair<SourceLocation,
StringRef> *>();
Record.AddSourceLocation(Diag->first);
Record.AddString(Diag->second);
}
}
}
[Concepts] Requires Expressions Implement support for C++2a requires-expressions. Re-commit after compilation failure on some platforms due to alignment issues with PointerIntPair. Differential Revision: https://reviews.llvm.org/D50360
2020-01-18 15:11:43 +08:00
}
static void
addSubstitutionDiagnostic(
ASTRecordWriter &Record,
const concepts::Requirement::SubstitutionDiagnostic *D) {
Record.AddString(D->SubstitutedEntity);
Record.AddSourceLocation(D->DiagLoc);
Record.AddString(D->DiagMessage);
}
void ASTStmtWriter::VisitConceptSpecializationExpr(
ConceptSpecializationExpr *E) {
VisitExpr(E);
ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
Record.push_back(TemplateArgs.size());
Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());
Record.AddSourceLocation(E->getTemplateKWLoc());
Record.AddDeclarationNameInfo(E->getConceptNameInfo());
Record.AddDeclRef(E->getNamedConcept());
[Concepts] Add FoundDecl to ConceptSpecializationExpr serialization FoundDecl was missing from ConceptSpecializationExpr serialization - add it.
2020-03-11 04:04:11 +08:00
Record.AddDeclRef(E->getFoundDecl());
[Concepts] Requires Expressions Implement support for C++2a requires-expressions. Re-commit after compilation failure on some platforms due to alignment issues with PointerIntPair. Differential Revision: https://reviews.llvm.org/D50360
2020-01-18 15:11:43 +08:00
Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
for (const TemplateArgument &Arg : TemplateArgs)
Record.AddTemplateArgument(Arg);
if (!E->isValueDependent())
addConstraintSatisfaction(Record, E->getSatisfaction());
[Concepts] Constraint Enforcement & Diagnostics Part of the C++20 concepts implementation effort. - Associated constraints (requires clauses, currently) are now enforced when instantiating/specializing templates and when considering partial specializations and function overloads. - Elaborated diagnostics give helpful insight as to why the constraints were not satisfied. Phabricator: D41569 Re-commit, after fixing some memory bugs.
2019-12-06 07:30:21 +08:00
[Concepts] Concept Specialization Expressions Part of C++20 Concepts implementation effort. Added Concept Specialization Expressions that are created when a concept is refe$ D41217 on Phabricator. (recommit after fixing failing Parser test on windows) llvm-svn: 374903
2019-10-15 23:24:26 +08:00
Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
}
[Concepts] Requires Expressions Implement support for C++2a requires-expressions. Re-commit after compilation failure on some platforms due to alignment issues with PointerIntPair. Differential Revision: https://reviews.llvm.org/D50360
2020-01-18 15:11:43 +08:00
void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
VisitExpr(E);
Record.push_back(E->getLocalParameters().size());
Record.push_back(E->getRequirements().size());
Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
Record.push_back(E->RequiresExprBits.IsSatisfied);
Record.AddDeclRef(E->getBody());
for (ParmVarDecl *P : E->getLocalParameters())
Record.AddDeclRef(P);
for (concepts::Requirement *R : E->getRequirements()) {
if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
Record.push_back(concepts::Requirement::RK_Type);
Record.push_back(TypeReq->Status);
if (TypeReq->Status == concepts::TypeRequirement::SS_SubstitutionFailure)
addSubstitutionDiagnostic(Record, TypeReq->getSubstitutionDiagnostic());
else
Record.AddTypeSourceInfo(TypeReq->getType());
} else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(R)) {
Record.push_back(ExprReq->getKind());
Record.push_back(ExprReq->Status);
if (ExprReq->isExprSubstitutionFailure()) {
addSubstitutionDiagnostic(Record,
ExprReq->Value.get<concepts::Requirement::SubstitutionDiagnostic *>());
} else
Record.AddStmt(ExprReq->Value.get<Expr *>());
if (ExprReq->getKind() == concepts::Requirement::RK_Compound) {
Record.AddSourceLocation(ExprReq->NoexceptLoc);
const auto &RetReq = ExprReq->getReturnTypeRequirement();
if (RetReq.isSubstitutionFailure()) {
Record.push_back(2);
addSubstitutionDiagnostic(Record, RetReq.getSubstitutionDiagnostic());
} else if (RetReq.isTypeConstraint()) {
Record.push_back(1);
Record.AddTemplateParameterList(
RetReq.getTypeConstraintTemplateParameterList());
if (ExprReq->Status >=
concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
Record.AddStmt(
ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr());
} else {
assert(RetReq.isEmpty());
Record.push_back(0);
}
}
} else {
auto *NestedReq = cast<concepts::NestedRequirement>(R);
Record.push_back(concepts::Requirement::RK_Nested);
Record.push_back(NestedReq->isSubstitutionFailure());
if (NestedReq->isSubstitutionFailure()){
addSubstitutionDiagnostic(Record,
NestedReq->getSubstitutionDiagnostic());
} else {
Record.AddStmt(NestedReq->Value.get<Expr *>());
if (!NestedReq->isDependent())
addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
}
}
}
Record.AddSourceLocation(E->getEndLoc());
Code = serialization::EXPR_REQUIRES;
}
[Concepts] Concept Specialization Expressions Part of C++20 Concepts implementation effort. Added Concept Specialization Expressions that are created when a concept is refe$ D41217 on Phabricator. (recommit after fixing failing Parser test on windows) llvm-svn: 374903
2019-10-15 23:24:26 +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());
[AST] Add a flag indicating if any subexpression had errors The only subexpression that is considered an error now is TypoExpr, but we plan to add expressions with errors to improve editor tooling on broken code. We intend to use the same mechanism to guard against spurious diagnostics on those as well. See the follow-up revision for an actual usage of the flag. Original patch from Ilya. Reviewers: sammccall Reviewed By: sammccall Tags: #clang Differential Revision: https://reviews.llvm.org/D65591
2020-03-17 17:36:19 +08:00
Record.push_back(E->containsErrors());
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][Serialization] Fix the serialization of ConstantExpr. The serialization of ConstantExpr has currently a number of problems: - Some fields are just not serialized (ConstantExprBits.APValueKind and ConstantExprBits.IsImmediateInvocation). - ASTStmtReader::VisitConstantExpr forgets to add the trailing APValue to the list of objects to be destroyed when the APValue needs cleanup. While we are at it, bring the serialization of ConstantExpr more in-line with what is done with the other expressions by doing the following NFCs: - Get rid of ConstantExpr::DefaultInit. It is better to not initialize the fields of an empty ConstantExpr since this will allow msan to detect if a field was not deserialized. - Move the initialization of the fields of ConstantExpr to the constructor; ConstantExpr::Create allocates the memory and ConstantExpr::ConstantExpr is responsible for the initialization. Review after commit since this is a straightforward mechanical fix similar to the other serialization fixes.
2020-06-21 20:02:48 +08:00
Record.push_back(E->ConstantExprBits.ResultKind);
Record.push_back(E->ConstantExprBits.APValueKind);
Record.push_back(E->ConstantExprBits.IsUnsigned);
Record.push_back(E->ConstantExprBits.BitWidth);
// HasCleanup not serialized since we can just query the APValue.
Record.push_back(E->ConstantExprBits.IsImmediateInvocation);
[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
switch (E->ConstantExprBits.ResultKind) {
[clang][Serialization] Fix the serialization of ConstantExpr. The serialization of ConstantExpr has currently a number of problems: - Some fields are just not serialized (ConstantExprBits.APValueKind and ConstantExprBits.IsImmediateInvocation). - ASTStmtReader::VisitConstantExpr forgets to add the trailing APValue to the list of objects to be destroyed when the APValue needs cleanup. While we are at it, bring the serialization of ConstantExpr more in-line with what is done with the other expressions by doing the following NFCs: - Get rid of ConstantExpr::DefaultInit. It is better to not initialize the fields of an empty ConstantExpr since this will allow msan to detect if a field was not deserialized. - Move the initialization of the fields of ConstantExpr to the constructor; ConstantExpr::Create allocates the memory and ConstantExpr::ConstantExpr is responsible for the initialization. Review after commit since this is a straightforward mechanical fix similar to the other serialization fixes.
2020-06-21 20:02:48 +08:00
case ConstantExpr::RSK_None:
break;
[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
case ConstantExpr::RSK_Int64:
Record.push_back(E->Int64Result());
break;
case ConstantExpr::RSK_APValue:
Record.AddAPValue(E->APValueResult());
[clang][Serialization] Fix the serialization of ConstantExpr. The serialization of ConstantExpr has currently a number of problems: - Some fields are just not serialized (ConstantExprBits.APValueKind and ConstantExprBits.IsImmediateInvocation). - ASTStmtReader::VisitConstantExpr forgets to add the trailing APValue to the list of objects to be destroyed when the APValue needs cleanup. While we are at it, bring the serialization of ConstantExpr more in-line with what is done with the other expressions by doing the following NFCs: - Get rid of ConstantExpr::DefaultInit. It is better to not initialize the fields of an empty ConstantExpr since this will allow msan to detect if a field was not deserialized. - Move the initialization of the fields of ConstantExpr to the constructor; ConstantExpr::Create allocates the memory and ConstantExpr::ConstantExpr is responsible for the initialization. Review after commit since this is a straightforward mechanical fix similar to the other serialization fixes.
2020-06-21 20:02:48 +08:00
break;
default:
llvm_unreachable("unexpected ResultKind!");
[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
}
[clang][Serialization] Fix the serialization of ConstantExpr. The serialization of ConstantExpr has currently a number of problems: - Some fields are just not serialized (ConstantExprBits.APValueKind and ConstantExprBits.IsImmediateInvocation). - ASTStmtReader::VisitConstantExpr forgets to add the trailing APValue to the list of objects to be destroyed when the APValue needs cleanup. While we are at it, bring the serialization of ConstantExpr more in-line with what is done with the other expressions by doing the following NFCs: - Get rid of ConstantExpr::DefaultInit. It is better to not initialize the fields of an empty ConstantExpr since this will allow msan to detect if a field was not deserialized. - Move the initialization of the fields of ConstantExpr to the constructor; ConstantExpr::Create allocates the memory and ConstantExpr::ConstantExpr is responsible for the initialization. Review after commit since this is a straightforward mechanical fix similar to the other serialization fixes.
2020-06-21 20:02:48 +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
Record.AddStmt(E->getSubExpr());
Code = serialization::EXPR_CONSTANT;
}
Reimplement __builtin_unique_stable_name- The original version of this was reverted, and @rjmcall provided some advice to architect a new solution. This is that solution. This implements a builtin to provide a unique name that is stable across compilations of this TU for the purposes of implementing the library component of the unnamed kernel feature of SYCL. It does this by running the Itanium mangler with a few modifications. Because it is somewhat common to wrap non-kernel-related lambdas in macros that aren't present on the device (such as for logging), this uniquely generates an ID for all lambdas involved in the naming of a kernel. It uses the lambda-mangling number to do this, except replaces this with its own number (starting at 10000 for readabililty reasons) for lambdas used to name a kernel. Additionally, this implements itself as constexpr with a slight catch: if a name would be invalidated by the use of this lambda in a later kernel invocation, it is diagnosed as an error (see the Sema tests). Differential Revision: https://reviews.llvm.org/D103112
2021-04-23 23:22:35 +08:00
void ASTStmtWriter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
VisitExpr(E);
Record.AddSourceLocation(E->getLocation());
Record.AddSourceLocation(E->getLParenLocation());
Record.AddSourceLocation(E->getRParenLocation());
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Code = serialization::EXPR_SYCL_UNIQUE_STABLE_NAME;
}
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());
[Fixed Point] [AST] Add an AST serialization code for fixed-point literals. Summary: This patch adds the EXPR_FIXEDPOINT_LITERAL AST code to serialize FixedPointLiterals. They were previously being serialized with the code for integer literals, which doesn't work properly. Reviewers: leonardchan, rjmccall Reviewed By: leonardchan, rjmccall Subscribers: vabridgers, JesperAntonsson, bjope, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D57226
2020-04-08 03:46:08 +08:00
Record.push_back(E->getScale());
[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
Record.AddAPInt(E->getValue());
[Fixed Point] [AST] Add an AST serialization code for fixed-point literals. Summary: This patch adds the EXPR_FIXEDPOINT_LITERAL AST code to serialize FixedPointLiterals. They were previously being serialized with the code for integer literals, which doesn't work properly. Reviewers: leonardchan, rjmccall Reviewed By: leonardchan, rjmccall Subscribers: vabridgers, JesperAntonsson, bjope, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D57226
2020-04-08 03:46:08 +08:00
Code = serialization::EXPR_FIXEDPOINT_LITERAL;
[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
}
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);
Reapply "Add support for #pragma float_control" with buildbot fixes Add support for #pragma float_control Reviewers: rjmccall, erichkeane, sepavloff Differential Revision: https://reviews.llvm.org/D72841 This reverts commit fce82c0ed310174fe48e2402ac731b6340098389.
2020-05-02 01:32:06 +08:00
bool HasFPFeatures = E->hasStoredFPFeatures();
// Write this first for easy access when deserializing, as they affect the
// size of the UnaryOperator.
Record.push_back(HasFPFeatures);
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());
Reapply "Add support for #pragma float_control" with buildbot fixes Add support for #pragma float_control Reviewers: rjmccall, erichkeane, sepavloff Differential Revision: https://reviews.llvm.org/D72841 This reverts commit fce82c0ed310174fe48e2402ac731b6340098389.
2020-05-02 01:32:06 +08:00
if (HasFPFeatures)
Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
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
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
}
[Matrix] Implement matrix index expressions ([][]). This patch implements matrix index expressions (matrix[RowIdx][ColumnIdx]). It does so by introducing a new MatrixSubscriptExpr(Base, RowIdx, ColumnIdx). MatrixSubscriptExprs are built in 2 steps in ActOnMatrixSubscriptExpr. First, if the base of a subscript is of matrix type, we create a incomplete MatrixSubscriptExpr(base, idx, nullptr). Second, if the base is an incomplete MatrixSubscriptExpr, we create a complete MatrixSubscriptExpr(base->getBase(), base->getRowIdx(), idx) Similar to vector elements, it is not possible to take the address of a MatrixSubscriptExpr. For CodeGen, a new MatrixElt type is added to LValue, which is very similar to VectorElt. The only difference is that we may need to cast the type of the base from an array to a vector type when accessing it. Reviewers: rjmccall, anemet, Bigcheese, rsmith, martong Reviewed By: rjmccall Differential Revision: https://reviews.llvm.org/D76791
2020-06-02 02:42:03 +08:00
void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
VisitExpr(E);
Record.AddStmt(E->getBase());
Record.AddStmt(E->getRowIdx());
Record.AddStmt(E->getColumnIdx());
Record.AddSourceLocation(E->getRBracketLoc());
Code = serialization::EXPR_ARRAY_SUBSCRIPT;
}
[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());
[OPENMP50] extend array section for stride (Parsing/Sema/AST) Reviewers: ABataev, jdoerfert Reviewed By: ABataev Subscribers: yaxunl, guansong, arphaman, sstefan1, cfe-commits, sandoval, dreachem Tags: #clang Differential Revision: https://reviews.llvm.org/D82800
2020-07-10 02:27:32 +08:00
Record.AddStmt(E->getStride());
Record.AddSourceLocation(E->getColonLocFirst());
Record.AddSourceLocation(E->getColonLocSecond());
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->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;
}
[OPENMP50]Add basic support for array-shaping operation. Summary: Added basic representation and parsing/sema handling of array-shaping operations. Array shaping expression is an expression of form ([s0]..[sn])base, where s0, ..., sn must be a positive integer, base - a pointer. This expression is a kind of cast operation that converts pointer expression into an array-like kind of expression. Reviewers: rjmccall, rsmith, jdoerfert Subscribers: guansong, arphaman, cfe-commits, caomhin, kkwli0 Tags: #clang Differential Revision: https://reviews.llvm.org/D74144
2020-02-05 22:33:05 +08:00
void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
VisitExpr(E);
Record.push_back(E->getDimensions().size());
Record.AddStmt(E->getBase());
for (Expr *Dim : E->getDimensions())
Record.AddStmt(Dim);
for (SourceRange SR : E->getBracketsRanges())
Record.AddSourceRange(SR);
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Code = serialization::EXPR_OMP_ARRAY_SHAPING;
}
[OPENMP50]Add initial support for OpenMP 5.0 iterator. Added basic parsing/semantic analysis/(de)serialization support for iterator expression introduced in OpenMP 5.0.
2020-04-02 03:06:38 +08:00
void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
VisitExpr(E);
Record.push_back(E->numOfIterators());
Record.AddSourceLocation(E->getIteratorKwLoc());
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
Record.AddDeclRef(E->getIteratorDecl(I));
Record.AddSourceLocation(E->getAssignLoc(I));
OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
Record.AddStmt(Range.Begin);
Record.AddStmt(Range.End);
Record.AddStmt(Range.Step);
Record.AddSourceLocation(E->getColonLoc(I));
if (Range.Step)
Record.AddSourceLocation(E->getSecondColonLoc(I));
[OPENMP50]Codegen for iterator construct. Implemented codegen for the iterator expression in the depend clauses. Iterator construct is emitted the following way: iterator(cnt1, cnt2, ...), in : <dep> <TotalNumDeps> = <cnt1_size> * <cnt2_size> * ...; kmp_depend_t deps[<TotalNumDeps>]; deps_counter = 0; for (cnt1) { for (cnt2) { ... deps[deps_counter].base_addr = &<dep>; deps[deps_counter].size = sizeof(<dep>); deps[deps_counter].flags = in; deps_counter += 1; ... } } For depobj construct the codegen is very similar, but the memory is allocated dynamically and added extra first item reserved for internal use.
2020-04-06 23:21:43 +08:00
// Serialize helpers
OMPIteratorHelperData &HD = E->getHelper(I);
Record.AddDeclRef(HD.CounterVD);
Record.AddStmt(HD.Upper);
Record.AddStmt(HD.Update);
Record.AddStmt(HD.CounterUpdate);
[OPENMP50]Add initial support for OpenMP 5.0 iterator. Added basic parsing/semantic analysis/(de)serialization support for iterator expression introduced in OpenMP 5.0.
2020-04-02 03:06:38 +08:00
}
Code = serialization::EXPR_OMP_ITERATOR;
}
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());
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 13:04:19 +08:00
Record.push_back(E->hasStoredFPFeatures());
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()));
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 13:04:19 +08:00
if (E->hasStoredFPFeatures())
Record.push_back(E->getFPFeatures().getAsOpaqueInt());
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
}
[AST] Add RecoveryExpr to retain expressions on semantic errors Normally clang avoids creating expressions when it encounters semantic errors, even if the parser knows which expression to produce. This works well for the compiler. However, this is not ideal for source-level tools that have to deal with broken code, e.g. clangd is not able to provide navigation features even for names that compiler knows how to resolve. The new RecoveryExpr aims to capture the minimal set of information useful for the tools that need to deal with incorrect code: source range of the expression being dropped, subexpressions of the expression. We aim to make constructing RecoveryExprs as simple as possible to ensure writing code to avoid dropping expressions is easy. Producing RecoveryExprs can result in new code paths being taken in the frontend. In particular, clang can produce some new diagnostics now and we aim to suppress bogus ones based on Expr::containsErrors. We deliberately produce RecoveryExprs only in the parser for now to minimize the code affected by this patch. Producing RecoveryExprs in Sema potentially allows to preserve more information (e.g. type of an expression), but also results in more code being affected. E.g. SFINAE checks will have to take presence of RecoveryExprs into account. Initial implementation only works in C++ mode, as it relies on compiler postponing diagnostics on dependent expressions. C and ObjC often do not do this, so they require more work to make sure we do not produce too many bogus diagnostics on the new expressions. See documentation of RecoveryExpr for more details. original patch from Ilya This change is based on https://reviews.llvm.org/D61722 Reviewers: sammccall, rsmith Reviewed By: sammccall, rsmith Tags: #clang Differential Revision: https://reviews.llvm.org/D69330
2020-03-19 23:30:40 +08:00
void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
VisitExpr(E);
Record.push_back(std::distance(E->children().begin(), E->children().end()));
Record.AddSourceLocation(E->getBeginLoc());
Record.AddSourceLocation(E->getEndLoc());
for (Stmt *Child : E->children())
Record.AddStmt(Child);
Code = serialization::EXPR_RECOVERY;
}
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());
[AST][FPEnv] Keep FP options in trailing storage of CastExpr This is recommit of 6c8041aa0f, reverted in de044f7562 because of some fails. Original commit message is below. This change allow a CastExpr to have optional FPOptionsOverride object, stored in trailing storage. Of all cast nodes only ImplicitCastExpr, CStyleCastExpr, CXXFunctionalCastExpr and CXXStaticCastExpr are allowed to have FPOptions. Differential Revision: https://reviews.llvm.org/D85960
2020-09-12 22:54:14 +08:00
Record.push_back(E->hasStoredFPFeatures());
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);
[AST][FPEnv] Keep FP options in trailing storage of CastExpr This is recommit of 6c8041aa0f, reverted in de044f7562 because of some fails. Original commit message is below. This change allow a CastExpr to have optional FPOptionsOverride object, stored in trailing storage. Of all cast nodes only ImplicitCastExpr, CStyleCastExpr, CXXFunctionalCastExpr and CXXStaticCastExpr are allowed to have FPOptions. Differential Revision: https://reviews.llvm.org/D85960
2020-09-12 22:54:14 +08:00
if (E->hasStoredFPFeatures())
Record.push_back(E->getFPFeatures().getAsOpaqueInt());
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);
Move BinaryOperators.FPOptions to trailing storage Reviewers: rjmccall Differential Revision: https://reviews.llvm.org/D76384
2020-04-11 04:34:46 +08:00
bool HasFPFeatures = E->hasStoredFPFeatures();
// Write this first for easy access when deserializing, as they affect the
// size of the UnaryOperator.
Record.push_back(HasFPFeatures);
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.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
Record.AddSourceLocation(E->getOperatorLoc());
Move BinaryOperators.FPOptions to trailing storage Reviewers: rjmccall Differential Revision: https://reviews.llvm.org/D76384
2020-04-11 04:34:46 +08:00
if (HasFPFeatures)
Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
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
[AST][FPEnv] Keep FP options in trailing storage of CastExpr This is recommit of 6c8041aa0f, reverted in de044f7562 because of some fails. Original commit message is below. This change allow a CastExpr to have optional FPOptionsOverride object, stored in trailing storage. Of all cast nodes only ImplicitCastExpr, CStyleCastExpr, CXXFunctionalCastExpr and CXXStaticCastExpr are allowed to have FPOptions. Differential Revision: https://reviews.llvm.org/D85960
2020-09-12 22:54:14 +08:00
if (E->path_size() == 0 && !E->hasStoredFPFeatures())
[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
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());
PR45083: Mark statement expressions as being dependent if they appear in a dependent context. This matches the GCC behavior. We track the enclosing template depth when determining whether a statement expression is within a dependent context; there doesn't appear to be any other reliable way to determine this. We previously assumed they were neither value- nor instantiation-dependent under any circumstances, which would lead to crashes and other misbehavior.
2020-03-10 08:34:33 +08:00
Record.push_back(E->getTemplateDepth());
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());
[clang] Add range accessor for ObjCAtTryStmt catch_stmts and use it No behavior change. Differential Revision: https://reviews.llvm.org/D112543
2021-10-26 22:53:33 +08:00
for (ObjCAtCatchStmt *C : S->catch_stmts())
Record.AddStmt(C);
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());
Revert "Revert "Revert "Modify FPFeatures to use delta not absolute settings""" This reverts commit 9518763d710bfbbf9315fa88972c55898be44a0e. Memory sanitizer fails in CGFPOptionsRAII::CGFPOptionsRAII dtor
2020-06-26 23:45:12 +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
}
[c++20] Add CXXRewrittenBinaryOperator to represent a comparison operator that is rewritten as a call to multiple other operators. No functionality change yet: nothing creates these expressions. llvm-svn: 375305
2019-10-19 08:04:38 +08:00
void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
CXXRewrittenBinaryOperator *E) {
VisitExpr(E);
Record.push_back(E->isReversed());
Record.AddStmt(E->getSemanticForm());
Code = serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR;
}
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);
[clang][NFC] Pack LambdaExpr This saves sizeof(void *) bytes per LambdaExpr. Review-after-commit since this is a straightforward change similar to the work done on other nodes. NFC.
2020-06-13 21:17:03 +08:00
Record.push_back(E->LambdaExprBits.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);
[clang][NFC] Pack LambdaExpr This saves sizeof(void *) bytes per LambdaExpr. Review-after-commit since this is a straightforward change similar to the work done on other nodes. NFC.
2020-06-13 21:17:03 +08:00
Record.push_back(E->LambdaExprBits.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);
[clang][NFC] Pack LambdaExpr This saves sizeof(void *) bytes per LambdaExpr. Review-after-commit since this is a straightforward change similar to the work done on other nodes. NFC.
2020-06-13 21:17:03 +08:00
Record.push_back(E->LambdaExprBits.ExplicitParams);
Record.push_back(E->LambdaExprBits.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
[clang][Serialization] Don't duplicate the body of LambdaExpr during deserialization 05843dc6ab97a00cbde7aa4f08bf3692eb83109d changed the serialization of the body of LambdaExpr to avoid a mutation in LambdaExpr::getBody and to avoid a missing body in LambdaExpr::children. Unfortunately this replaced one bug by another: we are now duplicating the body during deserialization; that is after deserialization the identity: E->getBody() == E->getCallOperator()->getBody() does not hold. Fix that by instead lazily loading the body from the call operator when needed. Differential Revision: https://reviews.llvm.org/D83009 Reviewed By: martong, aaron.ballman, vabridgers
2020-07-02 21:13:35 +08:00
// Don't serialize the body. It belongs to the call operator declaration.
// LambdaExpr only stores a copy of the Stmt *.
[clang] Fix the serialization of LambdaExpr and the bogus mutation in LambdaExpr::getBody The body of LambdaExpr is currently not properly serialized. Instead LambdaExpr::getBody checks if the body has been already deserialized and if not mutates LambdaExpr. This can be observed with an AST dump test, where the body of the LambdaExpr will be null. The mutation in LambdaExpr::getBody was left because of another bug: it is not true that the body of a LambdaExpr is always a CompoundStmt; it can also be a CoroutineBodyStmt wrapping a CompoundStmt. This is fixed by returning a Stmt * from getBody and introducing a convenience function getCompoundStmtBody which always returns a CompoundStmt *. This function can be used by callers who do not care about the coroutine node. Happily all but one user of getBody treat it as a Stmt * and so this change is non-intrusive. Differential Revision: https://reviews.llvm.org/D81787 Reviewed By: aaron.ballman
2020-06-18 19:51:11 +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
}
[OpenCL] Added addrspace_cast operator in C++ mode. This operator is intended for casting between pointers to objects in different address spaces and follows similar logic as const_cast in C++. Tags: #clang Differential Revision: https://reviews.llvm.org/D60193
2020-05-18 18:02:01 +08:00
void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
VisitCXXNamedCastExpr(E);
Code = serialization::EXPR_CXX_ADDRSPACE_CAST;
}
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());
[PCH] Support writing BuiltinBitCastExprs to PCHs eee944e7f adds the new BuiltinBitCastExpr, but does not set the Code member of ASTStmtWriter. This is not correct and causes an assertion failue in ASTStmtWriter::emit() when building PCHs that contain __builtin_bit_cast. This commit adds serialization::EXPR_BUILTIN_BIT_CAST and handles ASTStmtWriter::Code properly. Differential revision: https://reviews.llvm.org/D80360
2020-06-12 00:30:16 +08:00
Code = serialization::EXPR_BUILTIN_BIT_CAST;
[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
}
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());
[CodeGen] Emit destructor calls to destruct compound literals Fix a bug in IRGen where it wasn't destructing compound literals in C that are ObjC pointer arrays or non-trivial structs. Also diagnose jumps that enter or exit the lifetime of the compound literals. rdar://problem/51867864 Differential Revision: https://reviews.llvm.org/D64464
2020-03-11 05:06:25 +08:00
for (auto &Obj : E->getObjects()) {
if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {
Record.push_back(serialization::COK_Block);
Record.AddDeclRef(BD);
} else if (auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
Record.push_back(serialization::COK_CompoundLiteral);
Record.AddStmt(CLE);
}
}
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);
Rename CXXUnresolvedConstructExpr::arg_size for consistency Make it possible to use argumentCountIs and hasArgument with CXXUnresolvedConstructExpr. Differential Revision: https://reviews.llvm.org/D90553
2020-10-31 00:49:24 +08:00
Record.push_back(E->getNumArgs());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
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());
[c++20] For P0732R2: Give class NTTPs the proper type when examined with 'decltype'. This requires that we track enough information to determine the original type of the parameter in a substituted non-type template parameter, to distinguish the reference-to-class case from the class case.
2020-09-14 10:38:32 +08:00
Record.push_back(E->isReferenceParameter());
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->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);
[NFC] Refactor representation of materialized temporaries Summary: this patch refactor representation of materialized temporaries to prevent an issue raised by rsmith in https://reviews.llvm.org/D63640#inline-612718 Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: thakis, sammccall, ilya-biryukov, rnkovacs, arphaman, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D69360
2019-11-17 18:41:55 +08:00
Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
if (E->getLifetimeExtendedTemporaryDecl())
Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
else
Record.AddStmt(E->getSubExpr());
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]);
PR30738: Implement two-phase name lookup for fold-expressions.
2020-08-07 06:57:35 +08:00
Record.AddStmt(E->SubExprs[2]);
[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());
Rework how UuidAttr, CXXUuidofExpr, and GUID template arguments and constants are represented. Summary: Previously, we treated CXXUuidofExpr as quite a special case: it was the only kind of expression that could be a canonical template argument, it could be a constant lvalue base object, and so on. In addition, we represented the UUID value as a string, whose source form we did not preserve faithfully, and that we partially parsed in multiple different places. With this patch, we create an MSGuidDecl object to represent the implicit object of type 'struct _GUID' created by a UuidAttr. Each UuidAttr holds a pointer to its 'struct _GUID' and its original (as-written) UUID string. A non-value-dependent CXXUuidofExpr behaves like a DeclRefExpr denoting that MSGuidDecl object. We cache an APValue representation of the GUID on the MSGuidDecl and use it from constant evaluation where needed. This allows removing a lot of the special-case logic to handle these expressions. Unfortunately, many parts of Clang assume there are only a couple of interesting kinds of ValueDecl, so the total amount of special-case logic is not really reduced very much. This fixes a few bugs and issues: * PR38490: we now support reading from GUID objects returned from __uuidof during constant evaluation. * Our Itanium mangling for a non-instantiation-dependent template argument involving __uuidof no longer depends on which CXXUuidofExpr template argument we happened to see first. * We now predeclare ::_GUID, and permit use of __uuidof without any header inclusion, better matching MSVC's behavior. We do not predefine ::__s_GUID, though; that seems like a step too far. * Our IR representation for GUID constants now uses the correct IR type wherever possible. We will still fall back to using the {i32, i16, i16, [8 x i8]} layout if a definition of struct _GUID is not available. This is not ideal: in principle the two layouts could have different padding. Reviewers: rnk, jdoerfert Subscribers: arphaman, cfe-commits, aeubanks Tags: #clang Differential Revision: https://reviews.llvm.org/D78171
2020-04-12 13:15:29 +08:00
Record.AddDeclRef(E->getGuidDecl());
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.
//===----------------------------------------------------------------------===//
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
[clang][OpenMP] Use OpenMPIRBuilder for workshare loops. Initial support for using the OpenMPIRBuilder by clang to generate loops using the OpenMPIRBuilder. This initial support is intentionally limited to: * Only the worksharing-loop directive. * Recognizes only the nowait clause. * No loop nests with more than one loop. * Untested with templates, exceptions. * Semantic checking left to the existing infrastructure. This patch introduces a new AST node, OMPCanonicalLoop, which becomes parent of any loop that has to adheres to the restrictions as specified by the OpenMP standard. These restrictions allow OMPCanonicalLoop to provide the following additional information that depends on base language semantics: * The distance function: How many loop iterations there will be before entering the loop nest. * The loop variable function: Conversion from a logical iteration number to the loop variable. These allow the OpenMPIRBuilder to act solely using logical iteration numbers without needing to be concerned with iterator semantics between calling the distance function and determining what the value of the loop variable ought to be. Any OpenMP logical should be done by the OpenMPIRBuilder such that it can be reused MLIR OpenMP dialect and thus by flang. The distance and loop variable function are implemented using lambdas (or more exactly: CapturedStmt because lambda implementation is more interviewed with the parser). It is up to the OpenMPIRBuilder how they are called which depends on what is done with the loop. By default, these are emitted as outlined functions but we might think about emitting them inline as the OpenMPRuntime does. For compatibility with the current OpenMP implementation, even though not necessary for the OpenMPIRBuilder, OMPCanonicalLoop can still be nested within OMPLoopDirectives' CapturedStmt. Although OMPCanonicalLoop's are not currently generated when the OpenMPIRBuilder is not enabled, these can just be skipped when not using the OpenMPIRBuilder in case we don't want to make the AST dependent on the EnableOMPBuilder setting. Loop nests with more than one loop require support by the OpenMPIRBuilder (D93268). A simple implementation of non-rectangular loop nests would add another lambda function that returns whether a loop iteration of the rectangular overapproximation is also within its non-rectangular subset. Reviewed By: jdenny Differential Revision: https://reviews.llvm.org/D94973
2021-03-04 07:15:32 +08:00
void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
VisitStmt(S);
for (Stmt *SubStmt : S->SubStmts)
Record.AddStmt(SubStmt);
Code = serialization::STMT_OMP_CANONICAL_LOOP;
}
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeOMPChildren(E->Data);
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());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
}
[OpenMP] Implement '#pragma omp tile', by Michael Kruse (@Meinersbur). The tile directive is in OpenMP's Technical Report 8 and foreseeably will be part of the upcoming OpenMP 5.1 standard. This implementation is based on an AST transformation providing a de-sugared loop nest. This makes it simple to forward the de-sugared transformation to loop associated directives taking the tiled loops. In contrast to other loop associated directives, the OMPTileDirective does not use CapturedStmts. Letting loop associated directives consume loops from different capture context would be difficult. A significant amount of code generation logic is taking place in the Sema class. Eventually, I would prefer if these would move into the CodeGen component such that we could make use of the OpenMPIRBuilder, together with flang. Only expressions converting between the language's iteration variable and the logical iteration space need to take place in the semantic analyzer: Getting the of iterations (e.g. the overload resolution of `std::distance`) and converting the logical iteration number to the iteration variable (e.g. overload resolution of `iteration + .omp.iv`). In clang, only CXXForRangeStmt is also represented by its de-sugared components. However, OpenMP loop are not defined as syntatic sugar. Starting with an AST-based approach allows us to gradually move generated AST statements into CodeGen, instead all at once. I would also like to refactor `checkOpenMPLoop` into its functionalities in a follow-up. In this patch it is used twice. Once for checking proper nesting and emitting diagnostics, and additionally for deriving the logical iteration space per-loop (instead of for the loop nest). Differential Revision: https://reviews.llvm.org/D76342
2021-02-13 03:26:59 +08:00
void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *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);
[OpenMP] Implement '#pragma omp tile', by Michael Kruse (@Meinersbur). The tile directive is in OpenMP's Technical Report 8 and foreseeably will be part of the upcoming OpenMP 5.1 standard. This implementation is based on an AST transformation providing a de-sugared loop nest. This makes it simple to forward the de-sugared transformation to loop associated directives taking the tiled loops. In contrast to other loop associated directives, the OMPTileDirective does not use CapturedStmts. Letting loop associated directives consume loops from different capture context would be difficult. A significant amount of code generation logic is taking place in the Sema class. Eventually, I would prefer if these would move into the CodeGen component such that we could make use of the OpenMPIRBuilder, together with flang. Only expressions converting between the language's iteration variable and the logical iteration space need to take place in the semantic analyzer: Getting the of iterations (e.g. the overload resolution of `std::distance`) and converting the logical iteration number to the iteration variable (e.g. overload resolution of `iteration + .omp.iv`). In clang, only CXXForRangeStmt is also represented by its de-sugared components. However, OpenMP loop are not defined as syntatic sugar. Starting with an AST-based approach allows us to gradually move generated AST statements into CodeGen, instead all at once. I would also like to refactor `checkOpenMPLoop` into its functionalities in a follow-up. In this patch it is used twice. Once for checking proper nesting and emitting diagnostics, and additionally for deriving the logical iteration space per-loop (instead of for the loop nest). Differential Revision: https://reviews.llvm.org/D76342
2021-02-13 03:26:59 +08:00
Record.writeUInt32(D->getLoopsNumber());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 11:13:43 +08:00
VisitOMPExecutableDirective(D);
}
[OpenMP] Implement '#pragma omp tile', by Michael Kruse (@Meinersbur). The tile directive is in OpenMP's Technical Report 8 and foreseeably will be part of the upcoming OpenMP 5.1 standard. This implementation is based on an AST transformation providing a de-sugared loop nest. This makes it simple to forward the de-sugared transformation to loop associated directives taking the tiled loops. In contrast to other loop associated directives, the OMPTileDirective does not use CapturedStmts. Letting loop associated directives consume loops from different capture context would be difficult. A significant amount of code generation logic is taking place in the Sema class. Eventually, I would prefer if these would move into the CodeGen component such that we could make use of the OpenMPIRBuilder, together with flang. Only expressions converting between the language's iteration variable and the logical iteration space need to take place in the semantic analyzer: Getting the of iterations (e.g. the overload resolution of `std::distance`) and converting the logical iteration number to the iteration variable (e.g. overload resolution of `iteration + .omp.iv`). In clang, only CXXForRangeStmt is also represented by its de-sugared components. However, OpenMP loop are not defined as syntatic sugar. Starting with an AST-based approach allows us to gradually move generated AST statements into CodeGen, instead all at once. I would also like to refactor `checkOpenMPLoop` into its functionalities in a follow-up. In this patch it is used twice. Once for checking proper nesting and emitting diagnostics, and additionally for deriving the logical iteration space per-loop (instead of for the loop nest). Differential Revision: https://reviews.llvm.org/D76342
2021-02-13 03:26:59 +08:00
void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
VisitOMPLoopBasedDirective(D);
}
OpenMP 5.0 metadirective This patch supports OpenMP 5.0 metadirective features. It is implemented keeping the OpenMP 5.1 features like dynamic user condition in mind. A new function, getBestWhenMatchForContext, is defined in llvm/Frontend/OpenMP/OMPContext.h Currently this function return the index of the when clause with the highest score from the ones applicable in the Context. But this function is declared with an array which can be used in OpenMP 5.1 implementation to select all the valid when clauses which can be resolved in runtime. Currently this array is set to null by default and its implementation is left for future. Reviewed By: jdoerfert Differential Revision: https://reviews.llvm.org/D91944
2021-09-18 05:03:01 +08:00
void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_META_DIRECTIVE;
}
[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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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;
}
[Clang][OpenMP] Infix OMPLoopTransformationDirective abstract class. NFC. Insert OMPLoopTransformationDirective between OMPLoopBasedDirective and the loop transformations OMPTileDirective and OMPUnrollDirective. This simplifies handling of loop transformations not requiring distinguishing between OMPTileDirective and OMPUnrollDirective anymore. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D111119
2021-10-06 23:02:27 +08:00
void ASTStmtWriter::VisitOMPLoopTransformationDirective(
OMPLoopTransformationDirective *D) {
[OpenMP] Implement '#pragma omp tile', by Michael Kruse (@Meinersbur). The tile directive is in OpenMP's Technical Report 8 and foreseeably will be part of the upcoming OpenMP 5.1 standard. This implementation is based on an AST transformation providing a de-sugared loop nest. This makes it simple to forward the de-sugared transformation to loop associated directives taking the tiled loops. In contrast to other loop associated directives, the OMPTileDirective does not use CapturedStmts. Letting loop associated directives consume loops from different capture context would be difficult. A significant amount of code generation logic is taking place in the Sema class. Eventually, I would prefer if these would move into the CodeGen component such that we could make use of the OpenMPIRBuilder, together with flang. Only expressions converting between the language's iteration variable and the logical iteration space need to take place in the semantic analyzer: Getting the of iterations (e.g. the overload resolution of `std::distance`) and converting the logical iteration number to the iteration variable (e.g. overload resolution of `iteration + .omp.iv`). In clang, only CXXForRangeStmt is also represented by its de-sugared components. However, OpenMP loop are not defined as syntatic sugar. Starting with an AST-based approach allows us to gradually move generated AST statements into CodeGen, instead all at once. I would also like to refactor `checkOpenMPLoop` into its functionalities in a follow-up. In this patch it is used twice. Once for checking proper nesting and emitting diagnostics, and additionally for deriving the logical iteration space per-loop (instead of for the loop nest). Differential Revision: https://reviews.llvm.org/D76342
2021-02-13 03:26:59 +08:00
VisitOMPLoopBasedDirective(D);
[Clang][OpenMP] Allow loop-transformations with template parameters. Clang would reject #pragma omp for #pragma omp tile sizes(P) for (int i = 0; i < 128; ++i) {} where P is a template parameter, but the loop itself is not template-dependent. Because P context-dependent, the TransformedStmt cannot be generated and therefore is nullptr (until the template is instantiated by TreeTransform). The OMPForDirective would still expect the a loop is the dependent context and trigger an error. Fix by introducing a NumGeneratedLoops field to OMPLoopTransformation. This is used to distinguish the case where no TransformedStmt will be generated at all (e.g. #pragma omp unroll full) and template instantiation is needed. In the latter case, delay resolving the iteration space like when the for-loop itself is template-dependent until the template instatiation. A more radical solution would always delay the iteration space analysis until template instantiation, but would also break many test cases. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D111124
2021-10-07 00:43:29 +08:00
Record.writeUInt32(D->getNumGeneratedLoops());
[Clang][OpenMP] Infix OMPLoopTransformationDirective abstract class. NFC. Insert OMPLoopTransformationDirective between OMPLoopBasedDirective and the loop transformations OMPTileDirective and OMPUnrollDirective. This simplifies handling of loop transformations not requiring distinguishing between OMPTileDirective and OMPUnrollDirective anymore. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D111119
2021-10-06 23:02:27 +08:00
}
void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) {
VisitOMPLoopTransformationDirective(D);
[OpenMP] Implement '#pragma omp tile', by Michael Kruse (@Meinersbur). The tile directive is in OpenMP's Technical Report 8 and foreseeably will be part of the upcoming OpenMP 5.1 standard. This implementation is based on an AST transformation providing a de-sugared loop nest. This makes it simple to forward the de-sugared transformation to loop associated directives taking the tiled loops. In contrast to other loop associated directives, the OMPTileDirective does not use CapturedStmts. Letting loop associated directives consume loops from different capture context would be difficult. A significant amount of code generation logic is taking place in the Sema class. Eventually, I would prefer if these would move into the CodeGen component such that we could make use of the OpenMPIRBuilder, together with flang. Only expressions converting between the language's iteration variable and the logical iteration space need to take place in the semantic analyzer: Getting the of iterations (e.g. the overload resolution of `std::distance`) and converting the logical iteration number to the iteration variable (e.g. overload resolution of `iteration + .omp.iv`). In clang, only CXXForRangeStmt is also represented by its de-sugared components. However, OpenMP loop are not defined as syntatic sugar. Starting with an AST-based approach allows us to gradually move generated AST statements into CodeGen, instead all at once. I would also like to refactor `checkOpenMPLoop` into its functionalities in a follow-up. In this patch it is used twice. Once for checking proper nesting and emitting diagnostics, and additionally for deriving the logical iteration space per-loop (instead of for the loop nest). Differential Revision: https://reviews.llvm.org/D76342
2021-02-13 03:26:59 +08:00
Code = serialization::STMT_OMP_TILE_DIRECTIVE;
}
[OpenMP] Implement '#pragma omp unroll'. Implementation of the unroll directive introduced in OpenMP 5.1. Follows the approach from D76342 for the tile directive (i.e. AST-based, not using the OpenMPIRBuilder). Tries to use `llvm.loop.unroll.*` metadata where possible, but has to fall back to an AST representation of the outer loop if the partially unrolled generated loop is associated with another directive (because it needs to compute the number of iterations). Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D99459
2021-06-11 03:24:17 +08:00
void ASTStmtWriter::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
[Clang][OpenMP] Infix OMPLoopTransformationDirective abstract class. NFC. Insert OMPLoopTransformationDirective between OMPLoopBasedDirective and the loop transformations OMPTileDirective and OMPUnrollDirective. This simplifies handling of loop transformations not requiring distinguishing between OMPTileDirective and OMPUnrollDirective anymore. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D111119
2021-10-06 23:02:27 +08:00
VisitOMPLoopTransformationDirective(D);
[OpenMP] Implement '#pragma omp unroll'. Implementation of the unroll directive introduced in OpenMP 5.1. Follows the approach from D76342 for the tile directive (i.e. AST-based, not using the OpenMPIRBuilder). Tries to use `llvm.loop.unroll.*` metadata where possible, but has to fall back to an AST representation of the outer loop if the partially unrolled generated loop is associated with another directive (because it needs to compute the number of iterations). Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D99459
2021-06-11 03:24:17 +08:00
Code = serialization::STMT_OMP_UNROLL_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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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);
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);
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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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;
}
[OpenMP50] Add parallel master construct Reviewers: ABataev, jdoerfert Reviewed By: ABataev Subscribers: rnk, jholewinski, guansong, arphaman, jfb, cfe-commits, sandoval, dreachem Tags: #clang Differential Revision: https://reviews.llvm.org/D70726
2019-12-06 02:43:48 +08:00
void ASTStmtWriter::VisitOMPParallelMasterDirective(
OMPParallelMasterDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASTER_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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->isXLHSInRHSPart());
Record.writeBool(D->isPostfixUpdate());
[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);
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);
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);
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);
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);
VisitOMPExecutableDirective(D);
[OPENMP]Allow cancellation constructs in target parallel regions. Summary: omp cancellation point parallel and omp cancel parallel directives are allowed in target paralle regions. Reviewers: jdoerfert Subscribers: yaxunl, guansong, caomhin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D78941
2020-04-27 23:37:35 +08:00
Record.writeBool(D->hasCancel());
[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
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);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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
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);
[OpenMP] support depend clause for taskwait directive, by Deepak Eachempati. This patch adds clang (parsing, sema, serialization, codegen) support for the 'depend' clause on the 'taskwait' directive. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D113540
2021-11-19 21:59:40 +08:00
Record.push_back(D->getNumClauses());
[OPENMP] Initial parsing and sema analysis for 'taskwait' directive. llvm-svn: 213363
2014-07-18 18:17:07 +08:00
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);
VisitOMPExecutableDirective(D);
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);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
}
[OPENMP50]Add basic support for depobj construct. Added basic parsing/sema/serialization support for depobj directive.
2020-02-28 22:52:15 +08:00
void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_DEPOBJ_DIRECTIVE;
}
[OPENMP50]Initial support for scan directive. Addedi basic parsing/sema/serialization support for scan directive.
2020-03-20 19:03:01 +08:00
void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_SCAN_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);
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);
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);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeEnum(D->getCancelRegion());
[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
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);
VisitOMPExecutableDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeEnum(D->getCancelRegion());
[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
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);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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
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;
}
[OPENMP50]Support for 'master taskloop' directive. Added full support for master taskloop directive. llvm-svn: 374437
2019-10-11 04:13:02 +08:00
void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
OMPMasterTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[OPENMP50]Support for 'master taskloop' directive. Added full support for master taskloop directive. llvm-svn: 374437
2019-10-11 04:13:02 +08:00
Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
}
[OPENMP50]Add support for master taskloop simd. Added trsing/semantics/codegen for combined construct master taskloop simd. llvm-svn: 375255
2019-10-19 00:47:35 +08:00
void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
OMPMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
}
[OPENMP50]Add support for 'parallel master taskloop' construct. Added parsing/sema/codegen support for 'parallel master taskloop' constructs. Some of the clauses, like 'grainsize', 'num_tasks', 'final' and 'priority' are not supported in full, only constant expressions can be used currently in these clauses. llvm-svn: 374791
2019-10-15 01:17:41 +08:00
void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
OMPParallelMasterTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
[OPENMP]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[OPENMP50]Add support for 'parallel master taskloop' construct. Added parsing/sema/codegen support for 'parallel master taskloop' constructs. Some of the clauses, like 'grainsize', 'num_tasks', 'final' and 'priority' are not supported in full, only constant expressions can be used currently in these clauses. llvm-svn: 374791
2019-10-15 01:17:41 +08:00
Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
}
[OPENMP50]Add support for parallel master taskloop simd directive. Added full support for parallel master taskloop simd directive.
2019-10-25 22:27:13 +08:00
void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
OMPParallelMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASTER_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);
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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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);
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]Redesign of OMPExecutableDirective/OMPDeclarativeDirective representation. Summary: Introduced OMPChildren class to handle all associated clauses, statement and child expressions/statements. It allows to represent some directives more correctly (like flush, depobj etc. with pseudo clauses, ordered depend directives, which are standalone, and target data directives). Also, it will make easier to avoid using of CapturedStmt in directives, if required (atomic, tile etc. directives). Also, it simplifies serialization/deserialization of the executable/declarative directives. Reduces number of allocation operations for mapper declarations. Reviewers: jdoerfert Subscribers: yaxunl, guansong, jfb, cfe-commits, sstefan1, aaron.ballman, caomhin Tags: #clang Differential Revision: https://reviews.llvm.org/D83261
2020-06-27 05:42:31 +08:00
Record.writeBool(D->hasCancel());
[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;
}
[OPENMP51]Initial support for the interop directive. Added basic parsing/sema/serialization support for interop directive. Support for the 'init' clause. Differential Revision: https://reviews.llvm.org/D98558
2021-03-16 04:09:46 +08:00
void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_INTEROP_DIRECTIVE;
}
[OPENMP51]Initial support for the dispatch directive. Added basic parsing/sema/serialization support for dispatch directive. Differential Revision: https://reviews.llvm.org/D99537
2021-03-23 09:13:29 +08:00
void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Record.AddSourceLocation(D->getTargetCallLoc());
Code = serialization::STMT_OMP_DISPATCH_DIRECTIVE;
}
[OpenMP51] Initial support for masked directive and filter clause Adds basic parsing/sema/serialization support for the #pragma omp masked directive. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D99995
2021-04-10 03:00:36 +08:00
void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_MASKED_DIRECTIVE;
}
[OpenMP] Initial parsing/sema for the 'omp loop' construct Adds basic parsing/sema/serialization support for the #pragma omp loop directive. Differential Revision: https://reviews.llvm.org/D112499
2021-10-28 23:10:40 +08:00
void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_GENERIC_LOOP_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();
}