Skip to content

Commit 7389dbc

Browse files
melvermelver
committed
rebase
Created using spr 1.3.8-beta.1
2 parents 8f2c71c + 4f4bee4 commit 7389dbc

File tree

8 files changed

+269
-11
lines changed

8 files changed

+269
-11
lines changed

‎clang-tools-extra/docs/clang-tidy/checks/bugprone/switch-missing-default-case.rst‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,8 @@ on covering cases with non-enums where the compiler may not issue warnings.
99
Switch statements without a default case can lead to unexpected
1010
behavior and incomplete handling of all possible cases. When a switch statement
1111
lacks a default case, if a value is encountered that does not match any of the
12-
specified cases, the program will continue execution without any defined
13-
behavior or handling.
12+
specified cases, the switch statement will do nothing and the program will
13+
continue execution without handling the value.
1414

1515
This check helps identify switch statements that are missing a default case,
1616
allowing developers to ensure that all possible cases are handled properly.

‎clang/lib/Sema/SemaConcept.cpp‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -385,6 +385,28 @@ class HashParameterMapping : public RecursiveASTVisitor<HashParameterMapping> {
385385
return inherited::TraverseStmt(E->getReplacement());
386386
}
387387

388+
bool TraverseTemplateName(TemplateName Template) {
389+
if (auto *TTP = dyn_cast_if_present<TemplateTemplateParmDecl>(
390+
Template.getAsTemplateDecl());
391+
TTP && TTP->getDepth() < TemplateArgs.getNumLevels()) {
392+
if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
393+
TTP->getPosition()))
394+
return true;
395+
396+
TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
397+
if (TTP->isParameterPack() && SemaRef.ArgPackSubstIndex) {
398+
assert(Arg.getKind() == TemplateArgument::Pack &&
399+
"Missing argument pack");
400+
Arg = SemaRef.getPackSubstitutedTemplateArgument(Arg);
401+
}
402+
assert(!Arg.getAsTemplate().isNull() &&
403+
"Null template template argument");
404+
UsedTemplateArgs.push_back(
405+
SemaRef.Context.getCanonicalTemplateArgument(Arg));
406+
}
407+
return inherited::TraverseTemplateName(Template);
408+
}
409+
388410
void VisitConstraint(const NormalizedConstraintWithParamMapping &Constraint) {
389411
if (!Constraint.hasParameterMapping()) {
390412
for (const auto &List : TemplateArgs)
@@ -2678,8 +2700,9 @@ FormulaType SubsumptionChecker::Normalize(const NormalizedConstraint &NC) {
26782700
});
26792701

26802702
if (Compound.getCompoundKind() == FormulaType::Kind) {
2703+
unsigned SizeLeft = Left.size();
26812704
Res = std::move(Left);
2682-
Res.reserve(Left.size() + Right.size());
2705+
Res.reserve(SizeLeft + Right.size());
26832706
std::for_each(std::make_move_iterator(Right.begin()),
26842707
std::make_move_iterator(Right.end()), Add);
26852708
return Res;

‎clang/test/SemaTemplate/concepts.cpp‎

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1573,3 +1573,62 @@ namespace GH162770 {
15731573
template<typename... Ts> auto comma = (..., Ts());
15741574
auto b = comma<check<e{}>>;
15751575
} // namespace GH162770
1576+
1577+
namespace GH164750 {
1578+
1579+
template <typename>
1580+
struct a;
1581+
template <typename>
1582+
struct b;
1583+
1584+
template <template <typename> typename c, typename d, typename>
1585+
concept e = !__is_convertible_to(c<d>*, b<d>*);
1586+
1587+
template <typename...>
1588+
struct f;
1589+
template <typename g, typename... h>
1590+
struct f<g, h...> {
1591+
g i;
1592+
};
1593+
1594+
template <typename, typename>
1595+
struct u;
1596+
template <typename j, template <typename> typename k, typename l>
1597+
requires e<k, j, l>
1598+
struct u<const k<j>*, l> {
1599+
u(const a<j>*);
1600+
};
1601+
template <typename j, template <typename> typename k, typename l>
1602+
struct u<const k<j>*, l> {
1603+
u(const b<j>*);
1604+
};
1605+
1606+
template <typename>
1607+
struct m;
1608+
template <typename n, typename... o>
1609+
struct m<n (*)(o...)> {
1610+
template <template <typename> typename j>
1611+
using p = j<o...>;
1612+
};
1613+
1614+
template <typename q, typename r>
1615+
struct s {
1616+
template <typename... p>
1617+
struct D {
1618+
using v = f<u<r, p>...>;
1619+
};
1620+
template <typename... t>
1621+
s(t... p1) : x(p1...) {}
1622+
m<q>::template p<D>::v x;
1623+
};
1624+
template <typename w, typename... t>
1625+
void fn1(w, t... p2) {
1626+
s<w, t...>(p2...);
1627+
}
1628+
int* fn2(int) { return nullptr; }
1629+
void fn3() {
1630+
fn1(fn2, static_cast<const a<int>*>(nullptr));
1631+
fn1(fn2, static_cast<const b<int>*>(nullptr));
1632+
}
1633+
1634+
}

‎llvm/lib/CGData/CodeGenDataReader.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -125,7 +125,7 @@ Error IndexedCodeGenDataReader::read() {
125125
FunctionMapRecord.setReadStableFunctionMapNames(
126126
IndexedCodeGenDataReadFunctionMapNames);
127127
if (IndexedCodeGenDataLazyLoading)
128-
FunctionMapRecord.lazyDeserialize(SharedDataBuffer,
128+
FunctionMapRecord.lazyDeserialize(std::move(SharedDataBuffer),
129129
Header.StableFunctionMapOffset);
130130
else
131131
FunctionMapRecord.deserialize(Ptr);

‎llvm/lib/CGData/StableFunctionMap.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -137,6 +137,7 @@ size_t StableFunctionMap::size(SizeType Type) const {
137137
const StableFunctionMap::StableFunctionEntries &
138138
StableFunctionMap::at(HashFuncsMapType::key_type FunctionHash) const {
139139
auto It = HashToFuncs.find(FunctionHash);
140+
assert(It != HashToFuncs.end() && "FunctionHash not found!");
140141
if (isLazilyLoaded())
141142
deserializeLazyLoadingEntry(It);
142143
return It->second.Entries;

‎llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp‎

Lines changed: 19 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2760,21 +2760,34 @@ Instruction *InstCombinerImpl::visitSub(BinaryOperator &I) {
27602760
// Optimize pointer differences into the same array into a size. Consider:
27612761
// &A[10] - &A[0]: we should compile this to "10".
27622762
Value *LHSOp, *RHSOp;
2763-
if (match(Op0, m_PtrToInt(m_Value(LHSOp))) &&
2764-
match(Op1, m_PtrToInt(m_Value(RHSOp))))
2763+
if (match(Op0, m_PtrToIntOrAddr(m_Value(LHSOp))) &&
2764+
match(Op1, m_PtrToIntOrAddr(m_Value(RHSOp))))
27652765
if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(),
27662766
I.hasNoUnsignedWrap()))
27672767
return replaceInstUsesWith(I, Res);
27682768

27692769
// trunc(p)-trunc(q) -> trunc(p-q)
2770-
if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) &&
2771-
match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp)))))
2770+
if (match(Op0, m_Trunc(m_PtrToIntOrAddr(m_Value(LHSOp)))) &&
2771+
match(Op1, m_Trunc(m_PtrToIntOrAddr(m_Value(RHSOp)))))
27722772
if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(),
27732773
/* IsNUW */ false))
27742774
return replaceInstUsesWith(I, Res);
27752775

