This is an archive of the discontinued LLVM Phabricator instance.

Differential D21507

Changes after running check modernize-use-emplace (D20964)
AbandonedPublic

Authored by Prazek on Jun 19 2016, 12:49 PM.

Details

Reviewers
• tstellarAMD
alexfh
rsmith
Summary

Many changes after running my new check. I coudn't generate diff with full files because it was too heavy.

NOTE before you comment:

  • there are some places where .push_back(std::make_pair(a, b)) is changed to .emplace_back(std::make_pair(a, b)). This is because

the type that make_pair returns is different than it is inside vector. I plan to write matcher that would match places when
.emplace_back(std::make_pair(a, b)) or .push_back(std::make_pair(a, b)) could be changed to .emplace_back(a, b). I don't want to change it by hand right now,
and I want to keep this diff like this, because I will have some code that I can try next check later.

Diff Detail

Event Timeline

Prazek updated this revision to Diff 61218.Jun 19 2016, 12:49 PM
Prazek retitled this revision from to Changes after running check modernize-use-emplace (D20964).
Prazek updated this object.
Prazek added reviewers: alexfh, rsmith.
Prazek set the repository for this revision to rL LLVM.
Prazek added subscribers: cfe-commits, llvm-commits.
Herald added a reviewer: • tstellarAMD. · View Herald TranscriptJun 19 2016, 12:49 PM
Herald added subscribers: jfb, mzolotukhin, dsanders and 7 others. · View Herald Transcript
Prazek added a parent revision: D20964: [clang-tidy] Add modernize-use-emplace.Jun 19 2016, 12:50 PM
jlebar added a subscriber: jlebar.Jun 20 2016, 9:36 AM

There seem to be many nontrivial whitespace errors introduced by this patch. For example,

-        Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(),
-                                                       Ident.getHTMLIdent()));
+        Attrs.emplace_back(Ident.getLocation(),
+                                                       Ident.getHTMLIdent());

and

-        BitGroups.push_back(BitGroup(LastValue, LastRLAmt, LastGroupStartIdx,
-                                     i-1));
+        BitGroups.emplace_back(LastValue, LastRLAmt, LastGroupStartIdx,
+                                     i-1);
Prazek added a comment.Jun 20 2016, 1:54 PM
In D21507#462210, @jlebar wrote:

There seem to be many nontrivial whitespace errors introduced by this patch. For example,

-        Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(),
-                                                       Ident.getHTMLIdent()));
+        Attrs.emplace_back(Ident.getLocation(),
+                                                       Ident.getHTMLIdent());

and

-        BitGroups.push_back(BitGroup(LastValue, LastRLAmt, LastGroupStartIdx,
-                                     i-1));
+        BitGroups.emplace_back(LastValue, LastRLAmt, LastGroupStartIdx,
+                                     i-1);

That's right. I will git-clang-format it before pushing upstream. This is just raw diff of what check does.

vsk added a subscriber: vsk.Jun 22 2016, 11:03 AM

Neat! It would help to upload a git-clang-format'd. Fwiw I only managed to look over the changes in lib/{ARCMigrate,AST,Analysis}.

Have you run check-all and the full test-suite?

Prazek added a comment.Jun 23 2016, 3:27 AM
In D21507#464791, @vsk wrote:

Neat! It would help to upload a git-clang-format'd. Fwiw I only managed to look over the changes in lib/{ARCMigrate,AST,Analysis}.

Have you run check-all and the full test-suite?

Yep, didn't have any problems with dat

vsk added a comment.Jun 23 2016, 8:09 AM
In D21507#465444, @Prazek wrote:
In D21507#464791, @vsk wrote:

Neat! It would help to upload a git-clang-format'd. Fwiw I only managed to look over the changes in lib/{ARCMigrate,AST,Analysis}.

Have you run check-all and the full test-suite?

Yep, didn't have any problems with dat

Ok great! This looks good then. I'd wait for one of the clang-tidy devs to give an actual lgtm. It might also be worth sending a "heads-up" email to llvm-dev once it's approved.

sanjoy added a comment.Jun 23 2016, 10:55 AM

One other thing to point out -- have you verified that the changes in unittests/ are benign (i.e. you're not semantically changing the tests)?

Prazek added a comment.Jun 28 2016, 4:55 AM
In D21507#465733, @sanjoy wrote:

One other thing to point out -- have you verified that the changes in unittests/ are benign (i.e. you're not semantically changing the tests)?

Yes I do.

alexfh requested changes to this revision.Feb 2 2017, 8:44 AM

If you're still considering to submit this patch, could you rebase it (or maybe re-generate instead?) and split into easier to digest parts?

A couple of things I noticed:

  1. v.push_back(X); -> v.emplace_back(X); pattern, where X has a type of element of v. Not sure whether emplace_back provides any benefit in this case.
  2. a sub-case of 1 where X is std::make_pair(...), in this case emplace_back makes sense, if std::make_pair is removed as well. I don't know whether it's practical to teach the check this pattern. Given its frequency, might well be good.
lib/Bitcode/Reader/BitcodeReader.cpp
3903

No make_pair.

3921

ditto

3924

ditto

3989

ditto

lib/Bitcode/Writer/ValueEnumerator.cpp
149

No std::make_pair needed.

606

ditto

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp
50

No need for std::make_pair.

lib/CodeGen/CGExprScalar.cpp
2755

make_pair can be removed, IIUC.

lib/CodeGen/CGVTables.cpp
948

Not sure if it's practical to teach the check this pattern, but std::make_pair is not needed here.

lib/CodeGen/ScheduleDAGInstrs.cpp
1498

No make_pair needed.

lib/CodeGen/SelectionDAG/FastISel.cpp
2079

No make_pair needed.

This revision now requires changes to proceed.Feb 2 2017, 8:44 AM
Prazek abandoned this revision.May 6 2017, 2:40 AM

Revision Contents

PathSize
lib/
ARCMigrate/
2 lines
2 lines
AST/
2 lines
2 lines
12 lines
4 lines
2 lines
6 lines
2 lines
Analysis/
2 lines
2 lines
4 lines
20 lines
2 lines
2 lines
Basic/
2 lines
2 lines
Bitcode/
Reader/
10 lines
Writer/
4 lines
CodeGen/
3 lines
AsmPrinter/
6 lines
2 lines
4 lines
2 lines
8 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
37 lines
2 lines
40 lines
10 lines
6 lines
2 lines
4 lines
12 lines
2 lines
12 lines
2 lines
4 lines
2 lines
MIRParser/
2 lines
10 lines
4 lines
4 lines
6 lines
2 lines
4 lines
4 lines
6 lines
SelectionDAG/
2 lines
2 lines
2 lines
4 lines
31 lines
24 lines
4 lines
2 lines
2 lines
DebugInfo/
CodeView/
2 lines
3 lines
DWARF/
2 lines
Driver/
10 lines
ExecutionEngine/
RuntimeDyld/
3 lines
4 lines
Format/
12 lines
6 lines
Frontend/
4 lines
2 lines
2 lines
IR/
2 lines
Lex/
2 lines
10 lines
2 lines
2 lines
2 lines
8 lines
3 lines
LibDriver/
4 lines
MC/
2 lines
MCParser/
2 lines
4 lines
Object/
2 lines
Parse/
6 lines
4 lines
6 lines
12 lines
2 lines
ProfileData/
Coverage/
4 lines
Sema/
2 lines
4 lines
54 lines
2 lines
2 lines
2 lines
10 lines
2 lines
8 lines
17 lines
7 lines
20 lines
12 lines
2 lines
15 lines
2 lines
8 lines
5 lines
12 lines
Serialization/
14 lines
4 lines
28 lines
41 lines
9 lines
StaticAnalyzer/
Checkers/
4 lines
Core/
20 lines
2 lines
Frontend/
2 lines
Support/
4 lines
2 lines
2 lines
TableGen/
4 lines
Target/
AArch64/
10 lines
AMDGPU/
8 lines
2 lines
6 lines
2 lines
4 lines
16 lines
ARM/
12 lines
32 lines
8 lines
4 lines
AsmParser/
10 lines
Hexagon/
4 lines
4 lines
2 lines
4 lines
MCTargetDesc/
4 lines
4 lines
6 lines
2 lines
Mips/
14 lines
NVPTX/
2 lines
30 lines
PowerPC/
12 lines
48 lines
2 lines
Sparc/
2 lines
X86/
AsmParser/
4 lines
2 lines
6 lines
XCore/
2 lines
Tooling/
Core/
6 lines
2 lines
Transforms/
IPO/
6 lines
2 lines
4 lines
2 lines
InstCombine/
5 lines
8 lines
Instrumentation/
2 lines
2 lines
3 lines
ObjCARC/
2 lines
Scalar/
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
14 lines
2 lines
Utils/
4 lines
4 lines
9 lines
3 lines
2 lines
Vectorize/
14 lines
16 lines
tools/
clang-format/
6 lines
diagtool/
2 lines
libclang/
6 lines
6 lines
llvm-ar/
2 lines
llvm-config/
2 lines
llvm-diff/
6 lines
llvm-pdbdump/
2 lines
llvm-readobj/
4 lines
obj2yaml/
8 lines
yaml2obj/
16 lines
unittests/
ADT/
10 lines
2 lines
58 lines
Format/
28 lines
IR/
4 lines
ProfileData/
12 lines
Support/
90 lines
34 lines
utils/
FileCheck/
2 lines
TableGen/
6 lines
4 lines
2 lines
4 lines
2 lines
9 lines
2 lines

Diff 61218

lib/ARCMigrate/TransGCAttrs.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Spell == "strong") if (Spell == "strong")
Kind = MigrationContext::GCAttrOccurrence::Strong; Kind = MigrationContext::GCAttrOccurrence::Strong;
else if (Spell == "weak") else if (Spell == "weak")
Kind = MigrationContext::GCAttrOccurrence::Weak; Kind = MigrationContext::GCAttrOccurrence::Weak;
else else
return false; return false;
MigrateCtx.AttrSet.insert(RawLoc); MigrateCtx.AttrSet.insert(RawLoc);
MigrateCtx.GCAttrs.push_back(MigrationContext::GCAttrOccurrence()); MigrateCtx.GCAttrs.emplace_back();
MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs.back(); MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs.back();
Attr.Kind = Kind; Attr.Kind = Kind;
Attr.Loc = Loc; Attr.Loc = Loc;
Attr.ModifiedType = TL.getModifiedLoc().getType(); Attr.ModifiedType = TL.getModifiedLoc().getType();
Attr.Dcl = D; Attr.Dcl = D;
Attr.FullyMigratable = FullyMigratable; Attr.FullyMigratable = FullyMigratable;
return true; return true;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/ARCMigrate/TransProperties.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines static void collectProperties(ObjCContainerDecl *D, AtPropDeclsTy &AtProps,
for (auto *Prop : D->instance_properties()) { for (auto *Prop : D->instance_properties()) {
if (Prop->getAtLoc().isInvalid()) if (Prop->getAtLoc().isInvalid())
continue; continue;
unsigned RawLoc = Prop->getAtLoc().getRawEncoding(); unsigned RawLoc = Prop->getAtLoc().getRawEncoding();
if (PrevAtProps) if (PrevAtProps)
if (PrevAtProps->find(RawLoc) != PrevAtProps->end()) if (PrevAtProps->find(RawLoc) != PrevAtProps->end())
continue; continue;
PropsTy &props = AtProps[RawLoc]; PropsTy &props = AtProps[RawLoc];
props.push_back(Prop); props.emplace_back(Prop);
} }
} }
void doTransform(ObjCImplementationDecl *D) { void doTransform(ObjCImplementationDecl *D) {
CurImplD = D; CurImplD = D;
ObjCInterfaceDecl *iface = D->getClassInterface(); ObjCInterfaceDecl *iface = D->getClassInterface();
if (!iface) if (!iface)
return; return;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/ASTContext.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
delete Entry.second.get<ast_type_traits::DynTypedNode *>(); delete Entry.second.get<ast_type_traits::DynTypedNode *>();
} else if (Entry.second.is<ParentVector *>()) { } else if (Entry.second.is<ParentVector *>()) {
delete Entry.second.get<ParentVector *>(); delete Entry.second.get<ParentVector *>();
} }
} }
} }
void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
Deallocations.push_back({Callback, Data}); Deallocations.emplace_back(Callback, Data);
} }
void void
ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) { ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
ExternalSource = std::move(Source); ExternalSource = std::move(Source);
} }
void ASTContext::PrintStats() const { void ASTContext::PrintStats() const {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/ASTDiagnostic.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (const TemplateSpecializationType *TST = if (const TemplateSpecializationType *TST =
dyn_cast<TemplateSpecializationType>(Ty)) { dyn_cast<TemplateSpecializationType>(Ty)) {
if (!TST->isTypeAlias()) { if (!TST->isTypeAlias()) {
bool DesugarArgument = false; bool DesugarArgument = false;
SmallVector<TemplateArgument, 4> Args; SmallVector<TemplateArgument, 4> Args;
for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) { for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
const TemplateArgument &Arg = TST->getArg(I); const TemplateArgument &Arg = TST->getArg(I);
if (Arg.getKind() == TemplateArgument::Type) if (Arg.getKind() == TemplateArgument::Type)
Args.push_back(Desugar(Context, Arg.getAsType(), DesugarArgument)); Args.emplace_back(Desugar(Context, Arg.getAsType(), DesugarArgument));
else else
Args.push_back(Arg); Args.push_back(Arg);
} }
if (DesugarArgument) { if (DesugarArgument) {
ShouldAKA = true; ShouldAKA = true;
QT = Context.getTemplateSpecializationType( QT = Context.getTemplateSpecializationType(
TST->getTemplateName(), Args.data(), Args.size(), QT); TST->getTemplateName(), Args.data(), Args.size(), QT);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/CommentParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<HTMLStartTagComment::Attribute, 2> Attrs; SmallVector<HTMLStartTagComment::Attribute, 2> Attrs;
while (true) { while (true) {
switch (Tok.getKind()) { switch (Tok.getKind()) {
case tok::html_ident: { case tok::html_ident: {
Token Ident = Tok; Token Ident = Tok;
consumeToken(); consumeToken();
if (Tok.isNot(tok::html_equals)) { if (Tok.isNot(tok::html_equals)) {
Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(), Attrs.emplace_back(Ident.getLocation(),
Ident.getHTMLIdent())); Ident.getHTMLIdent());
continue; continue;
} }
Token Equals = Tok; Token Equals = Tok;
consumeToken(); consumeToken();
if (Tok.isNot(tok::html_quoted_string)) { if (Tok.isNot(tok::html_quoted_string)) {
Diag(Tok.getLocation(), Diag(Tok.getLocation(),
diag::warn_doc_html_start_tag_expected_quoted_string) diag::warn_doc_html_start_tag_expected_quoted_string)
<< SourceRange(Equals.getLocation()); << SourceRange(Equals.getLocation());
Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(), Attrs.emplace_back(Ident.getLocation(),
Ident.getHTMLIdent())); Ident.getHTMLIdent());
while (Tok.is(tok::html_equals) || while (Tok.is(tok::html_equals) ||
Tok.is(tok::html_quoted_string)) Tok.is(tok::html_quoted_string))
consumeToken(); consumeToken();
continue; continue;
} }
Attrs.push_back(HTMLStartTagComment::Attribute( Attrs.emplace_back(
Ident.getLocation(), Ident.getLocation(),
Ident.getHTMLIdent(), Ident.getHTMLIdent(),
Equals.getLocation(), Equals.getLocation(),
SourceRange(Tok.getLocation(), SourceRange(Tok.getLocation(),
Tok.getEndLocation()), Tok.getEndLocation()),
Tok.getHTMLQuotedString())); Tok.getHTMLQuotedString());
consumeToken(); consumeToken();
continue; continue;
} }
case tok::html_greater: case tok::html_greater:
S.actOnHTMLStartTagFinish(HST, S.actOnHTMLStartTagFinish(HST,
S.copyArray(llvm::makeArrayRef(Attrs)), S.copyArray(llvm::makeArrayRef(Attrs)),
Tok.getLocation(), Tok.getLocation(),
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/DeclObjC.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return data().IvarList; return data().IvarList;
if (ObjCImplementationDecl *ImplDecl = getImplementation()) { if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
data().IvarListMissingImplementation = false; data().IvarListMissingImplementation = false;
if (!ImplDecl->ivar_empty()) { if (!ImplDecl->ivar_empty()) {
SmallVector<SynthesizeIvarChunk, 16> layout; SmallVector<SynthesizeIvarChunk, 16> layout;
for (auto *IV : ImplDecl->ivars()) { for (auto *IV : ImplDecl->ivars()) {
if (IV->getSynthesize() && !IV->isInvalidDecl()) { if (IV->getSynthesize() && !IV->isInvalidDecl()) {
layout.push_back(SynthesizeIvarChunk( layout.emplace_back(
IV->getASTContext().getTypeSize(IV->getType()), IV)); IV->getASTContext().getTypeSize(IV->getType()), IV);
continue; continue;
} }
if (!data().IvarList) if (!data().IvarList)
data().IvarList = IV; data().IvarList = IV;
else else
curIvar->setNextIvar(IV); curIvar->setNextIvar(IV);
curIvar = IV; curIvar = IV;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/ExprConstant.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
--Info.CallStackDepth; --Info.CallStackDepth;
Info.CurrentCall = Caller; Info.CurrentCall = Caller;
} }
APValue &CallStackFrame::createTemporary(const void *Key, APValue &CallStackFrame::createTemporary(const void *Key,
bool IsLifetimeExtended) { bool IsLifetimeExtended) {
APValue &Result = Temporaries[Key]; APValue &Result = Temporaries[Key];
assert(Result.isUninit() && "temporary created multiple times"); assert(Result.isUninit() && "temporary created multiple times");
Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended)); Info.CleanupStack.emplace_back(&Result, IsLifetimeExtended);
return Result; return Result;
} }
static void describeCall(CallStackFrame *Frame, raw_ostream &Out); static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
void EvalInfo::addCallStack(unsigned Limit) { void EvalInfo::addCallStack(unsigned Limit) {
// Determine which calls to skip, if any. // Determine which calls to skip, if any.
unsigned ActiveCalls = CallStackDepth - 1; unsigned ActiveCalls = CallStackDepth - 1;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/AST/VTTBuilder.cpp

Show All 40 Linesvoid VTTBuilder::AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
// Store the vtable pointer index if we're generating the primary VTT. // Store the vtable pointer index if we're generating the primary VTT.
if (VTableClass == MostDerivedClass) { if (VTableClass == MostDerivedClass) {
assert(!SecondaryVirtualPointerIndices.count(Base) && assert(!SecondaryVirtualPointerIndices.count(Base) &&
"A virtual pointer index already exists for this base subobject!"); "A virtual pointer index already exists for this base subobject!");
SecondaryVirtualPointerIndices[Base] = VTTComponents.size(); SecondaryVirtualPointerIndices[Base] = VTTComponents.size();
} }
if (!GenerateDefinition) { if (!GenerateDefinition) {
VTTComponents.push_back(VTTComponent()); VTTComponents.emplace_back();
return; return;
} }
VTTComponents.push_back(VTTComponent(VTableIndex, Base)); VTTComponents.emplace_back(VTableIndex, Base);
} }
void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) { void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) {
const CXXRecordDecl *RD = Base.getBase(); const CXXRecordDecl *RD = Base.getBase();
for (const auto &I : RD->bases()) { for (const auto &I : RD->bases()) {
// Don't layout virtual bases. // Don't layout virtual bases.
if (I.isVirtual()) if (I.isVirtual())
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Linesvoid VTTBuilder::LayoutVTT(BaseSubobject Base, bool BaseIsVirtual) {
bool IsPrimaryVTT = Base.getBase() == MostDerivedClass; bool IsPrimaryVTT = Base.getBase() == MostDerivedClass;
if (!IsPrimaryVTT) { if (!IsPrimaryVTT) {
// Remember the sub-VTT index. // Remember the sub-VTT index.
SubVTTIndicies[Base] = VTTComponents.size(); SubVTTIndicies[Base] = VTTComponents.size();
} }
uint64_t VTableIndex = VTTVTables.size(); uint64_t VTableIndex = VTTVTables.size();
VTTVTables.push_back(VTTVTable(Base, BaseIsVirtual)); VTTVTables.emplace_back(Base, BaseIsVirtual);
// Add the primary vtable pointer. // Add the primary vtable pointer.
AddVTablePointer(Base, VTableIndex, RD); AddVTablePointer(Base, VTableIndex, RD);
// Add the secondary VTTs. // Add the secondary VTTs.
LayoutSecondaryVTTs(Base); LayoutSecondaryVTTs(Base);
// Add the secondary virtual pointers. // Add the secondary virtual pointers.
LayoutSecondaryVirtualPointers(Base, VTableIndex); LayoutSecondaryVirtualPointers(Base, VTableIndex);
// If this is the primary VTT, we want to lay out virtual VTTs as well. // If this is the primary VTT, we want to lay out virtual VTTs as well.
if (IsPrimaryVTT) { if (IsPrimaryVTT) {
VisitedVirtualBasesSetTy VBases; VisitedVirtualBasesSetTy VBases;
LayoutVirtualVTTs(Base.getBase(), VBases); LayoutVirtualVTTs(Base.getBase(), VBases);
} }
} }

lib/AST/VTableBuilder.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
CharUnits OffsetOffset) { CharUnits OffsetOffset) {
// Check if we can reuse an offset. // Check if we can reuse an offset.
for (const auto &OffsetPair : Offsets) { for (const auto &OffsetPair : Offsets) {
if (MethodsCanShareVCallOffset(OffsetPair.first, MD)) if (MethodsCanShareVCallOffset(OffsetPair.first, MD))
return false; return false;
} }
// Add the offset. // Add the offset.
Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset)); Offsets.emplace_back(MD, OffsetOffset);
return true; return true;
} }
CharUnits VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) { CharUnits VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
// Look for an offset. // Look for an offset.
for (const auto &OffsetPair : Offsets) { for (const auto &OffsetPair : Offsets) {
if (MethodsCanShareVCallOffset(OffsetPair.first, MD)) if (MethodsCanShareVCallOffset(OffsetPair.first, MD))
return OffsetPair.second; return OffsetPair.second;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Analysis/BlockFrequencyInfoImpl.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
bool IsOverflow = NewTotal < Total; bool IsOverflow = NewTotal < Total;
assert(!(DidOverflow && IsOverflow) && "unexpected repeated overflow"); assert(!(DidOverflow && IsOverflow) && "unexpected repeated overflow");
DidOverflow |= IsOverflow; DidOverflow |= IsOverflow;
// Update the total. // Update the total.
Total = NewTotal; Total = NewTotal;
// Save the weight. // Save the weight.
Weights.push_back(Weight(Type, Node, Amount)); Weights.emplace_back(Type, Node, Amount);
} }
static void combineWeight(Weight &W, const Weight &OtherW) { static void combineWeight(Weight &W, const Weight &OtherW) {
assert(OtherW.TargetNode.isValid()); assert(OtherW.TargetNode.isValid());
if (!W.Amount) { if (!W.Amount) {
W = OtherW; W = OtherW;
return; return;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Analysis/CFG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Block = createBlock(false); Block = createBlock(false);
Block->setTerminator(G); Block->setTerminator(G);
// If we already know the mapping to the label block add the successor now. // If we already know the mapping to the label block add the successor now.
LabelMapTy::iterator I = LabelMap.find(G->getLabel()); LabelMapTy::iterator I = LabelMap.find(G->getLabel());
if (I == LabelMap.end()) if (I == LabelMap.end())
// We will need to backpatch this block later. // We will need to backpatch this block later.
BackpatchBlocks.push_back(JumpSource(Block, ScopePos)); BackpatchBlocks.emplace_back(Block, ScopePos);
else { else {
JumpTarget JT = I->second; JumpTarget JT = I->second;
addAutomaticObjDtors(ScopePos, JT.scopePosition, G); addAutomaticObjDtors(ScopePos, JT.scopePosition, G);
addSuccessor(Block, JT.block); addSuccessor(Block, JT.block);
} }
return Block; return Block;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Analysis/EHPersonalities.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 LinesDenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
// a nested funclet). // a nested funclet).
// //
// Note: Despite not being a funclet in the truest sense, a catchswitch is // Note: Despite not being a funclet in the truest sense, a catchswitch is
// considered to belong to its own funclet for the purposes of coloring. // considered to belong to its own funclet for the purposes of coloring.
DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for " DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for "
<< F.getName() << "\n"); << F.getName() << "\n");
Worklist.push_back({EntryBlock, EntryBlock}); Worklist.emplace_back(EntryBlock, EntryBlock);
while (!Worklist.empty()) { while (!Worklist.empty()) {
BasicBlock *Visiting; BasicBlock *Visiting;
BasicBlock *Color; BasicBlock *Color;
std::tie(Visiting, Color) = Worklist.pop_back_val(); std::tie(Visiting, Color) = Worklist.pop_back_val();
DEBUG_WITH_TYPE("winehprepare-coloring", DEBUG_WITH_TYPE("winehprepare-coloring",
dbgs() << "Visiting " << Visiting->getName() << ", " dbgs() << "Visiting " << Visiting->getName() << ", "
<< Color->getName() << "\n"); << Color->getName() << "\n");
Show All 20 Lines if (auto *CatchRet = dyn_cast<CatchReturnInst>(Terminator)) {
Value *ParentPad = CatchRet->getCatchSwitchParentPad(); Value *ParentPad = CatchRet->getCatchSwitchParentPad();
if (isa<ConstantTokenNone>(ParentPad)) if (isa<ConstantTokenNone>(ParentPad))
SuccColor = EntryBlock; SuccColor = EntryBlock;
else else
SuccColor = cast<Instruction>(ParentPad)->getParent(); SuccColor = cast<Instruction>(ParentPad)->getParent();
} }
for (BasicBlock *Succ : successors(Visiting)) for (BasicBlock *Succ : successors(Visiting))
Worklist.push_back({Succ, SuccColor}); Worklist.emplace_back(Succ, SuccColor);
} }
return BlockColors; return BlockColors;
} }

lib/Analysis/LazyCallGraph.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
assert(RootN->DFSNumber == -1 && assert(RootN->DFSNumber == -1 &&
"Shouldn't have any mid-DFS root nodes!"); "Shouldn't have any mid-DFS root nodes!");
continue; continue;
} }
RootN->DFSNumber = RootN->LowLink = 1; RootN->DFSNumber = RootN->LowLink = 1;
int NextDFSNumber = 2; int NextDFSNumber = 2;
DFSStack.push_back({RootN, RootN->call_begin()}); DFSStack.emplace_back(RootN, RootN->call_begin());
do { do {
Node *N; Node *N;
call_edge_iterator I; call_edge_iterator I;
std::tie(N, I) = DFSStack.pop_back_val(); std::tie(N, I) = DFSStack.pop_back_val();
auto E = N->call_end(); auto E = N->call_end();
while (I != E) { while (I != E) {
Node &ChildN = *I->getNode(); Node &ChildN = *I->getNode();
if (ChildN.DFSNumber == 0) { if (ChildN.DFSNumber == 0) {
// We haven't yet visited this child, so descend, pushing the current // We haven't yet visited this child, so descend, pushing the current
// node onto the stack. // node onto the stack.
DFSStack.push_back({N, I}); DFSStack.emplace_back(N, I);
assert(!G->SCCMap.count(&ChildN) && assert(!G->SCCMap.count(&ChildN) &&
"Found a node with 0 DFS number but already in an SCC!"); "Found a node with 0 DFS number but already in an SCC!");
ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++; ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++;
N = &ChildN; N = &ChildN;
I = N->call_begin(); I = N->call_begin();
E = N->call_end(); E = N->call_end();
continue; continue;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// participate in the merged connected component. // participate in the merged connected component.
SmallPtrSet<RefSCC *, 8> ConnectedSet; SmallPtrSet<RefSCC *, 8> ConnectedSet;
ConnectedSet.insert(this); ConnectedSet.insert(this);
// We build up a DFS stack of the parents chains. // We build up a DFS stack of the parents chains.
SmallVector<std::pair<RefSCC *, parent_iterator>, 8> DFSStack; SmallVector<std::pair<RefSCC *, parent_iterator>, 8> DFSStack;
SmallPtrSet<RefSCC *, 8> Visited; SmallPtrSet<RefSCC *, 8> Visited;
int ConnectedDepth = -1; int ConnectedDepth = -1;
DFSStack.push_back({&SourceC, SourceC.parent_begin()}); DFSStack.emplace_back(&SourceC, SourceC.parent_begin());
do { do {
auto DFSPair = DFSStack.pop_back_val(); auto DFSPair = DFSStack.pop_back_val();
RefSCC *C = DFSPair.first; RefSCC *C = DFSPair.first;
parent_iterator I = DFSPair.second; parent_iterator I = DFSPair.second;
auto E = C->parent_end(); auto E = C->parent_end();
while (I != E) { while (I != E) {
RefSCC &Parent = *I++; RefSCC &Parent = *I++;
// If we have already processed this parent SCC, skip it, and remember // If we have already processed this parent SCC, skip it, and remember
// whether it was connected so we don't have to check the rest of the // whether it was connected so we don't have to check the rest of the
// stack. This also handles when we reach a child of the 'this' SCC (the // stack. This also handles when we reach a child of the 'this' SCC (the
// callee) which terminates the search. // callee) which terminates the search.
if (ConnectedSet.count(&Parent)) { if (ConnectedSet.count(&Parent)) {
assert(ConnectedDepth < (int)DFSStack.size() && assert(ConnectedDepth < (int)DFSStack.size() &&
"Cannot have a connected depth greater than the DFS depth!"); "Cannot have a connected depth greater than the DFS depth!");
ConnectedDepth = DFSStack.size(); ConnectedDepth = DFSStack.size();
continue; continue;
} }
if (Visited.count(&Parent)) if (Visited.count(&Parent))
continue; continue;
// We fully explore the depth-first space, adding nodes to the connected // We fully explore the depth-first space, adding nodes to the connected
// set only as we pop them off, so "recurse" by rotating to the parent. // set only as we pop them off, so "recurse" by rotating to the parent.
DFSStack.push_back({C, I}); DFSStack.emplace_back(C, I);
C = &Parent; C = &Parent;
I = C->parent_begin(); I = C->parent_begin();
E = C->parent_end(); E = C->parent_end();
} }
// If we've found a connection anywhere below this point on the stack (and // If we've found a connection anywhere below this point on the stack (and
// thus up the parent graph from the caller), the current node needs to be // thus up the parent graph from the caller), the current node needs to be
// added to the connected set now that we've processed all of its parents. // added to the connected set now that we've processed all of its parents.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
assert(RootN->DFSNumber == -1 && assert(RootN->DFSNumber == -1 &&
"Shouldn't have any mid-DFS root nodes!"); "Shouldn't have any mid-DFS root nodes!");
continue; continue;
} }
RootN->DFSNumber = RootN->LowLink = 1; RootN->DFSNumber = RootN->LowLink = 1;
int NextDFSNumber = 2; int NextDFSNumber = 2;
DFSStack.push_back({RootN, RootN->begin()}); DFSStack.emplace_back(RootN, RootN->begin());
do { do {
Node *N; Node *N;
edge_iterator I; edge_iterator I;
std::tie(N, I) = DFSStack.pop_back_val(); std::tie(N, I) = DFSStack.pop_back_val();
auto E = N->end(); auto E = N->end();
assert(N->DFSNumber != 0 && "We should always assign a DFS number " assert(N->DFSNumber != 0 && "We should always assign a DFS number "
"before processing a node."); "before processing a node.");
while (I != E) { while (I != E) {
Node &ChildN = I->getNode(*G); Node &ChildN = I->getNode(*G);
if (ChildN.DFSNumber == 0) { if (ChildN.DFSNumber == 0) {
// Mark that we should start at this child when next this node is the // Mark that we should start at this child when next this node is the
// top of the stack. We don't start at the next child to ensure this // top of the stack. We don't start at the next child to ensure this
// child's lowlink is reflected. // child's lowlink is reflected.
DFSStack.push_back({N, I}); DFSStack.emplace_back(N, I);
// Continue, resetting to the child node. // Continue, resetting to the child node.
ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++; ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++;
N = &ChildN; N = &ChildN;
I = ChildN.begin(); I = ChildN.begin();
E = ChildN.end(); E = ChildN.end();
continue; continue;
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
assert(RootN->DFSNumber == -1 && assert(RootN->DFSNumber == -1 &&
"Shouldn't have any mid-DFS root nodes!"); "Shouldn't have any mid-DFS root nodes!");
continue; continue;
} }
RootN->DFSNumber = RootN->LowLink = 1; RootN->DFSNumber = RootN->LowLink = 1;
int NextDFSNumber = 2; int NextDFSNumber = 2;
DFSStack.push_back({RootN, RootN->call_begin()}); DFSStack.emplace_back(RootN, RootN->call_begin());
do { do {
Node *N; Node *N;
call_edge_iterator I; call_edge_iterator I;
std::tie(N, I) = DFSStack.pop_back_val(); std::tie(N, I) = DFSStack.pop_back_val();
auto E = N->call_end(); auto E = N->call_end();
while (I != E) { while (I != E) {
Node &ChildN = *I->getNode(); Node &ChildN = *I->getNode();
if (ChildN.DFSNumber == 0) { if (ChildN.DFSNumber == 0) {
// We haven't yet visited this child, so descend, pushing the current // We haven't yet visited this child, so descend, pushing the current
// node onto the stack. // node onto the stack.
DFSStack.push_back({N, I}); DFSStack.emplace_back(N, I);
assert(!lookupSCC(ChildN) && assert(!lookupSCC(ChildN) &&
"Found a node with 0 DFS number but already in an SCC!"); "Found a node with 0 DFS number but already in an SCC!");
ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++; ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++;
N = &ChildN; N = &ChildN;
I = N->call_begin(); I = N->call_begin();
E = N->call_end(); E = N->call_end();
continue; continue;
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
return nullptr; return nullptr;
N = &get(*RefSCCEntryNodes.pop_back_val()); N = &get(*RefSCCEntryNodes.pop_back_val());
} while (N->DFSNumber != 0); } while (N->DFSNumber != 0);
// Found a new root, begin the DFS here. // Found a new root, begin the DFS here.
N->LowLink = N->DFSNumber = 1; N->LowLink = N->DFSNumber = 1;
NextDFSNumber = 2; NextDFSNumber = 2;
DFSStack.push_back({N, N->begin()}); DFSStack.emplace_back(N, N->begin());
} }
for (;;) { for (;;) {
Node *N; Node *N;
edge_iterator I; edge_iterator I;
std::tie(N, I) = DFSStack.pop_back_val(); std::tie(N, I) = DFSStack.pop_back_val();
assert(N->DFSNumber > 0 && "We should always assign a DFS number " assert(N->DFSNumber > 0 && "We should always assign a DFS number "
"before placing a node onto the stack."); "before placing a node onto the stack.");
auto E = N->end(); auto E = N->end();
while (I != E) { while (I != E) {
Node &ChildN = I->getNode(*this); Node &ChildN = I->getNode(*this);
if (ChildN.DFSNumber == 0) { if (ChildN.DFSNumber == 0) {
// We haven't yet visited this child, so descend, pushing the current // We haven't yet visited this child, so descend, pushing the current
// node onto the stack. // node onto the stack.
DFSStack.push_back({N, N->begin()}); DFSStack.emplace_back(N, N->begin());
assert(!SCCMap.count(&ChildN) && assert(!SCCMap.count(&ChildN) &&
"Found a node with 0 DFS number but already in an SCC!"); "Found a node with 0 DFS number but already in an SCC!");
ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++; ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++;
N = &ChildN; N = &ChildN;
I = N->begin(); I = N->begin();
E = N->end(); E = N->end();
continue; continue;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Analysis/LoopAccessAnalysis.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SafeForVectorization &= Dependence::isSafeForVectorization(Type); SafeForVectorization &= Dependence::isSafeForVectorization(Type);
// Gather dependences unless we accumulated MaxDependences // Gather dependences unless we accumulated MaxDependences
// dependences. In that case return as soon as we find the first // dependences. In that case return as soon as we find the first
// unsafe dependence. This puts a limit on this quadratic // unsafe dependence. This puts a limit on this quadratic
// algorithm. // algorithm.
if (RecordDependences) { if (RecordDependences) {
if (Type != Dependence::NoDep) if (Type != Dependence::NoDep)
Dependences.push_back(Dependence(A.second, B.second, Type)); Dependences.emplace_back(A.second, B.second, Type);
if (Dependences.size() >= MaxDependences) { if (Dependences.size() >= MaxDependences) {
RecordDependences = false; RecordDependences = false;
Dependences.clear(); Dependences.clear();
DEBUG(dbgs() << "Too many dependences, stopped recording\n"); DEBUG(dbgs() << "Too many dependences, stopped recording\n");
} }
} }
if (!RecordDependences && !SafeForVectorization) if (!RecordDependences && !SafeForVectorization)
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Dep = MemDepResult::getNonFuncLocal(); Dep = MemDepResult::getNonFuncLocal();
} }
// If we had a dirty entry for the block, update it. Otherwise, just add // If we had a dirty entry for the block, update it. Otherwise, just add
// a new entry. // a new entry.
if (ExistingResult) if (ExistingResult)
ExistingResult->setResult(Dep); ExistingResult->setResult(Dep);
else else
Cache.push_back(NonLocalDepEntry(DirtyBB, Dep)); Cache.emplace_back(DirtyBB, Dep);
// If the block has a dependency (i.e. it isn't completely transparent to // If the block has a dependency (i.e. it isn't completely transparent to
// the value), remember the association! // the value), remember the association!
if (!Dep.isNonLocal()) { if (!Dep.isNonLocal()) {
// Keep the ReverseNonLocalDeps map up to date so we can efficiently // Keep the ReverseNonLocalDeps map up to date so we can efficiently
// update this when we remove instructions. // update this when we remove instructions.
if (Instruction *Inst = Dep.getInst()) if (Instruction *Inst = Dep.getInst())
ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction()); ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction());
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Basic/Diagnostic.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Clear state related to #pragma diagnostic. // Clear state related to #pragma diagnostic.
DiagStates.clear(); DiagStates.clear();
DiagStatePoints.clear(); DiagStatePoints.clear();
DiagStateOnPushStack.clear(); DiagStateOnPushStack.clear();
// Create a DiagState and DiagStatePoint representing diagnostic changes // Create a DiagState and DiagStatePoint representing diagnostic changes
// through command-line. // through command-line.
DiagStates.emplace_back(); DiagStates.emplace_back();
DiagStatePoints.push_back(DiagStatePoint(&DiagStates.back(), FullSourceLoc())); DiagStatePoints.emplace_back(&DiagStates.back(), FullSourceLoc());
} }
void DiagnosticsEngine::SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1, void DiagnosticsEngine::SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1,
StringRef Arg2) { StringRef Arg2) {
if (DelayedDiagID) if (DelayedDiagID)
return; return;
DelayedDiagID = DiagID; DelayedDiagID = DiagID;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Basic/Module.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return Result; return Result;
} }
std::string Module::getFullModuleName() const { std::string Module::getFullModuleName() const {
SmallVector<StringRef, 2> Names; SmallVector<StringRef, 2> Names;
// Build up the set of module names (from innermost to outermost). // Build up the set of module names (from innermost to outermost).
for (const Module *M = this; M; M = M->Parent) for (const Module *M = this; M; M = M->Parent)
Names.push_back(M->Name); Names.emplace_back(M->Name);
std::string Result; std::string Result;
for (SmallVectorImpl<StringRef>::reverse_iterator I = Names.rbegin(), for (SmallVectorImpl<StringRef>::reverse_iterator I = Names.rbegin(),
IEnd = Names.rend(); IEnd = Names.rend();
I != IEnd; ++I) { I != IEnd; ++I) {
if (!Result.empty()) if (!Result.empty())
Result += '.'; Result += '.';
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
getMDOrNull(Record[12]), getMDOrNull(Record[13]), getMDOrNull(Record[12]), getMDOrNull(Record[13]),
Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]), Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
Record.size() <= 14 ? 0 : Record[14]); Record.size() <= 14 ? 0 : Record[14]);
MetadataList.assignValue(CU, NextMetadataNo++); MetadataList.assignValue(CU, NextMetadataNo++);
// Move the Upgrade the list of subprograms. // Move the Upgrade the list of subprograms.
if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11])) if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
CUSubprograms.push_back({CU, SPs}); CUSubprograms.emplace_back(CU, SPs);
break; break;
} }
case bitc::METADATA_SUBPROGRAM: { case bitc::METADATA_SUBPROGRAM: {
if (Record.size() != 18 && Record.size() != 19) if (Record.size() != 18 && Record.size() != 19)
return error("Invalid record"); return error("Invalid record");
IsDistinct = IsDistinct =
(Record[0] & 1) || Record[8]; // All definitions should be distinct. (Record[0] & 1) || Record[8]; // All definitions should be distinct.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
return error("Invalid ID"); return error("Invalid ID");
Func->setGC(GCTable[Record[8] - 1]); Func->setGC(GCTable[Record[8] - 1]);
} }
GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
if (Record.size() > 9) if (Record.size() > 9)
UnnamedAddr = getDecodedUnnamedAddrType(Record[9]); UnnamedAddr = getDecodedUnnamedAddrType(Record[9]);
Func->setUnnamedAddr(UnnamedAddr); Func->setUnnamedAddr(UnnamedAddr);
if (Record.size() > 10 && Record[10] != 0) if (Record.size() > 10 && Record[10] != 0)
FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1)); FunctionPrologues.emplace_back(std::make_pair(Func, Record[10]-1));
alexfhUnsubmitted
Not Done
ReplyInline Actions

No make_pair.

alexfh: No `make_pair`.
if (Record.size() > 11) if (Record.size() > 11)
Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11])); Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
else else
upgradeDLLImportExportLinkage(Func, RawLinkage); upgradeDLLImportExportLinkage(Func, RawLinkage);
if (Record.size() > 12) { if (Record.size() > 12) {
if (unsigned ComdatID = Record[12]) { if (unsigned ComdatID = Record[12]) {
if (ComdatID > ComdatList.size()) if (ComdatID > ComdatList.size())
return error("Invalid function comdat ID"); return error("Invalid function comdat ID");
Func->setComdat(ComdatList[ComdatID - 1]); Func->setComdat(ComdatList[ComdatID - 1]);
} }
} else if (hasImplicitComdat(RawLinkage)) { } else if (hasImplicitComdat(RawLinkage)) {
Func->setComdat(reinterpret_cast<Comdat *>(1)); Func->setComdat(reinterpret_cast<Comdat *>(1));
} }
if (Record.size() > 13 && Record[13] != 0) if (Record.size() > 13 && Record[13] != 0)
FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1)); FunctionPrefixes.emplace_back(std::make_pair(Func, Record[13]-1));
alexfhUnsubmitted
Not Done
ReplyInline Actions

ditto

alexfh: ditto
if (Record.size() > 14 && Record[14] != 0) if (Record.size() > 14 && Record[14] != 0)
FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1)); FunctionPersonalityFns.emplace_back(std::make_pair(Func, Record[14] - 1));
alexfhUnsubmitted
Not Done
ReplyInline Actions

ditto

alexfh: ditto
ValueList.push_back(Func); ValueList.push_back(Func);
// If this is a function with a body, remember the prototype we are // If this is a function with a body, remember the prototype we are
// creating now, so that we can match up the body with them later. // creating now, so that we can match up the body with them later.
if (!isProto) { if (!isProto) {
Func->setIsMaterializable(true); Func->setIsMaterializable(true);
FunctionsWithBodies.push_back(Func); FunctionsWithBodies.push_back(Func);
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++])); NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
else else
upgradeDLLImportExportLinkage(NewGA, Linkage); upgradeDLLImportExportLinkage(NewGA, Linkage);
if (OpNum != Record.size()) if (OpNum != Record.size())
NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++])); NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
if (OpNum != Record.size()) if (OpNum != Record.size())
NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++])); NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
ValueList.push_back(NewGA); ValueList.push_back(NewGA);
IndirectSymbolInits.push_back(std::make_pair(NewGA, Val)); IndirectSymbolInits.emplace_back(std::make_pair(NewGA, Val));
alexfhUnsubmitted
Not Done
ReplyInline Actions

ditto

alexfh: ditto
break; break;
} }
/// MODULE_CODE_PURGEVALS: [numvals] /// MODULE_CODE_PURGEVALS: [numvals]
case bitc::MODULE_CODE_PURGEVALS: case bitc::MODULE_CODE_PURGEVALS:
// Trim down the value list to the specified size. // Trim down the value list to the specified size.
if (Record.size() < 1 || Record[0] > ValueList.size()) if (Record.size() < 1 || Record[0] > ValueList.size())
return error("Invalid record"); return error("Invalid record");
ValueList.shrinkTo(Record[0]); ValueList.shrinkTo(Record[0]);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Bitcode/Writer/ValueEnumerator.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned ID, const OrderMap &OM, unsigned ID, const OrderMap &OM,
UseListOrderStack &Stack) { UseListOrderStack &Stack) {
// Predict use-list order for this one. // Predict use-list order for this one.
typedef std::pair<const Use *, unsigned> Entry; typedef std::pair<const Use *, unsigned> Entry;
SmallVector<Entry, 64> List; SmallVector<Entry, 64> List;
for (const Use &U : V->uses()) for (const Use &U : V->uses())
// Check if this user will be serialized. // Check if this user will be serialized.
if (OM.lookup(U.getUser()).first) if (OM.lookup(U.getUser()).first)
List.push_back(std::make_pair(&U, List.size())); List.emplace_back(std::make_pair(&U, List.size()));
alexfhUnsubmitted
Not Done
ReplyInline Actions

No std::make_pair needed.

alexfh: No `std::make_pair` needed.
if (List.size() < 2) if (List.size() < 2)
// We may have lost some users. // We may have lost some users.
return; return;
bool IsGlobalValue = OM.isGlobalValue(ID); bool IsGlobalValue = OM.isGlobalValue(ID);
std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) { std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) {
const Use *LU = L.first; const Use *LU = L.first;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
if (I != N->op_end()) { if (I != N->op_end()) {
auto *Op = cast<MDNode>(*I); auto *Op = cast<MDNode>(*I);
Worklist.back().second = ++I; Worklist.back().second = ++I;
// Delay traversing Op if it's a distinct node and N is uniqued. // Delay traversing Op if it's a distinct node and N is uniqued.
if (Op->isDistinct() && !N->isDistinct()) if (Op->isDistinct() && !N->isDistinct())
DelayedDistinctNodes.push_back(Op); DelayedDistinctNodes.push_back(Op);
else else
Worklist.push_back(std::make_pair(Op, Op->op_begin())); Worklist.emplace_back(std::make_pair(Op, Op->op_begin()));
alexfhUnsubmitted
Not Done
ReplyInline Actions

ditto

alexfh: ditto
continue; continue;
} }
// All the operands have been visited. Now assign an ID. // All the operands have been visited. Now assign an ID.
Worklist.pop_back(); Worklist.pop_back();
MDs.push_back(N); MDs.push_back(N);
MetadataMap[N].ID = MDs.size(); MetadataMap[N].ID = MDs.size();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/Analysis.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// transfer control to another funclet. // transfer control to another funclet.
if (MBBI->getOpcode() != TII->getCatchReturnOpcode()) if (MBBI->getOpcode() != TII->getCatchReturnOpcode())
continue; continue;
// FIXME: SEH CatchPads are not necessarily in the parent function: // FIXME: SEH CatchPads are not necessarily in the parent function:
// they could be inside a finally block. // they could be inside a finally block.
const MachineBasicBlock *Successor = MBBI->getOperand(0).getMBB(); const MachineBasicBlock *Successor = MBBI->getOperand(0).getMBB();
const MachineBasicBlock *SuccessorColor = MBBI->getOperand(1).getMBB(); const MachineBasicBlock *SuccessorColor = MBBI->getOperand(1).getMBB();
CatchRetSuccessors.push_back( CatchRetSuccessors.emplace_back(Successor, IsSEH ? EntryBBNumber : SuccessorColor->getNumber());
{Successor, IsSEH ? EntryBBNumber : SuccessorColor->getNumber()});
} }
// We don't have anything to do if there aren't any EH pads. // We don't have anything to do if there aren't any EH pads.
if (FuncletBlocks.empty()) if (FuncletBlocks.empty())
return FuncletMembership; return FuncletMembership;
// Identify all the basic blocks reachable from the function entry. // Identify all the basic blocks reachable from the function entry.
collectFuncletMembers(FuncletMembership, EntryBBNumber, &MF.front()); collectFuncletMembers(FuncletMembership, EntryBBNumber, &MF.front());
Show All 16 Lines

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (EmitCodeView && TM.getTargetTriple().isKnownWindowsMSVCEnvironment()) { if (EmitCodeView && TM.getTargetTriple().isKnownWindowsMSVCEnvironment()) {
Handlers.push_back(HandlerInfo(new CodeViewDebug(this), Handlers.push_back(HandlerInfo(new CodeViewDebug(this),
DbgTimerName, DbgTimerName,
CodeViewLineTablesGroupName)); CodeViewLineTablesGroupName));
} }
if (!EmitCodeView || MMI->getModule()->getDwarfVersion()) { if (!EmitCodeView || MMI->getModule()->getDwarfVersion()) {
DD = new DwarfDebug(this, &M); DD = new DwarfDebug(this, &M);
DD->beginModule(); DD->beginModule();
Handlers.push_back(HandlerInfo(DD, DbgTimerName, DWARFGroupName)); Handlers.emplace_back(DD, DbgTimerName, DWARFGroupName);
} }
} }
EHStreamer *ES = nullptr; EHStreamer *ES = nullptr;
switch (MAI->getExceptionHandlingType()) { switch (MAI->getExceptionHandlingType()) {
case ExceptionHandling::None: case ExceptionHandling::None:
break; break;
case ExceptionHandling::SjLj: case ExceptionHandling::SjLj:
Show All 11 Lines
case WinEH::EncodingType::X86: case WinEH::EncodingType::X86:
case WinEH::EncodingType::Itanium: case WinEH::EncodingType::Itanium:
ES = new WinException(this); ES = new WinException(this);
break; break;
} }
break; break;
} }
if (ES) if (ES)
Handlers.push_back(HandlerInfo(ES, EHTimerName, DWARFGroupName)); Handlers.emplace_back(ES, EHTimerName, DWARFGroupName);
return false; return false;
} }
static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) { static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {
if (!MAI.hasWeakDefCanBeHiddenDirective()) if (!MAI.hasWeakDefCanBeHiddenDirective())
return false; return false;
return canBeOmittedFromSymbolTable(GV); return canBeOmittedFromSymbolTable(GV);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
SmallVector<Structor, 8> Structors; SmallVector<Structor, 8> Structors;
for (Value *O : InitList->operands()) { for (Value *O : InitList->operands()) {
ConstantStruct *CS = dyn_cast<ConstantStruct>(O); ConstantStruct *CS = dyn_cast<ConstantStruct>(O);
if (!CS) continue; // Malformed. if (!CS) continue; // Malformed.
if (CS->getOperand(1)->isNullValue()) if (CS->getOperand(1)->isNullValue())
break; // Found a null terminator, skip the rest. break; // Found a null terminator, skip the rest.
ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0)); ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
if (!Priority) continue; // Malformed. if (!Priority) continue; // Malformed.
Structors.push_back(Structor()); Structors.emplace_back();
Structor &S = Structors.back(); Structor &S = Structors.back();
S.Priority = Priority->getLimitedValue(65535); S.Priority = Priority->getLimitedValue(65535);
S.Func = CS->getOperand(1); S.Func = CS->getOperand(1);
if (ETy->getNumElements() == 3 && !CS->getOperand(2)->isNullValue()) if (ETy->getNumElements() == 3 && !CS->getOperand(2)->isNullValue())
S.ComdatKey = dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts()); S.ComdatKey = dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts());
} }
// Emit the function pointers in the target-specific order // Emit the function pointers in the target-specific order
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesvoid DbgValueHistoryMap::startInstrRange(InlinedVariable Var,
assert(MI.isDebugValue() && "not a DBG_VALUE"); assert(MI.isDebugValue() && "not a DBG_VALUE");
auto &Ranges = VarInstrRanges[Var]; auto &Ranges = VarInstrRanges[Var];
if (!Ranges.empty() && Ranges.back().second == nullptr && if (!Ranges.empty() && Ranges.back().second == nullptr &&
Ranges.back().first->isIdenticalTo(MI)) { Ranges.back().first->isIdenticalTo(MI)) {
DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n" DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
<< "\t" << Ranges.back().first << "\t" << MI << "\n"); << "\t" << Ranges.back().first << "\t" << MI << "\n");
return; return;
} }
Ranges.push_back(std::make_pair(&MI, nullptr)); Ranges.emplace_back(std::make_pair(&MI, nullptr));
alexfhUnsubmitted
Not Done
ReplyInline Actions

No need for std::make_pair.

alexfh: No need for `std::make_pair`.
} }
void DbgValueHistoryMap::endInstrRange(InlinedVariable Var, void DbgValueHistoryMap::endInstrRange(InlinedVariable Var,
const MachineInstr &MI) { const MachineInstr &MI) {
auto &Ranges = VarInstrRanges[Var]; auto &Ranges = VarInstrRanges[Var];
// Verify that the current instruction range is not yet closed. // Verify that the current instruction range is not yet closed.
assert(!Ranges.empty() && Ranges.back().second == nullptr); assert(!Ranges.empty() && Ranges.back().second == nullptr);
// For now, instruction ranges are not allowed to cross basic block // For now, instruction ranges are not allowed to cross basic block
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
addScopeRangeList(Die, std::move(Ranges)); addScopeRangeList(Die, std::move(Ranges));
} }
void DwarfCompileUnit::attachRangesOrLowHighPC( void DwarfCompileUnit::attachRangesOrLowHighPC(
DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
SmallVector<RangeSpan, 2> List; SmallVector<RangeSpan, 2> List;
List.reserve(Ranges.size()); List.reserve(Ranges.size());
for (const InsnRange &R : Ranges) for (const InsnRange &R : Ranges)
List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first), List.emplace_back(DD->getLabelBeforeInsn(R.first),
DD->getLabelAfterInsn(R.second))); DD->getLabelAfterInsn(R.second));
attachRangesOrLowHighPC(Die, std::move(List)); attachRangesOrLowHighPC(Die, std::move(List));
} }
// This scope represents inlined body of a function. Construct DIE to // This scope represents inlined body of a function. Construct DIE to
// represent this concrete inlined copy of the function. // represent this concrete inlined copy of the function.
DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
assert(Scope->getScopeNode()); assert(Scope->getScopeNode());
auto *DS = Scope->getScopeNode(); auto *DS = Scope->getScopeNode();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (IA == 0) if (IA == 0)
return false; return false;
if (IB == 0) if (IB == 0)
return true; return true;
return IA < IB; return IA < IB;
}); });
// Insert a final terminator. // Insert a final terminator.
List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section))); List.emplace_back(nullptr, Asm->OutStreamer->endSection(Section));
// Build spans between each label. // Build spans between each label.
const MCSymbol *StartSym = List[0].Sym; const MCSymbol *StartSym = List[0].Sym;
for (size_t n = 1, e = List.size(); n < e; n++) { for (size_t n = 1, e = List.size(); n < e; n++) {
const SymbolCU &Prev = List[n - 1]; const SymbolCU &Prev = List[n - 1];
const SymbolCU &Cur = List[n]; const SymbolCU &Cur = List[n];
// Try and build the longest span we can within the same CU. // Try and build the longest span we can within the same CU.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/BranchFolding.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
minCommonTailLength, minCommonTailLength,
CommonTailLen, TrialBBI1, TrialBBI2, CommonTailLen, TrialBBI1, TrialBBI2,
SuccBB, PredBB, SuccBB, PredBB,
FuncletMembership)) { FuncletMembership)) {
if (CommonTailLen > maxCommonTailLength) { if (CommonTailLen > maxCommonTailLength) {
SameTails.clear(); SameTails.clear();
maxCommonTailLength = CommonTailLen; maxCommonTailLength = CommonTailLen;
HighestMPIter = CurMPIter; HighestMPIter = CurMPIter;
SameTails.push_back(SameTailElt(CurMPIter, TrialBBI1)); SameTails.emplace_back(CurMPIter, TrialBBI1);
} }
if (HighestMPIter == CurMPIter && if (HighestMPIter == CurMPIter &&
CommonTailLen == maxCommonTailLength) CommonTailLen == maxCommonTailLength)
SameTails.push_back(SameTailElt(I, TrialBBI2)); SameTails.emplace_back(I, TrialBBI2);
} }
if (I == B) if (I == B)
break; break;
} }
} }
return maxCommonTailLength; return maxCommonTailLength;
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Block placement does not create new tail merging opportunities for these // Block placement does not create new tail merging opportunities for these
// blocks. // blocks.
if (!AfterBlockPlacement) { if (!AfterBlockPlacement) {
MergePotentials.clear(); MergePotentials.clear();
for (MachineBasicBlock &MBB : MF) { for (MachineBasicBlock &MBB : MF) {
if (MergePotentials.size() == TailMergeThreshold) if (MergePotentials.size() == TailMergeThreshold)
break; break;
if (!TriedMerging.count(&MBB) && MBB.succ_empty()) if (!TriedMerging.count(&MBB) && MBB.succ_empty())
MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(MBB), &MBB)); MergePotentials.emplace_back(HashEndOfMBB(MBB), &MBB);
} }
// If this is a large problem, avoid visiting the same basic blocks // If this is a large problem, avoid visiting the same basic blocks
// multiple times. // multiple times.
if (MergePotentials.size() == TailMergeThreshold) if (MergePotentials.size() == TailMergeThreshold)
for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i) for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
TriedMerging.insert(MergePotentials[i].getBlock()); TriedMerging.insert(MergePotentials[i].getBlock());
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
DebugLoc dl; // FIXME: this is nowhere DebugLoc dl; // FIXME: this is nowhere
TII->RemoveBranch(*PBB); TII->RemoveBranch(*PBB);
if (!Cond.empty()) if (!Cond.empty())
// reinsert conditional branch only, for now // reinsert conditional branch only, for now
TII->InsertBranch(*PBB, (TBB == IBB) ? FBB : TBB, nullptr, TII->InsertBranch(*PBB, (TBB == IBB) ? FBB : TBB, nullptr,
NewCond, dl); NewCond, dl);
} }
MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(*PBB), PBB)); MergePotentials.emplace_back(HashEndOfMBB(*PBB), PBB);
} }
} }
// If this is a large problem, avoid visiting the same basic blocks multiple // If this is a large problem, avoid visiting the same basic blocks multiple
// times. // times.
if (MergePotentials.size() == TailMergeThreshold) if (MergePotentials.size() == TailMergeThreshold)
for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i) for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
TriedMerging.insert(MergePotentials[i].getBlock()); TriedMerging.insert(MergePotentials[i].getBlock());
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGBlocks.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Theoretically, this could be in a different address space, so // Theoretically, this could be in a different address space, so
// don't assume standard pointer size/align. // don't assume standard pointer size/align.
llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType); llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType);
std::pair<CharUnits,CharUnits> tinfo std::pair<CharUnits,CharUnits> tinfo
= CGM.getContext().getTypeInfoInChars(thisType); = CGM.getContext().getTypeInfoInChars(thisType);
maxFieldAlign = std::max(maxFieldAlign, tinfo.second); maxFieldAlign = std::max(maxFieldAlign, tinfo.second);
layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, layout.emplace_back(tinfo.second, tinfo.first,
Qualifiers::OCL_None, Qualifiers::OCL_None,
nullptr, llvmType)); nullptr, llvmType);
} }
// Next, all the block captures. // Next, all the block captures.
for (const auto &CI : block->captures()) { for (const auto &CI : block->captures()) {
const VarDecl *variable = CI.getVariable(); const VarDecl *variable = CI.getVariable();
if (CI.isByRef()) { if (CI.isByRef()) {
// We have to copy/dispose of the __block reference. // We have to copy/dispose of the __block reference.
info.NeedsCopyDispose = true; info.NeedsCopyDispose = true;
// Just use void* instead of a pointer to the byref type. // Just use void* instead of a pointer to the byref type.
CharUnits align = CGM.getPointerAlign(); CharUnits align = CGM.getPointerAlign();
maxFieldAlign = std::max(maxFieldAlign, align); maxFieldAlign = std::max(maxFieldAlign, align);
layout.push_back(BlockLayoutChunk(align, CGM.getPointerSize(), layout.emplace_back(align, CGM.getPointerSize(),
Qualifiers::OCL_None, &CI, Qualifiers::OCL_None, &CI,
CGM.VoidPtrTy)); CGM.VoidPtrTy);
continue; continue;
} }
// Otherwise, build a layout chunk with the size and alignment of // Otherwise, build a layout chunk with the size and alignment of
// the declaration. // the declaration.
if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) { if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) {
info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant); info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant);
continue; continue;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
CharUnits size = C.getTypeSizeInChars(VT); CharUnits size = C.getTypeSizeInChars(VT);
CharUnits align = C.getDeclAlign(variable); CharUnits align = C.getDeclAlign(variable);
maxFieldAlign = std::max(maxFieldAlign, align); maxFieldAlign = std::max(maxFieldAlign, align);
llvm::Type *llvmType = llvm::Type *llvmType =
CGM.getTypes().ConvertTypeForMem(VT); CGM.getTypes().ConvertTypeForMem(VT);
layout.push_back(BlockLayoutChunk(align, size, lifetime, &CI, llvmType)); layout.emplace_back(align, size, lifetime, &CI, llvmType);
} }
// If that was everything, we're done here. // If that was everything, we're done here.
if (layout.empty()) { if (layout.empty()) {
info.StructureType = info.StructureType =
llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
info.CanBeGlobal = true; info.CanBeGlobal = true;
return; return;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGDebugInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// If this is just a forward declaration return a special forward-declaration // If this is just a forward declaration return a special forward-declaration
// debug type since we won't be able to lay out the entire type. // debug type since we won't be able to lay out the entire type.
ObjCInterfaceDecl *Def = ID->getDefinition(); ObjCInterfaceDecl *Def = ID->getDefinition();
if (!Def || !Def->getImplementation()) { if (!Def || !Def->getImplementation()) {
llvm::DIScope *Mod = getParentModuleOrNull(ID); llvm::DIScope *Mod = getParentModuleOrNull(ID);
llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType( llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU, llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
DefUnit, Line, RuntimeLang); DefUnit, Line, RuntimeLang);
ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit)); ObjCInterfaceCache.emplace_back(Ty, FwdDecl, Unit);
return FwdDecl; return FwdDecl;
} }
return CreateTypeDefinition(Ty, Unit); return CreateTypeDefinition(Ty, Unit);
} }
llvm::DIModule * llvm::DIModule *
CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod, CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGExprConstant.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<BaseInfo, 8> Bases; SmallVector<BaseInfo, 8> Bases;
Bases.reserve(CD->getNumBases()); Bases.reserve(CD->getNumBases());
unsigned BaseNo = 0; unsigned BaseNo = 0;
for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) { BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
assert(!Base->isVirtual() && "should not have virtual bases here"); assert(!Base->isVirtual() && "should not have virtual bases here");
const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
CharUnits BaseOffset = Layout.getBaseClassOffset(BD); CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); Bases.emplace_back(BD, BaseOffset, BaseNo);
} }
std::stable_sort(Bases.begin(), Bases.end()); std::stable_sort(Bases.begin(), Bases.end());
for (unsigned I = 0, N = Bases.size(); I != N; ++I) { for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
BaseInfo &Base = Bases[I]; BaseInfo &Base = Bases[I];
bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGExprScalar.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One); BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
} }
llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0); llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero); llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
CGF.EmitBlock(Cont); CGF.EmitBlock(Cont);
llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2); llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
BaseCheck->addIncoming(Builder.getTrue(), Orig); BaseCheck->addIncoming(Builder.getTrue(), Orig);
BaseCheck->addIncoming(ValidBase, CheckShiftBase); BaseCheck->addIncoming(ValidBase, CheckShiftBase);
Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase)); Checks.emplace_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
alexfhUnsubmitted
Not Done
ReplyInline Actions

make_pair can be removed, IIUC.

alexfh: `make_pair` can be removed, IIUC.
} }
assert(!Checks.empty()); assert(!Checks.empty());
EmitBinOpCheck(Checks, Ops); EmitBinOpCheck(Checks, Ops);
} }
return Builder.CreateShl(Ops.LHS, RHS, "shl"); return Builder.CreateShl(Ops.LHS, RHS, "shl");
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGLoopInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
LoopInfo::LoopInfo(BasicBlock *Header, const LoopAttributes &Attrs, LoopInfo::LoopInfo(BasicBlock *Header, const LoopAttributes &Attrs,
llvm::DebugLoc Location) llvm::DebugLoc Location)
: LoopID(nullptr), Header(Header), Attrs(Attrs) { : LoopID(nullptr), Header(Header), Attrs(Attrs) {
LoopID = createMetadata(Header->getContext(), Attrs, Location); LoopID = createMetadata(Header->getContext(), Attrs, Location);
} }
void LoopInfoStack::push(BasicBlock *Header, llvm::DebugLoc Location) { void LoopInfoStack::push(BasicBlock *Header, llvm::DebugLoc Location) {
Active.push_back(LoopInfo(Header, StagedAttrs, Location)); Active.emplace_back(Header, StagedAttrs, Location);
// Clear the attributes so nested loops do not inherit them. // Clear the attributes so nested loops do not inherit them.
StagedAttrs.clear(); StagedAttrs.clear();
} }
void LoopInfoStack::push(BasicBlock *Header, clang::ASTContext &Ctx, void LoopInfoStack::push(BasicBlock *Header, clang::ASTContext &Ctx,
ArrayRef<const clang::Attr *> Attrs, ArrayRef<const clang::Attr *> Attrs,
llvm::DebugLoc Location) { llvm::DebugLoc Location) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGObjC.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
// If we do have an element variable, this assignment is the end of // If we do have an element variable, this assignment is the end of
// its initialization. // its initialization.
if (elementIsVariable) if (elementIsVariable)
EmitAutoVarCleanups(variable); EmitAutoVarCleanups(variable);
// Perform the loop body, setting up break and continue labels. // Perform the loop body, setting up break and continue labels.
BreakContinueStack.push_back(BreakContinue(LoopEnd, AfterBody)); BreakContinueStack.emplace_back(LoopEnd, AfterBody);
{ {
RunCleanupsScope Scope(*this); RunCleanupsScope Scope(*this);
EmitStmt(S.getBody()); EmitStmt(S.getBody());
} }
BreakContinueStack.pop_back(); BreakContinueStack.pop_back();
// Destroy the element variable now. // Destroy the element variable now.
elementVariableScope.ForceCleanup(); elementVariableScope.ForceCleanup();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGObjCMac.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
return C; return C;
} }
void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) { void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
// __isa is the first field in block descriptor and must assume by runtime's // __isa is the first field in block descriptor and must assume by runtime's
// convention that it is GC'able. // convention that it is GC'able.
IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1)); IvarsInfo.emplace_back(CharUnits::Zero(), 1);
const BlockDecl *blockDecl = blockInfo.getBlockDecl(); const BlockDecl *blockDecl = blockInfo.getBlockDecl();
// Ignore the optional 'this' capture: C++ objects are not assumed // Ignore the optional 'this' capture: C++ objects are not assumed
// to be GC'ed. // to be GC'ed.
CharUnits lastFieldOffset; CharUnits lastFieldOffset;
Show All 12 Lines
// Block fields are not necessarily ordered; if we detect that we're // Block fields are not necessarily ordered; if we detect that we're
// adding them out-of-order, make sure we sort later. // adding them out-of-order, make sure we sort later.
if (fieldOffset < lastFieldOffset) if (fieldOffset < lastFieldOffset)
IsDisordered = true; IsDisordered = true;
lastFieldOffset = fieldOffset; lastFieldOffset = fieldOffset;
// __block variables are passed by their descriptor address. // __block variables are passed by their descriptor address.
if (CI.isByRef()) { if (CI.isByRef()) {
IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); IvarsInfo.emplace_back(fieldOffset, /*size in words*/ 1);
continue; continue;
} }
assert(!type->isArrayType() && "array variable should not be caught"); assert(!type->isArrayType() && "array variable should not be caught");
if (const RecordType *record = type->getAs<RecordType>()) { if (const RecordType *record = type->getAs<RecordType>()) {
visitRecord(record, fieldOffset); visitRecord(record, fieldOffset);
continue; continue;
} }
Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type); Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
if (GCAttr == Qualifiers::Strong) { if (GCAttr == Qualifiers::Strong) {
assert(CGM.getContext().getTypeSize(type) assert(CGM.getContext().getTypeSize(type)
== CGM.getTarget().getPointerWidth(0)); == CGM.getTarget().getPointerWidth(0));
IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); IvarsInfo.emplace_back(fieldOffset, /*size in words*/ 1);
} }
} }
} }
/// getBlockCaptureLifetime - This routine returns life time of the captured /// getBlockCaptureLifetime - This routine returns life time of the captured
/// block variable for the purpose of block layout meta-data generation. FQT is /// block variable for the purpose of block layout meta-data generation. FQT is
/// the type of the variable captured in the block. /// the type of the variable captured in the block.
Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT, Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
Show All 14 Lines
} }
void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref, void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
Qualifiers::ObjCLifetime LifeTime, Qualifiers::ObjCLifetime LifeTime,
CharUnits FieldOffset, CharUnits FieldOffset,
CharUnits FieldSize) { CharUnits FieldSize) {
// __block variables are passed by their descriptor address. // __block variables are passed by their descriptor address.
if (IsByref) if (IsByref)
RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset, RunSkipBlockVars.emplace_back(BLOCK_LAYOUT_BYREF, FieldOffset,
FieldSize)); FieldSize);
else if (LifeTime == Qualifiers::OCL_Strong) else if (LifeTime == Qualifiers::OCL_Strong)
RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset, RunSkipBlockVars.emplace_back(BLOCK_LAYOUT_STRONG, FieldOffset,
FieldSize)); FieldSize);
else if (LifeTime == Qualifiers::OCL_Weak) else if (LifeTime == Qualifiers::OCL_Weak)
RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset, RunSkipBlockVars.emplace_back(BLOCK_LAYOUT_WEAK, FieldOffset,
FieldSize)); FieldSize);
else if (LifeTime == Qualifiers::OCL_ExplicitNone) else if (LifeTime == Qualifiers::OCL_ExplicitNone)
RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset, RunSkipBlockVars.emplace_back(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
FieldSize)); FieldSize);
else else
RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES, RunSkipBlockVars.emplace_back(BLOCK_LAYOUT_NON_OBJECT_BYTES,
FieldOffset, FieldOffset,
FieldSize)); FieldSize);
} }
void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout, void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
const RecordDecl *RD, const RecordDecl *RD,
ArrayRef<const FieldDecl*> RecFields, ArrayRef<const FieldDecl*> RecFields,
CharUnits BytePos, bool &HasUnion, CharUnits BytePos, bool &HasUnion,
bool ByrefLayout) { bool ByrefLayout) {
bool IsUnion = (RD && RD->isUnion()); bool IsUnion = (RD && RD->isUnion());
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
HasUnion); HasUnion);
// Replicate layout information for each array element. Note that // Replicate layout information for each array element. Note that
// one element is already done. // one element is already done.
uint64_t ElIx = 1; uint64_t ElIx = 1;
for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) { for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
CharUnits Size = CGM.getContext().getTypeSizeInChars(RT); CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
for (int i = OldIndex+1; i <= FirstIndex; ++i) for (int i = OldIndex+1; i <= FirstIndex; ++i)
RunSkipBlockVars.push_back( RunSkipBlockVars.emplace_back(RunSkipBlockVars[i].opcode,
RUN_SKIP(RunSkipBlockVars[i].opcode,
RunSkipBlockVars[i].block_var_bytepos + Size*ElIx, RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
RunSkipBlockVars[i].block_var_size)); RunSkipBlockVars[i].block_var_size);
} }
continue; continue;
} }
} }
CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType()); CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
if (IsUnion) { if (IsUnion) {
CharUnits UnionIvarSize = FieldSize; CharUnits UnionIvarSize = FieldSize;
if (UnionIvarSize > MaxUnionSize) { if (UnionIvarSize > MaxUnionSize) {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
auto numEltEntries = IvarsInfo.size() - oldEnd; auto numEltEntries = IvarsInfo.size() - oldEnd;
if (numElts != 1 && numEltEntries != 0) { if (numElts != 1 && numEltEntries != 0) {
CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType); CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) { for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
// Copy the last numEltEntries onto the end of the array, adjusting // Copy the last numEltEntries onto the end of the array, adjusting
// each for the element size. // each for the element size.
for (size_t i = 0; i != numEltEntries; ++i) { for (size_t i = 0; i != numEltEntries; ++i) {
auto firstEntry = IvarsInfo[oldEnd + i]; auto firstEntry = IvarsInfo[oldEnd + i];
IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize, IvarsInfo.emplace_back(firstEntry.Offset + eltIndex * eltSize,
firstEntry.SizeInWords)); firstEntry.SizeInWords);
} }
} }
} }
return; return;
} }
// Classify the element type. // Classify the element type.
Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType); Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
// If it matches what we're looking for, add an entry. // If it matches what we're looking for, add an entry.
if ((ForStrongLayout && GCAttr == Qualifiers::Strong) if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
|| (!ForStrongLayout && GCAttr == Qualifiers::Weak)) { || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
assert(CGM.getContext().getTypeSizeInChars(fieldType) assert(CGM.getContext().getTypeSizeInChars(fieldType)
== CGM.getPointerSize()); == CGM.getPointerSize());
IvarsInfo.push_back(IvarInfo(fieldOffset, numElts)); IvarsInfo.emplace_back(fieldOffset, numElts);
} }
} }
/// buildBitmap - This routine does the horsework of taking the offsets of /// buildBitmap - This routine does the horsework of taking the offsets of
/// strong/weak references and creating a bitmap. The bitmap is also /// strong/weak references and creating a bitmap. The bitmap is also
/// returned in the given buffer, suitable for being passed to \c dump(). /// returned in the given buffer, suitable for being passed to \c dump().
llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC, llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
llvm::SmallVectorImpl<unsigned char> &buffer) { llvm::SmallVectorImpl<unsigned char> &buffer) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGObjCRuntime.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<CatchHandler, 8> Handlers; SmallVector<CatchHandler, 8> Handlers;
// Enter the catch, if there is one. // Enter the catch, if there is one.
if (S.getNumCatchStmts()) { if (S.getNumCatchStmts()) {
for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) { for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I); const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I);
const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl(); const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
Handlers.push_back(CatchHandler()); Handlers.emplace_back();
CatchHandler &Handler = Handlers.back(); CatchHandler &Handler = Handlers.back();
Handler.Variable = CatchDecl; Handler.Variable = CatchDecl;
Handler.Body = CatchStmt->getCatchBody(); Handler.Body = CatchStmt->getCatchBody();
Handler.Block = CGF.createBasicBlock("catch"); Handler.Block = CGF.createBasicBlock("catch");
// @catch(...) always matches. // @catch(...) always matches.
if (!CatchDecl) { if (!CatchDecl) {
Handler.TypeInfo = nullptr; // catch-all Handler.TypeInfo = nullptr; // catch-all
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGRecordLayoutBuilder.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
FieldEnd = D->field_end(); FieldEnd = D->field_end();
Field != FieldEnd;) Field != FieldEnd;)
if (Field->isBitField()) { if (Field->isBitField()) {
RecordDecl::field_iterator Start = Field; RecordDecl::field_iterator Start = Field;
// Iterate to gather the list of bitfields. // Iterate to gather the list of bitfields.
for (++Field; Field != FieldEnd && Field->isBitField(); ++Field); for (++Field; Field != FieldEnd && Field->isBitField(); ++Field);
accumulateBitFields(Start, Field); accumulateBitFields(Start, Field);
} else { } else {
Members.push_back(MemberInfo( Members.emplace_back(
bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field, bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field,
getStorageType(*Field), *Field)); getStorageType(*Field), *Field);
++Field; ++Field;
} }
} }
void void
CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field, CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field,
RecordDecl::field_iterator FieldEnd) { RecordDecl::field_iterator FieldEnd) {
// Run stores the first element of the current run of bitfields. FieldEnd is // Run stores the first element of the current run of bitfields. FieldEnd is
Show All 23 Lines
Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type); Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type);
// Add the storage member to the record. This must be added to the // Add the storage member to the record. This must be added to the
// record before the bitfield members so that it gets laid out before // record before the bitfield members so that it gets laid out before
// the bitfields it contains get laid out. // the bitfields it contains get laid out.
Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
} }
// Bitfields get the offset of their storage but come afterward and remain // Bitfields get the offset of their storage but come afterward and remain
// there after a stable sort. // there after a stable sort.
Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), Members.emplace_back(bitsToCharUnits(StartBitOffset),
MemberInfo::Field, nullptr, *Field)); MemberInfo::Field, nullptr, *Field);
} }
return; return;
} }
for (;;) { for (;;) {
// Check to see if we need to start a new run. // Check to see if we need to start a new run.
if (Run == FieldEnd) { if (Run == FieldEnd) {
// If we're out of fields, return. // If we're out of fields, return.
if (Field == FieldEnd) if (Field == FieldEnd)
Show All 16 Lines
} }
// We've hit a break-point in the run and need to emit a storage field. // We've hit a break-point in the run and need to emit a storage field.
llvm::Type *Type = getIntNType(Tail - StartBitOffset); llvm::Type *Type = getIntNType(Tail - StartBitOffset);
// Add the storage member to the record and set the bitfield info for all of // Add the storage member to the record and set the bitfield info for all of
// the bitfields in the run. Bitfields get the offset of their storage but // the bitfields in the run. Bitfields get the offset of their storage but
// come afterward and remain there after a stable sort. // come afterward and remain there after a stable sort.
Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
for (; Run != Field; ++Run) for (; Run != Field; ++Run)
Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), Members.emplace_back(bitsToCharUnits(StartBitOffset),
MemberInfo::Field, nullptr, *Run)); MemberInfo::Field, nullptr, *Run);
Run = FieldEnd; Run = FieldEnd;
} }
} }
void CGRecordLowering::accumulateBases() { void CGRecordLowering::accumulateBases() {
// If we've got a primary virtual base, we need to add it with the bases. // If we've got a primary virtual base, we need to add it with the bases.
if (Layout.isPrimaryBaseVirtual()) { if (Layout.isPrimaryBaseVirtual()) {
const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase(); const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase();
Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base, Members.emplace_back(CharUnits::Zero(), MemberInfo::Base,
getStorageType(BaseDecl), BaseDecl)); getStorageType(BaseDecl), BaseDecl);
} }
// Accumulate the non-virtual bases. // Accumulate the non-virtual bases.
for (const auto &Base : RD->bases()) { for (const auto &Base : RD->bases()) {
if (Base.isVirtual()) if (Base.isVirtual())
continue; continue;
// Bases can be zero-sized even if not technically empty if they // Bases can be zero-sized even if not technically empty if they
// contain only a trailing array member. // contain only a trailing array member.
const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
if (!BaseDecl->isEmpty() && if (!BaseDecl->isEmpty() &&
!Context.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero()) !Context.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl), Members.emplace_back(Layout.getBaseClassOffset(BaseDecl),
MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); MemberInfo::Base, getStorageType(BaseDecl), BaseDecl);
} }
} }
void CGRecordLowering::accumulateVPtrs() { void CGRecordLowering::accumulateVPtrs() {
if (Layout.hasOwnVFPtr()) if (Layout.hasOwnVFPtr())
Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr, Members.emplace_back(CharUnits::Zero(), MemberInfo::VFPtr,
llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)-> llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)->
getPointerTo()->getPointerTo())); getPointerTo()->getPointerTo());
if (Layout.hasOwnVBPtr()) if (Layout.hasOwnVBPtr())
Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr, Members.emplace_back(Layout.getVBPtrOffset(), MemberInfo::VBPtr,
llvm::Type::getInt32PtrTy(Types.getLLVMContext()))); llvm::Type::getInt32PtrTy(Types.getLLVMContext()));
} }
void CGRecordLowering::accumulateVBases() { void CGRecordLowering::accumulateVBases() {
CharUnits ScissorOffset = Layout.getNonVirtualSize(); CharUnits ScissorOffset = Layout.getNonVirtualSize();
// In the itanium ABI, it's possible to place a vbase at a dsize that is // In the itanium ABI, it's possible to place a vbase at a dsize that is
// smaller than the nvsize. Here we check to see if such a base is placed // smaller than the nvsize. Here we check to see if such a base is placed
// before the nvsize and set the scissor offset to that, instead of the // before the nvsize and set the scissor offset to that, instead of the
// nvsize. // nvsize.
if (isOverlappingVBaseABI()) if (isOverlappingVBaseABI())
for (const auto &Base : RD->vbases()) { for (const auto &Base : RD->vbases()) {
const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
if (BaseDecl->isEmpty()) if (BaseDecl->isEmpty())
continue; continue;
// If the vbase is a primary virtual base of some base, then it doesn't // If the vbase is a primary virtual base of some base, then it doesn't
// get its own storage location but instead lives inside of that base. // get its own storage location but instead lives inside of that base.
if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl))
continue; continue;
ScissorOffset = std::min(ScissorOffset, ScissorOffset = std::min(ScissorOffset,
Layout.getVBaseClassOffset(BaseDecl)); Layout.getVBaseClassOffset(BaseDecl));
} }
Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr, Members.emplace_back(ScissorOffset, MemberInfo::Scissor, nullptr,
RD)); RD);
for (const auto &Base : RD->vbases()) { for (const auto &Base : RD->vbases()) {
const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
if (BaseDecl->isEmpty()) if (BaseDecl->isEmpty())
continue; continue;
CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl); CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl);
// If the vbase is a primary virtual base of some base, then it doesn't // If the vbase is a primary virtual base of some base, then it doesn't
// get its own storage location but instead lives inside of that base. // get its own storage location but instead lives inside of that base.
if (isOverlappingVBaseABI() && if (isOverlappingVBaseABI() &&
Context.isNearlyEmpty(BaseDecl) && Context.isNearlyEmpty(BaseDecl) &&
!hasOwnStorage(RD, BaseDecl)) { !hasOwnStorage(RD, BaseDecl)) {
Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr, Members.emplace_back(Offset, MemberInfo::VBase, nullptr,
BaseDecl)); BaseDecl);
continue; continue;
} }
// If we've got a vtordisp, add it as a storage type. // If we've got a vtordisp, add it as a storage type.
if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp()) if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp())
Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4), Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4),
getIntNType(32))); getIntNType(32)));
Members.push_back(MemberInfo(Offset, MemberInfo::VBase, Members.emplace_back(Offset, MemberInfo::VBase,
getStorageType(BaseDecl), BaseDecl)); getStorageType(BaseDecl), BaseDecl);
} }
} }
bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl, bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl,
const CXXRecordDecl *Query) { const CXXRecordDecl *Query) {
const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl); const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl);
if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query) if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query)
return false; return false;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGStmt.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs, LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs,
Builder.getCurrentDebugLocation()); Builder.getCurrentDebugLocation());
// Create an exit block for when the condition fails, which will // Create an exit block for when the condition fails, which will
// also become the break target. // also become the break target.
JumpDest LoopExit = getJumpDestInCurrentScope("while.end"); JumpDest LoopExit = getJumpDestInCurrentScope("while.end");
// Store the blocks to use for break and continue. // Store the blocks to use for break and continue.
BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); BreakContinueStack.emplace_back(LoopExit, LoopHeader);
// C++ [stmt.while]p2: // C++ [stmt.while]p2:
// When the condition of a while statement is a declaration, the // When the condition of a while statement is a declaration, the
// scope of the variable that is declared extends from its point // scope of the variable that is declared extends from its point
// of declaration (3.3.2) to the end of the while statement. // of declaration (3.3.2) to the end of the while statement.
// [...] // [...]
// The object created in a condition is destroyed and created // The object created in a condition is destroyed and created
// with each iteration of the loop. // with each iteration of the loop.
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
void CodeGenFunction::EmitDoStmt(const DoStmt &S, void CodeGenFunction::EmitDoStmt(const DoStmt &S,
ArrayRef<const Attr *> DoAttrs) { ArrayRef<const Attr *> DoAttrs) {
JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
uint64_t ParentCount = getCurrentProfileCount(); uint64_t ParentCount = getCurrentProfileCount();
// Store the blocks to use for break and continue. // Store the blocks to use for break and continue.
BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); BreakContinueStack.emplace_back(LoopExit, LoopCond);
// Emit the body of the loop. // Emit the body of the loop.
llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); llvm::BasicBlock *LoopBody = createBasicBlock("do.body");
LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, LoopStack.push(LoopBody, CGM.getContext(), DoAttrs,
Builder.getCurrentDebugLocation()); Builder.getCurrentDebugLocation());
EmitBlockWithFallThrough(LoopBody, &S); EmitBlockWithFallThrough(LoopBody, &S);
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
// If the for loop doesn't have an increment we can just use the // If the for loop doesn't have an increment we can just use the
// condition as the continue block. Otherwise we'll need to create // condition as the continue block. Otherwise we'll need to create
// a block for it (in the current scope, i.e. in the scope of the // a block for it (in the current scope, i.e. in the scope of the
// condition), and that we will become our continue block. // condition), and that we will become our continue block.
if (S.getInc()) if (S.getInc())
Continue = getJumpDestInCurrentScope("for.inc"); Continue = getJumpDestInCurrentScope("for.inc");
// Store the blocks to use for break and continue. // Store the blocks to use for break and continue.
BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); BreakContinueStack.emplace_back(LoopExit, Continue);
// Create a cleanup scope for the condition variable cleanups. // Create a cleanup scope for the condition variable cleanups.
LexicalScope ConditionScope(*this, S.getSourceRange()); LexicalScope ConditionScope(*this, S.getSourceRange());
if (S.getCond()) { if (S.getCond()) {
// If the for statement has a condition scope, emit the local variable // If the for statement has a condition scope, emit the local variable
// declaration. // declaration.
if (S.getConditionVariable()) { if (S.getConditionVariable()) {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
EmitBlock(ForBody); EmitBlock(ForBody);
incrementProfileCounter(&S); incrementProfileCounter(&S);
// Create a block for the increment. In case of a 'continue', we jump there. // Create a block for the increment. In case of a 'continue', we jump there.
JumpDest Continue = getJumpDestInCurrentScope("for.inc"); JumpDest Continue = getJumpDestInCurrentScope("for.inc");
// Store the blocks to use for break and continue. // Store the blocks to use for break and continue.
BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); BreakContinueStack.emplace_back(LoopExit, Continue);
{ {
// Create a separate cleanup scope for the loop variable and body. // Create a separate cleanup scope for the loop variable and body.
LexicalScope BodyScope(*this, S.getSourceRange()); LexicalScope BodyScope(*this, S.getSourceRange());
EmitStmt(S.getLoopVarStmt()); EmitStmt(S.getLoopVarStmt());
EmitStmt(S.getBody()); EmitStmt(S.getBody());
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
Builder.ClearInsertionPoint(); Builder.ClearInsertionPoint();
// All break statements jump to NextBlock. If BreakContinueStack is non-empty // All break statements jump to NextBlock. If BreakContinueStack is non-empty
// then reuse last ContinueBlock. // then reuse last ContinueBlock.
JumpDest OuterContinue; JumpDest OuterContinue;
if (!BreakContinueStack.empty()) if (!BreakContinueStack.empty())
OuterContinue = BreakContinueStack.back().ContinueBlock; OuterContinue = BreakContinueStack.back().ContinueBlock;
BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); BreakContinueStack.emplace_back(SwitchExit, OuterContinue);
// Emit switch body. // Emit switch body.
EmitStmt(S.getBody()); EmitStmt(S.getBody());
BreakContinueStack.pop_back(); BreakContinueStack.pop_back();
// Update the default block in case explicit case range tests have // Update the default block in case explicit case range tests have
// been chained on top. // been chained on top.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGStmtOpenMP.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Update the linear variables. // Update the linear variables.
for (const auto *C : D.getClausesOfKind<OMPLinearClause>()) { for (const auto *C : D.getClausesOfKind<OMPLinearClause>()) {
for (auto *U : C->updates()) for (auto *U : C->updates())
EmitIgnoredExpr(U); EmitIgnoredExpr(U);
} }
// On a continue in the body, jump to the end. // On a continue in the body, jump to the end.
auto Continue = getJumpDestInCurrentScope("omp.body.continue"); auto Continue = getJumpDestInCurrentScope("omp.body.continue");
BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); BreakContinueStack.emplace_back(LoopExit, Continue);
// Emit loop body. // Emit loop body.
EmitStmt(D.getBody()); EmitStmt(D.getBody());
// The end (updates/cleanups). // The end (updates/cleanups).
EmitBlock(Continue.getBlock()); EmitBlock(Continue.getBlock());
BreakContinueStack.pop_back(); BreakContinueStack.pop_back();
} }
void CodeGenFunction::EmitOMPInnerLoop( void CodeGenFunction::EmitOMPInnerLoop(
Show All 23 Lines
EmitBranchThroughCleanup(LoopExit); EmitBranchThroughCleanup(LoopExit);
} }
EmitBlock(LoopBody); EmitBlock(LoopBody);
incrementProfileCounter(&S); incrementProfileCounter(&S);
// Create a block for the increment. // Create a block for the increment.
auto Continue = getJumpDestInCurrentScope("omp.inner.for.inc"); auto Continue = getJumpDestInCurrentScope("omp.inner.for.inc");
BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); BreakContinueStack.emplace_back(LoopExit, Continue);
BodyGen(*this); BodyGen(*this);
// Emit "IV = IV + 1" and a back-edge to the condition block. // Emit "IV = IV + 1" and a back-edge to the condition block.
EmitBlock(Continue.getBlock()); EmitBlock(Continue.getBlock());
EmitIgnoredExpr(IncExpr); EmitIgnoredExpr(IncExpr);
PostIncGen(*this); PostIncGen(*this);
BreakContinueStack.pop_back(); BreakContinueStack.pop_back();
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Emit "IV = LB" (in case of static schedule, we have already calculated new // Emit "IV = LB" (in case of static schedule, we have already calculated new
// LB for loop condition and emitted it above). // LB for loop condition and emitted it above).
if (DynamicOrOrdered) if (DynamicOrOrdered)
EmitIgnoredExpr(S.getInit()); EmitIgnoredExpr(S.getInit());
// Create a block for the increment. // Create a block for the increment.
auto Continue = getJumpDestInCurrentScope("omp.dispatch.inc"); auto Continue = getJumpDestInCurrentScope("omp.dispatch.inc");
BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); BreakContinueStack.emplace_back(LoopExit, Continue);
// Generate !llvm.loop.parallel metadata for loads and stores for loops // Generate !llvm.loop.parallel metadata for loads and stores for loops
// with dynamic/guided scheduling and without ordered clause. // with dynamic/guided scheduling and without ordered clause.
if (!isOpenMPSimdDirective(S.getDirectiveKind())) if (!isOpenMPSimdDirective(S.getDirectiveKind()))
LoopStack.setParallel(!IsMonotonic); LoopStack.setParallel(!IsMonotonic);
else else
EmitOMPSimdInit(S, IsMonotonic); EmitOMPSimdInit(S, IsMonotonic);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CGVTables.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
CharUnits PointerWidth = CharUnits PointerWidth =
Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
typedef std::pair<const CXXRecordDecl *, unsigned> BSEntry; typedef std::pair<const CXXRecordDecl *, unsigned> BSEntry;
std::vector<BSEntry> BitsetEntries; std::vector<BSEntry> BitsetEntries;
// Create a bit set entry for each address point. // Create a bit set entry for each address point.
for (auto &&AP : VTLayout.getAddressPoints()) for (auto &&AP : VTLayout.getAddressPoints())
BitsetEntries.push_back(std::make_pair(AP.first.getBase(), AP.second)); BitsetEntries.emplace_back(std::make_pair(AP.first.getBase(), AP.second));
alexfhUnsubmitted
Not Done
ReplyInline Actions

Not sure if it's practical to teach the check this pattern, but std::make_pair is not needed here.

alexfh: Not sure if it's practical to teach the check this pattern, but `std::make_pair` is not needed…
// Sort the bit set entries for determinism. // Sort the bit set entries for determinism.
std::sort(BitsetEntries.begin(), BitsetEntries.end(), std::sort(BitsetEntries.begin(), BitsetEntries.end(),
[this](const BSEntry &E1, const BSEntry &E2) { [this](const BSEntry &E1, const BSEntry &E2) {
if (&E1 == &E2) if (&E1 == &E2)
return false; return false;
std::string S1; std::string S1;
Show All 26 Lines

lib/CodeGen/CodeGenModule.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return getModule().getNamedValue(Name); return getModule().getNamedValue(Name);
} }
/// AddGlobalCtor - Add a function to the list that will be called before /// AddGlobalCtor - Add a function to the list that will be called before
/// main() runs. /// main() runs.
void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority, void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
llvm::Constant *AssociatedData) { llvm::Constant *AssociatedData) {
// FIXME: Type coercion of void()* types. // FIXME: Type coercion of void()* types.
GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData)); GlobalCtors.emplace_back(Priority, Ctor, AssociatedData);
} }
/// AddGlobalDtor - Add a function to the list that will be called /// AddGlobalDtor - Add a function to the list that will be called
/// when the module is unloaded. /// when the module is unloaded.
void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) { void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
// FIXME: Type coercion of void()* types. // FIXME: Type coercion of void()* types.
GlobalDtors.push_back(Structor(Priority, Dtor, nullptr)); GlobalDtors.emplace_back(Priority, Dtor, nullptr);
} }
void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
// Ctor function type is void()*. // Ctor function type is void()*.
llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
// Get the type of a ctor entry, { i32, void ()*, i8* }. // Get the type of a ctor entry, { i32, void ()*, i8* }.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenPGO.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
CurrentCount = 0; CurrentCount = 0;
RecordNextStmtCount = true; RecordNextStmtCount = true;
} }
void VisitWhileStmt(const WhileStmt *S) { void VisitWhileStmt(const WhileStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
uint64_t ParentCount = CurrentCount; uint64_t ParentCount = CurrentCount;
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
// Visit the body region first so the break/continue adjustments can be // Visit the body region first so the break/continue adjustments can be
// included when visiting the condition. // included when visiting the condition.
uint64_t BodyCount = setCount(PGO.getRegionCount(S)); uint64_t BodyCount = setCount(PGO.getRegionCount(S));
CountMap[S->getBody()] = CurrentCount; CountMap[S->getBody()] = CurrentCount;
Visit(S->getBody()); Visit(S->getBody());
uint64_t BackedgeCount = CurrentCount; uint64_t BackedgeCount = CurrentCount;
// ...then go back and propagate counts through the condition. The count // ...then go back and propagate counts through the condition. The count
// at the start of the condition is the sum of the incoming edges, // at the start of the condition is the sum of the incoming edges,
// the backedge from the end of the loop body, and the edges from // the backedge from the end of the loop body, and the edges from
// continue statements. // continue statements.
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
uint64_t CondCount = uint64_t CondCount =
setCount(ParentCount + BackedgeCount + BC.ContinueCount); setCount(ParentCount + BackedgeCount + BC.ContinueCount);
CountMap[S->getCond()] = CondCount; CountMap[S->getCond()] = CondCount;
Visit(S->getCond()); Visit(S->getCond());
setCount(BC.BreakCount + CondCount - BodyCount); setCount(BC.BreakCount + CondCount - BodyCount);
RecordNextStmtCount = true; RecordNextStmtCount = true;
} }
void VisitDoStmt(const DoStmt *S) { void VisitDoStmt(const DoStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
uint64_t LoopCount = PGO.getRegionCount(S); uint64_t LoopCount = PGO.getRegionCount(S);
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
// The count doesn't include the fallthrough from the parent scope. Add it. // The count doesn't include the fallthrough from the parent scope. Add it.
uint64_t BodyCount = setCount(LoopCount + CurrentCount); uint64_t BodyCount = setCount(LoopCount + CurrentCount);
CountMap[S->getBody()] = BodyCount; CountMap[S->getBody()] = BodyCount;
Visit(S->getBody()); Visit(S->getBody());
uint64_t BackedgeCount = CurrentCount; uint64_t BackedgeCount = CurrentCount;
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
// The count at the start of the condition is equal to the count at the // The count at the start of the condition is equal to the count at the
// end of the body, plus any continues. // end of the body, plus any continues.
uint64_t CondCount = setCount(BackedgeCount + BC.ContinueCount); uint64_t CondCount = setCount(BackedgeCount + BC.ContinueCount);
CountMap[S->getCond()] = CondCount; CountMap[S->getCond()] = CondCount;
Visit(S->getCond()); Visit(S->getCond());
setCount(BC.BreakCount + CondCount - LoopCount); setCount(BC.BreakCount + CondCount - LoopCount);
RecordNextStmtCount = true; RecordNextStmtCount = true;
} }
void VisitForStmt(const ForStmt *S) { void VisitForStmt(const ForStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
if (S->getInit()) if (S->getInit())
Visit(S->getInit()); Visit(S->getInit());
uint64_t ParentCount = CurrentCount; uint64_t ParentCount = CurrentCount;
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
// Visit the body region first. (This is basically the same as a while // Visit the body region first. (This is basically the same as a while
// loop; see further comments in VisitWhileStmt.) // loop; see further comments in VisitWhileStmt.)
uint64_t BodyCount = setCount(PGO.getRegionCount(S)); uint64_t BodyCount = setCount(PGO.getRegionCount(S));
CountMap[S->getBody()] = BodyCount; CountMap[S->getBody()] = BodyCount;
Visit(S->getBody()); Visit(S->getBody());
uint64_t BackedgeCount = CurrentCount; uint64_t BackedgeCount = CurrentCount;
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
Show All 19 Lines
void VisitCXXForRangeStmt(const CXXForRangeStmt *S) { void VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
Visit(S->getLoopVarStmt()); Visit(S->getLoopVarStmt());
Visit(S->getRangeStmt()); Visit(S->getRangeStmt());
Visit(S->getBeginStmt()); Visit(S->getBeginStmt());
Visit(S->getEndStmt()); Visit(S->getEndStmt());
uint64_t ParentCount = CurrentCount; uint64_t ParentCount = CurrentCount;
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
// Visit the body region first. (This is basically the same as a while // Visit the body region first. (This is basically the same as a while
// loop; see further comments in VisitWhileStmt.) // loop; see further comments in VisitWhileStmt.)
uint64_t BodyCount = setCount(PGO.getRegionCount(S)); uint64_t BodyCount = setCount(PGO.getRegionCount(S));
CountMap[S->getBody()] = BodyCount; CountMap[S->getBody()] = BodyCount;
Visit(S->getBody()); Visit(S->getBody());
uint64_t BackedgeCount = CurrentCount; uint64_t BackedgeCount = CurrentCount;
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
Show All 11 Lines
setCount(BC.BreakCount + CondCount - BodyCount); setCount(BC.BreakCount + CondCount - BodyCount);
RecordNextStmtCount = true; RecordNextStmtCount = true;
} }
void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
Visit(S->getElement()); Visit(S->getElement());
uint64_t ParentCount = CurrentCount; uint64_t ParentCount = CurrentCount;
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
// Counter tracks the body of the loop. // Counter tracks the body of the loop.
uint64_t BodyCount = setCount(PGO.getRegionCount(S)); uint64_t BodyCount = setCount(PGO.getRegionCount(S));
CountMap[S->getBody()] = BodyCount; CountMap[S->getBody()] = BodyCount;
Visit(S->getBody()); Visit(S->getBody());
uint64_t BackedgeCount = CurrentCount; uint64_t BackedgeCount = CurrentCount;
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
setCount(BC.BreakCount + ParentCount + BackedgeCount + BC.ContinueCount - setCount(BC.BreakCount + ParentCount + BackedgeCount + BC.ContinueCount -
BodyCount); BodyCount);
RecordNextStmtCount = true; RecordNextStmtCount = true;
} }
void VisitSwitchStmt(const SwitchStmt *S) { void VisitSwitchStmt(const SwitchStmt *S) {
RecordStmtCount(S); RecordStmtCount(S);
Visit(S->getCond()); Visit(S->getCond());
CurrentCount = 0; CurrentCount = 0;
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
Visit(S->getBody()); Visit(S->getBody());
// If the switch is inside a loop, add the continue counts. // If the switch is inside a loop, add the continue counts.
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
if (!BreakContinueStack.empty()) if (!BreakContinueStack.empty())
BreakContinueStack.back().ContinueCount += BC.ContinueCount; BreakContinueStack.back().ContinueCount += BC.ContinueCount;
// Counter tracks the exit block of the switch. // Counter tracks the exit block of the switch.
setCount(PGO.getRegionCount(S)); setCount(PGO.getRegionCount(S));
RecordNextStmtCount = true; RecordNextStmtCount = true;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenPrepare.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
public: public:
/// \brief Replace all the use of \p Inst by \p New. /// \brief Replace all the use of \p Inst by \p New.
UsesReplacer(Instruction *Inst, Value *New) : TypePromotionAction(Inst) { UsesReplacer(Instruction *Inst, Value *New) : TypePromotionAction(Inst) {
DEBUG(dbgs() << "Do: UsersReplacer: " << *Inst << " with " << *New DEBUG(dbgs() << "Do: UsersReplacer: " << *Inst << " with " << *New
<< "\n"); << "\n");
// Record the original uses. // Record the original uses.
for (Use &U : Inst->uses()) { for (Use &U : Inst->uses()) {
Instruction *UserI = cast<Instruction>(U.getUser()); Instruction *UserI = cast<Instruction>(U.getUser());
OriginalUses.push_back(InstructionAndIdx(UserI, U.getOperandNo())); OriginalUses.emplace_back(UserI, U.getOperandNo());
} }
// Now, we can replace the uses. // Now, we can replace the uses.
Inst->replaceAllUsesWith(New); Inst->replaceAllUsesWith(New);
} }
/// \brief Reassign the original uses of Inst to Inst. /// \brief Reassign the original uses of Inst to Inst.
void undo() override { void undo() override {
DEBUG(dbgs() << "Undo: UsersReplacer: " << *Inst << "\n"); DEBUG(dbgs() << "Undo: UsersReplacer: " << *Inst << "\n");
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/CoverageMappingGen.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
void VisitWhileStmt(const WhileStmt *S) { void VisitWhileStmt(const WhileStmt *S) {
extendRegion(S); extendRegion(S);
Counter ParentCount = getRegion().getCounter(); Counter ParentCount = getRegion().getCounter();
Counter BodyCount = getRegionCounter(S); Counter BodyCount = getRegionCounter(S);
// Handle the body first so that we can get the backedge count. // Handle the body first so that we can get the backedge count.
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
extendRegion(S->getBody()); extendRegion(S->getBody());
Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
// Go back to handle the condition. // Go back to handle the condition.
Counter CondCount = Counter CondCount =
addCounters(ParentCount, BackedgeCount, BC.ContinueCount); addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
propagateCounts(CondCount, S->getCond()); propagateCounts(CondCount, S->getCond());
adjustForOutOfOrderTraversal(getEnd(S)); adjustForOutOfOrderTraversal(getEnd(S));
Counter OutCount = Counter OutCount =
addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount)); addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
if (OutCount != ParentCount) if (OutCount != ParentCount)
pushRegion(OutCount); pushRegion(OutCount);
} }
void VisitDoStmt(const DoStmt *S) { void VisitDoStmt(const DoStmt *S) {
extendRegion(S); extendRegion(S);
Counter ParentCount = getRegion().getCounter(); Counter ParentCount = getRegion().getCounter();
Counter BodyCount = getRegionCounter(S); Counter BodyCount = getRegionCounter(S);
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
extendRegion(S->getBody()); extendRegion(S->getBody());
Counter BackedgeCount = Counter BackedgeCount =
propagateCounts(addCounters(ParentCount, BodyCount), S->getBody()); propagateCounts(addCounters(ParentCount, BodyCount), S->getBody());
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
Counter CondCount = addCounters(BackedgeCount, BC.ContinueCount); Counter CondCount = addCounters(BackedgeCount, BC.ContinueCount);
propagateCounts(CondCount, S->getCond()); propagateCounts(CondCount, S->getCond());
Counter OutCount = Counter OutCount =
addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount)); addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
if (OutCount != ParentCount) if (OutCount != ParentCount)
pushRegion(OutCount); pushRegion(OutCount);
} }
void VisitForStmt(const ForStmt *S) { void VisitForStmt(const ForStmt *S) {
extendRegion(S); extendRegion(S);
if (S->getInit()) if (S->getInit())
Visit(S->getInit()); Visit(S->getInit());
Counter ParentCount = getRegion().getCounter(); Counter ParentCount = getRegion().getCounter();
Counter BodyCount = getRegionCounter(S); Counter BodyCount = getRegionCounter(S);
// Handle the body first so that we can get the backedge count. // Handle the body first so that we can get the backedge count.
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
extendRegion(S->getBody()); extendRegion(S->getBody());
Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
// The increment is essentially part of the body but it needs to include // The increment is essentially part of the body but it needs to include
// the count for all the continue statements. // the count for all the continue statements.
if (const Stmt *Inc = S->getInc()) if (const Stmt *Inc = S->getInc())
propagateCounts(addCounters(BackedgeCount, BC.ContinueCount), Inc); propagateCounts(addCounters(BackedgeCount, BC.ContinueCount), Inc);
Show All 15 Lines
void VisitCXXForRangeStmt(const CXXForRangeStmt *S) { void VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
extendRegion(S); extendRegion(S);
Visit(S->getLoopVarStmt()); Visit(S->getLoopVarStmt());
Visit(S->getRangeStmt()); Visit(S->getRangeStmt());
Counter ParentCount = getRegion().getCounter(); Counter ParentCount = getRegion().getCounter();
Counter BodyCount = getRegionCounter(S); Counter BodyCount = getRegionCounter(S);
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
extendRegion(S->getBody()); extendRegion(S->getBody());
Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
Counter LoopCount = Counter LoopCount =
addCounters(ParentCount, BackedgeCount, BC.ContinueCount); addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
Counter OutCount = Counter OutCount =
addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount)); addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
if (OutCount != ParentCount) if (OutCount != ParentCount)
pushRegion(OutCount); pushRegion(OutCount);
} }
void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
extendRegion(S); extendRegion(S);
Visit(S->getElement()); Visit(S->getElement());
Counter ParentCount = getRegion().getCounter(); Counter ParentCount = getRegion().getCounter();
Counter BodyCount = getRegionCounter(S); Counter BodyCount = getRegionCounter(S);
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
extendRegion(S->getBody()); extendRegion(S->getBody());
Counter BackedgeCount = propagateCounts(BodyCount, S->getBody()); Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
BreakContinue BC = BreakContinueStack.pop_back_val(); BreakContinue BC = BreakContinueStack.pop_back_val();
Counter LoopCount = Counter LoopCount =
addCounters(ParentCount, BackedgeCount, BC.ContinueCount); addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
Counter OutCount = Counter OutCount =
addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount)); addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
if (OutCount != ParentCount) if (OutCount != ParentCount)
pushRegion(OutCount); pushRegion(OutCount);
} }
void VisitSwitchStmt(const SwitchStmt *S) { void VisitSwitchStmt(const SwitchStmt *S) {
extendRegion(S); extendRegion(S);
Visit(S->getCond()); Visit(S->getCond());
BreakContinueStack.push_back(BreakContinue()); BreakContinueStack.emplace_back();
const Stmt *Body = S->getBody(); const Stmt *Body = S->getBody();
extendRegion(Body); extendRegion(Body);
if (const auto *CS = dyn_cast<CompoundStmt>(Body)) { if (const auto *CS = dyn_cast<CompoundStmt>(Body)) {
if (!CS->body_empty()) { if (!CS->body_empty()) {
// The body of the switch needs a zero region so that fallthrough counts // The body of the switch needs a zero region so that fallthrough counts
// behave correctly, but it would be misleading to include the braces of // behave correctly, but it would be misleading to include the braces of
// the compound statement in the zeroed area, so we need to handle this // the compound statement in the zeroed area, so we need to handle this
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/EarlyIfConversion.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
FBB = TBB == Succ0 ? Succ1 : Succ0; FBB = TBB == Succ0 ? Succ1 : Succ0;
// Any phis in the tail block must be convertible to selects. // Any phis in the tail block must be convertible to selects.
PHIs.clear(); PHIs.clear();
MachineBasicBlock *TPred = getTPred(); MachineBasicBlock *TPred = getTPred();
MachineBasicBlock *FPred = getFPred(); MachineBasicBlock *FPred = getFPred();
for (MachineBasicBlock::iterator I = Tail->begin(), E = Tail->end(); for (MachineBasicBlock::iterator I = Tail->begin(), E = Tail->end();
I != E && I->isPHI(); ++I) { I != E && I->isPHI(); ++I) {
PHIs.push_back(&*I); PHIs.emplace_back(&*I);
PHIInfo &PI = PHIs.back(); PHIInfo &PI = PHIs.back();
// Find PHI operands corresponding to TPred and FPred. // Find PHI operands corresponding to TPred and FPred.
for (unsigned i = 1; i != PI.PHI->getNumOperands(); i += 2) { for (unsigned i = 1; i != PI.PHI->getNumOperands(); i += 2) {
if (PI.PHI->getOperand(i+1).getMBB() == TPred) if (PI.PHI->getOperand(i+1).getMBB() == TPred)
PI.TReg = PI.PHI->getOperand(i).getReg(); PI.TReg = PI.PHI->getOperand(i).getReg();
if (PI.PHI->getOperand(i+1).getMBB() == FPred) if (PI.PHI->getOperand(i+1).getMBB() == FPred)
PI.FReg = PI.PHI->getOperand(i).getReg(); PI.FReg = PI.PHI->getOperand(i).getReg();
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/IfConversion.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
BBI.IsBeingAnalyzed = false; BBI.IsBeingAnalyzed = false;
BBI.IsAnalyzed = true; BBI.IsAnalyzed = true;
BBStack.pop_back(); BBStack.pop_back();
continue; continue;
} }
// Push the False and True blocks to the stack. // Push the False and True blocks to the stack.
State.SuccsAnalyzed = true; State.SuccsAnalyzed = true;
BBStack.push_back(BBI.FalseBB); BBStack.emplace_back(BBI.FalseBB);
BBStack.push_back(BBI.TrueBB); BBStack.emplace_back(BBI.TrueBB);
continue; continue;
} }
BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()];
BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
if (TrueBBI.IsDone && FalseBBI.IsDone) { if (TrueBBI.IsDone && FalseBBI.IsDone) {
BBI.IsBeingAnalyzed = false; BBI.IsBeingAnalyzed = false;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/LocalStackSlotAllocation.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Don't try this with values not in the local block. // Don't try this with values not in the local block.
if (!MFI->isObjectPreAllocated(MI->getOperand(i).getIndex())) if (!MFI->isObjectPreAllocated(MI->getOperand(i).getIndex()))
break; break;
int Idx = MI->getOperand(i).getIndex(); int Idx = MI->getOperand(i).getIndex();
int64_t LocalOffset = LocalOffsets[Idx]; int64_t LocalOffset = LocalOffsets[Idx];
if (!TRI->needsFrameBaseReg(MI, LocalOffset)) if (!TRI->needsFrameBaseReg(MI, LocalOffset))
break; break;
FrameReferenceInsns. FrameReferenceInsns.
push_back(FrameRef(MI, LocalOffset, Idx)); emplace_back(MI, LocalOffset, Idx);
break; break;
} }
} }
} }
} }
// Sort the frame references by local offset // Sort the frame references by local offset
array_pod_sort(FrameReferenceInsns.begin(), FrameReferenceInsns.end()); array_pod_sort(FrameReferenceInsns.begin(), FrameReferenceInsns.end());
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/MIRParser/MIRParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const yaml::StringValue &RegisterSource, int FrameIdx) { const yaml::StringValue &RegisterSource, int FrameIdx) {
if (RegisterSource.Value.empty()) if (RegisterSource.Value.empty())
return false; return false;
unsigned Reg = 0; unsigned Reg = 0;
SMDiagnostic Error; SMDiagnostic Error;
if (parseNamedRegisterReference(Reg, SM, MF, RegisterSource.Value, PFS, if (parseNamedRegisterReference(Reg, SM, MF, RegisterSource.Value, PFS,
IRSlots, Error)) IRSlots, Error))
return error(Error, RegisterSource.SourceRange); return error(Error, RegisterSource.SourceRange);
CSIInfo.push_back(CalleeSavedInfo(Reg, FrameIdx)); CSIInfo.emplace_back(Reg, FrameIdx);
return false; return false;
} }
/// Verify that given node is of a certain type. Return true on error. /// Verify that given node is of a certain type. Return true on error.
template <typename T> template <typename T>
static bool typecheckMDNode(T *&Result, MDNode *Node, static bool typecheckMDNode(T *&Result, MDNode *Node,
const yaml::StringValue &Source, const yaml::StringValue &Source,
StringRef TypeString, MIRParserImpl &Parser) { StringRef TypeString, MIRParserImpl &Parser) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/MachineFunction.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
/// Create a new statically sized stack object, returning a nonnegative /// Create a new statically sized stack object, returning a nonnegative
/// identifier to represent it. /// identifier to represent it.
int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment, int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
bool isSS, const AllocaInst *Alloca) { bool isSS, const AllocaInst *Alloca) {
assert(Size != 0 && "Cannot allocate zero size stack objects!"); assert(Size != 0 && "Cannot allocate zero size stack objects!");
Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
Objects.push_back(StackObject(Size, Alignment, 0, false, isSS, Alloca, Objects.emplace_back(Size, Alignment, 0, false, isSS, Alloca,
!isSS)); !isSS);
int Index = (int)Objects.size() - NumFixedObjects - 1; int Index = (int)Objects.size() - NumFixedObjects - 1;
assert(Index >= 0 && "Bad frame index!"); assert(Index >= 0 && "Bad frame index!");
ensureMaxAlignment(Alignment); ensureMaxAlignment(Alignment);
return Index; return Index;
} }
/// Create a new statically sized stack object that represents a spill slot, /// Create a new statically sized stack object that represents a spill slot,
/// returning a nonnegative identifier to represent it. /// returning a nonnegative identifier to represent it.
int MachineFrameInfo::CreateSpillStackObject(uint64_t Size, int MachineFrameInfo::CreateSpillStackObject(uint64_t Size,
unsigned Alignment) { unsigned Alignment) {
Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
CreateStackObject(Size, Alignment, true); CreateStackObject(Size, Alignment, true);
int Index = (int)Objects.size() - NumFixedObjects - 1; int Index = (int)Objects.size() - NumFixedObjects - 1;
ensureMaxAlignment(Alignment); ensureMaxAlignment(Alignment);
return Index; return Index;
} }
/// Notify the MachineFrameInfo object that a variable sized object has been /// Notify the MachineFrameInfo object that a variable sized object has been
/// created. This must be created whenever a variable sized object is created, /// created. This must be created whenever a variable sized object is created,
/// whether or not the index returned is actually used. /// whether or not the index returned is actually used.
int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment, int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment,
const AllocaInst *Alloca) { const AllocaInst *Alloca) {
HasVarSizedObjects = true; HasVarSizedObjects = true;
Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true)); Objects.emplace_back(0, Alignment, 0, false, false, Alloca, true);
ensureMaxAlignment(Alignment); ensureMaxAlignment(Alignment);
return (int)Objects.size()-NumFixedObjects-1; return (int)Objects.size()-NumFixedObjects-1;
} }
/// Create a new object at a fixed location on the stack. /// Create a new object at a fixed location on the stack.
/// All fixed objects should be created before other objects are created for /// All fixed objects should be created before other objects are created for
/// efficiency. By default, fixed objects are immutable. This returns an /// efficiency. By default, fixed objects are immutable. This returns an
/// index with a negative value. /// index with a negative value.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
for (unsigned i = 0, e = Constants.size(); i != e; ++i) for (unsigned i = 0, e = Constants.size(); i != e; ++i)
if (!Constants[i].isMachineConstantPoolEntry() && if (!Constants[i].isMachineConstantPoolEntry() &&
CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) { CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
if ((unsigned)Constants[i].getAlignment() < Alignment) if ((unsigned)Constants[i].getAlignment() < Alignment)
Constants[i].Alignment = Alignment; Constants[i].Alignment = Alignment;
return i; return i;
} }
Constants.push_back(MachineConstantPoolEntry(C, Alignment)); Constants.emplace_back(C, Alignment);
return Constants.size()-1; return Constants.size()-1;
} }
unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,
unsigned Alignment) { unsigned Alignment) {
assert(Alignment && "Alignment must be specified!"); assert(Alignment && "Alignment must be specified!");
if (Alignment > PoolAlignment) PoolAlignment = Alignment; if (Alignment > PoolAlignment) PoolAlignment = Alignment;
// Check to see if we already have this constant. // Check to see if we already have this constant.
// //
// FIXME, this could be made much more efficient for large constant pools. // FIXME, this could be made much more efficient for large constant pools.
int Idx = V->getExistingMachineCPValue(this, Alignment); int Idx = V->getExistingMachineCPValue(this, Alignment);
if (Idx != -1) { if (Idx != -1) {
MachineCPVsSharingEntries.insert(V); MachineCPVsSharingEntries.insert(V);
return (unsigned)Idx; return (unsigned)Idx;
} }
Constants.push_back(MachineConstantPoolEntry(V, Alignment)); Constants.emplace_back(V, Alignment);
return Constants.size()-1; return Constants.size()-1;
} }
void MachineConstantPool::print(raw_ostream &OS) const { void MachineConstantPool::print(raw_ostream &OS) const {
if (Constants.empty()) return; if (Constants.empty()) return;
OS << "Constant Pool:\n"; OS << "Constant Pool:\n";
for (unsigned i = 0, e = Constants.size(); i != e; ++i) { for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
Show All 13 Lines

lib/CodeGen/MachineScheduler.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const std::vector<unsigned> &RegionPressure = const std::vector<unsigned> &RegionPressure =
RPTracker.getPressure().MaxSetPressure; RPTracker.getPressure().MaxSetPressure;
for (unsigned i = 0, e = RegionPressure.size(); i < e; ++i) { for (unsigned i = 0, e = RegionPressure.size(); i < e; ++i) {
unsigned Limit = RegClassInfo->getRegPressureSetLimit(i); unsigned Limit = RegClassInfo->getRegPressureSetLimit(i);
if (RegionPressure[i] > Limit) { if (RegionPressure[i] > Limit) {
DEBUG(dbgs() << TRI->getRegPressureSetName(i) DEBUG(dbgs() << TRI->getRegPressureSetName(i)
<< " Limit " << Limit << " Limit " << Limit
<< " Actual " << RegionPressure[i] << "\n"); << " Actual " << RegionPressure[i] << "\n");
RegionCriticalPSets.push_back(PressureChange(i)); RegionCriticalPSets.emplace_back(i);
} }
} }
DEBUG(dbgs() << "Excess PSets: "; DEBUG(dbgs() << "Excess PSets: ";
for (unsigned i = 0, e = RegionCriticalPSets.size(); i != e; ++i) for (unsigned i = 0, e = RegionCriticalPSets.size(); i != e; ++i)
dbgs() << TRI->getRegPressureSetName( dbgs() << TRI->getRegPressureSetName(
RegionCriticalPSets[i].getPSet()) << " "; RegionCriticalPSets[i].getPSet()) << " ";
dbgs() << "\n"); dbgs() << "\n");
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
void BaseMemOpClusterMutation::clusterNeighboringMemOps( void BaseMemOpClusterMutation::clusterNeighboringMemOps(
ArrayRef<SUnit *> MemOps, ScheduleDAGMI *DAG) { ArrayRef<SUnit *> MemOps, ScheduleDAGMI *DAG) {
SmallVector<MemOpInfo, 32> MemOpRecords; SmallVector<MemOpInfo, 32> MemOpRecords;
for (unsigned Idx = 0, End = MemOps.size(); Idx != End; ++Idx) { for (unsigned Idx = 0, End = MemOps.size(); Idx != End; ++Idx) {
SUnit *SU = MemOps[Idx]; SUnit *SU = MemOps[Idx];
unsigned BaseReg; unsigned BaseReg;
int64_t Offset; int64_t Offset;
if (TII->getMemOpBaseRegImmOfs(SU->getInstr(), BaseReg, Offset, TRI)) if (TII->getMemOpBaseRegImmOfs(SU->getInstr(), BaseReg, Offset, TRI))
MemOpRecords.push_back(MemOpInfo(SU, BaseReg, Offset)); MemOpRecords.emplace_back(SU, BaseReg, Offset);
} }
if (MemOpRecords.size() < 2) if (MemOpRecords.size() < 2)
return; return;
std::sort(MemOpRecords.begin(), MemOpRecords.end()); std::sort(MemOpRecords.begin(), MemOpRecords.end());
unsigned ClusterLength = 1; unsigned ClusterLength = 1;
for (unsigned Idx = 0, End = MemOpRecords.size(); Idx < (End - 1); ++Idx) { for (unsigned Idx = 0, End = MemOpRecords.size(); Idx < (End - 1); ++Idx) {
if (MemOpRecords[Idx].BaseReg != MemOpRecords[Idx+1].BaseReg) { if (MemOpRecords[Idx].BaseReg != MemOpRecords[Idx+1].BaseReg) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/MachineTraceMetrics.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Reg is live-in to all blocks in Trace that follow DefMBB. // Reg is live-in to all blocks in Trace that follow DefMBB.
for (unsigned i = Trace.size(); i; --i) { for (unsigned i = Trace.size(); i; --i) {
const MachineBasicBlock *MBB = Trace[i-1]; const MachineBasicBlock *MBB = Trace[i-1];
if (MBB == DefMBB) if (MBB == DefMBB)
return; return;
TraceBlockInfo &TBI = BlockInfo[MBB->getNumber()]; TraceBlockInfo &TBI = BlockInfo[MBB->getNumber()];
// Just add the register. The height will be updated later. // Just add the register. The height will be updated later.
TBI.LiveIns.push_back(Reg); TBI.LiveIns.emplace_back(Reg);
} }
} }
/// Compute instruction heights in the trace through MBB. This updates MBB and /// Compute instruction heights in the trace through MBB. This updates MBB and
/// the blocks below it in the trace. It is assumed that the trace has already /// the blocks below it in the trace. It is assumed that the trace has already
/// been computed. /// been computed.
void MachineTraceMetrics::Ensemble:: void MachineTraceMetrics::Ensemble::
computeInstrHeights(const MachineBasicBlock *MBB) { computeInstrHeights(const MachineBasicBlock *MBB) {
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
const MachineInstr *DefMI = MTM.MRI->getVRegDef(LIR.Reg); const MachineInstr *DefMI = MTM.MRI->getVRegDef(LIR.Reg);
LIR.Height = Heights.lookup(DefMI); LIR.Height = Heights.lookup(DefMI);
DEBUG(dbgs() << ' ' << PrintReg(LIR.Reg) << '@' << LIR.Height); DEBUG(dbgs() << ' ' << PrintReg(LIR.Reg) << '@' << LIR.Height);
} }
// Transfer the live regunits to the live-in list. // Transfer the live regunits to the live-in list.
for (SparseSet<LiveRegUnit>::const_iterator for (SparseSet<LiveRegUnit>::const_iterator
RI = RegUnits.begin(), RE = RegUnits.end(); RI != RE; ++RI) { RI = RegUnits.begin(), RE = RegUnits.end(); RI != RE; ++RI) {
TBI.LiveIns.push_back(LiveInReg(RI->RegUnit, RI->Cycle)); TBI.LiveIns.emplace_back(RI->RegUnit, RI->Cycle);
DEBUG(dbgs() << ' ' << PrintRegUnit(RI->RegUnit, MTM.TRI) DEBUG(dbgs() << ' ' << PrintRegUnit(RI->RegUnit, MTM.TRI)
<< '@' << RI->Cycle); << '@' << RI->Cycle);
} }
DEBUG(dbgs() << '\n'); DEBUG(dbgs() << '\n');
if (!TBI.HasValidInstrDepths) if (!TBI.HasValidInstrDepths)
continue; continue;
// Add live-ins to the critical path length. // Add live-ins to the critical path length.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/PeepholeOptimizer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const MachineInstr *getInst() const { return Inst; } const MachineInstr *getInst() const { return Inst; }
void clear() { void clear() {
RegSrcs.clear(); RegSrcs.clear();
Inst = nullptr; Inst = nullptr;
} }
void addSource(unsigned SrcReg, unsigned SrcSubReg) { void addSource(unsigned SrcReg, unsigned SrcSubReg) {
RegSrcs.push_back(TargetInstrInfo::RegSubRegPair(SrcReg, SrcSubReg)); RegSrcs.emplace_back(SrcReg, SrcSubReg);
} }
void setSource(int Idx, unsigned SrcReg, unsigned SrcSubReg) { void setSource(int Idx, unsigned SrcReg, unsigned SrcSubReg) {
assert(Idx < getNumSources() && "Reg pair source out of index"); assert(Idx < getNumSources() && "Reg pair source out of index");
RegSrcs[Idx] = TargetInstrInfo::RegSubRegPair(SrcReg, SrcSubReg); RegSrcs[Idx] = TargetInstrInfo::RegSubRegPair(SrcReg, SrcSubReg);
} }
int getNumSources() const { return RegSrcs.size(); } int getNumSources() const { return RegSrcs.size(); }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
RewriteMap.insert(std::make_pair(CurSrcPair, Res)); RewriteMap.insert(std::make_pair(CurSrcPair, Res));
// ValueTrackerResult usually have one source unless it's the result from // ValueTrackerResult usually have one source unless it's the result from
// a PHI instruction. Add the found PHI edges to be looked up further. // a PHI instruction. Add the found PHI edges to be looked up further.
unsigned NumSrcs = Res.getNumSources(); unsigned NumSrcs = Res.getNumSources();
if (NumSrcs > 1) { if (NumSrcs > 1) {
PHICount++; PHICount++;
for (unsigned i = 0; i < NumSrcs; ++i) for (unsigned i = 0; i < NumSrcs; ++i)
SrcToLook.push_back(TargetInstrInfo::RegSubRegPair( SrcToLook.emplace_back(
Res.getSrcReg(i), Res.getSrcSubReg(i))); Res.getSrcReg(i), Res.getSrcSubReg(i));
break; break;
} }
CurSrcPair.Reg = Res.getSrcReg(0); CurSrcPair.Reg = Res.getSrcReg(0);
CurSrcPair.SubReg = Res.getSrcSubReg(0); CurSrcPair.SubReg = Res.getSrcSubReg(0);
// Do not extend the live-ranges of physical registers as they add // Do not extend the live-ranges of physical registers as they add
// constraints to the register allocator. Moreover, if we want to extend // constraints to the register allocator. Moreover, if we want to extend
// the live-range of a physical register, unlike SSA virtual register, // the live-range of a physical register, unlike SSA virtual register,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/PrologEpilogInserter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo(); const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&F); const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&F);
std::vector<CalleeSavedInfo> CSI; std::vector<CalleeSavedInfo> CSI;
for (unsigned i = 0; CSRegs[i]; ++i) { for (unsigned i = 0; CSRegs[i]; ++i) {
unsigned Reg = CSRegs[i]; unsigned Reg = CSRegs[i];
if (SavedRegs.test(Reg)) if (SavedRegs.test(Reg))
CSI.push_back(CalleeSavedInfo(Reg)); CSI.emplace_back(Reg);
} }
const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering(); const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering();
MachineFrameInfo *MFI = F.getFrameInfo(); MachineFrameInfo *MFI = F.getFrameInfo();
if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI)) { if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI)) {
// If target doesn't implement this, use generic code. // If target doesn't implement this, use generic code.
if (CSI.empty()) if (CSI.empty())
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/RegAllocGreedy.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (OtherReg == Reg) if (OtherReg == Reg)
continue; continue;
} }
// Get the current assignment. // Get the current assignment.
unsigned OtherPhysReg = TargetRegisterInfo::isPhysicalRegister(OtherReg) unsigned OtherPhysReg = TargetRegisterInfo::isPhysicalRegister(OtherReg)
? OtherReg ? OtherReg
: VRM->getPhys(OtherReg); : VRM->getPhys(OtherReg);
// Push the collected information. // Push the collected information.
Out.push_back(HintInfo(MBFI->getBlockFreq(Instr.getParent()), OtherReg, Out.emplace_back(MBFI->getBlockFreq(Instr.getParent()), OtherReg,
OtherPhysReg)); OtherPhysReg);
} }
} }
/// \brief Using the given \p List, compute the cost of the broken hints if /// \brief Using the given \p List, compute the cost of the broken hints if
/// \p PhysReg was used. /// \p PhysReg was used.
/// \return The cost of \p List for \p PhysReg. /// \return The cost of \p List for \p PhysReg.
BlockFrequency RAGreedy::getBrokenHintFreq(const HintsInfo &List, BlockFrequency RAGreedy::getBrokenHintFreq(const HintsInfo &List,
unsigned PhysReg) { unsigned PhysReg) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/RegisterCoalescer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
void RegisterCoalescer::joinAllIntervals() { void RegisterCoalescer::joinAllIntervals() {
DEBUG(dbgs() << "********** JOINING INTERVALS ***********\n"); DEBUG(dbgs() << "********** JOINING INTERVALS ***********\n");
assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around."); assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around.");
std::vector<MBBPriorityInfo> MBBs; std::vector<MBBPriorityInfo> MBBs;
MBBs.reserve(MF->size()); MBBs.reserve(MF->size());
for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) { for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) {
MachineBasicBlock *MBB = &*I; MachineBasicBlock *MBB = &*I;
MBBs.push_back(MBBPriorityInfo(MBB, Loops->getLoopDepth(MBB), MBBs.emplace_back(MBB, Loops->getLoopDepth(MBB),
JoinSplitEdges && isSplitEdge(MBB))); JoinSplitEdges && isSplitEdge(MBB));
} }
array_pod_sort(MBBs.begin(), MBBs.end(), compareMBBPriority); array_pod_sort(MBBs.begin(), MBBs.end(), compareMBBPriority);
// Coalesce intervals in MBB priority order. // Coalesce intervals in MBB priority order.
unsigned CurrDepth = UINT_MAX; unsigned CurrDepth = UINT_MAX;
for (unsigned i = 0, e = MBBs.size(); i != e; ++i) { for (unsigned i = 0, e = MBBs.size(); i != e; ++i) {
// Try coalescing the collected local copies for deeper loops. // Try coalescing the collected local copies for deeper loops.
if (JoinGlobalCopies && MBBs[i].Depth < CurrDepth) { if (JoinGlobalCopies && MBBs[i].Depth < CurrDepth) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/ScheduleDAGInstrs.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// For now, ignore PseudoSourceValues which may alias LLVM IR values // For now, ignore PseudoSourceValues which may alias LLVM IR values
// because the code that uses this function has no way to cope with // because the code that uses this function has no way to cope with
// such aliases. // such aliases.
if (PSV->isAliased(MFI)) if (PSV->isAliased(MFI))
return false; return false;
bool MayAlias = PSV->mayAlias(MFI); bool MayAlias = PSV->mayAlias(MFI);
Objects.push_back(UnderlyingObjectsVector::value_type(PSV, MayAlias)); Objects.emplace_back(PSV, MayAlias);
} else if (const Value *V = MMO->getValue()) { } else if (const Value *V = MMO->getValue()) {
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
getUnderlyingObjects(V, Objs, DL); getUnderlyingObjects(V, Objs, DL);
for (Value *V : Objs) { for (Value *V : Objs) {
if (!isIdentifiedObject(V)) if (!isIdentifiedObject(V))
return false; return false;
Objects.push_back(UnderlyingObjectsVector::value_type(V, true)); Objects.emplace_back(V, true);
} }
} else } else
return false; return false;
} }
return true; return true;
}; };
if (!allMMOsOkay()) if (!allMMOsOkay())
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
void visitPostorderEdge(const SDep &PredDep, const SUnit *Succ) { void visitPostorderEdge(const SDep &PredDep, const SUnit *Succ) {
R.DFSNodeData[Succ->NodeNum].InstrCount R.DFSNodeData[Succ->NodeNum].InstrCount
+= R.DFSNodeData[PredDep.getSUnit()->NodeNum].InstrCount; += R.DFSNodeData[PredDep.getSUnit()->NodeNum].InstrCount;
joinPredSubtree(PredDep, Succ); joinPredSubtree(PredDep, Succ);
} }
/// Add a connection for cross edges. /// Add a connection for cross edges.
void visitCrossEdge(const SDep &PredDep, const SUnit *Succ) { void visitCrossEdge(const SDep &PredDep, const SUnit *Succ) {
ConnectionPairs.push_back(std::make_pair(PredDep.getSUnit(), Succ)); ConnectionPairs.emplace_back(std::make_pair(PredDep.getSUnit(), Succ));
alexfhUnsubmitted
Not Done
ReplyInline Actions

No make_pair needed.

alexfh: No `make_pair` needed.
} }
/// Set each node's subtree ID to the representative ID and record connections /// Set each node's subtree ID to the representative ID and record connections
/// between trees. /// between trees.
void finalize() { void finalize() {
SubtreeClasses.compress(); SubtreeClasses.compress();
R.DFSTreeData.resize(SubtreeClasses.getNumClasses()); R.DFSTreeData.resize(SubtreeClasses.getNumClasses());
assert(SubtreeClasses.getNumClasses() == RootSet.size() assert(SubtreeClasses.getNumClasses() == RootSet.size()
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!LdPtr.equalBaseIndex(LdBasePtr)) if (!LdPtr.equalBaseIndex(LdBasePtr))
break; break;
} else { } else {
// Check that all other base pointers are the same as this one. // Check that all other base pointers are the same as this one.
LdBasePtr = LdPtr; LdBasePtr = LdPtr;
} }
// We found a potential memory operand to merge. // We found a potential memory operand to merge.
LoadNodes.push_back(MemOpLink(Ld, LdPtr.Offset, 0)); LoadNodes.emplace_back(Ld, LdPtr.Offset, 0);
} }
if (LoadNodes.size() < 2) if (LoadNodes.size() < 2)
return false; return false;
// If we have load/store pair instructions and we only have two values, // If we have load/store pair instructions and we only have two values,
// don't bother. // don't bother.
unsigned RequiredAlignment; unsigned RequiredAlignment;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/FastISel.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (const auto *Inst = dyn_cast<Instruction>(PHIOp)) if (const auto *Inst = dyn_cast<Instruction>(PHIOp))
DbgLoc = Inst->getDebugLoc(); DbgLoc = Inst->getDebugLoc();
unsigned Reg = getRegForValue(PHIOp); unsigned Reg = getRegForValue(PHIOp);
if (!Reg) { if (!Reg) {
FuncInfo.PHINodesToUpdate.resize(FuncInfo.OrigNumPHINodesToUpdate); FuncInfo.PHINodesToUpdate.resize(FuncInfo.OrigNumPHINodesToUpdate);
return false; return false;
} }
FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); FuncInfo.PHINodesToUpdate.emplace_back(std::make_pair(MBBI++, Reg));
alexfhUnsubmitted
Not Done
ReplyInline Actions

No make_pair needed.

alexfh: No `make_pair` needed.
DbgLoc = DebugLoc(); DbgLoc = DebugLoc();
} }
} }
return true; return true;
} }
bool FastISel::tryToFoldLoad(const LoadInst *LI, const Instruction *FoldInst) { bool FastISel::tryToFoldLoad(const LoadInst *LI, const Instruction *FoldInst) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
N->getOperand(N->getNumOperands()-1).getValueType() == MVT::Glue) { N->getOperand(N->getNumOperands()-1).getValueType() == MVT::Glue) {
return false; return false;
} }
// Don't add glue to something that already has a glue value. // Don't add glue to something that already has a glue value.
if (N->getValueType(N->getNumValues() - 1) == MVT::Glue) return false; if (N->getValueType(N->getNumValues() - 1) == MVT::Glue) return false;
SmallVector<EVT, 4> VTs(N->value_begin(), N->value_end()); SmallVector<EVT, 4> VTs(N->value_begin(), N->value_end());
if (AddGlue) if (AddGlue)
VTs.push_back(MVT::Glue); VTs.emplace_back(MVT::Glue);
CloneNodeWithValues(N, DAG, VTs, Glue); CloneNodeWithValues(N, DAG, VTs, Glue);
return true; return true;
} }
// Cleanup after unsuccessful AddGlue. Use the standard method of morphing the // Cleanup after unsuccessful AddGlue. Use the standard method of morphing the
// node even though simply shrinking the value list is sufficient. // node even though simply shrinking the value list is sufficient.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
ArgChains.push_back(Chain); ArgChains.push_back(Chain);
// Add a chain value for each stack argument. // Add a chain value for each stack argument.
for (SDNode::use_iterator U = getEntryNode().getNode()->use_begin(), for (SDNode::use_iterator U = getEntryNode().getNode()->use_begin(),
UE = getEntryNode().getNode()->use_end(); U != UE; ++U) UE = getEntryNode().getNode()->use_end(); U != UE; ++U)
if (LoadSDNode *L = dyn_cast<LoadSDNode>(*U)) if (LoadSDNode *L = dyn_cast<LoadSDNode>(*U))
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(L->getBasePtr())) if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(L->getBasePtr()))
if (FI->getIndex() < 0) if (FI->getIndex() < 0)
ArgChains.push_back(SDValue(L, 1)); ArgChains.emplace_back(L, 1);
// Build a tokenfactor for all the chains. // Build a tokenfactor for all the chains.
return getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains); return getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains);
} }
/// getMemsetValue - Vectorized representation of the memset value /// getMemsetValue - Vectorized representation of the memset value
/// operand. /// operand.
static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG, static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
namespace { namespace {
struct EVTArray { struct EVTArray {
std::vector<EVT> VTs; std::vector<EVT> VTs;
EVTArray() { EVTArray() {
VTs.reserve(MVT::LAST_VALUETYPE); VTs.reserve(MVT::LAST_VALUETYPE);
for (unsigned i = 0; i < MVT::LAST_VALUETYPE; ++i) for (unsigned i = 0; i < MVT::LAST_VALUETYPE; ++i)
VTs.push_back(MVT((MVT::SimpleValueType)i)); VTs.emplace_back(MVT((MVT::SimpleValueType)i));
} }
}; };
} }
static ManagedStatic<std::set<EVT, EVT::compareRawBits> > EVTs; static ManagedStatic<std::set<EVT, EVT::compareRawBits> > EVTs;
static ManagedStatic<EVTArray> SimpleVTArray; static ManagedStatic<EVTArray> SimpleVTArray;
static ManagedStatic<sys::SmartMutex<true> > VTMutex; static ManagedStatic<sys::SmartMutex<true> > VTMutex;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end(); for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
OI != OE; ++OI) { OI != OE; ++OI) {
SDNode *Val = getValue(*OI).getNode(); SDNode *Val = getValue(*OI).getNode();
// If the operand is an empty aggregate, there are no values. // If the operand is an empty aggregate, there are no values.
if (!Val) continue; if (!Val) continue;
// Add each leaf value from the operand to the Constants list // Add each leaf value from the operand to the Constants list
// to form a flattened list of all the values. // to form a flattened list of all the values.
for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i) for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
Constants.push_back(SDValue(Val, i)); Constants.emplace_back(Val, i);
} }
return DAG.getMergeValues(Constants, getCurSDLoc()); return DAG.getMergeValues(Constants, getCurSDLoc());
} }
if (const ConstantDataSequential *CDS = if (const ConstantDataSequential *CDS =
dyn_cast<ConstantDataSequential>(C)) { dyn_cast<ConstantDataSequential>(C)) {
SmallVector<SDValue, 4> Ops; SmallVector<SDValue, 4> Ops;
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) { for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
SDNode *Val = getValue(CDS->getElementAsConstant(i)).getNode(); SDNode *Val = getValue(CDS->getElementAsConstant(i)).getNode();
// Add each leaf value from the operand to the Constants list // Add each leaf value from the operand to the Constants list
// to form a flattened list of all the values. // to form a flattened list of all the values.
for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i) for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
Ops.push_back(SDValue(Val, i)); Ops.emplace_back(Val, i);
} }
if (isa<ArrayType>(CDS->getType())) if (isa<ArrayType>(CDS->getType()))
return DAG.getMergeValues(Ops, getCurSDLoc()); return DAG.getMergeValues(Ops, getCurSDLoc());
return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(), return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(),
VT, Ops); VT, Ops);
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Propagate extension type if any // Propagate extension type if any
if (ExtendKind == ISD::SIGN_EXTEND) if (ExtendKind == ISD::SIGN_EXTEND)
Flags.setSExt(); Flags.setSExt();
else if (ExtendKind == ISD::ZERO_EXTEND) else if (ExtendKind == ISD::ZERO_EXTEND)
Flags.setZExt(); Flags.setZExt();
for (unsigned i = 0; i < NumParts; ++i) { for (unsigned i = 0; i < NumParts; ++i) {
Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(), Outs.emplace_back(Flags, Parts[i].getValueType(),
VT, /*isfixed=*/true, 0, 0)); VT, /*isfixed=*/true, 0, 0);
OutVals.push_back(Parts[i]); OutVals.push_back(Parts[i]);
} }
} }
} }
} }
// Push in swifterror virtual register as the last element of Outs. This makes // Push in swifterror virtual register as the last element of Outs. This makes
// sure swifterror virtual register will be returned in the swifterror // sure swifterror virtual register will be returned in the swifterror
// physical register. // physical register.
const Function *F = I.getParent()->getParent(); const Function *F = I.getParent()->getParent();
if (TLI.supportSwiftError() && if (TLI.supportSwiftError() &&
F->getAttributes().hasAttrSomewhere(Attribute::SwiftError)) { F->getAttributes().hasAttrSomewhere(Attribute::SwiftError)) {
ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy(); ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
Flags.setSwiftError(); Flags.setSwiftError();
Outs.push_back(ISD::OutputArg(Flags, EVT(TLI.getPointerTy(DL)) /*vt*/, Outs.emplace_back(Flags, EVT(TLI.getPointerTy(DL)) /*vt*/,
EVT(TLI.getPointerTy(DL)) /*argvt*/, EVT(TLI.getPointerTy(DL)) /*argvt*/,
true /*isfixed*/, 1 /*origidx*/, true /*isfixed*/, 1 /*origidx*/,
0 /*partOffs*/)); 0 /*partOffs*/);
// Create SDNode for the swifterror virtual register. // Create SDNode for the swifterror virtual register.
OutVals.push_back(DAG.getRegister(FuncInfo.SwiftErrorMap[FuncInfo.MBB][0], OutVals.push_back(DAG.getRegister(FuncInfo.SwiftErrorMap[FuncInfo.MBB][0],
EVT(TLI.getPointerTy(DL)))); EVT(TLI.getPointerTy(DL))));
} }
bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg(); bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
CallingConv::ID CallConv = CallingConv::ID CallConv =
DAG.getMachineFunction().getFunction()->getCallingConv(); DAG.getMachineFunction().getFunction()->getCallingConv();
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
LHSVal = getValue(LHS); LHSVal = getValue(LHS);
RHSVal = getValue(RHS); RHSVal = getValue(RHS);
BaseOps = {}; BaseOps = {};
} }
} }
for (unsigned i = 0; i != NumValues; ++i) { for (unsigned i = 0; i != NumValues; ++i) {
SmallVector<SDValue, 3> Ops(BaseOps.begin(), BaseOps.end()); SmallVector<SDValue, 3> Ops(BaseOps.begin(), BaseOps.end());
Ops.push_back(SDValue(LHSVal.getNode(), LHSVal.getResNo() + i)); Ops.emplace_back(LHSVal.getNode(), LHSVal.getResNo() + i);
Ops.push_back(SDValue(RHSVal.getNode(), RHSVal.getResNo() + i)); Ops.emplace_back(RHSVal.getNode(), RHSVal.getResNo() + i);
Values[i] = DAG.getNode(OpCode, getCurSDLoc(), Values[i] = DAG.getNode(OpCode, getCurSDLoc(),
LHSVal.getNode()->getValueType(LHSVal.getResNo()+i), LHSVal.getNode()->getValueType(LHSVal.getResNo()+i),
Ops); Ops);
} }
setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(), setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
DAG.getVTList(ValueVTs), Values)); DAG.getVTList(ValueVTs), Values));
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
SDValue Op = getValue(I.getArgOperand(i)); SDValue Op = getValue(I.getArgOperand(i));
Ops.push_back(Op); Ops.push_back(Op);
} }
SmallVector<EVT, 4> ValueVTs; SmallVector<EVT, 4> ValueVTs;
ComputeValueVTs(TLI, DAG.getDataLayout(), I.getType(), ValueVTs); ComputeValueVTs(TLI, DAG.getDataLayout(), I.getType(), ValueVTs);
if (HasChain) if (HasChain)
ValueVTs.push_back(MVT::Other); ValueVTs.emplace_back(MVT::Other);
SDVTList VTs = DAG.getVTList(ValueVTs); SDVTList VTs = DAG.getVTList(ValueVTs);
// Create the node. // Create the node.
SDValue Result; SDValue Result;
if (IsTgtIntrinsic) { if (IsTgtIntrinsic) {
// This is target intrinsic that touches memory // This is target intrinsic that touches memory
Result = DAG.getMemIntrinsicNode(Info.opc, getCurSDLoc(), Result = DAG.getMemIntrinsicNode(Info.opc, getCurSDLoc(),
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// C_Register operands have already been allocated, Other/Memory don't need // C_Register operands have already been allocated, Other/Memory don't need
// to be. // to be.
if (OpInfo.ConstraintType == TargetLowering::C_RegisterClass) if (OpInfo.ConstraintType == TargetLowering::C_RegisterClass)
GetRegistersForValue(DAG, TLI, getCurSDLoc(), OpInfo); GetRegistersForValue(DAG, TLI, getCurSDLoc(), OpInfo);
} }
// AsmNodeOperands - The operands for the ISD::INLINEASM node. // AsmNodeOperands - The operands for the ISD::INLINEASM node.
std::vector<SDValue> AsmNodeOperands; std::vector<SDValue> AsmNodeOperands;
AsmNodeOperands.push_back(SDValue()); // reserve space for input chain AsmNodeOperands.emplace_back(); // reserve space for input chain
AsmNodeOperands.push_back(DAG.getTargetExternalSymbol( AsmNodeOperands.push_back(DAG.getTargetExternalSymbol(
IA->getAsmString().c_str(), TLI.getPointerTy(DAG.getDataLayout()))); IA->getAsmString().c_str(), TLI.getPointerTy(DAG.getDataLayout())));
// If we have a !srcloc metadata node associated with it, we want to attach // If we have a !srcloc metadata node associated with it, we want to attach
// this to the ultimately generated inline asm machineinstr. To do this, we // this to the ultimately generated inline asm machineinstr. To do this, we
// pass in the third operand as this (potentially null) inline asm MDNode. // pass in the third operand as this (potentially null) inline asm MDNode.
const MDNode *SrcLoc = CS.getInstruction()->getMetadata("srcloc"); const MDNode *SrcLoc = CS.getInstruction()->getMetadata("srcloc");
AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc)); AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
if (IsAnyRegCC && HasDef) { if (IsAnyRegCC && HasDef) {
// Create the return types based on the intrinsic definition // Create the return types based on the intrinsic definition
const TargetLowering &TLI = DAG.getTargetLoweringInfo(); const TargetLowering &TLI = DAG.getTargetLoweringInfo();
SmallVector<EVT, 3> ValueVTs; SmallVector<EVT, 3> ValueVTs;
ComputeValueVTs(TLI, DAG.getDataLayout(), CS->getType(), ValueVTs); ComputeValueVTs(TLI, DAG.getDataLayout(), CS->getType(), ValueVTs);
assert(ValueVTs.size() == 1 && "Expected only one return value type."); assert(ValueVTs.size() == 1 && "Expected only one return value type.");
// There is always a chain and a glue type at the end // There is always a chain and a glue type at the end
ValueVTs.push_back(MVT::Other); ValueVTs.emplace_back(MVT::Other);
ValueVTs.push_back(MVT::Glue); ValueVTs.emplace_back(MVT::Glue);
NodeTys = DAG.getVTList(ValueVTs); NodeTys = DAG.getVTList(ValueVTs);
} else } else
NodeTys = DAG.getVTList(MVT::Other, MVT::Glue); NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
// Replace the target specific call node with a PATCHPOINT node. // Replace the target specific call node with a PATCHPOINT node.
MachineSDNode *MN = DAG.getMachineNode(TargetOpcode::PATCHPOINT, MachineSDNode *MN = DAG.getMachineNode(TargetOpcode::PATCHPOINT,
dl, NodeTys, Ops); dl, NodeTys, Ops);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// the input for this MBB. // the input for this MBB.
SmallVector<EVT, 4> ValueVTs; SmallVector<EVT, 4> ValueVTs;
const TargetLowering &TLI = DAG.getTargetLoweringInfo(); const TargetLowering &TLI = DAG.getTargetLoweringInfo();
ComputeValueVTs(TLI, DAG.getDataLayout(), PN->getType(), ValueVTs); ComputeValueVTs(TLI, DAG.getDataLayout(), PN->getType(), ValueVTs);
for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) { for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) {
EVT VT = ValueVTs[vti]; EVT VT = ValueVTs[vti];
unsigned NumRegisters = TLI.getNumRegisters(*DAG.getContext(), VT); unsigned NumRegisters = TLI.getNumRegisters(*DAG.getContext(), VT);
for (unsigned i = 0, e = NumRegisters; i != e; ++i) for (unsigned i = 0, e = NumRegisters; i != e; ++i)
FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); FuncInfo.PHINodesToUpdate.emplace_back(std::make_pair(MBBI++, Reg+i));
Reg += NumRegisters; Reg += NumRegisters;
} }
} }
} }
ConstantsOut.clear(); ConstantsOut.clear();
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
auto TotalProb = BranchProbability::getZero(); auto TotalProb = BranchProbability::getZero();
for (unsigned i = First; i <= Last; ++i) { for (unsigned i = First; i <= Last; ++i) {
// Find the CaseBits for this destination. // Find the CaseBits for this destination.
unsigned j; unsigned j;
for (j = 0; j < CBV.size(); ++j) for (j = 0; j < CBV.size(); ++j)
if (CBV[j].BB == Clusters[i].MBB) if (CBV[j].BB == Clusters[i].MBB)
break; break;
if (j == CBV.size()) if (j == CBV.size())
CBV.push_back( CBV.emplace_back(0, Clusters[i].MBB, 0, BranchProbability::getZero());
CaseBits(0, Clusters[i].MBB, 0, BranchProbability::getZero()));
CaseBits *CB = &CBV[j]; CaseBits *CB = &CBV[j];
// Update Mask, Bits and ExtraProb. // Update Mask, Bits and ExtraProb.
uint64_t Lo = (Clusters[i].Low->getValue() - LowBound).getZExtValue(); uint64_t Lo = (Clusters[i].Low->getValue() - LowBound).getZExtValue();
uint64_t Hi = (Clusters[i].High->getValue() - LowBound).getZExtValue(); uint64_t Hi = (Clusters[i].High->getValue() - LowBound).getZExtValue();
assert(Hi >= Lo && Hi < 64 && "Invalid bit case!"); assert(Hi >= Lo && Hi < 64 && "Invalid bit case!");
CB->Mask |= (-1ULL >> (63 - (Hi - Lo))) << Lo; CB->Mask |= (-1ULL >> (63 - (Hi - Lo))) << Lo;
CB->Bits += Hi - Lo + 1; CB->Bits += Hi - Lo + 1;
CB->ExtraProb += Clusters[i].Prob; CB->ExtraProb += Clusters[i].Prob;
TotalProb += Clusters[i].Prob; TotalProb += Clusters[i].Prob;
} }
BitTestInfo BTI; BitTestInfo BTI;
std::sort(CBV.begin(), CBV.end(), [](const CaseBits &a, const CaseBits &b) { std::sort(CBV.begin(), CBV.end(), [](const CaseBits &a, const CaseBits &b) {
// Sort by probability first, number of bits second. // Sort by probability first, number of bits second.
if (a.ExtraProb != b.ExtraProb) if (a.ExtraProb != b.ExtraProb)
return a.ExtraProb > b.ExtraProb; return a.ExtraProb > b.ExtraProb;
return a.Bits > b.Bits; return a.Bits > b.Bits;
}); });
for (auto &CB : CBV) { for (auto &CB : CBV) {
MachineBasicBlock *BitTestBB = MachineBasicBlock *BitTestBB =
FuncInfo.MF->CreateMachineBasicBlock(SI->getParent()); FuncInfo.MF->CreateMachineBasicBlock(SI->getParent());
BTI.push_back(BitTestCase(CB.Mask, BitTestBB, CB.BB, CB.ExtraProb)); BTI.emplace_back(CB.Mask, BitTestBB, CB.BB, CB.ExtraProb);
} }
BitTestCases.emplace_back(std::move(LowBound), std::move(CmpRange), BitTestCases.emplace_back(std::move(LowBound), std::move(CmpRange),
SI->getCondition(), -1U, MVT::Other, false, SI->getCondition(), -1U, MVT::Other, false,
ContiguousRange, nullptr, nullptr, std::move(BTI), ContiguousRange, nullptr, nullptr, std::move(BTI),
TotalProb); TotalProb);
BTCluster = CaseCluster::bitTests(Clusters[First].Low, Clusters[Last].High, BTCluster = CaseCluster::bitTests(Clusters[First].Low, Clusters[Last].High,
BitTestCases.size() - 1, TotalProb); BitTestCases.size() - 1, TotalProb);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
continue; continue;
} }
case OPC_EmitInteger: { case OPC_EmitInteger: {
MVT::SimpleValueType VT = MVT::SimpleValueType VT =
(MVT::SimpleValueType)MatcherTable[MatcherIndex++]; (MVT::SimpleValueType)MatcherTable[MatcherIndex++];
int64_t Val = MatcherTable[MatcherIndex++]; int64_t Val = MatcherTable[MatcherIndex++];
if (Val & 128) if (Val & 128)
Val = GetVBR(Val, MatcherTable, MatcherIndex); Val = GetVBR(Val, MatcherTable, MatcherIndex);
RecordedNodes.push_back(std::pair<SDValue, SDNode*>( RecordedNodes.emplace_back(
CurDAG->getTargetConstant(Val, SDLoc(NodeToMatch), CurDAG->getTargetConstant(Val, SDLoc(NodeToMatch),
VT), nullptr)); VT), nullptr);
continue; continue;
} }
case OPC_EmitRegister: { case OPC_EmitRegister: {
MVT::SimpleValueType VT = MVT::SimpleValueType VT =
(MVT::SimpleValueType)MatcherTable[MatcherIndex++]; (MVT::SimpleValueType)MatcherTable[MatcherIndex++];
unsigned RegNo = MatcherTable[MatcherIndex++]; unsigned RegNo = MatcherTable[MatcherIndex++];
RecordedNodes.push_back(std::pair<SDValue, SDNode*>( RecordedNodes.emplace_back(
CurDAG->getRegister(RegNo, VT), nullptr)); CurDAG->getRegister(RegNo, VT), nullptr);
continue; continue;
} }
case OPC_EmitRegister2: { case OPC_EmitRegister2: {
// For targets w/ more than 256 register names, the register enum // For targets w/ more than 256 register names, the register enum
// values are stored in two bytes in the matcher table (just like // values are stored in two bytes in the matcher table (just like
// opcodes). // opcodes).
MVT::SimpleValueType VT = MVT::SimpleValueType VT =
(MVT::SimpleValueType)MatcherTable[MatcherIndex++]; (MVT::SimpleValueType)MatcherTable[MatcherIndex++];
unsigned RegNo = MatcherTable[MatcherIndex++]; unsigned RegNo = MatcherTable[MatcherIndex++];
RegNo |= MatcherTable[MatcherIndex++] << 8; RegNo |= MatcherTable[MatcherIndex++] << 8;
RecordedNodes.push_back(std::pair<SDValue, SDNode*>( RecordedNodes.emplace_back(
CurDAG->getRegister(RegNo, VT), nullptr)); CurDAG->getRegister(RegNo, VT), nullptr);
continue; continue;
} }
case OPC_EmitConvertToTarget: { case OPC_EmitConvertToTarget: {
// Convert from IMM/FPIMM to target version. // Convert from IMM/FPIMM to target version.
unsigned RecNo = MatcherTable[MatcherIndex++]; unsigned RecNo = MatcherTable[MatcherIndex++];
assert(RecNo < RecordedNodes.size() && "Invalid EmitConvertToTarget"); assert(RecNo < RecordedNodes.size() && "Invalid EmitConvertToTarget");
SDValue Imm = RecordedNodes[RecNo].first; SDValue Imm = RecordedNodes[RecNo].first;
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
continue; continue;
} }
case OPC_EmitNodeXForm: { case OPC_EmitNodeXForm: {
unsigned XFormNo = MatcherTable[MatcherIndex++]; unsigned XFormNo = MatcherTable[MatcherIndex++];
unsigned RecNo = MatcherTable[MatcherIndex++]; unsigned RecNo = MatcherTable[MatcherIndex++];
assert(RecNo < RecordedNodes.size() && "Invalid EmitNodeXForm"); assert(RecNo < RecordedNodes.size() && "Invalid EmitNodeXForm");
SDValue Res = RunSDNodeXForm(RecordedNodes[RecNo].first, XFormNo); SDValue Res = RunSDNodeXForm(RecordedNodes[RecNo].first, XFormNo);
RecordedNodes.push_back(std::pair<SDValue,SDNode*>(Res, nullptr)); RecordedNodes.emplace_back(Res, nullptr);
continue; continue;
} }
case OPC_EmitNode: case OPC_MorphNodeTo: case OPC_EmitNode: case OPC_MorphNodeTo:
case OPC_EmitNode0: case OPC_EmitNode1: case OPC_EmitNode2: case OPC_EmitNode0: case OPC_EmitNode1: case OPC_EmitNode2:
case OPC_MorphNodeTo0: case OPC_MorphNodeTo1: case OPC_MorphNodeTo2: { case OPC_MorphNodeTo0: case OPC_MorphNodeTo1: case OPC_MorphNodeTo2: {
uint16_t TargetOpc = MatcherTable[MatcherIndex++]; uint16_t TargetOpc = MatcherTable[MatcherIndex++];
TargetOpc |= (unsigned short)MatcherTable[MatcherIndex++] << 8; TargetOpc |= (unsigned short)MatcherTable[MatcherIndex++] << 8;
Show All 9 Lines
else else
NumVTs = MatcherTable[MatcherIndex++]; NumVTs = MatcherTable[MatcherIndex++];
SmallVector<EVT, 4> VTs; SmallVector<EVT, 4> VTs;
for (unsigned i = 0; i != NumVTs; ++i) { for (unsigned i = 0; i != NumVTs; ++i) {
MVT::SimpleValueType VT = MVT::SimpleValueType VT =
(MVT::SimpleValueType)MatcherTable[MatcherIndex++]; (MVT::SimpleValueType)MatcherTable[MatcherIndex++];
if (VT == MVT::iPTR) if (VT == MVT::iPTR)
VT = TLI->getPointerTy(CurDAG->getDataLayout()).SimpleTy; VT = TLI->getPointerTy(CurDAG->getDataLayout()).SimpleTy;
VTs.push_back(VT); VTs.emplace_back(VT);
} }
if (EmitNodeInfo & OPFL_Chain) if (EmitNodeInfo & OPFL_Chain)
VTs.push_back(MVT::Other); VTs.emplace_back(MVT::Other);
if (EmitNodeInfo & OPFL_GlueOutput) if (EmitNodeInfo & OPFL_GlueOutput)
VTs.push_back(MVT::Glue); VTs.emplace_back(MVT::Glue);
// This is hot code, so optimize the two most common cases of 1 and 2 // This is hot code, so optimize the two most common cases of 1 and 2
// results. // results.
SDVTList VTList; SDVTList VTList;
if (VTs.size() == 1) if (VTs.size() == 1)
VTList = CurDAG->getVTList(VTs[0]); VTList = CurDAG->getVTList(VTs[0]);
else if (VTs.size() == 2) else if (VTs.size() == 2)
VTList = CurDAG->getVTList(VTs[0], VTs[1]); VTList = CurDAG->getVTList(VTs[0], VTs[1]);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// If this is a normal EmitNode command, just create the new node and // If this is a normal EmitNode command, just create the new node and
// add the results to the RecordedNodes list. // add the results to the RecordedNodes list.
Res = CurDAG->getMachineNode(TargetOpc, SDLoc(NodeToMatch), Res = CurDAG->getMachineNode(TargetOpc, SDLoc(NodeToMatch),
VTList, Ops); VTList, Ops);
// Add all the non-glue/non-chain results to the RecordedNodes list. // Add all the non-glue/non-chain results to the RecordedNodes list.
for (unsigned i = 0, e = VTs.size(); i != e; ++i) { for (unsigned i = 0, e = VTs.size(); i != e; ++i) {
if (VTs[i] == MVT::Other || VTs[i] == MVT::Glue) break; if (VTs[i] == MVT::Other || VTs[i] == MVT::Glue) break;
RecordedNodes.push_back(std::pair<SDValue,SDNode*>(SDValue(Res, i), RecordedNodes.emplace_back(SDValue(Res, i),
nullptr)); nullptr);
} }
} else { } else {
assert(NodeToMatch->getOpcode() != ISD::DELETED_NODE && assert(NodeToMatch->getOpcode() != ISD::DELETED_NODE &&
"NodeToMatch was removed partway through selection"); "NodeToMatch was removed partway through selection");
SelectionDAG::DAGNodeDeletedListener NDL(*CurDAG, [&](SDNode *N, SelectionDAG::DAGNodeDeletedListener NDL(*CurDAG, [&](SDNode *N,
SDNode *E) { SDNode *E) {
auto &Chain = ChainNodesMatched; auto &Chain = ChainNodesMatched;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Build the GC_TRANSITION_END node if necessary. // Build the GC_TRANSITION_END node if necessary.
// //
// See the comment above regarding GC_TRANSITION_START for the layout of // See the comment above regarding GC_TRANSITION_START for the layout of
// the operands to the GC_TRANSITION_END node. // the operands to the GC_TRANSITION_END node.
if (IsGCTransition) { if (IsGCTransition) {
SmallVector<SDValue, 8> TEOps; SmallVector<SDValue, 8> TEOps;
// Add chain // Add chain
TEOps.push_back(SDValue(StatepointMCNode, 0)); TEOps.emplace_back(StatepointMCNode, 0);
// Add GC transition arguments // Add GC transition arguments
for (const Value *V : SI.GCTransitionArgs) { for (const Value *V : SI.GCTransitionArgs) {
TEOps.push_back(getValue(V)); TEOps.push_back(getValue(V));
if (V->getType()->isPointerTy()) if (V->getType()->isPointerTy())
TEOps.push_back(DAG.getSrcValue(V)); TEOps.push_back(DAG.getSrcValue(V));
} }
// Add glue // Add glue
TEOps.push_back(SDValue(StatepointMCNode, 1)); TEOps.emplace_back(StatepointMCNode, 1);
SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue); SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
SDValue GCTransitionStart = SDValue GCTransitionStart =
DAG.getNode(ISD::GC_TRANSITION_END, getCurSDLoc(), NodeTys, TEOps); DAG.getNode(ISD::GC_TRANSITION_END, getCurSDLoc(), NodeTys, TEOps);
SinkNode = GCTransitionStart.getNode(); SinkNode = GCTransitionStart.getNode();
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/SlotIndexes.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
// We insert one blank instructions between basic blocks. // We insert one blank instructions between basic blocks.
indexList.push_back(createEntry(nullptr, index += SlotIndex::InstrDist)); indexList.push_back(createEntry(nullptr, index += SlotIndex::InstrDist));
MBBRanges[mbb->getNumber()].first = blockStartIndex; MBBRanges[mbb->getNumber()].first = blockStartIndex;
MBBRanges[mbb->getNumber()].second = SlotIndex(&indexList.back(), MBBRanges[mbb->getNumber()].second = SlotIndex(&indexList.back(),
SlotIndex::Slot_Block); SlotIndex::Slot_Block);
idx2MBBMap.push_back(IdxMBBPair(blockStartIndex, mbb)); idx2MBBMap.emplace_back(blockStartIndex, mbb);
} }
// Sort the Idx2MBBMap // Sort the Idx2MBBMap
std::sort(idx2MBBMap.begin(), idx2MBBMap.end(), Idx2MBBCompare()); std::sort(idx2MBBMap.begin(), idx2MBBMap.end(), Idx2MBBCompare());
DEBUG(mf->print(dbgs(), this)); DEBUG(mf->print(dbgs(), this));
// And we're done! // And we're done!
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/CodeGen/WinEHPrepare.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// TODO: identify related phi nodes that can share spill slots, and share them // TODO: identify related phi nodes that can share spill slots, and share them
// (also needs liveness). // (also needs liveness).
void WinEHPrepare::insertPHIStores(PHINode *OriginalPHI, void WinEHPrepare::insertPHIStores(PHINode *OriginalPHI,
AllocaInst *SpillSlot) { AllocaInst *SpillSlot) {
// Use a worklist of (Block, Value) pairs -- the given Value needs to be // Use a worklist of (Block, Value) pairs -- the given Value needs to be
// stored to the spill slot by the end of the given Block. // stored to the spill slot by the end of the given Block.
SmallVector<std::pair<BasicBlock *, Value *>, 4> Worklist; SmallVector<std::pair<BasicBlock *, Value *>, 4> Worklist;
Worklist.push_back({OriginalPHI->getParent(), OriginalPHI}); Worklist.emplace_back(OriginalPHI->getParent(), OriginalPHI);
while (!Worklist.empty()) { while (!Worklist.empty()) {
BasicBlock *EHBlock; BasicBlock *EHBlock;
Value *InVal; Value *InVal;
std::tie(EHBlock, InVal) = Worklist.pop_back_val(); std::tie(EHBlock, InVal) = Worklist.pop_back_val();
PHINode *PN = dyn_cast<PHINode>(InVal); PHINode *PN = dyn_cast<PHINode>(InVal);
if (PN && PN->getParent() == EHBlock) { if (PN && PN->getParent() == EHBlock) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/DebugInfo/CodeView/MemoryTypeTableBuilder.cpp

Show All 34 Lines for (int I = Data.size() + SizeOfRecLen; I < TotalSize; ++I)
Mem[I] = LF_PAD0 + (TotalSize - I); Mem[I] = LF_PAD0 + (TotalSize - I);
TypeIndex TI(static_cast<uint32_t>(Records.size()) + TypeIndex TI(static_cast<uint32_t>(Records.size()) +
TypeIndex::FirstNonSimpleIndex); TypeIndex::FirstNonSimpleIndex);
// Use only the data supplied by the user as a key to the hash table, so that // Use only the data supplied by the user as a key to the hash table, so that
// future lookups will succeed. // future lookups will succeed.
HashedRecords.insert(std::make_pair(StringRef(Mem + SizeOfRecLen, Data.size()), TI)); HashedRecords.insert(std::make_pair(StringRef(Mem + SizeOfRecLen, Data.size()), TI));
Records.push_back(StringRef(Mem, TotalSize)); Records.emplace_back(Mem, TotalSize);
return TI; return TI;
} }

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
FieldBuilder.write##Name(Record); \ FieldBuilder.write##Name(Record); \
return Error::success(); \ return Error::success(); \
} }
#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName) #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
#include "llvm/DebugInfo/CodeView/TypeRecords.def" #include "llvm/DebugInfo/CodeView/TypeRecords.def"
Error TypeStreamMerger::visitUnknownType(const CVRecord<TypeLeafKind> &Rec) { Error TypeStreamMerger::visitUnknownType(const CVRecord<TypeLeafKind> &Rec) {
// We failed to translate a type. Translate this index as "not translated". // We failed to translate a type. Translate this index as "not translated".
IndexMap.push_back( IndexMap.emplace_back(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct);
TypeIndex(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct));
return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record); return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record);
} }
bool TypeStreamMerger::mergeStream(const CVTypeArray &Types) { bool TypeStreamMerger::mergeStream(const CVTypeArray &Types) {
assert(IndexMap.empty()); assert(IndexMap.empty());
CVTypeVisitor Visitor(*this); CVTypeVisitor Visitor(*this);
if (auto EC = Visitor.visitTypeStream(Types)) { if (auto EC = Visitor.visitTypeStream(Types)) {
consumeError(std::move(EC)); consumeError(std::move(EC));
Show All 10 Lines

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines while (true) {
CurOffset = *OffsetPtr; CurOffset = *OffsetPtr;
uint16_t Form = Data.getULEB128(OffsetPtr); uint16_t Form = Data.getULEB128(OffsetPtr);
if (CurOffset == *OffsetPtr) { if (CurOffset == *OffsetPtr) {
clear(); clear();
return false; return false;
} }
if (Attr == 0 && Form == 0) if (Attr == 0 && Form == 0)
break; break;
AttributeSpecs.push_back(AttributeSpec(Attr, Form)); AttributeSpecs.emplace_back(Attr, Form);
} }
if (Tag == 0) { if (Tag == 0) {
clear(); clear();
return false; return false;
} }
return true; return true;
} }
Show All 35 Lines

lib/Driver/Driver.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
if (Ty == types::TY_INVALID) { if (Ty == types::TY_INVALID) {
Ty = InputType; Ty = InputType;
InputTypeArg->claim(); InputTypeArg->claim();
} }
} }
if (DiagnoseInputExistence(*this, Args, Value, Ty)) if (DiagnoseInputExistence(*this, Args, Value, Ty))
Inputs.push_back(std::make_pair(Ty, A)); Inputs.emplace_back(std::make_pair(Ty, A));
} else if (A->getOption().matches(options::OPT__SLASH_Tc)) { } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
StringRef Value = A->getValue(); StringRef Value = A->getValue();
if (DiagnoseInputExistence(*this, Args, Value, types::TY_C)) { if (DiagnoseInputExistence(*this, Args, Value, types::TY_C)) {
Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
Inputs.push_back(std::make_pair(types::TY_C, InputArg)); Inputs.emplace_back(std::make_pair(types::TY_C, InputArg));
} }
A->claim(); A->claim();
} else if (A->getOption().matches(options::OPT__SLASH_Tp)) { } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
StringRef Value = A->getValue(); StringRef Value = A->getValue();
if (DiagnoseInputExistence(*this, Args, Value, types::TY_CXX)) { if (DiagnoseInputExistence(*this, Args, Value, types::TY_CXX)) {
Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
Inputs.push_back(std::make_pair(types::TY_CXX, InputArg)); Inputs.emplace_back(std::make_pair(types::TY_CXX, InputArg));
} }
A->claim(); A->claim();
} else if (A->getOption().hasFlag(options::LinkerInput)) { } else if (A->getOption().hasFlag(options::LinkerInput)) {
// Just treat as object type, we could make a special type for this if // Just treat as object type, we could make a special type for this if
// necessary. // necessary.
Inputs.push_back(std::make_pair(types::TY_Object, A)); Inputs.emplace_back(std::make_pair(types::TY_Object, A));
} else if (A->getOption().matches(options::OPT_x)) { } else if (A->getOption().matches(options::OPT_x)) {
InputTypeArg = A; InputTypeArg = A;
InputType = types::lookupTypeForTypeSpecifier(A->getValue()); InputType = types::lookupTypeForTypeSpecifier(A->getValue());
A->claim(); A->claim();
// Follow gcc behavior and treat as linker input for invalid -x // Follow gcc behavior and treat as linker input for invalid -x
// options. Its not clear why we shouldn't just revert to unknown; but // options. Its not clear why we shouldn't just revert to unknown; but
// this isn't very important, we might as well be bug compatible. // this isn't very important, we might as well be bug compatible.
if (!InputType) { if (!InputType) {
Diag(clang::diag::err_drv_unknown_language) << A->getValue(); Diag(clang::diag::err_drv_unknown_language) << A->getValue();
InputType = types::TY_Object; InputType = types::TY_Object;
} }
} }
} }
if (CCCIsCPP() && Inputs.empty()) { if (CCCIsCPP() && Inputs.empty()) {
// If called as standalone preprocessor, stdin is processed // If called as standalone preprocessor, stdin is processed
// if no other input is present. // if no other input is present.
Arg *A = MakeInputArg(Args, Opts, "-"); Arg *A = MakeInputArg(Args, Opts, "-");
Inputs.push_back(std::make_pair(types::TY_C, A)); Inputs.emplace_back(std::make_pair(types::TY_C, A));
} }
} }
// For each unique --cuda-gpu-arch= argument creates a TY_CUDA_DEVICE // For each unique --cuda-gpu-arch= argument creates a TY_CUDA_DEVICE
// input action and then wraps each in CudaDeviceAction paired with // input action and then wraps each in CudaDeviceAction paired with
// appropriate GPU arch name. In case of partial (i.e preprocessing // appropriate GPU arch name. In case of partial (i.e preprocessing
// only) or device-only compilation, each device action is added to /p // only) or device-only compilation, each device action is added to /p
// Actions and /p Current is released. Otherwise the function creates // Actions and /p Current is released. Otherwise the function creates
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return ExceptTabSIDOrErr.takeError(); return ExceptTabSIDOrErr.takeError();
} else { } else {
auto I = SectionMap.find(Section); auto I = SectionMap.find(Section);
if (I != SectionMap.end()) if (I != SectionMap.end())
if (auto Err = impl().finalizeSection(Obj, I->second, Section)) if (auto Err = impl().finalizeSection(Obj, I->second, Section))
return Err; return Err;
} }
} }
UnregisteredEHFrameSections.push_back( UnregisteredEHFrameSections.emplace_back(HFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID);
EHFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID));
return Error::success(); return Error::success();
} }
template <typename Impl> template <typename Impl>
unsigned char *RuntimeDyldMachOCRTPBase<Impl>::processFDE(uint8_t *P, unsigned char *RuntimeDyldMachOCRTPBase<Impl>::processFDE(uint8_t *P,
int64_t DeltaForText, int64_t DeltaForText,
int64_t DeltaForEH) { int64_t DeltaForEH) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/ExecutionEngine/SectionMemoryManager.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
if (FreeMB.Free.size() >= RequiredSize) { if (FreeMB.Free.size() >= RequiredSize) {
Addr = (uintptr_t)FreeMB.Free.base(); Addr = (uintptr_t)FreeMB.Free.base();
uintptr_t EndOfBlock = Addr + FreeMB.Free.size(); uintptr_t EndOfBlock = Addr + FreeMB.Free.size();
// Align the address. // Align the address.
Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1); Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
if (FreeMB.PendingPrefixIndex == (unsigned)-1) { if (FreeMB.PendingPrefixIndex == (unsigned)-1) {
// The part of the block we're giving out to the user is now pending // The part of the block we're giving out to the user is now pending
MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size)); MemGroup.PendingMem.emplace_back((void *)Addr, Size);
// Remember this pending block, such that future allocations can just // Remember this pending block, such that future allocations can just
// modify it rather than creating a new one // modify it rather than creating a new one
FreeMB.PendingPrefixIndex = MemGroup.PendingMem.size() - 1; FreeMB.PendingPrefixIndex = MemGroup.PendingMem.size() - 1;
} else { } else {
sys::MemoryBlock &PendingMB = MemGroup.PendingMem[FreeMB.PendingPrefixIndex]; sys::MemoryBlock &PendingMB = MemGroup.PendingMem[FreeMB.PendingPrefixIndex];
PendingMB = sys::MemoryBlock(PendingMB.base(), Addr + Size - (uintptr_t)PendingMB.base()); PendingMB = sys::MemoryBlock(PendingMB.base(), Addr + Size - (uintptr_t)PendingMB.base());
} }
Show All 31 Linesuint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
MemGroup.AllocatedMem.push_back(MB); MemGroup.AllocatedMem.push_back(MB);
Addr = (uintptr_t)MB.base(); Addr = (uintptr_t)MB.base();
uintptr_t EndOfBlock = Addr + MB.size(); uintptr_t EndOfBlock = Addr + MB.size();
// Align the address. // Align the address.
Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1); Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
// The part of the block we're giving out to the user is now pending // The part of the block we're giving out to the user is now pending
MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size)); MemGroup.PendingMem.emplace_back((void *)Addr, Size);
// The allocateMappedMemory may allocate much more memory than we need. In // The allocateMappedMemory may allocate much more memory than we need. In
// this case, we store the unused memory as a free memory block. // this case, we store the unused memory as a free memory block.
unsigned FreeSize = EndOfBlock-Addr-Size; unsigned FreeSize = EndOfBlock-Addr-Size;
if (FreeSize > 16) { if (FreeSize > 16) {
FreeMemBlock FreeMB; FreeMemBlock FreeMB;
FreeMB.Free = sys::MemoryBlock((void*)(Addr + Size), FreeSize); FreeMB.Free = sys::MemoryBlock((void*)(Addr + Size), FreeSize);
FreeMB.PendingPrefixIndex = (unsigned)-1; FreeMB.PendingPrefixIndex = (unsigned)-1;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Format/ContinuationIndenter.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
LineState ContinuationIndenter::getInitialState(unsigned FirstIndent, LineState ContinuationIndenter::getInitialState(unsigned FirstIndent,
const AnnotatedLine *Line, const AnnotatedLine *Line,
bool DryRun) { bool DryRun) {
LineState State; LineState State;
State.FirstIndent = FirstIndent; State.FirstIndent = FirstIndent;
State.Column = FirstIndent; State.Column = FirstIndent;
State.Line = Line; State.Line = Line;
State.NextToken = Line->First; State.NextToken = Line->First;
State.Stack.push_back(ParenState(FirstIndent, Line->Level, FirstIndent, State.Stack.emplace_back(FirstIndent, Line->Level, FirstIndent,
/*AvoidBinPacking=*/false, /*AvoidBinPacking=*/false,
/*NoLineBreak=*/false)); /*NoLineBreak=*/false);
State.LineContainsContinuedForLoopSection = false; State.LineContainsContinuedForLoopSection = false;
State.StartOfStringLiteral = 0; State.StartOfStringLiteral = 0;
State.StartOfLineLevel = 0; State.StartOfLineLevel = 0;
State.LowestLevelOnLine = 0; State.LowestLevelOnLine = 0;
State.IgnoreStackForComparison = false; State.IgnoreStackForComparison = false;
// The first token has already been indented and thus consumed. // The first token has already been indented and thus consumed.
moveStateToNextToken(State, DryRun, /*Newline=*/false); moveStateToNextToken(State, DryRun, /*Newline=*/false);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// However, don't do this for non-empty nested blocks, dict literals and // However, don't do this for non-empty nested blocks, dict literals and
// array literals as these follow different indentation rules. // array literals as these follow different indentation rules.
bool NoLineBreak = bool NoLineBreak =
Current.Children.empty() && Current.Children.empty() &&
!Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) && !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
(State.Stack.back().NoLineBreak || (State.Stack.back().NoLineBreak ||
(Current.is(TT_TemplateOpener) && (Current.is(TT_TemplateOpener) &&
State.Stack.back().ContainsUnwrappedBuilder)); State.Stack.back().ContainsUnwrappedBuilder));
State.Stack.push_back(ParenState(NewIndent, NewIndentLevel, LastSpace, State.Stack.emplace_back(NewIndent, NewIndentLevel, LastSpace,
AvoidBinPacking, NoLineBreak)); AvoidBinPacking, NoLineBreak);
State.Stack.back().NestedBlockIndent = NestedBlockIndent; State.Stack.back().NestedBlockIndent = NestedBlockIndent;
State.Stack.back().BreakBeforeParameter = BreakBeforeParameter; State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1; State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
} }
void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) { void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
const FormatToken &Current = *State.NextToken; const FormatToken &Current = *State.NextToken;
if (!Current.closesScope()) if (!Current.closesScope())
Show All 17 Lines
void ContinuationIndenter::moveStateToNewBlock(LineState &State) { void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent; unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
// ObjC block sometimes follow special indentation rules. // ObjC block sometimes follow special indentation rules.
unsigned NewIndent = unsigned NewIndent =
NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace) NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
? Style.ObjCBlockIndentWidth ? Style.ObjCBlockIndentWidth
: Style.IndentWidth); : Style.IndentWidth);
State.Stack.push_back(ParenState( State.Stack.emplace_back(
NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1, NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1,
State.Stack.back().LastSpace, /*AvoidBinPacking=*/true, State.Stack.back().LastSpace, /*AvoidBinPacking=*/true,
/*NoLineBreak=*/false)); /*NoLineBreak=*/false);
State.Stack.back().NestedBlockIndent = NestedBlockIndent; State.Stack.back().NestedBlockIndent = NestedBlockIndent;
State.Stack.back().BreakBeforeParameter = true; State.Stack.back().BreakBeforeParameter = true;
} }
unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current, unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
LineState &State) { LineState &State) {
if (!Current.IsMultiline) if (!Current.IsMultiline)
return 0; return 0;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Format/TokenAnnotator.cpp

Show All 30 Lines
/// store a parenthesis levels. It also tries to resolve matching "<" and ">" /// store a parenthesis levels. It also tries to resolve matching "<" and ">"
/// into template parameter lists. /// into template parameter lists.
class AnnotatingParser { class AnnotatingParser {
public: public:
AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line, AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
const AdditionalKeywords &Keywords) const AdditionalKeywords &Keywords)
: Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false), : Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false),
Keywords(Keywords) { Keywords(Keywords) {
Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false)); Contexts.emplace_back(tok::unknown, 1, /*IsExpression=*/false);
resetTokenMetadata(CurrentToken); resetTokenMetadata(CurrentToken);
} }
private: private:
bool parseAngle() { bool parseAngle() {
if (!CurrentToken || !CurrentToken->Previous) if (!CurrentToken || !CurrentToken->Previous)
return false; return false;
if (NonTemplateLess.count(CurrentToken->Previous)) if (NonTemplateLess.count(CurrentToken->Previous))
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
/// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
/// of each instance. /// of each instance.
struct ScopedContextCreator { struct ScopedContextCreator {
AnnotatingParser &P; AnnotatingParser &P;
ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind, ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind,
unsigned Increase) unsigned Increase)
: P(P) { : P(P) {
P.Contexts.push_back(Context(ContextKind, P.Contexts.emplace_back(ContextKind,
P.Contexts.back().BindingStrength + Increase, P.Contexts.back().BindingStrength + Increase,
P.Contexts.back().IsExpression)); P.Contexts.back().IsExpression);
} }
~ScopedContextCreator() { P.Contexts.pop_back(); } ~ScopedContextCreator() { P.Contexts.pop_back(); }
}; };
void modifyContext(const FormatToken &Current) { void modifyContext(const FormatToken &Current) {
if (Current.getPrecedence() == prec::Assignment && if (Current.getPrecedence() == prec::Assignment &&
!Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) && !Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) &&
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Frontend/ASTUnit.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// macro name, without its arguments. // macro name, without its arguments.
CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(), CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(),
CCP_CodePattern, C->Availability); CCP_CodePattern, C->Availability);
Builder.AddTypedTextChunk(C->Completion->getTypedText()); Builder.AddTypedTextChunk(C->Completion->getTypedText());
Priority = CCP_CodePattern; Priority = CCP_CodePattern;
Completion = Builder.TakeString(); Completion = Builder.TakeString();
} }
AllResults.push_back(Result(Completion, Priority, C->Kind, AllResults.emplace_back(Completion, Priority, C->Kind,
C->Availability)); C->Availability);
} }
// If we did not add any cached completion results, just forward the // If we did not add any cached completion results, just forward the
// results we were given to the next consumer. // results we were given to the next consumer.
if (!AddedResult) { if (!AddedResult) {
Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
return; return;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Frontend/CompilerInstance.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
/*AllowReplacements=*/true, /*AllowReplacements=*/true,
BestEditDistance); BestEditDistance);
if (ED <= BestEditDistance) { if (ED <= BestEditDistance) {
if (ED < BestEditDistance) { if (ED < BestEditDistance) {
Best.clear(); Best.clear();
BestEditDistance = ED; BestEditDistance = ED;
} }
Best.push_back((*J)->Name); Best.emplace_back((*J)->Name);
} }
} }
// If there was a clear winner, user it. // If there was a clear winner, user it.
if (Best.size() == 1) { if (Best.size() == 1) {
getDiagnostics().Report(Path[I].second, getDiagnostics().Report(Path[I].second,
diag::err_no_submodule_suggest) diag::err_no_submodule_suggest)
<< Path[I].first << Module->getFullModuleName() << Best[0] << Path[I].first << Module->getFullModuleName() << Best[0]
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Frontend/PrintPreprocessedOutput.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
do PP.Lex(Tok); do PP.Lex(Tok);
while (Tok.isNot(tok::eof)); while (Tok.isNot(tok::eof));
SmallVector<id_macro_pair, 128> MacrosByID; SmallVector<id_macro_pair, 128> MacrosByID;
for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end(); for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end();
I != E; ++I) { I != E; ++I) {
auto *MD = I->second.getLatest(); auto *MD = I->second.getLatest();
if (MD && MD->isDefined()) if (MD && MD->isDefined())
MacrosByID.push_back(id_macro_pair(I->first, MD->getMacroInfo())); MacrosByID.emplace_back(I->first, MD->getMacroInfo());
} }
llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(), MacroIDCompare); llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(), MacroIDCompare);
for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) { for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) {
MacroInfo &MI = *MacrosByID[i].second; MacroInfo &MI = *MacrosByID[i].second;
// Ignore computed macros like __LINE__ and friends. // Ignore computed macros like __LINE__ and friends.
if (MI.isBuiltinMacro()) continue; if (MI.isBuiltinMacro()) continue;
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned ID, const OrderMap &OM, unsigned ID, const OrderMap &OM,
UseListOrderStack &Stack) { UseListOrderStack &Stack) {
// Predict use-list order for this one. // Predict use-list order for this one.
typedef std::pair<const Use *, unsigned> Entry; typedef std::pair<const Use *, unsigned> Entry;
SmallVector<Entry, 64> List; SmallVector<Entry, 64> List;
for (const Use &U : V->uses()) for (const Use &U : V->uses())
// Check if this user will be serialized. // Check if this user will be serialized.
if (OM.lookup(U.getUser()).first) if (OM.lookup(U.getUser()).first)
List.push_back(std::make_pair(&U, List.size())); List.emplace_back(std::make_pair(&U, List.size()));
if (List.size() < 2) if (List.size() < 2)
// We may have lost some users. // We may have lost some users.
return; return;
bool GetsReversed = bool GetsReversed =
!isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V); !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
if (auto *BA = dyn_cast<BlockAddress>(V)) if (auto *BA = dyn_cast<BlockAddress>(V))
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/MacroArgs.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// this, we set up a fake TokenLexer to lex from the unexpanded argument // this, we set up a fake TokenLexer to lex from the unexpanded argument
// list. With this installed, we lex expanded tokens until we hit the EOF // list. With this installed, we lex expanded tokens until we hit the EOF
// token at the end of the unexp list. // token at the end of the unexp list.
PP.EnterTokenStream(AT, NumToks, false /*disable expand*/, PP.EnterTokenStream(AT, NumToks, false /*disable expand*/,
false /*owns tokens*/); false /*owns tokens*/);
// Lex all of the macro-expanded tokens into Result. // Lex all of the macro-expanded tokens into Result.
do { do {
Result.push_back(Token()); Result.emplace_back();
Token &Tok = Result.back(); Token &Tok = Result.back();
PP.Lex(Tok); PP.Lex(Tok);
} while (Result.back().isNot(tok::eof)); } while (Result.back().isNot(tok::eof));
// Pop the token stream off the top of the stack. We know that the internal // Pop the token stream off the top of the stack. We know that the internal
// pointer inside of it is to the "end" of the token stream, but the stack // pointer inside of it is to the "end" of the token stream, but the stack
// will not otherwise be popped until the next token is lexed. The problem is // will not otherwise be popped until the next token is lexed. The problem is
// that the token may be lexed sometime after the vector of tokens itself is // that the token may be lexed sometime after the vector of tokens itself is
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/ModuleMap.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Result->IsInferred = true; Result->IsInferred = true;
// Associate the module and the directory. // Associate the module and the directory.
UmbrellaDirs[SkippedDirs[I-1]] = Result; UmbrellaDirs[SkippedDirs[I-1]] = Result;
// If inferred submodules export everything they import, add a // If inferred submodules export everything they import, add a
// wildcard to the set of exports. // wildcard to the set of exports.
if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
Result->Exports.push_back(Module::ExportDecl(nullptr, true)); Result->Exports.emplace_back(nullptr, true);
} }
// Infer a submodule with the same name as this header file. // Infer a submodule with the same name as this header file.
SmallString<32> NameBuf; SmallString<32> NameBuf;
StringRef Name = sanitizeFilenameAsIdentifier( StringRef Name = sanitizeFilenameAsIdentifier(
llvm::sys::path::stem(File->getName()), NameBuf); llvm::sys::path::stem(File->getName()), NameBuf);
Result = findOrCreateModule(Name, Result, /*IsFramework=*/false, Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
Explicit).first; Explicit).first;
InferredModuleAllowedBy[Result] = UmbrellaModuleMap; InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
Result->IsInferred = true; Result->IsInferred = true;
Result->addTopHeader(File); Result->addTopHeader(File);
// If inferred submodules export everything they import, add a // If inferred submodules export everything they import, add a
// wildcard to the set of exports. // wildcard to the set of exports.
if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
Result->Exports.push_back(Module::ExportDecl(nullptr, true)); Result->Exports.emplace_back(nullptr, true);
} else { } else {
// Record each of the directories we stepped through as being part of // Record each of the directories we stepped through as being part of
// the module we found, since the umbrella header covers them all. // the module we found, since the umbrella header covers them all.
for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I) for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
UmbrellaDirs[SkippedDirs[I]] = Result; UmbrellaDirs[SkippedDirs[I]] = Result;
} }
KnownHeader Header(Result, NormalHeader); KnownHeader Header(Result, NormalHeader);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// umbrella header "umbrella-header-name" // umbrella header "umbrella-header-name"
// //
// The "Headers/" component of the name is implied because this is // The "Headers/" component of the name is implied because this is
// a framework module. // a framework module.
setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h"); setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h");
// export * // export *
Result->Exports.push_back(Module::ExportDecl(nullptr, true)); Result->Exports.emplace_back(nullptr, true);
// module * { export * } // module * { export * }
Result->InferSubmodules = true; Result->InferSubmodules = true;
Result->InferExportWildcard = true; Result->InferExportWildcard = true;
// Look for subframeworks. // Look for subframeworks.
std::error_code EC; std::error_code EC;
SmallString<128> SubframeworksDirName SmallString<128> SubframeworksDirName
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
inferFrameworkLink(Result, FrameworkDir, FileMgr); inferFrameworkLink(Result, FrameworkDir, FileMgr);
} }
return Result; return Result;
} }
void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader, void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader,
Twine NameAsWritten) { Twine NameAsWritten) {
Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader)); Headers[UmbrellaHeader].emplace_back(Mod, NormalHeader);
Mod->Umbrella = UmbrellaHeader; Mod->Umbrella = UmbrellaHeader;
Mod->UmbrellaAsWritten = NameAsWritten.str(); Mod->UmbrellaAsWritten = NameAsWritten.str();
UmbrellaDirs[UmbrellaHeader->getDir()] = Mod; UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
// Notify callbacks that we just added a new header. // Notify callbacks that we just added a new header.
for (const auto &Cb : Callbacks) for (const auto &Cb : Callbacks)
Cb->moduleMapAddUmbrellaHeader(&SourceMgr.getFileManager(), UmbrellaHeader); Cb->moduleMapAddUmbrellaHeader(&SourceMgr.getFileManager(), UmbrellaHeader);
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
/// \brief Append to \p Paths the set of paths needed to get to the /// \brief Append to \p Paths the set of paths needed to get to the
/// subframework in which the given module lives. /// subframework in which the given module lives.
static void appendSubframeworkPaths(Module *Mod, static void appendSubframeworkPaths(Module *Mod,
SmallVectorImpl<char> &Path) { SmallVectorImpl<char> &Path) {
// Collect the framework names from the given module to the top-level module. // Collect the framework names from the given module to the top-level module.
SmallVector<StringRef, 2> Paths; SmallVector<StringRef, 2> Paths;
for (; Mod; Mod = Mod->Parent) { for (; Mod; Mod = Mod->Parent) {
if (Mod->IsFramework) if (Mod->IsFramework)
Paths.push_back(Mod->Name); Paths.emplace_back(Mod->Name);
} }
if (Paths.empty()) if (Paths.empty())
return; return;
// Add Frameworks/Name.framework for each subframework. // Add Frameworks/Name.framework for each subframework.
for (unsigned I = Paths.size() - 1; I != 0; --I) for (unsigned I = Paths.size() - 1; I != 0; --I)
llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework"); llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework");
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/PPCaching.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesvoid Preprocessor::EnterCachingLexMode() {
CurLexerKind = CLK_CachingLexer; CurLexerKind = CLK_CachingLexer;
} }
const Token &Preprocessor::PeekAhead(unsigned N) { const Token &Preprocessor::PeekAhead(unsigned N) {
assert(CachedLexPos + N > CachedTokens.size() && "Confused caching."); assert(CachedLexPos + N > CachedTokens.size() && "Confused caching.");
ExitCachingLexMode(); ExitCachingLexMode();
for (unsigned C = CachedLexPos + N - CachedTokens.size(); C > 0; --C) { for (unsigned C = CachedLexPos + N - CachedTokens.size(); C > 0; --C) {
CachedTokens.push_back(Token()); CachedTokens.emplace_back();
Lex(CachedTokens.back()); Lex(CachedTokens.back());
} }
EnterCachingLexMode(); EnterCachingLexMode();
return CachedTokens.back(); return CachedTokens.back();
} }
void Preprocessor::AnnotatePreviousCachedTokens(const Token &Tok) { void Preprocessor::AnnotatePreviousCachedTokens(const Token &Tok) {
assert(Tok.isAnnotation() && "Expected annotation token"); assert(Tok.isAnnotation() && "Expected annotation token");
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lib/Lex/PPConditionalDirectiveRecord.cpp

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/Lex/PPConditionalDirectiveRecord.h" #include "clang/Lex/PPConditionalDirectiveRecord.h"
#include "llvm/Support/Capacity.h" #include "llvm/Support/Capacity.h"
using namespace clang; using namespace clang;
PPConditionalDirectiveRecord::PPConditionalDirectiveRecord(SourceManager &SM) PPConditionalDirectiveRecord::PPConditionalDirectiveRecord(SourceManager &SM)
: SourceMgr(SM) { : SourceMgr(SM) {
CondDirectiveStack.push_back(SourceLocation()); CondDirectiveStack.emplace_back();
} }
bool PPConditionalDirectiveRecord::rangeIntersectsConditionalDirective( bool PPConditionalDirectiveRecord::rangeIntersectsConditionalDirective(
SourceRange Range) const { SourceRange Range) const {
if (Range.isInvalid()) if (Range.isInvalid())
return false; return false;
CondDirectiveLocsTy::const_iterator CondDirectiveLocsTy::const_iterator
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/PPDirectives.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// from the -include command line argument) from the current working // from the -include command line argument) from the current working
// directory instead of relative to the main file. // directory instead of relative to the main file.
// //
// If we have the module includes buffer, resolve #include references (which // If we have the module includes buffer, resolve #include references (which
// come from header declarations in the module map) relative to the module // come from header declarations in the module map) relative to the module
// map file. // map file.
if (!FileEnt) { if (!FileEnt) {
if (FID == SourceMgr.getMainFileID() && MainFileDir) { if (FID == SourceMgr.getMainFileID() && MainFileDir) {
Includers.push_back(std::make_pair(nullptr, MainFileDir)); Includers.emplace_back(std::make_pair(nullptr, MainFileDir));
BuildSystemModule = getCurrentModule()->IsSystem; BuildSystemModule = getCurrentModule()->IsSystem;
} else if ((FileEnt = } else if ((FileEnt =
SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))) SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory("."))); Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory(".")));
} else { } else {
Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/PPLexerChange.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// active (an active lexer would return EOD at EOF if there was no \n in // active (an active lexer would return EOD at EOF if there was no \n in
// preprocessor directive mode), so just return EOF as our token. // preprocessor directive mode), so just return EOF as our token.
assert(!FoundLexer && "Lexer should return EOD before EOF in PP mode"); assert(!FoundLexer && "Lexer should return EOD before EOF in PP mode");
} }
void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc) { void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc) {
if (!getLangOpts().ModulesLocalVisibility) { if (!getLangOpts().ModulesLocalVisibility) {
// Just track that we entered this submodule. // Just track that we entered this submodule.
BuildingSubmoduleStack.push_back(BuildingSubmoduleInfo( BuildingSubmoduleStack.emplace_back(
M, ImportLoc, CurSubmoduleState, PendingModuleMacroNames.size())); M, ImportLoc, CurSubmoduleState, PendingModuleMacroNames.size());
return; return;
} }
// Resolve as much of the module definition as we can now, before we enter // Resolve as much of the module definition as we can now, before we enter
// one of its headers. // one of its headers.
// FIXME: Can we enable Complain here? // FIXME: Can we enable Complain here?
// FIXME: Can we do this when local visibility is disabled? // FIXME: Can we do this when local visibility is disabled?
ModuleMap &ModMap = getHeaderSearchInfo().getModuleMap(); ModuleMap &ModMap = getHeaderSearchInfo().getModuleMap();
Show All 24 Lines
MacroState MS(Macro.second.getLatest()); MacroState MS(Macro.second.getLatest());
MS.setOverriddenMacros(*this, Macro.second.getOverriddenMacros()); MS.setOverriddenMacros(*this, Macro.second.getOverriddenMacros());
State.Macros.insert(std::make_pair(Macro.first, std::move(MS))); State.Macros.insert(std::make_pair(Macro.first, std::move(MS)));
} }
} }
// Track that we entered this module. // Track that we entered this module.
BuildingSubmoduleStack.push_back(BuildingSubmoduleInfo( BuildingSubmoduleStack.emplace_back(
M, ImportLoc, CurSubmoduleState, PendingModuleMacroNames.size())); M, ImportLoc, CurSubmoduleState, PendingModuleMacroNames.size());
// Switch to this submodule as the current submodule. // Switch to this submodule as the current submodule.
CurSubmoduleState = &State; CurSubmoduleState = &State;
// This module is visible to itself. // This module is visible to itself.
if (FirstTime) if (FirstTime)
makeModuleVisible(M, ImportLoc); makeModuleVisible(M, ImportLoc);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Lex/PPMacroExpansion.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SourceRange ExpansionRange(ExpandLoc, ExpansionEnd); SourceRange ExpansionRange(ExpandLoc, ExpansionEnd);
if (Callbacks) { if (Callbacks) {
if (InMacroArgs) { if (InMacroArgs) {
// We can have macro expansion inside a conditional directive while // We can have macro expansion inside a conditional directive while
// reading the function macro arguments. To ensure, in that case, that // reading the function macro arguments. To ensure, in that case, that
// MacroExpands callbacks still happen in source order, queue this // MacroExpands callbacks still happen in source order, queue this
// callback to have it happen after the function macro callback. // callback to have it happen after the function macro callback.
DelayedMacroExpandsCallbacks.push_back( DelayedMacroExpandsCallbacks.emplace_back(Identifier, M, ExpansionRange);
MacroExpandsInfo(Identifier, M, ExpansionRange));
} else { } else {
Callbacks->MacroExpands(Identifier, M, ExpansionRange, Args); Callbacks->MacroExpands(Identifier, M, ExpansionRange, Args);
if (!DelayedMacroExpandsCallbacks.empty()) { if (!DelayedMacroExpandsCallbacks.empty()) {
for (unsigned i=0, e = DelayedMacroExpandsCallbacks.size(); i!=e; ++i) { for (unsigned i=0, e = DelayedMacroExpandsCallbacks.size(); i!=e; ++i) {
MacroExpandsInfo &Info = DelayedMacroExpandsCallbacks[i]; MacroExpandsInfo &Info = DelayedMacroExpandsCallbacks[i];
// FIXME: We lose macro args info with delayed callback. // FIXME: We lose macro args info with delayed callback.
Callbacks->MacroExpands(Info.Tok, Info.MD, Info.Range, Callbacks->MacroExpands(Info.Tok, Info.MD, Info.Range,
/*Args=*/nullptr); /*Args=*/nullptr);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/LibDriver/LibDriver.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesstatic std::string getOutputPath(llvm::opt::InputArgList *Args,
llvm::sys::path::replace_extension(Val, ".lib"); llvm::sys::path::replace_extension(Val, ".lib");
return Val.str(); return Val.str();
} }
static std::vector<StringRef> getSearchPaths(llvm::opt::InputArgList *Args, static std::vector<StringRef> getSearchPaths(llvm::opt::InputArgList *Args,
StringSaver &Saver) { StringSaver &Saver) {
std::vector<StringRef> Ret; std::vector<StringRef> Ret;
// Add current directory as first item of the search path. // Add current directory as first item of the search path.
Ret.push_back(""); Ret.emplace_back("");
// Add /libpath flags. // Add /libpath flags.
for (auto *Arg : Args->filtered(OPT_libpath)) for (auto *Arg : Args->filtered(OPT_libpath))
Ret.push_back(Arg->getValue()); Ret.emplace_back(Arg->getValue());
// Add $LIB. // Add $LIB.
Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB"); Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB");
if (!EnvOpt.hasValue()) if (!EnvOpt.hasValue())
return Ret; return Ret;
StringRef Env = Saver.save(*EnvOpt); StringRef Env = Saver.save(*EnvOpt);
while (!Env.empty()) { while (!Env.empty()) {
StringRef Path; StringRef Path;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

lib/MC/ConstantPools.cpp

Show All 33 Linesvoid ConstantPool::emitEntries(MCStreamer &Streamer) {
Streamer.EmitDataRegion(MCDR_DataRegionEnd); Streamer.EmitDataRegion(MCDR_DataRegionEnd);
Entries.clear(); Entries.clear();
} }
const MCExpr *ConstantPool::addEntry(const MCExpr *Value, MCContext &Context, const MCExpr *ConstantPool::addEntry(const MCExpr *Value, MCContext &Context,
unsigned Size, SMLoc Loc) { unsigned Size, SMLoc Loc) {
MCSymbol *CPEntryLabel = Context.createTempSymbol(); MCSymbol *CPEntryLabel = Context.createTempSymbol();
Entries.push_back(ConstantPoolEntry(CPEntryLabel, Value, Size, Loc)); Entries.emplace_back(CPEntryLabel, Value, Size, Loc);
return MCSymbolRefExpr::create(CPEntryLabel, Context); return MCSymbolRefExpr::create(CPEntryLabel, Context);
} }
bool ConstantPool::empty() { return Entries.empty(); } bool ConstantPool::empty() { return Entries.empty(); }
// //
// AssemblerConstantPools implementation // AssemblerConstantPools implementation
// //
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lib/MC/MCParser/AsmParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
MCSymbol *GapStartSym = getContext().getOrCreateSymbol(GapStartName); MCSymbol *GapStartSym = getContext().getOrCreateSymbol(GapStartName);
Loc = getLexer().getLoc(); Loc = getLexer().getLoc();
StringRef GapEndName; StringRef GapEndName;
if (parseIdentifier(GapEndName)) if (parseIdentifier(GapEndName))
return Error(Loc, "expected identifier in directive"); return Error(Loc, "expected identifier in directive");
MCSymbol *GapEndSym = getContext().getOrCreateSymbol(GapEndName); MCSymbol *GapEndSym = getContext().getOrCreateSymbol(GapEndName);
Ranges.push_back({GapStartSym, GapEndSym}); Ranges.emplace_back(GapStartSym, GapEndSym);
} }
if (getLexer().isNot(AsmToken::Comma)) if (getLexer().isNot(AsmToken::Comma))
return TokError("unexpected token in directive"); return TokError("unexpected token in directive");
Lex(); Lex();
std::string FixedSizePortion; std::string FixedSizePortion;
if (parseEscapedString(FixedSizePortion)) if (parseEscapedString(FixedSizePortion))
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/MC/MCStreamer.cpp

Show All 38 Lines
void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {} void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
void MCTargetStreamer::finish() {} void MCTargetStreamer::finish() {}
void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {} void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
MCStreamer::MCStreamer(MCContext &Ctx) MCStreamer::MCStreamer(MCContext &Ctx)
: Context(Ctx), CurrentWinFrameInfo(nullptr) { : Context(Ctx), CurrentWinFrameInfo(nullptr) {
SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); SectionStack.emplace_back();
} }
MCStreamer::~MCStreamer() { MCStreamer::~MCStreamer() {
for (unsigned i = 0; i < getNumWinFrameInfos(); ++i) for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
delete WinFrameInfos[i]; delete WinFrameInfos[i];
} }
void MCStreamer::reset() { void MCStreamer::reset() {
DwarfFrameInfos.clear(); DwarfFrameInfos.clear();
for (unsigned i = 0; i < getNumWinFrameInfos(); ++i) for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
delete WinFrameInfos[i]; delete WinFrameInfos[i];
WinFrameInfos.clear(); WinFrameInfos.clear();
CurrentWinFrameInfo = nullptr; CurrentWinFrameInfo = nullptr;
SymbolOrdering.clear(); SymbolOrdering.clear();
SectionStack.clear(); SectionStack.clear();
SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); SectionStack.emplace_back();
} }
raw_ostream &MCStreamer::GetCommentOS() { raw_ostream &MCStreamer::GetCommentOS() {
// By default, discard comments. // By default, discard comments.
return nulls(); return nulls();
} }
void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {} void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Object/SymbolSize.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
llvm::object::computeSymbolSizes(const ObjectFile &O) { llvm::object::computeSymbolSizes(const ObjectFile &O) {
std::vector<std::pair<SymbolRef, uint64_t>> Ret; std::vector<std::pair<SymbolRef, uint64_t>> Ret;
if (const auto *E = dyn_cast<ELFObjectFileBase>(&O)) { if (const auto *E = dyn_cast<ELFObjectFileBase>(&O)) {
auto Syms = E->symbols(); auto Syms = E->symbols();
if (Syms.begin() == Syms.end()) if (Syms.begin() == Syms.end())
Syms = E->getDynamicSymbolIterators(); Syms = E->getDynamicSymbolIterators();
for (ELFSymbolRef Sym : Syms) for (ELFSymbolRef Sym : Syms)
Ret.push_back({Sym, Sym.getSize()}); Ret.emplace_back(Sym, Sym.getSize());
return Ret; return Ret;
} }
// Collect sorted symbol addresses. Include dummy addresses for the end // Collect sorted symbol addresses. Include dummy addresses for the end
// of each section. // of each section.
std::vector<SymEntry> Addresses; std::vector<SymEntry> Addresses;
unsigned SymNum = 0; unsigned SymNum = 0;
for (symbol_iterator I = O.symbol_begin(), E = O.symbol_end(); I != E; ++I) { for (symbol_iterator I = O.symbol_begin(), E = O.symbol_end(); I != E; ++I) {
Show All 37 Lines

lib/Parse/ParseDecl.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// token in this argument, assume it's meant to be an identifier. // token in this argument, assume it's meant to be an identifier.
if (AttrKind == AttributeList::UnknownAttribute || if (AttrKind == AttributeList::UnknownAttribute ||
AttrKind == AttributeList::IgnoredAttribute) { AttrKind == AttributeList::IgnoredAttribute) {
const Token &Next = NextToken(); const Token &Next = NextToken();
IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma); IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
} }
if (IsIdentifierArg) if (IsIdentifierArg)
ArgExprs.push_back(ParseIdentifierLoc()); ArgExprs.emplace_back(ParseIdentifierLoc());
} }
if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) { if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
// Eat the comma. // Eat the comma.
if (!ArgExprs.empty()) if (!ArgExprs.empty())
ConsumeToken(); ConsumeToken();
// Parse the non-empty comma-separated list of expressions. // Parse the non-empty comma-separated list of expressions.
do { do {
std::unique_ptr<EnterExpressionEvaluationContext> Unevaluated; std::unique_ptr<EnterExpressionEvaluationContext> Unevaluated;
if (attributeParsedArgsUnevaluated(*AttrName)) if (attributeParsedArgsUnevaluated(*AttrName))
Unevaluated.reset( Unevaluated.reset(
new EnterExpressionEvaluationContext(Actions, Sema::Unevaluated)); new EnterExpressionEvaluationContext(Actions, Sema::Unevaluated));
ExprResult ArgExpr( ExprResult ArgExpr(
Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression())); Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()));
if (ArgExpr.isInvalid()) { if (ArgExpr.isInvalid()) {
SkipUntil(tok::r_paren, StopAtSemi); SkipUntil(tok::r_paren, StopAtSemi);
return 0; return 0;
} }
ArgExprs.push_back(ArgExpr.get()); ArgExprs.emplace_back(ArgExpr.get());
// Eat the comma, move to the next argument // Eat the comma, move to the next argument
} while (TryConsumeToken(tok::comma)); } while (TryConsumeToken(tok::comma));
} }
SourceLocation RParen = Tok.getLocation(); SourceLocation RParen = Tok.getLocation();
if (!ExpectAndConsume(tok::r_paren)) { if (!ExpectAndConsume(tok::r_paren)) {
SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc; SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc;
Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc, Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc,
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
return; return;
} }
T.consumeClose(); T.consumeClose();
if (EndLoc) if (EndLoc)
*EndLoc = T.getCloseLocation(); *EndLoc = T.getCloseLocation();
ArgsVector ArgExprs; ArgsVector ArgExprs;
ArgExprs.push_back(ArgExpr.get()); ArgExprs.emplace_back(ArgExpr.get());
Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1, Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1,
AttributeList::AS_Keyword, EllipsisLoc); AttributeList::AS_Keyword, EllipsisLoc);
} }
/// Determine whether we're looking at something that might be a declarator /// Determine whether we're looking at something that might be a declarator
/// in a simple-declaration. If it can't possibly be a declarator, maybe /// in a simple-declaration. If it can't possibly be a declarator, maybe
/// diagnose a missing semicolon after a prior tag definition in the decl /// diagnose a missing semicolon after a prior tag definition in the decl
/// specifier. /// specifier.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Parse/ParseDeclCXX.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Stash the exception-specification tokens in the late-pased method. // Stash the exception-specification tokens in the late-pased method.
LateMethod->ExceptionSpecTokens = FTI.ExceptionSpecTokens; LateMethod->ExceptionSpecTokens = FTI.ExceptionSpecTokens;
FTI.ExceptionSpecTokens = nullptr; FTI.ExceptionSpecTokens = nullptr;
// Push tokens for each parameter. Those that do not have // Push tokens for each parameter. Those that do not have
// defaults will be NULL. // defaults will be NULL.
LateMethod->DefaultArgs.reserve(FTI.NumParams); LateMethod->DefaultArgs.reserve(FTI.NumParams);
for (unsigned ParamIdx = 0; ParamIdx < FTI.NumParams; ++ParamIdx) for (unsigned ParamIdx = 0; ParamIdx < FTI.NumParams; ++ParamIdx)
LateMethod->DefaultArgs.push_back(LateParsedDefaultArgument( LateMethod->DefaultArgs.emplace_back(
FTI.Params[ParamIdx].Param, FTI.Params[ParamIdx].DefaultArgTokens)); FTI.Params[ParamIdx].Param, FTI.Params[ParamIdx].DefaultArgTokens);
} }
} }
/// isCXX11VirtSpecifier - Determine whether the given token is a C++11 /// isCXX11VirtSpecifier - Determine whether the given token is a C++11
/// virt-specifier. /// virt-specifier.
/// ///
/// virt-specifier: /// virt-specifier:
/// override /// override
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Parse/ParseExpr.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Diag(Tok, diag::err_expected) << tok::identifier; Diag(Tok, diag::err_expected) << tok::identifier;
SkipUntil(tok::r_paren, StopAtSemi); SkipUntil(tok::r_paren, StopAtSemi);
return ExprError(); return ExprError();
} }
// Keep track of the various subcomponents we see. // Keep track of the various subcomponents we see.
SmallVector<Sema::OffsetOfComponent, 4> Comps; SmallVector<Sema::OffsetOfComponent, 4> Comps;
Comps.push_back(Sema::OffsetOfComponent()); Comps.emplace_back();
Comps.back().isBrackets = false; Comps.back().isBrackets = false;
Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken(); Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
// FIXME: This loop leaks the index expressions on error. // FIXME: This loop leaks the index expressions on error.
while (1) { while (1) {
if (Tok.is(tok::period)) { if (Tok.is(tok::period)) {
// offsetof-member-designator: offsetof-member-designator '.' identifier // offsetof-member-designator: offsetof-member-designator '.' identifier
Comps.push_back(Sema::OffsetOfComponent()); Comps.emplace_back();
Comps.back().isBrackets = false; Comps.back().isBrackets = false;
Comps.back().LocStart = ConsumeToken(); Comps.back().LocStart = ConsumeToken();
if (Tok.isNot(tok::identifier)) { if (Tok.isNot(tok::identifier)) {
Diag(Tok, diag::err_expected) << tok::identifier; Diag(Tok, diag::err_expected) << tok::identifier;
SkipUntil(tok::r_paren, StopAtSemi); SkipUntil(tok::r_paren, StopAtSemi);
return ExprError(); return ExprError();
} }
Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
Comps.back().LocEnd = ConsumeToken(); Comps.back().LocEnd = ConsumeToken();
} else if (Tok.is(tok::l_square)) { } else if (Tok.is(tok::l_square)) {
if (CheckProhibitedCXX11Attribute()) if (CheckProhibitedCXX11Attribute())
return ExprError(); return ExprError();
// offsetof-member-designator: offsetof-member-design '[' expression ']' // offsetof-member-designator: offsetof-member-design '[' expression ']'
Comps.push_back(Sema::OffsetOfComponent()); Comps.emplace_back();
Comps.back().isBrackets = true; Comps.back().isBrackets = true;
BalancedDelimiterTracker ST(*this, tok::l_square); BalancedDelimiterTracker ST(*this, tok::l_square);
ST.consumeOpen(); ST.consumeOpen();
Comps.back().LocStart = ST.getOpenLocation(); Comps.back().LocStart = ST.getOpenLocation();
Res = ParseExpression(); Res = ParseExpression();
if (Res.isInvalid()) { if (Res.isInvalid()) {
SkipUntil(tok::r_paren, StopAtSemi); SkipUntil(tok::r_paren, StopAtSemi);
return Res; return Res;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Parse/ParseObjc.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
DeclSpec DS(AttrFactory); DeclSpec DS(AttrFactory);
ParseDeclarationSpecifiers(DS); ParseDeclarationSpecifiers(DS);
// Parse the declarator. // Parse the declarator.
Declarator ParmDecl(DS, Declarator::PrototypeContext); Declarator ParmDecl(DS, Declarator::PrototypeContext);
ParseDeclarator(ParmDecl); ParseDeclarator(ParmDecl);
IdentifierInfo *ParmII = ParmDecl.getIdentifier(); IdentifierInfo *ParmII = ParmDecl.getIdentifier();
Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, CParamInfo.emplace_back(ParmII,
ParmDecl.getIdentifierLoc(), ParmDecl.getIdentifierLoc(),
Param, Param,
nullptr)); nullptr);
} }
// FIXME: Add support for optional parameter list... // FIXME: Add support for optional parameter list...
// If attributes exist after the method, parse them. // If attributes exist after the method, parse them.
if (getLangOpts().ObjC2) if (getLangOpts().ObjC2)
MaybeParseGNUAttributes(methodAttrs); MaybeParseGNUAttributes(methodAttrs);
if (KeyIdents.size() == 0) if (KeyIdents.size() == 0)
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
identifierLocs.push_back(ConsumeToken()); identifierLocs.push_back(ConsumeToken());
continue; continue;
} }
if (Tok.is(tok::code_completion)) { if (Tok.is(tok::code_completion)) {
// FIXME: Also include types here. // FIXME: Also include types here.
SmallVector<IdentifierLocPair, 4> identifierLocPairs; SmallVector<IdentifierLocPair, 4> identifierLocPairs;
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) { for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
identifierLocPairs.push_back(IdentifierLocPair(identifiers[i], identifierLocPairs.emplace_back(identifiers[i],
identifierLocs[i])); identifierLocs[i]);
} }
QualType BaseT = Actions.GetTypeFromParser(baseType); QualType BaseT = Actions.GetTypeFromParser(baseType);
if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) { if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) {
Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type); Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
} else { } else {
Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs); Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs);
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Parse the list of forward declarations. // Parse the list of forward declarations.
while (1) { while (1) {
ConsumeToken(); // the ',' ConsumeToken(); // the ','
if (Tok.isNot(tok::identifier)) { if (Tok.isNot(tok::identifier)) {
Diag(Tok, diag::err_expected) << tok::identifier; Diag(Tok, diag::err_expected) << tok::identifier;
SkipUntil(tok::semi); SkipUntil(tok::semi);
return nullptr; return nullptr;
} }
ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(), ProtocolRefs.emplace_back(Tok.getIdentifierInfo(),
Tok.getLocation())); Tok.getLocation());
ConsumeToken(); // the identifier ConsumeToken(); // the identifier
if (Tok.isNot(tok::comma)) if (Tok.isNot(tok::comma))
break; break;
} }
// Consume the ';'. // Consume the ';'.
if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@protocol")) if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@protocol"))
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Parse/ParseStmtAsm.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
LBraceLocs.push_back(EndLoc); LBraceLocs.push_back(EndLoc);
++NumTokensRead; ++NumTokensRead;
} else { } else {
// Single-line inline asm; compute which line it is on. // Single-line inline asm; compute which line it is on.
std::pair<FileID, unsigned> ExpAsmLoc = std::pair<FileID, unsigned> ExpAsmLoc =
SrcMgr.getDecomposedExpansionLoc(EndLoc); SrcMgr.getDecomposedExpansionLoc(EndLoc);
FID = ExpAsmLoc.first; FID = ExpAsmLoc.first;
LineNo = SrcMgr.getLineNumber(FID, ExpAsmLoc.second); LineNo = SrcMgr.getLineNumber(FID, ExpAsmLoc.second);
LBraceLocs.push_back(SourceLocation()); LBraceLocs.emplace_back();
} }
SourceLocation TokLoc = Tok.getLocation(); SourceLocation TokLoc = Tok.getLocation();
do { do {
// If we hit EOF, we're done, period. // If we hit EOF, we're done, period.
if (isEofOrEom()) if (isEofOrEom())
break; break;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/ProfileData/Coverage/CoverageMappingReader.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
<< ColumnEnd << ", "; << ColumnEnd << ", ";
if (Kind == CounterMappingRegion::ExpansionRegion) if (Kind == CounterMappingRegion::ExpansionRegion)
dbgs() << "Expands to file " << ExpandedFileID; dbgs() << "Expands to file " << ExpandedFileID;
else else
CounterMappingContext(Expressions).dump(C, dbgs()); CounterMappingContext(Expressions).dump(C, dbgs());
dbgs() << "\n"; dbgs() << "\n";
}); });
MappingRegions.push_back(CounterMappingRegion( MappingRegions.emplace_back(
C, InferredFileID, ExpandedFileID, LineStart, ColumnStart, C, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
LineStart + NumLines, ColumnEnd, Kind)); LineStart + NumLines, ColumnEnd, Kind);
} }
return Error::success(); return Error::success();
} }
Error RawCoverageMappingReader::read() { Error RawCoverageMappingReader::read() {
// Read the virtual file mapping. // Read the virtual file mapping.
llvm::SmallVector<unsigned, 8> VirtualFileMapping; llvm::SmallVector<unsigned, 8> VirtualFileMapping;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/AnalysisBasedWarnings.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
assert(Base && "A profile always has a base or property."); assert(Base && "A profile always has a base or property.");
if (const VarDecl *BaseVar = dyn_cast<VarDecl>(Base)) if (const VarDecl *BaseVar = dyn_cast<VarDecl>(Base))
if (BaseVar->hasLocalStorage() && !isa<ParmVarDecl>(Base)) if (BaseVar->hasLocalStorage() && !isa<ParmVarDecl>(Base))
continue; continue;
} }
} }
UsesByStmt.push_back(StmtUsesPair(UI->getUseExpr(), I)); UsesByStmt.emplace_back(UI->getUseExpr(), I);
} }
if (UsesByStmt.empty()) if (UsesByStmt.empty())
return; return;
// Sort by first use so that we emit the warnings in a deterministic order. // Sort by first use so that we emit the warnings in a deterministic order.
SourceManager &SM = S.getSourceManager(); SourceManager &SM = S.getSourceManager();
std::sort(UsesByStmt.begin(), UsesByStmt.end(), std::sort(UsesByStmt.begin(), UsesByStmt.end(),
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/CodeCompleteConsumer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Priority, Availability, Priority, Availability,
Annotations.data(), Annotations.size(), Annotations.data(), Annotations.size(),
ParentName, BriefComment); ParentName, BriefComment);
Chunks.clear(); Chunks.clear();
return Result; return Result;
} }
void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) { void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text)); Chunks.emplace_back(CodeCompletionString::CK_TypedText, Text);
} }
void CodeCompletionBuilder::AddTextChunk(const char *Text) { void CodeCompletionBuilder::AddTextChunk(const char *Text) {
Chunks.push_back(Chunk::CreateText(Text)); Chunks.push_back(Chunk::CreateText(Text));
} }
void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) { void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
Chunks.push_back(Chunk::CreateOptional(Optional)); Chunks.push_back(Chunk::CreateOptional(Optional));
Show All 13 Lines
void void
CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) { CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) {
Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter)); Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
} }
void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK, void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
const char *Text) { const char *Text) {
Chunks.push_back(Chunk(CK, Text)); Chunks.emplace_back(CK, Text);
} }
void CodeCompletionBuilder::addParentContext(const DeclContext *DC) { void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
if (DC->isTranslationUnit()) { if (DC->isTranslationUnit()) {
return; return;
} }
if (DC->isFunctionOrMethod()) if (DC->isFunctionOrMethod())
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/JumpDiagnostics.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
}; };
} // end anonymous namespace } // end anonymous namespace
#define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x))) #define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x)))
JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s) JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
: S(s), Permissive(s.hasAnyUnrecoverableErrorsInThisFunction()) { : S(s), Permissive(s.hasAnyUnrecoverableErrorsInThisFunction()) {
// Add a scope entry for function scope. // Add a scope entry for function scope.
Scopes.push_back(GotoScope(~0U, ~0U, ~0U, SourceLocation())); Scopes.emplace_back(~0U, ~0U, ~0U, SourceLocation());
// Build information for the top level compound statement, so that we have a // Build information for the top level compound statement, so that we have a
// defined scope record for every "goto" and label. // defined scope record for every "goto" and label.
unsigned BodyParentScope = 0; unsigned BodyParentScope = 0;
BuildScopeInformation(Body, BodyParentScope); BuildScopeInformation(Body, BodyParentScope);
// Check that all jumps we saw are kosher. // Check that all jumps we saw are kosher.
VerifyJumps(); VerifyJumps();
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
return ScopePair(0U, 0U); return ScopePair(0U, 0U);
} }
/// \brief Build scope information for a declaration that is part of a DeclStmt. /// \brief Build scope information for a declaration that is part of a DeclStmt.
void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) { void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) {
// If this decl causes a new scope, push and switch to it. // If this decl causes a new scope, push and switch to it.
std::pair<unsigned,unsigned> Diags = GetDiagForGotoScopeDecl(S, D); std::pair<unsigned,unsigned> Diags = GetDiagForGotoScopeDecl(S, D);
if (Diags.first || Diags.second) { if (Diags.first || Diags.second) {
Scopes.push_back(GotoScope(ParentScope, Diags.first, Diags.second, Scopes.emplace_back(ParentScope, Diags.first, Diags.second,
D->getLocation())); D->getLocation());
ParentScope = Scopes.size()-1; ParentScope = Scopes.size()-1;
} }
// If the decl has an initializer, walk it with the potentially new // If the decl has an initializer, walk it with the potentially new
// scope we just installed. // scope we just installed.
if (VarDecl *VD = dyn_cast<VarDecl>(D)) if (VarDecl *VD = dyn_cast<VarDecl>(D))
if (Expr *Init = VD->getInit()) if (Expr *Init = VD->getInit())
BuildScopeInformation(Init, ParentScope); BuildScopeInformation(Init, ParentScope);
Show All 25 Lines
diag::note_exits_block_captures_weak); diag::note_exits_block_captures_weak);
break; break;
case QualType::DK_none: case QualType::DK_none:
llvm_unreachable("non-lifetime captured variable"); llvm_unreachable("non-lifetime captured variable");
} }
SourceLocation Loc = D->getLocation(); SourceLocation Loc = D->getLocation();
if (Loc.isInvalid()) if (Loc.isInvalid())
Loc = BDecl->getLocation(); Loc = BDecl->getLocation();
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
Diags.first, Diags.second, Loc)); Diags.first, Diags.second, Loc);
ParentScope = Scopes.size()-1; ParentScope = Scopes.size()-1;
} }
} }
/// BuildScopeInformation - The statements from CI to CE are known to form a /// BuildScopeInformation - The statements from CI to CE are known to form a
/// coherent VLA scope with a specified parent node. Walk through the /// coherent VLA scope with a specified parent node. Walk through the
/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively /// statements, adding any labels or gotos to LabelAndGotoScopes and recursively
/// walking the AST as needed. /// walking the AST as needed.
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// it. This makes the second scan not have to walk the AST again. // it. This makes the second scan not have to walk the AST again.
LabelAndGotoScopes[S] = ParentScope; LabelAndGotoScopes[S] = ParentScope;
Jumps.push_back(S); Jumps.push_back(S);
break; break;
case Stmt::CXXTryStmtClass: { case Stmt::CXXTryStmtClass: {
CXXTryStmt *TS = cast<CXXTryStmt>(S); CXXTryStmt *TS = cast<CXXTryStmt>(S);
unsigned newParentScope; unsigned newParentScope;
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_cxx_try, diag::note_protected_by_cxx_try,
diag::note_exits_cxx_try, diag::note_exits_cxx_try,
TS->getSourceRange().getBegin())); TS->getSourceRange().getBegin());
if (Stmt *TryBlock = TS->getTryBlock()) if (Stmt *TryBlock = TS->getTryBlock())
BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1)); BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1));
// Jump from the catch into the try is not allowed either. // Jump from the catch into the try is not allowed either.
for (unsigned I = 0, E = TS->getNumHandlers(); I != E; ++I) { for (unsigned I = 0, E = TS->getNumHandlers(); I != E; ++I) {
CXXCatchStmt *CS = TS->getHandler(I); CXXCatchStmt *CS = TS->getHandler(I);
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_cxx_catch, diag::note_protected_by_cxx_catch,
diag::note_exits_cxx_catch, diag::note_exits_cxx_catch,
CS->getSourceRange().getBegin())); CS->getSourceRange().getBegin());
BuildScopeInformation(CS->getHandlerBlock(), BuildScopeInformation(CS->getHandlerBlock(),
(newParentScope = Scopes.size()-1)); (newParentScope = Scopes.size()-1));
} }
return; return;
} }
case Stmt::SEHTryStmtClass: { case Stmt::SEHTryStmtClass: {
SEHTryStmt *TS = cast<SEHTryStmt>(S); SEHTryStmt *TS = cast<SEHTryStmt>(S);
unsigned newParentScope; unsigned newParentScope;
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_seh_try, diag::note_protected_by_seh_try,
diag::note_exits_seh_try, diag::note_exits_seh_try,
TS->getSourceRange().getBegin())); TS->getSourceRange().getBegin());
if (Stmt *TryBlock = TS->getTryBlock()) if (Stmt *TryBlock = TS->getTryBlock())
BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1)); BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1));
// Jump from __except or __finally into the __try are not allowed either. // Jump from __except or __finally into the __try are not allowed either.
if (SEHExceptStmt *Except = TS->getExceptHandler()) { if (SEHExceptStmt *Except = TS->getExceptHandler()) {
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_seh_except, diag::note_protected_by_seh_except,
diag::note_exits_seh_except, diag::note_exits_seh_except,
Except->getSourceRange().getBegin())); Except->getSourceRange().getBegin());
BuildScopeInformation(Except->getBlock(), BuildScopeInformation(Except->getBlock(),
(newParentScope = Scopes.size()-1)); (newParentScope = Scopes.size()-1));
} else if (SEHFinallyStmt *Finally = TS->getFinallyHandler()) { } else if (SEHFinallyStmt *Finally = TS->getFinallyHandler()) {
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_seh_finally, diag::note_protected_by_seh_finally,
diag::note_exits_seh_finally, diag::note_exits_seh_finally,
Finally->getSourceRange().getBegin())); Finally->getSourceRange().getBegin());
BuildScopeInformation(Finally->getBlock(), BuildScopeInformation(Finally->getBlock(),
(newParentScope = Scopes.size()-1)); (newParentScope = Scopes.size()-1));
} }
return; return;
} }
default: default:
Show All 35 Lines
BuildScopeInformation(I, ParentScope); BuildScopeInformation(I, ParentScope);
continue; continue;
} }
// Disallow jumps into any part of an @try statement by pushing a scope and // Disallow jumps into any part of an @try statement by pushing a scope and
// walking all sub-stmts in that scope. // walking all sub-stmts in that scope.
if (ObjCAtTryStmt *AT = dyn_cast<ObjCAtTryStmt>(SubStmt)) { if (ObjCAtTryStmt *AT = dyn_cast<ObjCAtTryStmt>(SubStmt)) {
unsigned newParentScope; unsigned newParentScope;
// Recursively walk the AST for the @try part. // Recursively walk the AST for the @try part.
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_objc_try, diag::note_protected_by_objc_try,
diag::note_exits_objc_try, diag::note_exits_objc_try,
AT->getAtTryLoc())); AT->getAtTryLoc());
if (Stmt *TryPart = AT->getTryBody()) if (Stmt *TryPart = AT->getTryBody())
BuildScopeInformation(TryPart, (newParentScope = Scopes.size()-1)); BuildScopeInformation(TryPart, (newParentScope = Scopes.size()-1));
// Jump from the catch to the finally or try is not valid. // Jump from the catch to the finally or try is not valid.
for (unsigned I = 0, N = AT->getNumCatchStmts(); I != N; ++I) { for (unsigned I = 0, N = AT->getNumCatchStmts(); I != N; ++I) {
ObjCAtCatchStmt *AC = AT->getCatchStmt(I); ObjCAtCatchStmt *AC = AT->getCatchStmt(I);
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_objc_catch, diag::note_protected_by_objc_catch,
diag::note_exits_objc_catch, diag::note_exits_objc_catch,
AC->getAtCatchLoc())); AC->getAtCatchLoc());
// @catches are nested and it isn't // @catches are nested and it isn't
BuildScopeInformation(AC->getCatchBody(), BuildScopeInformation(AC->getCatchBody(),
(newParentScope = Scopes.size()-1)); (newParentScope = Scopes.size()-1));
} }
// Jump from the finally to the try or catch is not valid. // Jump from the finally to the try or catch is not valid.
if (ObjCAtFinallyStmt *AF = AT->getFinallyStmt()) { if (ObjCAtFinallyStmt *AF = AT->getFinallyStmt()) {
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_objc_finally, diag::note_protected_by_objc_finally,
diag::note_exits_objc_finally, diag::note_exits_objc_finally,
AF->getAtFinallyLoc())); AF->getAtFinallyLoc());
BuildScopeInformation(AF, (newParentScope = Scopes.size()-1)); BuildScopeInformation(AF, (newParentScope = Scopes.size()-1));
} }
continue; continue;
} }
unsigned newParentScope; unsigned newParentScope;
// Disallow jumps into the protected statement of an @synchronized, but // Disallow jumps into the protected statement of an @synchronized, but
// allow jumps into the object expression it protects. // allow jumps into the object expression it protects.
if (ObjCAtSynchronizedStmt *AS = if (ObjCAtSynchronizedStmt *AS =
dyn_cast<ObjCAtSynchronizedStmt>(SubStmt)) { dyn_cast<ObjCAtSynchronizedStmt>(SubStmt)) {
// Recursively walk the AST for the @synchronized object expr, it is // Recursively walk the AST for the @synchronized object expr, it is
// evaluated in the normal scope. // evaluated in the normal scope.
BuildScopeInformation(AS->getSynchExpr(), ParentScope); BuildScopeInformation(AS->getSynchExpr(), ParentScope);
// Recursively walk the AST for the @synchronized part, protected by a new // Recursively walk the AST for the @synchronized part, protected by a new
// scope. // scope.
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_objc_synchronized, diag::note_protected_by_objc_synchronized,
diag::note_exits_objc_synchronized, diag::note_exits_objc_synchronized,
AS->getAtSynchronizedLoc())); AS->getAtSynchronizedLoc());
BuildScopeInformation(AS->getSynchBody(), BuildScopeInformation(AS->getSynchBody(),
(newParentScope = Scopes.size()-1)); (newParentScope = Scopes.size()-1));
continue; continue;
} }
// Disallow jumps into the protected statement of an @autoreleasepool. // Disallow jumps into the protected statement of an @autoreleasepool.
if (ObjCAutoreleasePoolStmt *AS = if (ObjCAutoreleasePoolStmt *AS =
dyn_cast<ObjCAutoreleasePoolStmt>(SubStmt)) { dyn_cast<ObjCAutoreleasePoolStmt>(SubStmt)) {
// Recursively walk the AST for the @autoreleasepool part, protected by a // Recursively walk the AST for the @autoreleasepool part, protected by a
// new scope. // new scope.
Scopes.push_back(GotoScope(ParentScope, Scopes.emplace_back(ParentScope,
diag::note_protected_by_objc_autoreleasepool, diag::note_protected_by_objc_autoreleasepool,
diag::note_exits_objc_autoreleasepool, diag::note_exits_objc_autoreleasepool,
AS->getAtLoc())); AS->getAtLoc());
BuildScopeInformation(AS->getSubStmt(), BuildScopeInformation(AS->getSubStmt(),
(newParentScope = Scopes.size() - 1)); (newParentScope = Scopes.size() - 1));
continue; continue;
} }
// Disallow jumps past full-expressions that use blocks with // Disallow jumps past full-expressions that use blocks with
// non-trivial cleanups of their captures. This is theoretically // non-trivial cleanups of their captures. This is theoretically
// implementable but a lot of work which we haven't felt up to doing. // implementable but a lot of work which we haven't felt up to doing.
Show All 13 Lines
dyn_cast<MaterializeTemporaryExpr>(SubStmt)) { dyn_cast<MaterializeTemporaryExpr>(SubStmt)) {
if (MTE->getStorageDuration() == SD_Automatic) { if (MTE->getStorageDuration() == SD_Automatic) {
SmallVector<const Expr *, 4> CommaLHS; SmallVector<const Expr *, 4> CommaLHS;
SmallVector<SubobjectAdjustment, 4> Adjustments; SmallVector<SubobjectAdjustment, 4> Adjustments;
const Expr *ExtendedObject = const Expr *ExtendedObject =
MTE->GetTemporaryExpr()->skipRValueSubobjectAdjustments( MTE->GetTemporaryExpr()->skipRValueSubobjectAdjustments(
CommaLHS, Adjustments); CommaLHS, Adjustments);
if (ExtendedObject->getType().isDestructedType()) { if (ExtendedObject->getType().isDestructedType()) {
Scopes.push_back(GotoScope(ParentScope, 0, Scopes.emplace_back(ParentScope, 0,
diag::note_exits_temporary_dtor, diag::note_exits_temporary_dtor,
ExtendedObject->getExprLoc())); ExtendedObject->getExprLoc());
ParentScope = Scopes.size()-1; ParentScope = Scopes.size()-1;
} }
} }
} }
// Recursively walk the AST. // Recursively walk the AST.
BuildScopeInformation(SubStmt, ParentScope); BuildScopeInformation(SubStmt, ParentScope);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/ScopeInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
: Base(getBaseInfo(IvarE->getBase())), Property(IvarE->getDecl()) { : Base(getBaseInfo(IvarE->getBase())), Property(IvarE->getDecl()) {
} }
void FunctionScopeInfo::recordUseOfWeak(const ObjCMessageExpr *Msg, void FunctionScopeInfo::recordUseOfWeak(const ObjCMessageExpr *Msg,
const ObjCPropertyDecl *Prop) { const ObjCPropertyDecl *Prop) {
assert(Msg && Prop); assert(Msg && Prop);
WeakUseVector &Uses = WeakUseVector &Uses =
WeakObjectUses[WeakObjectProfileTy(Msg->getInstanceReceiver(), Prop)]; WeakObjectUses[WeakObjectProfileTy(Msg->getInstanceReceiver(), Prop)];
Uses.push_back(WeakUseTy(Msg, Msg->getNumArgs() == 0)); Uses.emplace_back(Msg, Msg->getNumArgs() == 0);
} }
void FunctionScopeInfo::markSafeWeakUse(const Expr *E) { void FunctionScopeInfo::markSafeWeakUse(const Expr *E) {
E = E->IgnoreParenCasts(); E = E->IgnoreParenCasts();
if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) { if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
markSafeWeakUse(POE->getSyntacticForm()); markSafeWeakUse(POE->getSyntacticForm());
return; return;
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lib/Sema/Sema.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
for (const auto &PUD : Scope->PossiblyUnreachableDiags) for (const auto &PUD : Scope->PossiblyUnreachableDiags)
Diag(PUD.Loc, PUD.PD); Diag(PUD.Loc, PUD.PD);
if (FunctionScopes.back() != Scope) if (FunctionScopes.back() != Scope)
delete Scope; delete Scope;
} }
void Sema::PushCompoundScope() { void Sema::PushCompoundScope() {
getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); getCurFunction()->CompoundScopes.emplace_back();
} }
void Sema::PopCompoundScope() { void Sema::PopCompoundScope() {
FunctionScopeInfo *CurFunction = getCurFunction(); FunctionScopeInfo *CurFunction = getCurFunction();
assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
CurFunction->CompoundScopes.pop_back(); CurFunction->CompoundScopes.pop_back();
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaAttr.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
PragmaMsStackAction Action, PragmaMsStackAction Action,
llvm::StringRef StackSlotLabel, llvm::StringRef StackSlotLabel,
ValueType Value) { ValueType Value) {
if (Action == PSK_Reset) { if (Action == PSK_Reset) {
CurrentValue = DefaultValue; CurrentValue = DefaultValue;
return; return;
} }
if (Action & PSK_Push) if (Action & PSK_Push)
Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation)); Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation);
else if (Action & PSK_Pop) { else if (Action & PSK_Pop) {
if (!StackSlotLabel.empty()) { if (!StackSlotLabel.empty()) {
// If we've got a label, try to find it and jump there. // If we've got a label, try to find it and jump there.
auto I = std::find_if(Stack.rbegin(), Stack.rend(), auto I = std::find_if(Stack.rbegin(), Stack.rend(),
[&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; });
// If we found the label so pop from there. // If we found the label so pop from there.
if (I != Stack.rend()) { if (I != Stack.rend()) {
CurrentValue = I->Value; CurrentValue = I->Value;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaCast.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
OS << "__" << DstCCName; OS << "__" << DstCCName;
IdentifierInfo *II = PP.getIdentifierInfo(OS.str()); IdentifierInfo *II = PP.getIdentifierInfo(OS.str());
AttrTokens.push_back(II->isKeyword(Self.getLangOpts()) AttrTokens.push_back(II->isKeyword(Self.getLangOpts())
? TokenValue(II->getTokenID()) ? TokenValue(II->getTokenID())
: TokenValue(II)); : TokenValue(II));
} else { } else {
// __attribute__((stdcall)) or __attribute__((vectorcall)) // __attribute__((stdcall)) or __attribute__((vectorcall))
OS << "__attribute__((" << DstCCName << "))"; OS << "__attribute__((" << DstCCName << "))";
AttrTokens.push_back(tok::kw___attribute); AttrTokens.emplace_back(tok::kw___attribute);
AttrTokens.push_back(tok::l_paren); AttrTokens.emplace_back(tok::l_paren);
AttrTokens.push_back(tok::l_paren); AttrTokens.emplace_back(tok::l_paren);
IdentifierInfo *II = PP.getIdentifierInfo(DstCCName); IdentifierInfo *II = PP.getIdentifierInfo(DstCCName);
AttrTokens.push_back(II->isKeyword(Self.getLangOpts()) AttrTokens.push_back(II->isKeyword(Self.getLangOpts())
? TokenValue(II->getTokenID()) ? TokenValue(II->getTokenID())
: TokenValue(II)); : TokenValue(II));
AttrTokens.push_back(tok::r_paren); AttrTokens.emplace_back(tok::r_paren);
AttrTokens.push_back(tok::r_paren); AttrTokens.emplace_back(tok::r_paren);
} }
StringRef AttrSpelling = PP.getLastMacroWithSpelling(NameLoc, AttrTokens); StringRef AttrSpelling = PP.getLastMacroWithSpelling(NameLoc, AttrTokens);
if (!AttrSpelling.empty()) if (!AttrSpelling.empty())
CCAttrText = AttrSpelling; CCAttrText = AttrSpelling;
OS << ' '; OS << ' ';
Self.Diag(NameLoc, diag::note_change_calling_conv_fixit) Self.Diag(NameLoc, diag::note_change_calling_conv_fixit)
<< FD << DstCCName << FixItHint::CreateInsertion(NameLoc, CCAttrText); << FD << DstCCName << FixItHint::CreateInsertion(NameLoc, CCAttrText);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaDeclCXX.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Even if a definition wasn't required before, it may be required now. // Even if a definition wasn't required before, it may be required now.
if (Pos != VTablesUsed.end()) { if (Pos != VTablesUsed.end()) {
if (!Pos->second && VTables[I].DefinitionRequired) if (!Pos->second && VTables[I].DefinitionRequired)
Pos->second = true; Pos->second = true;
continue; continue;
} }
VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired; VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location)); NewUses.emplace_back(VTables[I].Record, VTables[I].Location);
} }
VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end()); VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
} }
void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
bool DefinitionRequired) { bool DefinitionRequired) {
// Ignore any vtable uses in unevaluated operands or for classes that do // Ignore any vtable uses in unevaluated operands or for classes that do
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaDeclObjC.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// \c*. // \c*.
typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl; typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl;
SmallVector<TypeOrClassDecl, 4> typeDecls; SmallVector<TypeOrClassDecl, 4> typeDecls;
unsigned numTypeDeclsResolved = 0; unsigned numTypeDeclsResolved = 0;
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) { for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
NamedDecl *decl = LookupSingleName(S, identifiers[i], identifierLocs[i], NamedDecl *decl = LookupSingleName(S, identifiers[i], identifierLocs[i],
LookupOrdinaryName); LookupOrdinaryName);
if (!decl) { if (!decl) {
typeDecls.push_back(TypeOrClassDecl()); typeDecls.emplace_back();
continue; continue;
} }
if (auto typeDecl = dyn_cast<TypeDecl>(decl)) { if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
typeDecls.push_back(typeDecl); typeDecls.emplace_back(typeDecl);
++numTypeDeclsResolved; ++numTypeDeclsResolved;
continue; continue;
} }
if (auto objcClass = dyn_cast<ObjCInterfaceDecl>(decl)) { if (auto objcClass = dyn_cast<ObjCInterfaceDecl>(decl)) {
typeDecls.push_back(objcClass); typeDecls.emplace_back(objcClass);
++numTypeDeclsResolved; ++numTypeDeclsResolved;
continue; continue;
} }
typeDecls.push_back(TypeOrClassDecl()); typeDecls.emplace_back();
} }
AttributeFactory attrFactory; AttributeFactory attrFactory;
// Local function that forms a reference to the given type or // Local function that forms a reference to the given type or
// Objective-C class declaration. // Objective-C class declaration.
auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc) auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc)
-> TypeResult { -> TypeResult {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaExpr.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// FIXME: An integral constant expression? // FIXME: An integral constant expression?
if (!Idx->isTypeDependent() && !Idx->isValueDependent() && if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
!Idx->getType()->isIntegerType()) !Idx->getType()->isIntegerType())
return ExprError(Diag(Idx->getLocStart(), return ExprError(Diag(Idx->getLocStart(),
diag::err_typecheck_subscript_not_integer) diag::err_typecheck_subscript_not_integer)
<< Idx->getSourceRange()); << Idx->getSourceRange());
// Record this array index. // Record this array index.
Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); Comps.emplace_back(OC.LocStart, Exprs.size(), OC.LocEnd);
Exprs.push_back(Idx); Exprs.push_back(Idx);
continue; continue;
} }
// Offset of a field. // Offset of a field.
if (CurrentType->isDependentType()) { if (CurrentType->isDependentType()) {
// We have the offset of a field, but we can't look into the dependent // We have the offset of a field, but we can't look into the dependent
// type. Just record the identifier of the field. // type. Just record the identifier of the field.
Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); Comps.emplace_back(OC.LocStart, OC.U.IdentInfo, OC.LocEnd);
CurrentType = Context.DependentTy; CurrentType = Context.DependentTy;
continue; continue;
} }
// We need to have a complete type to look into. // We need to have a complete type to look into.
if (RequireCompleteType(OC.LocStart, CurrentType, if (RequireCompleteType(OC.LocStart, CurrentType,
diag::err_offsetof_incomplete_type)) diag::err_offsetof_incomplete_type))
return ExprError(); return ExprError();
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
CXXBasePath &Path = Paths.front(); CXXBasePath &Path = Paths.front();
for (const CXXBasePathElement &B : Path) for (const CXXBasePathElement &B : Path)
Comps.push_back(OffsetOfNode(B.Base)); Comps.push_back(OffsetOfNode(B.Base));
} }
if (IndirectMemberDecl) { if (IndirectMemberDecl) {
for (auto *FI : IndirectMemberDecl->chain()) { for (auto *FI : IndirectMemberDecl->chain()) {
assert(isa<FieldDecl>(FI)); assert(isa<FieldDecl>(FI));
Comps.push_back(OffsetOfNode(OC.LocStart, Comps.emplace_back(OC.LocStart,
cast<FieldDecl>(FI), OC.LocEnd)); cast<FieldDecl>(FI), OC.LocEnd);
} }
} else } else
Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); Comps.emplace_back(OC.LocStart, MemberDecl, OC.LocEnd);
CurrentType = MemberDecl->getType().getNonReferenceType(); CurrentType = MemberDecl->getType().getNonReferenceType();
} }
return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo, return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo,
Comps, Exprs, RParenLoc); Comps, Exprs, RParenLoc);
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
PointOfInstantiation = MSInfo->getPointOfInstantiation(); PointOfInstantiation = MSInfo->getPointOfInstantiation();
} }
} }
if (!AlreadyInstantiated || Func->isConstexpr()) { if (!AlreadyInstantiated || Func->isConstexpr()) {
if (isa<CXXRecordDecl>(Func->getDeclContext()) && if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() && cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
ActiveTemplateInstantiations.size()) ActiveTemplateInstantiations.size())
PendingLocalImplicitInstantiations.push_back( PendingLocalImplicitInstantiations.emplace_back(std::make_pair(Func, PointOfInstantiation));
std::make_pair(Func, PointOfInstantiation));
else if (Func->isConstexpr()) else if (Func->isConstexpr())
// Do not defer instantiations of constexpr functions, to avoid the // Do not defer instantiations of constexpr functions, to avoid the
// expression evaluator needing to call back into Sema if it sees a // expression evaluator needing to call back into Sema if it sees a
// call to such a function. // call to such a function.
InstantiateFunctionDefinition(PointOfInstantiation, Func); InstantiateFunctionDefinition(PointOfInstantiation, Func);
else { else {
PendingInstantiations.push_back(std::make_pair(Func, PendingInstantiations.emplace_back(std::make_pair(Func,
PointOfInstantiation)); PointOfInstantiation));
// Notify the consumer that a function was implicitly instantiated. // Notify the consumer that a function was implicitly instantiated.
Consumer.HandleCXXImplicitFunctionInstantiation(Func); Consumer.HandleCXXImplicitFunctionInstantiation(Func);
} }
} }
} else { } else {
// Walk redefinitions, as some of them may be instantiable. // Walk redefinitions, as some of them may be instantiable.
for (auto i : Func->redecls()) { for (auto i : Func->redecls()) {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Do not instantiate specializations that are still type-dependent. // Do not instantiate specializations that are still type-dependent.
if (IsNonDependent) { if (IsNonDependent) {
if (Var->isUsableInConstantExpressions(SemaRef.Context)) { if (Var->isUsableInConstantExpressions(SemaRef.Context)) {
// Do not defer instantiations of variables which could be used in a // Do not defer instantiations of variables which could be used in a
// constant expression. // constant expression.
SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var); SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
} else { } else {
SemaRef.PendingInstantiations SemaRef.PendingInstantiations
.push_back(std::make_pair(Var, PointOfInstantiation)); .emplace_back(std::make_pair(Var, PointOfInstantiation));
} }
} }
} }
} }
if (!MarkODRUsed) if (!MarkODRUsed)
return; return;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaExprCXX.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs; SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
SmallVector<Expr *, 2> ArgExprs; SmallVector<Expr *, 2> ArgExprs;
ArgExprs.reserve(Args.size() - 1); ArgExprs.reserve(Args.size() - 1);
for (unsigned I = 1, N = Args.size(); I != N; ++I) { for (unsigned I = 1, N = Args.size(); I != N; ++I) {
QualType ArgTy = Args[I]->getType(); QualType ArgTy = Args[I]->getType();
if (ArgTy->isObjectType() || ArgTy->isFunctionType()) if (ArgTy->isObjectType() || ArgTy->isFunctionType())
ArgTy = S.Context.getRValueReferenceType(ArgTy); ArgTy = S.Context.getRValueReferenceType(ArgTy);
OpaqueArgExprs.push_back( OpaqueArgExprs.emplace_back(Args[I]->getTypeLoc().getLocStart(),
OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
ArgTy.getNonLValueExprType(S.Context), ArgTy.getNonLValueExprType(S.Context),
Expr::getValueKindForType(ArgTy))); Expr::getValueKindForType(ArgTy));
} }
for (Expr &E : OpaqueArgExprs) for (Expr &E : OpaqueArgExprs)
ArgExprs.push_back(&E); ArgExprs.push_back(&E);
// Perform the initialization in an unevaluated context within a SFINAE // Perform the initialization in an unevaluated context within a SFINAE
// trap at translation unit scope. // trap at translation unit scope.
EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true); Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// If we're allowed to create a non-standard composite type, keep track // If we're allowed to create a non-standard composite type, keep track
// of where we need to fill in additional 'const' qualifiers. // of where we need to fill in additional 'const' qualifiers.
if (NonStandardCompositeType && if (NonStandardCompositeType &&
Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
NeedConstBefore = QualifierUnion.size(); NeedConstBefore = QualifierUnion.size();
QualifierUnion.push_back( QualifierUnion.push_back(
Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
MemberOfClass.push_back(std::make_pair(nullptr, nullptr)); MemberOfClass.emplace_back(std::make_pair(nullptr, nullptr));
continue; continue;
} }
const MemberPointerType *MemPtr1, *MemPtr2; const MemberPointerType *MemPtr1, *MemPtr2;
if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
(MemPtr2 = Composite2->getAs<MemberPointerType>())) { (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
Composite1 = MemPtr1->getPointeeType(); Composite1 = MemPtr1->getPointeeType();
Composite2 = MemPtr2->getPointeeType(); Composite2 = MemPtr2->getPointeeType();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaInit.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
IndirectFieldDecl *IndirectField) { IndirectFieldDecl *IndirectField) {
typedef DesignatedInitExpr::Designator Designator; typedef DesignatedInitExpr::Designator Designator;
// Build the replacement designators. // Build the replacement designators.
SmallVector<Designator, 4> Replacements; SmallVector<Designator, 4> Replacements;
for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(), for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
PE = IndirectField->chain_end(); PI != PE; ++PI) { PE = IndirectField->chain_end(); PI != PE; ++PI) {
if (PI + 1 == PE) if (PI + 1 == PE)
Replacements.push_back(Designator((IdentifierInfo *)nullptr, Replacements.emplace_back((IdentifierInfo *)nullptr,
DIE->getDesignator(DesigIdx)->getDotLoc(), DIE->getDesignator(DesigIdx)->getDotLoc(),
DIE->getDesignator(DesigIdx)->getFieldLoc())); DIE->getDesignator(DesigIdx)->getFieldLoc());
else else
Replacements.push_back(Designator((IdentifierInfo *)nullptr, Replacements.emplace_back((IdentifierInfo *)nullptr,
SourceLocation(), SourceLocation())); SourceLocation(), SourceLocation());
assert(isa<FieldDecl>(*PI)); assert(isa<FieldDecl>(*PI));
Replacements.back().setField(cast<FieldDecl>(*PI)); Replacements.back().setField(cast<FieldDecl>(*PI));
} }
// Expand the current designator into the set of replacement // Expand the current designator into the set of replacement
// designators, so we have a full subobject path down to where the // designators, so we have a full subobject path down to where the
// member of the anonymous struct/union is actually stored. // member of the anonymous struct/union is actually stored.
DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0], DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
SmallVector<ASTDesignator, 32> Designators; SmallVector<ASTDesignator, 32> Designators;
SmallVector<Expr *, 32> InitExpressions; SmallVector<Expr *, 32> InitExpressions;
// Build designators and check array designator expressions. // Build designators and check array designator expressions.
for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
const Designator &D = Desig.getDesignator(Idx); const Designator &D = Desig.getDesignator(Idx);
switch (D.getKind()) { switch (D.getKind()) {
case Designator::FieldDesignator: case Designator::FieldDesignator:
Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), Designators.emplace_back(D.getField(), D.getDotLoc(),
D.getFieldLoc())); D.getFieldLoc());
break; break;
case Designator::ArrayDesignator: { case Designator::ArrayDesignator: {
Expr *Index = static_cast<Expr *>(D.getArrayIndex()); Expr *Index = static_cast<Expr *>(D.getArrayIndex());
llvm::APSInt IndexValue; llvm::APSInt IndexValue;
if (!Index->isTypeDependent() && !Index->isValueDependent()) if (!Index->isTypeDependent() && !Index->isValueDependent())
Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get(); Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
if (!Index) if (!Index)
Invalid = true; Invalid = true;
else { else {
Designators.push_back(ASTDesignator(InitExpressions.size(), Designators.emplace_back(InitExpressions.size(),
D.getLBracketLoc(), D.getLBracketLoc(),
D.getRBracketLoc())); D.getRBracketLoc());
InitExpressions.push_back(Index); InitExpressions.push_back(Index);
} }
break; break;
} }
case Designator::ArrayRangeDesignator: { case Designator::ArrayRangeDesignator: {
Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
Show All 21 Lines
StartValue = StartValue.extend(EndValue.getBitWidth()); StartValue = StartValue.extend(EndValue.getBitWidth());
if (!StartDependent && !EndDependent && EndValue < StartValue) { if (!StartDependent && !EndDependent && EndValue < StartValue) {
Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
<< StartValue.toString(10) << EndValue.toString(10) << StartValue.toString(10) << EndValue.toString(10)
<< StartIndex->getSourceRange() << EndIndex->getSourceRange(); << StartIndex->getSourceRange() << EndIndex->getSourceRange();
Invalid = true; Invalid = true;
} else { } else {
Designators.push_back(ASTDesignator(InitExpressions.size(), Designators.emplace_back(InitExpressions.size(),
D.getLBracketLoc(), D.getLBracketLoc(),
D.getEllipsisLoc(), D.getEllipsisLoc(),
D.getRBracketLoc())); D.getRBracketLoc());
InitExpressions.push_back(StartIndex); InitExpressions.push_back(StartIndex);
InitExpressions.push_back(EndIndex); InitExpressions.push_back(EndIndex);
} }
} }
break; break;
} }
} }
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaLambda.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
auto CurField = Class->field_begin(); auto CurField = Class->field_begin();
for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) { for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
LambdaScopeInfo::Capture From = LSI->Captures[I]; LambdaScopeInfo::Capture From = LSI->Captures[I];
assert(!From.isBlockCapture() && "Cannot capture __block variables"); assert(!From.isBlockCapture() && "Cannot capture __block variables");
bool IsImplicit = I >= LSI->NumExplicitCaptures; bool IsImplicit = I >= LSI->NumExplicitCaptures;
// Handle 'this' capture. // Handle 'this' capture.
if (From.isThisCapture()) { if (From.isThisCapture()) {
Captures.push_back( Captures.emplace_back(From.getLocation(), IsImplicit,
LambdaCapture(From.getLocation(), IsImplicit, From.isCopyCapture() ? LCK_StarThis : LCK_This);
From.isCopyCapture() ? LCK_StarThis : LCK_This));
CaptureInits.push_back(From.getInitExpr()); CaptureInits.push_back(From.getInitExpr());
ArrayIndexStarts.push_back(ArrayIndexVars.size()); ArrayIndexStarts.push_back(ArrayIndexVars.size());
continue; continue;
} }
if (From.isVLATypeCapture()) { if (From.isVLATypeCapture()) {
Captures.push_back( Captures.emplace_back(From.getLocation(), IsImplicit, LCK_VLAType);
LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType));
CaptureInits.push_back(nullptr); CaptureInits.push_back(nullptr);
ArrayIndexStarts.push_back(ArrayIndexVars.size()); ArrayIndexStarts.push_back(ArrayIndexVars.size());
continue; continue;
} }
VarDecl *Var = From.getVariable(); VarDecl *Var = From.getVariable();
LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef; LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind, Captures.emplace_back(From.getLocation(), IsImplicit, Kind,
Var, From.getEllipsisLoc())); Var, From.getEllipsisLoc());
Expr *Init = From.getInitExpr(); Expr *Init = From.getInitExpr();
if (!Init) { if (!Init) {
auto InitResult = performLambdaVarCaptureInitialization( auto InitResult = performLambdaVarCaptureInitialization(
*this, From, *CurField, ArrayIndexVars, ArrayIndexStarts); *this, From, *CurField, ArrayIndexVars, ArrayIndexStarts);
if (InitResult.isInvalid()) if (InitResult.isInvalid())
return ExprError(); return ExprError();
Init = InitResult.get(); Init = InitResult.get();
} else { } else {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaLookup.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) { void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
// Find the common ancestor between the effective context and // Find the common ancestor between the effective context and
// the nominated namespace. // the nominated namespace.
DeclContext *Common = UD->getNominatedNamespace(); DeclContext *Common = UD->getNominatedNamespace();
while (!Common->Encloses(EffectiveDC)) while (!Common->Encloses(EffectiveDC))
Common = Common->getParent(); Common = Common->getParent();
Common = Common->getPrimaryContext(); Common = Common->getPrimaryContext();
list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common)); list.emplace_back(UD->getNominatedNamespace(), Common);
} }
void done() { void done() {
std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator()); std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
} }
typedef ListTy::const_iterator const_iterator; typedef ListTy::const_iterator const_iterator;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaOpenMP.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!CurContext->isDependentContext() && if (!CurContext->isDependentContext() &&
DSAStack->getParentOrderedRegionParam() && DSAStack->getParentOrderedRegionParam() &&
DepCounter != DSAStack->isParentLoopControlVariable(D).first) { DepCounter != DSAStack->isParentLoopControlVariable(D).first) {
Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration) Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration)
<< DSAStack->getParentLoopControlVariable( << DSAStack->getParentLoopControlVariable(
DepCounter.getZExtValue()); DepCounter.getZExtValue());
continue; continue;
} }
OpsOffs.push_back({RHS, OOK}); OpsOffs.emplace_back(RHS, OOK);
} else { } else {
// OpenMP [2.11.1.1, Restrictions, p.3] // OpenMP [2.11.1.1, Restrictions, p.3]
// A variable that is part of another variable (such as a field of a // A variable that is part of another variable (such as a field of a
// structure) but is not an array element or an array section cannot // structure) but is not an array element or an array section cannot
// appear in a depend clause. // appear in a depend clause.
auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr); auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr);
auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr); auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr); auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
RelevantExpr = CurE; RelevantExpr = CurE;
// If we got a reference to a declaration, we should not expect any array // If we got a reference to a declaration, we should not expect any array
// section before that. // section before that.
AllowUnitySizeArraySection = false; AllowUnitySizeArraySection = false;
AllowWholeSizeArraySection = false; AllowWholeSizeArraySection = false;
// Record the component. // Record the component.
CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent( CurComponents.emplace_back(
CurE, CurE->getDecl())); CurE, CurE->getDecl());
continue; continue;
} }
if (auto *CurE = dyn_cast<MemberExpr>(E)) { if (auto *CurE = dyn_cast<MemberExpr>(E)) {
auto *BaseE = CurE->getBase()->IgnoreParenImpCasts(); auto *BaseE = CurE->getBase()->IgnoreParenImpCasts();
if (isa<CXXThisExpr>(BaseE)) if (isa<CXXThisExpr>(BaseE))
// We found a base expression: this->Val. // We found a base expression: this->Val.
Show All 40 Lines
// OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7] // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7]
// If a list item is an element of a structure, only the rightmost symbol // If a list item is an element of a structure, only the rightmost symbol
// of the variable reference can be an array section. // of the variable reference can be an array section.
// //
AllowUnitySizeArraySection = false; AllowUnitySizeArraySection = false;
AllowWholeSizeArraySection = false; AllowWholeSizeArraySection = false;
// Record the component. // Record the component.
CurComponents.push_back( CurComponents.emplace_back(CurE, FD);
OMPClauseMappableExprCommon::MappableComponent(CurE, FD));
continue; continue;
} }
if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) { if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) {
E = CurE->getBase()->IgnoreParenImpCasts(); E = CurE->getBase()->IgnoreParenImpCasts();
if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) { if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) {
SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name) SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
<< 0 << CurE->getSourceRange(); << 0 << CurE->getSourceRange();
break; break;
} }
// If we got an array subscript that express the whole dimension we // If we got an array subscript that express the whole dimension we
// can have any array expressions before. If it only expressing part of // can have any array expressions before. If it only expressing part of
// the dimension, we can only have unitary-size array expressions. // the dimension, we can only have unitary-size array expressions.
if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE,
E->getType())) E->getType()))
AllowWholeSizeArraySection = false; AllowWholeSizeArraySection = false;
// Record the component - we don't have any declaration associated. // Record the component - we don't have any declaration associated.
CurComponents.push_back( CurComponents.emplace_back(CurE, nullptr);
OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
continue; continue;
} }
if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) { if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) {
E = CurE->getBase()->IgnoreParenImpCasts(); E = CurE->getBase()->IgnoreParenImpCasts();
auto CurType = auto CurType =
OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType(); OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
Show All 31 Lines
// compatible with the properties of the current array section. // compatible with the properties of the current array section.
SemaRef.Diag( SemaRef.Diag(
ELoc, diag::err_array_section_does_not_specify_contiguous_storage) ELoc, diag::err_array_section_does_not_specify_contiguous_storage)
<< CurE->getSourceRange(); << CurE->getSourceRange();
break; break;
} }
// Record the component - we don't have any declaration associated. // Record the component - we don't have any declaration associated.
CurComponents.push_back( CurComponents.emplace_back(CurE, nullptr);
OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
continue; continue;
} }
// If nothing else worked, this is not a valid map clause expression. // If nothing else worked, this is not a valid map clause expression.
SemaRef.Diag(ELoc, SemaRef.Diag(ELoc,
diag::err_omp_expected_named_var_member_or_array_expression) diag::err_omp_expected_named_var_member_or_array_expression)
<< ERange; << ERange;
break; break;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaTemplate.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
DeduceTemplateArguments(Partial, TemplateArgList, Info)) { DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
// Store the failed-deduction information for use in diagnostics, later. // Store the failed-deduction information for use in diagnostics, later.
// TODO: Actually use the failed-deduction info? // TODO: Actually use the failed-deduction info?
FailedCandidates.addCandidate().set( FailedCandidates.addCandidate().set(
DeclAccessPair::make(Template, AS_public), Partial, DeclAccessPair::make(Template, AS_public), Partial,
MakeDeductionFailureInfo(Context, Result, Info)); MakeDeductionFailureInfo(Context, Result, Info));
(void)Result; (void)Result;
} else { } else {
Matched.push_back(PartialSpecMatchResult()); Matched.emplace_back();
Matched.back().Partial = Partial; Matched.back().Partial = Partial;
Matched.back().Args = Info.take(); Matched.back().Args = Info.take();
} }
} }
if (Matched.size() >= 1) { if (Matched.size() >= 1) {
SmallVector<MatchResult, 4>::iterator Best = Matched.begin(); SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
if (Matched.size() == 1) { if (Matched.size() == 1) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaTemplateDeduction.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Result) if (Result)
return Result; return Result;
// Don't track the argument type, since an initializer list has none. // Don't track the argument type, since an initializer list has none.
continue; continue;
} }
// Keep track of the argument type and corresponding parameter index, // Keep track of the argument type and corresponding parameter index,
// so we can check for compatibility between the deduced A and A. // so we can check for compatibility between the deduced A and A.
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, OriginalCallArgs.emplace_back(OrigParamType, ArgIdx-1,
ArgType)); ArgType);
if (TemplateDeductionResult Result if (TemplateDeductionResult Result
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
ParamType, ArgType, ParamType, ArgType,
Info, Deduced, TDF)) Info, Deduced, TDF))
return Result; return Result;
continue; continue;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
if (Result) if (Result)
return Result; return Result;
} else { } else {
// Keep track of the argument type and corresponding argument index, // Keep track of the argument type and corresponding argument index,
// so we can check for compatibility between the deduced A and A. // so we can check for compatibility between the deduced A and A.
if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, OriginalCallArgs.emplace_back(OrigParamType, ArgIdx,
ArgType)); ArgType);
if (TemplateDeductionResult Result if (TemplateDeductionResult Result
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
ParamType, ArgType, Info, ParamType, ArgType, Info,
Deduced, TDF)) Deduced, TDF))
return Result; return Result;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaTemplateInstantiate.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Info)) { Info)) {
// Store the failed-deduction information for use in diagnostics, later. // Store the failed-deduction information for use in diagnostics, later.
// TODO: Actually use the failed-deduction info? // TODO: Actually use the failed-deduction info?
FailedCandidates.addCandidate().set( FailedCandidates.addCandidate().set(
DeclAccessPair::make(Template, AS_public), Partial, DeclAccessPair::make(Template, AS_public), Partial,
MakeDeductionFailureInfo(Context, Result, Info)); MakeDeductionFailureInfo(Context, Result, Info));
(void)Result; (void)Result;
} else { } else {
Matched.push_back(PartialSpecMatchResult()); Matched.emplace_back();
Matched.back().Partial = Partial; Matched.back().Partial = Partial;
Matched.back().Args = Info.take(); Matched.back().Args = Info.take();
} }
} }
// If we're dealing with a member template where the template parameters // If we're dealing with a member template where the template parameters
// have been instantiated, this provides the original template parameters // have been instantiated, this provides the original template parameters
// from which the member template's parameters were instantiated. // from which the member template's parameters were instantiated.
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
if (Function->isDefined()) { if (Function->isDefined()) {
// Let the ASTConsumer know that this function has been explicitly // Let the ASTConsumer know that this function has been explicitly
// instantiated now, and its linkage might have changed. // instantiated now, and its linkage might have changed.
Consumer.HandleTopLevelDecl(DeclGroupRef(Function)); Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
} else if (TSK == TSK_ExplicitInstantiationDefinition) { } else if (TSK == TSK_ExplicitInstantiationDefinition) {
InstantiateFunctionDefinition(PointOfInstantiation, Function); InstantiateFunctionDefinition(PointOfInstantiation, Function);
} else if (TSK == TSK_ImplicitInstantiation) { } else if (TSK == TSK_ImplicitInstantiation) {
PendingLocalImplicitInstantiations.push_back( PendingLocalImplicitInstantiations.emplace_back(std::make_pair(Function, PointOfInstantiation));
std::make_pair(Function, PointOfInstantiation));
} }
} }
} else if (auto *Var = dyn_cast<VarDecl>(D)) { } else if (auto *Var = dyn_cast<VarDecl>(D)) {
if (isa<VarTemplateSpecializationDecl>(Var)) if (isa<VarTemplateSpecializationDecl>(Var))
continue; continue;
if (Var->isStaticDataMember()) { if (Var->isStaticDataMember()) {
MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Sema/SemaTemplateInstantiateDecl.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// If some prior declaration of this function has been used, we need // If some prior declaration of this function has been used, we need
// to instantiate its definition. // to instantiate its definition.
if (!QueuedInstantiation && R->isUsed(false)) { if (!QueuedInstantiation && R->isUsed(false)) {
if (MemberSpecializationInfo *MSInfo = if (MemberSpecializationInfo *MSInfo =
Function->getMemberSpecializationInfo()) { Function->getMemberSpecializationInfo()) {
if (MSInfo->getPointOfInstantiation().isInvalid()) { if (MSInfo->getPointOfInstantiation().isInvalid()) {
SourceLocation Loc = R->getLocation(); // FIXME SourceLocation Loc = R->getLocation(); // FIXME
MSInfo->setPointOfInstantiation(Loc); MSInfo->setPointOfInstantiation(Loc);
SemaRef.PendingLocalImplicitInstantiations.push_back( SemaRef.PendingLocalImplicitInstantiations.emplace_back(std::make_pair(Function, Loc));
std::make_pair(Function, Loc));
QueuedInstantiation = true; QueuedInstantiation = true;
} }
} }
} }
// If some prior declaration of this function was a friend with an // If some prior declaration of this function was a friend with an
// uninstantiated definition, reject it. // uninstantiated definition, reject it.
if (R->getFriendObjectKind()) { if (R->getFriendObjectKind()) {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Try to find a defaulted definition // Try to find a defaulted definition
PatternDecl->isDefined(PatternDecl); PatternDecl->isDefined(PatternDecl);
} }
assert(PatternDecl && "template definition is not a template"); assert(PatternDecl && "template definition is not a template");
// Postpone late parsed template instantiations. // Postpone late parsed template instantiations.
if (PatternDecl->isLateTemplateParsed() && if (PatternDecl->isLateTemplateParsed() &&
!LateTemplateParser) { !LateTemplateParser) {
PendingInstantiations.push_back( PendingInstantiations.emplace_back(std::make_pair(Function, PointOfInstantiation));
std::make_pair(Function, PointOfInstantiation));
return; return;
} }
// If we're performing recursive template instantiation, create our own // If we're performing recursive template instantiation, create our own
// queue of pending implicit instantiations that we will instantiate later, // queue of pending implicit instantiations that we will instantiate later,
// while we're still within our own instantiation context. // while we're still within our own instantiation context.
// This has to happen before LateTemplateParser below is called, so that // This has to happen before LateTemplateParser below is called, so that
// it marks vtables used in late parsed templates as used. // it marks vtables used in late parsed templates as used.
Show All 33 Lines
if (PatternDecl) if (PatternDecl)
Diag(PatternDecl->getLocation(), Diag(PatternDecl->getLocation(),
diag::note_explicit_instantiation_here); diag::note_explicit_instantiation_here);
Function->setInvalidDecl(); Function->setInvalidDecl();
} else if (Function->getTemplateSpecializationKind() } else if (Function->getTemplateSpecializationKind()
== TSK_ExplicitInstantiationDefinition) { == TSK_ExplicitInstantiationDefinition) {
assert(!Recursive); assert(!Recursive);
PendingInstantiations.push_back( PendingInstantiations.emplace_back(std::make_pair(Function, PointOfInstantiation));
std::make_pair(Function, PointOfInstantiation));
} else if (Function->getTemplateSpecializationKind() } else if (Function->getTemplateSpecializationKind()
== TSK_ImplicitInstantiation) { == TSK_ImplicitInstantiation) {
if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) { if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
Diag(PointOfInstantiation, diag::warn_func_template_missing) Diag(PointOfInstantiation, diag::warn_func_template_missing)
<< Function; << Function;
Diag(PatternDecl->getLocation(), diag::note_forward_template_decl); Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
if (getLangOpts().CPlusPlus11) if (getLangOpts().CPlusPlus11)
Diag(PointOfInstantiation, diag::note_inst_declaration_hint) Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
diag::err_explicit_instantiation_undefined_member) diag::err_explicit_instantiation_undefined_member)
<< 2 << Var->getDeclName() << Var->getDeclContext(); << 2 << Var->getDeclName() << Var->getDeclContext();
Diag(PatternDecl->getLocation(), Diag(PatternDecl->getLocation(),
diag::note_explicit_instantiation_here); diag::note_explicit_instantiation_here);
if (VarSpec) if (VarSpec)
Var->setInvalidDecl(); Var->setInvalidDecl();
} else if (Var->getTemplateSpecializationKind() } else if (Var->getTemplateSpecializationKind()
== TSK_ExplicitInstantiationDefinition) { == TSK_ExplicitInstantiationDefinition) {
PendingInstantiations.push_back( PendingInstantiations.emplace_back(std::make_pair(Var, PointOfInstantiation));
std::make_pair(Var, PointOfInstantiation));
} else if (Var->getTemplateSpecializationKind() } else if (Var->getTemplateSpecializationKind()
== TSK_ImplicitInstantiation) { == TSK_ImplicitInstantiation) {
// Warn about missing definition at the end of translation unit. // Warn about missing definition at the end of translation unit.
if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) { if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
Diag(PointOfInstantiation, diag::warn_var_template_missing) Diag(PointOfInstantiation, diag::warn_var_template_missing)
<< Var; << Var;
Diag(PatternDecl->getLocation(), diag::note_forward_template_decl); Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
if (getLangOpts().CPlusPlus11) if (getLangOpts().CPlusPlus11)
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Serialization/ASTReader.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
HFI.IsValid = true; HFI.IsValid = true;
return HFI; return HFI;
} }
void ASTReader::addPendingMacro(IdentifierInfo *II, void ASTReader::addPendingMacro(IdentifierInfo *II,
ModuleFile *M, ModuleFile *M,
uint64_t MacroDirectivesOffset) { uint64_t MacroDirectivesOffset) {
assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset)); PendingMacroIDs[II].emplace_back(M, MacroDirectivesOffset);
} }
void ASTReader::ReadDefinedMacros() { void ASTReader::ReadDefinedMacros() {
// Note that we are loading defined macros. // Note that we are loading defined macros.
Deserializing Macros(this); Deserializing Macros(this);
for (auto &I : llvm::reverse(ModuleMgr)) { for (auto &I : llvm::reverse(ModuleMgr)) {
BitstreamCursor &MacroCursor = I->MacroCursor; BitstreamCursor &MacroCursor = I->MacroCursor;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) { if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
// If we aren't loading a module (which has its own exports), make // If we aren't loading a module (which has its own exports), make
// all of the imported modules visible. // all of the imported modules visible.
// FIXME: Deal with macros-only imports. // FIXME: Deal with macros-only imports.
for (unsigned I = 0, N = Record.size(); I != N; /**/) { for (unsigned I = 0, N = Record.size(); I != N; /**/) {
unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]); unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
SourceLocation Loc = ReadSourceLocation(F, Record, I); SourceLocation Loc = ReadSourceLocation(F, Record, I);
if (GlobalID) if (GlobalID)
ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc)); ImportedModules.emplace_back(GlobalID, Loc);
} }
} }
break; break;
} }
case MACRO_OFFSET: { case MACRO_OFFSET: {
if (F.LocalNumMacros != 0) { if (F.LocalNumMacros != 0) {
Error("duplicate MACRO_OFFSET record in AST file"); Error("duplicate MACRO_OFFSET record in AST file");
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
unsigned Idx = 0; unsigned Idx = 0;
DiagStates.clear(); DiagStates.clear();
assert(!Diag.DiagStates.empty()); assert(!Diag.DiagStates.empty());
DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one. DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
while (Idx < F.PragmaDiagMappings.size()) { while (Idx < F.PragmaDiagMappings.size()) {
SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
unsigned DiagStateID = F.PragmaDiagMappings[Idx++]; unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
if (DiagStateID != 0) { if (DiagStateID != 0) {
Diag.DiagStatePoints.push_back( Diag.DiagStatePoints.emplace_back(DiagStates[DiagStateID-1],
DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1], FullSourceLoc(Loc, SourceMgr));
FullSourceLoc(Loc, SourceMgr)));
continue; continue;
} }
assert(DiagStateID == 0); assert(DiagStateID == 0);
// A new DiagState was created here. // A new DiagState was created here.
Diag.DiagStates.push_back(*Diag.GetCurDiagState()); Diag.DiagStates.push_back(*Diag.GetCurDiagState());
DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back(); DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
DiagStates.push_back(NewState); DiagStates.push_back(NewState);
Diag.DiagStatePoints.push_back( Diag.DiagStatePoints.emplace_back(NewState,
DiagnosticsEngine::DiagStatePoint(NewState, FullSourceLoc(Loc, SourceMgr));
FullSourceLoc(Loc, SourceMgr)));
while (1) { while (1) {
assert(Idx < F.PragmaDiagMappings.size() && assert(Idx < F.PragmaDiagMappings.size() &&
"Invalid data, didn't find '-1' marking end of diag/map pairs"); "Invalid data, didn't find '-1' marking end of diag/map pairs");
if (Idx >= F.PragmaDiagMappings.size()) { if (Idx >= F.PragmaDiagMappings.size()) {
break; // Something is messed up but at least avoid infinite loop in break; // Something is messed up but at least avoid infinite loop in
// release build. // release build.
} }
unsigned DiagID = F.PragmaDiagMappings[Idx++]; unsigned DiagID = F.PragmaDiagMappings[Idx++];
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Serialization/ASTReaderDecl.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
captures.reserve(numCaptures); captures.reserve(numCaptures);
for (unsigned i = 0; i != numCaptures; ++i) { for (unsigned i = 0; i != numCaptures; ++i) {
VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx); VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
unsigned flags = Record[Idx++]; unsigned flags = Record[Idx++];
bool byRef = (flags & 1); bool byRef = (flags & 1);
bool nested = (flags & 2); bool nested = (flags & 2);
Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr); Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr)); captures.emplace_back(decl, byRef, nested, copyExpr);
} }
BD->setCaptures(Reader.getContext(), captures, capturesCXXThis); BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
} }
void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) { void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
VisitDecl(CD); VisitDecl(CD);
unsigned ContextParamPos = Record[Idx++]; unsigned ContextParamPos = Record[Idx++];
CD->setNothrow(Record[Idx++] != 0); CD->setNothrow(Record[Idx++] != 0);
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
T *DAsT = static_cast<T*>(D); T *DAsT = static_cast<T*>(D);
// Note that we need to load local redeclarations of this decl and build a // Note that we need to load local redeclarations of this decl and build a
// decl chain for them. This must happen *after* we perform the preloading // decl chain for them. This must happen *after* we perform the preloading
// above; this ensures that the redeclaration chain is built in the correct // above; this ensures that the redeclaration chain is built in the correct
// order. // order.
if (IsFirstLocalDecl) if (IsFirstLocalDecl)
Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset)); Reader.PendingDeclChains.emplace_back(std::make_pair(DAsT, RedeclOffset));
return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl); return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl);
} }
/// \brief Attempts to merge the given declaration (D) with another declaration /// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity. /// of the same entity.
template<typename T> template<typename T>
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Serialization/ASTReaderStmt.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Read the clobbers. // Read the clobbers.
SmallVector<std::string, 16> ClobbersData; SmallVector<std::string, 16> ClobbersData;
SmallVector<StringRef, 16> Clobbers; SmallVector<StringRef, 16> Clobbers;
ClobbersData.reserve(S->NumClobbers); ClobbersData.reserve(S->NumClobbers);
Clobbers.reserve(S->NumClobbers); Clobbers.reserve(S->NumClobbers);
for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) { for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
ClobbersData.push_back(ReadString(Record, Idx)); ClobbersData.push_back(ReadString(Record, Idx));
Clobbers.push_back(ClobbersData.back()); Clobbers.emplace_back(ClobbersData.back());
} }
// Read the operands. // Read the operands.
unsigned NumOperands = S->NumOutputs + S->NumInputs; unsigned NumOperands = S->NumOutputs + S->NumInputs;
SmallVector<Expr*, 16> Exprs; SmallVector<Expr*, 16> Exprs;
SmallVector<std::string, 16> ConstraintsData; SmallVector<std::string, 16> ConstraintsData;
SmallVector<StringRef, 16> Constraints; SmallVector<StringRef, 16> Constraints;
Exprs.reserve(NumOperands); Exprs.reserve(NumOperands);
ConstraintsData.reserve(NumOperands); ConstraintsData.reserve(NumOperands);
Constraints.reserve(NumOperands); Constraints.reserve(NumOperands);
for (unsigned i = 0; i != NumOperands; ++i) { for (unsigned i = 0; i != NumOperands; ++i) {
Exprs.push_back(cast<Expr>(Reader.ReadSubStmt())); Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
ConstraintsData.push_back(ReadString(Record, Idx)); ConstraintsData.push_back(ReadString(Record, Idx));
Constraints.push_back(ConstraintsData.back()); Constraints.emplace_back(ConstraintsData.back());
} }
S->initialize(Reader.getContext(), AsmStr, AsmToks, S->initialize(Reader.getContext(), AsmStr, AsmToks,
Constraints, Exprs, Clobbers); Constraints, Exprs, Clobbers);
} }
void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
// FIXME: Implement coroutine serialization. // FIXME: Implement coroutine serialization.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
while (Idx < Record.size()) { while (Idx < Record.size()) {
switch ((DesignatorTypes)Record[Idx++]) { switch ((DesignatorTypes)Record[Idx++]) {
case DESIG_FIELD_DECL: { case DESIG_FIELD_DECL: {
FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx); FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
SourceLocation DotLoc SourceLocation DotLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
SourceLocation FieldLoc SourceLocation FieldLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
Designators.push_back(Designator(Field->getIdentifier(), DotLoc, Designators.emplace_back(Field->getIdentifier(), DotLoc,
FieldLoc)); FieldLoc);
Designators.back().setField(Field); Designators.back().setField(Field);
break; break;
} }
case DESIG_FIELD_NAME: { case DESIG_FIELD_NAME: {
const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx); const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
SourceLocation DotLoc SourceLocation DotLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
SourceLocation FieldLoc SourceLocation FieldLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
Designators.push_back(Designator(Name, DotLoc, FieldLoc)); Designators.emplace_back(Name, DotLoc, FieldLoc);
break; break;
} }
case DESIG_ARRAY: { case DESIG_ARRAY: {
unsigned Index = Record[Idx++]; unsigned Index = Record[Idx++];
SourceLocation LBracketLoc SourceLocation LBracketLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
SourceLocation RBracketLoc SourceLocation RBracketLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc)); Designators.emplace_back(Index, LBracketLoc, RBracketLoc);
break; break;
} }
case DESIG_ARRAY_RANGE: { case DESIG_ARRAY_RANGE: {
unsigned Index = Record[Idx++]; unsigned Index = Record[Idx++];
SourceLocation LBracketLoc SourceLocation LBracketLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
SourceLocation EllipsisLoc SourceLocation EllipsisLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
SourceLocation RBracketLoc SourceLocation RBracketLoc
= ReadSourceLocation(Record, Idx); = ReadSourceLocation(Record, Idx);
Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc, Designators.emplace_back(Index, LBracketLoc, EllipsisLoc,
RBracketLoc)); RBracketLoc);
break; break;
} }
} }
} }
E->setDesignators(Reader.getContext(), E->setDesignators(Reader.getContext(),
Designators.data(), Designators.size()); Designators.data(), Designators.size());
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
C->setComponentListSizes(ListSizes); C->setComponentListSizes(ListSizes);
SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
Components.reserve(TotalComponents); Components.reserve(TotalComponents);
for (unsigned i = 0; i < TotalComponents; ++i) { for (unsigned i = 0; i < TotalComponents; ++i) {
Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); Expr *AssociatedExpr = Reader->Reader.ReadSubExpr();
ValueDecl *AssociatedDecl = ValueDecl *AssociatedDecl =
Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx);
Components.push_back(OMPClauseMappableExprCommon::MappableComponent( Components.emplace_back(
AssociatedExpr, AssociatedDecl)); AssociatedExpr, AssociatedDecl);
} }
C->setComponents(Components, ListSizes); C->setComponents(Components, ListSizes);
} }
void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
C->setNumTeams(Reader->Reader.ReadSubExpr()); C->setNumTeams(Reader->Reader.ReadSubExpr());
C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
} }
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
C->setComponentListSizes(ListSizes); C->setComponentListSizes(ListSizes);
SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
Components.reserve(TotalComponents); Components.reserve(TotalComponents);
for (unsigned i = 0; i < TotalComponents; ++i) { for (unsigned i = 0; i < TotalComponents; ++i) {
Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); Expr *AssociatedExpr = Reader->Reader.ReadSubExpr();
ValueDecl *AssociatedDecl = ValueDecl *AssociatedDecl =
Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx);
Components.push_back(OMPClauseMappableExprCommon::MappableComponent( Components.emplace_back(
AssociatedExpr, AssociatedDecl)); AssociatedExpr, AssociatedDecl);
} }
C->setComponents(Components, ListSizes); C->setComponents(Components, ListSizes);
} }
void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) { void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
auto NumVars = C->varlist_size(); auto NumVars = C->varlist_size();
auto UniqueDecls = C->getUniqueDeclarationsNum(); auto UniqueDecls = C->getUniqueDeclarationsNum();
Show All 26 Lines
C->setComponentListSizes(ListSizes); C->setComponentListSizes(ListSizes);
SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
Components.reserve(TotalComponents); Components.reserve(TotalComponents);
for (unsigned i = 0; i < TotalComponents; ++i) { for (unsigned i = 0; i < TotalComponents; ++i) {
Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); Expr *AssociatedExpr = Reader->Reader.ReadSubExpr();
ValueDecl *AssociatedDecl = ValueDecl *AssociatedDecl =
Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx);
Components.push_back(OMPClauseMappableExprCommon::MappableComponent( Components.emplace_back(
AssociatedExpr, AssociatedDecl)); AssociatedExpr, AssociatedDecl);
} }
C->setComponents(Components, ListSizes); C->setComponents(Components, ListSizes);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// OpenMP Directives. // OpenMP Directives.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Serialization/ASTWriter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
RecordData Record; RecordData Record;
for (PreprocessingRecord::iterator E = PPRec.local_begin(), for (PreprocessingRecord::iterator E = PPRec.local_begin(),
EEnd = PPRec.local_end(); EEnd = PPRec.local_end();
E != EEnd; E != EEnd;
(void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
Record.clear(); Record.clear();
PreprocessedEntityOffsets.push_back( PreprocessedEntityOffsets.emplace_back((*E)->getSourceRange(), Stream.GetCurrentBitNo());
PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo()));
if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) { if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
// Record this macro definition's ID. // Record this macro definition's ID.
MacroDefinitions[MD] = NextPreprocessorEntityID; MacroDefinitions[MD] = NextPreprocessorEntityID;
AddIdentifierRef(MD->getName(), Record); AddIdentifierRef(MD->getName(), Record);
Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
continue; continue;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
WriteDeclContextVisibleUpdate(Context.ExternCContext); WriteDeclContextVisibleUpdate(Context.ExternCContext);
// If the translation unit has an anonymous namespace, and we don't already // If the translation unit has an anonymous namespace, and we don't already
// have an update block for it, write it as an update block. // have an update block for it, write it as an update block.
// FIXME: Why do we not do this if there's already an update block? // FIXME: Why do we not do this if there's already an update block?
if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
if (Record.empty()) if (Record.empty())
Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); Record.emplace_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS);
} }
// Add update records for all mangling numbers and static local numbers. // Add update records for all mangling numbers and static local numbers.
// These aren't really update records, but this is a convenient way of // These aren't really update records, but this is a convenient way of
// tagging this rare extra data onto the declarations. // tagging this rare extra data onto the declarations.
for (const auto &Number : Context.MangleNumbers) for (const auto &Number : Context.MangleNumbers)
if (!Number.first->isFromASTFile()) if (!Number.first->isFromASTFile())
DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, DeclUpdates[Number.first].emplace_back(UPD_MANGLING_NUMBER,
Number.second)); Number.second);
for (const auto &Number : Context.StaticLocalNumbers) for (const auto &Number : Context.StaticLocalNumbers)
if (!Number.first->isFromASTFile()) if (!Number.first->isFromASTFile())
DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, DeclUpdates[Number.first].emplace_back(UPD_STATIC_LOCAL_NUMBER,
Number.second)); Number.second);
// Make sure visible decls, added to DeclContexts previously loaded from // Make sure visible decls, added to DeclContexts previously loaded from
// an AST file, are registered for serialization. // an AST file, are registered for serialization.
for (const auto *I : UpdatingVisibleDecls) { for (const auto *I : UpdatingVisibleDecls) {
GetDeclRef(I); GetDeclRef(I);
} }
// Make sure all decls associated with an identifier are registered for // Make sure all decls associated with an identifier are registered for
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
struct ModuleInfo { struct ModuleInfo {
uint64_t ID; uint64_t ID;
Module *M; Module *M;
ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {}
}; };
llvm::SmallVector<ModuleInfo, 64> Imports; llvm::SmallVector<ModuleInfo, 64> Imports;
for (const auto *I : Context.local_imports()) { for (const auto *I : Context.local_imports()) {
assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], Imports.emplace_back(SubmoduleIDs[I->getImportedModule()],
I->getImportedModule())); I->getImportedModule());
} }
if (!Imports.empty()) { if (!Imports.empty()) {
auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
return A.ID < B.ID; return A.ID < B.ID;
}; };
auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) { auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) {
return A.ID == B.ID; return A.ID == B.ID;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
return; return;
if (!isa<CXXMethodDecl>(D)) if (!isa<CXXMethodDecl>(D))
return; return;
// A decl coming from PCH was modified. // A decl coming from PCH was modified.
assert(RD->isCompleteDefinition()); assert(RD->isCompleteDefinition());
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); DeclUpdates[RD].emplace_back(UPD_CXX_ADDED_IMPLICIT_MEMBER, D);
} }
void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) {
assert(!DoneWritingDeclsAndTypes && "Already done writing updates!"); assert(!DoneWritingDeclsAndTypes && "Already done writing updates!");
if (!Chain) return; if (!Chain) return;
Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) {
// If we don't already know the exception specification for this redecl // If we don't already know the exception specification for this redecl
// chain, add an update record for it. // chain, add an update record for it.
if (isUnresolvedExceptionSpec(cast<FunctionDecl>(D) if (isUnresolvedExceptionSpec(cast<FunctionDecl>(D)
->getType() ->getType()
->castAs<FunctionProtoType>() ->castAs<FunctionProtoType>()
->getExceptionSpecType())) ->getExceptionSpecType()))
DeclUpdates[D].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); DeclUpdates[D].emplace_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC);
}); });
} }
void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!Chain) return; if (!Chain) return;
Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) {
DeclUpdates[D].push_back( DeclUpdates[D].emplace_back(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType);
DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType));
}); });
} }
void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD, void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD,
const FunctionDecl *Delete) { const FunctionDecl *Delete) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
assert(Delete && "Not given an operator delete"); assert(Delete && "Not given an operator delete");
if (!Chain) return; if (!Chain) return;
Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) { Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) {
DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, Delete)); DeclUpdates[D].emplace_back(UPD_CXX_RESOLVED_DTOR_DELETE, Delete);
}); });
} }
void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!D->isFromASTFile()) if (!D->isFromASTFile())
return; // Declaration not imported from PCH. return; // Declaration not imported from PCH.
Show All 11 Lines
void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!D->isFromASTFile()) if (!D->isFromASTFile())
return; return;
// Since the actual instantiation is delayed, this really means that we need // Since the actual instantiation is delayed, this really means that we need
// to update the instantiation location. // to update the instantiation location.
DeclUpdates[D].push_back( DeclUpdates[D].emplace_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER,
DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER, D->getMemberSpecializationInfo()->getPointOfInstantiation());
D->getMemberSpecializationInfo()->getPointOfInstantiation()));
} }
void ASTWriter::DefaultArgumentInstantiated(const ParmVarDecl *D) { void ASTWriter::DefaultArgumentInstantiated(const ParmVarDecl *D) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!D->isFromASTFile()) if (!D->isFromASTFile())
return; return;
DeclUpdates[D].push_back( DeclUpdates[D].emplace_back(UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT, D);
DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT, D));
} }
void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
const ObjCInterfaceDecl *IFD) { const ObjCInterfaceDecl *IFD) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!IFD->isFromASTFile()) if (!IFD->isFromASTFile())
return; // Declaration not imported from PCH. return; // Declaration not imported from PCH.
Show All 24 Lines
} }
void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D, void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D,
const Attr *Attr) { const Attr *Attr) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!D->isFromASTFile()) if (!D->isFromASTFile())
return; return;
DeclUpdates[D].push_back( DeclUpdates[D].emplace_back(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr);
DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr));
} }
void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
assert(D->isHidden() && "expected a hidden declaration"); assert(D->isHidden() && "expected a hidden declaration");
DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); DeclUpdates[D].emplace_back(UPD_DECL_EXPORTED, M);
} }
void ASTWriter::AddedAttributeToRecord(const Attr *Attr, void ASTWriter::AddedAttributeToRecord(const Attr *Attr,
const RecordDecl *Record) { const RecordDecl *Record) {
assert(!WritingAST && "Already writing the AST!"); assert(!WritingAST && "Already writing the AST!");
if (!Record->isFromASTFile()) if (!Record->isFromASTFile())
return; return;
DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr)); DeclUpdates[Record].emplace_back(UPD_ADDED_ATTR_TO_RECORD, Attr);
} }
Context not available.

lib/Serialization/ASTWriterDecl.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!Template->isFromASTFile()) if (!Template->isFromASTFile())
return; return;
// We only need to associate the first local declaration of the // We only need to associate the first local declaration of the
// specialization. The other declarations will get pulled in by it. // specialization. The other declarations will get pulled in by it.
if (Writer.getFirstLocalDecl(Specialization) != Specialization) if (Writer.getFirstLocalDecl(Specialization) != Specialization)
return; return;
Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate( Writer.DeclUpdates[Template].emplace_back(
UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization)); UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization);
} }
}; };
} }
void ASTDeclWriter::Visit(Decl *D) { void ASTDeclWriter::Visit(Decl *D) {
DeclVisitor<ASTDeclWriter>::Visit(D); DeclVisitor<ASTDeclWriter>::Visit(D);
// Source locations require array (variable-length) abbreviations. The // Source locations require array (variable-length) abbreviations. The
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
D == D->getMostRecentDecl()) { D == D->getMostRecentDecl()) {
// This is a most recent reopening of the anonymous namespace. If its parent // This is a most recent reopening of the anonymous namespace. If its parent
// is in a previous PCH (or is the TU), mark that parent for update, because // is in a previous PCH (or is the TU), mark that parent for update, because
// the original namespace always points to the latest re-opening of its // the original namespace always points to the latest re-opening of its
// anonymous namespace. // anonymous namespace.
Decl *Parent = cast<Decl>( Decl *Parent = cast<Decl>(
D->getParent()->getRedeclContext()->getPrimaryContext()); D->getParent()->getRedeclContext()->getPrimaryContext());
if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) { if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
Writer.DeclUpdates[Parent].push_back( Writer.DeclUpdates[Parent].emplace_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D);
ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
} }
} }
} }
void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
VisitRedeclarable(D); VisitRedeclarable(D);
VisitNamedDecl(D); VisitNamedDecl(D);
Record.AddSourceLocation(D->getNamespaceLoc()); Record.AddSourceLocation(D->getNamespaceLoc());
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Emit this declaration to the bitstream. // Emit this declaration to the bitstream.
uint64_t Offset = W.Emit(D); uint64_t Offset = W.Emit(D);
// Record the offset for this declaration // Record the offset for this declaration
SourceLocation Loc = D->getLocation(); SourceLocation Loc = D->getLocation();
unsigned Index = ID - FirstDeclID; unsigned Index = ID - FirstDeclID;
if (DeclOffsets.size() == Index) if (DeclOffsets.size() == Index)
DeclOffsets.push_back(DeclOffset(Loc, Offset)); DeclOffsets.emplace_back(Loc, Offset);
else if (DeclOffsets.size() < Index) { else if (DeclOffsets.size() < Index) {
// FIXME: Can/should this happen? // FIXME: Can/should this happen?
DeclOffsets.resize(Index+1); DeclOffsets.resize(Index+1);
DeclOffsets[Index].setLocation(Loc); DeclOffsets[Index].setLocation(Loc);
DeclOffsets[Index].BitOffset = Offset; DeclOffsets[Index].BitOffset = Offset;
} else { } else {
llvm_unreachable("declarations should be emitted in ID order"); llvm_unreachable("declarations should be emitted in ID order");
} }
Show All 24 Lines

lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linespublic:
CastedAllocFinder(ASTContext *Ctx) : CastedAllocFinder(ASTContext *Ctx) :
II_malloc(&Ctx->Idents.get("malloc")), II_malloc(&Ctx->Idents.get("malloc")),
II_calloc(&Ctx->Idents.get("calloc")), II_calloc(&Ctx->Idents.get("calloc")),
II_realloc(&Ctx->Idents.get("realloc")) {} II_realloc(&Ctx->Idents.get("realloc")) {}
void VisitChild(ExprParent Parent, const Stmt *S) { void VisitChild(ExprParent Parent, const Stmt *S) {
TypeCallPair AllocCall = Visit(S); TypeCallPair AllocCall = Visit(S);
if (AllocCall.second && AllocCall.second != S) if (AllocCall.second && AllocCall.second != S)
Calls.push_back(CallRecord(Parent, cast<Expr>(S), AllocCall.first, Calls.emplace_back(Parent, cast<Expr>(S), AllocCall.first,
AllocCall.second)); AllocCall.second);
} }
void VisitChildren(const Stmt *S) { void VisitChildren(const Stmt *S) {
for (const Stmt *Child : S->children()) for (const Stmt *Child : S->children())
if (Child) if (Child)
VisitChild(S, Child); VisitChild(S, Child);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Core/BugReporter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
do { do {
if (Optional<CallExitEnd> CE = P.getAs<CallExitEnd>()) { if (Optional<CallExitEnd> CE = P.getAs<CallExitEnd>()) {
PathDiagnosticCallPiece *C = PathDiagnosticCallPiece *C =
PathDiagnosticCallPiece::construct(N, *CE, SMgr); PathDiagnosticCallPiece::construct(N, *CE, SMgr);
// Record the mapping from call piece to LocationContext. // Record the mapping from call piece to LocationContext.
LCM[&C->path] = CE->getCalleeContext(); LCM[&C->path] = CE->getCalleeContext();
PD.getActivePath().push_front(C); PD.getActivePath().push_front(C);
PD.pushActivePath(&C->path); PD.pushActivePath(&C->path);
CallStack.push_back(StackDiagPair(C, N)); CallStack.emplace_back(C, N);
break; break;
} }
if (Optional<CallEnter> CE = P.getAs<CallEnter>()) { if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
// Flush all locations, and pop the active path. // Flush all locations, and pop the active path.
bool VisitedEntireCall = PD.isWithinCall(); bool VisitedEntireCall = PD.isWithinCall();
PD.popActivePath(); PD.popActivePath();
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
return; return;
} }
if (containsLocation(TopContextLoc, CLoc)) { if (containsLocation(TopContextLoc, CLoc)) {
if (alwaysAdd) { if (alwaysAdd) {
rawAddEdge(NewLoc); rawAddEdge(NewLoc);
if (IsConsumedExpr(CLoc)) { if (IsConsumedExpr(CLoc)) {
CLocs.push_back(ContextLocation(CLoc, /*IsDead=*/true)); CLocs.emplace_back(CLoc, /*IsDead=*/true);
return; return;
} }
} }
CLocs.push_back(ContextLocation(CLoc, /*IsDead=*/IsPostJump)); CLocs.emplace_back(CLoc, /*IsDead=*/IsPostJump);
return; return;
} }
// Context does not contain the location. Flush it. // Context does not contain the location. Flush it.
popLocation(); popLocation();
} }
// If we reach here, there is no enclosing context. Just add the edge. // If we reach here, there is no enclosing context. Just add the edge.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
while (!CLocs.empty()) { while (!CLocs.empty()) {
const PathDiagnosticLocation &TopContextLoc = CLocs.back(); const PathDiagnosticLocation &TopContextLoc = CLocs.back();
// Is the top location context the same as the one for the new location? // Is the top location context the same as the one for the new location?
if (TopContextLoc == L) if (TopContextLoc == L)
return; return;
if (containsLocation(TopContextLoc, L)) { if (containsLocation(TopContextLoc, L)) {
CLocs.push_back(L); CLocs.emplace_back(L);
return; return;
} }
// Context does not contain the location. Flush it. // Context does not contain the location. Flush it.
popLocation(); popLocation();
} }
CLocs.push_back(L); CLocs.emplace_back(L);
} }
// Cone-of-influence: support the reverse propagation of "interesting" symbols // Cone-of-influence: support the reverse propagation of "interesting" symbols
// and values by tracing interesting calculations backwards through evaluated // and values by tracing interesting calculations backwards through evaluated
// expressions along a path. This is probably overly complicated, but the idea // expressions along a path. This is probably overly complicated, but the idea
// is that if an expression computed an "interesting" value, the child // is that if an expression computed an "interesting" value, the child
// expressions are are also likely to be "interesting" as well (which then // expressions are are also likely to be "interesting" as well (which then
// propagates to the values they in turn compute). This reverse propagation // propagates to the values they in turn compute). This reverse propagation
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
PathDiagnosticCallPiece::construct(N, *CE, SM); PathDiagnosticCallPiece::construct(N, *CE, SM);
LCM[&C->path] = CE->getCalleeContext(); LCM[&C->path] = CE->getCalleeContext();
EB.addEdge(C->callReturn, /*AlwaysAdd=*/true, /*IsPostJump=*/true); EB.addEdge(C->callReturn, /*AlwaysAdd=*/true, /*IsPostJump=*/true);
EB.flushLocations(); EB.flushLocations();
PD.getActivePath().push_front(C); PD.getActivePath().push_front(C);
PD.pushActivePath(&C->path); PD.pushActivePath(&C->path);
CallStack.push_back(StackDiagPair(C, N)); CallStack.emplace_back(C, N);
break; break;
} }
// Pop the call hierarchy if we are done walking the contents // Pop the call hierarchy if we are done walking the contents
// of a function call. // of a function call.
if (Optional<CallEnter> CE = P.getAs<CallEnter>()) { if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
// Add an edge to the start of the function. // Add an edge to the start of the function.
const Decl *D = CE->getCalleeContext()->getDecl(); const Decl *D = CE->getCalleeContext()->getDecl();
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Add the edge to the return site. // Add the edge to the return site.
addEdgeToPath(PD.getActivePath(), PrevLoc, C->callReturn, PDB.LC); addEdgeToPath(PD.getActivePath(), PrevLoc, C->callReturn, PDB.LC);
PD.getActivePath().push_front(C); PD.getActivePath().push_front(C);
PrevLoc.invalidate(); PrevLoc.invalidate();
// Make the contents of the call the active path for now. // Make the contents of the call the active path for now.
PD.pushActivePath(&C->path); PD.pushActivePath(&C->path);
CallStack.push_back(StackDiagPair(C, N)); CallStack.emplace_back(C, N);
break; break;
} }
if (Optional<PostStmt> PS = P.getAs<PostStmt>()) { if (Optional<PostStmt> PS = P.getAs<PostStmt>()) {
// For expressions, make sure we propagate the // For expressions, make sure we propagate the
// interesting symbols correctly. // interesting symbols correctly.
if (const Expr *Ex = PS->getStmtAs<Expr>()) if (const Expr *Ex = PS->getStmtAs<Expr>())
reversePropagateIntererstingSymbols(*PDB.getBugReport(), IE, reversePropagateIntererstingSymbols(*PDB.getBugReport(), IE,
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Find the (first) error node in the trimmed graph. We just need to consult // Find the (first) error node in the trimmed graph. We just need to consult
// the node map which maps from nodes in the original graph to nodes // the node map which maps from nodes in the original graph to nodes
// in the new graph. // in the new graph.
llvm::SmallPtrSet<const ExplodedNode *, 32> RemainingNodes; llvm::SmallPtrSet<const ExplodedNode *, 32> RemainingNodes;
for (unsigned i = 0, count = Nodes.size(); i < count; ++i) { for (unsigned i = 0, count = Nodes.size(); i < count; ++i) {
if (const ExplodedNode *NewNode = ForwardMap.lookup(Nodes[i])) { if (const ExplodedNode *NewNode = ForwardMap.lookup(Nodes[i])) {
ReportNodes.push_back(std::make_pair(NewNode, i)); ReportNodes.emplace_back(std::make_pair(NewNode, i));
RemainingNodes.insert(NewNode); RemainingNodes.insert(NewNode);
} }
} }
assert(!RemainingNodes.empty() && "No error node found in the trimmed graph"); assert(!RemainingNodes.empty() && "No error node found in the trimmed graph");
// Perform a forward BFS to find all the shortest paths. // Perform a forward BFS to find all the shortest paths.
std::queue<const ExplodedNode *> WS; std::queue<const ExplodedNode *> WS;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// At this point we know that 'N' is not a sink and it has at least one // At this point we know that 'N' is not a sink and it has at least one
// successor. Use a DFS worklist to find a non-sink end-of-path node. // successor. Use a DFS worklist to find a non-sink end-of-path node.
typedef FRIEC_WLItem WLItem; typedef FRIEC_WLItem WLItem;
typedef SmallVector<WLItem, 10> DFSWorkList; typedef SmallVector<WLItem, 10> DFSWorkList;
llvm::DenseMap<const ExplodedNode *, unsigned> Visited; llvm::DenseMap<const ExplodedNode *, unsigned> Visited;
DFSWorkList WL; DFSWorkList WL;
WL.push_back(errorNode); WL.emplace_back(errorNode);
Visited[errorNode] = 1; Visited[errorNode] = 1;
while (!WL.empty()) { while (!WL.empty()) {
WLItem &WI = WL.back(); WLItem &WI = WL.back();
assert(!WI.N->succ_empty()); assert(!WI.N->succ_empty());
for (; WI.I != WI.E; ++WI.I) { for (; WI.I != WI.E; ++WI.I) {
const ExplodedNode *Succ = *WI.I; const ExplodedNode *Succ = *WI.I;
Show All 10 Lines
// Found a sink? Continue on to the next successor. // Found a sink? Continue on to the next successor.
continue; continue;
} }
// Mark the successor as visited. If it hasn't been explored, // Mark the successor as visited. If it hasn't been explored,
// enqueue it to the DFS worklist. // enqueue it to the DFS worklist.
unsigned &mark = Visited[Succ]; unsigned &mark = Visited[Succ];
if (!mark) { if (!mark) {
mark = 1; mark = 1;
WL.push_back(Succ); WL.emplace_back(Succ);
break; break;
} }
} }
// The worklist may have been cleared at this point. First // The worklist may have been cleared at this point. First
// check if it is empty before checking the last item. // check if it is empty before checking the last item.
if (!WL.empty() && &WL.back() == &WI) if (!WL.empty() && &WL.back() == &WI)
WL.pop_back(); WL.pop_back();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines if (opt.isEnabled())
collected.insert(&*i); collected.insert(&*i);
else else
collected.remove(&*i); collected.remove(&*i);
} }
} }
void CheckerRegistry::addChecker(InitializationFunction fn, StringRef name, void CheckerRegistry::addChecker(InitializationFunction fn, StringRef name,
StringRef desc) { StringRef desc) {
Checkers.push_back(CheckerInfo(fn, name, desc)); Checkers.emplace_back(fn, name, desc);
// Record the presence of the checker in its packages. // Record the presence of the checker in its packages.
StringRef packageName, leafName; StringRef packageName, leafName;
std::tie(packageName, leafName) = name.rsplit(PackageSeparator); std::tie(packageName, leafName) = name.rsplit(PackageSeparator);
while (!leafName.empty()) { while (!leafName.empty()) {
Packages[packageName] += 1; Packages[packageName] += 1;
std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator); std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
ArrayRef<std::string> plugins, ArrayRef<std::string> plugins,
DiagnosticsEngine &diags) { DiagnosticsEngine &diags) {
std::unique_ptr<CheckerManager> checkerMgr( std::unique_ptr<CheckerManager> checkerMgr(
new CheckerManager(langOpts, &opts)); new CheckerManager(langOpts, &opts));
SmallVector<CheckerOptInfo, 8> checkerOpts; SmallVector<CheckerOptInfo, 8> checkerOpts;
for (unsigned i = 0, e = opts.CheckersControlList.size(); i != e; ++i) { for (unsigned i = 0, e = opts.CheckersControlList.size(); i != e; ++i) {
const std::pair<std::string, bool> &opt = opts.CheckersControlList[i]; const std::pair<std::string, bool> &opt = opts.CheckersControlList[i];
checkerOpts.push_back(CheckerOptInfo(opt.first.c_str(), opt.second)); checkerOpts.emplace_back(opt.first.c_str(), opt.second);
} }
ClangCheckerRegistry allCheckers(plugins, &diags); ClangCheckerRegistry allCheckers(plugins, &diags);
allCheckers.initializeManager(*checkerMgr, checkerOpts); allCheckers.initializeManager(*checkerMgr, checkerOpts);
allCheckers.validateCheckerOptions(opts, diags); allCheckers.validateCheckerOptions(opts, diags);
checkerMgr->finishedCheckerRegistration(); checkerMgr->finishedCheckerRegistration();
for (unsigned i = 0, e = checkerOpts.size(); i != e; ++i) { for (unsigned i = 0, e = checkerOpts.size(); i != e; ++i) {
Show All 17 Lines

lib/Support/CommandLine.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
// Positional argument! // Positional argument!
if (ActivePositionalArg) { if (ActivePositionalArg) {
ProvidePositionalOption(ActivePositionalArg, argv[i], i); ProvidePositionalOption(ActivePositionalArg, argv[i], i);
continue; // We are done! continue; // We are done!
} }
if (!PositionalOpts.empty()) { if (!PositionalOpts.empty()) {
PositionalVals.push_back(std::make_pair(argv[i], i)); PositionalVals.emplace_back(std::make_pair(argv[i], i));
// All of the positional arguments have been fulfulled, give the rest to // All of the positional arguments have been fulfulled, give the rest to
// the consume after option... if it's specified... // the consume after option... if it's specified...
// //
if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) { if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {
for (++i; i < argc; ++i) for (++i; i < argc; ++i)
PositionalVals.push_back(std::make_pair(argv[i], i)); PositionalVals.emplace_back(std::make_pair(argv[i], i));
break; // Handle outside of the argument processing loop... break; // Handle outside of the argument processing loop...
} }
// Delay processing positional arguments until the end... // Delay processing positional arguments until the end...
continue; continue;
} }
} else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
!DashDashFound) { !DashDashFound) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Support/SourceMgr.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Ignore pieces of the range that go onto other lines. // Ignore pieces of the range that go onto other lines.
if (R.Start.getPointer() < LineStart) if (R.Start.getPointer() < LineStart)
R.Start = SMLoc::getFromPointer(LineStart); R.Start = SMLoc::getFromPointer(LineStart);
if (R.End.getPointer() > LineEnd) if (R.End.getPointer() > LineEnd)
R.End = SMLoc::getFromPointer(LineEnd); R.End = SMLoc::getFromPointer(LineEnd);
// Translate from SMLoc ranges to column ranges. // Translate from SMLoc ranges to column ranges.
// FIXME: Handle multibyte characters. // FIXME: Handle multibyte characters.
ColRanges.push_back(std::make_pair(R.Start.getPointer()-LineStart, ColRanges.emplace_back(std::make_pair(R.Start.getPointer()-LineStart,
R.End.getPointer()-LineStart)); R.End.getPointer()-LineStart));
} }
LineAndCol = getLineAndColumn(Loc, CurBuf); LineAndCol = getLineAndColumn(Loc, CurBuf);
} }
return SMDiagnostic(*this, Loc, BufferID, LineAndCol.first, return SMDiagnostic(*this, Loc, BufferID, LineAndCol.first,
LineAndCol.second-1, Kind, Msg.str(), LineAndCol.second-1, Kind, Msg.str(),
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Support/TargetRegistry.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const std::pair<StringRef, const Target *> *RHS) { const std::pair<StringRef, const Target *> *RHS) {
return LHS->first.compare(RHS->first); return LHS->first.compare(RHS->first);
} }
void TargetRegistry::printRegisteredTargetsForVersion() { void TargetRegistry::printRegisteredTargetsForVersion() {
std::vector<std::pair<StringRef, const Target*> > Targets; std::vector<std::pair<StringRef, const Target*> > Targets;
size_t Width = 0; size_t Width = 0;
for (const auto &T : TargetRegistry::targets()) { for (const auto &T : TargetRegistry::targets()) {
Targets.push_back(std::make_pair(T.getName(), &T)); Targets.emplace_back(std::make_pair(T.getName(), &T));
Width = std::max(Width, Targets.back().first.size()); Width = std::max(Width, Targets.back().first.size());
} }
array_pod_sort(Targets.begin(), Targets.end(), TargetArraySortFn); array_pod_sort(Targets.begin(), Targets.end(), TargetArraySortFn);
raw_ostream &OS = outs(); raw_ostream &OS = outs();
OS << " Registered Targets:\n"; OS << " Registered Targets:\n";
for (unsigned i = 0, e = Targets.size(); i != e; ++i) { for (unsigned i = 0, e = Targets.size(); i != e; ++i) {
OS << " " << Targets[i].first; OS << " " << Targets[i].first;
OS.indent(Width - Targets[i].first.size()) << " - " OS.indent(Width - Targets[i].first.size()) << " - "
<< Targets[i].second->getShortDescription() << '\n'; << Targets[i].second->getShortDescription() << '\n';
} }
if (Targets.empty()) if (Targets.empty())
OS << " (none)\n"; OS << " (none)\n";
} }
Context not available.

lib/TableGen/TGParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!List) { if (!List) {
Error(Loc, "Loop list is not a list"); Error(Loc, "Loop list is not a list");
return true; return true;
} }
// Process each value. // Process each value.
for (unsigned i = 0; i < List->size(); ++i) { for (unsigned i = 0; i < List->size(); ++i) {
Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i); Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i);
IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal)); IterVals.emplace_back(CurLoop.IterVar, ItemVal);
if (ProcessForeachDefs(CurRec, Loc, IterVals)) if (ProcessForeachDefs(CurRec, Loc, IterVals))
return true; return true;
IterVals.pop_back(); IterVals.pop_back();
} }
return false; return false;
} }
// This is the bottom of the recursion. We have all of the iterator values // This is the bottom of the recursion. We have all of the iterator values
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
if (!IterName) if (!IterName)
return TokError("expected declaration in for"); return TokError("expected declaration in for");
if (Lex.getCode() != tgtok::In) if (Lex.getCode() != tgtok::In)
return TokError("Unknown tok"); return TokError("Unknown tok");
Lex.Lex(); // Eat the in Lex.Lex(); // Eat the in
// Create a loop object and remember it. // Create a loop object and remember it.
Loops.push_back(ForeachLoop(IterName, ListValue)); Loops.emplace_back(IterName, ListValue);
if (Lex.getCode() != tgtok::l_brace) { if (Lex.getCode() != tgtok::l_brace) {
// FOREACH Declaration IN Object // FOREACH Declaration IN Object
if (ParseObject(CurMultiClass)) if (ParseObject(CurMultiClass))
return true; return true;
} else { } else {
SMLoc BraceLoc = Lex.getLoc(); SMLoc BraceLoc = Lex.getLoc();
// Otherwise, this is a group foreach. // Otherwise, this is a group foreach.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64ISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(L->getBasePtr())) if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(L->getBasePtr()))
if (FI->getIndex() < 0) { if (FI->getIndex() < 0) {
int64_t InFirstByte = MFI->getObjectOffset(FI->getIndex()); int64_t InFirstByte = MFI->getObjectOffset(FI->getIndex());
int64_t InLastByte = InFirstByte; int64_t InLastByte = InFirstByte;
InLastByte += MFI->getObjectSize(FI->getIndex()) - 1; InLastByte += MFI->getObjectSize(FI->getIndex()) - 1;
if ((InFirstByte <= FirstByte && FirstByte <= InLastByte) || if ((InFirstByte <= FirstByte && FirstByte <= InLastByte) ||
(FirstByte <= InFirstByte && InFirstByte <= LastByte)) (FirstByte <= InFirstByte && InFirstByte <= LastByte))
ArgChains.push_back(SDValue(L, 1)); ArgChains.emplace_back(L, 1);
} }
// Build a tokenfactor for all the chains. // Build a tokenfactor for all the chains.
return DAG.getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains); return DAG.getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains);
} }
bool AArch64TargetLowering::DoesCalleeRestoreStack(CallingConv::ID CallCC, bool AArch64TargetLowering::DoesCalleeRestoreStack(CallingConv::ID CallCC,
bool TailCallOpt) const { bool TailCallOpt) const {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
SDVTList SDTys = DAG.getVTList(Tys); SDVTList SDTys = DAG.getVTList(Tys);
unsigned NewOp = IsLaneOp ? AArch64ISD::LD1LANEpost : AArch64ISD::LD1DUPpost; unsigned NewOp = IsLaneOp ? AArch64ISD::LD1LANEpost : AArch64ISD::LD1DUPpost;
SDValue UpdN = DAG.getMemIntrinsicNode(NewOp, SDLoc(N), SDTys, Ops, SDValue UpdN = DAG.getMemIntrinsicNode(NewOp, SDLoc(N), SDTys, Ops,
MemVT, MemVT,
LoadSDN->getMemOperand()); LoadSDN->getMemOperand());
// Update the uses. // Update the uses.
SmallVector<SDValue, 2> NewResults; SmallVector<SDValue, 2> NewResults;
NewResults.push_back(SDValue(LD, 0)); // The result of load NewResults.emplace_back(LD, 0); // The result of load
NewResults.push_back(SDValue(UpdN.getNode(), 2)); // Chain NewResults.emplace_back(UpdN.getNode(), 2); // Chain
DCI.CombineTo(LD, NewResults); DCI.CombineTo(LD, NewResults);
DCI.CombineTo(N, SDValue(UpdN.getNode(), 0)); // Dup/Inserted Result DCI.CombineTo(N, SDValue(UpdN.getNode(), 0)); // Dup/Inserted Result
DCI.CombineTo(User, SDValue(UpdN.getNode(), 1)); // Write back register DCI.CombineTo(User, SDValue(UpdN.getNode(), 1)); // Write back register
break; break;
} }
return SDValue(); return SDValue();
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N); MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N);
SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, SDLoc(N), SDTys, Ops, SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, SDLoc(N), SDTys, Ops,
MemInt->getMemoryVT(), MemInt->getMemoryVT(),
MemInt->getMemOperand()); MemInt->getMemOperand());
// Update the uses. // Update the uses.
std::vector<SDValue> NewResults; std::vector<SDValue> NewResults;
for (unsigned i = 0; i < NumResultVecs; ++i) { for (unsigned i = 0; i < NumResultVecs; ++i) {
NewResults.push_back(SDValue(UpdN.getNode(), i)); NewResults.emplace_back(UpdN.getNode(), i);
} }
NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs + 1)); NewResults.emplace_back(UpdN.getNode(), NumResultVecs + 1);
DCI.CombineTo(N, NewResults); DCI.CombineTo(N, NewResults);
DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs)); DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
break; break;
} }
return SDValue(); return SDValue();
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/R600EmitClauseMarkers.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Consts[i].first->getReg() != AMDGPU::ALU_CONST) if (Consts[i].first->getReg() != AMDGPU::ALU_CONST)
continue; continue;
unsigned Sel = Consts[i].second; unsigned Sel = Consts[i].second;
unsigned Chan = Sel & 3, Index = ((Sel >> 2) - 512) & 31; unsigned Chan = Sel & 3, Index = ((Sel >> 2) - 512) & 31;
unsigned KCacheIndex = Index * 4 + Chan; unsigned KCacheIndex = Index * 4 + Chan;
const std::pair<unsigned, unsigned> &BankLine = getAccessedBankLine(Sel); const std::pair<unsigned, unsigned> &BankLine = getAccessedBankLine(Sel);
if (CachedConsts.empty()) { if (CachedConsts.empty()) {
CachedConsts.push_back(BankLine); CachedConsts.push_back(BankLine);
UsedKCache.push_back(std::pair<unsigned, unsigned>(0, KCacheIndex)); UsedKCache.emplace_back(0, KCacheIndex);
continue; continue;
} }
if (CachedConsts[0] == BankLine) { if (CachedConsts[0] == BankLine) {
UsedKCache.push_back(std::pair<unsigned, unsigned>(0, KCacheIndex)); UsedKCache.emplace_back(0, KCacheIndex);
continue; continue;
} }
if (CachedConsts.size() == 1) { if (CachedConsts.size() == 1) {
CachedConsts.push_back(BankLine); CachedConsts.push_back(BankLine);
UsedKCache.push_back(std::pair<unsigned, unsigned>(1, KCacheIndex)); UsedKCache.emplace_back(1, KCacheIndex);
continue; continue;
} }
if (CachedConsts[1] == BankLine) { if (CachedConsts[1] == BankLine) {
UsedKCache.push_back(std::pair<unsigned, unsigned>(1, KCacheIndex)); UsedKCache.emplace_back(1, KCacheIndex);
continue; continue;
} }
return false; return false;
} }
if (!UpdateInstr) if (!UpdateInstr)
return true; return true;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/R600InstrInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
MachineOperand &Operand = MI->getOperand( MachineOperand &Operand = MI->getOperand(
getOperandIdx(MI->getOpcode(), AMDGPU::OpName::literal)); getOperandIdx(MI->getOpcode(), AMDGPU::OpName::literal));
if (Operand.isImm()) { if (Operand.isImm()) {
Result.push_back(std::make_pair(&MO, Operand.getImm())); Result.push_back(std::make_pair(&MO, Operand.getImm()));
continue; continue;
} }
assert(Operand.isGlobal()); assert(Operand.isGlobal());
} }
Result.push_back(std::make_pair(&MO, 0)); Result.emplace_back(std::make_pair(&MO, 0));
} }
return Result; return Result;
} }
std::vector<std::pair<int, unsigned> > std::vector<std::pair<int, unsigned> >
R600InstrInfo::ExtractSrcs(MachineInstr *MI, R600InstrInfo::ExtractSrcs(MachineInstr *MI,
const DenseMap<unsigned, unsigned> &PV, const DenseMap<unsigned, unsigned> &PV,
unsigned &ConstCount) const { unsigned &ConstCount) const {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
RegSeqInfo *ToMerge, std::vector< std::pair<unsigned, unsigned> > &Remap) RegSeqInfo *ToMerge, std::vector< std::pair<unsigned, unsigned> > &Remap)
const { const {
unsigned CurrentUndexIdx = 0; unsigned CurrentUndexIdx = 0;
for (DenseMap<unsigned, unsigned>::iterator It = ToMerge->RegToChan.begin(), for (DenseMap<unsigned, unsigned>::iterator It = ToMerge->RegToChan.begin(),
E = ToMerge->RegToChan.end(); It != E; ++It) { E = ToMerge->RegToChan.end(); It != E; ++It) {
DenseMap<unsigned, unsigned>::const_iterator PosInUntouched = DenseMap<unsigned, unsigned>::const_iterator PosInUntouched =
Untouched->RegToChan.find((*It).first); Untouched->RegToChan.find((*It).first);
if (PosInUntouched != Untouched->RegToChan.end()) { if (PosInUntouched != Untouched->RegToChan.end()) {
Remap.push_back(std::pair<unsigned, unsigned> Remap.emplace_back((*It).second, (*PosInUntouched).second);
((*It).second, (*PosInUntouched).second));
continue; continue;
} }
if (CurrentUndexIdx >= Untouched->UndefReg.size()) if (CurrentUndexIdx >= Untouched->UndefReg.size())
return false; return false;
Remap.push_back(std::pair<unsigned, unsigned> Remap.emplace_back((*It).second, Untouched->UndefReg[CurrentUndexIdx++]);
((*It).second, Untouched->UndefReg[CurrentUndexIdx++]));
} }
return true; return true;
} }
static static
unsigned getReassignedChan( unsigned getReassignedChan(
const std::vector<std::pair<unsigned, unsigned> > &RemapChan, const std::vector<std::pair<unsigned, unsigned> > &RemapChan,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/SIFoldOperands.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!CanCommute || if (!CanCommute ||
!TII->commuteInstruction(MI, false, CommuteIdx0, CommuteIdx1)) !TII->commuteInstruction(MI, false, CommuteIdx0, CommuteIdx1))
return false; return false;
if (!TII->isOperandLegal(MI, OpNo, OpToFold)) if (!TII->isOperandLegal(MI, OpNo, OpToFold))
return false; return false;
} }
FoldList.push_back(FoldCandidate(MI, OpNo, OpToFold)); FoldList.emplace_back(MI, OpNo, OpToFold);
return true; return true;
} }
static void foldOperand(MachineOperand &OpToFold, MachineInstr *UseMI, static void foldOperand(MachineOperand &OpToFold, MachineInstr *UseMI,
unsigned UseOpIdx, unsigned UseOpIdx,
std::vector<FoldCandidate> &FoldList, std::vector<FoldCandidate> &FoldList,
SmallVectorImpl<MachineInstr *> &CopiesToReplace, SmallVectorImpl<MachineInstr *> &CopiesToReplace,
const SIInstrInfo *TII, const SIRegisterInfo &TRI, const SIInstrInfo *TII, const SIRegisterInfo &TRI,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/SIISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
for (unsigned i = 0; i < Node->getNumOperands(); ++i) { for (unsigned i = 0; i < Node->getNumOperands(); ++i) {
if (!isFrameIndexOp(Node->getOperand(i))) { if (!isFrameIndexOp(Node->getOperand(i))) {
Ops.push_back(Node->getOperand(i)); Ops.push_back(Node->getOperand(i));
continue; continue;
} }
SDLoc DL(Node); SDLoc DL(Node);
Ops.push_back(SDValue(DAG.getMachineNode(AMDGPU::S_MOV_B32, DL, Ops.emplace_back(DAG.getMachineNode(AMDGPU::S_MOV_B32, DL,
Node->getOperand(i).getValueType(), Node->getOperand(i).getValueType(),
Node->getOperand(i)), 0)); Node->getOperand(i)), 0);
} }
DAG.UpdateNodeOperands(Node, Ops); DAG.UpdateNodeOperands(Node, Ops);
} }
/// \brief Fold the instructions after selecting them. /// \brief Fold the instructions after selecting them.
SDNode *SITargetLowering::PostISelFolding(MachineSDNode *Node, SDNode *SITargetLowering::PostISelFolding(MachineSDNode *Node,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/AMDGPU/SIWholeQuadMode.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
} }
if (!Flags) if (!Flags)
continue; continue;
} }
Instructions[&MI].Needs = Flags; Instructions[&MI].Needs = Flags;
Worklist.push_back(&MI); Worklist.emplace_back(&MI);
GlobalFlags |= Flags; GlobalFlags |= Flags;
} }
if (WQMOutputs && MBB.succ_empty()) { if (WQMOutputs && MBB.succ_empty()) {
// This is a prolog shader. Make sure we go back to exact mode at the end. // This is a prolog shader. Make sure we go back to exact mode at the end.
Blocks[&MBB].OutNeeds = StateExact; Blocks[&MBB].OutNeeds = StateExact;
Worklist.push_back(&MBB); Worklist.emplace_back(&MBB);
GlobalFlags |= StateExact; GlobalFlags |= StateExact;
} }
} }
return GlobalFlags; return GlobalFlags;
} }
void SIWholeQuadMode::propagateInstruction(const MachineInstr &MI, void SIWholeQuadMode::propagateInstruction(const MachineInstr &MI,
Show All 9 Lines
Instructions[&MI].Needs = StateWQM; Instructions[&MI].Needs = StateWQM;
II.Needs = StateWQM; II.Needs = StateWQM;
} }
// Propagate to block level // Propagate to block level
BI.Needs |= II.Needs; BI.Needs |= II.Needs;
if ((BI.InNeeds | II.Needs) != BI.InNeeds) { if ((BI.InNeeds | II.Needs) != BI.InNeeds) {
BI.InNeeds |= II.Needs; BI.InNeeds |= II.Needs;
Worklist.push_back(&MBB); Worklist.emplace_back(&MBB);
} }
// Propagate backwards within block // Propagate backwards within block
if (const MachineInstr *PrevMI = MI.getPrevNode()) { if (const MachineInstr *PrevMI = MI.getPrevNode()) {
char InNeeds = II.Needs | II.OutNeeds; char InNeeds = II.Needs | II.OutNeeds;
if (!PrevMI->isPHI()) { if (!PrevMI->isPHI()) {
InstrInfo &PrevII = Instructions[PrevMI]; InstrInfo &PrevII = Instructions[PrevMI];
if ((PrevII.OutNeeds | InNeeds) != PrevII.OutNeeds) { if ((PrevII.OutNeeds | InNeeds) != PrevII.OutNeeds) {
PrevII.OutNeeds |= InNeeds; PrevII.OutNeeds |= InNeeds;
Worklist.push_back(PrevMI); Worklist.emplace_back(PrevMI);
} }
} }
} }
// Propagate WQM flag to instruction inputs // Propagate WQM flag to instruction inputs
assert(II.Needs != (StateWQM | StateExact)); assert(II.Needs != (StateWQM | StateExact));
if (II.Needs != StateWQM) if (II.Needs != StateWQM)
return; return;
Show All 22 Lines
// The instruction might also be flagged as NeedExact. This happens when // The instruction might also be flagged as NeedExact. This happens when
// the result of an atomic is used in a WQM computation. In this case, // the result of an atomic is used in a WQM computation. In this case,
// the atomic must not run for helper pixels and the WQM result is // the atomic must not run for helper pixels and the WQM result is
// undefined. // undefined.
if (DefII.Needs != 0) if (DefII.Needs != 0)
continue; continue;
DefII.Needs = StateWQM; DefII.Needs = StateWQM;
Worklist.push_back(DefMI); Worklist.emplace_back(DefMI);
} }
} }
} }
void SIWholeQuadMode::propagateBlock(const MachineBasicBlock &MBB, void SIWholeQuadMode::propagateBlock(const MachineBasicBlock &MBB,
std::vector<WorkItem>& Worklist) { std::vector<WorkItem>& Worklist) {
BlockInfo BI = Blocks[&MBB]; // take a copy to prevent dangling references BlockInfo BI = Blocks[&MBB]; // take a copy to prevent dangling references
// Propagate through instructions // Propagate through instructions
if (!MBB.empty()) { if (!MBB.empty()) {
const MachineInstr *LastMI = &*MBB.rbegin(); const MachineInstr *LastMI = &*MBB.rbegin();
InstrInfo &LastII = Instructions[LastMI]; InstrInfo &LastII = Instructions[LastMI];
if ((LastII.OutNeeds | BI.OutNeeds) != LastII.OutNeeds) { if ((LastII.OutNeeds | BI.OutNeeds) != LastII.OutNeeds) {
LastII.OutNeeds |= BI.OutNeeds; LastII.OutNeeds |= BI.OutNeeds;
Worklist.push_back(LastMI); Worklist.emplace_back(LastMI);
} }
} }
// Predecessor blocks must provide for our WQM/Exact needs. // Predecessor blocks must provide for our WQM/Exact needs.
for (const MachineBasicBlock *Pred : MBB.predecessors()) { for (const MachineBasicBlock *Pred : MBB.predecessors()) {
BlockInfo &PredBI = Blocks[Pred]; BlockInfo &PredBI = Blocks[Pred];
if ((PredBI.OutNeeds | BI.InNeeds) == PredBI.OutNeeds) if ((PredBI.OutNeeds | BI.InNeeds) == PredBI.OutNeeds)
continue; continue;
PredBI.OutNeeds |= BI.InNeeds; PredBI.OutNeeds |= BI.InNeeds;
PredBI.InNeeds |= BI.InNeeds; PredBI.InNeeds |= BI.InNeeds;
Worklist.push_back(Pred); Worklist.emplace_back(Pred);
} }
// All successors must be prepared to accept the same set of WQM/Exact // All successors must be prepared to accept the same set of WQM/Exact
// data. // data.
for (const MachineBasicBlock *Succ : MBB.successors()) { for (const MachineBasicBlock *Succ : MBB.successors()) {
BlockInfo &SuccBI = Blocks[Succ]; BlockInfo &SuccBI = Blocks[Succ];
if ((SuccBI.InNeeds | BI.OutNeeds) == SuccBI.InNeeds) if ((SuccBI.InNeeds | BI.OutNeeds) == SuccBI.InNeeds)
continue; continue;
SuccBI.InNeeds |= BI.OutNeeds; SuccBI.InNeeds |= BI.OutNeeds;
Worklist.push_back(Succ); Worklist.emplace_back(Succ);
} }
} }
char SIWholeQuadMode::analyzeFunction(MachineFunction &MF) { char SIWholeQuadMode::analyzeFunction(MachineFunction &MF) {
std::vector<WorkItem> Worklist; std::vector<WorkItem> Worklist;
char GlobalFlags = scanInstructions(MF, Worklist); char GlobalFlags = scanInstructions(MF, Worklist);
while (!Worklist.empty()) { while (!Worklist.empty()) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/ARM/ARMConstantIslandPass.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
case ARM::t2B: case ARM::t2B:
Bits = 24; Bits = 24;
Scale = 2; Scale = 2;
break; break;
} }
// Record this immediate branch. // Record this immediate branch.
unsigned MaxOffs = ((1 << (Bits-1))-1) * Scale; unsigned MaxOffs = ((1 << (Bits-1))-1) * Scale;
ImmBranches.push_back(ImmBranch(I, MaxOffs, isCond, UOpc)); ImmBranches.emplace_back(I, MaxOffs, isCond, UOpc);
} }
if (Opc == ARM::tPUSH || Opc == ARM::tPOP_RET) if (Opc == ARM::tPUSH || Opc == ARM::tPOP_RET)
PushPopMIs.push_back(I); PushPopMIs.push_back(I);
if (Opc == ARM::CONSTPOOL_ENTRY || Opc == ARM::JUMPTABLE_ADDRS || if (Opc == ARM::CONSTPOOL_ENTRY || Opc == ARM::JUMPTABLE_ADDRS ||
Opc == ARM::JUMPTABLE_INSTS || Opc == ARM::JUMPTABLE_TBB || Opc == ARM::JUMPTABLE_INSTS || Opc == ARM::JUMPTABLE_TBB ||
Opc == ARM::JUMPTABLE_TBH) Opc == ARM::JUMPTABLE_TBH)
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
unsigned CPI = I->getOperand(op).getIndex(); unsigned CPI = I->getOperand(op).getIndex();
if (I->getOperand(op).isJTI()) { if (I->getOperand(op).isJTI()) {
JumpTableUserIndices.insert(std::make_pair(CPI, CPUsers.size())); JumpTableUserIndices.insert(std::make_pair(CPI, CPUsers.size()));
CPI = JumpTableEntryIndices[CPI]; CPI = JumpTableEntryIndices[CPI];
} }
MachineInstr *CPEMI = CPEMIs[CPI]; MachineInstr *CPEMI = CPEMIs[CPI];
unsigned MaxOffs = ((1 << Bits)-1) * Scale; unsigned MaxOffs = ((1 << Bits)-1) * Scale;
CPUsers.push_back(CPUser(I, CPEMI, MaxOffs, NegOk, IsSoImm)); CPUsers.emplace_back(I, CPEMI, MaxOffs, NegOk, IsSoImm);
// Increment corresponding CPEntry reference count. // Increment corresponding CPEntry reference count.
CPEntry *CPE = findConstPoolEntry(CPI, CPEMI); CPEntry *CPE = findConstPoolEntry(CPI, CPEMI);
assert(CPE && "Cannot find a corresponding CPEntry!"); assert(CPE && "Cannot find a corresponding CPEntry!");
CPE->RefCount++; CPE->RefCount++;
// Instructions can only use one CP entry, don't bother scanning the // Instructions can only use one CP entry, don't bother scanning the
// rest of the operands. // rest of the operands.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// machinery has to know about it. // machinery has to know about it.
int UncondBr = isThumb ? ((isThumb2) ? ARM::t2B : ARM::tB) : ARM::B; int UncondBr = isThumb ? ((isThumb2) ? ARM::t2B : ARM::tB) : ARM::B;
if (!isThumb) if (!isThumb)
BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB); BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB);
else else
BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB) BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB)
.addImm(ARMCC::AL).addReg(0); .addImm(ARMCC::AL).addReg(0);
unsigned MaxDisp = getUnconditionalBrDisp(UncondBr); unsigned MaxDisp = getUnconditionalBrDisp(UncondBr);
ImmBranches.push_back(ImmBranch(&UserMBB->back(), ImmBranches.emplace_back(&UserMBB->back(),
MaxDisp, false, UncondBr)); MaxDisp, false, UncondBr);
computeBlockSize(UserMBB); computeBlockSize(UserMBB);
adjustBBOffsetsAfter(UserMBB); adjustBBOffsetsAfter(UserMBB);
return; return;
} }
} }
// What a big block. Find a place within the block to split it. This is a // What a big block. Find a place within the block to split it. This is a
// little tricky on Thumb1 since instructions are 2 bytes and constant pool // little tricky on Thumb1 since instructions are 2 bytes and constant pool
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
// Update internal data structures to account for the newly inserted MBB. // Update internal data structures to account for the newly inserted MBB.
updateForInsertedWaterBlock(NewIsland); updateForInsertedWaterBlock(NewIsland);
// Now that we have an island to add the CPE to, clone the original CPE and // Now that we have an island to add the CPE to, clone the original CPE and
// add it to the island. // add it to the island.
U.HighWaterMark = NewIsland; U.HighWaterMark = NewIsland;
U.CPEMI = BuildMI(NewIsland, DebugLoc(), CPEMI->getDesc()) U.CPEMI = BuildMI(NewIsland, DebugLoc(), CPEMI->getDesc())
.addImm(ID).addOperand(CPEMI->getOperand(1)).addImm(Size); .addImm(ID).addOperand(CPEMI->getOperand(1)).addImm(Size);
CPEntries[CPI].push_back(CPEntry(U.CPEMI, ID, 1)); CPEntries[CPI].emplace_back(U.CPEMI, ID, 1);
++NumCPEs; ++NumCPEs;
// Decrement the old entry, and remove it if refcount becomes 0. // Decrement the old entry, and remove it if refcount becomes 0.
decrementCPEReferenceCount(CPI, CPEMI); decrementCPEReferenceCount(CPI, CPEMI);
// Mark the basic block as aligned as required by the const-pool entry. // Mark the basic block as aligned as required by the const-pool entry.
NewIsland->setAlignment(getCPELogAlign(U.CPEMI)); NewIsland->setAlignment(getCPELogAlign(U.CPEMI));
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back()); BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back());
if (isThumb) if (isThumb)
BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB) BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB)
.addImm(ARMCC::AL).addReg(0); .addImm(ARMCC::AL).addReg(0);
else else
BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB); BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB);
BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back()); BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back());
unsigned MaxDisp = getUnconditionalBrDisp(Br.UncondBr); unsigned MaxDisp = getUnconditionalBrDisp(Br.UncondBr);
ImmBranches.push_back(ImmBranch(&MBB->back(), MaxDisp, false, Br.UncondBr)); ImmBranches.emplace_back(&MBB->back(), MaxDisp, false, Br.UncondBr);
// Remove the old conditional branch. It may or may not still be in MBB. // Remove the old conditional branch. It may or may not still be in MBB.
BBInfo[MI->getParent()->getNumber()].Size -= TII->GetInstSizeInBytes(MI); BBInfo[MI->getParent()->getNumber()].Size -= TII->GetInstSizeInBytes(MI);
MI->eraseFromParent(); MI->eraseFromParent();
adjustBBOffsetsAfter(MBB); adjustBBOffsetsAfter(MBB);
return true; return true;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/ARM/ARMISelDAGToDAG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs; unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
if (!is64BitVector) if (!is64BitVector)
ResTyElts *= 2; ResTyElts *= 2;
ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts); ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
} }
std::vector<EVT> ResTys; std::vector<EVT> ResTys;
ResTys.push_back(ResTy); ResTys.push_back(ResTy);
if (isUpdating) if (isUpdating)
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
ResTys.push_back(MVT::Other); ResTys.emplace_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl); SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32); SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SDNode *VLd; SDNode *VLd;
SmallVector<SDValue, 7> Ops; SmallVector<SDValue, 7> Ops;
// Double registers and VLD1/VLD2 quad registers are directly supported. // Double registers and VLD1/VLD2 quad registers are directly supported.
if (is64BitVector || NumVecs <= 2) { if (is64BitVector || NumVecs <= 2) {
Show All 28 Lines
SDValue ImplDef = SDValue ImplDef =
SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0); SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0);
const SDValue OpsA[] = { MemAddr, Align, Reg0, ImplDef, Pred, Reg0, Chain }; const SDValue OpsA[] = { MemAddr, Align, Reg0, ImplDef, Pred, Reg0, Chain };
SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl, SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
ResTy, AddrTy, MVT::Other, OpsA); ResTy, AddrTy, MVT::Other, OpsA);
Chain = SDValue(VLdA, 2); Chain = SDValue(VLdA, 2);
// Load the odd subregs. // Load the odd subregs.
Ops.push_back(SDValue(VLdA, 1)); Ops.emplace_back(VLdA, 1);
Ops.push_back(Align); Ops.push_back(Align);
if (isUpdating) { if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1); SDValue Inc = N->getOperand(AddrOpIdx + 1);
assert(isa<ConstantSDNode>(Inc.getNode()) && assert(isa<ConstantSDNode>(Inc.getNode()) &&
"only constant post-increment update allowed for VLD3/4"); "only constant post-increment update allowed for VLD3/4");
(void)Inc; (void)Inc;
Ops.push_back(Reg0); Ops.push_back(Reg0);
} }
Ops.push_back(SDValue(VLdA, 0)); Ops.emplace_back(VLdA, 0);
Ops.push_back(Pred); Ops.push_back(Pred);
Ops.push_back(Reg0); Ops.push_back(Reg0);
Ops.push_back(Chain); Ops.push_back(Chain);
VLd = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, Ops); VLd = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, Ops);
} }
// Transfer memoperands. // Transfer memoperands.
MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1); MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
case MVT::v2f64: case MVT::v2f64:
case MVT::v2i64: OpcodeIndex = 3; case MVT::v2i64: OpcodeIndex = 3;
assert(NumVecs == 1 && "v2i64 type only supported for VST1"); assert(NumVecs == 1 && "v2i64 type only supported for VST1");
break; break;
} }
std::vector<EVT> ResTys; std::vector<EVT> ResTys;
if (isUpdating) if (isUpdating)
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
ResTys.push_back(MVT::Other); ResTys.emplace_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl); SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32); SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SmallVector<SDValue, 7> Ops; SmallVector<SDValue, 7> Ops;
// Double registers and VST1/VST2 quad registers are directly supported. // Double registers and VST1/VST2 quad registers are directly supported.
if (is64BitVector || NumVecs <= 2) { if (is64BitVector || NumVecs <= 2) {
SDValue SrcReg; SDValue SrcReg;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
const SDValue OpsA[] = { MemAddr, Align, Reg0, RegSeq, Pred, Reg0, Chain }; const SDValue OpsA[] = { MemAddr, Align, Reg0, RegSeq, Pred, Reg0, Chain };
SDNode *VStA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl, SDNode *VStA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
MemAddr.getValueType(), MemAddr.getValueType(),
MVT::Other, OpsA); MVT::Other, OpsA);
cast<MachineSDNode>(VStA)->setMemRefs(MemOp, MemOp + 1); cast<MachineSDNode>(VStA)->setMemRefs(MemOp, MemOp + 1);
Chain = SDValue(VStA, 1); Chain = SDValue(VStA, 1);
// Store the odd D registers. // Store the odd D registers.
Ops.push_back(SDValue(VStA, 0)); Ops.emplace_back(VStA, 0);
Ops.push_back(Align); Ops.push_back(Align);
if (isUpdating) { if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1); SDValue Inc = N->getOperand(AddrOpIdx + 1);
assert(isa<ConstantSDNode>(Inc.getNode()) && assert(isa<ConstantSDNode>(Inc.getNode()) &&
"only constant post-increment update allowed for VST3/4"); "only constant post-increment update allowed for VST3/4");
(void)Inc; (void)Inc;
Ops.push_back(Reg0); Ops.push_back(Reg0);
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
if (IsLoad) { if (IsLoad) {
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs; unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
if (!is64BitVector) if (!is64BitVector)
ResTyElts *= 2; ResTyElts *= 2;
ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(), ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(),
MVT::i64, ResTyElts)); MVT::i64, ResTyElts));
} }
if (isUpdating) if (isUpdating)
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
ResTys.push_back(MVT::Other); ResTys.emplace_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl); SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32); SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Ops.push_back(MemAddr); Ops.push_back(MemAddr);
Ops.push_back(Align); Ops.push_back(Align);
if (isUpdating) { if (isUpdating) {
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
Ops.push_back(Pred); Ops.push_back(Pred);
Ops.push_back(Reg0); Ops.push_back(Reg0);
Ops.push_back(Chain); Ops.push_back(Chain);
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs; unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
std::vector<EVT> ResTys; std::vector<EVT> ResTys;
ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(), MVT::i64,ResTyElts)); ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(), MVT::i64,ResTyElts));
if (isUpdating) if (isUpdating)
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
ResTys.push_back(MVT::Other); ResTys.emplace_back(MVT::Other);
SDNode *VLdDup = CurDAG->getMachineNode(Opc, dl, ResTys, Ops); SDNode *VLdDup = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
cast<MachineSDNode>(VLdDup)->setMemRefs(MemOp, MemOp + 1); cast<MachineSDNode>(VLdDup)->setMemRefs(MemOp, MemOp + 1);
SuperReg = SDValue(VLdDup, 0); SuperReg = SDValue(VLdDup, 0);
// Extract the subregisters. // Extract the subregisters.
static_assert(ARM::dsub_7 == ARM::dsub_0 + 7, "Unexpected subreg numbering"); static_assert(ARM::dsub_7 == ARM::dsub_0 + 7, "Unexpected subreg numbering");
unsigned SubIdx = ARM::dsub_0; unsigned SubIdx = ARM::dsub_0;
for (unsigned Vec = 0; Vec < NumVecs; ++Vec) for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
bool IsAcquire = IntNo == Intrinsic::arm_ldaexd; bool IsAcquire = IntNo == Intrinsic::arm_ldaexd;
unsigned NewOpc = isThumb ? (IsAcquire ? ARM::t2LDAEXD : ARM::t2LDREXD) unsigned NewOpc = isThumb ? (IsAcquire ? ARM::t2LDAEXD : ARM::t2LDREXD)
: (IsAcquire ? ARM::LDAEXD : ARM::LDREXD); : (IsAcquire ? ARM::LDAEXD : ARM::LDREXD);
// arm_ldrexd returns a i64 value in {i32, i32} // arm_ldrexd returns a i64 value in {i32, i32}
std::vector<EVT> ResTys; std::vector<EVT> ResTys;
if (isThumb) { if (isThumb) {
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
ResTys.push_back(MVT::i32); ResTys.emplace_back(MVT::i32);
} else } else
ResTys.push_back(MVT::Untyped); ResTys.emplace_back(MVT::Untyped);
ResTys.push_back(MVT::Other); ResTys.emplace_back(MVT::Other);
// Place arguments in the right order. // Place arguments in the right order.
SDValue Ops[] = {MemAddr, getAL(CurDAG, dl), SDValue Ops[] = {MemAddr, getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32), Chain}; CurDAG->getRegister(0, MVT::i32), Chain};
SDNode *Ld = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops); SDNode *Ld = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops);
// Transfer memoperands. // Transfer memoperands.
MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1); MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
MemOp[0] = cast<MemIntrinsicSDNode>(N)->getMemOperand(); MemOp[0] = cast<MemIntrinsicSDNode>(N)->getMemOperand();
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
bool isThumb = Subtarget->isThumb() && Subtarget->hasThumb2(); bool isThumb = Subtarget->isThumb() && Subtarget->hasThumb2();
// Place arguments in the right order. // Place arguments in the right order.
SmallVector<SDValue, 7> Ops; SmallVector<SDValue, 7> Ops;
if (isThumb) { if (isThumb) {
Ops.push_back(Val0); Ops.push_back(Val0);
Ops.push_back(Val1); Ops.push_back(Val1);
} else } else
// arm_strexd uses GPRPair. // arm_strexd uses GPRPair.
Ops.push_back(SDValue(createGPRPairNode(MVT::Untyped, Val0, Val1), 0)); Ops.emplace_back(createGPRPairNode(MVT::Untyped, Val0, Val1), 0);
Ops.push_back(MemAddr); Ops.push_back(MemAddr);
Ops.push_back(getAL(CurDAG, dl)); Ops.push_back(getAL(CurDAG, dl));
Ops.push_back(CurDAG->getRegister(0, MVT::i32)); Ops.push_back(CurDAG->getRegister(0, MVT::i32));
Ops.push_back(Chain); Ops.push_back(Chain);
bool IsRelease = IntNo == Intrinsic::arm_stlexd; bool IsRelease = IntNo == Intrinsic::arm_stlexd;
unsigned NewOpc = isThumb ? (IsRelease ? ARM::t2STLEXD : ARM::t2STREXD) unsigned NewOpc = isThumb ? (IsRelease ? ARM::t2STLEXD : ARM::t2STREXD)
: (IsRelease ? ARM::STLEXD : ARM::STREXD); : (IsRelease ? ARM::STLEXD : ARM::STREXD);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/ARM/ARMISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, dl, SDTys, SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, dl, SDTys,
Ops, AlignedVecTy, Ops, AlignedVecTy,
MemN->getMemOperand()); MemN->getMemOperand());
// Update the uses. // Update the uses.
SmallVector<SDValue, 5> NewResults; SmallVector<SDValue, 5> NewResults;
for (unsigned i = 0; i < NumResultVecs; ++i) for (unsigned i = 0; i < NumResultVecs; ++i)
NewResults.push_back(SDValue(UpdN.getNode(), i)); NewResults.emplace_back(UpdN.getNode(), i);
// If this is an non-standard-aligned LOAD, the first result is the loaded // If this is an non-standard-aligned LOAD, the first result is the loaded
// value. Bitcast it to the expected result type. // value. Bitcast it to the expected result type.
if (AlignedVecTy != VecTy && N->getOpcode() == ISD::LOAD) { if (AlignedVecTy != VecTy && N->getOpcode() == ISD::LOAD) {
SDValue &LdVal = NewResults[0]; SDValue &LdVal = NewResults[0];
LdVal = DAG.getNode(ISD::BITCAST, dl, VecTy, LdVal); LdVal = DAG.getNode(ISD::BITCAST, dl, VecTy, LdVal);
} }
NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs+1)); // chain NewResults.emplace_back(UpdN.getNode(), NumResultVecs+1); // chain
DCI.CombineTo(N, NewResults); DCI.CombineTo(N, NewResults);
DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs)); DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
break; break;
} }
return SDValue(); return SDValue();
} }
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
SDNode *User = *UI; SDNode *User = *UI;
DCI.CombineTo(User, SDValue(VLDDup.getNode(), ResNo)); DCI.CombineTo(User, SDValue(VLDDup.getNode(), ResNo));
} }
// Now the vldN-lane intrinsic is dead except for its chain result. // Now the vldN-lane intrinsic is dead except for its chain result.
// Update uses of the chain. // Update uses of the chain.
std::vector<SDValue> VLDDupResults; std::vector<SDValue> VLDDupResults;
for (unsigned n = 0; n < NumVecs; ++n) for (unsigned n = 0; n < NumVecs; ++n)
VLDDupResults.push_back(SDValue(VLDDup.getNode(), n)); VLDDupResults.emplace_back(VLDDup.getNode(), n);
VLDDupResults.push_back(SDValue(VLDDup.getNode(), NumVecs)); VLDDupResults.emplace_back(VLDDup.getNode(), NumVecs);
DCI.CombineTo(VLD, VLDDupResults); DCI.CombineTo(VLD, VLDDupResults);
return true; return true;
} }
/// PerformVDUPLANECombine - Target-specific dag combine xforms for /// PerformVDUPLANECombine - Target-specific dag combine xforms for
/// ARMISD::VDUPLANE. /// ARMISD::VDUPLANE.
static SDValue PerformVDUPLANECombine(SDNode *N, static SDValue PerformVDUPLANECombine(SDNode *N,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/ARM/ARMLoadStoreOptimizer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned PredReg = 0; unsigned PredReg = 0;
ARMCC::CondCodes Pred = getInstrPredicate(*MBBI, PredReg); ARMCC::CondCodes Pred = getInstrPredicate(*MBBI, PredReg);
int Offset = getMemoryOpOffset(MBBI); int Offset = getMemoryOpOffset(MBBI);
if (CurrBase == 0) { if (CurrBase == 0) {
// Start of a new chain. // Start of a new chain.
CurrBase = Base; CurrBase = Base;
CurrOpc = Opcode; CurrOpc = Opcode;
CurrPred = Pred; CurrPred = Pred;
MemOps.push_back(MemOpQueueEntry(MBBI, Offset, Position)); MemOps.emplace_back(MBBI, Offset, Position);
continue; continue;
} }
// Note: No need to match PredReg in the next if. // Note: No need to match PredReg in the next if.
if (CurrOpc == Opcode && CurrBase == Base && CurrPred == Pred) { if (CurrOpc == Opcode && CurrBase == Base && CurrPred == Pred) {
// Watch out for: // Watch out for:
// r4 := ldr [r0, #8] // r4 := ldr [r0, #8]
// r4 := ldr [r0, #4] // r4 := ldr [r0, #4]
// or // or
Show All 11 Lines
} }
} }
} }
} }
if (!Overlap) { if (!Overlap) {
// Check offset and sort memory operation into the current chain. // Check offset and sort memory operation into the current chain.
if (Offset > MemOps.back().Offset) { if (Offset > MemOps.back().Offset) {
MemOps.push_back(MemOpQueueEntry(MBBI, Offset, Position)); MemOps.emplace_back(MBBI, Offset, Position);
continue; continue;
} else { } else {
MemOpQueue::iterator MI, ME; MemOpQueue::iterator MI, ME;
for (MI = MemOps.begin(), ME = MemOps.end(); MI != ME; ++MI) { for (MI = MemOps.begin(), ME = MemOps.end(); MI != ME; ++MI) {
if (Offset < MI->Offset) { if (Offset < MI->Offset) {
// Found a place to insert. // Found a place to insert.
break; break;
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// space for that many. // space for that many.
int EReg = 0; int EReg = 0;
SmallVector<std::pair<unsigned, unsigned>, 16> Registers; SmallVector<std::pair<unsigned, unsigned>, 16> Registers;
// Allow Q regs and just interpret them as the two D sub-registers. // Allow Q regs and just interpret them as the two D sub-registers.
if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) { if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
Reg = getDRegFromQReg(Reg); Reg = getDRegFromQReg(Reg);
EReg = MRI->getEncodingValue(Reg); EReg = MRI->getEncodingValue(Reg);
Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); Registers.emplace_back(EReg, Reg);
++Reg; ++Reg;
} }
const MCRegisterClass *RC; const MCRegisterClass *RC;
if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg)) if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg))
RC = &ARMMCRegisterClasses[ARM::GPRRegClassID]; RC = &ARMMCRegisterClasses[ARM::GPRRegClassID];
else if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg)) else if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg))
RC = &ARMMCRegisterClasses[ARM::DPRRegClassID]; RC = &ARMMCRegisterClasses[ARM::DPRRegClassID];
else if (ARMMCRegisterClasses[ARM::SPRRegClassID].contains(Reg)) else if (ARMMCRegisterClasses[ARM::SPRRegClassID].contains(Reg))
RC = &ARMMCRegisterClasses[ARM::SPRRegClassID]; RC = &ARMMCRegisterClasses[ARM::SPRRegClassID];
else else
return Error(RegLoc, "invalid register in register list"); return Error(RegLoc, "invalid register in register list");
// Store the register. // Store the register.
EReg = MRI->getEncodingValue(Reg); EReg = MRI->getEncodingValue(Reg);
Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); Registers.emplace_back(EReg, Reg);
// This starts immediately after the first register token in the list, // This starts immediately after the first register token in the list,
// so we can see either a comma or a minus (range separator) as a legal // so we can see either a comma or a minus (range separator) as a legal
// next token. // next token.
while (Parser.getTok().is(AsmToken::Comma) || while (Parser.getTok().is(AsmToken::Comma) ||
Parser.getTok().is(AsmToken::Minus)) { Parser.getTok().is(AsmToken::Minus)) {
if (Parser.getTok().is(AsmToken::Minus)) { if (Parser.getTok().is(AsmToken::Minus)) {
Parser.Lex(); // Eat the minus. Parser.Lex(); // Eat the minus.
Show All 14 Lines
// Ranges must go from low to high. // Ranges must go from low to high.
if (MRI->getEncodingValue(Reg) > MRI->getEncodingValue(EndReg)) if (MRI->getEncodingValue(Reg) > MRI->getEncodingValue(EndReg))
return Error(AfterMinusLoc, "bad range in register list"); return Error(AfterMinusLoc, "bad range in register list");
// Add all the registers in the range to the register list. // Add all the registers in the range to the register list.
while (Reg != EndReg) { while (Reg != EndReg) {
Reg = getNextRegister(Reg); Reg = getNextRegister(Reg);
EReg = MRI->getEncodingValue(Reg); EReg = MRI->getEncodingValue(Reg);
Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); Registers.emplace_back(EReg, Reg);
} }
continue; continue;
} }
Parser.Lex(); // Eat the comma. Parser.Lex(); // Eat the comma.
RegLoc = Parser.getTok().getLoc(); RegLoc = Parser.getTok().getLoc();
int OldReg = Reg; int OldReg = Reg;
const AsmToken RegTok = Parser.getTok(); const AsmToken RegTok = Parser.getTok();
Reg = tryParseRegister(); Reg = tryParseRegister();
Show All 20 Lines
") in register list"); ") in register list");
continue; continue;
} }
// VFP register lists must also be contiguous. // VFP register lists must also be contiguous.
if (RC != &ARMMCRegisterClasses[ARM::GPRRegClassID] && if (RC != &ARMMCRegisterClasses[ARM::GPRRegClassID] &&
Reg != OldReg + 1) Reg != OldReg + 1)
return Error(RegLoc, "non-contiguous register range"); return Error(RegLoc, "non-contiguous register range");
EReg = MRI->getEncodingValue(Reg); EReg = MRI->getEncodingValue(Reg);
Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); Registers.emplace_back(EReg, Reg);
if (isQReg) { if (isQReg) {
EReg = MRI->getEncodingValue(++Reg); EReg = MRI->getEncodingValue(++Reg);
Registers.push_back(std::pair<unsigned, unsigned>(EReg, Reg)); Registers.emplace_back(EReg, Reg);
} }
} }
if (Parser.getTok().isNot(AsmToken::RCurly)) if (Parser.getTok().isNot(AsmToken::RCurly))
return Error(Parser.getTok().getLoc(), "'}' expected"); return Error(Parser.getTok().getLoc(), "'}' expected");
SMLoc E = Parser.getTok().getEndLoc(); SMLoc E = Parser.getTok().getEndLoc();
Parser.Lex(); // Eat '}' token. Parser.Lex(); // Eat '}' token.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/Hexagon/HexagonBitSimplify.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
break; break;
} }
if (isBitShuffle(UseI, PR) || isStoreInput(UseI, PR)) if (isBitShuffle(UseI, PR) || isStoreInput(UseI, PR))
GoodUse = true; GoodUse = true;
} }
if (BadUse || !GoodUse) if (BadUse || !GoodUse)
continue; continue;
Phis.push_back(PhiInfo(I, *C.LB)); Phis.emplace_back(I, *C.LB);
} }
DEBUG({ DEBUG({
dbgs() << "Phis: {"; dbgs() << "Phis: {";
for (auto &I : Phis) { for (auto &I : Phis) {
dbgs() << ' ' << PrintReg(I.DefR, HRI) << "=phi(" dbgs() << ' ' << PrintReg(I.DefR, HRI) << "=phi("
<< PrintReg(I.PR.Reg, HRI, I.PR.Sub) << ":b" << I.PB->getNumber() << PrintReg(I.PR.Reg, HRI, I.PR.Sub) << ":b" << I.PB->getNumber()
<< ',' << PrintReg(I.LR.Reg, HRI, I.LR.Sub) << ":b" << ',' << PrintReg(I.LR.Reg, HRI, I.LR.Sub) << ":b"
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
continue; continue;
// Set EP to the epilog block, if it has only 1 predecessor (i.e. the // Set EP to the epilog block, if it has only 1 predecessor (i.e. the
// edge from B to EP is non-critical. // edge from B to EP is non-critical.
if ((*SI)->pred_size() == 1) if ((*SI)->pred_size() == 1)
EB = *SI; EB = *SI;
break; break;
} }
Cand.push_back(LoopCand(&B, PB, EB)); Cand.emplace_back(&B, PB, EB);
} }
bool Changed = false; bool Changed = false;
for (auto &C : Cand) for (auto &C : Cand)
Changed |= processLoop(C); Changed |= processLoop(C);
return Changed; return Changed;
} }
Show All 13 Lines

lib/Target/Hexagon/HexagonFrameLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
int MinOffset = 0; // CS offsets are negative. int MinOffset = 0; // CS offsets are negative.
const SpillSlot *FixedSlots = getCalleeSavedSpillSlots(NumFixed); const SpillSlot *FixedSlots = getCalleeSavedSpillSlots(NumFixed);
for (const SpillSlot *S = FixedSlots; S != FixedSlots+NumFixed; ++S) { for (const SpillSlot *S = FixedSlots; S != FixedSlots+NumFixed; ++S) {
if (!SRegs[S->Reg]) if (!SRegs[S->Reg])
continue; continue;
const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(S->Reg); const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(S->Reg);
int FI = MFI->CreateFixedSpillStackObject(RC->getSize(), S->Offset); int FI = MFI->CreateFixedSpillStackObject(RC->getSize(), S->Offset);
MinOffset = std::min(MinOffset, S->Offset); MinOffset = std::min(MinOffset, S->Offset);
CSI.push_back(CalleeSavedInfo(S->Reg, FI)); CSI.emplace_back(S->Reg, FI);
SRegs[S->Reg] = false; SRegs[S->Reg] = false;
} }
// There can be some registers that don't have fixed slots. For example, // There can be some registers that don't have fixed slots. For example,
// we need to store R0-R3 in functions with exception handling. For each // we need to store R0-R3 in functions with exception handling. For each
// such register, create a non-fixed stack object. // such register, create a non-fixed stack object.
for (int x = SRegs.find_first(); x >= 0; x = SRegs.find_next(x)) { for (int x = SRegs.find_first(); x >= 0; x = SRegs.find_next(x)) {
unsigned R = x; unsigned R = x;
const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(R); const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(R);
int Off = MinOffset - RC->getSize(); int Off = MinOffset - RC->getSize();
unsigned Align = std::min(RC->getAlignment(), getStackAlignment()); unsigned Align = std::min(RC->getAlignment(), getStackAlignment());
assert(isPowerOf2_32(Align)); assert(isPowerOf2_32(Align));
Off &= -Align; Off &= -Align;
int FI = MFI->CreateFixedSpillStackObject(RC->getSize(), Off); int FI = MFI->CreateFixedSpillStackObject(RC->getSize(), Off);
MinOffset = std::min(MinOffset, Off); MinOffset = std::min(MinOffset, Off);
CSI.push_back(CalleeSavedInfo(R, FI)); CSI.emplace_back(R, FI);
SRegs[R] = false; SRegs[R] = false;
} }
DEBUG({ DEBUG({
dbgs() << "CS information: {"; dbgs() << "CS information: {";
for (unsigned i = 0, n = CSI.size(); i < n; ++i) { for (unsigned i = 0, n = CSI.size(); i < n; ++i) {
int FI = CSI[i].getFrameIdx(); int FI = CSI[i].getFrameIdx();
int Off = MFI->getObjectOffset(FI); int Off = MFI->getObjectOffset(FI);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/Hexagon/HexagonGenMux.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Failure || (!CanUp && !CanDown)) if (Failure || (!CanUp && !CanDown))
continue; continue;
MachineOperand *SrcT = (MinX == CI.TrueX) ? Src1 : Src2; MachineOperand *SrcT = (MinX == CI.TrueX) ? Src1 : Src2;
MachineOperand *SrcF = (MinX == CI.FalseX) ? Src1 : Src2; MachineOperand *SrcF = (MinX == CI.FalseX) ? Src1 : Src2;
// Prefer "down", since this will move the MUX farther away from the // Prefer "down", since this will move the MUX farther away from the
// predicate definition. // predicate definition.
MachineBasicBlock::iterator At = CanDown ? Def2 : Def1; MachineBasicBlock::iterator At = CanDown ? Def2 : Def1;
ML.push_back(MuxInfo(At, DR, PR, SrcT, SrcF, Def1, Def2)); ML.emplace_back(At, DR, PR, SrcT, SrcF, Def1, Def2);
} }
for (unsigned I = 0, N = ML.size(); I < N; ++I) { for (unsigned I = 0, N = ML.size(); I < N; ++I) {
MuxInfo &MX = ML[I]; MuxInfo &MX = ML[I];
MachineBasicBlock &B = *MX.At->getParent(); MachineBasicBlock &B = *MX.At->getParent();
DebugLoc DL = MX.At->getDebugLoc(); DebugLoc DL = MX.At->getDebugLoc();
unsigned MxOpc = getMuxOpcode(*MX.SrcT, *MX.SrcF); unsigned MxOpc = getMuxOpcode(*MX.SrcT, *MX.SrcF);
if (!MxOpc) if (!MxOpc)
Show All 27 Lines

lib/Target/Hexagon/HexagonOptAddrMode.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
<< Print<Liveness::RefMap>(phiUse, *DFG) << "\n"); << Print<Liveness::RefMap>(phiUse, *DFG) << "\n");
if (phiUse.size() > 0) { if (phiUse.size() > 0) {
for (auto I : phiUse) { for (auto I : phiUse) {
if (DR != I.first) if (DR != I.first)
continue; continue;
auto phiUseSet = I.second; auto phiUseSet = I.second;
for (auto phiUI : phiUseSet) { for (auto phiUI : phiUseSet) {
NodeAddr<UseNode *> phiUA = DFG->addr<UseNode *>(phiUI); NodeAddr<UseNode *> phiUA = DFG->addr<UseNode *>(phiUI);
UNodeList.push_back(phiUA); UNodeList.emplace_back(phiUA);
} }
} }
} }
} else } else
UNodeList.push_back(UA); UNodeList.emplace_back(UA);
} }
} }
} }
bool HexagonOptAddrMode::analyzeUses(unsigned tfrDefR, bool HexagonOptAddrMode::analyzeUses(unsigned tfrDefR,
const NodeList &UNodeList, const NodeList &UNodeList,
InstrEvalMap &InstrEvalResult, InstrEvalMap &InstrEvalResult,
short &SizeInc) { short &SizeInc) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/Hexagon/MCTargetDesc/HexagonMCDuplexInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
HexagonMCInstrInfo::hasExtenderForIndex(MCB, j - 1), HexagonMCInstrInfo::hasExtenderForIndex(MCB, j - 1),
bisReversable)) { bisReversable)) {
// Get iClass. // Get iClass.
unsigned iClass = iClassOfDuplexPair( unsigned iClass = iClassOfDuplexPair(
getDuplexCandidateGroup(*MCB.getOperand(k).getInst()), getDuplexCandidateGroup(*MCB.getOperand(k).getInst()),
getDuplexCandidateGroup(*MCB.getOperand(j).getInst())); getDuplexCandidateGroup(*MCB.getOperand(j).getInst()));
// Save off pairs for duplex checking. // Save off pairs for duplex checking.
duplexToTry.push_back(DuplexCandidate(j, k, iClass)); duplexToTry.emplace_back(j, k, iClass);
DEBUG(dbgs() << "adding pair: " << j << "," << k << ":" DEBUG(dbgs() << "adding pair: " << j << "," << k << ":"
<< MCB.getOperand(j).getInst()->getOpcode() << "," << MCB.getOperand(j).getInst()->getOpcode() << ","
<< MCB.getOperand(k).getInst()->getOpcode() << "\n"); << MCB.getOperand(k).getInst()->getOpcode() << "\n");
continue; continue;
} else { } else {
DEBUG(dbgs() << "skipping pair: " << j << "," << k << ":" DEBUG(dbgs() << "skipping pair: " << j << "," << k << ":"
<< MCB.getOperand(j).getInst()->getOpcode() << "," << MCB.getOperand(j).getInst()->getOpcode() << ","
<< MCB.getOperand(k).getInst()->getOpcode() << "\n"); << MCB.getOperand(k).getInst()->getOpcode() << "\n");
} }
// Try reverse. // Try reverse.
if (bisReversable) { if (bisReversable) {
if (isOrderedDuplexPair( if (isOrderedDuplexPair(
MCII, *MCB.getOperand(j).getInst(), MCII, *MCB.getOperand(j).getInst(),
HexagonMCInstrInfo::hasExtenderForIndex(MCB, j - 1), HexagonMCInstrInfo::hasExtenderForIndex(MCB, j - 1),
*MCB.getOperand(k).getInst(), *MCB.getOperand(k).getInst(),
HexagonMCInstrInfo::hasExtenderForIndex(MCB, k - 1), HexagonMCInstrInfo::hasExtenderForIndex(MCB, k - 1),
bisReversable)) { bisReversable)) {
// Get iClass. // Get iClass.
unsigned iClass = iClassOfDuplexPair( unsigned iClass = iClassOfDuplexPair(
getDuplexCandidateGroup(*MCB.getOperand(j).getInst()), getDuplexCandidateGroup(*MCB.getOperand(j).getInst()),
getDuplexCandidateGroup(*MCB.getOperand(k).getInst())); getDuplexCandidateGroup(*MCB.getOperand(k).getInst()));
// Save off pairs for duplex checking. // Save off pairs for duplex checking.
duplexToTry.push_back(DuplexCandidate(k, j, iClass)); duplexToTry.emplace_back(k, j, iClass);
DEBUG(dbgs() << "adding pair:" << k << "," << j << ":" DEBUG(dbgs() << "adding pair:" << k << "," << j << ":"
<< MCB.getOperand(j).getInst()->getOpcode() << "," << MCB.getOperand(j).getInst()->getOpcode() << ","
<< MCB.getOperand(k).getInst()->getOpcode() << "\n"); << MCB.getOperand(k).getInst()->getOpcode() << "\n");
} else { } else {
DEBUG(dbgs() << "skipping pair: " << k << "," << j << ":" DEBUG(dbgs() << "skipping pair: " << k << "," << j << ":"
<< MCB.getOperand(j).getInst()->getOpcode() << "," << MCB.getOperand(j).getInst()->getOpcode() << ","
<< MCB.getOperand(k).getInst()->getOpcode() << "\n"); << MCB.getOperand(k).getInst()->getOpcode() << "\n");
} }
} }
} }
} }
return duplexToTry; return duplexToTry;
} }
Context not available.

lib/Target/Hexagon/RDFDeadCode.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Prepare the actual set of ref nodes to remove: ref nodes from Nodes // Prepare the actual set of ref nodes to remove: ref nodes from Nodes
// are included directly, for each InstrNode in Nodes, include the set // are included directly, for each InstrNode in Nodes, include the set
// of all RefNodes from it. // of all RefNodes from it.
NodeList DRNs, DINs; NodeList DRNs, DINs;
for (auto I : Nodes) { for (auto I : Nodes) {
auto BA = DFG.addr<NodeBase*>(I); auto BA = DFG.addr<NodeBase*>(I);
uint16_t Type = BA.Addr->getType(); uint16_t Type = BA.Addr->getType();
if (Type == NodeAttrs::Ref) { if (Type == NodeAttrs::Ref) {
DRNs.push_back(DFG.addr<RefNode*>(I)); DRNs.emplace_back(DFG.addr<RefNode*>(I));
continue; continue;
} }
// If it's a code node, add all ref nodes from it. // If it's a code node, add all ref nodes from it.
uint16_t Kind = BA.Addr->getKind(); uint16_t Kind = BA.Addr->getKind();
if (Kind == NodeAttrs::Stmt || Kind == NodeAttrs::Phi) { if (Kind == NodeAttrs::Stmt || Kind == NodeAttrs::Phi) {
for (auto N : NodeAddr<CodeNode*>(BA).Addr->members(DFG)) for (auto N : NodeAddr<CodeNode*>(BA).Addr->members(DFG))
DRNs.push_back(N); DRNs.push_back(N);
DINs.push_back(DFG.addr<InstrNode*>(I)); DINs.emplace_back(DFG.addr<InstrNode*>(I));
} else { } else {
llvm_unreachable("Unexpected code node"); llvm_unreachable("Unexpected code node");
return false; return false;
} }
} }
// Sort the list so that use nodes are removed first. This makes the // Sort the list so that use nodes are removed first. This makes the
// "unlink" functions a bit faster. // "unlink" functions a bit faster.
Show All 35 Lines

lib/Target/Hexagon/RDFGraph.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
assert(!empty()); assert(!empty());
unsigned P = nextDown(Stack.size()); unsigned P = nextDown(Stack.size());
Stack.resize(P); Stack.resize(P);
} }
// Push a delimiter for block node N on the stack. // Push a delimiter for block node N on the stack.
void DataFlowGraph::DefStack::start_block(NodeId N) { void DataFlowGraph::DefStack::start_block(NodeId N) {
assert(N != 0); assert(N != 0);
Stack.push_back(NodeAddr<DefNode*>(nullptr, N)); Stack.emplace_back(nullptr, N);
} }
// Remove all nodes from the top of the stack, until the delimited for // Remove all nodes from the top of the stack, until the delimited for
// block node N is encountered. Remove the delimiter as well. In effect, // block node N is encountered. Remove the delimiter as well. In effect,
// this will remove from the stack all definitions from block N. // this will remove from the stack all definitions from block N.
void DataFlowGraph::DefStack::clear_block(NodeId N) { void DataFlowGraph::DefStack::clear_block(NodeId N) {
assert(N != 0); assert(N != 0);
unsigned P = Stack.size(); unsigned P = Stack.size();
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// See "getNextRelated" for the meaning of a "related reference". // See "getNextRelated" for the meaning of a "related reference".
NodeList DataFlowGraph::getRelatedRefs(NodeAddr<InstrNode*> IA, NodeList DataFlowGraph::getRelatedRefs(NodeAddr<InstrNode*> IA,
NodeAddr<RefNode*> RA) const { NodeAddr<RefNode*> RA) const {
assert(IA.Id != 0 && RA.Id != 0); assert(IA.Id != 0 && RA.Id != 0);
NodeList Refs; NodeList Refs;
NodeId Start = RA.Id; NodeId Start = RA.Id;
do { do {
Refs.push_back(RA); Refs.emplace_back(RA);
RA = getNextRelated(IA, RA); RA = getNextRelated(IA, RA);
} while (RA.Id != 0 && RA.Id != Start); } while (RA.Id != 0 && RA.Id != Start);
return Refs; return Refs;
} }
// Clear all information in the graph. // Clear all information in the graph.
void DataFlowGraph::reset() { void DataFlowGraph::reset() {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Also, defs reached by DA are now "promoted" to being reached by RD, // Also, defs reached by DA are now "promoted" to being reached by RD,
// so all of them will need to be spliced into the sibling chain where // so all of them will need to be spliced into the sibling chain where
// DA belongs. // DA belongs.
auto getAllNodes = [this] (NodeId N) -> NodeList { auto getAllNodes = [this] (NodeId N) -> NodeList {
NodeList Res; NodeList Res;
while (N) { while (N) {
auto RA = addr<RefNode*>(N); auto RA = addr<RefNode*>(N);
// Keep the nodes in the exact sibling order. // Keep the nodes in the exact sibling order.
Res.push_back(RA); Res.emplace_back(RA);
N = RA.Addr->getSibling(); N = RA.Addr->getSibling();
} }
return Res; return Res;
}; };
NodeList ReachedDefs = getAllNodes(DA.Addr->getReachedDef()); NodeList ReachedDefs = getAllNodes(DA.Addr->getReachedDef());
NodeList ReachedUses = getAllNodes(DA.Addr->getReachedUse()); NodeList ReachedUses = getAllNodes(DA.Addr->getReachedUse());
if (RD == 0) { if (RD == 0) {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lib/Target/Hexagon/RDFLiveness.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// for cases where the reached use is not covered by any of the defs // for cases where the reached use is not covered by any of the defs
// encountered so far: the phi def is needed to expose the liveness // encountered so far: the phi def is needed to expose the liveness
// of that use to the entry of the block. // of that use to the entry of the block.
// Example: // Example:
// phi d1<R3>(,d2,), ... Phi def d1 is covered by d2. // phi d1<R3>(,d2,), ... Phi def d1 is covered by d2.
// d2<R3>(d1,,u3), ... // d2<R3>(d1,,u3), ...
// ..., u3<D1>(d2) This use needs to be live on entry. // ..., u3<D1>(d2) This use needs to be live on entry.
if (FullChain || IsPhi || !RAI.covers(RRs, QR)) if (FullChain || IsPhi || !RAI.covers(RRs, QR))
Ds.push_back(DA); Ds.emplace_back(DA);
} }
RDefs.insert(RDefs.end(), Ds.begin(), Ds.end()); RDefs.insert(RDefs.end(), Ds.begin(), Ds.end());
for (NodeAddr<DefNode*> DA : Ds) { for (NodeAddr<DefNode*> DA : Ds) {
// When collecting a full chain of definitions, do not consider phi // When collecting a full chain of definitions, do not consider phi
// defs to actually define a register. // defs to actually define a register.
uint16_t Flags = DA.Addr->getFlags(); uint16_t Flags = DA.Addr->getFlags();
if (!FullChain || !(Flags & NodeAttrs::PhiRef)) if (!FullChain || !(Flags & NodeAttrs::PhiRef))
if (!(Flags & NodeAttrs::Preserving)) if (!(Flags & NodeAttrs::Preserving))
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/Mips/MipsConstantIslandPass.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
UOpc=Mips::Bimm16; UOpc=Mips::Bimm16;
Bits = 16; Bits = 16;
Scale = 2; Scale = 2;
isCond = true; isCond = true;
break; break;
} }
// Record this immediate branch. // Record this immediate branch.
unsigned MaxOffs = ((1 << (Bits-1))-1) * Scale; unsigned MaxOffs = ((1 << (Bits-1))-1) * Scale;
ImmBranches.push_back(ImmBranch(I, MaxOffs, isCond, UOpc)); ImmBranches.emplace_back(I, MaxOffs, isCond, UOpc);
} }
if (Opc == Mips::CONSTPOOL_ENTRY) if (Opc == Mips::CONSTPOOL_ENTRY)
continue; continue;
// Scan the instructions for constant pool operands. // Scan the instructions for constant pool operands.
for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
Show All 25 Lines
NegOk = true; NegOk = true;
break; break;
} }
// Remember that this is a user of a CP entry. // Remember that this is a user of a CP entry.
unsigned CPI = I->getOperand(op).getIndex(); unsigned CPI = I->getOperand(op).getIndex();
MachineInstr *CPEMI = CPEMIs[CPI]; MachineInstr *CPEMI = CPEMIs[CPI];
unsigned MaxOffs = ((1 << Bits)-1) * Scale; unsigned MaxOffs = ((1 << Bits)-1) * Scale;
unsigned LongFormMaxOffs = ((1 << LongFormBits)-1) * LongFormScale; unsigned LongFormMaxOffs = ((1 << LongFormBits)-1) * LongFormScale;
CPUsers.push_back(CPUser(I, CPEMI, MaxOffs, NegOk, CPUsers.emplace_back(I, CPEMI, MaxOffs, NegOk,
LongFormMaxOffs, LongFormOpcode)); LongFormMaxOffs, LongFormOpcode);
// Increment corresponding CPEntry reference count. // Increment corresponding CPEntry reference count.
CPEntry *CPE = findConstPoolEntry(CPI, CPEMI); CPEntry *CPE = findConstPoolEntry(CPI, CPEMI);
assert(CPE && "Cannot find a corresponding CPEntry!"); assert(CPE && "Cannot find a corresponding CPEntry!");
CPE->RefCount++; CPE->RefCount++;
// Instructions can only use one CP entry, don't bother scanning the // Instructions can only use one CP entry, don't bother scanning the
// rest of the operands. // rest of the operands.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// Add an unconditional branch from UserMBB to fallthrough block. Record // Add an unconditional branch from UserMBB to fallthrough block. Record
// it for branch lengthening; this new branch will not get out of range, // it for branch lengthening; this new branch will not get out of range,
// but if the preceding conditional branch is out of range, the targets // but if the preceding conditional branch is out of range, the targets
// will be exchanged, and the altered branch may be out of range, so the // will be exchanged, and the altered branch may be out of range, so the
// machinery has to know about it. // machinery has to know about it.
int UncondBr = Mips::Bimm16; int UncondBr = Mips::Bimm16;
BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB); BuildMI(UserMBB, DebugLoc(), TII->get(UncondBr)).addMBB(NewMBB);
unsigned MaxDisp = getUnconditionalBrDisp(UncondBr); unsigned MaxDisp = getUnconditionalBrDisp(UncondBr);
ImmBranches.push_back(ImmBranch(&UserMBB->back(), ImmBranches.emplace_back(&UserMBB->back(),
MaxDisp, false, UncondBr)); MaxDisp, false, UncondBr);
BBInfo[UserMBB->getNumber()].Size += Delta; BBInfo[UserMBB->getNumber()].Size += Delta;
adjustBBOffsetsAfter(UserMBB); adjustBBOffsetsAfter(UserMBB);
return; return;
} }
} }
// What a big block. Find a place within the block to split it. // What a big block. Find a place within the block to split it.
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
// We will be generating a new clone. Get a UID for it. // We will be generating a new clone. Get a UID for it.
unsigned ID = createPICLabelUId(); unsigned ID = createPICLabelUId();
// Now that we have an island to add the CPE to, clone the original CPE and // Now that we have an island to add the CPE to, clone the original CPE and
// add it to the island. // add it to the island.
U.HighWaterMark = NewIsland; U.HighWaterMark = NewIsland;
U.CPEMI = BuildMI(NewIsland, DebugLoc(), TII->get(Mips::CONSTPOOL_ENTRY)) U.CPEMI = BuildMI(NewIsland, DebugLoc(), TII->get(Mips::CONSTPOOL_ENTRY))
.addImm(ID).addConstantPoolIndex(CPI).addImm(Size); .addImm(ID).addConstantPoolIndex(CPI).addImm(Size);
CPEntries[CPI].push_back(CPEntry(U.CPEMI, ID, 1)); CPEntries[CPI].emplace_back(U.CPEMI, ID, 1);
++NumCPEs; ++NumCPEs;
// Mark the basic block as aligned as required by the const-pool entry. // Mark the basic block as aligned as required by the const-pool entry.
NewIsland->setAlignment(getCPELogAlign(U.CPEMI)); NewIsland->setAlignment(getCPELogAlign(U.CPEMI));
// Increase the size of the island block to account for the new entry. // Increase the size of the island block to account for the new entry.
BBInfo[NewIsland->getNumber()].Size += Size; BBInfo[NewIsland->getNumber()].Size += Size;
adjustBBOffsetsAfter(&*--NewIsland->getIterator()); adjustBBOffsetsAfter(&*--NewIsland->getIterator());
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
BuildMI(MBB, DebugLoc(), TII->get(OppositeBranchOpcode)) BuildMI(MBB, DebugLoc(), TII->get(OppositeBranchOpcode))
.addMBB(NextBB); .addMBB(NextBB);
} }
Br.MI = &MBB->back(); Br.MI = &MBB->back();
BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back()); BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back());
BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB); BuildMI(MBB, DebugLoc(), TII->get(Br.UncondBr)).addMBB(DestBB);
BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back()); BBInfo[MBB->getNumber()].Size += TII->GetInstSizeInBytes(&MBB->back());
unsigned MaxDisp = getUnconditionalBrDisp(Br.UncondBr); unsigned MaxDisp = getUnconditionalBrDisp(Br.UncondBr);
ImmBranches.push_back(ImmBranch(&MBB->back(), MaxDisp, false, Br.UncondBr)); ImmBranches.emplace_back(&MBB->back(), MaxDisp, false, Br.UncondBr);
// Remove the old conditional branch. It may or may not still be in MBB. // Remove the old conditional branch. It may or may not still be in MBB.
BBInfo[MI->getParent()->getNumber()].Size -= TII->GetInstSizeInBytes(MI); BBInfo[MI->getParent()->getNumber()].Size -= TII->GetInstSizeInBytes(MI);
MI->eraseFromParent(); MI->eraseFromParent();
adjustBBOffsetsAfter(MBB); adjustBBOffsetsAfter(MBB);
return true; return true;
} }
Show All 38 Lines

lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Build the "promoted" result VTList for the load. If we are really loading // Build the "promoted" result VTList for the load. If we are really loading
// i8s, then the return type will be promoted to i16 since we do not expose // i8s, then the return type will be promoted to i16 since we do not expose
// 8-bit registers in NVPTX. // 8-bit registers in NVPTX.
EVT NodeVT = (EltVT == MVT::i8) ? MVT::i16 : EltVT; EVT NodeVT = (EltVT == MVT::i8) ? MVT::i16 : EltVT;
SmallVector<EVT, 5> InstVTs; SmallVector<EVT, 5> InstVTs;
for (unsigned i = 0; i != NumElts; ++i) { for (unsigned i = 0; i != NumElts; ++i) {
InstVTs.push_back(NodeVT); InstVTs.push_back(NodeVT);
} }
InstVTs.push_back(MVT::Other); InstVTs.emplace_back(MVT::Other);
SDVTList InstVTList = CurDAG->getVTList(InstVTs); SDVTList InstVTList = CurDAG->getVTList(InstVTs);
if (SelectDirectAddr(Op1, Addr)) { if (SelectDirectAddr(Op1, Addr)) {
switch (N->getOpcode()) { switch (N->getOpcode()) {
default: default:
return false; return false;
case ISD::INTRINSIC_W_CHAIN: case ISD::INTRINSIC_W_CHAIN:
if (IsLDG) { if (IsLDG) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/NVPTX/NVPTXISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (NumElts == 1) { if (NumElts == 1) {
// Just a simple load // Just a simple load
SmallVector<EVT, 4> LoadRetVTs; SmallVector<EVT, 4> LoadRetVTs;
if (EltVT == MVT::i1 || EltVT == MVT::i8) { if (EltVT == MVT::i1 || EltVT == MVT::i8) {
// If loading i1/i8 result, generate // If loading i1/i8 result, generate
// load.b8 i16 // load.b8 i16
// if i1 // if i1
// trunc i16 to i1 // trunc i16 to i1
LoadRetVTs.push_back(MVT::i16); LoadRetVTs.emplace_back(MVT::i16);
} else } else
LoadRetVTs.push_back(EltVT); LoadRetVTs.push_back(EltVT);
LoadRetVTs.push_back(MVT::Other); LoadRetVTs.emplace_back(MVT::Other);
LoadRetVTs.push_back(MVT::Glue); LoadRetVTs.emplace_back(MVT::Glue);
SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32), SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32),
DAG.getConstant(0, dl, MVT::i32), InFlag}; DAG.getConstant(0, dl, MVT::i32), InFlag};
SDValue retval = DAG.getMemIntrinsicNode( SDValue retval = DAG.getMemIntrinsicNode(
NVPTXISD::LoadParam, dl, NVPTXISD::LoadParam, dl,
DAG.getVTList(LoadRetVTs), LoadRetOps, EltVT, MachinePointerInfo()); DAG.getVTList(LoadRetVTs), LoadRetOps, EltVT, MachinePointerInfo());
Chain = retval.getValue(1); Chain = retval.getValue(1);
InFlag = retval.getValue(2); InFlag = retval.getValue(2);
SDValue Ret0 = retval; SDValue Ret0 = retval;
if (needTruncate) if (needTruncate)
Ret0 = DAG.getNode(ISD::TRUNCATE, dl, EltVT, Ret0); Ret0 = DAG.getNode(ISD::TRUNCATE, dl, EltVT, Ret0);
InVals.push_back(Ret0); InVals.push_back(Ret0);
} else if (NumElts == 2) { } else if (NumElts == 2) {
// LoadV2 // LoadV2
SmallVector<EVT, 4> LoadRetVTs; SmallVector<EVT, 4> LoadRetVTs;
if (EltVT == MVT::i1 || EltVT == MVT::i8) { if (EltVT == MVT::i1 || EltVT == MVT::i8) {
// If loading i1/i8 result, generate // If loading i1/i8 result, generate
// load.b8 i16 // load.b8 i16
// if i1 // if i1
// trunc i16 to i1 // trunc i16 to i1
LoadRetVTs.push_back(MVT::i16); LoadRetVTs.emplace_back(MVT::i16);
LoadRetVTs.push_back(MVT::i16); LoadRetVTs.emplace_back(MVT::i16);
} else { } else {
LoadRetVTs.push_back(EltVT); LoadRetVTs.push_back(EltVT);
LoadRetVTs.push_back(EltVT); LoadRetVTs.push_back(EltVT);
} }
LoadRetVTs.push_back(MVT::Other); LoadRetVTs.emplace_back(MVT::Other);
LoadRetVTs.push_back(MVT::Glue); LoadRetVTs.emplace_back(MVT::Glue);
SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32), SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32),
DAG.getConstant(0, dl, MVT::i32), InFlag}; DAG.getConstant(0, dl, MVT::i32), InFlag};
SDValue retval = DAG.getMemIntrinsicNode( SDValue retval = DAG.getMemIntrinsicNode(
NVPTXISD::LoadParamV2, dl, NVPTXISD::LoadParamV2, dl,
DAG.getVTList(LoadRetVTs), LoadRetOps, EltVT, MachinePointerInfo()); DAG.getVTList(LoadRetVTs), LoadRetOps, EltVT, MachinePointerInfo());
Chain = retval.getValue(2); Chain = retval.getValue(2);
InFlag = retval.getValue(3); InFlag = retval.getValue(3);
SDValue Ret0 = retval.getValue(0); SDValue Ret0 = retval.getValue(0);
Show All 20 Lines
for (unsigned i = 0; i < NumElts; i += VecSize) { for (unsigned i = 0; i < NumElts; i += VecSize) {
SmallVector<EVT, 8> LoadRetVTs; SmallVector<EVT, 8> LoadRetVTs;
if (EltVT == MVT::i1 || EltVT == MVT::i8) { if (EltVT == MVT::i1 || EltVT == MVT::i8) {
// If loading i1/i8 result, generate // If loading i1/i8 result, generate
// load.b8 i16 // load.b8 i16
// if i1 // if i1
// trunc i16 to i1 // trunc i16 to i1
for (unsigned j = 0; j < VecSize; ++j) for (unsigned j = 0; j < VecSize; ++j)
LoadRetVTs.push_back(MVT::i16); LoadRetVTs.emplace_back(MVT::i16);
} else { } else {
for (unsigned j = 0; j < VecSize; ++j) for (unsigned j = 0; j < VecSize; ++j)
LoadRetVTs.push_back(EltVT); LoadRetVTs.push_back(EltVT);
} }
LoadRetVTs.push_back(MVT::Other); LoadRetVTs.emplace_back(MVT::Other);
LoadRetVTs.push_back(MVT::Glue); LoadRetVTs.emplace_back(MVT::Glue);
SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32), SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32),
DAG.getConstant(Ofst, dl, MVT::i32), InFlag}; DAG.getConstant(Ofst, dl, MVT::i32), InFlag};
SDValue retval = DAG.getMemIntrinsicNode( SDValue retval = DAG.getMemIntrinsicNode(
Opc, dl, DAG.getVTList(LoadRetVTs), Opc, dl, DAG.getVTList(LoadRetVTs),
LoadRetOps, EltVT, MachinePointerInfo()); LoadRetOps, EltVT, MachinePointerInfo());
if (VecSize == 2) { if (VecSize == 2) {
Chain = retval.getValue(2); Chain = retval.getValue(2);
InFlag = retval.getValue(3); InFlag = retval.getValue(3);
Show All 28 Lines
needTruncate = true; needTruncate = true;
} }
SmallVector<EVT, 4> LoadRetVTs; SmallVector<EVT, 4> LoadRetVTs;
EVT TheLoadType = VTs[i]; EVT TheLoadType = VTs[i];
if (retTy->isIntegerTy() && DL.getTypeAllocSizeInBits(retTy) < 32) { if (retTy->isIntegerTy() && DL.getTypeAllocSizeInBits(retTy) < 32) {
// This is for integer types only, and specifically not for // This is for integer types only, and specifically not for
// aggregates. // aggregates.
LoadRetVTs.push_back(MVT::i32); LoadRetVTs.emplace_back(MVT::i32);
TheLoadType = MVT::i32; TheLoadType = MVT::i32;
needTruncate = true; needTruncate = true;
} else if (sz < 16) { } else if (sz < 16) {
// If loading i1/i8 result, generate // If loading i1/i8 result, generate
// load i8 (-> i16) // load i8 (-> i16)
// trunc i16 to i1/i8 // trunc i16 to i1/i8
// FIXME: Do we need to set needTruncate to true here, too? We could // FIXME: Do we need to set needTruncate to true here, too? We could
// not figure out what this branch is for in D17872, so we left it // not figure out what this branch is for in D17872, so we left it
// alone. The comment above about loading i1/i8 may be wrong, as the // alone. The comment above about loading i1/i8 may be wrong, as the
// branch above seems to cover integers of size < 32. // branch above seems to cover integers of size < 32.
LoadRetVTs.push_back(MVT::i16); LoadRetVTs.emplace_back(MVT::i16);
} else } else
LoadRetVTs.push_back(Ins[i].VT); LoadRetVTs.emplace_back(Ins[i].VT);
LoadRetVTs.push_back(MVT::Other); LoadRetVTs.emplace_back(MVT::Other);
LoadRetVTs.push_back(MVT::Glue); LoadRetVTs.emplace_back(MVT::Glue);
SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32), SDValue LoadRetOps[] = {Chain, DAG.getConstant(1, dl, MVT::i32),
DAG.getConstant(Offsets[i], dl, MVT::i32), DAG.getConstant(Offsets[i], dl, MVT::i32),
InFlag}; InFlag};
SDValue retval = DAG.getMemIntrinsicNode( SDValue retval = DAG.getMemIntrinsicNode(
NVPTXISD::LoadParam, dl, NVPTXISD::LoadParam, dl,
DAG.getVTList(LoadRetVTs), LoadRetOps, DAG.getVTList(LoadRetVTs), LoadRetOps,
TheLoadType, MachinePointerInfo(), AlignI); TheLoadType, MachinePointerInfo(), AlignI);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
// If this bit has the same underlying value and the same rotate factor as // If this bit has the same underlying value and the same rotate factor as
// the last one, then they're part of the same group. // the last one, then they're part of the same group.
if (ThisRLAmt == LastRLAmt && ThisValue == LastValue) if (ThisRLAmt == LastRLAmt && ThisValue == LastValue)
continue; continue;
if (LastValue.getNode()) if (LastValue.getNode())
BitGroups.push_back(BitGroup(LastValue, LastRLAmt, LastGroupStartIdx, BitGroups.emplace_back(LastValue, LastRLAmt, LastGroupStartIdx,
i-1)); i-1);
LastRLAmt = ThisRLAmt; LastRLAmt = ThisRLAmt;
LastValue = ThisValue; LastValue = ThisValue;
LastGroupStartIdx = i; LastGroupStartIdx = i;
} }
if (LastValue.getNode()) if (LastValue.getNode())
BitGroups.push_back(BitGroup(LastValue, LastRLAmt, LastGroupStartIdx, BitGroups.emplace_back(LastValue, LastRLAmt, LastGroupStartIdx,
Bits.size()-1)); Bits.size()-1);
if (BitGroups.empty()) if (BitGroups.empty())
return; return;
// We might be able to combine the first and last groups. // We might be able to combine the first and last groups.
if (BitGroups.size() > 1) { if (BitGroups.size() > 1) {
// If the first and last groups are the same, then remove the first group // If the first and last groups are the same, then remove the first group
// in favor of the last group, making the ending index of the last group // in favor of the last group, making the ending index of the last group
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
SmallVector<SDValue, 4> Ops; SmallVector<SDValue, 4> Ops;
for (const SDValue &V : PN->ops()) { for (const SDValue &V : PN->ops()) {
if (!ToPromote.count(V.getNode()) && V.getValueType() == MVT::i32 && if (!ToPromote.count(V.getNode()) && V.getValueType() == MVT::i32 &&
!isa<ConstantSDNode>(V)) { !isa<ConstantSDNode>(V)) {
SDValue ReplOpOps[] = { ISR.getOperand(0), V, ISR.getOperand(2) }; SDValue ReplOpOps[] = { ISR.getOperand(0), V, ISR.getOperand(2) };
SDNode *ReplOp = SDNode *ReplOp =
CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, SDLoc(V), CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, SDLoc(V),
ISR.getNode()->getVTList(), ReplOpOps); ISR.getNode()->getVTList(), ReplOpOps);
Ops.push_back(SDValue(ReplOp, 0)); Ops.emplace_back(ReplOp, 0);
} else { } else {
Ops.push_back(V); Ops.push_back(V);
} }
} }
// Because all to-be-promoted nodes only have users that are other // Because all to-be-promoted nodes only have users that are other
// promoted nodes (or the original INSERT_SUBREG), we can safely replace // promoted nodes (or the original INSERT_SUBREG), we can safely replace
// the i32 result value type with i64. // the i32 result value type with i64.
SmallVector<EVT, 2> NewVTs; SmallVector<EVT, 2> NewVTs;
SDVTList VTs = PN->getVTList(); SDVTList VTs = PN->getVTList();
for (unsigned i = 0, ie = VTs.NumVTs; i != ie; ++i) for (unsigned i = 0, ie = VTs.NumVTs; i != ie; ++i)
if (VTs.VTs[i] == MVT::i32) if (VTs.VTs[i] == MVT::i32)
NewVTs.push_back(MVT::i64); NewVTs.emplace_back(MVT::i64);
else else
NewVTs.push_back(VTs.VTs[i]); NewVTs.push_back(VTs.VTs[i]);
DEBUG(dbgs() << "PPC64 ZExt Peephole morphing:\nOld: "); DEBUG(dbgs() << "PPC64 ZExt Peephole morphing:\nOld: ");
DEBUG(PN->dump(CurDAG)); DEBUG(PN->dump(CurDAG));
CurDAG->SelectNodeTo(PN, NewOpcode, CurDAG->getVTList(NewVTs), Ops); CurDAG->SelectNodeTo(PN, NewOpcode, CurDAG->getVTList(NewVTs), Ops);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/PowerPC/PPCISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVectorImpl<SDValue> &Ops, std::vector<EVT> &NodeTys, SmallVectorImpl<SDValue> &Ops, std::vector<EVT> &NodeTys,
ImmutableCallSite *CS, const PPCSubtarget &Subtarget) { ImmutableCallSite *CS, const PPCSubtarget &Subtarget) {
bool isPPC64 = Subtarget.isPPC64(); bool isPPC64 = Subtarget.isPPC64();
bool isSVR4ABI = Subtarget.isSVR4ABI(); bool isSVR4ABI = Subtarget.isSVR4ABI();
bool isELFv2ABI = Subtarget.isELFv2ABI(); bool isELFv2ABI = Subtarget.isELFv2ABI();
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout()); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
NodeTys.push_back(MVT::Other); // Returns a chain NodeTys.emplace_back(MVT::Other); // Returns a chain
NodeTys.push_back(MVT::Glue); // Returns a flag for retval copy to use. NodeTys.emplace_back(MVT::Glue); // Returns a flag for retval copy to use.
unsigned CallOpc = PPCISD::CALL; unsigned CallOpc = PPCISD::CALL;
bool needIndirectCall = true; bool needIndirectCall = true;
if (!isSVR4ABI || !isPPC64) if (!isSVR4ABI || !isPPC64)
if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) { if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) {
// If this is an absolute destination address, use the munged value. // If this is an absolute destination address, use the munged value.
Callee = SDValue(Dest, 0); Callee = SDValue(Dest, 0);
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
MTCTROps[2] = InFlag; MTCTROps[2] = InFlag;
} }
Chain = DAG.getNode(PPCISD::MTCTR, dl, NodeTys, Chain = DAG.getNode(PPCISD::MTCTR, dl, NodeTys,
makeArrayRef(MTCTROps, InFlag.getNode() ? 3 : 2)); makeArrayRef(MTCTROps, InFlag.getNode() ? 3 : 2));
InFlag = Chain.getValue(1); InFlag = Chain.getValue(1);
NodeTys.clear(); NodeTys.clear();
NodeTys.push_back(MVT::Other); NodeTys.emplace_back(MVT::Other);
NodeTys.push_back(MVT::Glue); NodeTys.emplace_back(MVT::Glue);
Ops.push_back(Chain); Ops.push_back(Chain);
CallOpc = PPCISD::BCTRL; CallOpc = PPCISD::BCTRL;
Callee.setNode(nullptr); Callee.setNode(nullptr);
// Add use of X11 (holding environment pointer) // Add use of X11 (holding environment pointer)
if (isSVR4ABI && isPPC64 && !isELFv2ABI && !hasNest) if (isSVR4ABI && isPPC64 && !isELFv2ABI && !hasNest)
Ops.push_back(DAG.getRegister(PPC::X11, PtrVT)); Ops.push_back(DAG.getRegister(PPC::X11, PtrVT));
// Add CTR register as callee so a bctr can be emitted later. // Add CTR register as callee so a bctr can be emitted later.
if (isTailCall) if (isTailCall)
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// All aggregates smaller than 8 bytes must be passed right-justified. // All aggregates smaller than 8 bytes must be passed right-justified.
if (Size==1 || Size==2 || Size==4) { if (Size==1 || Size==2 || Size==4) {
EVT VT = (Size==1) ? MVT::i8 : ((Size==2) ? MVT::i16 : MVT::i32); EVT VT = (Size==1) ? MVT::i8 : ((Size==2) ? MVT::i16 : MVT::i32);
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg, SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
MachinePointerInfo(), VT, MachinePointerInfo(), VT,
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
continue; continue;
} }
} }
if (GPR_idx == NumGPRs && Size < 8) { if (GPR_idx == NumGPRs && Size < 8) {
SDValue AddPtr = PtrOff; SDValue AddPtr = PtrOff;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
CallSeqStart, CallSeqStart,
Flags, DAG, dl); Flags, DAG, dl);
// Load the slot into the register. // Load the slot into the register.
SDValue Load = DAG.getLoad(PtrVT, dl, Chain, PtrOff, SDValue Load = DAG.getLoad(PtrVT, dl, Chain, PtrOff,
MachinePointerInfo(), MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
// Done with this argument. // Done with this argument.
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
continue; continue;
} }
// For aggregates larger than PtrByteSize, copy the pieces of the // For aggregates larger than PtrByteSize, copy the pieces of the
// object that fit into registers from the parameter save area. // object that fit into registers from the parameter save area.
for (unsigned j=0; j<Size; j+=PtrByteSize) { for (unsigned j=0; j<Size; j+=PtrByteSize) {
SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType()); SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType());
SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const); SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg, SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
MachinePointerInfo(), MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
} else { } else {
ArgOffset += ((Size - j + PtrByteSize-1)/PtrByteSize)*PtrByteSize; ArgOffset += ((Size - j + PtrByteSize-1)/PtrByteSize)*PtrByteSize;
break; break;
} }
} }
continue; continue;
} }
switch (Arg.getSimpleValueType().SimpleTy) { switch (Arg.getSimpleValueType().SimpleTy) {
default: llvm_unreachable("Unexpected ValueType for argument!"); default: llvm_unreachable("Unexpected ValueType for argument!");
case MVT::i1: case MVT::i1:
case MVT::i32: case MVT::i32:
case MVT::i64: case MVT::i64:
if (Flags.isNest()) { if (Flags.isNest()) {
// The 'nest' parameter, if any, is passed in R11. // The 'nest' parameter, if any, is passed in R11.
RegsToPass.push_back(std::make_pair(PPC::X11, Arg)); RegsToPass.emplace_back(std::make_pair(PPC::X11, Arg));
hasNest = true; hasNest = true;
break; break;
} }
// These can be scalar arguments or elements of an integer array type // These can be scalar arguments or elements of an integer array type
// passed directly. Clang may use those instead of "byval" aggregate // passed directly. Clang may use those instead of "byval" aggregate
// types to avoid forcing arguments to memory unnecessarily. // types to avoid forcing arguments to memory unnecessarily.
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Arg));
} else { } else {
if (CallConv == CallingConv::Fast) if (CallConv == CallingConv::Fast)
ComputePtrOff(); ComputePtrOff();
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset, LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
true, isTailCall, false, MemOpChains, true, isTailCall, false, MemOpChains,
TailCallArguments, dl); TailCallArguments, dl);
if (CallConv == CallingConv::Fast) if (CallConv == CallingConv::Fast)
Show All 13 Lines
// Unnamed arguments for vararg functions always go to GPRs and // Unnamed arguments for vararg functions always go to GPRs and
// then the parameter save area. For now, put all arguments to vararg // then the parameter save area. For now, put all arguments to vararg
// routines always in both locations (FPR *and* GPR or stack slot). // routines always in both locations (FPR *and* GPR or stack slot).
bool NeedGPROrStack = isVarArg || FPR_idx == NumFPRs; bool NeedGPROrStack = isVarArg || FPR_idx == NumFPRs;
bool NeededLoad = false; bool NeededLoad = false;
// First load the argument into the next available FPR. // First load the argument into the next available FPR.
if (FPR_idx != NumFPRs) if (FPR_idx != NumFPRs)
RegsToPass.push_back(std::make_pair(FPR[FPR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(FPR[FPR_idx++], Arg));
// Next, load the argument into GPR or stack slot if needed. // Next, load the argument into GPR or stack slot if needed.
if (!NeedGPROrStack) if (!NeedGPROrStack)
; ;
else if (GPR_idx != NumGPRs && CallConv != CallingConv::Fast) { else if (GPR_idx != NumGPRs && CallConv != CallingConv::Fast) {
// FIXME: We may want to re-enable this for CallingConv::Fast on the P8 // FIXME: We may want to re-enable this for CallingConv::Fast on the P8
// once we support fp <-> gpr moves. // once we support fp <-> gpr moves.
Show All 30 Lines
DAG.getConstant(32, dl, MVT::i32)); DAG.getConstant(32, dl, MVT::i32));
// Non-final even elements are skipped; they will be handled // Non-final even elements are skipped; they will be handled
// together the with subsequent argument on the next go-around. // together the with subsequent argument on the next go-around.
} else } else
ArgVal = SDValue(); ArgVal = SDValue();
if (ArgVal.getNode()) if (ArgVal.getNode())
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], ArgVal)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], ArgVal));
} else { } else {
if (CallConv == CallingConv::Fast) if (CallConv == CallingConv::Fast)
ComputePtrOff(); ComputePtrOff();
// Single-precision floating-point values are mapped to the // Single-precision floating-point values are mapped to the
// second (rightmost) word of the stack doubleword. // second (rightmost) word of the stack doubleword.
if (Arg.getValueType() == MVT::f32 && if (Arg.getValueType() == MVT::f32 &&
!isLittleEndian && !Flags.isInConsecutiveRegs()) { !isLittleEndian && !Flags.isInConsecutiveRegs()) {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
for (unsigned i=0; i<16; i+=PtrByteSize) { for (unsigned i=0; i<16; i+=PtrByteSize) {
if (GPR_idx == NumGPRs) if (GPR_idx == NumGPRs)
break; break;
SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
DAG.getConstant(i, dl, PtrVT)); DAG.getConstant(i, dl, PtrVT));
SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(), SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
} }
break; break;
} }
// Non-varargs Altivec params go into VRs or on the stack. // Non-varargs Altivec params go into VRs or on the stack.
if (VR_idx != NumVRs) { if (VR_idx != NumVRs) {
unsigned VReg = (Arg.getSimpleValueType() == MVT::v2f64 || unsigned VReg = (Arg.getSimpleValueType() == MVT::v2f64 ||
Arg.getSimpleValueType() == MVT::v2i64) ? Arg.getSimpleValueType() == MVT::v2i64) ?
Show All 30 Lines
SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff, SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
MachinePointerInfo(), false, false, 0); MachinePointerInfo(), false, false, 0);
MemOpChains.push_back(Store); MemOpChains.push_back(Store);
if (QFPR_idx != NumQFPRs) { if (QFPR_idx != NumQFPRs) {
SDValue Load = DAG.getLoad(IsF32 ? MVT::v4f32 : MVT::v4f64, dl, SDValue Load = DAG.getLoad(IsF32 ? MVT::v4f32 : MVT::v4f64, dl,
Store, PtrOff, MachinePointerInfo(), Store, PtrOff, MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(QFPR[QFPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(QFPR[QFPR_idx++], Load));
} }
ArgOffset += (IsF32 ? 16 : 32); ArgOffset += (IsF32 ? 16 : 32);
for (unsigned i = 0; i < (IsF32 ? 16U : 32U); i += PtrByteSize) { for (unsigned i = 0; i < (IsF32 ? 16U : 32U); i += PtrByteSize) {
if (GPR_idx == NumGPRs) if (GPR_idx == NumGPRs)
break; break;
SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
DAG.getConstant(i, dl, PtrVT)); DAG.getConstant(i, dl, PtrVT));
SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(), SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
} }
break; break;
} }
// Non-varargs QPX params go into registers or on the stack. // Non-varargs QPX params go into registers or on the stack.
if (QFPR_idx != NumQFPRs) { if (QFPR_idx != NumQFPRs) {
RegsToPass.push_back(std::make_pair(QFPR[QFPR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(QFPR[QFPR_idx++], Arg));
} else { } else {
if (CallConv == CallingConv::Fast) if (CallConv == CallingConv::Fast)
ComputePtrOff(); ComputePtrOff();
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset, LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
true, isTailCall, true, MemOpChains, true, isTailCall, true, MemOpChains,
TailCallArguments, dl); TailCallArguments, dl);
if (CallConv == CallingConv::Fast) if (CallConv == CallingConv::Fast)
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// passed left-justified. // passed left-justified.
if (Size==1 || Size==2) { if (Size==1 || Size==2) {
EVT VT = (Size==1) ? MVT::i8 : MVT::i16; EVT VT = (Size==1) ? MVT::i8 : MVT::i16;
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg, SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
MachinePointerInfo(), VT, MachinePointerInfo(), VT,
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
} else { } else {
SDValue Const = DAG.getConstant(PtrByteSize - Size, dl, SDValue Const = DAG.getConstant(PtrByteSize - Size, dl,
PtrOff.getValueType()); PtrOff.getValueType());
SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const); SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
Chain = CallSeqStart = createMemcpyOutsideCallSeq(Arg, AddPtr, Chain = CallSeqStart = createMemcpyOutsideCallSeq(Arg, AddPtr,
CallSeqStart, CallSeqStart,
Show All 15 Lines
for (unsigned j=0; j<Size; j+=PtrByteSize) { for (unsigned j=0; j<Size; j+=PtrByteSize) {
SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType()); SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType());
SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const); SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg, SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
MachinePointerInfo(), MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
} else { } else {
ArgOffset += ((Size - j + PtrByteSize-1)/PtrByteSize)*PtrByteSize; ArgOffset += ((Size - j + PtrByteSize-1)/PtrByteSize)*PtrByteSize;
break; break;
} }
} }
continue; continue;
} }
switch (Arg.getSimpleValueType().SimpleTy) { switch (Arg.getSimpleValueType().SimpleTy) {
default: llvm_unreachable("Unexpected ValueType for argument!"); default: llvm_unreachable("Unexpected ValueType for argument!");
case MVT::i1: case MVT::i1:
case MVT::i32: case MVT::i32:
case MVT::i64: case MVT::i64:
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
if (Arg.getValueType() == MVT::i1) if (Arg.getValueType() == MVT::i1)
Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, PtrVT, Arg); Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, PtrVT, Arg);
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Arg));
} else { } else {
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset, LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
isPPC64, isTailCall, false, MemOpChains, isPPC64, isTailCall, false, MemOpChains,
TailCallArguments, dl); TailCallArguments, dl);
} }
ArgOffset += PtrByteSize; ArgOffset += PtrByteSize;
break; break;
case MVT::f32: case MVT::f32:
case MVT::f64: case MVT::f64:
if (FPR_idx != NumFPRs) { if (FPR_idx != NumFPRs) {
RegsToPass.push_back(std::make_pair(FPR[FPR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(FPR[FPR_idx++], Arg));
if (isVarArg) { if (isVarArg) {
SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff, SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
MachinePointerInfo(), false, false, 0); MachinePointerInfo(), false, false, 0);
MemOpChains.push_back(Store); MemOpChains.push_back(Store);
// Float varargs are always shadowed in available integer registers // Float varargs are always shadowed in available integer registers
if (GPR_idx != NumGPRs) { if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff, SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
MachinePointerInfo(), false, false, MachinePointerInfo(), false, false,
false, 0); false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
} }
if (GPR_idx != NumGPRs && Arg.getValueType() == MVT::f64 && !isPPC64){ if (GPR_idx != NumGPRs && Arg.getValueType() == MVT::f64 && !isPPC64){
SDValue ConstFour = DAG.getConstant(4, dl, PtrOff.getValueType()); SDValue ConstFour = DAG.getConstant(4, dl, PtrOff.getValueType());
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour); PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff, SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
MachinePointerInfo(), MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
} }
} else { } else {
// If we have any FPRs remaining, we may also have GPRs remaining. // If we have any FPRs remaining, we may also have GPRs remaining.
// Args passed in FPRs consume either 1 (f32) or 2 (f64) available // Args passed in FPRs consume either 1 (f32) or 2 (f64) available
// GPRs. // GPRs.
if (GPR_idx != NumGPRs) if (GPR_idx != NumGPRs)
++GPR_idx; ++GPR_idx;
if (GPR_idx != NumGPRs && Arg.getValueType() == MVT::f64 && if (GPR_idx != NumGPRs && Arg.getValueType() == MVT::f64 &&
Show All 31 Lines
SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff, SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
MachinePointerInfo(), false, false, 0); MachinePointerInfo(), false, false, 0);
MemOpChains.push_back(Store); MemOpChains.push_back(Store);
if (VR_idx != NumVRs) { if (VR_idx != NumVRs) {
SDValue Load = DAG.getLoad(MVT::v4f32, dl, Store, PtrOff, SDValue Load = DAG.getLoad(MVT::v4f32, dl, Store, PtrOff,
MachinePointerInfo(), MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(VR[VR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(VR[VR_idx++], Load));
} }
ArgOffset += 16; ArgOffset += 16;
for (unsigned i=0; i<16; i+=PtrByteSize) { for (unsigned i=0; i<16; i+=PtrByteSize) {
if (GPR_idx == NumGPRs) if (GPR_idx == NumGPRs)
break; break;
SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
DAG.getConstant(i, dl, PtrVT)); DAG.getConstant(i, dl, PtrVT));
SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(), SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
false, false, false, 0); false, false, false, 0);
MemOpChains.push_back(Load.getValue(1)); MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load)); RegsToPass.emplace_back(std::make_pair(GPR[GPR_idx++], Load));
} }
break; break;
} }
// Non-varargs Altivec params generally go in registers, but have // Non-varargs Altivec params generally go in registers, but have
// stack space allocated at the end. // stack space allocated at the end.
if (VR_idx != NumVRs) { if (VR_idx != NumVRs) {
// Doesn't have GPR space allocated. // Doesn't have GPR space allocated.
RegsToPass.push_back(std::make_pair(VR[VR_idx++], Arg)); RegsToPass.emplace_back(std::make_pair(VR[VR_idx++], Arg));
} else if (nAltivecParamsAtEnd==0) { } else if (nAltivecParamsAtEnd==0) {
// We are emitting Altivec params in order. // We are emitting Altivec params in order.
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset, LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
isPPC64, isTailCall, true, MemOpChains, isPPC64, isTailCall, true, MemOpChains,
TailCallArguments, dl); TailCallArguments, dl);
ArgOffset += 16; ArgOffset += 16;
} }
break; break;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} else { } else {
continue; continue;
} }
bool FoundBucket = false; bool FoundBucket = false;
for (auto &B : Buckets) { for (auto &B : Buckets) {
const SCEV *Diff = SE->getMinusSCEV(LSCEV, B.BaseSCEV); const SCEV *Diff = SE->getMinusSCEV(LSCEV, B.BaseSCEV);
if (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) { if (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) {
B.Elements.push_back(BucketElement(CDiff, MemI)); B.Elements.emplace_back(CDiff, MemI);
FoundBucket = true; FoundBucket = true;
break; break;
} }
} }
if (!FoundBucket) { if (!FoundBucket) {
if (Buckets.size() == MaxVars) if (Buckets.size() == MaxVars)
return MadeChange; return MadeChange;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/Sparc/SparcISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*DAG.getContext()); *DAG.getContext());
// Analyze return values. // Analyze return values.
CCInfo.AnalyzeReturn(Outs, RetCC_Sparc32); CCInfo.AnalyzeReturn(Outs, RetCC_Sparc32);
SDValue Flag; SDValue Flag;
SmallVector<SDValue, 4> RetOps(1, Chain); SmallVector<SDValue, 4> RetOps(1, Chain);
// Make room for the return address offset. // Make room for the return address offset.
RetOps.push_back(SDValue()); RetOps.emplace_back();
// Copy the result values into the output registers. // Copy the result values into the output registers.
for (unsigned i = 0, realRVLocIdx = 0; for (unsigned i = 0, realRVLocIdx = 0;
i != RVLocs.size(); i != RVLocs.size();
++i, ++realRVLocIdx) { ++i, ++realRVLocIdx) {
CCValAssign &VA = RVLocs[i]; CCValAssign &VA = RVLocs[i];
assert(VA.isRegLoc() && "Can only return in registers!"); assert(VA.isRegLoc() && "Can only return in registers!");
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/X86/AsmParser/X86AsmParser.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (StackOp == IC_RPAREN) { if (StackOp == IC_RPAREN) {
++ParenCount; ++ParenCount;
InfixOperatorStack.pop_back(); InfixOperatorStack.pop_back();
} else if (StackOp == IC_LPAREN) { } else if (StackOp == IC_LPAREN) {
--ParenCount; --ParenCount;
InfixOperatorStack.pop_back(); InfixOperatorStack.pop_back();
} else { } else {
InfixOperatorStack.pop_back(); InfixOperatorStack.pop_back();
PostfixStack.push_back(std::make_pair(StackOp, 0)); PostfixStack.emplace_back(std::make_pair(StackOp, 0));
} }
} }
// Push the new operator. // Push the new operator.
InfixOperatorStack.push_back(Op); InfixOperatorStack.push_back(Op);
} }
int64_t execute() { int64_t execute() {
// Push any remaining operators onto the postfix stack. // Push any remaining operators onto the postfix stack.
while (!InfixOperatorStack.empty()) { while (!InfixOperatorStack.empty()) {
InfixCalculatorTok StackOp = InfixOperatorStack.pop_back_val(); InfixCalculatorTok StackOp = InfixOperatorStack.pop_back_val();
if (StackOp != IC_LPAREN && StackOp != IC_RPAREN) if (StackOp != IC_LPAREN && StackOp != IC_RPAREN)
PostfixStack.push_back(std::make_pair(StackOp, 0)); PostfixStack.emplace_back(std::make_pair(StackOp, 0));
} }
if (PostfixStack.empty()) if (PostfixStack.empty())
return 0; return 0;
SmallVector<ICToken, 16> OperandStack; SmallVector<ICToken, 16> OperandStack;
for (unsigned i = 0, e = PostfixStack.size(); i != e; ++i) { for (unsigned i = 0, e = PostfixStack.size(); i != e; ++i) {
ICToken Op = PostfixStack[i]; ICToken Op = PostfixStack[i];
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/X86/X86ISelDAGToDAG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
Ops.push_back(NewChain); Ops.push_back(NewChain);
} }
Ops.append(OrigChain->op_begin() + 1, OrigChain->op_end()); Ops.append(OrigChain->op_begin() + 1, OrigChain->op_end());
CurDAG->UpdateNodeOperands(OrigChain.getNode(), Ops); CurDAG->UpdateNodeOperands(OrigChain.getNode(), Ops);
CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0), CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0),
Load.getOperand(1), Load.getOperand(2)); Load.getOperand(1), Load.getOperand(2));
Ops.clear(); Ops.clear();
Ops.push_back(SDValue(Load.getNode(), 1)); Ops.emplace_back(Load.getNode(), 1);
Ops.append(Call->op_begin() + 1, Call->op_end()); Ops.append(Call->op_begin() + 1, Call->op_end());
CurDAG->UpdateNodeOperands(Call.getNode(), Ops); CurDAG->UpdateNodeOperands(Call.getNode(), Ops);
} }
/// Return true if call address is a load and it can be /// Return true if call address is a load and it can be
/// moved below CALLSEQ_START and the chains leading up to the call. /// moved below CALLSEQ_START and the chains leading up to the call.
/// Return the CALLSEQ_START by reference as a second output. /// Return the CALLSEQ_START by reference as a second output.
/// In the case of a tail call, there isn't a callseq node between the call /// In the case of a tail call, there isn't a callseq node between the call
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/X86/X86InstrInfo.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
cast<MachineSDNode>(Load)->setMemRefs(MMOs.first, MMOs.second); cast<MachineSDNode>(Load)->setMemRefs(MMOs.first, MMOs.second);
} }
// Emit the data processing instruction. // Emit the data processing instruction.
std::vector<EVT> VTs; std::vector<EVT> VTs;
const TargetRegisterClass *DstRC = nullptr; const TargetRegisterClass *DstRC = nullptr;
if (MCID.getNumDefs() > 0) { if (MCID.getNumDefs() > 0) {
DstRC = getRegClass(MCID, 0, &RI, MF); DstRC = getRegClass(MCID, 0, &RI, MF);
VTs.push_back(*DstRC->vt_begin()); VTs.emplace_back(*DstRC->vt_begin());
} }
for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) { for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) {
EVT VT = N->getValueType(i); EVT VT = N->getValueType(i);
if (VT != MVT::Other && i >= (unsigned)MCID.getNumDefs()) if (VT != MVT::Other && i >= (unsigned)MCID.getNumDefs())
VTs.push_back(VT); VTs.push_back(VT);
} }
if (Load) if (Load)
BeforeOps.push_back(SDValue(Load, 0)); BeforeOps.emplace_back(Load, 0);
BeforeOps.insert(BeforeOps.end(), AfterOps.begin(), AfterOps.end()); BeforeOps.insert(BeforeOps.end(), AfterOps.begin(), AfterOps.end());
SDNode *NewNode= DAG.getMachineNode(Opc, dl, VTs, BeforeOps); SDNode *NewNode= DAG.getMachineNode(Opc, dl, VTs, BeforeOps);
NewNodes.push_back(NewNode); NewNodes.push_back(NewNode);
// Emit the store instruction. // Emit the store instruction.
if (FoldedStore) { if (FoldedStore) {
AddrOps.pop_back(); AddrOps.pop_back();
AddrOps.push_back(SDValue(NewNode, 0)); AddrOps.emplace_back(NewNode, 0);
AddrOps.push_back(Chain); AddrOps.push_back(Chain);
std::pair<MachineInstr::mmo_iterator, std::pair<MachineInstr::mmo_iterator,
MachineInstr::mmo_iterator> MMOs = MachineInstr::mmo_iterator> MMOs =
MF.extractStoreMemRefs(cast<MachineSDNode>(N)->memoperands_begin(), MF.extractStoreMemRefs(cast<MachineSDNode>(N)->memoperands_begin(),
cast<MachineSDNode>(N)->memoperands_end()); cast<MachineSDNode>(N)->memoperands_end());
if (!(*MMOs.first) && if (!(*MMOs.first) &&
RC == &X86::VR128RegClass && RC == &X86::VR128RegClass &&
Subtarget.isUnalignedMem16Slow()) Subtarget.isUnalignedMem16Slow())
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Target/XCore/XCoreISelLowering.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const CCValAssign &VA = RVLocs[i]; const CCValAssign &VA = RVLocs[i];
if (VA.isRegLoc()) { if (VA.isRegLoc()) {
Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), VA.getValVT(), Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), VA.getValVT(),
InFlag).getValue(1); InFlag).getValue(1);
InFlag = Chain.getValue(2); InFlag = Chain.getValue(2);
InVals.push_back(Chain.getValue(0)); InVals.push_back(Chain.getValue(0));
} else { } else {
assert(VA.isMemLoc()); assert(VA.isMemLoc());
ResultMemLocs.push_back(std::make_pair(VA.getLocMemOffset(), ResultMemLocs.emplace_back(std::make_pair(VA.getLocMemOffset(),
InVals.size())); InVals.size()));
// Reserve space for this result. // Reserve space for this result.
InVals.push_back(SDValue()); InVals.push_back(SDValue());
} }
} }
// Copy results out of memory. // Copy results out of memory.
SmallVector<SDValue, 4> MemOpChains; SmallVector<SDValue, 4> MemOpChains;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Tooling/Core/Replacement.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Extend conflicted range // Extend conflicted range
ConflictRange = Range(ConflictRange.getOffset(), ConflictRange = Range(ConflictRange.getOffset(),
std::max(ConflictRange.getLength(), std::max(ConflictRange.getLength(),
Current.getOffset() + Current.getLength() - Current.getOffset() + Current.getLength() -
ConflictRange.getOffset())); ConflictRange.getOffset()));
++ConflictLength; ++ConflictLength;
} else { } else {
if (ConflictLength > 1) if (ConflictLength > 1)
Conflicts.push_back(Range(ConflictStart, ConflictLength)); Conflicts.emplace_back(ConflictStart, ConflictLength);
ConflictRange = Current; ConflictRange = Current;
ConflictStart = i; ConflictStart = i;
ConflictLength = 1; ConflictLength = 1;
} }
} }
if (ConflictLength > 1) if (ConflictLength > 1)
Conflicts.push_back(Range(ConflictStart, ConflictLength)); Conflicts.emplace_back(ConflictStart, ConflictLength);
} }
bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) { bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite) {
bool Result = true; bool Result = true;
for (Replacements::const_iterator I = Replaces.begin(), for (Replacements::const_iterator I = Replaces.begin(),
E = Replaces.end(); E = Replaces.end();
I != E; ++I) { I != E; ++I) {
if (I->isApplicable()) { if (I->isApplicable()) {
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
std::vector<Range> calculateChangedRanges(const Replacements &Replaces) { std::vector<Range> calculateChangedRanges(const Replacements &Replaces) {
std::vector<Range> ChangedRanges; std::vector<Range> ChangedRanges;
int Shift = 0; int Shift = 0;
for (const Replacement &R : Replaces) { for (const Replacement &R : Replaces) {
unsigned Offset = R.getOffset() + Shift; unsigned Offset = R.getOffset() + Shift;
unsigned Length = R.getReplacementText().size(); unsigned Length = R.getReplacementText().size();
Shift += Length - R.getLength(); Shift += Length - R.getLength();
ChangedRanges.push_back(Range(Offset, Length)); ChangedRanges.emplace_back(Offset, Length);
} }
return ChangedRanges; return ChangedRanges;
} }
namespace { namespace {
// Represents a merged replacement, i.e. a replacement consisting of multiple // Represents a merged replacement, i.e. a replacement consisting of multiple
// overlapping replacements from 'First' and 'Second' in mergeReplacements. // overlapping replacements from 'First' and 'Second' in mergeReplacements.
// //
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Tooling/FileMatchTrie.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
private: private:
/// \brief Gets all paths under this FileMatchTrieNode. /// \brief Gets all paths under this FileMatchTrieNode.
void getAll(std::vector<StringRef> &Results, void getAll(std::vector<StringRef> &Results,
llvm::StringMap<FileMatchTrieNode>::const_iterator Except) const { llvm::StringMap<FileMatchTrieNode>::const_iterator Except) const {
if (Path.empty()) if (Path.empty())
return; return;
if (Children.empty()) { if (Children.empty()) {
Results.push_back(StringRef(Path)); Results.emplace_back(Path);
return; return;
} }
for (llvm::StringMap<FileMatchTrieNode>::const_iterator for (llvm::StringMap<FileMatchTrieNode>::const_iterator
It = Children.begin(), E = Children.end(); It = Children.begin(), E = Children.end();
It != E; ++It) { It != E; ++It) {
if (It == Except) if (It == Except)
continue; continue;
It->getValue().getAll(Results, Children.end()); It->getValue().getAll(Results, Children.end());
Show All 39 Lines

lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
User *U = *UI++; User *U = *UI++;
if (StoreInst *SI = dyn_cast<StoreInst>(U)) { if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
Value *V = SI->getValueOperand(); Value *V = SI->getValueOperand();
if (isa<Constant>(V)) { if (isa<Constant>(V)) {
Changed = true; Changed = true;
SI->eraseFromParent(); SI->eraseFromParent();
} else if (Instruction *I = dyn_cast<Instruction>(V)) { } else if (Instruction *I = dyn_cast<Instruction>(V)) {
if (I->hasOneUse()) if (I->hasOneUse())
Dead.push_back(std::make_pair(I, SI)); Dead.emplace_back(std::make_pair(I, SI));
} }
} else if (MemSetInst *MSI = dyn_cast<MemSetInst>(U)) { } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(U)) {
if (isa<Constant>(MSI->getValue())) { if (isa<Constant>(MSI->getValue())) {
Changed = true; Changed = true;
MSI->eraseFromParent(); MSI->eraseFromParent();
} else if (Instruction *I = dyn_cast<Instruction>(MSI->getValue())) { } else if (Instruction *I = dyn_cast<Instruction>(MSI->getValue())) {
if (I->hasOneUse()) if (I->hasOneUse())
Dead.push_back(std::make_pair(I, MSI)); Dead.emplace_back(std::make_pair(I, MSI));
} }
} else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(U)) { } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(U)) {
GlobalVariable *MemSrc = dyn_cast<GlobalVariable>(MTI->getSource()); GlobalVariable *MemSrc = dyn_cast<GlobalVariable>(MTI->getSource());
if (MemSrc && MemSrc->isConstant()) { if (MemSrc && MemSrc->isConstant()) {
Changed = true; Changed = true;
MTI->eraseFromParent(); MTI->eraseFromParent();
} else if (Instruction *I = dyn_cast<Instruction>(MemSrc)) { } else if (Instruction *I = dyn_cast<Instruction>(MemSrc)) {
if (I->hasOneUse()) if (I->hasOneUse())
Dead.push_back(std::make_pair(I, MTI)); Dead.emplace_back(std::make_pair(I, MTI));
} }
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) { } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) {
if (CE->use_empty()) { if (CE->use_empty()) {
CE->destroyConstant(); CE->destroyConstant();
Changed = true; Changed = true;
} }
} else if (Constant *C = dyn_cast<Constant>(U)) { } else if (Constant *C = dyn_cast<Constant>(U)) {
if (isSafeToDestroyConstant(C)) { if (isSafeToDestroyConstant(C)) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/IPO/MergeFunctions.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
bool Changed = false; bool Changed = false;
// All functions in the module, ordered by hash. Functions with a unique // All functions in the module, ordered by hash. Functions with a unique
// hash value are easily eliminated. // hash value are easily eliminated.
std::vector<std::pair<FunctionComparator::FunctionHash, Function *>> std::vector<std::pair<FunctionComparator::FunctionHash, Function *>>
HashedFuncs; HashedFuncs;
for (Function &Func : M) { for (Function &Func : M) {
if (!Func.isDeclaration() && !Func.hasAvailableExternallyLinkage()) { if (!Func.isDeclaration() && !Func.hasAvailableExternallyLinkage()) {
HashedFuncs.push_back({FunctionComparator::functionHash(Func), &Func}); HashedFuncs.emplace_back(FunctionComparator::functionHash(Func), &Func);
} }
} }
std::stable_sort( std::stable_sort(
HashedFuncs.begin(), HashedFuncs.end(), HashedFuncs.begin(), HashedFuncs.end(),
[](const std::pair<FunctionComparator::FunctionHash, Function *> &a, [](const std::pair<FunctionComparator::FunctionHash, Function *> &a,
const std::pair<FunctionComparator::FunctionHash, Function *> &b) { const std::pair<FunctionComparator::FunctionHash, Function *> &b) {
return a.first < b.first; return a.first < b.first;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/IPO/SampleProfile.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const DILocation *DIL = Inst.getDebugLoc(); const DILocation *DIL = Inst.getDebugLoc();
if (!DIL) { if (!DIL) {
return Samples; return Samples;
} }
for (DIL = DIL->getInlinedAt(); DIL; DIL = DIL->getInlinedAt()) { for (DIL = DIL->getInlinedAt(); DIL; DIL = DIL->getInlinedAt()) {
DISubprogram *SP = DIL->getScope()->getSubprogram(); DISubprogram *SP = DIL->getScope()->getSubprogram();
if (!SP) if (!SP)
return nullptr; return nullptr;
S.push_back(LineLocation(getOffset(DIL->getLine(), SP->getLine()), S.emplace_back(getOffset(DIL->getLine(), SP->getLine()),
DIL->getDiscriminator())); DIL->getDiscriminator());
} }
if (S.size() == 0) if (S.size() == 0)
return Samples; return Samples;
const FunctionSamples *FS = Samples; const FunctionSamples *FS = Samples;
for (int i = S.size() - 1; i >= 0 && FS != nullptr; i--) { for (int i = S.size() - 1; i >= 0 && FS != nullptr; i--) {
FS = FS->findFunctionSamplesAt(S[i]); FS = FS->findFunctionSamplesAt(S[i]);
} }
return FS; return FS;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/IPO/WholeProgramDevirt.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!Fn) if (!Fn)
return false; return false;
// We can disregard __cxa_pure_virtual as a possible call target, as // We can disregard __cxa_pure_virtual as a possible call target, as
// calls to pure virtuals are UB. // calls to pure virtuals are UB.
if (Fn->getName() == "__cxa_pure_virtual") if (Fn->getName() == "__cxa_pure_virtual")
continue; continue;
TargetsForSlot.push_back({Fn, &BS}); TargetsForSlot.emplace_back(Fn, &BS);
} }
// Give up if we couldn't find any targets. // Give up if we couldn't find any targets.
return !TargetsForSlot.empty(); return !TargetsForSlot.empty();
} }
bool DevirtModule::trySingleImplDevirt( bool DevirtModule::trySingleImplDevirt(
ArrayRef<VirtualCallTarget> TargetsForSlot, ArrayRef<VirtualCallTarget> TargetsForSlot,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines for (auto &U : ValuePair.first->uses()) {
if (LoadInst *LI = dyn_cast<LoadInst>(I)) { if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
// Ignore non-volatile loads, they are always ok. // Ignore non-volatile loads, they are always ok.
if (!LI->isSimple()) return false; if (!LI->isSimple()) return false;
continue; continue;
} }
if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) { if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) {
// If uses of the bitcast are ok, we are ok. // If uses of the bitcast are ok, we are ok.
ValuesToInspect.push_back(std::make_pair(I, IsOffset)); ValuesToInspect.emplace_back(std::make_pair(I, IsOffset));
continue; continue;
} }
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) { if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) {
// If the GEP has all zero indices, it doesn't offset the pointer. If it // If the GEP has all zero indices, it doesn't offset the pointer. If it
// doesn't, it does. // doesn't, it does.
ValuesToInspect.push_back( ValuesToInspect.emplace_back(std::make_pair(I, IsOffset || !GEP->hasAllZeroIndices()));
std::make_pair(I, IsOffset || !GEP->hasAllZeroIndices()));
continue; continue;
} }
if (auto CS = CallSite(I)) { if (auto CS = CallSite(I)) {
// If this is the function being called then we treat it like a load and // If this is the function being called then we treat it like a load and
// ignore it. // ignore it.
if (CS.isCallee(&U)) if (CS.isCallee(&U))
continue; continue;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/InstCombine/InstCombinePHI.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (PHINode *UserPN = dyn_cast<PHINode>(UserI)) { if (PHINode *UserPN = dyn_cast<PHINode>(UserI)) {
if (PHIsInspected.insert(UserPN).second) if (PHIsInspected.insert(UserPN).second)
PHIsToSlice.push_back(UserPN); PHIsToSlice.push_back(UserPN);
continue; continue;
} }
// Truncates are always ok. // Truncates are always ok.
if (isa<TruncInst>(UserI)) { if (isa<TruncInst>(UserI)) {
PHIUsers.push_back(PHIUsageRecord(PHIId, 0, UserI)); PHIUsers.emplace_back(PHIId, 0, UserI);
continue; continue;
} }
// Otherwise it must be a lshr which can only be used by one trunc. // Otherwise it must be a lshr which can only be used by one trunc.
if (UserI->getOpcode() != Instruction::LShr || if (UserI->getOpcode() != Instruction::LShr ||
!UserI->hasOneUse() || !isa<TruncInst>(UserI->user_back()) || !UserI->hasOneUse() || !isa<TruncInst>(UserI->user_back()) ||
!isa<ConstantInt>(UserI->getOperand(1))) !isa<ConstantInt>(UserI->getOperand(1)))
return nullptr; return nullptr;
unsigned Shift = cast<ConstantInt>(UserI->getOperand(1))->getZExtValue(); unsigned Shift = cast<ConstantInt>(UserI->getOperand(1))->getZExtValue();
PHIUsers.push_back(PHIUsageRecord(PHIId, Shift, UserI->user_back())); PHIUsers.emplace_back(PHIId, Shift, UserI->user_back());
} }
} }
// If we have no users, they must be all self uses, just nuke the PHI. // If we have no users, they must be all self uses, just nuke the PHI.
if (PHIUsers.empty()) if (PHIUsers.empty())
return replaceInstUsesWith(FirstPhi, UndefValue::get(FirstPhi.getType())); return replaceInstUsesWith(FirstPhi, UndefValue::get(FirstPhi.getType()));
// If this phi node is transformable, create new PHIs for all the pieces // If this phi node is transformable, create new PHIs for all the pieces
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
// If the incoming value was a PHI, and if it was one of the PHIs we are // If the incoming value was a PHI, and if it was one of the PHIs we are
// rewriting, we will ultimately delete the code we inserted. This // rewriting, we will ultimately delete the code we inserted. This
// means we need to revisit that PHI to make sure we extract out the // means we need to revisit that PHI to make sure we extract out the
// needed piece. // needed piece.
if (PHINode *OldInVal = dyn_cast<PHINode>(PN->getIncomingValue(i))) if (PHINode *OldInVal = dyn_cast<PHINode>(PN->getIncomingValue(i)))
if (PHIsInspected.count(OldInVal)) { if (PHIsInspected.count(OldInVal)) {
unsigned RefPHIId = std::find(PHIsToSlice.begin(),PHIsToSlice.end(), unsigned RefPHIId = std::find(PHIsToSlice.begin(),PHIsToSlice.end(),
OldInVal)-PHIsToSlice.begin(); OldInVal)-PHIsToSlice.begin();
PHIUsers.push_back(PHIUsageRecord(RefPHIId, Offset, PHIUsers.emplace_back(RefPHIId, Offset,
cast<Instruction>(Res))); cast<Instruction>(Res));
++UserE; ++UserE;
} }
} }
PredValues.clear(); PredValues.clear();
DEBUG(dbgs() << " Made element PHI for offset " << Offset << ": " DEBUG(dbgs() << " Made element PHI for offset " << Offset << ": "
<< *EltPHI << '\n'); << *EltPHI << '\n');
ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)] = EltPHI; ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)] = EltPHI;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/GCOVProfiling.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
ArrayType *CounterTy = ArrayType *CounterTy =
ArrayType::get(Type::getInt64Ty(*Ctx), Edges); ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
GlobalVariable *Counters = GlobalVariable *Counters =
new GlobalVariable(*M, CounterTy, false, new GlobalVariable(*M, CounterTy, false,
GlobalValue::InternalLinkage, GlobalValue::InternalLinkage,
Constant::getNullValue(CounterTy), Constant::getNullValue(CounterTy),
"__llvm_gcov_ctr"); "__llvm_gcov_ctr");
CountersBySP.push_back(std::make_pair(Counters, SP)); CountersBySP.emplace_back(std::make_pair(Counters, SP));
UniqueVector<BasicBlock *> ComplexEdgePreds; UniqueVector<BasicBlock *> ComplexEdgePreds;
UniqueVector<BasicBlock *> ComplexEdgeSuccs; UniqueVector<BasicBlock *> ComplexEdgeSuccs;
unsigned Edge = 0; unsigned Edge = 0;
for (auto &BB : F) { for (auto &BB : F) {
TerminatorInst *TI = BB.getTerminator(); TerminatorInst *TI = BB.getTerminator();
int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors(); int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
DEBUG(dbgs() << " Not promote: " << Reason << "\n"); DEBUG(dbgs() << " Not promote: " << Reason << "\n");
emitOptimizationRemarkMissed( emitOptimizationRemarkMissed(
F.getContext(), "pgo-icall-prom", F, Inst->getDebugLoc(), F.getContext(), "pgo-icall-prom", F, Inst->getDebugLoc(),
Twine("Cannot promote indirect call to ") + Twine("Cannot promote indirect call to ") +
(TargetFuncName.empty() ? Twine(Target) : Twine(TargetFuncName)) + (TargetFuncName.empty() ? Twine(Target) : Twine(TargetFuncName)) +
Twine(" with count of ") + Twine(Count) + ": " + Reason); Twine(" with count of ") + Twine(Count) + ": " + Reason);
break; break;
} }
Ret.push_back(PromotionCandidate(TargetFunction, Count)); Ret.emplace_back(TargetFunction, Count);
TotalCount -= Count; TotalCount -= Count;
} }
return Ret; return Ret;
} }
// Create a diamond structure for If_Then_Else. Also update the profile // Create a diamond structure for If_Then_Else. Also update the profile
// count. Do the fix-up for the invoke instruction. // count. Do the fix-up for the invoke instruction.
static void createIfThenElse(Instruction *Inst, Function *DirectCallee, static void createIfThenElse(Instruction *Inst, Function *DirectCallee,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
void insertShadowCheck(Value *Shadow, Value *Origin, Instruction *OrigIns) { void insertShadowCheck(Value *Shadow, Value *Origin, Instruction *OrigIns) {
assert(Shadow); assert(Shadow);
if (!InsertChecks) return; if (!InsertChecks) return;
#ifndef NDEBUG #ifndef NDEBUG
Type *ShadowTy = Shadow->getType(); Type *ShadowTy = Shadow->getType();
assert((isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy)) && assert((isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy)) &&
"Can only insert checks for integer and vector shadow types"); "Can only insert checks for integer and vector shadow types");
#endif #endif
InstrumentationList.push_back( InstrumentationList.emplace_back(Shadow, Origin, OrigIns);
ShadowOriginAndInsertPoint(Shadow, Origin, OrigIns));
} }
/// \brief Remember the place where a shadow check should be inserted. /// \brief Remember the place where a shadow check should be inserted.
/// ///
/// This location will be later instrumented with a check that will print a /// This location will be later instrumented with a check that will print a
/// UMR warning in runtime if the value is not fully defined. /// UMR warning in runtime if the value is not fully defined.
void insertShadowCheck(Value *Val, Instruction *OrigIns) { void insertShadowCheck(Value *Val, Instruction *OrigIns) {
assert(Val); assert(Val);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Op->getType() != ParamTy) if (Op->getType() != ParamTy)
Op = new BitCastInst(Op, ParamTy, "", InsertPos); Op = new BitCastInst(Op, ParamTy, "", InsertPos);
Clone->setArgOperand(0, Op); Clone->setArgOperand(0, Op);
Clone->insertBefore(InsertPos); Clone->insertBefore(InsertPos);
DEBUG(dbgs() << "Cloning " DEBUG(dbgs() << "Cloning "
<< *CInst << "\n" << *CInst << "\n"
"And inserting clone at " << *InsertPos << "\n"); "And inserting clone at " << *InsertPos << "\n");
Worklist.push_back(std::make_pair(Clone, Incoming)); Worklist.emplace_back(std::make_pair(Clone, Incoming));
} }
} }
// Erase the original call. // Erase the original call.
DEBUG(dbgs() << "Erasing: " << *CInst << "\n"); DEBUG(dbgs() << "Erasing: " << *CInst << "\n");
EraseInstruction(CInst); EraseInstruction(CInst);
continue; continue;
} }
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/ConstantHoisting.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Linesstruct ConstantCandidate {
unsigned CumulativeCost; unsigned CumulativeCost;
ConstantCandidate(ConstantInt *ConstInt) ConstantCandidate(ConstantInt *ConstInt)
: ConstInt(ConstInt), CumulativeCost(0) { } : ConstInt(ConstInt), CumulativeCost(0) { }
/// \brief Add the user to the use list and update the cost. /// \brief Add the user to the use list and update the cost.
void addUser(Instruction *Inst, unsigned Idx, unsigned Cost) { void addUser(Instruction *Inst, unsigned Idx, unsigned Cost) {
CumulativeCost += Cost; CumulativeCost += Cost;
Uses.push_back(ConstantUser(Inst, Idx)); Uses.emplace_back(Inst, Idx);
} }
}; };
/// \brief This represents a constant that has been rebased with respect to a /// \brief This represents a constant that has been rebased with respect to a
/// base constant. The difference to the base constant is recorded in Offset. /// base constant. The difference to the base constant is recorded in Offset.
struct RebasedConstantInfo { struct RebasedConstantInfo {
ConstantUseListType Uses; ConstantUseListType Uses;
Constant *Offset; Constant *Offset;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/JumpThreading.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
"Can't handle critical edge here!"); "Can't handle critical edge here!");
LoadInst *NewVal = new LoadInst(LoadedPtr, LI->getName()+".pr", false, LoadInst *NewVal = new LoadInst(LoadedPtr, LI->getName()+".pr", false,
LI->getAlignment(), LI->getAlignment(),
UnavailablePred->getTerminator()); UnavailablePred->getTerminator());
NewVal->setDebugLoc(LI->getDebugLoc()); NewVal->setDebugLoc(LI->getDebugLoc());
if (AATags) if (AATags)
NewVal->setAAMetadata(AATags); NewVal->setAAMetadata(AATags);
AvailablePreds.push_back(std::make_pair(UnavailablePred, NewVal)); AvailablePreds.emplace_back(std::make_pair(UnavailablePred, NewVal));
} }
// Now we know that each predecessor of this block has a value in // Now we know that each predecessor of this block has a value in
// AvailablePreds, sort them for efficient access as we're walking the preds. // AvailablePreds, sort them for efficient access as we're walking the preds.
array_pod_sort(AvailablePreds.begin(), AvailablePreds.end()); array_pod_sort(AvailablePreds.begin(), AvailablePreds.end());
// Create a PHI node at the start of the block for the PRE'd load value. // Create a PHI node at the start of the block for the PRE'd load value.
pred_iterator PB = pred_begin(LoadBB), PE = pred_end(LoadBB); pred_iterator PB = pred_begin(LoadBB), PE = pred_end(LoadBB);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoadCombine.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!LI) if (!LI)
continue; continue;
++NumLoadsAnalyzed; ++NumLoadsAnalyzed;
if (!LI->isSimple() || !LI->getType()->isIntegerTy()) if (!LI->isSimple() || !LI->getType()->isIntegerTy())
continue; continue;
auto POP = getPointerOffsetPair(*LI); auto POP = getPointerOffsetPair(*LI);
if (!POP.Pointer) if (!POP.Pointer)
continue; continue;
LoadMap[POP.Pointer].push_back(LoadPOPPair(LI, POP, Index++)); LoadMap[POP.Pointer].emplace_back(LI, POP, Index++);
AST.add(LI); AST.add(LI);
} }
if (combineLoads(LoadMap)) if (combineLoads(LoadMap))
Combined = true; Combined = true;
return Combined; return Combined;
} }
char LoadCombine::ID = 0; char LoadCombine::ID = 0;
BasicBlockPass *llvm::createLoadCombinePass() { BasicBlockPass *llvm::createLoadCombinePass() {
return new LoadCombine(); return new LoadCombine();
} }
INITIALIZE_PASS_BEGIN(LoadCombine, "load-combine", LDCOMBINE_NAME, false, false) INITIALIZE_PASS_BEGIN(LoadCombine, "load-combine", LDCOMBINE_NAME, false, false)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_END(LoadCombine, "load-combine", LDCOMBINE_NAME, false, false) INITIALIZE_PASS_END(LoadCombine, "load-combine", LDCOMBINE_NAME, false, false)
Context not available.

lib/Transforms/Scalar/LoopInstSimplify.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
bool Changed = false; bool Changed = false;
bool LocalChanged; bool LocalChanged;
do { do {
LocalChanged = false; LocalChanged = false;
VisitStack.clear(); VisitStack.clear();
Visited.clear(); Visited.clear();
VisitStack.push_back(WorklistItem(L->getHeader(), false)); VisitStack.emplace_back(L->getHeader(), false);
while (!VisitStack.empty()) { while (!VisitStack.empty()) {
WorklistItem Item = VisitStack.pop_back_val(); WorklistItem Item = VisitStack.pop_back_val();
BasicBlock *BB = Item.getPointer(); BasicBlock *BB = Item.getPointer();
bool IsSubloopHeader = Item.getInt(); bool IsSubloopHeader = Item.getInt();
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout(); const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
// Simplify instructions in the current basic block. // Simplify instructions in the current basic block.
Show All 39 Lines
++SI) { ++SI) {
BasicBlock *SuccBB = *SI; BasicBlock *SuccBB = *SI;
if (!Visited.insert(SuccBB).second) if (!Visited.insert(SuccBB).second)
continue; continue;
const Loop *SuccLoop = LI->getLoopFor(SuccBB); const Loop *SuccLoop = LI->getLoopFor(SuccBB);
if (SuccLoop && SuccLoop->getHeader() == SuccBB if (SuccLoop && SuccLoop->getHeader() == SuccBB
&& L->contains(SuccLoop)) { && L->contains(SuccLoop)) {
VisitStack.push_back(WorklistItem(SuccBB, true)); VisitStack.emplace_back(SuccBB, true);
SmallVector<BasicBlock*, 8> SubLoopExitBlocks; SmallVector<BasicBlock*, 8> SubLoopExitBlocks;
SuccLoop->getExitBlocks(SubLoopExitBlocks); SuccLoop->getExitBlocks(SubLoopExitBlocks);
for (unsigned i = 0; i < SubLoopExitBlocks.size(); ++i) { for (unsigned i = 0; i < SubLoopExitBlocks.size(); ++i) {
BasicBlock *ExitBB = SubLoopExitBlocks[i]; BasicBlock *ExitBB = SubLoopExitBlocks[i];
if (LI->getLoopFor(ExitBB) == L && Visited.insert(ExitBB).second) if (LI->getLoopFor(ExitBB) == L && Visited.insert(ExitBB).second)
VisitStack.push_back(WorklistItem(ExitBB, false)); VisitStack.emplace_back(ExitBB, false);
} }
continue; continue;
} }
bool IsExitBlock = std::binary_search(ExitBlocks.begin(), bool IsExitBlock = std::binary_search(ExitBlocks.begin(),
ExitBlocks.end(), SuccBB); ExitBlocks.end(), SuccBB);
if (IsExitBlock) if (IsExitBlock)
continue; continue;
VisitStack.push_back(WorklistItem(SuccBB, false)); VisitStack.emplace_back(SuccBB, false);
} }
} }
// Place the list of instructions to simplify on the next loop iteration // Place the list of instructions to simplify on the next loop iteration
// into ToSimplify. // into ToSimplify.
std::swap(ToSimplify, Next); std::swap(ToSimplify, Next);
Next->clear(); Next->clear();
Changed |= LocalChanged; Changed |= LocalChanged;
} while (LocalChanged); } while (LocalChanged);
return Changed; return Changed;
} }
Context not available.

lib/Transforms/Scalar/LoopStrengthReduce.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (M == J || M == JE) continue; if (M == J || M == JE) continue;
// Compute the difference between the two. // Compute the difference between the two.
int64_t Imm = (uint64_t)JImm - M->first; int64_t Imm = (uint64_t)JImm - M->first;
for (int LUIdx = UsedByIndices.find_first(); LUIdx != -1; for (int LUIdx = UsedByIndices.find_first(); LUIdx != -1;
LUIdx = UsedByIndices.find_next(LUIdx)) LUIdx = UsedByIndices.find_next(LUIdx))
// Make a memo of this use, offset, and register tuple. // Make a memo of this use, offset, and register tuple.
if (UniqueItems.insert(std::make_pair(LUIdx, Imm)).second) if (UniqueItems.insert(std::make_pair(LUIdx, Imm)).second)
WorkItems.push_back(WorkItem(LUIdx, Imm, OrigReg)); WorkItems.emplace_back(LUIdx, Imm, OrigReg);
} }
} }
} }
Map.clear(); Map.clear();
Sequence.clear(); Sequence.clear();
UsedByIndicesMap.clear(); UsedByIndicesMap.clear();
UniqueItems.clear(); UniqueItems.clear();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoopUnrollPass.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
"Must have an incoming value only for the preheader and the latch."); "Must have an incoming value only for the preheader and the latch.");
Value *V = PHI->getIncomingValueForBlock( Value *V = PHI->getIncomingValueForBlock(
Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch()); Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch());
Constant *C = dyn_cast<Constant>(V); Constant *C = dyn_cast<Constant>(V);
if (Iteration != 0 && !C) if (Iteration != 0 && !C)
C = SimplifiedValues.lookup(V); C = SimplifiedValues.lookup(V);
if (C) if (C)
SimplifiedInputValues.push_back({PHI, C}); SimplifiedInputValues.emplace_back(PHI, C);
} }
// Now clear and re-populate the map for the next iteration. // Now clear and re-populate the map for the next iteration.
SimplifiedValues.clear(); SimplifiedValues.clear();
while (!SimplifiedInputValues.empty()) while (!SimplifiedInputValues.empty())
SimplifiedValues.insert(SimplifiedInputValues.pop_back_val()); SimplifiedValues.insert(SimplifiedInputValues.pop_back_val());
UnrolledInstAnalyzer Analyzer(Iteration, SimplifiedValues, SE, L); UnrolledInstAnalyzer Analyzer(Iteration, SimplifiedValues, SE, L);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/PlaceSafepoints.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
assert(ParsePointsNeeded.empty()); assert(ParsePointsNeeded.empty());
for (auto *CI : Calls) { for (auto *CI : Calls) {
// No safepoint needed or wanted // No safepoint needed or wanted
if (!needsStatepoint(CI)) if (!needsStatepoint(CI))
continue; continue;
// These are likely runtime calls. Should we assert that via calling // These are likely runtime calls. Should we assert that via calling
// convention or something? // convention or something?
ParsePointsNeeded.push_back(CallSite(CI)); ParsePointsNeeded.emplace_back(CI);
} }
assert(ParsePointsNeeded.size() <= Calls.size()); assert(ParsePointsNeeded.size() <= Calls.size());
} }
Context not available.

lib/Transforms/Scalar/SROA.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (Size > AllocSize - BeginOffset) { if (Size > AllocSize - BeginOffset) {
DEBUG(dbgs() << "WARNING: Clamping a " << Size << " byte use @" << Offset DEBUG(dbgs() << "WARNING: Clamping a " << Size << " byte use @" << Offset
<< " to remain within the " << AllocSize << " byte alloca:\n" << " to remain within the " << AllocSize << " byte alloca:\n"
<< " alloca: " << AS.AI << "\n" << " alloca: " << AS.AI << "\n"
<< " use: " << I << "\n"); << " use: " << I << "\n");
EndOffset = AllocSize; EndOffset = AllocSize;
} }
AS.Slices.push_back(Slice(BeginOffset, EndOffset, U, IsSplittable)); AS.Slices.emplace_back(BeginOffset, EndOffset, U, IsSplittable);
} }
void visitBitCastInst(BitCastInst &BC) { void visitBitCastInst(BitCastInst &BC) {
if (BC.use_empty()) if (BC.use_empty())
return markAsDead(BC); return markAsDead(BC);
return Base::visitBitCastInst(BC); return Base::visitBitCastInst(BC);
} }
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
getAdjustedAlignment(LI, PartOffset, DL), /*IsVolatile*/ false, getAdjustedAlignment(LI, PartOffset, DL), /*IsVolatile*/ false,
LI->getName()); LI->getName());
// Append this load onto the list of split loads so we can find it later // Append this load onto the list of split loads so we can find it later
// to rewrite the stores. // to rewrite the stores.
SplitLoads.push_back(PLoad); SplitLoads.push_back(PLoad);
// Now build a new slice for the alloca. // Now build a new slice for the alloca.
NewSlices.push_back( NewSlices.emplace_back(BaseOffset + PartOffset, BaseOffset + PartOffset + PartSize,
Slice(BaseOffset + PartOffset, BaseOffset + PartOffset + PartSize,
&PLoad->getOperandUse(PLoad->getPointerOperandIndex()), &PLoad->getOperandUse(PLoad->getPointerOperandIndex()),
/*IsSplittable*/ false)); /*IsSplittable*/ false);
DEBUG(dbgs() << " new slice [" << NewSlices.back().beginOffset() DEBUG(dbgs() << " new slice [" << NewSlices.back().beginOffset()
<< ", " << NewSlices.back().endOffset() << "): " << *PLoad << ", " << NewSlices.back().endOffset() << "): " << *PLoad
<< "\n"); << "\n");
// See if we've handled all the splits. // See if we've handled all the splits.
if (Idx >= Size) if (Idx >= Size)
break; break;
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
IRB.SetInsertPoint(SI); IRB.SetInsertPoint(SI);
StoreInst *PStore = IRB.CreateAlignedStore( StoreInst *PStore = IRB.CreateAlignedStore(
PLoad, getAdjustedPtr(IRB, DL, StoreBasePtr, PLoad, getAdjustedPtr(IRB, DL, StoreBasePtr,
APInt(DL.getPointerSizeInBits(), PartOffset), APInt(DL.getPointerSizeInBits(), PartOffset),
PartPtrTy, StoreBasePtr->getName() + "."), PartPtrTy, StoreBasePtr->getName() + "."),
getAdjustedAlignment(SI, PartOffset, DL), /*IsVolatile*/ false); getAdjustedAlignment(SI, PartOffset, DL), /*IsVolatile*/ false);
// Now build a new slice for the alloca. // Now build a new slice for the alloca.
NewSlices.push_back( NewSlices.emplace_back(BaseOffset + PartOffset, BaseOffset + PartOffset + PartSize,
Slice(BaseOffset + PartOffset, BaseOffset + PartOffset + PartSize,
&PStore->getOperandUse(PStore->getPointerOperandIndex()), &PStore->getOperandUse(PStore->getPointerOperandIndex()),
/*IsSplittable*/ false)); /*IsSplittable*/ false);
DEBUG(dbgs() << " new slice [" << NewSlices.back().beginOffset() DEBUG(dbgs() << " new slice [" << NewSlices.back().beginOffset()
<< ", " << NewSlices.back().endOffset() << "): " << *PStore << ", " << NewSlices.back().endOffset() << "): " << *PStore
<< "\n"); << "\n");
if (!SplitLoads) { if (!SplitLoads) {
DEBUG(dbgs() << " of split load: " << *PLoad << "\n"); DEBUG(dbgs() << " of split load: " << *PLoad << "\n");
} }
// See if we've finished all the splits. // See if we've finished all the splits.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
for (auto &P : AS.partitions()) { for (auto &P : AS.partitions()) {
if (AllocaInst *NewAI = rewritePartition(AI, AS, P)) { if (AllocaInst *NewAI = rewritePartition(AI, AS, P)) {
Changed = true; Changed = true;
if (NewAI != &AI) { if (NewAI != &AI) {
uint64_t SizeOfByte = 8; uint64_t SizeOfByte = 8;
uint64_t AllocaSize = DL.getTypeSizeInBits(NewAI->getAllocatedType()); uint64_t AllocaSize = DL.getTypeSizeInBits(NewAI->getAllocatedType());
// Don't include any padding. // Don't include any padding.
uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte); uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte);
Pieces.push_back(Piece(NewAI, P.beginOffset() * SizeOfByte, Size)); Pieces.emplace_back(NewAI, P.beginOffset() * SizeOfByte, Size);
} }
} }
++NumPartitions; ++NumPartitions;
} }
NumAllocaPartitions += NumPartitions; NumAllocaPartitions += NumPartitions;
MaxPartitionsPerAlloca = MaxPartitionsPerAlloca =
std::max<unsigned>(NumPartitions, MaxPartitionsPerAlloca); std::max<unsigned>(NumPartitions, MaxPartitionsPerAlloca);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Scalar/Scalarizer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
for (unsigned I = 0, E = SV.size(); I != E; ++I) { for (unsigned I = 0, E = SV.size(); I != E; ++I) {
Instruction *Old = cast<Instruction>(SV[I]); Instruction *Old = cast<Instruction>(SV[I]);
CV[I]->takeName(Old); CV[I]->takeName(Old);
Old->replaceAllUsesWith(CV[I]); Old->replaceAllUsesWith(CV[I]);
Old->eraseFromParent(); Old->eraseFromParent();
} }
} }
SV = CV; SV = CV;
Gathered.push_back(GatherList::value_type(Op, &SV)); Gathered.emplace_back(Op, &SV);
} }
// Return true if it is safe to transfer the given metadata tag from // Return true if it is safe to transfer the given metadata tag from
// vector to scalar instructions. // vector to scalar instructions.
bool Scalarizer::canTransferMetadata(unsigned Tag) { bool Scalarizer::canTransferMetadata(unsigned Tag) {
return (Tag == LLVMContext::MD_tbaa return (Tag == LLVMContext::MD_tbaa
|| Tag == LLVMContext::MD_fpmath || Tag == LLVMContext::MD_fpmath
|| Tag == LLVMContext::MD_tbaa_struct || Tag == LLVMContext::MD_tbaa_struct
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Utils/LowerSwitch.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
} }
/// Transform simple list of Cases into list of CaseRange's. /// Transform simple list of Cases into list of CaseRange's.
unsigned LowerSwitch::Clusterify(CaseVector& Cases, SwitchInst *SI) { unsigned LowerSwitch::Clusterify(CaseVector& Cases, SwitchInst *SI) {
unsigned numCmps = 0; unsigned numCmps = 0;
// Start with "simple" cases // Start with "simple" cases
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i) for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i)
Cases.push_back(CaseRange(i.getCaseValue(), i.getCaseValue(), Cases.emplace_back(i.getCaseValue(), i.getCaseValue(),
i.getCaseSuccessor())); i.getCaseSuccessor());
std::sort(Cases.begin(), Cases.end(), CaseCmp()); std::sort(Cases.begin(), Cases.end(), CaseCmp());
// Merge case into clusters // Merge case into clusters
if (Cases.size() >= 2) { if (Cases.size() >= 2) {
CaseItr I = Cases.begin(); CaseItr I = Cases.begin();
for (CaseItr J = std::next(I), E = Cases.end(); J != E; ++J) { for (CaseItr J = std::next(I), E = Cases.end(); J != E; ++J) {
int64_t nextValue = J->Low->getSExtValue(); int64_t nextValue = J->Low->getSExtValue();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Utils/MemorySSA.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
/// \brief This is the standard SSA renaming algorithm. /// \brief This is the standard SSA renaming algorithm.
/// ///
/// We walk the dominator tree in preorder, renaming accesses, and then filling /// We walk the dominator tree in preorder, renaming accesses, and then filling
/// in phi nodes in our successors. /// in phi nodes in our successors.
void MemorySSA::renamePass(DomTreeNode *Root, MemoryAccess *IncomingVal, void MemorySSA::renamePass(DomTreeNode *Root, MemoryAccess *IncomingVal,
SmallPtrSet<BasicBlock *, 16> &Visited) { SmallPtrSet<BasicBlock *, 16> &Visited) {
SmallVector<RenamePassData, 32> WorkStack; SmallVector<RenamePassData, 32> WorkStack;
IncomingVal = renameBlock(Root->getBlock(), IncomingVal); IncomingVal = renameBlock(Root->getBlock(), IncomingVal);
WorkStack.push_back({Root, Root->begin(), IncomingVal}); WorkStack.emplace_back(Root, Root->begin(), IncomingVal);
Visited.insert(Root->getBlock()); Visited.insert(Root->getBlock());
while (!WorkStack.empty()) { while (!WorkStack.empty()) {
DomTreeNode *Node = WorkStack.back().DTN; DomTreeNode *Node = WorkStack.back().DTN;
DomTreeNode::const_iterator ChildIt = WorkStack.back().ChildIt; DomTreeNode::const_iterator ChildIt = WorkStack.back().ChildIt;
IncomingVal = WorkStack.back().IncomingVal; IncomingVal = WorkStack.back().IncomingVal;
if (ChildIt == Node->end()) { if (ChildIt == Node->end()) {
WorkStack.pop_back(); WorkStack.pop_back();
} else { } else {
DomTreeNode *Child = *ChildIt; DomTreeNode *Child = *ChildIt;
++WorkStack.back().ChildIt; ++WorkStack.back().ChildIt;
BasicBlock *BB = Child->getBlock(); BasicBlock *BB = Child->getBlock();
Visited.insert(BB); Visited.insert(BB);
IncomingVal = renameBlock(BB, IncomingVal); IncomingVal = renameBlock(BB, IncomingVal);
WorkStack.push_back({Child, Child->begin(), IncomingVal}); WorkStack.emplace_back(Child, Child->begin(), IncomingVal);
} }
} }
} }
/// \brief Compute dominator levels, used by the phi insertion algorithm above. /// \brief Compute dominator levels, used by the phi insertion algorithm above.
void MemorySSA::computeDomLevels(DenseMap<DomTreeNode *, unsigned> &DomLevels) { void MemorySSA::computeDomLevels(DenseMap<DomTreeNode *, unsigned> &DomLevels) {
for (auto DFI = df_begin(DT->getRootNode()), DFE = df_end(DT->getRootNode()); for (auto DFI = df_begin(DT->getRootNode()), DFE = df_end(DT->getRootNode());
DFI != DFE; ++DFI) DFI != DFE; ++DFI)
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Utils/SimplifyCFG.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
/// Given a value comparison instruction, /// Given a value comparison instruction,
/// decode all of the 'cases' that it represents and return the 'default' block. /// decode all of the 'cases' that it represents and return the 'default' block.
BasicBlock *SimplifyCFGOpt::GetValueEqualityComparisonCases( BasicBlock *SimplifyCFGOpt::GetValueEqualityComparisonCases(
TerminatorInst *TI, std::vector<ValueEqualityComparisonCase> &Cases) { TerminatorInst *TI, std::vector<ValueEqualityComparisonCase> &Cases) {
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
Cases.reserve(SI->getNumCases()); Cases.reserve(SI->getNumCases());
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e;
++i) ++i)
Cases.push_back( Cases.emplace_back(i.getCaseValue(), i.getCaseSuccessor());
ValueEqualityComparisonCase(i.getCaseValue(), i.getCaseSuccessor()));
return SI->getDefaultDest(); return SI->getDefaultDest();
} }
BranchInst *BI = cast<BranchInst>(TI); BranchInst *BI = cast<BranchInst>(TI);
ICmpInst *ICI = cast<ICmpInst>(BI->getCondition()); ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());
BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE); BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE);
Cases.push_back(ValueEqualityComparisonCase( Cases.emplace_back(
GetConstantInt(ICI->getOperand(1), DL), Succ)); GetConstantInt(ICI->getOperand(1), DL), Succ);
return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ); return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);
} }
/// Given a vector of bb/value pairs, remove any entries /// Given a vector of bb/value pairs, remove any entries
/// in the list that match the specified block. /// in the list that match the specified block.
static void static void
EliminateBlockCases(BasicBlock *BB, EliminateBlockCases(BasicBlock *BB,
std::vector<ValueEqualityComparisonCase> &Cases) { std::vector<ValueEqualityComparisonCase> &Cases) {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// If there are any constants vectored to BB that TI doesn't handle, // If there are any constants vectored to BB that TI doesn't handle,
// they must go to the default destination of TI. // they must go to the default destination of TI.
for (std::set<ConstantInt *, ConstantIntOrdering>::iterator for (std::set<ConstantInt *, ConstantIntOrdering>::iterator
I = PTIHandled.begin(), I = PTIHandled.begin(),
E = PTIHandled.end(); E = PTIHandled.end();
I != E; ++I) { I != E; ++I) {
if (PredHasWeights || SuccHasWeights) if (PredHasWeights || SuccHasWeights)
Weights.push_back(WeightsForHandled[*I]); Weights.push_back(WeightsForHandled[*I]);
PredCases.push_back(ValueEqualityComparisonCase(*I, BBDefault)); PredCases.emplace_back(*I, BBDefault);
NewSuccessors.push_back(BBDefault); NewSuccessors.push_back(BBDefault);
} }
} }
// Okay, at this point, we know which new successor Pred will get. Make // Okay, at this point, we know which new successor Pred will get. Make
// sure we update the number of entries in the PHI nodes for these // sure we update the number of entries in the PHI nodes for these
// successors. // successors.
for (BasicBlock *NewSuccessor : NewSuccessors) for (BasicBlock *NewSuccessor : NewSuccessors)
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Utils/SplitModule.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SmallVector<SortType, 64> Sets; SmallVector<SortType, 64> Sets;
SmallPtrSet<const GlobalValue *, 32> Visited; SmallPtrSet<const GlobalValue *, 32> Visited;
// To guarantee determinism, we have to sort SCC according to size. // To guarantee determinism, we have to sort SCC according to size.
// When size is the same, use leader's name. // When size is the same, use leader's name.
for (ClusterMapType::iterator I = GVtoClusterMap.begin(), for (ClusterMapType::iterator I = GVtoClusterMap.begin(),
E = GVtoClusterMap.end(); I != E; ++I) E = GVtoClusterMap.end(); I != E; ++I)
if (I->isLeader()) if (I->isLeader())
Sets.push_back( Sets.emplace_back(std::make_pair(std::distance(GVtoClusterMap.member_begin(I),
std::make_pair(std::distance(GVtoClusterMap.member_begin(I),
GVtoClusterMap.member_end()), I)); GVtoClusterMap.member_end()), I));
std::sort(Sets.begin(), Sets.end(), [](const SortType &a, const SortType &b) { std::sort(Sets.begin(), Sets.end(), [](const SortType &a, const SortType &b) {
if (a.first == b.first) if (a.first == b.first)
return a.second->getData()->getName() > b.second->getData()->getName(); return a.second->getData()->getName() > b.second->getData()->getName();
else else
return a.first > b.first; return a.first > b.first;
}); });
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Utils/ValueMapper.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
/// ValueMapper should explicitly call \a flush() before destruction. /// ValueMapper should explicitly call \a flush() before destruction.
~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); } ~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); }
bool hasWorkToDo() const { return !Worklist.empty(); } bool hasWorkToDo() const { return !Worklist.empty(); }
unsigned unsigned
registerAlternateMappingContext(ValueToValueMapTy &VM, registerAlternateMappingContext(ValueToValueMapTy &VM,
ValueMaterializer *Materializer = nullptr) { ValueMaterializer *Materializer = nullptr) {
MCs.push_back(MappingContext(VM, Materializer)); MCs.emplace_back(VM, Materializer);
return MCs.size() - 1; return MCs.size() - 1;
} }
void addFlags(RemapFlags Flags); void addFlags(RemapFlags Flags);
Value *mapValue(const Value *V); Value *mapValue(const Value *V);
void remapInstruction(Instruction *I); void remapInstruction(Instruction *I);
void remapFunction(Function &F); void remapFunction(Function &F);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lib/Transforms/Vectorize/BBVectorize.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
DenseSet<ValuePair> &PairableInstUsers, DenseSet<ValuePair> &PairableInstUsers,
DenseMap<Value *, Value *> &ChosenPairs, DenseMap<Value *, Value *> &ChosenPairs,
DenseMap<ValuePair, size_t> &DAG, ValuePair J) { DenseMap<ValuePair, size_t> &DAG, ValuePair J) {
// Each of these pairs is viewed as the root node of a DAG. The DAG // Each of these pairs is viewed as the root node of a DAG. The DAG
// is then walked (depth-first). As this happens, we keep track of // is then walked (depth-first). As this happens, we keep track of
// the pairs that compose the DAG and the maximum depth of the DAG. // the pairs that compose the DAG and the maximum depth of the DAG.
SmallVector<ValuePairWithDepth, 32> Q; SmallVector<ValuePairWithDepth, 32> Q;
// General depth-first post-order traversal: // General depth-first post-order traversal:
Q.push_back(ValuePairWithDepth(J, getDepthFactor(J.first))); Q.emplace_back(J, getDepthFactor(J.first));
do { do {
ValuePairWithDepth QTop = Q.back(); ValuePairWithDepth QTop = Q.back();
// Push each child onto the queue: // Push each child onto the queue:
bool MoreChildren = false; bool MoreChildren = false;
size_t MaxChildDepth = QTop.second; size_t MaxChildDepth = QTop.second;
DenseMap<ValuePair, std::vector<ValuePair> >::iterator QQ = DenseMap<ValuePair, std::vector<ValuePair> >::iterator QQ =
ConnectedPairs.find(QTop.first); ConnectedPairs.find(QTop.first);
if (QQ != ConnectedPairs.end()) if (QQ != ConnectedPairs.end())
for (std::vector<ValuePair>::iterator k = QQ->second.begin(), for (std::vector<ValuePair>::iterator k = QQ->second.begin(),
ke = QQ->second.end(); k != ke; ++k) { ke = QQ->second.end(); k != ke; ++k) {
// Make sure that this child pair is still a candidate: // Make sure that this child pair is still a candidate:
if (CandidatePairsSet.count(*k)) { if (CandidatePairsSet.count(*k)) {
DenseMap<ValuePair, size_t>::iterator C = DAG.find(*k); DenseMap<ValuePair, size_t>::iterator C = DAG.find(*k);
if (C == DAG.end()) { if (C == DAG.end()) {
size_t d = getDepthFactor(k->first); size_t d = getDepthFactor(k->first);
Q.push_back(ValuePairWithDepth(*k, QTop.second+d)); Q.emplace_back(*k, QTop.second+d);
MoreChildren = true; MoreChildren = true;
} else { } else {
MaxChildDepth = std::max(MaxChildDepth, C->second); MaxChildDepth = std::max(MaxChildDepth, C->second);
} }
} }
} }
if (!MoreChildren) { if (!MoreChildren) {
Show All 14 Lines
DenseMap<ValuePair, std::vector<ValuePair> > &PairableInstUserMap, DenseMap<ValuePair, std::vector<ValuePair> > &PairableInstUserMap,
DenseSet<VPPair> &PairableInstUserPairSet, DenseSet<VPPair> &PairableInstUserPairSet,
DenseMap<Value *, Value *> &ChosenPairs, DenseMap<Value *, Value *> &ChosenPairs,
DenseMap<ValuePair, size_t> &DAG, DenseMap<ValuePair, size_t> &DAG,
DenseSet<ValuePair> &PrunedDAG, ValuePair J, DenseSet<ValuePair> &PrunedDAG, ValuePair J,
bool UseCycleCheck) { bool UseCycleCheck) {
SmallVector<ValuePairWithDepth, 32> Q; SmallVector<ValuePairWithDepth, 32> Q;
// General depth-first post-order traversal: // General depth-first post-order traversal:
Q.push_back(ValuePairWithDepth(J, getDepthFactor(J.first))); Q.emplace_back(J, getDepthFactor(J.first));
do { do {
ValuePairWithDepth QTop = Q.pop_back_val(); ValuePairWithDepth QTop = Q.pop_back_val();
PrunedDAG.insert(QTop.first); PrunedDAG.insert(QTop.first);
// Visit each child, pruning as necessary... // Visit each child, pruning as necessary...
SmallVector<ValuePairWithDepth, 8> BestChildren; SmallVector<ValuePairWithDepth, 8> BestChildren;
DenseMap<ValuePair, std::vector<ValuePair> >::iterator QQ = DenseMap<ValuePair, std::vector<ValuePair> >::iterator QQ =
ConnectedPairs.find(QTop.first); ConnectedPairs.find(QTop.first);
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
C2->first.second == C->first.first || C2->first.second == C->first.first ||
C2->first.second == C->first.second || C2->first.second == C->first.second ||
pairsConflict(C2->first, C->first, PairableInstUsers)) pairsConflict(C2->first, C->first, PairableInstUsers))
C2 = BestChildren.erase(C2); C2 = BestChildren.erase(C2);
else else
++C2; ++C2;
} }
BestChildren.push_back(ValuePairWithDepth(C->first, C->second)); BestChildren.emplace_back(C->first, C->second);
} }
for (SmallVectorImpl<ValuePairWithDepth>::iterator C for (SmallVectorImpl<ValuePairWithDepth>::iterator C
= BestChildren.begin(), E2 = BestChildren.end(); = BestChildren.begin(), E2 = BestChildren.end();
C != E2; ++C) { C != E2; ++C) {
size_t DepthF = getDepthFactor(C->first.first); size_t DepthF = getDepthFactor(C->first.first);
Q.push_back(ValuePairWithDepth(C->first, QTop.second+DepthF)); Q.emplace_back(C->first, QTop.second+DepthF);
} }
} while (!Q.empty()); } while (!Q.empty());
} }
// This function finds the best dag of mututally-compatible connected // This function finds the best dag of mututally-compatible connected
// pairs, given the choice of root pairs as an iterator range. // pairs, given the choice of root pairs as an iterator range.
void BBVectorize::findBestDAGFor( void BBVectorize::findBestDAGFor(
DenseMap<Value *, std::vector<Value *> > &CandidatePairs, DenseMap<Value *, std::vector<Value *> > &CandidatePairs,
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// yet-to-be-fused pair. The loads in question are the keys of the map. // yet-to-be-fused pair. The loads in question are the keys of the map.
if (I->mayReadFromMemory()) { if (I->mayReadFromMemory()) {
std::vector<ValuePair> NewSetMembers; std::vector<ValuePair> NewSetMembers;
DenseMap<Value *, std::vector<Value *> >::iterator II = DenseMap<Value *, std::vector<Value *> >::iterator II =
LoadMoveSet.find(I); LoadMoveSet.find(I);
if (II != LoadMoveSet.end()) if (II != LoadMoveSet.end())
for (std::vector<Value *>::iterator N = II->second.begin(), for (std::vector<Value *>::iterator N = II->second.begin(),
NE = II->second.end(); N != NE; ++N) NE = II->second.end(); N != NE; ++N)
NewSetMembers.push_back(ValuePair(K, *N)); NewSetMembers.emplace_back(K, *N);
DenseMap<Value *, std::vector<Value *> >::iterator JJ = DenseMap<Value *, std::vector<Value *> >::iterator JJ =
LoadMoveSet.find(J); LoadMoveSet.find(J);
if (JJ != LoadMoveSet.end()) if (JJ != LoadMoveSet.end())
for (std::vector<Value *>::iterator N = JJ->second.begin(), for (std::vector<Value *>::iterator N = JJ->second.begin(),
NE = JJ->second.end(); N != NE; ++N) NE = JJ->second.end(); N != NE; ++N)
NewSetMembers.push_back(ValuePair(K, *N)); NewSetMembers.emplace_back(K, *N);
for (std::vector<ValuePair>::iterator A = NewSetMembers.begin(), for (std::vector<ValuePair>::iterator A = NewSetMembers.begin(),
AE = NewSetMembers.end(); A != AE; ++A) { AE = NewSetMembers.end(); A != AE; ++A) {
LoadMoveSet[A->first].push_back(A->second); LoadMoveSet[A->first].push_back(A->second);
LoadMoveSetPairs.insert(*A); LoadMoveSetPairs.insert(*A);
} }
} }
// Before removing I, set the iterator to the next instruction. // Before removing I, set the iterator to the next instruction.
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lib/Transforms/Vectorize/SLPVectorizer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// Ignore users in the user ignore list. // Ignore users in the user ignore list.
if (std::find(UserIgnoreList.begin(), UserIgnoreList.end(), UserInst) != if (std::find(UserIgnoreList.begin(), UserIgnoreList.end(), UserInst) !=
UserIgnoreList.end()) UserIgnoreList.end())
continue; continue;
DEBUG(dbgs() << "SLP: Need to extract:" << *U << " from lane " << DEBUG(dbgs() << "SLP: Need to extract:" << *U << " from lane " <<
Lane << " from " << *Scalar << ".\n"); Lane << " from " << *Scalar << ".\n");
ExternalUses.push_back(ExternalUser(Scalar, U, Lane)); ExternalUses.emplace_back(Scalar, U, Lane);
} }
} }
} }
} }
void BoUpSLP::buildTree_rec(ArrayRef<Value *> VL, unsigned Depth) { void BoUpSLP::buildTree_rec(ArrayRef<Value *> VL, unsigned Depth) {
bool SameTy = allConstant(VL) || getSameType(VL); (void)SameTy; bool SameTy = allConstant(VL) || getSameType(VL); (void)SameTy;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
for (unsigned Lane = 0, LE = VL.size(); Lane != LE; ++Lane) { for (unsigned Lane = 0, LE = VL.size(); Lane != LE; ++Lane) {
// Is this the lane of the scalar that we are looking for ? // Is this the lane of the scalar that we are looking for ?
if (E->Scalars[Lane] == VL[i]) { if (E->Scalars[Lane] == VL[i]) {
FoundLane = Lane; FoundLane = Lane;
break; break;
} }
} }
assert(FoundLane >= 0 && "Could not find the correct lane"); assert(FoundLane >= 0 && "Could not find the correct lane");
ExternalUses.push_back(ExternalUser(VL[i], Insrt, FoundLane)); ExternalUses.emplace_back(VL[i], Insrt, FoundLane);
} }
} }
} }
return Vec; return Vec;
} }
Value *BoUpSLP::alreadyVectorized(ArrayRef<Value *> VL) const { Value *BoUpSLP::alreadyVectorized(ArrayRef<Value *> VL) const {
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
Value *VecPtr = Builder.CreateBitCast(LI->getPointerOperand(), Value *VecPtr = Builder.CreateBitCast(LI->getPointerOperand(),
VecTy->getPointerTo(AS)); VecTy->getPointerTo(AS));
// The pointer operand uses an in-tree scalar so we add the new BitCast to // The pointer operand uses an in-tree scalar so we add the new BitCast to
// ExternalUses list to make sure that an extract will be generated in the // ExternalUses list to make sure that an extract will be generated in the
// future. // future.
if (ScalarToTreeEntry.count(LI->getPointerOperand())) if (ScalarToTreeEntry.count(LI->getPointerOperand()))
ExternalUses.push_back( ExternalUses.emplace_back(LI->getPointerOperand(), cast<User>(VecPtr), 0);
ExternalUser(LI->getPointerOperand(), cast<User>(VecPtr), 0));
unsigned Alignment = LI->getAlignment(); unsigned Alignment = LI->getAlignment();
LI = Builder.CreateLoad(VecPtr); LI = Builder.CreateLoad(VecPtr);
if (!Alignment) { if (!Alignment) {
Alignment = DL->getABITypeAlignment(ScalarLoadTy); Alignment = DL->getABITypeAlignment(ScalarLoadTy);
} }
LI->setAlignment(Alignment); LI->setAlignment(Alignment);
E->VectorizedValue = LI; E->VectorizedValue = LI;
Show All 15 Lines
Value *VecPtr = Builder.CreateBitCast(SI->getPointerOperand(), Value *VecPtr = Builder.CreateBitCast(SI->getPointerOperand(),
VecTy->getPointerTo(AS)); VecTy->getPointerTo(AS));
StoreInst *S = Builder.CreateStore(VecValue, VecPtr); StoreInst *S = Builder.CreateStore(VecValue, VecPtr);
// The pointer operand uses an in-tree scalar so we add the new BitCast to // The pointer operand uses an in-tree scalar so we add the new BitCast to
// ExternalUses list to make sure that an extract will be generated in the // ExternalUses list to make sure that an extract will be generated in the
// future. // future.
if (ScalarToTreeEntry.count(SI->getPointerOperand())) if (ScalarToTreeEntry.count(SI->getPointerOperand()))
ExternalUses.push_back( ExternalUses.emplace_back(SI->getPointerOperand(), cast<User>(VecPtr), 0);
ExternalUser(SI->getPointerOperand(), cast<User>(VecPtr), 0));
if (!Alignment) { if (!Alignment) {
Alignment = DL->getABITypeAlignment(SI->getValueOperand()->getType()); Alignment = DL->getABITypeAlignment(SI->getValueOperand()->getType());
} }
S->setAlignment(Alignment); S->setAlignment(Alignment);
E->VectorizedValue = S; E->VectorizedValue = S;
++NumVectorInstructions; ++NumVectorInstructions;
return propagateMetadata(S, E->Scalars); return propagateMetadata(S, E->Scalars);
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CI->getOperandBundlesAsDefs(OpBundles); CI->getOperandBundlesAsDefs(OpBundles);
Value *V = Builder.CreateCall(CF, OpVecs, OpBundles); Value *V = Builder.CreateCall(CF, OpVecs, OpBundles);
// The scalar argument uses an in-tree scalar so we add the new vectorized // The scalar argument uses an in-tree scalar so we add the new vectorized
// call to ExternalUses list to make sure that an extract will be // call to ExternalUses list to make sure that an extract will be
// generated in the future. // generated in the future.
if (ScalarArg && ScalarToTreeEntry.count(ScalarArg)) if (ScalarArg && ScalarToTreeEntry.count(ScalarArg))
ExternalUses.push_back(ExternalUser(ScalarArg, cast<User>(V), 0)); ExternalUses.emplace_back(ScalarArg, cast<User>(V), 0);
E->VectorizedValue = V; E->VectorizedValue = V;
++NumVectorInstructions; ++NumVectorInstructions;
return V; return V;
} }
case Instruction::ShuffleVector: { case Instruction::ShuffleVector: {
ValueList LHSVL, RHSVL; ValueList LHSVL, RHSVL;
assert(isa<BinaryOperator>(VL0) && "Invalid Shuffle Vector Operand"); assert(isa<BinaryOperator>(VL0) && "Invalid Shuffle Vector Operand");
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// We currently only support adds. // We currently only support adds.
if (ReductionOpcode != Instruction::Add && if (ReductionOpcode != Instruction::Add &&
ReductionOpcode != Instruction::FAdd) ReductionOpcode != Instruction::FAdd)
return false; return false;
// Post order traverse the reduction tree starting at B. We only handle true // Post order traverse the reduction tree starting at B. We only handle true
// trees containing only binary operators or selects. // trees containing only binary operators or selects.
SmallVector<std::pair<Instruction *, unsigned>, 32> Stack; SmallVector<std::pair<Instruction *, unsigned>, 32> Stack;
Stack.push_back(std::make_pair(B, 0)); Stack.emplace_back(std::make_pair(B, 0));
while (!Stack.empty()) { while (!Stack.empty()) {
Instruction *TreeN = Stack.back().first; Instruction *TreeN = Stack.back().first;
unsigned EdgeToVist = Stack.back().second++; unsigned EdgeToVist = Stack.back().second++;
bool IsReducedValue = TreeN->getOpcode() != ReductionOpcode; bool IsReducedValue = TreeN->getOpcode() != ReductionOpcode;
// Only handle trees in the current basic block. // Only handle trees in the current basic block.
if (TreeN->getParent() != B->getParent()) if (TreeN->getParent() != B->getParent())
return false; return false;
Show All 24 Lines
continue; continue;
} }
// Visit left or right. // Visit left or right.
Value *NextV = TreeN->getOperand(EdgeToVist); Value *NextV = TreeN->getOperand(EdgeToVist);
// We currently only allow BinaryOperator's and SelectInst's as reduction // We currently only allow BinaryOperator's and SelectInst's as reduction
// values in our tree. // values in our tree.
if (isa<BinaryOperator>(NextV) || isa<SelectInst>(NextV)) if (isa<BinaryOperator>(NextV) || isa<SelectInst>(NextV))
Stack.push_back(std::make_pair(cast<Instruction>(NextV), 0)); Stack.emplace_back(std::make_pair(cast<Instruction>(NextV), 0));
else if (NextV != Phi) else if (NextV != Phi)
return false; return false;
} }
return true; return true;
} }
/// \brief Attempt to vectorize the tree found by /// \brief Attempt to vectorize the tree found by
/// matchAssociativeReduction. /// matchAssociativeReduction.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/clang-format/ClangFormat.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return true; return true;
} }
SourceLocation Start = Sources.translateLineCol(ID, FromLine, 1); SourceLocation Start = Sources.translateLineCol(ID, FromLine, 1);
SourceLocation End = Sources.translateLineCol(ID, ToLine, UINT_MAX); SourceLocation End = Sources.translateLineCol(ID, ToLine, UINT_MAX);
if (Start.isInvalid() || End.isInvalid()) if (Start.isInvalid() || End.isInvalid())
return true; return true;
unsigned Offset = Sources.getFileOffset(Start); unsigned Offset = Sources.getFileOffset(Start);
unsigned Length = Sources.getFileOffset(End) - Offset; unsigned Length = Sources.getFileOffset(End) - Offset;
Ranges.push_back(tooling::Range(Offset, Length)); Ranges.emplace_back(Offset, Length);
} }
return false; return false;
} }
if (Offsets.empty()) if (Offsets.empty())
Offsets.push_back(0); Offsets.push_back(0);
if (Offsets.size() != Lengths.size() && if (Offsets.size() != Lengths.size() &&
!(Offsets.size() == 1 && Lengths.empty())) { !(Offsets.size() == 1 && Lengths.empty())) {
Show All 16 Lines
return true; return true;
} }
End = Start.getLocWithOffset(Lengths[i]); End = Start.getLocWithOffset(Lengths[i]);
} else { } else {
End = Sources.getLocForEndOfFile(ID); End = Sources.getLocForEndOfFile(ID);
} }
unsigned Offset = Sources.getFileOffset(Start); unsigned Offset = Sources.getFileOffset(Start);
unsigned Length = Sources.getFileOffset(End) - Offset; unsigned Length = Sources.getFileOffset(End) - Offset;
Ranges.push_back(tooling::Range(Offset, Length)); Ranges.emplace_back(Offset, Length);
} }
return false; return false;
} }
static void outputReplacementXML(StringRef Text) { static void outputReplacementXML(StringRef Text) {
// FIXME: When we sort includes, we need to make sure the stream is correct // FIXME: When we sort includes, we need to make sure the stream is correct
// utf-8. // utf-8.
size_t From = 0; size_t From = 0;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
if (SortIncludes.getNumOccurrences() != 0) if (SortIncludes.getNumOccurrences() != 0)
FormatStyle.SortIncludes = SortIncludes; FormatStyle.SortIncludes = SortIncludes;
unsigned CursorPosition = Cursor; unsigned CursorPosition = Cursor;
Replacements Replaces = sortIncludes(FormatStyle, Code->getBuffer(), Ranges, Replacements Replaces = sortIncludes(FormatStyle, Code->getBuffer(), Ranges,
AssumedFileName, &CursorPosition); AssumedFileName, &CursorPosition);
std::string ChangedCode = std::string ChangedCode =
tooling::applyAllReplacements(Code->getBuffer(), Replaces); tooling::applyAllReplacements(Code->getBuffer(), Replaces);
for (const auto &R : Replaces) for (const auto &R : Replaces)
Ranges.push_back({R.getOffset(), R.getLength()}); Ranges.emplace_back(R.getOffset(), R.getLength());
bool IncompleteFormat = false; bool IncompleteFormat = false;
Replacements FormatChanges = reformat(FormatStyle, ChangedCode, Ranges, Replacements FormatChanges = reformat(FormatStyle, ChangedCode, Ranges,
AssumedFileName, &IncompleteFormat); AssumedFileName, &IncompleteFormat);
Replaces = tooling::mergeReplacements(Replaces, FormatChanges); Replaces = tooling::mergeReplacements(Replaces, FormatChanges);
if (OutputXML) { if (OutputXML) {
outs() << "<?xml version='1.0'?>\n<replacements " outs() << "<?xml version='1.0'?>\n<replacements "
"xml:space='preserve' incomplete_format='" "xml:space='preserve' incomplete_format='"
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/diagtool/ShowEnabledWarnings.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
continue; continue;
DiagnosticsEngine::Level DiagLevel = DiagnosticsEngine::Level DiagLevel =
Diags->getDiagnosticLevel(DiagID, SourceLocation()); Diags->getDiagnosticLevel(DiagID, SourceLocation());
if (DiagLevel == DiagnosticsEngine::Ignored) if (DiagLevel == DiagnosticsEngine::Ignored)
continue; continue;
StringRef WarningOpt = DiagnosticIDs::getWarningOptionForDiag(DiagID); StringRef WarningOpt = DiagnosticIDs::getWarningOptionForDiag(DiagID);
Active.push_back(PrettyDiag(I->getName(), WarningOpt, DiagLevel)); Active.emplace_back(I->getName(), WarningOpt, DiagLevel);
} }
// Print them all out. // Print them all out.
for (std::vector<PrettyDiag>::const_iterator I = Active.begin(), for (std::vector<PrettyDiag>::const_iterator I = Active.begin(),
E = Active.end(); I != E; ++I) { E = Active.end(); I != E; ++I) {
if (ShouldShowLevels) if (ShouldShowLevels)
Out << getCharForLevel(I->Level) << " "; Out << getCharForLevel(I->Level) << " ";
Out << I->Name; Out << I->Name;
if (!I->Flag.empty()) if (!I->Flag.empty())
Out << " [-W" << I->Flag << "]"; Out << " [-W" << I->Flag << "]";
Out << '\n'; Out << '\n';
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
Context not available.

tools/libclang/CIndex.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
const DeclarationName::NameKind Kind = NI.getName().getNameKind(); const DeclarationName::NameKind Kind = NI.getName().getNameKind();
RefNamePieces Pieces; RefNamePieces Pieces;
if (WantQualifier && QLoc.isValid()) if (WantQualifier && QLoc.isValid())
Pieces.push_back(QLoc); Pieces.push_back(QLoc);
if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
Pieces.push_back(NI.getLoc()); Pieces.emplace_back(NI.getLoc());
if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid()) if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid())
Pieces.push_back(*TemplateArgsLoc); Pieces.push_back(*TemplateArgsLoc);
if (Kind == DeclarationName::CXXOperatorName) { if (Kind == DeclarationName::CXXOperatorName) {
Pieces.push_back(SourceLocation::getFromRawEncoding( Pieces.emplace_back(SourceLocation::getFromRawEncoding(
NI.getInfo().CXXOperatorName.BeginOpNameLoc)); NI.getInfo().CXXOperatorName.BeginOpNameLoc));
Pieces.push_back(SourceLocation::getFromRawEncoding( Pieces.emplace_back(SourceLocation::getFromRawEncoding(
NI.getInfo().CXXOperatorName.EndOpNameLoc)); NI.getInfo().CXXOperatorName.EndOpNameLoc));
} }
if (WantSinglePiece) { if (WantSinglePiece) {
SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
Pieces.clear(); Pieces.clear();
Pieces.push_back(R); Pieces.push_back(R);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/libclang/CXIndexDataConsumer.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (!D->hasAttrs()) if (!D->hasAttrs())
return; return;
for (const auto *A : D->attrs()) { for (const auto *A : D->attrs()) {
CXCursor C = MakeCXCursor(A, D, IdxCtx.CXTU); CXCursor C = MakeCXCursor(A, D, IdxCtx.CXTU);
CXIdxLoc Loc = IdxCtx.getIndexLoc(A->getLocation()); CXIdxLoc Loc = IdxCtx.getIndexLoc(A->getLocation());
switch (C.kind) { switch (C.kind) {
default: default:
Attrs.push_back(AttrInfo(CXIdxAttr_Unexposed, C, Loc, A)); Attrs.emplace_back(CXIdxAttr_Unexposed, C, Loc, A);
break; break;
case CXCursor_IBActionAttr: case CXCursor_IBActionAttr:
Attrs.push_back(AttrInfo(CXIdxAttr_IBAction, C, Loc, A)); Attrs.emplace_back(CXIdxAttr_IBAction, C, Loc, A);
break; break;
case CXCursor_IBOutletAttr: case CXCursor_IBOutletAttr:
Attrs.push_back(AttrInfo(CXIdxAttr_IBOutlet, C, Loc, A)); Attrs.emplace_back(CXIdxAttr_IBOutlet, C, Loc, A);
break; break;
case CXCursor_IBOutletCollectionAttr: case CXCursor_IBOutletCollectionAttr:
IBCollAttrs.push_back(IBOutletCollectionInfo(C, Loc, A)); IBCollAttrs.push_back(IBOutletCollectionInfo(C, Loc, A));
break; break;
} }
} }
for (unsigned i = 0, e = IBCollAttrs.size(); i != e; ++i) { for (unsigned i = 0, e = IBCollAttrs.size(); i != e; ++i) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/llvm-ar/llvm-ar.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
show_help("An archive name must be specified"); show_help("An archive name must be specified");
ArchiveName = RestOfArgs[0]; ArchiveName = RestOfArgs[0];
RestOfArgs.erase(RestOfArgs.begin()); RestOfArgs.erase(RestOfArgs.begin());
} }
// Copy over remaining items in RestOfArgs to our Members vector // Copy over remaining items in RestOfArgs to our Members vector
static void getMembers() { static void getMembers() {
for (auto &Arg : RestOfArgs) for (auto &Arg : RestOfArgs)
Members.push_back(Arg); Members.emplace_back(Arg);
} }
static void runMRIScript(); static void runMRIScript();
// Parse the command line options as presented and return the operation // Parse the command line options as presented and return the operation
// specified. Process all modifiers and check to make sure that constraints on // specified. Process all modifiers and check to make sure that constraints on
// modifier/operation pairs have not been violated. // modifier/operation pairs have not been violated.
static ArchiveOperation parseCommandLine() { static ArchiveOperation parseCommandLine() {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/llvm-config/llvm-config.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (PrintSharedMode && BuiltSharedLibs) { if (PrintSharedMode && BuiltSharedLibs) {
OS << "shared\n"; OS << "shared\n";
return 0; return 0;
} }
// If no components were specified, default to "all". // If no components were specified, default to "all".
if (Components.empty()) if (Components.empty())
Components.push_back("all"); Components.emplace_back("all");
// Construct the list of all the required libraries. // Construct the list of all the required libraries.
std::function<std::string(const StringRef &)> std::function<std::string(const StringRef &)>
GetComponentLibraryPathFunction = [&](const StringRef &Name) { GetComponentLibraryPathFunction = [&](const StringRef &Name) {
return GetComponentLibraryPath(Name, LinkMode == LinkModeShared); return GetComponentLibraryPath(Name, LinkMode == LinkModeShared);
}; };
std::vector<std::string> MissingLibs; std::vector<std::string> MissingLibs;
std::vector<std::string> RequiredLibs = ComputeLibsForComponents( std::vector<std::string> RequiredLibs = ComputeLibsForComponents(
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/llvm-diff/DiffLog.cpp

Show All 25 Lines
StringRef LogBuilder::getFormat() const { return Format; } StringRef LogBuilder::getFormat() const { return Format; }
unsigned LogBuilder::getNumArguments() const { return Arguments.size(); } unsigned LogBuilder::getNumArguments() const { return Arguments.size(); }
Value *LogBuilder::getArgument(unsigned I) const { return Arguments[I]; } Value *LogBuilder::getArgument(unsigned I) const { return Arguments[I]; }
DiffLogBuilder::~DiffLogBuilder() { consumer.logd(*this); } DiffLogBuilder::~DiffLogBuilder() { consumer.logd(*this); }
void DiffLogBuilder::addMatch(Instruction *L, Instruction *R) { void DiffLogBuilder::addMatch(Instruction *L, Instruction *R) {
Diff.push_back(DiffRecord(L, R)); Diff.emplace_back(L, R);
} }
void DiffLogBuilder::addLeft(Instruction *L) { void DiffLogBuilder::addLeft(Instruction *L) {
// HACK: VS 2010 has a bug in the stdlib that requires this. // HACK: VS 2010 has a bug in the stdlib that requires this.
Diff.push_back(DiffRecord(L, DiffRecord::second_type(nullptr))); Diff.emplace_back(L, DiffRecord::second_type(nullptr));
} }
void DiffLogBuilder::addRight(Instruction *R) { void DiffLogBuilder::addRight(Instruction *R) {
// HACK: VS 2010 has a bug in the stdlib that requires this. // HACK: VS 2010 has a bug in the stdlib that requires this.
Diff.push_back(DiffRecord(DiffRecord::first_type(nullptr), R)); Diff.emplace_back(DiffRecord::first_type(nullptr), R);
} }
unsigned DiffLogBuilder::getNumLines() const { return Diff.size(); } unsigned DiffLogBuilder::getNumLines() const { return Diff.size(); }
DiffChange DiffLogBuilder::getLineKind(unsigned I) const { DiffChange DiffLogBuilder::getLineKind(unsigned I) const {
return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left) return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left)
: DC_right); : DC_right);
} }
Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; } Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; }
Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; } Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; }

tools/llvm-pdbdump/llvm-pdbdump.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
auto FileByteStream = auto FileByteStream =
llvm::make_unique<FileBufferByteStream>(std::move(*OutFileOrError)); llvm::make_unique<FileBufferByteStream>(std::move(*OutFileOrError));
PDBFile Pdb(std::move(FileByteStream)); PDBFile Pdb(std::move(FileByteStream));
Pdb.setSuperBlock(&YamlObj.Headers.SuperBlock); Pdb.setSuperBlock(&YamlObj.Headers.SuperBlock);
if (YamlObj.StreamMap.hasValue()) { if (YamlObj.StreamMap.hasValue()) {
std::vector<ArrayRef<support::ulittle32_t>> StreamMap; std::vector<ArrayRef<support::ulittle32_t>> StreamMap;
for (auto &E : YamlObj.StreamMap.getValue()) { for (auto &E : YamlObj.StreamMap.getValue()) {
StreamMap.push_back(E.Blocks); StreamMap.emplace_back(E.Blocks);
} }
Pdb.setStreamMap(StreamMap); Pdb.setStreamMap(StreamMap);
} }
if (YamlObj.StreamSizes.hasValue()) { if (YamlObj.StreamSizes.hasValue()) {
Pdb.setStreamSizes(YamlObj.StreamSizes.getValue()); Pdb.setStreamSizes(YamlObj.StreamSizes.getValue());
} }
Pdb.commit(); Pdb.commit();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/llvm-readobj/ELFDumper.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
return; return;
// Has the VersionMap already been loaded? // Has the VersionMap already been loaded?
if (VersionMap.size() > 0) if (VersionMap.size() > 0)
return; return;
// The first two version indexes are reserved. // The first two version indexes are reserved.
// Index 0 is LOCAL, index 1 is GLOBAL. // Index 0 is LOCAL, index 1 is GLOBAL.
VersionMap.push_back(VersionMapEntry()); VersionMap.emplace_back();
VersionMap.push_back(VersionMapEntry()); VersionMap.emplace_back();
if (dot_gnu_version_d_sec) if (dot_gnu_version_d_sec)
LoadVersionDefs(dot_gnu_version_d_sec); LoadVersionDefs(dot_gnu_version_d_sec);
if (dot_gnu_version_r_sec) if (dot_gnu_version_r_sec)
LoadVersionNeeds(dot_gnu_version_r_sec); LoadVersionNeeds(dot_gnu_version_r_sec);
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/obj2yaml/macho2yaml.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned Count; unsigned Count;
uint64_t ULEB = 0; uint64_t ULEB = 0;
switch (RebaseOp.Opcode) { switch (RebaseOp.Opcode) {
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
ULEB = decodeULEB128(OpCode + 1, &Count); ULEB = decodeULEB128(OpCode + 1, &Count);
RebaseOp.ExtraData.push_back(ULEB); RebaseOp.ExtraData.emplace_back(ULEB);
OpCode += Count; OpCode += Count;
// Intentionally no break here -- This opcode has two ULEB values // Intentionally no break here -- This opcode has two ULEB values
case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
case MachO::REBASE_OPCODE_ADD_ADDR_ULEB: case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES: case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
ULEB = decodeULEB128(OpCode + 1, &Count); ULEB = decodeULEB128(OpCode + 1, &Count);
RebaseOp.ExtraData.push_back(ULEB); RebaseOp.ExtraData.emplace_back(ULEB);
OpCode += Count; OpCode += Count;
break; break;
default: default:
break; break;
} }
LEData.RebaseOpcodes.push_back(RebaseOp); LEData.RebaseOpcodes.push_back(RebaseOp);
Show All 21 Lines
unsigned Count; unsigned Count;
uint64_t ULEB = 0; uint64_t ULEB = 0;
int64_t SLEB = 0; int64_t SLEB = 0;
switch (BindOp.Opcode) { switch (BindOp.Opcode) {
case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
ULEB = decodeULEB128(OpCode + 1, &Count); ULEB = decodeULEB128(OpCode + 1, &Count);
BindOp.ULEBExtraData.push_back(ULEB); BindOp.ULEBExtraData.emplace_back(ULEB);
OpCode += Count; OpCode += Count;
// Intentionally no break here -- this opcode has two ULEB values // Intentionally no break here -- this opcode has two ULEB values
case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
case MachO::BIND_OPCODE_ADD_ADDR_ULEB: case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
ULEB = decodeULEB128(OpCode + 1, &Count); ULEB = decodeULEB128(OpCode + 1, &Count);
BindOp.ULEBExtraData.push_back(ULEB); BindOp.ULEBExtraData.emplace_back(ULEB);
OpCode += Count; OpCode += Count;
break; break;
case MachO::BIND_OPCODE_SET_ADDEND_SLEB: case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
SLEB = decodeSLEB128(OpCode + 1, &Count); SLEB = decodeSLEB128(OpCode + 1, &Count);
BindOp.SLEBExtraData.push_back(SLEB); BindOp.SLEBExtraData.push_back(SLEB);
OpCode += Count; OpCode += Count;
break; break;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/yaml2obj/yaml2macho.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
std::vector<writeOperation> WriteQueue; std::vector<writeOperation> WriteQueue;
MachO::dyld_info_command *DyldInfoOnlyCmd = 0; MachO::dyld_info_command *DyldInfoOnlyCmd = 0;
MachO::symtab_command *SymtabCmd = 0; MachO::symtab_command *SymtabCmd = 0;
for (auto &LC : Obj.LoadCommands) { for (auto &LC : Obj.LoadCommands) {
switch (LC.Data.load_command_data.cmd) { switch (LC.Data.load_command_data.cmd) {
case MachO::LC_SYMTAB: case MachO::LC_SYMTAB:
SymtabCmd = &LC.Data.symtab_command_data; SymtabCmd = &LC.Data.symtab_command_data;
WriteQueue.push_back( WriteQueue.emplace_back(std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList));
std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList)); WriteQueue.emplace_back(std::make_pair(SymtabCmd->stroff, &MachOWriter::writeStringTable));
WriteQueue.push_back(
std::make_pair(SymtabCmd->stroff, &MachOWriter::writeStringTable));
break; break;
case MachO::LC_DYLD_INFO_ONLY: case MachO::LC_DYLD_INFO_ONLY:
DyldInfoOnlyCmd = &LC.Data.dyld_info_command_data; DyldInfoOnlyCmd = &LC.Data.dyld_info_command_data;
WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->rebase_off, WriteQueue.emplace_back(std::make_pair(DyldInfoOnlyCmd->rebase_off,
&MachOWriter::writeRebaseOpcodes)); &MachOWriter::writeRebaseOpcodes));
WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->bind_off, WriteQueue.emplace_back(std::make_pair(DyldInfoOnlyCmd->bind_off,
&MachOWriter::writeBasicBindOpcodes)); &MachOWriter::writeBasicBindOpcodes));
WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off, WriteQueue.emplace_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off,
&MachOWriter::writeWeakBindOpcodes)); &MachOWriter::writeWeakBindOpcodes));
WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off, WriteQueue.emplace_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off,
&MachOWriter::writeLazyBindOpcodes)); &MachOWriter::writeLazyBindOpcodes));
WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off, WriteQueue.emplace_back(std::make_pair(DyldInfoOnlyCmd->export_off,
&MachOWriter::writeExportTrie)); &MachOWriter::writeExportTrie));
break; break;
} }
} }
std::sort(WriteQueue.begin(), WriteQueue.end(), std::sort(WriteQueue.begin(), WriteQueue.end(),
[](const writeOperation &a, const writeOperation &b) { [](const writeOperation &a, const writeOperation &b) {
return a.first < b.first; return a.first < b.first;
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

unittests/ADT/DAGDeltaAlgorithmTest.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
} }
TEST(DAGDeltaAlgorithmTest, Basic) { TEST(DAGDeltaAlgorithmTest, Basic) {
std::vector<edge_ty> Deps; std::vector<edge_ty> Deps;
// Dependencies: // Dependencies:
// 1 - 3 // 1 - 3
Deps.clear(); Deps.clear();
Deps.push_back(std::make_pair(3, 1)); Deps.emplace_back(std::make_pair(3, 1));
// P = {3,5,7} \in S, // P = {3,5,7} \in S,
// [0, 20), // [0, 20),
// should minimize to {1,3,5,7} in a reasonable number of tests. // should minimize to {1,3,5,7} in a reasonable number of tests.
FixedDAGDeltaAlgorithm FDA(fixed_set(3, 3, 5, 7)); FixedDAGDeltaAlgorithm FDA(fixed_set(3, 3, 5, 7));
EXPECT_EQ(fixed_set(4, 1, 3, 5, 7), FDA.Run(range(20), Deps)); EXPECT_EQ(fixed_set(4, 1, 3, 5, 7), FDA.Run(range(20), Deps));
EXPECT_GE(46U, FDA.getNumTests()); EXPECT_GE(46U, FDA.getNumTests());
// Dependencies: // Dependencies:
// 0 - 1 // 0 - 1
// \- 2 - 3 // \- 2 - 3
// \- 4 // \- 4
Deps.clear(); Deps.clear();
Deps.push_back(std::make_pair(1, 0)); Deps.emplace_back(std::make_pair(1, 0));
Deps.push_back(std::make_pair(2, 0)); Deps.emplace_back(std::make_pair(2, 0));
Deps.push_back(std::make_pair(4, 0)); Deps.emplace_back(std::make_pair(4, 0));
Deps.push_back(std::make_pair(3, 2)); Deps.emplace_back(std::make_pair(3, 2));
// This is a case where we must hold required changes. // This is a case where we must hold required changes.
// //
// P = {1,3} \in S, // P = {1,3} \in S,
// [0, 5), // [0, 5),
// should minimize to {0,1,2,3} in a small number of tests. // should minimize to {0,1,2,3} in a small number of tests.
FixedDAGDeltaAlgorithm FDA2(fixed_set(2, 1, 3)); FixedDAGDeltaAlgorithm FDA2(fixed_set(2, 1, 3));
EXPECT_EQ(fixed_set(4, 0, 1, 2, 3), FDA2.Run(range(5), Deps)); EXPECT_EQ(fixed_set(4, 0, 1, 2, 3), FDA2.Run(range(5), Deps));
Show All 14 Lines

unittests/ADT/SmallVectorTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
hasValue = m.hasValue; hasValue = m.hasValue;
m.hasValue = false; m.hasValue = false;
return *this; return *this;
} }
}; };
TEST(SmallVectorTest, MidInsert) { TEST(SmallVectorTest, MidInsert) {
SmallVector<MovedFrom, 3> v; SmallVector<MovedFrom, 3> v;
v.push_back(MovedFrom()); v.emplace_back();
v.insert(v.begin(), MovedFrom()); v.insert(v.begin(), MovedFrom());
for (MovedFrom &m : v) for (MovedFrom &m : v)
EXPECT_TRUE(m.hasValue); EXPECT_TRUE(m.hasValue);
} }
enum EmplaceableArgState { enum EmplaceableArgState {
EAS_Defaulted, EAS_Defaulted,
EAS_Arg, EAS_Arg,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

unittests/ADT/StringRefTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")), EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
Str.rsplit('o')); Str.rsplit('o'));
} }
TEST(StringRefTest, Split2) { TEST(StringRefTest, Split2) {
SmallVector<StringRef, 5> parts; SmallVector<StringRef, 5> parts;
SmallVector<StringRef, 5> expected; SmallVector<StringRef, 5> expected;
expected.push_back("ab"); expected.push_back("c"); expected.emplace_back("ab"); expected.emplace_back("c");
StringRef(",ab,,c,").split(parts, ",", -1, false); StringRef(",ab,,c,").split(parts, ",", -1, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(""); expected.push_back("ab"); expected.push_back(""); expected.emplace_back(""); expected.emplace_back("ab"); expected.emplace_back("");
expected.push_back("c"); expected.push_back(""); expected.emplace_back("c"); expected.emplace_back("");
StringRef(",ab,,c,").split(parts, ",", -1, true); StringRef(",ab,,c,").split(parts, ",", -1, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(""); expected.emplace_back("");
StringRef("").split(parts, ",", -1, true); StringRef("").split(parts, ",", -1, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
StringRef("").split(parts, ",", -1, false); StringRef("").split(parts, ",", -1, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
StringRef(",").split(parts, ",", -1, false); StringRef(",").split(parts, ",", -1, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(""); expected.push_back(""); expected.emplace_back(""); expected.emplace_back("");
StringRef(",").split(parts, ",", -1, true); StringRef(",").split(parts, ",", -1, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back("b"); expected.emplace_back("a"); expected.emplace_back("b");
StringRef("a,b").split(parts, ",", -1, true); StringRef("a,b").split(parts, ",", -1, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
// Test MaxSplit // Test MaxSplit
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a,,b,c"); expected.emplace_back("a,,b,c");
StringRef("a,,b,c").split(parts, ",", 0, true); StringRef("a,,b,c").split(parts, ",", 0, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a,,b,c"); expected.emplace_back("a,,b,c");
StringRef("a,,b,c").split(parts, ",", 0, false); StringRef("a,,b,c").split(parts, ",", 0, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back(",b,c"); expected.emplace_back("a"); expected.emplace_back(",b,c");
StringRef("a,,b,c").split(parts, ",", 1, true); StringRef("a,,b,c").split(parts, ",", 1, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back(",b,c"); expected.emplace_back("a"); expected.emplace_back(",b,c");
StringRef("a,,b,c").split(parts, ",", 1, false); StringRef("a,,b,c").split(parts, ",", 1, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back(""); expected.push_back("b,c"); expected.emplace_back("a"); expected.emplace_back(""); expected.emplace_back("b,c");
StringRef("a,,b,c").split(parts, ",", 2, true); StringRef("a,,b,c").split(parts, ",", 2, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back("b,c"); expected.emplace_back("a"); expected.emplace_back("b,c");
StringRef("a,,b,c").split(parts, ",", 2, false); StringRef("a,,b,c").split(parts, ",", 2, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back(""); expected.push_back("b"); expected.emplace_back("a"); expected.emplace_back(""); expected.emplace_back("b");
expected.push_back("c"); expected.emplace_back("c");
StringRef("a,,b,c").split(parts, ",", 3, true); StringRef("a,,b,c").split(parts, ",", 3, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back("b"); expected.push_back("c"); expected.emplace_back("a"); expected.emplace_back("b"); expected.emplace_back("c");
StringRef("a,,b,c").split(parts, ",", 3, false); StringRef("a,,b,c").split(parts, ",", 3, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.push_back("b"); expected.push_back("c"); expected.emplace_back("a"); expected.emplace_back("b"); expected.emplace_back("c");
StringRef("a,,b,c").split(parts, ',', 3, false); StringRef("a,,b,c").split(parts, ',', 3, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(""); expected.emplace_back("");
StringRef().split(parts, ",", 0, true); StringRef().split(parts, ",", 0, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(StringRef()); expected.emplace_back();
StringRef("").split(parts, ",", 0, true); StringRef("").split(parts, ",", 0, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
StringRef("").split(parts, ",", 0, false); StringRef("").split(parts, ",", 0, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
StringRef().split(parts, ",", 0, false); StringRef().split(parts, ",", 0, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.emplace_back("a");
expected.push_back(""); expected.emplace_back("");
expected.push_back("b"); expected.emplace_back("b");
expected.push_back("c,d"); expected.emplace_back("c,d");
StringRef("a,,b,c,d").split(parts, ",", 3, true); StringRef("a,,b,c,d").split(parts, ",", 3, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(""); expected.emplace_back("");
StringRef().split(parts, ',', 0, true); StringRef().split(parts, ',', 0, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back(StringRef()); expected.emplace_back();
StringRef("").split(parts, ',', 0, true); StringRef("").split(parts, ',', 0, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
StringRef("").split(parts, ',', 0, false); StringRef("").split(parts, ',', 0, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
StringRef().split(parts, ',', 0, false); StringRef().split(parts, ',', 0, false);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
expected.clear(); parts.clear(); expected.clear(); parts.clear();
expected.push_back("a"); expected.emplace_back("a");
expected.push_back(""); expected.emplace_back("");
expected.push_back("b"); expected.emplace_back("b");
expected.push_back("c,d"); expected.emplace_back("c,d");
StringRef("a,,b,c,d").split(parts, ',', 3, true); StringRef("a,,b,c,d").split(parts, ',', 3, true);
EXPECT_TRUE(parts == expected); EXPECT_TRUE(parts == expected);
} }
TEST(StringRefTest, Trim) { TEST(StringRefTest, Trim) {
StringRef Str0("hello"); StringRef Str0("hello");
StringRef Str1(" hello "); StringRef Str1(" hello ");
StringRef Str2(" hello "); StringRef Str2(" hello ");
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
static const char join_result1[] = "a"; static const char join_result1[] = "a";
static const char join_result2[] = "a:b:c"; static const char join_result2[] = "a:b:c";
static const char join_result3[] = "a::b::c"; static const char join_result3[] = "a::b::c";
TEST(StringRefTest, joinStrings) { TEST(StringRefTest, joinStrings) {
std::vector<StringRef> v1; std::vector<StringRef> v1;
std::vector<std::string> v2; std::vector<std::string> v2;
for (size_t i = 0; i < array_lengthof(join_input); ++i) { for (size_t i = 0; i < array_lengthof(join_input); ++i) {
v1.push_back(join_input[i]); v1.emplace_back(join_input[i]);
v2.push_back(join_input[i]); v2.push_back(join_input[i]);
} }
bool v1_join1 = join(v1.begin(), v1.begin() + 1, ":") == join_result1; bool v1_join1 = join(v1.begin(), v1.begin() + 1, ":") == join_result1;
EXPECT_TRUE(v1_join1); EXPECT_TRUE(v1_join1);
bool v1_join2 = join(v1.begin(), v1.end(), ":") == join_result2; bool v1_join2 = join(v1.begin(), v1.end(), ":") == join_result2;
EXPECT_TRUE(v1_join2); EXPECT_TRUE(v1_join2);
bool v1_join3 = join(v1.begin(), v1.end(), "::") == join_result3; bool v1_join3 = join(v1.begin(), v1.end(), "::") == join_result3;
Show All 34 Lines

unittests/Format/CleanupTest.cpp

Show All 38 Lines std::string Code = "namespace A {\n"
"namespace C {\n" "namespace C {\n"
"namespace D { int i; }\n" "namespace D { int i; }\n"
"inline namespace E { namespace { } }\n" "inline namespace E { namespace { } }\n"
"}"; "}";
std::string Expected = "\n\n\n\n\nnamespace C {\n" std::string Expected = "\n\n\n\n\nnamespace C {\n"
"namespace D { int i; }\n \n" "namespace D { int i; }\n \n"
"}"; "}";
std::vector<tooling::Range> Ranges; std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(28, 0)); Ranges.emplace_back(28, 0);
Ranges.push_back(tooling::Range(91, 6)); Ranges.emplace_back(91, 6);
Ranges.push_back(tooling::Range(132, 0)); Ranges.emplace_back(132, 0);
std::string Result = cleanup(Code, Ranges); std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
} }
TEST_F(CleanupTest, NamespaceWithSyntaxError) { TEST_F(CleanupTest, NamespaceWithSyntaxError) {
std::string Code = "namespace A {\n" std::string Code = "namespace A {\n"
"namespace B {\n" // missing r_brace "namespace B {\n" // missing r_brace
"} // namespace A\n\n" "} // namespace A\n\n"
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 LinesTEST_F(CleanupTest, EmptyNamespaceWithCommentsBreakBeforeBrace) {
std::string Result = cleanup(Code, Ranges, Style); std::string Result = cleanup(Code, Ranges, Style);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
} }
TEST_F(CleanupTest, CtorInitializationSimpleRedundantComma) { TEST_F(CleanupTest, CtorInitializationSimpleRedundantComma) {
std::string Code = "class A {\nA() : , {} };"; std::string Code = "class A {\nA() : , {} };";
std::string Expected = "class A {\nA() {} };"; std::string Expected = "class A {\nA() {} };";
std::vector<tooling::Range> Ranges; std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(17, 0)); Ranges.emplace_back(17, 0);
Ranges.push_back(tooling::Range(19, 0)); Ranges.emplace_back(19, 0);
std::string Result = cleanup(Code, Ranges); std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
Code = "class A {\nA() : x(1), {} };"; Code = "class A {\nA() : x(1), {} };";
Expected = "class A {\nA() : x(1) {} };"; Expected = "class A {\nA() : x(1) {} };";
Ranges.clear(); Ranges.clear();
Ranges.push_back(tooling::Range(23, 0)); Ranges.emplace_back(23, 0);
Result = cleanup(Code, Ranges); Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
Code = "class A {\nA() :,,,,{} };"; Code = "class A {\nA() :,,,,{} };";
Expected = "class A {\nA() {} };"; Expected = "class A {\nA() {} };";
Ranges.clear(); Ranges.clear();
Ranges.push_back(tooling::Range(15, 0)); Ranges.emplace_back(15, 0);
Result = cleanup(Code, Ranges); Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
} }
TEST_F(CleanupTest, ListSimpleRedundantComma) { TEST_F(CleanupTest, ListSimpleRedundantComma) {
std::string Code = "void f() { std::vector<int> v = {1,2,,,3,{4,5}}; }"; std::string Code = "void f() { std::vector<int> v = {1,2,,,3,{4,5}}; }";
std::string Expected = "void f() { std::vector<int> v = {1,2,3,{4,5}}; }"; std::string Expected = "void f() { std::vector<int> v = {1,2,3,{4,5}}; }";
std::vector<tooling::Range> Ranges; std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(40, 0)); Ranges.emplace_back(40, 0);
std::string Result = cleanup(Code, Ranges); std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
Code = "int main() { f(1,,2,3,,4);}"; Code = "int main() { f(1,,2,3,,4);}";
Expected = "int main() { f(1,2,3,4);}"; Expected = "int main() { f(1,2,3,4);}";
Ranges.clear(); Ranges.clear();
Ranges.push_back(tooling::Range(17, 0)); Ranges.emplace_back(17, 0);
Ranges.push_back(tooling::Range(22, 0)); Ranges.emplace_back(22, 0);
Result = cleanup(Code, Ranges); Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
} }
TEST_F(CleanupTest, CtorInitializationBracesInParens) { TEST_F(CleanupTest, CtorInitializationBracesInParens) {
std::string Code = "class A {\nA() : x({1}),, {} };"; std::string Code = "class A {\nA() : x({1}),, {} };";
std::string Expected = "class A {\nA() : x({1}) {} };"; std::string Expected = "class A {\nA() : x({1}) {} };";
std::vector<tooling::Range> Ranges; std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(24, 0)); Ranges.emplace_back(24, 0);
Ranges.push_back(tooling::Range(26, 0)); Ranges.emplace_back(26, 0);
std::string Result = cleanup(Code, Ranges); std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
} }
TEST_F(CleanupTest, RedundantCommaNotInAffectedRanges) { TEST_F(CleanupTest, RedundantCommaNotInAffectedRanges) {
std::string Code = std::string Code =
"class A {\nA() : x({1}), /* comment */, { int x = 0; } };"; "class A {\nA() : x({1}), /* comment */, { int x = 0; } };";
std::string Expected = std::string Expected =
Show All 13 Lines
} }
// FIXME: delete comments too. // FIXME: delete comments too.
TEST_F(CleanupTest, CtorInitializationCommentAroundCommas) { TEST_F(CleanupTest, CtorInitializationCommentAroundCommas) {
// Remove redundant commas around comment. // Remove redundant commas around comment.
std::string Code = "class A {\nA() : x({1}), /* comment */, {} };"; std::string Code = "class A {\nA() : x({1}), /* comment */, {} };";
std::string Expected = "class A {\nA() : x({1}) /* comment */ {} };"; std::string Expected = "class A {\nA() : x({1}) /* comment */ {} };";
std::vector<tooling::Range> Ranges; std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(25, 0)); Ranges.emplace_back(25, 0);
Ranges.push_back(tooling::Range(40, 0)); Ranges.emplace_back(40, 0);
std::string Result = cleanup(Code, Ranges); std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result); EXPECT_EQ(Expected, Result);
// Remove trailing comma and ignore comment. // Remove trailing comma and ignore comment.
Code = "class A {\nA() : x({1}), // comment\n{} };"; Code = "class A {\nA() : x({1}), // comment\n{} };";
Expected = "class A {\nA() : x({1}) // comment\n{} };"; Expected = "class A {\nA() : x({1}) // comment\n{} };";
Ranges = std::vector<tooling::Range>(1, tooling::Range(25, 0)); Ranges = std::vector<tooling::Range>(1, tooling::Range(25, 0));
Result = cleanup(Code, Ranges); Result = cleanup(Code, Ranges);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

unittests/IR/ValueMapTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
EXPECT_EQ(0U, VM.count(this->AddV.get())); EXPECT_EQ(0U, VM.count(this->AddV.get()));
EXPECT_EQ(1U, VM.count(this->BitcastV.get())); EXPECT_EQ(1U, VM.count(this->BitcastV.get()));
VM.erase(this->BitcastV.get()); VM.erase(this->BitcastV.get());
EXPECT_EQ(0U, VM.count(this->BitcastV.get())); EXPECT_EQ(0U, VM.count(this->BitcastV.get()));
EXPECT_EQ(0U, VM.size()); EXPECT_EQ(0U, VM.size());
// Range insert: // Range insert:
SmallVector<std::pair<Instruction*, int>, 2> Elems; SmallVector<std::pair<Instruction*, int>, 2> Elems;
Elems.push_back(std::make_pair(this->AddV.get(), 1)); Elems.emplace_back(std::make_pair(this->AddV.get(), 1));
Elems.push_back(std::make_pair(this->BitcastV.get(), 2)); Elems.emplace_back(std::make_pair(this->BitcastV.get(), 2));
VM.insert(Elems.begin(), Elems.end()); VM.insert(Elems.begin(), Elems.end());
EXPECT_EQ(1, VM.lookup(this->AddV.get())); EXPECT_EQ(1, VM.lookup(this->AddV.get()));
EXPECT_EQ(2, VM.lookup(this->BitcastV.get())); EXPECT_EQ(2, VM.lookup(this->BitcastV.get()));
} }
template<typename ExpectedType, typename VarType> template<typename ExpectedType, typename VarType>
void CompileAssertHasType(VarType) { void CompileAssertHasType(VarType) {
static_assert(std::is_same<ExpectedType, VarType>::value, static_assert(std::is_same<ExpectedType, VarType>::value,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

unittests/ProfileData/InstrProfTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
ASSERT_EQ(2U, Counts.size()); ASSERT_EQ(2U, Counts.size());
ASSERT_EQ(15U, Counts[0]); ASSERT_EQ(15U, Counts[0]);
ASSERT_EQ(20U, Counts[1]); ASSERT_EQ(20U, Counts[1]);
} }
// Testing symtab creator interface used by indexed profile reader. // Testing symtab creator interface used by indexed profile reader.
TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_test) { TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_test) {
std::vector<StringRef> FuncNames; std::vector<StringRef> FuncNames;
FuncNames.push_back("func1"); FuncNames.emplace_back("func1");
FuncNames.push_back("func2"); FuncNames.emplace_back("func2");
FuncNames.push_back("func3"); FuncNames.emplace_back("func3");
FuncNames.push_back("bar1"); FuncNames.emplace_back("bar1");
FuncNames.push_back("bar2"); FuncNames.emplace_back("bar2");
FuncNames.push_back("bar3"); FuncNames.emplace_back("bar3");
InstrProfSymtab Symtab; InstrProfSymtab Symtab;
Symtab.create(FuncNames); Symtab.create(FuncNames);
StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func1")); StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func1"));
ASSERT_EQ(StringRef("func1"), R); ASSERT_EQ(StringRef("func1"), R);
R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func2")); R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func2"));
ASSERT_EQ(StringRef("func2"), R); ASSERT_EQ(StringRef("func2"), R);
R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func3")); R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func3"));
ASSERT_EQ(StringRef("func3"), R); ASSERT_EQ(StringRef("func3"), R);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

unittests/Support/Path.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines#ifdef LLVM_ON_WIN32
EXPECT_TRUE(path::is_separator('\\')); EXPECT_TRUE(path::is_separator('\\'));
#else #else
EXPECT_FALSE(path::is_separator('\\')); EXPECT_FALSE(path::is_separator('\\'));
#endif #endif
} }
TEST(Support, Path) { TEST(Support, Path) {
SmallVector<StringRef, 40> paths; SmallVector<StringRef, 40> paths;
paths.push_back(""); paths.emplace_back("");
paths.push_back("."); paths.emplace_back(".");
paths.push_back(".."); paths.emplace_back("..");
paths.push_back("foo"); paths.emplace_back("foo");
paths.push_back("/"); paths.emplace_back("/");
paths.push_back("/foo"); paths.emplace_back("/foo");
paths.push_back("foo/"); paths.emplace_back("foo/");
paths.push_back("/foo/"); paths.emplace_back("/foo/");
paths.push_back("foo/bar"); paths.emplace_back("foo/bar");
paths.push_back("/foo/bar"); paths.emplace_back("/foo/bar");
paths.push_back("//net"); paths.emplace_back("//net");
paths.push_back("//net/foo"); paths.emplace_back("//net/foo");
paths.push_back("///foo///"); paths.emplace_back("///foo///");
paths.push_back("///foo///bar"); paths.emplace_back("///foo///bar");
paths.push_back("/."); paths.emplace_back("/.");
paths.push_back("./"); paths.emplace_back("./");
paths.push_back("/.."); paths.emplace_back("/..");
paths.push_back("../"); paths.emplace_back("../");
paths.push_back("foo/."); paths.emplace_back("foo/.");
paths.push_back("foo/.."); paths.emplace_back("foo/..");
paths.push_back("foo/./"); paths.emplace_back("foo/./");
paths.push_back("foo/./bar"); paths.emplace_back("foo/./bar");
paths.push_back("foo/.."); paths.emplace_back("foo/..");
paths.push_back("foo/../"); paths.emplace_back("foo/../");
paths.push_back("foo/../bar"); paths.emplace_back("foo/../bar");
paths.push_back("c:"); paths.emplace_back("c:");
paths.push_back("c:/"); paths.emplace_back("c:/");
paths.push_back("c:foo"); paths.emplace_back("c:foo");
paths.push_back("c:/foo"); paths.emplace_back("c:/foo");
paths.push_back("c:foo/"); paths.emplace_back("c:foo/");
paths.push_back("c:/foo/"); paths.emplace_back("c:/foo/");
paths.push_back("c:/foo/bar"); paths.emplace_back("c:/foo/bar");
paths.push_back("prn:"); paths.emplace_back("prn:");
paths.push_back("c:\\"); paths.emplace_back("c:\\");
paths.push_back("c:foo"); paths.emplace_back("c:foo");
paths.push_back("c:\\foo"); paths.emplace_back("c:\\foo");
paths.push_back("c:foo\\"); paths.emplace_back("c:foo\\");
paths.push_back("c:\\foo\\"); paths.emplace_back("c:\\foo\\");
paths.push_back("c:\\foo/"); paths.emplace_back("c:\\foo/");
paths.push_back("c:/foo\\bar"); paths.emplace_back("c:/foo\\bar");
SmallVector<StringRef, 5> ComponentStack; SmallVector<StringRef, 5> ComponentStack;
for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(), for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(),
e = paths.end(); e = paths.end();
i != e; i != e;
++i) { ++i) {
for (sys::path::const_iterator ci = sys::path::begin(*i), for (sys::path::const_iterator ci = sys::path::begin(*i),
ce = sys::path::end(*i); ce = sys::path::end(*i);
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Lines for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str()); EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
} }
} }
#endif // LLVM_ON_WIN32 #endif // LLVM_ON_WIN32
TEST(Support, AbsolutePathIteratorEnd) { TEST(Support, AbsolutePathIteratorEnd) {
// Trailing slashes are converted to '.' unless they are part of the root path. // Trailing slashes are converted to '.' unless they are part of the root path.
SmallVector<StringRef, 4> Paths; SmallVector<StringRef, 4> Paths;
Paths.push_back("/foo/"); Paths.emplace_back("/foo/");
Paths.push_back("/foo//"); Paths.emplace_back("/foo//");
Paths.push_back("//net//"); Paths.emplace_back("//net//");
#ifdef LLVM_ON_WIN32 #ifdef LLVM_ON_WIN32
Paths.push_back("c:\\\\"); Paths.push_back("c:\\\\");
#endif #endif
for (StringRef Path : Paths) { for (StringRef Path : Paths) {
StringRef LastComponent = *path::rbegin(Path); StringRef LastComponent = *path::rbegin(Path);
EXPECT_EQ(".", LastComponent); EXPECT_EQ(".", LastComponent);
} }
SmallVector<StringRef, 3> RootPaths; SmallVector<StringRef, 3> RootPaths;
RootPaths.push_back("/"); RootPaths.emplace_back("/");
RootPaths.push_back("//net/"); RootPaths.emplace_back("//net/");
#ifdef LLVM_ON_WIN32 #ifdef LLVM_ON_WIN32
RootPaths.push_back("c:\\"); RootPaths.push_back("c:\\");
#endif #endif
for (StringRef Path : RootPaths) { for (StringRef Path : RootPaths) {
StringRef LastComponent = *path::rbegin(Path); StringRef LastComponent = *path::rbegin(Path);
EXPECT_EQ(1u, LastComponent.size()); EXPECT_EQ(1u, LastComponent.size());
EXPECT_TRUE(path::is_separator(LastComponent[0])); EXPECT_TRUE(path::is_separator(LastComponent[0]));
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

unittests/Support/YAMLIOTest.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// //
// Test writing then reading back custom values // Test writing then reading back custom values
// //
TEST(YAMLIO, TestReadWriteMyFlowSequence) { TEST(YAMLIO, TestReadWriteMyFlowSequence) {
std::string intermediate; std::string intermediate;
{ {
NameAndNumbers map; NameAndNumbers map;
map.name = "hello"; map.name = "hello";
map.strings.push_back(llvm::StringRef("one")); map.strings.emplace_back("one");
map.strings.push_back(llvm::StringRef("two")); map.strings.emplace_back("two");
map.single.push_back(1); map.single.emplace_back(1);
map.numbers.push_back(10); map.numbers.emplace_back(10);
map.numbers.push_back(-30); map.numbers.emplace_back(-30);
map.numbers.push_back(1024); map.numbers.emplace_back(1024);
llvm::raw_string_ostream ostr(intermediate); llvm::raw_string_ostream ostr(intermediate);
Output yout(ostr); Output yout(ostr);
yout << map; yout << map;
// Verify sequences were written in flow style // Verify sequences were written in flow style
ostr.flush(); ostr.flush();
llvm::StringRef flowOut(intermediate); llvm::StringRef flowOut(intermediate);
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
// //
// Test writing then reading back custom values // Test writing then reading back custom values
// //
TEST(YAMLIO, TestReadWriteMySecondsSequence) { TEST(YAMLIO, TestReadWriteMySecondsSequence) {
std::string intermediate; std::string intermediate;
{ {
SecondsSequence seq; SecondsSequence seq;
seq.push_back(4000); seq.emplace_back(4000);
seq.push_back(500); seq.emplace_back(500);
seq.push_back(59); seq.emplace_back(59);
llvm::raw_string_ostream ostr(intermediate); llvm::raw_string_ostream ostr(intermediate);
Output yout(ostr); Output yout(ostr);
yout << seq; yout << seq;
} }
{ {
Input yin(intermediate); Input yin(intermediate);
SecondsSequence seq2; SecondsSequence seq2;
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines
// //
// Test writing then reading back dynamic types // Test writing then reading back dynamic types
// //
TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) { TEST(YAMLIO, TestReadWriteKindAndFlagsSequence) {
std::string intermediate; std::string intermediate;
{ {
KindAndFlagsSequence seq; KindAndFlagsSequence seq;
seq.push_back(KindAndFlags(kindA,a1)); seq.emplace_back(kindA,a1);
seq.push_back(KindAndFlags(kindB,b1)); seq.emplace_back(kindB,b1);
seq.push_back(KindAndFlags(kindA,a2)); seq.emplace_back(kindA,a2);
seq.push_back(KindAndFlags(kindB,b2)); seq.emplace_back(kindB,b2);
seq.push_back(KindAndFlags(kindA,a3)); seq.emplace_back(kindA,a3);
llvm::raw_string_ostream ostr(intermediate); llvm::raw_string_ostream ostr(intermediate);
Output yout(ostr); Output yout(ostr);
yout << seq; yout << seq;
} }
{ {
Input yin(intermediate); Input yin(intermediate);
KindAndFlagsSequence seq2; KindAndFlagsSequence seq2;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
// //
// Test writing then reading back custom mappings // Test writing then reading back custom mappings
// //
TEST(YAMLIO, TestReadWriteMyFlowMapping) { TEST(YAMLIO, TestReadWriteMyFlowMapping) {
std::string intermediate; std::string intermediate;
{ {
FlowFooBarDoc doc; FlowFooBarDoc doc;
doc.attribute = FlowFooBar(42, 907); doc.attribute = FlowFooBar(42, 907);
doc.seq.push_back(FlowFooBar(1, 2)); doc.seq.emplace_back(1, 2);
doc.seq.push_back(FlowFooBar(0, 0)); doc.seq.emplace_back(0, 0);
doc.seq.push_back(FlowFooBar(-1, 1024)); doc.seq.emplace_back(-1, 1024);
llvm::raw_string_ostream ostr(intermediate); llvm::raw_string_ostream ostr(intermediate);
Output yout(ostr); Output yout(ostr);
yout << doc; yout << doc;
// Verify that mappings were written in flow style // Verify that mappings were written in flow style
ostr.flush(); ostr.flush();
llvm::StringRef flowOut(intermediate); llvm::StringRef flowOut(intermediate);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

utils/FileCheck/FileCheck.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
if (VarParenNum < 1 || VarParenNum > 9) { if (VarParenNum < 1 || VarParenNum > 9) {
SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
SourceMgr::DK_Error, SourceMgr::DK_Error,
"Can't back-reference more than 9 variables"); "Can't back-reference more than 9 variables");
return true; return true;
} }
AddBackrefToRegEx(VarParenNum); AddBackrefToRegEx(VarParenNum);
} else { } else {
VariableUses.push_back(std::make_pair(Name, RegExStr.size())); VariableUses.emplace_back(std::make_pair(Name, RegExStr.size()));
} }
continue; continue;
} }
// Handle [[foo:.*]]. // Handle [[foo:.*]].
VariableDefs[Name] = CurParen; VariableDefs[Name] = CurParen;
RegExStr += '('; RegExStr += '(';
++CurParen; ++CurParen;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

utils/TableGen/AsmMatcherEmitter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
DepMask = TheDef->getValue("ComplexDeprecationPredicate"); DepMask = TheDef->getValue("ComplexDeprecationPredicate");
HasDeprecation = HasDeprecation =
DepMask ? !DepMask->getValue()->getAsUnquotedString().empty() : false; DepMask ? !DepMask->getValue()->getAsUnquotedString().empty() : false;
} }
/// Append an AsmOperand for the given substring of AsmString. /// Append an AsmOperand for the given substring of AsmString.
void MatchableInfo::addAsmOperand(StringRef Token, bool IsIsolatedToken) { void MatchableInfo::addAsmOperand(StringRef Token, bool IsIsolatedToken) {
AsmOperands.push_back(AsmOperand(IsIsolatedToken, Token)); AsmOperands.emplace_back(IsIsolatedToken, Token);
} }
/// tokenizeAsmString - Tokenize a simplified assembly string. /// tokenizeAsmString - Tokenize a simplified assembly string.
void MatchableInfo::tokenizeAsmString(const AsmMatcherInfo &Info, void MatchableInfo::tokenizeAsmString(const AsmMatcherInfo &Info,
AsmVariantInfo const &Variant) { AsmVariantInfo const &Variant) {
StringRef String = AsmString; StringRef String = AsmString;
size_t Prev = 0; size_t Prev = 0;
bool InTok = false; bool InTok = false;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
OS << "static bool isSubclass(MatchClassKind A, MatchClassKind B) {\n"; OS << "static bool isSubclass(MatchClassKind A, MatchClassKind B) {\n";
OS << " if (A == B)\n"; OS << " if (A == B)\n";
OS << " return true;\n\n"; OS << " return true;\n\n";
bool EmittedSwitch = false; bool EmittedSwitch = false;
for (const auto &A : Infos) { for (const auto &A : Infos) {
std::vector<StringRef> SuperClasses; std::vector<StringRef> SuperClasses;
if (A.IsOptional) if (A.IsOptional)
SuperClasses.push_back("OptionalMatchClass"); SuperClasses.emplace_back("OptionalMatchClass");
for (const auto &B : Infos) { for (const auto &B : Infos) {
if (&A != &B && A.isSubsetOf(B)) if (&A != &B && A.isSubsetOf(B))
SuperClasses.push_back(B.Name); SuperClasses.emplace_back(B.Name);
} }
if (SuperClasses.empty()) if (SuperClasses.empty())
continue; continue;
// If this is the first SuperClass, emit the switch header. // If this is the first SuperClass, emit the switch header.
if (!EmittedSwitch) { if (!EmittedSwitch) {
OS << " switch (A) {\n"; OS << " switch (A) {\n";
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

utils/TableGen/CTagsEmitter.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
void CTagsEmitter::run(raw_ostream &OS) { void CTagsEmitter::run(raw_ostream &OS) {
const auto &Classes = Records.getClasses(); const auto &Classes = Records.getClasses();
const auto &Defs = Records.getDefs(); const auto &Defs = Records.getDefs();
std::vector<Tag> Tags; std::vector<Tag> Tags;
// Collect tags. // Collect tags.
Tags.reserve(Classes.size() + Defs.size()); Tags.reserve(Classes.size() + Defs.size());
for (const auto &C : Classes) for (const auto &C : Classes)
Tags.push_back(Tag(C.first, locate(C.second.get()))); Tags.emplace_back(C.first, locate(C.second.get()));
for (const auto &D : Defs) for (const auto &D : Defs)
Tags.push_back(Tag(D.first, locate(D.second.get()))); Tags.emplace_back(D.first, locate(D.second.get()));
// Emit tags. // Emit tags.
std::sort(Tags.begin(), Tags.end()); std::sort(Tags.begin(), Tags.end());
OS << "!_TAG_FILE_FORMAT\t1\t/original ctags format/\n"; OS << "!_TAG_FILE_FORMAT\t1\t/original ctags format/\n";
OS << "!_TAG_FILE_SORTED\t1\t/0=unsorted, 1=sorted, 2=foldcase/\n"; OS << "!_TAG_FILE_SORTED\t1\t/0=unsorted, 1=sorted, 2=foldcase/\n";
for (const Tag &T : Tags) for (const Tag &T : Tags)
T.emit(OS); T.emit(OS);
} }
namespace llvm { namespace llvm {
void EmitCTags(RecordKeeper &RK, raw_ostream &OS) { CTagsEmitter(RK).run(OS); } void EmitCTags(RecordKeeper &RK, raw_ostream &OS) { CTagsEmitter(RK).run(OS); }
} // End llvm namespace. } // End llvm namespace.

utils/TableGen/ClangAttrEmitter.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
std::string Cat = Category->getValueAsString("Name"); std::string Cat = Category->getValueAsString("Name");
bool Undocumented = Cat == "Undocumented"; bool Undocumented = Cat == "Undocumented";
if (Undocumented && Docs.size() > 1) if (Undocumented && Docs.size() > 1)
PrintFatalError(Doc.getLoc(), PrintFatalError(Doc.getLoc(),
"Attribute is \"Undocumented\", but has multiple " "Attribute is \"Undocumented\", but has multiple "
"documentation categories"); "documentation categories");
if (!Undocumented) if (!Undocumented)
SplitDocs[Category].push_back(DocumentationData(Doc, Attr)); SplitDocs[Category].emplace_back(Doc, Attr);
} }
} }
// Having split the attributes out based on what documentation goes where, // Having split the attributes out based on what documentation goes where,
// we can begin to generate sections of documentation. // we can begin to generate sections of documentation.
for (const auto &I : SplitDocs) { for (const auto &I : SplitDocs) {
WriteCategoryHeader(I.first, OS); WriteCategoryHeader(I.first, OS);
// Walk over each of the attributes in the category and write out their // Walk over each of the attributes in the category and write out their
// documentation. // documentation.
for (const auto &Doc : I.second) for (const auto &Doc : I.second)
WriteDocumentation(Doc, OS); WriteDocumentation(Doc, OS);
} }
} }
} // end namespace clang } // end namespace clang
Context not available.

utils/TableGen/CodeGenInstruction.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef();
// Take care to instantiate each of the suboperands with the correct // Take care to instantiate each of the suboperands with the correct
// nomenclature: $foo.bar // nomenclature: $foo.bar
ResultOperands.emplace_back(Result->getArgName(AliasOpNo) + "." + ResultOperands.emplace_back(Result->getArgName(AliasOpNo) + "." +
MIOI->getArgName(SubOp), MIOI->getArgName(SubOp),
SubRec); SubRec);
ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); ResultInstOperandIndex.emplace_back(std::make_pair(i, SubOp));
} }
++AliasOpNo; ++AliasOpNo;
} }
continue; continue;
} }
// If the argument did not match the instruction operand, and the operand // If the argument did not match the instruction operand, and the operand
// is composed of multiple suboperands, try matching the suboperands. // is composed of multiple suboperands, try matching the suboperands.
if (NumSubOps > 1) { if (NumSubOps > 1) {
DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
if (AliasOpNo >= Result->getNumArgs()) if (AliasOpNo >= Result->getNumArgs())
PrintFatalError(R->getLoc(), "not enough arguments for instruction!"); PrintFatalError(R->getLoc(), "not enough arguments for instruction!");
Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef();
if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false,
R->getLoc(), T, ResOp)) { R->getLoc(), T, ResOp)) {
ResultOperands.push_back(ResOp); ResultOperands.push_back(ResOp);
ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); ResultInstOperandIndex.emplace_back(std::make_pair(i, SubOp));
++AliasOpNo; ++AliasOpNo;
} else { } else {
PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) + PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) +
" does not match instruction operand class " + " does not match instruction operand class " +
(SubOp == 0 ? InstOpRec->getName() :SubRec->getName())); (SubOp == 0 ? InstOpRec->getName() :SubRec->getName()));
} }
} }
continue; continue;
Show All 9 Lines

utils/TableGen/CodeGenRegisters.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
// If some Cand sub-register is not part of this register, or if Cand only // If some Cand sub-register is not part of this register, or if Cand only
// has one sub-register, there is nothing to do. // has one sub-register, there is nothing to do.
if (Parts.size() <= 1) if (Parts.size() <= 1)
continue; continue;
// Each part of Cand is a sub-register of this. Make the full Cand also // Each part of Cand is a sub-register of this. Make the full Cand also
// a sub-register with a concatenated sub-register index. // a sub-register with a concatenated sub-register index.
CodeGenSubRegIndex *Concat= RegBank.getConcatSubRegIndex(Parts); CodeGenSubRegIndex *Concat= RegBank.getConcatSubRegIndex(Parts);
NewSubRegs.push_back(std::make_pair(Concat, Cand)); NewSubRegs.emplace_back(std::make_pair(Concat, Cand));
} }
} }
// Now add all the new sub-registers. // Now add all the new sub-registers.
for (unsigned i = 0, e = NewSubRegs.size(); i != e; ++i) { for (unsigned i = 0, e = NewSubRegs.size(); i != e; ++i) {
// Don't add Cand if another sub-register is already using the index. // Don't add Cand if another sub-register is already using the index.
if (!SubRegs.insert(NewSubRegs[i]).second) if (!SubRegs.insert(NewSubRegs[i]).second)
continue; continue;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

utils/TableGen/CodeGenSchedule.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
unsigned VarProcIdx = 0; unsigned VarProcIdx = 0;
if (SchedRW.TheDef->getValueInit("SchedModel")->isComplete()) { if (SchedRW.TheDef->getValueInit("SchedModel")->isComplete()) {
Record *ModelDef = SchedRW.TheDef->getValueAsDef("SchedModel"); Record *ModelDef = SchedRW.TheDef->getValueAsDef("SchedModel");
VarProcIdx = SchedModels.getProcModel(ModelDef).Index; VarProcIdx = SchedModels.getProcModel(ModelDef).Index;
} }
// Push each variant. Assign TransVecIdx later. // Push each variant. Assign TransVecIdx later.
const RecVec VarDefs = SchedRW.TheDef->getValueAsListOfDefs("Variants"); const RecVec VarDefs = SchedRW.TheDef->getValueAsListOfDefs("Variants");
for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI) for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI)
Variants.push_back(TransVariant(*RI, SchedRW.Index, VarProcIdx, 0)); Variants.emplace_back(*RI, SchedRW.Index, VarProcIdx, 0);
if (VarProcIdx == 0) if (VarProcIdx == 0)
GenericRW = true; GenericRW = true;
} }
for (RecIter AI = SchedRW.Aliases.begin(), AE = SchedRW.Aliases.end(); for (RecIter AI = SchedRW.Aliases.begin(), AE = SchedRW.Aliases.end();
AI != AE; ++AI) { AI != AE; ++AI) {
// If either the SchedAlias itself or the SchedReadWrite that it aliases // If either the SchedAlias itself or the SchedReadWrite that it aliases
// to is defined within a processor model, constrain all variants to // to is defined within a processor model, constrain all variants to
// that processor. // that processor.
unsigned AliasProcIdx = 0; unsigned AliasProcIdx = 0;
if ((*AI)->getValueInit("SchedModel")->isComplete()) { if ((*AI)->getValueInit("SchedModel")->isComplete()) {
Record *ModelDef = (*AI)->getValueAsDef("SchedModel"); Record *ModelDef = (*AI)->getValueAsDef("SchedModel");
AliasProcIdx = SchedModels.getProcModel(ModelDef).Index; AliasProcIdx = SchedModels.getProcModel(ModelDef).Index;
} }
const CodeGenSchedRW &AliasRW = const CodeGenSchedRW &AliasRW =
SchedModels.getSchedRW((*AI)->getValueAsDef("AliasRW")); SchedModels.getSchedRW((*AI)->getValueAsDef("AliasRW"));
if (AliasRW.HasVariants) { if (AliasRW.HasVariants) {
const RecVec VarDefs = AliasRW.TheDef->getValueAsListOfDefs("Variants"); const RecVec VarDefs = AliasRW.TheDef->getValueAsListOfDefs("Variants");
for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI) for (RecIter RI = VarDefs.begin(), RE = VarDefs.end(); RI != RE; ++RI)
Variants.push_back(TransVariant(*RI, AliasRW.Index, AliasProcIdx, 0)); Variants.emplace_back(*RI, AliasRW.Index, AliasProcIdx, 0);
} }
if (AliasRW.IsSequence) { if (AliasRW.IsSequence) {
Variants.push_back( Variants.emplace_back(AliasRW.TheDef, SchedRW.Index, AliasProcIdx, 0);
TransVariant(AliasRW.TheDef, SchedRW.Index, AliasProcIdx, 0));
} }
if (AliasProcIdx == 0) if (AliasProcIdx == 0)
GenericRW = true; GenericRW = true;
} }
for (unsigned VIdx = 0, VEnd = Variants.size(); VIdx != VEnd; ++VIdx) { for (unsigned VIdx = 0, VEnd = Variants.size(); VIdx != VEnd; ++VIdx) {
TransVariant &Variant = Variants[VIdx]; TransVariant &Variant = Variants[VIdx];
// Don't expand variants if the processor models don't intersect. // Don't expand variants if the processor models don't intersect.
// A zero processor index means any processor. // A zero processor index means any processor.
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// If this operand transition is reached through a processor-specific alias, // If this operand transition is reached through a processor-specific alias,
// then the whole transition is specific to this processor. // then the whole transition is specific to this processor.
if (VInfo.ProcIdx != 0) if (VInfo.ProcIdx != 0)
Trans.ProcIndices.assign(1, VInfo.ProcIdx); Trans.ProcIndices.assign(1, VInfo.ProcIdx);
IdxVec SelectedRWs; IdxVec SelectedRWs;
if (VInfo.VarOrSeqDef->isSubClassOf("SchedVar")) { if (VInfo.VarOrSeqDef->isSubClassOf("SchedVar")) {
Record *PredDef = VInfo.VarOrSeqDef->getValueAsDef("Predicate"); Record *PredDef = VInfo.VarOrSeqDef->getValueAsDef("Predicate");
Trans.PredTerm.push_back(PredCheck(IsRead, VInfo.RWIdx,PredDef)); Trans.PredTerm.emplace_back(IsRead, VInfo.RWIdx,PredDef);
RecVec SelectedDefs = VInfo.VarOrSeqDef->getValueAsListOfDefs("Selected"); RecVec SelectedDefs = VInfo.VarOrSeqDef->getValueAsListOfDefs("Selected");
SchedModels.findRWs(SelectedDefs, SelectedRWs, IsRead); SchedModels.findRWs(SelectedDefs, SelectedRWs, IsRead);
} }
else { else {
assert(VInfo.VarOrSeqDef->isSubClassOf("WriteSequence") && assert(VInfo.VarOrSeqDef->isSubClassOf("WriteSequence") &&
"variant must be a SchedVariant or aliased WriteSequence"); "variant must be a SchedVariant or aliased WriteSequence");
SelectedRWs.push_back(SchedModels.getSchedRWIdx(VInfo.VarOrSeqDef, IsRead)); SelectedRWs.push_back(SchedModels.getSchedRWIdx(VInfo.VarOrSeqDef, IsRead));
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

utils/TableGen/FixedLenDecoderEmitter.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstruct OperandInfo {
std::vector<EncodingField> Fields; std::vector<EncodingField> Fields;
std::string Decoder; std::string Decoder;
bool HasCompleteDecoder; bool HasCompleteDecoder;
OperandInfo(std::string D, bool HCD) OperandInfo(std::string D, bool HCD)
: Decoder(std::move(D)), HasCompleteDecoder(HCD) {} : Decoder(std::move(D)), HasCompleteDecoder(HCD) {}
void addField(unsigned Base, unsigned Width, unsigned Offset) { void addField(unsigned Base, unsigned Width, unsigned Offset) {
Fields.push_back(EncodingField(Base, Width, Offset)); Fields.emplace_back(Base, Width, Offset);
} }
unsigned numFields() const { return Fields.size(); } unsigned numFields() const { return Fields.size(); }
typedef std::vector<EncodingField>::const_iterator const_iterator; typedef std::vector<EncodingField>::const_iterator const_iterator;
const_iterator begin() const { return Fields.begin(); } const_iterator begin() const { return Fields.begin(); }
const_iterator end() const { return Fields.end(); } const_iterator end() const { return Fields.end(); }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines