[clang][Interp] Remove args from called functions in more cases

[tbaeder]

Summary

When calling functions in the checkingPotentialConstantExpression mode,
we cannot have arguments (including This + RVO pointers) for the
toplevel callee, but the functions called from within can work just
fine, or at least we succeed in pushing their arguments on the stack, so
we must also succeed in removing them again.

[aaron.ballman]

LGTM

clang/test/AST/Interp/functions.cpp

262

[tbaeder]

clang/test/AST/Interp/functions.cpp

262

Question regarding this: IIRC it was @MaskRay who once told me to use /// comments for everything that's not a RUN or expected line. If you look further up, I think I stuck to that (mostly). Should I continue doing that or not?

[aaron.ballman]

clang/test/AST/Interp/functions.cpp

262

Oh yeah, you did mostly stick to that; then ignore my suggestion. However, we have no policy regarding // vs /// vs /**/, so it's pretty much a case-by-case basis, but in general we use // for all comments unless there's a specific reason not to.

clang/lib/AST/Interp/Interp.h

 bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F);
 
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//
 // Returning values
 //===----------------------------------------------------------------------===//
 
-template <PrimType Name, bool Builtin = false,
-          class T = typename PrimConv<Name>::T>
+template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Ret(InterpState &S, CodePtr &PC, APValue &Result) {
   const T &Ret = S.Stk.pop<T>();
 
   assert(S.Current->getFrameOffset() == S.Stk.size() && "Invalid frame");
-  if (Builtin || !S.checkingPotentialConstantExpression())
+  if (!S.checkingPotentialConstantExpression() || S.Current->Caller)
     S.Current->popArgs();
 
   if (InterpFrame *Caller = S.Current->Caller) {
     PC = S.Current->getRetPC();
     delete S.Current;
     S.Current = Caller;
     S.Stk.push<T>(Ret);
   } else {
     delete S.Current;
     S.Current = nullptr;
     if (!ReturnValue<T>(Ret, Result))
       return false;
   }
   return true;
 }
 
-template <bool Builtin = false>
 inline bool RetVoid(InterpState &S, CodePtr &PC, APValue &Result) {
   assert(S.Current->getFrameOffset() == S.Stk.size() && "Invalid frame");
-  if (Builtin || !S.checkingPotentialConstantExpression())
+  if (!S.checkingPotentialConstantExpression() || S.Current->Caller)
     S.Current->popArgs();
 
   if (InterpFrame *Caller = S.Current->Caller) {
     PC = S.Current->getRetPC();
     delete S.Current;
     S.Current = Caller;
   } else {
     delete S.Current;

clang/lib/AST/Interp/InterpBuiltin.cpp

 
 bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F) {
   InterpFrame *Frame = S.Current;
   APValue Dummy;
 
   switch (F->getBuiltinID()) {
   case Builtin::BI__builtin_is_constant_evaluated:
     S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
-    return Ret<PT_Bool, true>(S, OpPC, Dummy);
+    return Ret<PT_Bool>(S, OpPC, Dummy);
   case Builtin::BI__builtin_assume:
-    return RetVoid<true>(S, OpPC, Dummy);
+    return RetVoid(S, OpPC, Dummy);
   case Builtin::BI__builtin_strcmp:
     if (interp__builtin_strcmp(S, OpPC, Frame))
-      return Ret<PT_Sint32, true>(S, OpPC, Dummy);
+      return Ret<PT_Sint32>(S, OpPC, Dummy);
     return false;
   default:
     return false;
   }
 
   return false;
 }
 
 } // namespace interp
 } // namespace clang

clang/test/AST/Interp/functions.cpp

constexpr SS() { func(); } // expected-note {{undefined function }} \
                                // ref-note {{undefined function}}
   };
   constexpr SS ss; // expected-error {{must be initialized by a constant expression}} \
                    // expected-note {{in call to 'SS()'}} \
                    // ref-error {{must be initialized by a constant expression}} \
                    // ref-note {{in call to 'SS()'}}
 
 }
+
+namespace CallWithArgs {
+  /// This used to call problems during checkPotentialConstantExpression() runs.
+  constexpr void g(int a) {}
+  constexpr void f() {
+    g(0);
+  }
+}