2776-
if (match(Op0, m_ZExt(m_PtrToIntSameSize(DL, m_Value(LHSOp)))) &&
2777-
match(Op1, m_ZExtOrSelf(m_PtrToInt(m_Value(RHSOp))))) {
2776+
auto MatchSubOfZExtOfPtrToIntOrAddr = [&]() {
2777+
if (match(Op0, m_ZExt(m_PtrToIntSameSize(DL, m_Value(LHSOp)))) &&
2778+
match(Op1, m_ZExt(m_PtrToIntSameSize(DL, m_Value(RHSOp)))))
2779+
return true;
2780+
if (match(Op0, m_ZExt(m_PtrToAddr(m_Value(LHSOp)))) &&
2781+
match(Op1, m_ZExt(m_PtrToAddr(m_Value(RHSOp)))))
2782+
return true;
2783+
// Special case for non-canonical ptrtoint in constant expression,
2784+
// where the zext has been folded into the ptrtoint.
2785+
if (match(Op0, m_ZExt(m_PtrToIntSameSize(DL, m_Value(LHSOp)))) &&
2786+
match(Op1, m_PtrToInt(m_Value(RHSOp))))
2787+
return true;
2788+
return false;
2789+
};
2790+
if (MatchSubOfZExtOfPtrToIntOrAddr()) {
27782791
if (auto *GEP = dyn_cast<GEPOperator>(LHSOp)) {
27792792
if (GEP->getPointerOperand() == RHSOp) {
27802793
if (GEP->hasNoUnsignedWrap() || GEP->hasNoUnsignedSignedWrap()) {

‎llvm/test/Transforms/InstCombine/ptrtoaddr.ll‎

Lines changed: 131 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,3 +40,134 @@ define i128 @ptrtoaddr_sext(ptr %p) {
4040
%ext = sext i64 %p.addr to i128
4141
ret i128 %ext
4242
}
43+
44+
define i64 @sub_ptrtoaddr(ptr %p, i64 %offset) {
45+
; CHECK-LABEL: define i64 @sub_ptrtoaddr(
46+
; CHECK-SAME: ptr [[P:%.*]], i64 [[OFFSET:%.*]]) {
47+
; CHECK-NEXT: ret i64 [[OFFSET]]
48+
;
49+
%p2 = getelementptr i8, ptr %p, i64 %offset
50+
%p.addr = ptrtoaddr ptr %p to i64
51+
%p2.addr = ptrtoaddr ptr %p2 to i64
52+
%sub = sub i64 %p2.addr, %p.addr
53+
ret i64 %sub
54+
}
55+
56+
define i64 @sub_ptrtoint_ptrtoaddr(ptr %p, i64 %offset) {
57+
; CHECK-LABEL: define i64 @sub_ptrtoint_ptrtoaddr(
58+
; CHECK-SAME: ptr [[P:%.*]], i64 [[OFFSET:%.*]]) {
59+
; CHECK-NEXT: ret i64 [[OFFSET]]
60+
;
61+
%p2 = getelementptr i8, ptr %p, i64 %offset
62+
%p.int = ptrtoint ptr %p to i64
63+
%p2.addr = ptrtoaddr ptr %p2 to i64
64+
%sub = sub i64 %p2.addr, %p.int
65+
ret i64 %sub
66+
}
67+
68+
define i32 @sub_ptrtoaddr_addrsize(ptr addrspace(1) %p, i32 %offset) {
69+
; CHECK-LABEL: define i32 @sub_ptrtoaddr_addrsize(
70+
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], i32 [[OFFSET:%.*]]) {
71+
; CHECK-NEXT: ret i32 [[OFFSET]]
72+
;
73+
%p2 = getelementptr i8, ptr addrspace(1) %p, i32 %offset
74+
%p.addr = ptrtoaddr ptr addrspace(1) %p to i32
75+
%p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32
76+
%sub = sub i32 %p2.addr, %p.addr
77+
ret i32 %sub
78+
}
79+
80+
define i32 @sub_trunc_ptrtoaddr(ptr %p, i64 %offset) {
81+
; CHECK-LABEL: define i32 @sub_trunc_ptrtoaddr(
82+
; CHECK-SAME: ptr [[P:%.*]], i64 [[OFFSET:%.*]]) {
83+
; CHECK-NEXT: [[SUB:%.*]] = trunc i64 [[OFFSET]] to i32
84+
; CHECK-NEXT: ret i32 [[SUB]]
85+
;
86+
%p2 = getelementptr i8, ptr %p, i64 %offset
87+
%p.addr = ptrtoaddr ptr %p to i64
88+
%p2.addr = ptrtoaddr ptr %p2 to i64
89+
%p.addr.trunc = trunc i64 %p.addr to i32
90+
%p2.addr.trunc = trunc i64 %p2.addr to i32
91+
%sub = sub i32 %p2.addr.trunc, %p.addr.trunc
92+
ret i32 %sub
93+
}
94+
95+
define i16 @sub_trunc_ptrtoaddr_addrsize(ptr addrspace(1) %p, i32 %offset) {
96+
; CHECK-LABEL: define i16 @sub_trunc_ptrtoaddr_addrsize(
97+
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], i32 [[OFFSET:%.*]]) {
98+
; CHECK-NEXT: [[SUB:%.*]] = trunc i32 [[OFFSET]] to i16
99+
; CHECK-NEXT: ret i16 [[SUB]]
100+
;
101+
%p2 = getelementptr i8, ptr addrspace(1) %p, i32 %offset
102+
%p.addr = ptrtoaddr ptr addrspace(1) %p to i32
103+
%p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32
104+
%p.addr.trunc = trunc i32 %p.addr to i16
105+
%p2.addr.trunc = trunc i32 %p2.addr to i16
106+
%sub = sub i16 %p2.addr.trunc, %p.addr.trunc
107+
ret i16 %sub
108+
}
109+
110+
define i16 @sub_trunc_ptrtoint_ptrtoaddr_addrsize(ptr addrspace(1) %p, i32 %offset) {
111+
; CHECK-LABEL: define i16 @sub_trunc_ptrtoint_ptrtoaddr_addrsize(
112+
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], i32 [[OFFSET:%.*]]) {
113+
; CHECK-NEXT: [[SUB:%.*]] = trunc i32 [[OFFSET]] to i16
114+
; CHECK-NEXT: ret i16 [[SUB]]
115+
;
116+
%p2 = getelementptr i8, ptr addrspace(1) %p, i32 %offset
117+
%p.int = ptrtoint ptr addrspace(1) %p to i64
118+
%p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32
119+
%p.int.trunc = trunc i64 %p.int to i16
120+
%p2.addr.trunc = trunc i32 %p2.addr to i16
121+
%sub = sub i16 %p2.addr.trunc, %p.int.trunc
122+
ret i16 %sub
123+
}
124+
125+
define i128 @sub_zext_ptrtoaddr(ptr %p, i64 %offset) {
126+
; CHECK-LABEL: define i128 @sub_zext_ptrtoaddr(
127+
; CHECK-SAME: ptr [[P:%.*]], i64 [[OFFSET:%.*]]) {
128+
; CHECK-NEXT: [[SUB:%.*]] = zext i64 [[OFFSET]] to i128
129+
; CHECK-NEXT: ret i128 [[SUB]]
130+
;
131+
%p2 = getelementptr nuw i8, ptr %p, i64 %offset
132+
%p.addr = ptrtoaddr ptr %p to i64
133+
%p2.addr = ptrtoaddr ptr %p2 to i64
134+
%p.addr.ext = zext i64 %p.addr to i128
135+
%p2.addr.ext = zext i64 %p2.addr to i128
136+
%sub = sub i128 %p2.addr.ext, %p.addr.ext
137+
ret i128 %sub
138+
}
139+
140+
define i64 @sub_zext_ptrtoaddr_addrsize(ptr addrspace(1) %p, i32 %offset) {
141+
; CHECK-LABEL: define i64 @sub_zext_ptrtoaddr_addrsize(
142+
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], i32 [[OFFSET:%.*]]) {
143+
; CHECK-NEXT: [[SUB:%.*]] = zext i32 [[OFFSET]] to i64
144+
; CHECK-NEXT: ret i64 [[SUB]]
145+
;
146+
%p2 = getelementptr nuw i8, ptr addrspace(1) %p, i32 %offset
147+
%p.addr = ptrtoaddr ptr addrspace(1) %p to i32
148+
%p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32
149+
%p.addr.ext = zext i32 %p.addr to i64
150+
%p2.addr.ext = zext i32 %p2.addr to i64
151+
%sub = sub i64 %p2.addr.ext, %p.addr.ext
152+
ret i64 %sub
153+
}
154+
155+
define i128 @sub_zext_ptrtoint_ptrtoaddr_addrsize(ptr addrspace(1) %p, i32 %offset) {
156+
; CHECK-LABEL: define i128 @sub_zext_ptrtoint_ptrtoaddr_addrsize(
157+
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], i32 [[OFFSET:%.*]]) {
158+
; CHECK-NEXT: [[P2:%.*]] = getelementptr nuw i8, ptr addrspace(1) [[P]], i32 [[OFFSET]]
159+
; CHECK-NEXT: [[P_INT:%.*]] = ptrtoint ptr addrspace(1) [[P]] to i64
160+
; CHECK-NEXT: [[P2_ADDR:%.*]] = ptrtoaddr ptr addrspace(1) [[P2]] to i32
161+
; CHECK-NEXT: [[P_INT_EXT:%.*]] = zext i64 [[P_INT]] to i128
162+
; CHECK-NEXT: [[P2_ADDR_EXT:%.*]] = zext i32 [[P2_ADDR]] to i128
163+
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i128 [[P2_ADDR_EXT]], [[P_INT_EXT]]
164+
; CHECK-NEXT: ret i128 [[SUB]]
165+
;
166+
%p2 = getelementptr nuw i8, ptr addrspace(1) %p, i32 %offset
167+
%p.int = ptrtoint ptr addrspace(1) %p to i64
168+
%p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32
169+
%p.int.ext = zext i64 %p.int to i128
170+
%p2.addr.ext = zext i32 %p2.addr to i128
171+
%sub = sub i128 %p2.addr.ext, %p.int.ext
172+
ret i128 %sub
173+
}

‎llvm/test/Transforms/InstCombine/sub-gep.ll‎

Lines changed: 32 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
22
; RUN: opt -S -passes=instcombine < %s | FileCheck %s
33

4-
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-p2:32:32"
4+
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-p2:32:32-p3:32:32:32:16"
55

66
define i64 @test_inbounds(ptr %base, i64 %idx) {
77
; CHECK-LABEL: @test_inbounds(
@@ -505,6 +505,23 @@ define i64 @negative_zext_ptrtoint_sub_ptrtoint_as2_nuw(i32 %offset) {
505505
ret i64 %D
506506
}
507507

508+
define i64 @negative_zext_ptrtoint_sub_zext_ptrtoint_as2_nuw_truncating(i32 %offset) {
509+
; CHECK-LABEL: @negative_zext_ptrtoint_sub_zext_ptrtoint_as2_nuw_truncating(
510+
; CHECK-NEXT: [[A:%.*]] = getelementptr nuw bfloat, ptr addrspace(2) @Arr_as2, i32 [[OFFSET:%.*]]
511+
; CHECK-NEXT: [[A_IDX:%.*]] = ptrtoint ptr addrspace(2) [[A]] to i32
512+
; CHECK-NEXT: [[E:%.*]] = zext i32 [[A_IDX]] to i64
513+
; CHECK-NEXT: [[D:%.*]] = zext i16 ptrtoint (ptr addrspace(2) @Arr_as2 to i16) to i64
514+
; CHECK-NEXT: [[E1:%.*]] = sub nsw i64 [[E]], [[D]]
515+
; CHECK-NEXT: ret i64 [[E1]]
516+
;
517+
%A = getelementptr nuw bfloat, ptr addrspace(2) @Arr_as2, i32 %offset
518+
%B = ptrtoint ptr addrspace(2) %A to i32
519+
%C = zext i32 %B to i64
520+
%D = zext i16 ptrtoint (ptr addrspace(2) @Arr_as2 to i16) to i64
521+
%E = sub i64 %C, %D
522+
ret i64 %E
523+
}
524+
508525
define i64 @ptrtoint_sub_zext_ptrtoint_as2_inbounds_local(ptr addrspace(2) %p, i32 %offset) {
509526
; CHECK-LABEL: @ptrtoint_sub_zext_ptrtoint_as2_inbounds_local(
510527
; CHECK-NEXT: [[A:%.*]] = getelementptr inbounds bfloat, ptr addrspace(2) [[P:%.*]], i32 [[OFFSET:%.*]]
@@ -614,6 +631,20 @@ define i64 @negative_zext_ptrtoint_sub_ptrtoint_as2_nuw_local(ptr addrspace(2) %
614631
ret i64 %D
615632
}
616633

634+
define i64 @zext_ptrtoint_sub_ptrtoint_as3_nuw_local(ptr addrspace(3) %p, i16 %offset) {
635+
; CHECK-LABEL: @zext_ptrtoint_sub_ptrtoint_as3_nuw_local(
636+
; CHECK-NEXT: [[SUB:%.*]] = zext i16 [[GEP_IDX:%.*]] to i64
637+
; CHECK-NEXT: ret i64 [[SUB]]
638+
;
639+
%gep = getelementptr nuw i8, ptr addrspace(3) %p, i16 %offset
640+
%gep.int = ptrtoint ptr addrspace(3) %gep to i32
641+
%p.int = ptrtoint ptr addrspace(3) %p to i32
642+
%gep.int.ext = zext i32 %gep.int to i64
643+
%p.int.ext = zext i32 %p.int to i64
644+
%sub = sub i64 %gep.int.ext, %p.int.ext
645+
ret i64 %sub
646+
}
647+
617648
define i64 @test30(ptr %foo, i64 %i, i64 %j) {
618649
; CHECK-LABEL: @test30(
619650
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nsw i64 [[I:%.*]], 2

0 commit comments

Comments
 (0)