1 //===--- State.cpp - State chain for the VM and AST Walker ------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "State.h"
10 #include "Frame.h"
11 #include "Program.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/CXXInheritance.h"
14 
15 using namespace clang;
16 using namespace clang::interp;
17 
18 State::~State() {}
19 
20 OptionalDiagnostic State::FFDiag(SourceLocation Loc, diag::kind DiagId,
21                                  unsigned ExtraNotes) {
22   return diag(Loc, DiagId, ExtraNotes, false);
23 }
24 
25 OptionalDiagnostic State::FFDiag(const Expr *E, diag::kind DiagId,
26                                  unsigned ExtraNotes) {
27   if (getEvalStatus().Diag)
28     return diag(E->getExprLoc(), DiagId, ExtraNotes, false);
29   setActiveDiagnostic(false);
30   return OptionalDiagnostic();
31 }
32 
33 OptionalDiagnostic State::FFDiag(const SourceInfo &SI, diag::kind DiagId,
34                                  unsigned ExtraNotes) {
35   if (getEvalStatus().Diag)
36     return diag(SI.getLoc(), DiagId, ExtraNotes, false);
37   setActiveDiagnostic(false);
38   return OptionalDiagnostic();
39 }
40 
41 OptionalDiagnostic State::CCEDiag(SourceLocation Loc, diag::kind DiagId,
42                                   unsigned ExtraNotes) {
43   // Don't override a previous diagnostic. Don't bother collecting
44   // diagnostics if we're evaluating for overflow.
45   if (!getEvalStatus().Diag || !getEvalStatus().Diag->empty()) {
46     setActiveDiagnostic(false);
47     return OptionalDiagnostic();
48   }
49   return diag(Loc, DiagId, ExtraNotes, true);
50 }
51 
52 OptionalDiagnostic State::CCEDiag(const Expr *E, diag::kind DiagId,
53                                   unsigned ExtraNotes) {
54   return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
55 }
56 
57 OptionalDiagnostic State::CCEDiag(const SourceInfo &SI, diag::kind DiagId,
58                                   unsigned ExtraNotes) {
59   return CCEDiag(SI.getLoc(), DiagId, ExtraNotes);
60 }
61 
62 OptionalDiagnostic State::Note(SourceLocation Loc, diag::kind DiagId) {
63   if (!hasActiveDiagnostic())
64     return OptionalDiagnostic();
65   return OptionalDiagnostic(&addDiag(Loc, DiagId));
66 }
67 
68 void State::addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
69   if (hasActiveDiagnostic()) {
70     getEvalStatus().Diag->insert(getEvalStatus().Diag->end(), Diags.begin(),
71                                  Diags.end());
72   }
73 }
74 
75 DiagnosticBuilder State::report(SourceLocation Loc, diag::kind DiagId) {
76   return getCtx().getDiagnostics().Report(Loc, DiagId);
77 }
78 
79 /// Add a diagnostic to the diagnostics list.
80 PartialDiagnostic &State::addDiag(SourceLocation Loc, diag::kind DiagId) {
81   PartialDiagnostic PD(DiagId, getCtx().getDiagAllocator());
82   getEvalStatus().Diag->push_back(std::make_pair(Loc, PD));
83   return getEvalStatus().Diag->back().second;
84 }
85 
86 OptionalDiagnostic State::diag(SourceLocation Loc, diag::kind DiagId,
87                                unsigned ExtraNotes, bool IsCCEDiag) {
88   Expr::EvalStatus &EvalStatus = getEvalStatus();
89   if (EvalStatus.Diag) {
90     if (hasPriorDiagnostic()) {
91       return OptionalDiagnostic();
92     }
93 
94     unsigned CallStackNotes = getCallStackDepth() - 1;
95     unsigned Limit = getCtx().getDiagnostics().getConstexprBacktraceLimit();
96     if (Limit)
97       CallStackNotes = std::min(CallStackNotes, Limit + 1);
98     if (checkingPotentialConstantExpression())
99       CallStackNotes = 0;
100 
101     setActiveDiagnostic(true);
102     setFoldFailureDiagnostic(!IsCCEDiag);
103     EvalStatus.Diag->clear();
104     EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
105     addDiag(Loc, DiagId);
106     if (!checkingPotentialConstantExpression()) {
107       addCallStack(Limit);
108     }
109     return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
110   }
111   setActiveDiagnostic(false);
112   return OptionalDiagnostic();
113 }
114 
115 const LangOptions &State::getLangOpts() const { return getCtx().getLangOpts(); }
116 
117 void State::addCallStack(unsigned Limit) {
118   // Determine which calls to skip, if any.
119   unsigned ActiveCalls = getCallStackDepth() - 1;
120   unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
121   if (Limit && Limit < ActiveCalls) {
122     SkipStart = Limit / 2 + Limit % 2;
123     SkipEnd = ActiveCalls - Limit / 2;
124   }
125 
126   // Walk the call stack and add the diagnostics.
127   unsigned CallIdx = 0;
128   Frame *Top = getCurrentFrame();
129   const Frame *Bottom = getBottomFrame();
130   for (Frame *F = Top; F != Bottom; F = F->getCaller(), ++CallIdx) {
131     SourceLocation CallLocation = F->getCallLocation();
132 
133     // Skip this call?
134     if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
135       if (CallIdx == SkipStart) {
136         // Note that we're skipping calls.
137         addDiag(CallLocation, diag::note_constexpr_calls_suppressed)
138             << unsigned(ActiveCalls - Limit);
139       }
140       continue;
141     }
142 
143     // Use a different note for an inheriting constructor, because from the
144     // user's perspective it's not really a function at all.
145     if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(F->getCallee())) {
146       if (CD->isInheritingConstructor()) {
147         addDiag(CallLocation, diag::note_constexpr_inherited_ctor_call_here)
148             << CD->getParent();
149         continue;
150       }
151     }
152 
153     SmallString<128> Buffer;
154     llvm::raw_svector_ostream Out(Buffer);
155     F->describe(Out);
156     addDiag(CallLocation, diag::note_constexpr_call_here) << Out.str();
157   }
158 }
159