mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 16:26:05 +00:00
Code Issues Projects 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.

2959 lines
96 KiB
C++
Raw Normal View History

Rename the ASTWriter implementation files llvm-svn: 111465
2010-08-18 23:56:31 +00:00
//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 08:50:56 +00: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 06:20:01 +00: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-09 23:08:25 +00: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 01:00:01 +00: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-09 23:08:25 +00:00
///
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
//===----------------------------------------------------------------------===//
Add a concept AST node. This patch adds a concept AST node (`ConceptLoc`) and uses it at the corresponding places. There are three objects that might have constraints via concepts: `TypeConstraint`, `ConceptSpecializationExpr` and `AutoTypeLoc`. The first two inherit from `ConceptReference` while the latter has the information about a possible constraint directly stored in `AutoTypeLocInfo`. It would be nice if the concept information would be stored the same way in all three cases. Moreover the current structure makes it difficult to deal with these concepts. For example in Clangd accessing the locations of constraints of a `AutoTypeLoc` can only be done with quite ugly hacks. So we think that it makes sense to create a new AST node for such concepts. In details we propose the following: - Rename `ConceptReference` to `ConceptLoc` (or something else what is approriate) and make it the new AST node. - `TypeConstraint` and `ConceptSpecializationExpr` do not longer inherit from `ConceptReference` but store a pointer to a `ConceptLoc`. - `AutoTypeLoc` stores a pointer to `ConceptLoc` instead of storing the concept info in `AutoTypeLocInfo`. This patch implements a first version of this idea which compiles and where the existing tests pass. To make this patch as small as possible we keep the existing member functions to access concept data. Later these can be replaced by directly calling the corresponding functions of the `ConceptLoc`s. Differential Revision: https://reviews.llvm.org/D155858
2023-08-02 14:00:16 +02:00
#include "clang/AST/ASTConcept.h"
Drop the ASTContext.h include from DeclFriend.h and DeclTemplate.h. llvm-svn: 159723
2012-07-04 20:19:54 +00: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-09 23:08:42 +00:00
#include "clang/AST/DeclCXX.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 01:15:58 +00:00
#include "clang/AST/DeclTemplate.h"
Add a concept AST node. This patch adds a concept AST node (`ConceptLoc`) and uses it at the corresponding places. There are three objects that might have constraints via concepts: `TypeConstraint`, `ConceptSpecializationExpr` and `AutoTypeLoc`. The first two inherit from `ConceptReference` while the latter has the information about a possible constraint directly stored in `AutoTypeLocInfo`. It would be nice if the concept information would be stored the same way in all three cases. Moreover the current structure makes it difficult to deal with these concepts. For example in Clangd accessing the locations of constraints of a `AutoTypeLoc` can only be done with quite ugly hacks. So we think that it makes sense to create a new AST node for such concepts. In details we propose the following: - Rename `ConceptReference` to `ConceptLoc` (or something else what is approriate) and make it the new AST node. - `TypeConstraint` and `ConceptSpecializationExpr` do not longer inherit from `ConceptReference` but store a pointer to a `ConceptLoc`. - `AutoTypeLoc` stores a pointer to `ConceptLoc` instead of storing the concept info in `AutoTypeLocInfo`. This patch implements a first version of this idea which compiles and where the existing tests pass. To make this patch as small as possible we keep the existing member functions to access concept data. Later these can be replaced by directly calling the corresponding functions of the `ConceptLoc`s. Differential Revision: https://reviews.llvm.org/D155858
2023-08-02 14:00:16 +02:00
#include "clang/AST/ExprOpenMP.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:10:13 +00:00
#include "clang/Lex/Token.h"
Add a concept AST node. This patch adds a concept AST node (`ConceptLoc`) and uses it at the corresponding places. There are three objects that might have constraints via concepts: `TypeConstraint`, `ConceptSpecializationExpr` and `AutoTypeLoc`. The first two inherit from `ConceptReference` while the latter has the information about a possible constraint directly stored in `AutoTypeLocInfo`. It would be nice if the concept information would be stored the same way in all three cases. Moreover the current structure makes it difficult to deal with these concepts. For example in Clangd accessing the locations of constraints of a `AutoTypeLoc` can only be done with quite ugly hacks. So we think that it makes sense to create a new AST node for such concepts. In details we propose the following: - Rename `ConceptReference` to `ConceptLoc` (or something else what is approriate) and make it the new AST node. - `TypeConstraint` and `ConceptSpecializationExpr` do not longer inherit from `ConceptReference` but store a pointer to a `ConceptLoc`. - `AutoTypeLoc` stores a pointer to `ConceptLoc` instead of storing the concept info in `AutoTypeLocInfo`. This patch implements a first version of this idea which compiles and where the existing tests pass. To make this patch as small as possible we keep the existing member functions to access concept data. Later these can be replaced by directly calling the corresponding functions of the `ConceptLoc`s. Differential Revision: https://reviews.llvm.org/D155858
2023-08-02 14:00:16 +02:00
#include "clang/Sema/DeclSpec.h"
#include "clang/Serialization/ASTRecordWriter.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-03 22:40:07 +00:00
#include "llvm/Bitstream/BitstreamWriter.h"
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
using namespace clang;
//===----------------------------------------------------------------------===//
// Statement/expression serialization
//===----------------------------------------------------------------------===//
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 08:49:18 +00:00
namespace clang {
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 03:13:43 +00:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-18 23:56:21 +00: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-06 17:06:00 +00:00
ASTRecordWriter Record;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00: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 02:27:19 +00:00
unsigned AbbrevToUse;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
/// A helper that can help us to write a packed bit across function
/// calls. For example, we may write seperate bits in seperate functions:
///
/// void VisitA(A* a) {
/// Record.push_back(a->isSomething());
/// }
///
/// void Visitb(B *b) {
/// VisitA(b);
/// Record.push_back(b->isAnother());
/// }
///
/// In such cases, it'll be better if we can pack these 2 bits. We achieve
/// this by writing a zero value in `VisitA` and recorded that first and add
/// the new bit to the recorded value.
class PakedBitsWriter {
public:
PakedBitsWriter(ASTRecordWriter &Record) : RecordRef(Record) {}
~PakedBitsWriter() { assert(!CurrentIndex); }
void addBit(bool Value) {
assert(CurrentIndex && "Writing Bits without recording first!");
PackingBits.addBit(Value);
}
void addBits(uint32_t Value, uint32_t BitsWidth) {
assert(CurrentIndex && "Writing Bits without recording first!");
PackingBits.addBits(Value, BitsWidth);
}
void writeBits() {
if (!CurrentIndex)
return;
RecordRef[*CurrentIndex] = (uint32_t)PackingBits;
CurrentIndex = std::nullopt;
PackingBits.reset(0);
}
void updateBits() {
writeBits();
CurrentIndex = RecordRef.size();
RecordRef.push_back(0);
}
private:
BitsPacker PackingBits;
ASTRecordWriter &RecordRef;
std::optional<unsigned> CurrentIndex;
};
PakedBitsWriter CurrentPackingBits;
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00:00
public:
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-06 17:06:00 +00:00
: Writer(Writer), Record(Writer, Record),
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
Code(serialization::STMT_NULL_PTR), AbbrevToUse(0),
CurrentPackingBits(this->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-06 17:06:00 +00:00
ASTStmtWriter(const ASTStmtWriter&) = delete;
[NFC][Clang] Fix Coverity issues of copy without assign This patch adds missing copy/move assignment operator to the class which has user-defined copy/move constructor. Reviewed By: tahonermann Differential Revision: https://reviews.llvm.org/D149718
2023-05-14 19:49:22 -07:00
ASTStmtWriter &operator=(const ASTStmtWriter &) = delete;
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00:00
Minor simplifications. llvm-svn: 265594
2016-04-06 20:12:34 +00:00
uint64_t Emit() {
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.writeBits();
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00: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 09:46:47 +00: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-29 18:15:14 +00:00
void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
const TemplateArgumentLoc *Args);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 07:00:14 +00: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 06:20:01 +00:00
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-22 23:07:51 +00:00
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-29 18:15:14 +00: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-06 17:06:00 +00: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-29 18:15:14 +00: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-06 17:06:00 +00:00
Record.AddTemplateArgumentLoc(Args[i]);
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 09:31:48 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitStmt(Stmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-27 18:43:27 +00:00
Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_NULL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitStmt(S);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(S->size());
Record.push_back(S->hasStoredFPFeatures());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[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 14:19:37 +00: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-06 17:06:00 +00:00
Record.AddStmt(CS);
[FPEnv] Allow CompoundStmt to keep FP options This is a recommit of b822efc7404bf09ccfdc1ab7657475026966c3b2, reverted in dc34d8df4c48b3a8f474360970cae8a58e6c84f0. The commit caused fails because the test ast-print-fp-pragmas.c did not specify particular target, and it failed on targets which do not support constrained intrinsics. The original commit message is below. AST does not have special nodes for pragmas. Instead a pragma modifies some state variables of Sema, which in turn results in modified attributes of AST nodes. This technique applies to floating point operations as well. Every AST node that can depend on FP options keeps current set of them. This technique works well for options like exception behavior or fast math options. They represent instructions to the compiler how to modify code generation for the affected nodes. However treatment of FP control modes has problems with this technique. Modifying FP control mode (like rounding direction) usually requires operations on hardware, like writing to control registers. It must be done prior to the first operation that depends on the control mode. In particular, such operations are required for implementation of `pragma STDC FENV_ROUND`, compiler should set up necessary rounding direction at the beginning of compound statement where the pragma occurs. As there is no representation for pragmas in AST, the code generation becomes a complicated task in this case. To solve this issue FP options are kept inside CompoundStmt. Unlike to FP options in expressions, these does not affect any operation on FP values, but only inform the codegen about the FP options that act in the body of the statement. As all pragmas that modify FP environment may occurs only at the start of compound statement or at global level, such solution works for all relevant pragmas. The options are kept as a difference from the options in the enclosing compound statement or default options, it helps codegen to set only changed control modes. Differential Revision: https://reviews.llvm.org/D123952
2022-07-01 18:32:26 +07:00
if (S->hasStoredFPFeatures())
Record.push_back(S->getStoredFPFeatures().getAsOpaqueInt());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00:00
Record.AddSourceLocation(S->getLBracLoc());
Record.AddSourceLocation(S->getRBracLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
if (!S->hasStoredFPFeatures())
AbbrevToUse = Writer.getCompoundStmtAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_COMPOUND;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-28 22:28:35 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getKeywordLoc());
Record.AddSourceLocation(S->getColonLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 12:30:53 +00: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-06 17:06:00 +00: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 12:30:53 +00:00
if (S->caseStmtIsGNURange()) {
Record.AddStmt(S->getRHS());
Record.AddSourceLocation(S->getEllipsisLoc());
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_CASE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getSubStmt());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_DEFAULT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-17 22:06:32 -07: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-06 17:06:00 +00:00
Record.AddDeclRef(S->getDecl());
Record.AddStmt(S->getSubStmt());
Record.AddSourceLocation(S->getIdentLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_LABEL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:33:13 +00:00
void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
VisitStmt(S);
Inline storage of attributes in AttributedStmt. llvm-svn: 159925
2012-07-09 10:04:07 +00: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-06 17:06:00 +00: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 00:33:13 +00:00
Code = serialization::STMT_ATTRIBUTED;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-27 21:12:20 +00:00
bool HasElse = S->getElse() != nullptr;
bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
bool HasInit = S->getInit() != nullptr;
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.updateBits();
CurrentPackingBits.addBit(HasElse);
CurrentPackingBits.addBit(HasVar);
CurrentPackingBits.addBit(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 08:02:53 -04: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-06 17:06:00 +00: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-27 21:12:20 +00:00
if (HasElse)
Record.AddStmt(S->getElse());
if (HasVar)
PR60985: Fix merging of lambda closure types across modules. Previously, distinct lambdas would get merged, and multiple definitions of the same lambda would not get merged, because we attempted to identify lambdas by their ordinal position within their lexical DeclContext. This failed for lambdas within namespace-scope variables and within variable templates, where the lexical position in the context containing the variable didn't uniquely identify the lambda. In this patch, we instead identify lambda closure types by index within their context declaration, which does uniquely identify them in a way that's consistent across modules. This change causes a deserialization cycle between the type of a variable with deduced type and a lambda appearing as the initializer of the variable -- reading the variable's type requires reading and merging the lambda, and reading the lambda requires reading and merging the variable. This is addressed by deferring loading the deduced type of a variable until after we finish recursive deserialization. This also exposes a pre-existing subtle issue where loading a variable declaration would trigger immediate loading of its initializer, which could recursively refer back to properties of the variable. This particularly causes problems if the initializer contains a lambda-expression, but can be problematic in general. That is addressed by switching to lazily loading the initializers of variables rather than always loading them with the variable declaration. As well as fixing a deserialization cycle, that should improve laziness of deserialization in general. LambdaDefinitionData had 63 spare bits in it, presumably caused by an off-by-one-error in some previous change. This change claims 32 of those bits as a counter for the lambda within its context. We could probably move the numbering to separate storage, like we do for the device-side mangling number, to optimize the likely-common case where all three numbers (host-side mangling number, device-side mangling number, and index within the context declaration) are zero, but that's not done in this change. Fixes #60985. Reviewed By: #clang-language-wg, aaron.ballman Differential Revision: https://reviews.llvm.org/D145737
2023-03-30 14:21:31 -07:00
Record.AddStmt(S->getConditionVariableDeclStmt());
[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-27 21:12:20 +00:00
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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getIfLoc());
[AST] add parenthesis locations for IfStmt and SwitchStmt Differential Revision: https://reviews.llvm.org/D85696
2020-08-10 16:29:33 -07: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-27 21:12:20 +00:00
if (HasElse)
Record.AddSourceLocation(S->getElseLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_IF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-29 16:12:37 +00: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-06 17:06:00 +00: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-29 16:12:37 +00:00
if (HasInit)
Record.AddStmt(S->getInit());
if (HasVar)
PR60985: Fix merging of lambda closure types across modules. Previously, distinct lambdas would get merged, and multiple definitions of the same lambda would not get merged, because we attempted to identify lambdas by their ordinal position within their lexical DeclContext. This failed for lambdas within namespace-scope variables and within variable templates, where the lexical position in the context containing the variable didn't uniquely identify the lambda. In this patch, we instead identify lambda closure types by index within their context declaration, which does uniquely identify them in a way that's consistent across modules. This change causes a deserialization cycle between the type of a variable with deduced type and a lambda appearing as the initializer of the variable -- reading the variable's type requires reading and merging the lambda, and reading the lambda requires reading and merging the variable. This is addressed by deferring loading the deduced type of a variable until after we finish recursive deserialization. This also exposes a pre-existing subtle issue where loading a variable declaration would trigger immediate loading of its initializer, which could recursively refer back to properties of the variable. This particularly causes problems if the initializer contains a lambda-expression, but can be problematic in general. That is addressed by switching to lazily loading the initializers of variables rather than always loading them with the variable declaration. As well as fixing a deserialization cycle, that should improve laziness of deserialization in general. LambdaDefinitionData had 63 spare bits in it, presumably caused by an off-by-one-error in some previous change. This change claims 32 of those bits as a counter for the lambda within its context. We could probably move the numbering to separate storage, like we do for the device-side mangling number, to optimize the likely-common case where all three numbers (host-side mangling number, device-side mangling number, and index within the context declaration) are zero, but that's not done in this change. Fixes #60985. Reviewed By: #clang-language-wg, aaron.ballman Differential Revision: https://reviews.llvm.org/D145737
2023-03-30 14:21:31 -07:00
Record.AddStmt(S->getConditionVariableDeclStmt());
[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-29 16:12:37 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getSwitchLoc());
[AST] add parenthesis locations for IfStmt and SwitchStmt Differential Revision: https://reviews.llvm.org/D85696
2020-08-10 16:29:33 -07: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-29 16:12:37 +00:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 15:08:12 +00:00
for (SwitchCase *SC = S->getSwitchCaseList(); SC;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-28 22:28:35 +00:00
Record.push_back(Writer.RecordSwitchCaseID(SC));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_SWITCH;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 13:42:41 +00: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-06 17:06:00 +00: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 13:42:41 +00:00
if (HasVar)
PR60985: Fix merging of lambda closure types across modules. Previously, distinct lambdas would get merged, and multiple definitions of the same lambda would not get merged, because we attempted to identify lambdas by their ordinal position within their lexical DeclContext. This failed for lambdas within namespace-scope variables and within variable templates, where the lexical position in the context containing the variable didn't uniquely identify the lambda. In this patch, we instead identify lambda closure types by index within their context declaration, which does uniquely identify them in a way that's consistent across modules. This change causes a deserialization cycle between the type of a variable with deduced type and a lambda appearing as the initializer of the variable -- reading the variable's type requires reading and merging the lambda, and reading the lambda requires reading and merging the variable. This is addressed by deferring loading the deduced type of a variable until after we finish recursive deserialization. This also exposes a pre-existing subtle issue where loading a variable declaration would trigger immediate loading of its initializer, which could recursively refer back to properties of the variable. This particularly causes problems if the initializer contains a lambda-expression, but can be problematic in general. That is addressed by switching to lazily loading the initializers of variables rather than always loading them with the variable declaration. As well as fixing a deserialization cycle, that should improve laziness of deserialization in general. LambdaDefinitionData had 63 spare bits in it, presumably caused by an off-by-one-error in some previous change. This change claims 32 of those bits as a counter for the lambda within its context. We could probably move the numbering to separate storage, like we do for the device-side mangling number, to optimize the likely-common case where all three numbers (host-side mangling number, device-side mangling number, and index within the context declaration) are zero, but that's not done in this change. Fixes #60985. Reviewed By: #clang-language-wg, aaron.ballman Differential Revision: https://reviews.llvm.org/D145737
2023-03-30 14:21:31 -07:00
Record.AddStmt(S->getConditionVariableDeclStmt());
[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 13:42:41 +00: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-06 17:06:00 +00: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-09 23:19:06 -04:00
Record.AddSourceLocation(S->getLParenLoc());
Record.AddSourceLocation(S->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_WHILE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::STMT_DO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitForStmt(ForStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getInit());
Record.AddStmt(S->getCond());
PR60985: Fix merging of lambda closure types across modules. Previously, distinct lambdas would get merged, and multiple definitions of the same lambda would not get merged, because we attempted to identify lambdas by their ordinal position within their lexical DeclContext. This failed for lambdas within namespace-scope variables and within variable templates, where the lexical position in the context containing the variable didn't uniquely identify the lambda. In this patch, we instead identify lambda closure types by index within their context declaration, which does uniquely identify them in a way that's consistent across modules. This change causes a deserialization cycle between the type of a variable with deduced type and a lambda appearing as the initializer of the variable -- reading the variable's type requires reading and merging the lambda, and reading the lambda requires reading and merging the variable. This is addressed by deferring loading the deduced type of a variable until after we finish recursive deserialization. This also exposes a pre-existing subtle issue where loading a variable declaration would trigger immediate loading of its initializer, which could recursively refer back to properties of the variable. This particularly causes problems if the initializer contains a lambda-expression, but can be problematic in general. That is addressed by switching to lazily loading the initializers of variables rather than always loading them with the variable declaration. As well as fixing a deserialization cycle, that should improve laziness of deserialization in general. LambdaDefinitionData had 63 spare bits in it, presumably caused by an off-by-one-error in some previous change. This change claims 32 of those bits as a counter for the lambda within its context. We could probably move the numbering to separate storage, like we do for the device-side mangling number, to optimize the likely-common case where all three numbers (host-side mangling number, device-side mangling number, and index within the context declaration) are zero, but that's not done in this change. Fixes #60985. Reviewed By: #clang-language-wg, aaron.ballman Differential Revision: https://reviews.llvm.org/D145737
2023-03-30 14:21:31 -07:00
Record.AddStmt(S->getConditionVariableDeclStmt());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00:00
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-18 23:57:32 +00:00
Code = serialization::STMT_FOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(S->getLabel());
Record.AddSourceLocation(S->getGotoLoc());
Record.AddSourceLocation(S->getLabelLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_GOTO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getGotoLoc());
Record.AddSourceLocation(S->getStarLoc());
Record.AddStmt(S->getTarget());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_INDIRECT_GOTO;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getContinueLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_CONTINUE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getBreakLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_BREAK;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 14:40:49 +00: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-06 17:06:00 +00: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 14:40:49 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getReturnLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_RETURN;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitStmt(S);
Port getStartLoc -> getBeginLoc Reviewers: teemperor! Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50349 llvm-svn: 339384
2018-08-09 21:05:56 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getEndLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(*D);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_DECL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:10:13 +00:00
void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getAsmLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:10:13 +00: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 15:57:25 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getRParenLoc());
Record.AddStmt(S->getAsmString());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
// Outputs
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00: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-06 17:06:00 +00: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 06:20:01 +00: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-06 17:06:00 +00: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 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getClobberStringLiteral(I));
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
Re-check in clang support gun asm goto after fixing tests. llvm-svn: 362410
2019-06-03 15:57:25 +00:00
// Labels
[clang] Fix label (de-)serialization in ASM statements. Differential Revision: https://reviews.llvm.org/D151073
2023-05-22 10:10:49 +00:00
for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {
Record.AddIdentifierRef(S->getLabelIdentifier(I));
Record.AddStmt(S->getLabelExpr(I));
}
Re-check in clang support gun asm goto after fixing tests. llvm-svn: 362410
2019-06-03 15:57:25 +00:00
[ms-inline asm] As part of a larger refactoring, rename AsmStmt to GCCAsmStmt. No functional change intended. llvm-svn: 162632
2012-08-25 00:11:56 +00:00
Code = serialization::STMT_GCCASM;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Etch out the code path for MS-style inline assembly. llvm-svn: 158325
2012-06-11 20:47:18 +00: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 00:10:13 +00: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-06 17:06:00 +00: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 00:10:13 +00: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-06 17:06:00 +00: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 00:10:13 +00: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-06 17:06:00 +00: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 00:10:13 +00: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-06 17:06:00 +00: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 00:10:13 +00: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-25 18:01:49 +00: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-06 17:06:00 +00: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 00:10:13 +00: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-06 17:06:00 +00: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 00:10:13 +00:00
}
[ms-inline asm] Update the AST Reader/Writer for MS-style inline asms. llvm-svn: 162629
2012-08-24 23:51:02 +00:00
Code = serialization::STMT_MSASM;
Etch out the code path for MS-style inline assembly. llvm-svn: 158325
2012-06-11 20:47:18 +00: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-25 18:01:49 +00: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 06:02:45 +00: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-25 18:01:49 +00: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 06:02:45 +00: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-25 18:01:49 +00: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 06:02:45 +00: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-25 18:01:49 +00: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-06 23:38:15 +00: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-25 18:01:49 +00: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 06:02:45 +00: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 09:11:43 +02: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 01:30:21 +02:00
Record.push_back(Satisfaction.IsSatisfied);
Reapply "[Concepts] Recover properly from a RecoveryExpr in a concept" This reverts commit 192d69f7e65a625e344421841e731e39f80595f5. This fixes the condition to check whether this is a situation where we are in a recovery-expr'ed concept a little better, so we don't access an inactive member of a union, which should make the bots happy. Differential Revision: https://reviews.llvm.org/D134542
2022-09-26 06:57:25 -07:00
Record.push_back(Satisfaction.ContainsErrors);
[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 01:30:21 +02:00
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 09:11:43 +02: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);
"Reapply "GH58368: Correct concept checking in a lambda defined in concept"" This reverts commit cecc9a92cfca71c1b6c2a35c5e302ab649496d11. The problem ended up being how we were handling the lambda-context in code generation: we were assuming any decl context here would be a named-decl, but that isn't the case. Instead, we just replace it with the concept's owning context. Differential Revision: https://reviews.llvm.org/D136451
2022-10-24 12:20:36 -07:00
Record.AddDeclRef(E->getSpecializationDecl());
Add a concept AST node. This patch adds a concept AST node (`ConceptLoc`) and uses it at the corresponding places. There are three objects that might have constraints via concepts: `TypeConstraint`, `ConceptSpecializationExpr` and `AutoTypeLoc`. The first two inherit from `ConceptReference` while the latter has the information about a possible constraint directly stored in `AutoTypeLocInfo`. It would be nice if the concept information would be stored the same way in all three cases. Moreover the current structure makes it difficult to deal with these concepts. For example in Clangd accessing the locations of constraints of a `AutoTypeLoc` can only be done with quite ugly hacks. So we think that it makes sense to create a new AST node for such concepts. In details we propose the following: - Rename `ConceptReference` to `ConceptLoc` (or something else what is approriate) and make it the new AST node. - `TypeConstraint` and `ConceptSpecializationExpr` do not longer inherit from `ConceptReference` but store a pointer to a `ConceptLoc`. - `AutoTypeLoc` stores a pointer to `ConceptLoc` instead of storing the concept info in `AutoTypeLocInfo`. This patch implements a first version of this idea which compiles and where the existing tests pass. To make this patch as small as possible we keep the existing member functions to access concept data. Later these can be replaced by directly calling the corresponding functions of the `ConceptLoc`s. Differential Revision: https://reviews.llvm.org/D155858
2023-08-02 14:00:16 +02:00
const ConceptReference *CR = E->getConceptReference();
Record.push_back(CR != nullptr);
if (CR)
Record.AddConceptReference(CR);
[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 09:11:43 +02:00
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 01:30:21 +02: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 15:24:26 +00: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 09:11:43 +02: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);
Make evaluation of nested requirement consistent with requires expr. Fixes: https://github.com/llvm/llvm-project/issues/45563 ``` template<class T> concept True = true; template <class T> concept C1 = requires (T) { requires True<typename T::value> || True<T>; }; template <class T> constexpr bool foo() requires True<typename T::value> || True<T> { return true; } static_assert(C1<double>); // Previously failed due to SFINAE error static_assert(foo<int>()); // but this works fine. ``` The issue here is the discrepancy between how a [nested requirement is evaluated](https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaTemplateInstantiate.cpp#L2331) Vs how a [non-nested requirement is evaluated](https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaConcept.cpp#L167-L200). This patch makes constraint checking consistent for nested requirement and trailing requires expressions by reusing the same evaluator. Differential Revision: https://reviews.llvm.org/D138914
2022-11-29 14:05:53 +01:00
Record.push_back(NestedReq->hasInvalidConstraint());
if (NestedReq->hasInvalidConstraint()) {
Record.AddString(NestedReq->getInvalidConstraintEntity());
addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
[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 09:11:43 +02:00
} else {
Make evaluation of nested requirement consistent with requires expr. Fixes: https://github.com/llvm/llvm-project/issues/45563 ``` template<class T> concept True = true; template <class T> concept C1 = requires (T) { requires True<typename T::value> || True<T>; }; template <class T> constexpr bool foo() requires True<typename T::value> || True<T> { return true; } static_assert(C1<double>); // Previously failed due to SFINAE error static_assert(foo<int>()); // but this works fine. ``` The issue here is the discrepancy between how a [nested requirement is evaluated](https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaTemplateInstantiate.cpp#L2331) Vs how a [non-nested requirement is evaluated](https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaConcept.cpp#L167-L200). This patch makes constraint checking consistent for nested requirement and trailing requires expressions by reusing the same evaluator. Differential Revision: https://reviews.llvm.org/D138914
2022-11-29 14:05:53 +01:00
Record.AddStmt(NestedReq->getConstraintExpr());
[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 09:11:43 +02:00
if (!NestedReq->isDependent())
addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
}
}
}
Implement mangling rules for C++20 concepts and requires-expressions. This implements proposals from: - https://github.com/itanium-cxx-abi/cxx-abi/issues/24: mangling for constraints, requires-clauses, requires-expressions. - https://github.com/itanium-cxx-abi/cxx-abi/issues/31: requires-clauses and template parameters in a lambda expression are mangled into the <lambda-sig>. - https://github.com/itanium-cxx-abi/cxx-abi/issues/47 (STEP 3): mangling for template argument is prefixed by mangling of template parameter declaration if it's not "obvious", for example because the template parameter is constrained (we already implemented STEP 1 and STEP 2). This changes the manglings for a few cases: - Functions and function templates with constraints. - Function templates with template parameters with deduced types: `typename<auto N> void f();` - Function templates with template template parameters where the argument has a different template-head: `template<template<typename...T>> void f(); f<std::vector>();` In each case where a mangling changed, the change fixes a mangling collision. Note that only function templates are affected, not class templates or variable templates, and only new constructs (template parameters with deduced types, constrained templates) and esoteric constructs (templates with template template parameters with non-matching template template arguments, most of which Clang still does not accept by default due to `-frelaxed-template-template-args` not being enabled by default), so the risk to ABI stability from this change is relatively low. Nonetheless, `-fclang-abi-compat=17` can be used to restore the old manglings for cases which we could successfully but incorrectly mangle before. Fixes #48216, #49884, #61273 Reviewed By: erichkeane, #libc_abi Differential Revision: https://reviews.llvm.org/D147655
2023-09-12 18:53:54 -07:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
[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 09:11:43 +02:00
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 15:24:26 +00: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-16 18:53:08 +00: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-03 19:20:19 +00: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 03:59:06 +00: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-06 17:06:00 +00: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 03:59:06 +00: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-06 17:06:00 +00: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-03 19:20:19 +00: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-14 19:41:04 +00: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-06 17:06:00 +00: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-03 19:20:19 +00: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-06 17:06:00 +00: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-03 19:20:19 +00: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-14 18:08:33 +00: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 12:21:55 +00: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-06 17:06:00 +00: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-03 19:20:19 +00: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-06 17:06:00 +00: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-14 18:08:33 +00: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-06 17:06:00 +00: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-03 19:20:19 +00: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-16 18:53:08 +00: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-03 19:20:19 +00: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-16 18:53:08 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitExpr(Expr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitStmt(E);
Recommit [NFC] [Serialization] Packing more bits This patch tries to reduce the size of the BMIs by packing more bits into an unsigned integer. This patch was reverted due to buildbot failure report. But it should be irrevelent after I took a double look. So I tried to recommit this NFC change again.
2023-12-07 17:01:06 +08:00
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.updateBits();
CurrentPackingBits.addBits(E->getDependence(), /*BitsWidth=*/5);
CurrentPackingBits.addBits(E->getValueKind(), /*BitsWidth=*/2);
CurrentPackingBits.addBits(E->getObjectKind(), /*BitsWidth=*/3);
Revert "[NFC] [Serialization] Packing more bits and refactor AbbrevToUse" This reverts commit 9cdb825a4f1bf9e75829d03879620c6144d0b7bc.
2023-12-15 14:30:24 -08:00
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
Record.AddTypeRef(E->getType());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 03:48:47 +00: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 13:02:48 +01: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][NFC] Refactor `ConstantExpr::ResultStorageKind` This patch converts `ConstantExpr::ResultStorageKind` to a scoped enum in namespace scoped `ConstantResultStorageKind`. This patch makes it possible to forward-declare this enum where it's necessery, e.g. for `preferred_type` annotation for bit-fields.
2023-11-04 13:28:02 +03:00
switch (E->getResultStorageKind()) {
case ConstantResultStorageKind::None:
[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 13:02:48 +01:00
break;
[clang][NFC] Refactor `ConstantExpr::ResultStorageKind` This patch converts `ConstantExpr::ResultStorageKind` to a scoped enum in namespace scoped `ConstantResultStorageKind`. This patch makes it possible to forward-declare this enum where it's necessery, e.g. for `preferred_type` annotation for bit-fields.
2023-11-04 13:28:02 +03:00
case ConstantResultStorageKind::Int64:
[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 10:24:47 +00:00
Record.push_back(E->Int64Result());
break;
[clang][NFC] Refactor `ConstantExpr::ResultStorageKind` This patch converts `ConstantExpr::ResultStorageKind` to a scoped enum in namespace scoped `ConstantResultStorageKind`. This patch makes it possible to forward-declare this enum where it's necessery, e.g. for `preferred_type` annotation for bit-fields.
2023-11-04 13:28:02 +03:00
case ConstantResultStorageKind::APValue:
[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 10:24:47 +00:00
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 13:02:48 +01:00
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 10:24:47 +00: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 13:02:48 +01: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 03:48:47 +00: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 08:22:35 -07: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-18 23:56:27 +00:00
void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-27 19:21:19 +00:00
bool HasFunctionName = E->getFunctionName() != nullptr;
Record.push_back(HasFunctionName);
[clang][NFC] Refactor `PredefinedExpr::IdentKind` This patch converts `PredefinedExpr::IdentKind` into a scoped enum in namespace scope, making it eligible for forward declaring. This is useful in certain contexts, such as `preferred_type` annotations on bit-fields.
2023-11-05 15:36:50 +03:00
Record.push_back(
llvm::to_underlying(E->getIdentKind())); // FIXME: stable encoding
Reland [clang] Make predefined expressions string literals under -fms-extensions MSVC makes these string literals [1][2]. [1] https://godbolt.org/z/6vnTzbExx [2] https://learn.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=msvc-170 Fixes #114 Initial commit didn't check if there was a function name when stepping through expressions ignoring parens. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D146764
2023-05-07 11:24:48 -07:00
Record.push_back(E->isTransparent());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00: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-27 19:21:19 +00:00
if (HasFunctionName)
Record.AddStmt(E->getFunctionName());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_PREDEFINED;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitExpr(E);
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 13:09:47 +00:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->hadMultipleCandidates());
CurrentPackingBits.addBit(E->refersToEnclosingVariableOrCapture());
CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2);
CurrentPackingBits.addBit(E->isImmediateEscalating());
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.addBit(E->getDecl() != E->getFoundDecl());
CurrentPackingBits.addBit(E->hasQualifier());
CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 13:09:47 +00:00
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00: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 12:01:24 +00:00
unsigned NumTemplateArgs = E->getNumTemplateArgs();
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(NumTemplateArgs);
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 12:01:24 +00:00
}
Read/write the C++ parts of DeclRefExpr and MemberExpr for PCH. llvm-svn: 107872
2010-07-08 13:09:47 +00: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 02:27:19 +00: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 09:46:47 +00: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 02:27:19 +00:00
(E->getDecl() == E->getFoundDecl()) &&
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
nk == DeclarationName::Identifier && E->getObjectKind() == OK_Ordinary) {
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 02:27:19 +00: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-06 18:19:42 +00: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-06 17:06:00 +00: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-06 18:19:42 +00: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-01 23:48:14 +00: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-06 17:06:00 +00: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-01 23:48:14 +00:00
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00: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-29 18:15:14 +00: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-06 18:19:42 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::EXPR_DECL_REF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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 02:27:19 +00:00
if (E->getValue().getBitWidth() == 32) {
AbbrevToUse = Writer.getIntegerLiteralAbbrev();
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_INTEGER_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-20 17:19:40 +00: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-07 14:46:08 -05: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-20 17:19:40 +00: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-07 14:46:08 -05: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-20 17:19:40 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 09:46:51 +00:00
Record.push_back(E->getRawSemantics());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddAPFloat(E->getValue());
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_FLOATING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_IMAGINARY_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-15 17:31:16 +00:00
// Store the various bits of data of StringLiteral.
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-15 17:31:16 +00:00
Record.push_back(E->getLength());
Record.push_back(E->getCharByteWidth());
[clang][NFC] Refactor `StringLiteral::StringKind` This patch converts `StringLiteral::StringKind` to a scoped enum in namespace scope. This enabled forward-declarations of this enum where necessary, e.g. for `preferred_type` annotation for bit-fields.
2023-11-05 12:27:31 +03:00
Record.push_back(llvm::to_underlying(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 00:40:03 +00: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-15 17:31:16 +00:00
// Store the trailing array of SourceLocation.
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-15 17:31:16 +00: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-18 23:57:32 +00:00
Code = serialization::EXPR_STRING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLocation());
[clang][NFC] Refactor `CharacterLiteral::CharacterKind` This patch converts `CharacterLiteral::CharacterKind` to scoped enum in namespace scope. This enables forward declaration of this enum, which is useful in case like annotating bit-fields with `preferred_type`.
2023-11-05 13:35:38 +03:00
Record.push_back(llvm::to_underlying(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 02:27:19 +00:00
AbbrevToUse = Writer.getCharacterLiteralAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CHARACTER_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLParen());
Record.AddSourceLocation(E->getRParen());
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_PAREN;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 08:49:18 +00: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-20 16:20:40 +00: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-18 23:57:32 +00:00
Code = serialization::EXPR_PAREN_LIST;
Support ParenListExpr for PCH. llvm-svn: 107266
2010-06-30 08:49:18 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-01 10:32:06 -07:00
bool HasFPFeatures = E->hasStoredFPFeatures();
// Write this first for easy access when deserializing, as they affect the
// size of the UnaryOperator.
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(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 08:31:08 +00:00
Record.AddStmt(E->getSubExpr());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBits(E->getOpcode(),
/*Width=*/5); // FIXME: stable encoding
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 08:31:08 +00:00
Record.AddSourceLocation(E->getOperatorLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(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-01 10:32:06 -07: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 08:31:08 +00:00
Code = serialization::EXPR_UNARY_OPERATOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-28 22:16:22 +00: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-06 17:06:00 +00: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-28 22:16:22 +00: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-29 22:31:18 +00: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-28 22:16:22 +00: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-06 17:06:00 +00: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-28 22:16:22 +00:00
switch (ON.getKind()) {
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-29 22:31:18 +00: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-28 22:16:22 +00:00
Record.push_back(ON.getArrayExprIndex());
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-29 22:31:18 +00: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-06 17:06:00 +00: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-28 22:16:22 +00:00
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-29 22:31:18 +00: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-06 17:06:00 +00: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-28 22:16:22 +00:00
break;
[TrailingObjects] Convert OffsetOfExpr. That necessitated moving the OffsetOfNode class out of OffsetOfExpr. llvm-svn: 256590
2015-12-29 22:31:18 +00: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-06 17:06:00 +00: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 00:18:15 +00: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-28 22:16:22 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getIndexExpr(I));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00: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-28 22:16:22 +00: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-11 19:24:49 +00:00
void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-11 19:24:49 +00:00
Record.push_back(E->getKind());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getArgumentExpr());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getOperatorLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_SIZEOF_ALIGN_OF;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getLHS());
Record.AddStmt(E->getRHS());
Record.AddSourceLocation(E->getRBracketLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_ARRAY_SUBSCRIPT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-01 19:42:03 +01: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 14:24:04 +00: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-06 17:06:00 +00: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-09 13:27:32 -05: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-06 17:06:00 +00: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 14:24:04 +00: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 09:33:05 -05: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-01 15:06:38 -04: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 11:21:43 -04: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-01 15:06:38 -04:00
}
Code = serialization::EXPR_OMP_ITERATOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitExpr(E);
Recommit [NFC] [Serialization] Packing more bits This patch tries to reduce the size of the BMIs by packing more bits into an unsigned integer. This patch was reverted due to buildbot failure report. But it should be irrevelent after I took a double look. So I tried to recommit this NFC change again.
2023-12-07 17:01:06 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(E->getNumArgs());
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(static_cast<bool>(E->getADLCallKind()));
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.addBit(E->hasStoredFPFeatures());
Recommit [NFC] [Serialization] Packing more bits This patch tries to reduce the size of the BMIs by packing more bits into an unsigned integer. This patch was reverted due to buildbot failure report. But it should be irrevelent after I took a double look. So I tried to recommit this NFC change again.
2023-12-07 17:01:06 +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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getRParenLoc());
Record.AddStmt(E->getCallee());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(*Arg);
Recommit [NFC] [Serialization] Packing more bits This patch tries to reduce the size of the BMIs by packing more bits into an unsigned integer. This patch was reverted due to buildbot failure report. But it should be irrevelent after I took a double look. So I tried to recommit this NFC change again.
2023-12-07 17:01:06 +08:00
[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 12:04:19 +07:00
if (E->hasStoredFPFeatures())
Record.push_back(E->getFPFeatures().getAsOpaqueInt());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&
E->getStmtClass() == Stmt::CallExprClass)
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
AbbrevToUse = Writer.getCallExprAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CALL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 16:30:40 +01: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-18 23:56:27 +00: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-06 23:24:15 +00: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 11:46:57 +00: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-06 23:24:15 +00:00
bool HasQualifier = E->hasQualifier();
[Clang][AST][NFC] MemberExpr stores NestedNameSpecifierLoc and DeclAccessPair separately (#86678) Currently, `MemberExpr` allocates a trailing `MemberExprNameQualifier` object if it either has a `NestedNameSpecifierLoc`, or if it names a member found via using declaration. Since the presence of a _nested-name-specifier_ does not necessarily imply the named member was found via using declaration, this patch removes `MemberExprNameQualifier` and allocates the members separately.
2024-04-02 10:27:18 -04:00
bool HasFoundDecl = E->hasFoundDecl();
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-06 23:24:15 +00:00
bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
unsigned NumTemplateArgs = E->getNumTemplateArgs();
// Write these first for easy access when deserializing, as they affect the
// size of the MemberExpr.
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(HasQualifier);
CurrentPackingBits.addBit(HasFoundDecl);
CurrentPackingBits.addBit(HasTemplateInfo);
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
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 11:46:57 +00: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-06 17:06:00 +00: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-06 23:24:15 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getMemberLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->isArrow());
CurrentPackingBits.addBit(E->hadMultipleCandidates());
CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/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-06 17:06:00 +00: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-06 23:24:15 +00:00
[Clang][AST][NFC] MemberExpr stores NestedNameSpecifierLoc and DeclAccessPair separately (#86678) Currently, `MemberExpr` allocates a trailing `MemberExprNameQualifier` object if it either has a `NestedNameSpecifierLoc`, or if it names a member found via using declaration. Since the presence of a _nested-name-specifier_ does not necessarily imply the named member was found via using declaration, this patch removes `MemberExprNameQualifier` and allocates the members separately.
2024-04-02 10:27:18 -04:00
if (HasQualifier)
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
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-06 23:24:15 +00:00
if (HasFoundDecl) {
DeclAccessPair FoundDecl = E->getFoundDecl();
Record.AddDeclRef(FoundDecl.getDecl());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBits(FoundDecl.getAccess(), /*BitWidth=*/2);
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-06 23:24:15 +00:00
}
if (HasTemplateInfo)
AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
E->getTrailingObjects<TemplateArgumentLoc>());
Fix a few line endings. NFC. llvm-svn: 236301
2015-05-01 02:04:32 +00: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-24 17:54:45 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-24 17:54:45 +00: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-06 17:06:00 +00: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-24 17:54:45 +00:00
Record.push_back(E->isArrow());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_ISA;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-15 23:02:42 +00: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-06 17:06:00 +00: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-15 23:02:42 +00: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-06 17:06:00 +00: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-15 23:02:42 +00: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-18 23:56:27 +00:00
void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitExpr(E);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
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 06:22:56 +00:00
Record.push_back(E->path_size());
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
// 7 bits should be enough to store the casting kinds.
CurrentPackingBits.addBits(E->getCastKind(), /*Width=*/7);
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.addBit(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-06 17:06:00 +00:00
Record.AddStmt(E->getSubExpr());
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 06:22:56 +00: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-06 17:06:00 +00: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 21:54:14 +07:00
if (E->hasStoredFPFeatures())
Record.push_back(E->getFPFeatures().getAsOpaqueInt());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitExpr(E);
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Move BinaryOperators.FPOptions to trailing storage Reviewers: rjmccall Differential Revision: https://reviews.llvm.org/D76384
2020-04-10 13:34:46 -07:00
// Write this first for easy access when deserializing, as they affect the
// size of the UnaryOperator.
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBits(E->getOpcode(), /*Width=*/6);
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
bool HasFPFeatures = E->hasStoredFPFeatures();
CurrentPackingBits.addBit(HasFPFeatures);
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00: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-10 13:34:46 -07:00
if (HasFPFeatures)
Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
if (!HasFPFeatures && E->getValueKind() == VK_PRValue &&
E->getObjectKind() == OK_Ordinary)
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
AbbrevToUse = Writer.getBinaryOperatorAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_BINARY_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddTypeRef(E->getComputationLHSType());
Record.AddTypeRef(E->getComputationResultType());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
if (!E->hasStoredFPFeatures() && E->getValueKind() == VK_PRValue &&
E->getObjectKind() == OK_Ordinary)
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
AbbrevToUse = Writer.getCompoundAssignOperatorAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::EXPR_CONDITIONAL_OPERATOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 10:25:35 +00: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-06 17:06:00 +00: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 10:25:35 +00:00
Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitCastExpr(E);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(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 04:19:32 +00: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 21:54:14 +07: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 04:19:32 +00:00
AbbrevToUse = Writer.getExprImplicitCastAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_IMPLICIT_CAST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CSTYLE_CAST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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 06:20:01 +00:00
Record.push_back(E->isFileScope());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_COMPOUND_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getBase());
Record.AddIdentifierRef(&E->getAccessor());
Record.AddSourceLocation(E->getAccessorLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-08 18:41:43 +00: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-06 17:06:00 +00: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 00:27:41 +00: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-06 17:06:00 +00: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 00:27:41 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(E->getInitializedFieldInUnion());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 05:29:30 +00: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-06 17:06:00 +00: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 05:29:30 +00: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-06 17:06:00 +00: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 05:29:30 +00:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_INIT_LIST;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getSubExpr(I));
Record.AddSourceLocation(E->getEqualOrColonLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
Record.push_back(E->usesGNUSyntax());
Revert "[Clang] Refactor "Designators" into a unified implementation [NFC]" This reverts commit 3c07db5f58e9852f35202f0fffed50fc7506f37b. This caused https://github.com/llvm/llvm-project/issues/61118. Reverting to ensure this is a pure NFC change.
2023-03-02 12:08:07 -08:00
for (const DesignatedInitExpr::Designator &D : E->designators()) {
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 00:15:04 +00:00
if (D.isFieldDesignator()) {
[Clang][NFC] Rename methods/vars to reflect their real usage The "getField" method is a bit confusing considering we also have a "getFieldName" method. Instead, use "getFieldDecl" rather than "getField". Differential Revision: https://reviews.llvm.org/D147743
2023-04-17 16:31:42 -07:00
if (FieldDecl *Field = D.getFieldDecl()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(Field);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
} else {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00: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 00:15:04 +00:00
Record.AddIdentifierRef(D.getFieldName());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:15:04 +00:00
Record.AddSourceLocation(D.getDotLoc());
Record.AddSourceLocation(D.getFieldLoc());
} else if (D.isArrayDesignator()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Record.push_back(serialization::DESIG_ARRAY);
[Clang][NFC] Refactor "Designators" to be more similar This makes the two interfaces for designators more similar so that it's easier to merge them together in a future refactoring. Differential Revision: https://reviews.llvm.org/D147580
2023-04-04 16:17:52 -07:00
Record.push_back(D.getArrayIndex());
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 00:15:04 +00:00
Record.AddSourceLocation(D.getLBracketLoc());
Record.AddSourceLocation(D.getRBracketLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:15:04 +00:00
assert(D.isArrayRangeDesignator() && "Unknown designator");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Record.push_back(serialization::DESIG_ARRAY_RANGE);
[Clang][NFC] Refactor "Designators" to be more similar This makes the two interfaces for designators more similar so that it's easier to merge them together in a future refactoring. Differential Revision: https://reviews.llvm.org/D147580
2023-04-04 16:17:52 -07:00
Record.push_back(D.getArrayIndex());
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 00:15:04 +00:00
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 06:20:01 +00:00
}
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_DESIGNATED_INIT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:27:52 +00: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-06 17:06:00 +00: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 00:27:52 +00: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 02:53:20 +00: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-18 23:56:27 +00:00
void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
VisitExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-17 20:55:33 +00:00
Record.push_back(E->isMicrosoftABI());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_VA_ARG;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-16 21:04:15 +00:00
void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
VisitExpr(E);
Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
Record.AddSourceLocation(E->getBeginLoc());
Record.AddSourceLocation(E->getEndLoc());
[clang][NFC] Refactor `SourceLocExpr::IdentKind` This patch converts `SourceLocExpr::IdentKind` into a scoped enum at namespace scope, making it eligible to be forward-declared. This is needed by `preferred_type` annotations on bit-fields.
2023-11-04 12:42:54 +03:00
Record.push_back(llvm::to_underlying(E->getIdentKind()));
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-16 21:04:15 +00:00
Code = serialization::EXPR_SOURCE_LOC;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getAmpAmpLoc());
Record.AddSourceLocation(E->getLabelLoc());
Record.AddDeclRef(E->getLabel());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_ADDR_LABEL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-09 17:34:33 -07:00
Record.push_back(E->getTemplateDepth());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_STMT;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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 00:40:58 +00:00
Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CHOOSE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getTokenLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_GNU_NULL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getExpr(I));
Record.AddSourceLocation(E->getBuiltinLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_SHUFFLE_VECTOR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 03:29:45 +00: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-06 17:06:00 +00: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 03:29:45 +00:00
Code = serialization::EXPR_CONVERT_VECTOR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(E->getBlockDecl());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_BLOCK;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:35:48 +00: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 14:15:10 +00: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 00:35:48 +00:00
Record.push_back(E->getNumAssocs());
[C] Support _Generic expressions with a type operand _Generic accepts an expression operand whose type is matched against a list of associations. The expression operand is unevaluated, but the type matched is the type after lvalue conversion. This conversion loses type information, which makes it more difficult to match against qualified or incomplete types. This extension allows _Generic to accept a type operand instead of an expression operand. The type operand form does not undergo any conversions and is matched directly against the association list. This extension is also supported in C++ as we already supported _Generic selection expressions there. The RFC for this extension can be found at: https://discourse.llvm.org/t/rfc-generic-selection-expression-with-a-type-operand/70388 Differential Revision: https://reviews.llvm.org/D149904
2023-06-05 11:03:14 -04:00
Record.push_back(E->isExprPredicate());
[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 13:58:15 +00: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-06 17:06:00 +00: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 14:15:10 +00: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 00:35:48 +00: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 09:01:30 +00: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-06 17:06:00 +00: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 09:01:30 +00: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-06 17:06:00 +00: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 09:01:30 +00: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 06:20:27 +00: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 09:01:30 +00:00
}
Initial implementation of __atomic_* (everything except __atomic_is_lock_free). llvm-svn: 141632
2011-10-11 02:20:01 +00: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-10 22:49:28 +00: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-06 17:06:00 +00: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 06:20:27 +00:00
Code = serialization::EXPR_ATOMIC;
Initial implementation of __atomic_* (everything except __atomic_is_lock_free). llvm-svn: 141632
2011-10-11 02:20:01 +00:00
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
//===----------------------------------------------------------------------===//
// Objective-C Expressions and Statements.
//===----------------------------------------------------------------------===//
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getString());
Record.AddSourceLocation(E->getAtLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_STRING_LITERAL;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Implements boxed expressions for Objective-C. <rdar://problem/10194391> llvm-svn: 155082
2012-04-19 00:25:12 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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 00:25:12 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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-06 20:05:56 +00: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-30 19:24:48 +00: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-06 17:06:00 +00: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-06 20:05:56 +00:00
Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
Record.AddSourceLocation(E->getAtLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_ENCODE;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00:00
Record.AddSelectorRef(E->getSelector());
Record.AddSourceLocation(E->getAtLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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 06:20:01 +00:00
Record.push_back(E->isArrow());
Record.push_back(E->isFreeIvar());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 00:19:18 +00:00
Record.push_back(E->SetterAndMethodRefFlags.getInt());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 01:19:52 +00: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-06 17:06:00 +00: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 01:19:52 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(E->getExplicitProperty());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 01:19:52 +00: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-06 17:06:00 +00: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 01:19:52 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getBase());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 01:19:52 +00: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-06 17:06:00 +00:00
Record.AddTypeRef(E->getSuperReceiverType());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 01:19:52 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(E->getClassReceiver());
Simplify the ASTs by consolidating ObjCImplicitGetterSetterExpr and ObjCPropertyRefExpr into the latter. llvm-svn: 120643
2010-12-02 01:19:52 +00:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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-30 19:24:48 +00: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-06 20:05:56 +00:00
Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 06:36:51 +00: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-15 23:02:42 +00: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 02:34:39 +00: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 00:45:42 +00: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-06 17:06:00 +00: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 00:45:42 +00: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-06 17:06:00 +00: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 00:45:42 +00: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-06 17:06:00 +00: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 00:45:42 +00: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-06 17:06:00 +00: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 00:45:42 +00: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-30 19:24:48 +00: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 00:45:42 +00:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLeftLoc());
Record.AddSourceLocation(E->getRightLoc());
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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 06:36:51 +00: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-06 17:06:00 +00: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 06:36:51 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_FOR_COLLECTION;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-12 21:31:00 +00: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-06 17:06:00 +00: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-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_CATCH;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-12 21:31:00 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getFinallyBody());
Record.AddSourceLocation(S->getAtFinallyLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_FINALLY;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-15 23:02:42 +00: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-12 21:31:00 +00: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-06 17:06:00 +00: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-15 23:02:42 +00:00
Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-12 21:31:00 +00: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-23 22:50:49 +00:00
Record.push_back(S->getNumCatchStmts());
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 05:54:18 +00: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-06 17:06:00 +00: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 10:53:33 -04: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-23 22:50:49 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getFinallyStmt());
Record.AddSourceLocation(S->getAtTryLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_AT_TRY;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-12 21:31:00 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getSynchExpr());
Record.AddStmt(S->getSynchBody());
Record.AddSourceLocation(S->getAtSynchronizedLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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-12 21:31:00 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getThrowExpr());
Record.AddSourceLocation(S->getThrowLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_OBJC_AT_THROW;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 20:05:56 +00: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-06 17:06:00 +00: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-06 20:05:56 +00: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 00:35:23 +00: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 03:19:21 +00:00
//===----------------------------------------------------------------------===//
// C++ Expressions and Statements.
//===----------------------------------------------------------------------===//
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-22 16:03:56 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getCatchLoc());
Record.AddDeclRef(S->getExceptionDecl());
Record.AddStmt(S->getHandlerBlock());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_CXX_CATCH;
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-22 16:03:56 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-22 16:03:56 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(S->getTryLoc());
Record.AddStmt(S->getTryBlock());
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-22 16:03:56 +00: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-06 17:06:00 +00:00
Record.AddStmt(S->getHandler(i));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::STMT_CXX_TRY;
Support C++ try/catch statements for PCH. llvm-svn: 109112
2010-07-22 16:03:56 +00: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-14 22:09:26 +00: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-06 17:06:00 +00: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-28 18:44:09 +00: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-06 17:06:00 +00: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-14 22:09:26 +00: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 01:33:02 +00: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-06 17:06:00 +00: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 01:33:02 +00: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-06 17:06:00 +00: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 01:33:02 +00:00
Code = serialization::STMT_MS_DEPENDENT_EXISTS;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 03:19:21 +00:00
VisitCallExpr(E);
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
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 08:45:12 -07:00
Record.AddSourceRange(E->Range);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
AbbrevToUse = Writer.getCXXOperatorCallExprAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_OPERATOR_CALL;
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 03:19:21 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00: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 05:36:05 +00:00
VisitCallExpr(E);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
AbbrevToUse = Writer.getCXXMemberCallExprAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00: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 05:36:05 +00: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 00:04:38 +00: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-18 23:56:27 +00: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-09 23:08:42 +00: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 14:39:30 +00:00
Fix broken de/serialization for a couple of C++ Exprs. llvm-svn: 106726
2010-06-24 08:57:09 +00: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-09 23:08:42 +00:00
Record.push_back(E->isElidable());
Added a flag to identify resolved overloaded function references. llvm-svn: 141171
2011-10-05 07:56:41 +00: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 01:39:02 +00: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 05:12:35 +00: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-16 18:50:27 +00:00
Record.push_back(E->requiresZeroInitialization());
[clang][NFC] Refactor `CXXConstructExpr::ConstructionKind` This patch converts `CXXConstructExpr::ConstructionKind` into a scoped enum in namespace scope, making it eligible for forward declaring. This is useful in cases like annotating bit-fields with `preferred_type`.
2023-11-05 16:38:10 +03:00
Record.push_back(
llvm::to_underlying(E->getConstructionKind())); // FIXME: stable encoding
[clang] Implement P2564 "consteval must propagate up" Reviewed By: aaron.ballman, #clang-language-wg Differential Revision: https://reviews.llvm.org/D151094
2023-05-08 12:18:43 +02:00
Record.push_back(E->isImmediateEscalating());
[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 14:39:30 +00: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-06 17:06:00 +00: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 14:39:30 +00: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-18 23:57:32 +00: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-09 23:08:42 +00: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-28 19:03:57 +00: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-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
Add PCH support for the remaining C++ exprs. llvm-svn: 108042
2010-07-10 11:46:15 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
Add PCH support for the remaining C++ exprs. llvm-svn: 108042
2010-07-10 11:46:15 +00: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 10:09:13 +00: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 14:17:03 +01: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-06 17:06:00 +00: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 14:17:03 +01: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-06 17:06:00 +00: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 14:17:03 +01: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->ClosingBrace);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-14 17:54:36 +00: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-06 17:06:00 +00:00
Record.AddStmt(*C);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-14 17:54:36 +00:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00: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 14:13:35 +01: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 12:51:11 +01:00
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-14 17:54:36 +00: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 10:09:13 +00: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-12 22:31:48 +00: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-06 17:06:00 +00: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-12 22:31:48 +00:00
Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00: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-06 17:06:00 +00:00
Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->getAngleBrackets().isValid());
if (E->getAngleBrackets().isValid())
Record.AddSourceRange(E->getAngleBrackets());
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_STATIC_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_DYNAMIC_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_REINTERPRET_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00:00
VisitCXXNamedCastExpr(E);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_CONST_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00: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 11:02:01 +01: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-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-16 21:21:01 +00: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-02 18:28:13 +00: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-11 12:30:16 -04: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-02 18:28:13 +00: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 08:35:16 +00: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-06 17:06:00 +00: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 08:35:16 +00:00
Code = serialization::EXPR_USER_DEFINED_LITERAL;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 06:32:43 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_BOOL_LITERAL;
Roll r95513 back in. llvm-svn: 95515
2010-02-07 06:32:43 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 06:32:43 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLocation());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
Roll r95513 back in. llvm-svn: 95515
2010-02-07 06:32:43 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
pch'ify typeid. llvm-svn: 103374
2010-05-09 06:03:39 +00: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-06 17:06:00 +00:00
Record.AddSourceRange(E->getSourceRange());
pch'ify typeid. llvm-svn: 103374
2010-05-09 06:03:39 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_TYPEID_TYPE;
pch'ify typeid. llvm-svn: 103374
2010-05-09 06:03:39 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getExprOperand());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_TYPEID_EXPR;
pch'ify typeid. llvm-svn: 103374
2010-05-09 06:03:39 +00:00
}
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 06:15:05 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getLocation());
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 06:15:05 +00:00
Record.push_back(E->isImplicit());
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_THIS;
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 06:15:05 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 06:40:08 +00: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-06 17:06:00 +00: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-06 22:04:06 +00:00
Record.push_back(E->isThrownVariableInScope());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_THROW;
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 06:15:05 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 06:40:08 +00: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-06 17:06:00 +00: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-16 21:04:15 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getUsedLocation());
Implement CWG2631 Implement https://cplusplus.github.io/CWG/issues/2631.html. Immediate calls in default arguments and defaults members are not evaluated. Instead, we evaluate them when constructing a `CXXDefaultArgExpr`/`BuildCXXDefaultInitExpr`. The immediate calls are executed by doing a transform on the initializing expression. Note that lambdas are not considering subexpressions so we do not need to transform them. As a result of this patch, unused default member initializers are not considered odr-used, and errors about members binding to local variables in an outer scope only surface at the point where a constructor is defined. Reviewed By: aaron.ballman, #clang-language-wg, rupprecht Differential Revision: https://reviews.llvm.org/D136554
2022-10-23 17:32:58 +02:00
Record.push_back(E->hasRewrittenInit());
if (E->hasRewrittenInit())
Record.AddStmt(E->getRewrittenExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_DEFAULT_ARG;
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 06:40:08 +00: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-20 22:23:05 +00:00
void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
VisitExpr(E);
Implement CWG2631 Implement https://cplusplus.github.io/CWG/issues/2631.html. Immediate calls in default arguments and defaults members are not evaluated. Instead, we evaluate them when constructing a `CXXDefaultArgExpr`/`BuildCXXDefaultInitExpr`. The immediate calls are executed by doing a transform on the initializing expression. Note that lambdas are not considering subexpressions so we do not need to transform them. As a result of this patch, unused default member initializers are not considered odr-used, and errors about members binding to local variables in an outer scope only surface at the point where a constructor is defined. Reviewed By: aaron.ballman, #clang-language-wg, rupprecht Differential Revision: https://reviews.llvm.org/D136554
2022-10-23 17:32:58 +02:00
Record.push_back(E->hasRewrittenInit());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00: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-16 21:04:15 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getExprLoc());
Implement CWG2631 Implement https://cplusplus.github.io/CWG/issues/2631.html. Immediate calls in default arguments and defaults members are not evaluated. Instead, we evaluate them when constructing a `CXXDefaultArgExpr`/`BuildCXXDefaultInitExpr`. The immediate calls are executed by doing a transform on the initializing expression. Note that lambdas are not considering subexpressions so we do not need to transform them. As a result of this patch, unused default member initializers are not considered odr-used, and errors about members binding to local variables in an outer scope only surface at the point where a constructor is defined. Reviewed By: aaron.ballman, #clang-language-wg, rupprecht Differential Revision: https://reviews.llvm.org/D136554
2022-10-23 17:32:58 +02:00
if (E->hasRewrittenInit())
Record.AddStmt(E->getRewrittenExpr());
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-20 22:23:05 +00:00
Code = serialization::EXPR_CXX_DEFAULT_INIT;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 00:25:06 +00: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-06 17:06:00 +00:00
Record.AddCXXTemporary(E->getTemporary());
Record.AddStmt(E->getSubExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_BIND_TEMPORARY;
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 00:25:06 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 01:22:27 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddSourceLocation(E->getRParenLoc());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 01:22:27 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 01:22:27 +00: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 15:04:45 +00: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 11:35:52 +00: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 15:04:45 +00: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-10 18:54:32 +00: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 12:22:20 +00:00
Record.push_back(E->doesUsualArrayDeleteWantSize());
[clang] Remove `CXXNewInitializationStyle::Implicit` (#78793) This is a follow up to https://github.com/llvm/llvm-project/pull/71417 , which aims to resolve concerns brought up there. Namely, this patch replaces `CXXNewInitializationStyle::Implicit` with a dedicated `HasInitializer` flag. This makes `CXXNewInitializationStyle` to model syntax again. This patch also renames `Call` and `List` to less confusing `Parens` and `Braces`.
2024-01-22 00:42:50 +04:00
Record.push_back(E->CXXNewExprBits.HasInitializer);
[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 15:04:45 +00: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-06 17:06:00 +00: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 15:04:45 +00: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-06 17:06:00 +00: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 15:04:45 +00: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-06 17:06:00 +00: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 12:22:20 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_NEW;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 01:22:27 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-22 17:07:59 +00: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-13 20:15:54 +00: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 09:37:56 +00: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-06 17:06:00 +00: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 12:32:32 +00:00
Record.AddSourceLocation(E->getBeginLoc());
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_DELETE;
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-22 17:07:59 +00:00
}
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 01:22:27 +00:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getBase());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00: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-06 17:06:00 +00: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 09:32:03 +00: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-06 17:06:00 +00:00
Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00: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-06 17:06:00 +00:00
Record.AddSourceLocation(E->getDestroyedTypeLoc());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00: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-06 17:06:00 +00:00
Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 09:32:03 +00: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 08:20:24 +00:00
void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 00:25:06 +00: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 05:35:25 +00: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-10 14:06:25 -07: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-21 20:29:17 +00: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-06 17:06:00 +00: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 08:20:24 +00:00
Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 00:25:06 +00: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 14:17:00 +00:00
void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
CXXDependentScopeMemberExpr *E) {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00: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 14:17:00 +00:00
// Don't emit anything here (or if you do you will have to update
// the corresponding deserialization function).
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(E->getNumTemplateArgs());
CurrentPackingBits.updateBits();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00: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 14:17:00 +00: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-29 18:15:14 +00: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 08:57:31 +00:00
}
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00:00
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->isArrow());
[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 14:17:00 +00:00
Record.AddTypeRef(E->getBaseType());
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(!E->isImplicitAccess());
Revert "[NFC] [Serialization] Packing more bits and refactor AbbrevToUse" This reverts commit 9cdb825a4f1bf9e75829d03879620c6144d0b7bc.
2023-12-15 14:30:24 -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-06 17:06:00 +00:00
Record.AddStmt(E->getBase());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
Record.AddSourceLocation(E->getOperatorLoc());
[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 14:17:00 +00: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-06 17:06:00 +00:00
Record.AddDeclarationNameInfo(E->MemberNameInfo);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00:00
}
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 09:31:56 +00:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 09:31:56 +00:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00: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 12:01:24 +00:00
// emitted first.
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(
E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00: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 14:27:04 +00:00
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-29 18:15:14 +00:00
const ASTTemplateKWAndArgsInfo &ArgInfo =
*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
// 16 bits should be enought to store the number of args
CurrentPackingBits.addBits(ArgInfo.NumTemplateArgs, /*Width=*/16);
[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-29 18:15:14 +00:00
AddTemplateKWAndArgsInfo(ArgInfo,
E->getTrailingObjects<TemplateArgumentLoc>());
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 09:31:56 +00: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-06 17:06:00 +00:00
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Record.AddDeclarationNameInfo(E->NameInfo);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 09:31:56 +00:00
}
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00: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-30 16:49:24 +00:00
Record.push_back(E->getNumArgs());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00: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-06 17:06:00 +00:00
Record.AddStmt(*ArgI);
Record.AddTypeSourceInfo(E->getTypeSourceInfo());
Record.AddSourceLocation(E->getLParenLoc());
Record.AddSourceLocation(E->getRParenLoc());
Model list initialization more directly; fixes an assert with coverage mapping Instead of using the validity of a brace's source location as a flag for list initialization, this now uses a PointerIntPair to model it so we do not increase the size of the AST node to track this information. This allows us to retain the valid source location information, which fixes the coverage assertion. Fixes https://github.com/llvm/llvm-project/issues/62105 Differential Revision: https://reviews.llvm.org/D148245
2023-04-14 07:18:46 -04:00
Record.push_back(E->isListInitialization());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 08:57:31 +00:00
}
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 06:15:05 +00:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00:00
VisitExpr(E);
Added source location for the template keyword in AST template-id expressions. llvm-svn: 149127
2012-01-27 09:46:47 +00:00
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(E->getNumDecls());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.updateBits();
CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
[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 15:43:19 +00: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-29 18:15:14 +00:00
const ASTTemplateKWAndArgsInfo &ArgInfo =
*E->getTrailingASTTemplateKWAndArgsInfo();
[NFC] [Serialization] Improve AST serialization by reordering packed bits and extract big bits from packed bits Previously I tried to improve the size of .pcm files by introducing packed bits. And I find we can improve it further by reordering the bits. The secret comes from the VBR format. We can find the formal definition of VBR format in the doc of LLVM. The VBR format will be pretty efficicent for small numbers. For example, if we need to pack 8 bits into a value and the stored value is 0xf0, the actual stored value will be 0b000111'110000, which takes 12 bits actually. However, if we changed the order to be 0x0f, then we can store it as 0b001111, which takes 6 bits only now. So we can improve the size by placing bits with lower probability to be 1 in the higher bits and extract bit bigs from the packed bits to make it possible to be optimized by VBR. After this patch, the size of std module becomes to 27.7MB from 28.1MB.
2023-12-21 16:35:20 +08:00
Record.push_back(ArgInfo.NumTemplateArgs);
[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-29 18:15:14 +00:00
AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
}
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00: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 15:43:19 +00: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-06 17:06:00 +00:00
Record.AddDeclRef(OvI.getDecl());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00: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 15:43:19 +00: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-06 17:06:00 +00:00
Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00:00
VisitOverloadExpr(E);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->isArrow());
CurrentPackingBits.addBit(E->hasUnresolvedUsing());
CurrentPackingBits.addBit(!E->isImplicitAccess());
if (!E->isImplicitAccess())
Record.AddStmt(E->getBase());
Revert "[NFC] [Serialization] Packing more bits and refactor AbbrevToUse" This reverts commit 9cdb825a4f1bf9e75829d03879620c6144d0b7bc.
2023-12-15 14:30:24 -08:00
Record.AddSourceLocation(E->getOperatorLoc());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
Record.AddTypeRef(E->getBaseType());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 09:03:26 +00:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 09:03:34 +00:00
VisitOverloadExpr(E);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->requiresADL());
CurrentPackingBits.addBit(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-06 17:06:00 +00:00
Record.AddDeclRef(E->getNamingClass());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 09:03:34 +00: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 07:38:34 +00: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-06 17:06:00 +00: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 07:38:34 +00: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-06 17:06:00 +00: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 07:38:34 +00: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 00:16:57 +00: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-06 17:06:00 +00: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 10:16:56 +00: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 00:16:57 +00: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 06:54:41 +00: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-06 17:06:00 +00: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 06:54:41 +00:00
Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
}
Serialization support for CXXNoexceptExpr. llvm-svn: 113627
2010-09-10 20:55:54 +00: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-06 17:06:00 +00:00
Record.AddSourceRange(E->getSourceRange());
Record.AddStmt(E->getOperand());
Serialization support for CXXNoexceptExpr. llvm-svn: 113627
2010-09-10 20:55:54 +00: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-03 17:17:50 +00: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-06 17:06:00 +00: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-14 21:20:45 +00: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-06 17:06:00 +00: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-03 17:17:50 +00: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-04 17:33:58 +00: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-23 21:41:42 +00: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-06 17:06:00 +00: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-23 21:41:42 +00: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-06 17:06:00 +00: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-23 21:41:42 +00: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-04 17:33:58 +00:00
Code = serialization::EXPR_SIZEOF_PACK;
}
[Clang][C++26] Implement Pack Indexing (P2662R3). (#72644) Implements https://isocpp.org/files/papers/P2662R3.pdf The feature is exposed as an extension in older language modes. Mangling is not yet supported and that is something we will have to do before release.
2024-01-27 10:23:38 +01:00
void ASTStmtWriter::VisitPackIndexingExpr(PackIndexingExpr *E) {
VisitExpr(E);
Record.push_back(E->TransformedExpressions);
Record.AddSourceLocation(E->getEllipsisLoc());
Record.AddSourceLocation(E->getRSquareLoc());
Record.AddStmt(E->getPackIdExpression());
Record.AddStmt(E->getIndexExpr());
Record.push_back(E->TransformedExpressions);
for (Expr *Sub : E->getExpressions())
Record.AddStmt(Sub);
Code = serialization::EXPR_PACK_INDEXING;
}
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 07:00:14 +00:00
void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
SubstNonTypeTemplateParmExpr *E) {
VisitExpr(E);
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
Record.AddDeclRef(E->getAssociatedDecl());
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +08:00
CurrentPackingBits.addBit(E->isReferenceParameter());
CurrentPackingBits.addBits(E->getIndex(), /*Width=*/12);
CurrentPackingBits.addBit((bool)E->getPackIndex());
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
if (auto PackIndex = E->getPackIndex())
Record.push_back(*PackIndex + 1);
Recommit [NFC] [Serialization] Packing more bits and refactor AbbrevToUse This patch tries to pack more bits into a value to reduce the size of .pcm files. Also, after we introduced BitsPackers, it may slightly better to adjust the way we use Abbrev. After this patch, the size of the BMI for std module reduce from 28.94MB to 28.1 MB. This was reverted due to it broke the build of lldb. The reason that we skip the serialization of a source location incorrectly. And this patch now fixes that.
2023-12-21 10:30:12 +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-06 17:06:00 +00: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 07:00:14 +00: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 01:15:58 +00:00
void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
SubstNonTypeTemplateParmPackExpr *E) {
VisitExpr(E);
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
Record.AddDeclRef(E->getAssociatedDecl());
Record.push_back(E->getIndex());
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-06 17:06:00 +00:00
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 01:15:58 +00: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 00:56:43 +00: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-06 17:06:00 +00: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 00:56:43 +00: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-06 17:06:00 +00: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 00:56:43 +00: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-21 17:03:29 +00: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 11:41:55 +01: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-21 17:03:29 +00: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 05:07:16 +00: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-06 17:06:00 +00: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 08:31:14 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->SubExprs[0]);
Record.AddStmt(E->SubExprs[1]);
PR30738: Implement two-phase name lookup for fold-expressions.
2020-08-06 15:57:35 -07: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 05:07:16 +00:00
Record.push_back(E->Opcode);
Code = serialization::EXPR_CXX_FOLD;
}
[clang] Reland parenthesized aggregate init patches This commit relands the patches for implementing P0960R3 and P1975R0, which describe initializing aggregates via a parenthesized list. The relanded commits are: * 40c52159d3ee - P0960R3 and P1975R0: Allow initializing aggregates from a parenthesized list of values * c77a91bb7ba7 - Remove overly restrictive aggregate paren init logic * 32d7aae04fdb - Fix a clang crash on invalid code in C++20 mode This patch also fixes a crash in the original implementation. Previously, if the input tried to call an implicitly deleted copy or move constructor of a union, we would then try to initialize the union by initializing it's first element with a reference to a union. This behavior is incorrect (we should fail to initialize) and if the type of the first element has a constructor with a single template typename parameter, then Clang will explode. This patch fixes that issue by checking that constructor overload resolution did not result in a deleted function before attempting parenthesized aggregate initialization. Additionally, this patch also includes D140159, which contains some minor fixes made in response to code review comments in the original implementation that were made after that patch was submitted. Co-authored-by: Sheng <ox59616e@gmail.com> Fixes #54040, Fixes #59675 Reviewed By: ilya-biryukov Differential Revision: https://reviews.llvm.org/D141546
2023-01-04 15:12:00 -08:00
void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
VisitExpr(E);
ArrayRef<Expr *> InitExprs = E->getInitExprs();
Record.push_back(InitExprs.size());
Record.push_back(E->getUserSpecifiedInitExprs().size());
Record.AddSourceLocation(E->getInitLoc());
Record.AddSourceLocation(E->getBeginLoc());
Record.AddSourceLocation(E->getEndLoc());
for (Expr *InitExpr : E->getInitExprs())
Record.AddStmt(InitExpr);
Expr *ArrayFiller = E->getArrayFiller();
FieldDecl *UnionField = E->getInitializedFieldInUnion();
bool HasArrayFillerOrUnionDecl = ArrayFiller || UnionField;
Record.push_back(HasArrayFillerOrUnionDecl);
if (HasArrayFillerOrUnionDecl) {
Record.push_back(static_cast<bool>(ArrayFiller));
if (ArrayFiller)
Record.AddStmt(ArrayFiller);
else
Record.AddDeclRef(UnionField);
}
Code = serialization::EXPR_CXX_PAREN_LIST_INIT;
}
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-15 23:31:06 +00: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-06 17:06:00 +00: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 01:47:58 +00: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-15 23:31:06 +00:00
Code = serialization::EXPR_OPAQUE_VALUE;
}
Add the initial TypoExpr AST node for delayed typo correction. llvm-svn: 220692
2014-10-27 18:07:20 +00: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 08:03:54 +00:00
llvm_unreachable("Cannot write TypoExpr nodes");
Add the initial TypoExpr AST node for delayed typo correction. llvm-svn: 220692
2014-10-27 18:07:20 +00:00
}
AST, Sema, Serialization: add CUDAKernelCallExpr and related semantic actions llvm-svn: 125217
2011-02-09 21:07:24 +00: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-06 17:06:00 +00:00
Record.AddStmt(E->getConfig());
AST, Sema, Serialization: add CUDAKernelCallExpr and related semantic actions llvm-svn: 125217
2011-02-09 21:07:24 +00: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 00:47:47 +00: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-06 17:06:00 +00: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 00:47:47 +00: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 07:00:14 +00:00
//===----------------------------------------------------------------------===//
// Microsoft Expressions and Statements.
//===----------------------------------------------------------------------===//
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 07:28:30 +00: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-06 17:06:00 +00: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 07:28:30 +00: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 12:01:00 +00: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-06 17:06:00 +00: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 12:01:00 +00: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 07:00:14 +00: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-06 17:06:00 +00: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-11 22:15:29 -07: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 07:00:14 +00: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-06 17:06:00 +00: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 07:00:14 +00: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-06 17:06:00 +00: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 07:00:14 +00: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-06 17:06:00 +00: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 07:00:14 +00: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-06 17:06:00 +00: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 07:00:14 +00: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-06 17:06:00 +00: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 07:00:14 +00: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 00:12:30 +00: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-06 17:06:00 +00: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 00:12:30 +00:00
Code = serialization::STMT_SEH_LEAVE;
}
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 03:13:43 +00: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-26 17:42:31 -04: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-03 17:15:32 -06: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 03:13:43 +00: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-26 17:42:31 -04: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-09 21:08:08 +00: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-09 21:09:38 +00:00
Record.AddSourceLocation(E->getEndLoc());
[Clang][OpenMP] Support for Code Generation of loop bind clause Support for Code Generation of "#pragma loop bind" clause. 1) bind(parallel) 2) bind(teams) 3) bind(thread) Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D144634
2023-08-09 14:26:29 -05:00
Record.writeEnum(E->getMappedDirective());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 03:13:43 +00: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-12 11: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 08:29:12 +00: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-12 11:26:59 -08:00
Record.writeUInt32(D->getLoopsNumber());
OpenMP: basic support for #pragma omp parallel llvm-svn: 186647
2013-07-19 03:13:43 +00: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-12 11: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-17 16:03:01 -05: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 11:27:13 +00:00
void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
[OPENMP] First changes for Parsing and Sema for 'omp simd' directive support llvm-svn: 202360
2014-02-27 08:29:12 +00: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-26 17:42:31 -04: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 11:27:13 +00: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 08:29:12 +00: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 10:02:27 -05: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-12 11: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-06 11:43:29 -05: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 10:02:27 -05: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-12 11: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-10 14:24:17 -05: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 10:02:27 -05: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-10 14:24:17 -05:00
Code = serialization::STMT_OMP_UNROLL_DIRECTIVE;
}
[OPENMP] Initial support for '#pragma omp for' (fixed incompatibility with MSVC). llvm-svn: 211140
2014-06-18 04:14:57 +00: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 11:27:13 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Initial support for '#pragma omp for' (fixed incompatibility with MSVC). llvm-svn: 211140
2014-06-18 04:14:57 +00:00
Code = serialization::STMT_OMP_FOR_DIRECTIVE;
}
Parsing/Sema of directive omp for simd llvm-svn: 218029
2014-09-18 05:12:34 +00: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 11:44:49 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Initial support for 'sections' directive. llvm-svn: 211685
2014-06-25 11:44:49 +00:00
Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'section' directive. llvm-svn: 211767
2014-06-26 08:21:58 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Initial parsing and sema analysis for 'section' directive. llvm-svn: 211767
2014-06-26 08:21:58 +00:00
Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
}
[OpenMP 5.1] Parsing and Sema support for `scope` directive structured-block where clause is one of the following: private(list) reduction([reduction-modifier ,] reduction-identifier : list) nowait Differential Revision: https://reviews.llvm.org/D157933
2023-08-09 15:28:09 -07:00
void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_SCOPE_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'single' directive. llvm-svn: 211774
2014-06-26 12:05:45 +00: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 08:54:58 +00: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 09:42:05 +00: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-06 17:06:00 +00:00
Record.AddDeclarationNameInfo(D->getDirectiveName());
[OPENMP] Parsing/Sema of the OpenMP directive 'critical'. llvm-svn: 213510
2014-07-21 09:42:05 +00:00
Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
}
[OPENMP] Added initial support for 'omp parallel for'. llvm-svn: 212453
2014-07-07 13:01:15 +00: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 11:27:13 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Added initial support for 'omp parallel for'. llvm-svn: 212453
2014-07-07 13:01:15 +00:00
Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
}
[OPENMP] Parsing/Sema of directive omp parallel for simd llvm-svn: 218299
2014-09-23 09:33:00 +00: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-05 13:43:48 -05:00
void ASTStmtWriter::VisitOMPParallelMasterDirective(
OMPParallelMasterDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE;
[OpenMP] Initial parsing and sema for 'parallel masked' construct Differential Revision: https://reviews.llvm.org/D127454
2022-06-16 16:32:30 -07:00
}
void ASTStmtWriter::VisitOMPParallelMaskedDirective(
OMPParallelMaskedDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASKED_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-05 13:43:48 -05:00
}
[OPENMP] Parsing and sema analysis for 'omp parallel sections' directive. llvm-svn: 212516
2014-07-08 08:12:03 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Parsing and sema analysis for 'omp parallel sections' directive. llvm-svn: 212516
2014-07-08 08:12:03 +00:00
Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
}
[OPENMP] Parsing and sema analysis for 'omp task' directive. llvm-svn: 212804
2014-07-11 11:25:16 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP] Parsing and sema analysis for 'omp task' directive. llvm-svn: 212804
2014-07-11 11:25:16 +00:00
Code = serialization::STMT_OMP_TASK_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis for 'atomic' directive. llvm-svn: 213639
2014-07-22 10:10:35 +00: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-26 17:42:31 -04:00
Record.writeBool(D->isXLHSInRHSPart());
Record.writeBool(D->isPostfixUpdate());
[Clang][OpenMP] Add the codegen support for `atomic compare capture` This patch adds the codegen support for `atomic compare capture` in clang. Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D120290
2022-06-02 21:38:12 -04:00
Record.writeBool(D->isFailOnly());
[OPENMP] Initial parsing and sema analysis for 'atomic' directive. llvm-svn: 213639
2014-07-22 10:10:35 +00:00
Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
}
[OPENMP] Initial parsing/sema analysis of 'target' directive. llvm-svn: 218110
2014-09-19 08:19:49 +00: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 13:44:28 +00: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-19 19:15:56 +00: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-19 20:04:50 +00: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 13:44:28 +00: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-26 18:48:41 +00: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 11:37:35 -04: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-26 18:48:41 +00: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 15:46:42 +00: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-26 17:42:31 -04: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 15:46:42 +00:00
Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
}
[OPENMP] Initial parsing and sema analysis of 'taskyield' directive. llvm-svn: 213355
2014-07-18 07:47:19 +00: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 09:11:51 +00: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 10:17:07 +00: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 05:59:40 -08:00
Record.push_back(D->getNumClauses());
[OPENMP] Initial parsing and sema analysis for 'taskwait' directive. llvm-svn: 213363
2014-07-18 10:17:07 +00:00
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
}
[OPENMP]Initial support for error directive. Differential Revision: https://reviews.llvm.org/D137209
2022-11-01 14:46:12 -07:00
void ASTStmtWriter::VisitOMPErrorDirective(OMPErrorDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_ERROR_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 12:14:09 +00: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 11:26:11 +00: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 09:52:15 -05: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 07:03:01 -04: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 06:45:04 +00: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 04:18:56 +00: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 06:57:41 +00: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-26 17:42:31 -04: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 06:57:41 +00: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 11:25:17 +00: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-26 17:42:31 -04: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 11:25:17 +00: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 04:18:41 +00: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-26 17:42:31 -04: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 04:18:41 +00: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 09:40:15 +00: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-10 20:13:02 +00: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-26 17:42:31 -04:00
Record.writeBool(D->hasCancel());
[OPENMP50]Support for 'master taskloop' directive. Added full support for master taskloop directive. llvm-svn: 374437
2019-10-10 20:13:02 +00:00
Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
}
[OpenMP] Initial parsing and sema support for 'masked taskloop' construct This patch gives basic parsing and semantic support for "masked taskloop" construct introduced in OpenMP 5.1 (section 2.16.7) Differential Revision: https://reviews.llvm.org/D128478
2022-06-24 08:42:21 -07:00
void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective(
OMPMaskedTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
Record.writeBool(D->hasCancel());
Code = serialization::STMT_OMP_MASKED_TASKLOOP_DIRECTIVE;
}
[OPENMP50]Add support for master taskloop simd. Added trsing/semantics/codegen for combined construct master taskloop simd. llvm-svn: 375255
2019-10-18 16:47:35 +00:00
void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
OMPMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
}
[OpenMP] Initial parsing and sema support for 'masked taskloop simd' construct This patch gives basic parsing and semantic support for "masked taskloop simd" construct introduced in OpenMP 5.1 (section 2.16.8) Differential Revision: https://reviews.llvm.org/D128693
2022-06-28 14:35:43 -07:00
void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(
OMPMaskedTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_MASKED_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-14 17:17:41 +00: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-26 17:42:31 -04: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-14 17:17:41 +00:00
Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
}
[OpenMP] Initial parsing and sema support for 'parallel masked taskloop' construct This patch gives basic parsing and semantic support for "parallel masked taskloop" construct introduced in OpenMP 5.1 (section 2.16.9) Differential Revision: https://reviews.llvm.org/D128834
2022-06-30 10:59:33 -07:00
void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective(
OMPParallelMaskedTaskLoopDirective *D) {
VisitOMPLoopDirective(D);
Record.writeBool(D->hasCancel());
Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE;
}
[OPENMP50]Add support for parallel master taskloop simd directive. Added full support for parallel master taskloop simd directive.
2019-10-25 10:27:13 -04:00
void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
OMPParallelMasterTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE;
}
[OpenMP] Initial parsing and semantic support for 'parallel masked taskloop simd' construct This patch gives basic parsing and semantic support for "parallel masked taskloop simd" construct introduced in OpenMP 5.1 (section 2.16.10) Differential Revision: https://reviews.llvm.org/D128946
2022-06-30 17:08:17 -07:00
void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective(
OMPParallelMaskedTaskLoopSimdDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE;
}
Add parse and sema of OpenMP distribute directive with all clauses except dist_schedule llvm-svn: 255498
2015-12-14 14:51:25 +00: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-26 17:30:50 +00: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 14:55:37 +00: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-26 17:42:31 -04: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 14:55:37 +00: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 05:00:15 +00: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 04:45:38 +00: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 02:54:56 +00: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-20 22:57:10 +00: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 14:37:37 +00: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 12:50:55 +00: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-11-30 23:51:03 +00: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 03:24:30 +00: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-26 17:42:31 -04: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 03:24:30 +00: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 05:48:59 +00: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 04:52:54 +00: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-29 22:16:30 +00: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-26 17:42:31 -04: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-29 22:16:30 +00: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 05:23:48 +00: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-10 18:08:18 +00: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-15 13:09:46 -07: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-22 18:13:29 -07: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-09 14:00:36 -05: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 08:10:40 -07:00
void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE;
}
[OpenMP] Initial parsing/sema for the 'omp teams loop' construct Adds basic parsing/sema/serialization support for the #pragma omp teams loop directive. Differential Revision: https://reviews.llvm.org/D121713
2022-03-15 08:35:59 -07:00
void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective(
OMPTeamsGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE;
}
[OpenMP] Initial parsing/sema for the 'omp target teams loop' construct Adds basic parsing/sema/serialization support for the #pragma omp target teams loop directive. Differential Revision: https://reviews.llvm.org/D122028
2022-03-18 11:02:02 -07:00
void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective(
OMPTargetTeamsGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE;
}
[OpenMP] Initial parsing/sema for the 'omp parallel loop' construct Adds basic parsing/sema/serialization support for the #pragma omp parallel loop directive. Differential Revision: https://reviews.llvm.org/D122247
2022-03-22 10:55:21 -07:00
void ASTStmtWriter::VisitOMPParallelGenericLoopDirective(
OMPParallelGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE;
}
[OpenMP] Initial parsing/sema for the 'omp target parallel loop' construct Adds basic parsing/sema/serialization support for the #pragma omp target parallel loop directive. Differential Revision: https://reviews.llvm.org/D122359
2022-03-23 15:37:06 -07:00
void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective(
OMPTargetParallelGenericLoopDirective *D) {
VisitOMPLoopDirective(D);
Code = serialization::STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE;
}
[OpenACC] Implement AST for OpenACC Compute Constructs (#81188) 'serial', 'parallel', and 'kernel' constructs are all considered 'Compute' constructs. This patch creates the AST type, plus the required infrastructure for such a type, plus some base types that will be useful in the future for breaking this up. The only difference between the three is the 'kind'( plus some minor clause legalization rules, but those can be differentiated easily enough), so rather than representing them as separate AST nodes, it seems to make sense to make them the same. Additionally, no clause AST functionality is being implemented yet, as that fits better in a separate patch, and this is enough to get the 'naked' constructs implemented. This is otherwise an 'NFC' patch, as it doesn't alter execution at all, so there aren't any tests. I did this to break up the review workload and to get feedback on the layout.
2024-02-13 06:02:13 -08:00
//===----------------------------------------------------------------------===//
// OpenACC Constructs/Directives.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) {
Record.writeEnum(S->Kind);
Record.AddSourceRange(S->Range);
// TODO OpenACC: Serialize Clauses.
}
void ASTStmtWriter::VisitOpenACCAssociatedStmtConstruct(
OpenACCAssociatedStmtConstruct *S) {
VisitOpenACCConstructStmt(S);
Record.AddStmt(S->getAssociatedStmt());
}
void ASTStmtWriter::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) {
VisitStmt(S);
[OpenACC] Add Compute Context Serialization test, fix a bug While working on a followup patch, I discovered we didn't serialize/deserialize the Compute Context properly, so this patch fixes it, then adds a PCH mode to the ast test.
2024-03-06 12:28:58 -08:00
VisitOpenACCAssociatedStmtConstruct(S);
[OpenACC] Implement AST for OpenACC Compute Constructs (#81188) 'serial', 'parallel', and 'kernel' constructs are all considered 'Compute' constructs. This patch creates the AST type, plus the required infrastructure for such a type, plus some base types that will be useful in the future for breaking this up. The only difference between the three is the 'kind'( plus some minor clause legalization rules, but those can be differentiated easily enough), so rather than representing them as separate AST nodes, it seems to make sense to make them the same. Additionally, no clause AST functionality is being implemented yet, as that fits better in a separate patch, and this is enough to get the 'naked' constructs implemented. This is otherwise an 'NFC' patch, as it doesn't alter execution at all, so there aren't any tests. I did this to break up the review workload and to get feedback on the layout.
2024-02-13 06:02:13 -08:00
Code = serialization::STMT_OPENACC_COMPUTE_CONSTRUCT;
}
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
//===----------------------------------------------------------------------===//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-18 23:56:21 +00:00
// ASTWriter Implementation
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
//===----------------------------------------------------------------------===//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-18 23:56:21 +00:00
unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
[clang] Use *{Map,Set}::contains (NFC)
2023-03-15 18:06:34 -07:00
assert(!SwitchCaseIDs.contains(S) && "SwitchCase recorded twice");
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
unsigned NextID = SwitchCaseIDs.size();
SwitchCaseIDs[S] = NextID;
return NextID;
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-18 23:56:21 +00:00
unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
[clang] Use *{Map,Set}::contains (NFC)
2023-03-15 18:06:34 -07:00
assert(SwitchCaseIDs.contains(S) && "SwitchCase hasn't been seen yet");
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
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 09:29:32 +00: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 01:00:01 +00:00
/// Write the given substatement or subexpression to the
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
/// bitstream.
Minor simplifications. llvm-svn: 265594
2016-04-06 20:12:34 +00:00
void ASTWriter::WriteSubStmt(Stmt *S) {
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
RecordData Record;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-18 23:56:27 +00:00
ASTStmtWriter Writer(*this, Record);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
++NumStatements;
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
if (!S) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-18 23:57:32 +00:00
Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 15:08:12 +00: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-21 23:02:28 +00: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 06:20:01 +00:00
Writer.Visit(S);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Fix order-of-evaluation bug (causing GCC buildbots to fail). llvm-svn: 265598
2016-04-06 20:57:53 +00:00
uint64_t Offset = Writer.Emit();
SubStmtEntries[S] = Offset;
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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 01:00:01 +00: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 06:20:01 +00: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-06 17:06:00 +00: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 02:39:13 +00: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-06 17:06:00 +00: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-21 23:02:28 +00:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
Minor simplifications. llvm-svn: 265594
2016-04-06 20:12:34 +00:00
Writer->WriteSubStmt(StmtsToEmit[I]);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00: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-06 17:06:00 +00:00
assert(N == StmtsToEmit.size() && "record modified while being written!");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 15:08:12 +00:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00: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-06 17:06:00 +00: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-21 23:02:28 +00: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-06 17:06:00 +00: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-06 20:12:34 +00: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-06 17:06:00 +00:00
assert(N == StmtsToEmit.size() && "record modified while being written!");
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 15:08:12 +00:00
split expr/stmt writing out to PCHWriterStmt.cpp llvm-svn: 70194
2009-04-27 06:20:01 +00:00
StmtsToEmit.clear();
}
Reference in New Issue Copy Permalink