[clang][Interp] Pass CallExpr to builtin functions

[tbaeder]

Summary

For some builtins, we need to do quite a bit of type checking ourselves,
so pass the call expression along. This way we can inspect arguments,
expected return value, etc.

As discussed with @aaron.ballman on Discord, reject non-StringLiteral inputs from __builtin_isnan().

[aaron.ballman]

clang/lib/AST/Interp/InterpBuiltin.cpp

78–79

Hmmm, I think I missed a situation when we were talking about this. Consider: https://godbolt.org/z/14dz5MMPj

I think the current interpreter is wrong to reject that code (I think the GCC behavior is correct). If you remove the constexpr from the declaration of Nan2, it compiles fine.

WDYT?

clang/test/AST/Interp/builtin-functions.cpp

44 ↗

(On Diff #541323)

I mentioned this on another review, but I think the current interpreter is wrong to reject this because that lambda is constexpr-suitable.

http://eel.is/c++draft/expr.prim.lambda#closure-5
http://eel.is/c++draft/dcl.constexpr#3

[tbaeder]

Ping

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!Func)
     return false;
 
   // Put arguments on the stack.
   for (const auto *Arg : E->arguments()) {
     if (!this->visit(Arg))
       return false;
   }
 
-  if (!this->emitCallBI(Func, E))
+  if (!this->emitCallBI(Func, E, E))
     return false;
 
   QualType ReturnType = E->getCallReturnType(Ctx.getASTContext());
   if (DiscardResult && !ReturnType->isVoidType()) {
     PrimType T = classifyPrim(ReturnType);
     return this->emitPop(T, E);
   }
 

clang/lib/AST/Interp/Interp.h

 /// Checks if the result is a floating-point operation is valid
 /// in the current context.
 bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status);
 
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
 /// Interpret a builtin function.
-bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F);
+bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F,
+                      const CallExpr *Call);
 
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//
 // Returning values
 //===----------------------------------------------------------------------===//
 
 /// Pop arguments of builtins defined as func-name(...).
if (Func->getParentDecl()->isDerivedFrom(ThisFieldDecl)) {
       // is the furthest we might go up in the hierarchy.
       ThisPtr = ThisPtr.getDeclPtr();
     }
   }
 
   return Call(S, OpPC, Func);
 }
 
-inline bool CallBI(InterpState &S, CodePtr &PC, const Function *Func) {
+inline bool CallBI(InterpState &S, CodePtr &PC, const Function *Func,
+                   const CallExpr *CE) {
   auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
 
   InterpFrame *FrameBefore = S.Current;
   S.Current = NewFrame.get();
 
-  if (InterpretBuiltin(S, PC, Func)) {
+  if (InterpretBuiltin(S, PC, Func, CE)) {
     NewFrame.release();
     return true;
   }
   S.Current = FrameBefore;
   return false;
 }
 
 inline bool CallPtr(InterpState &S, CodePtr OpPC) {

clang/lib/AST/Interp/InterpBuiltin.cpp

static bool interp__builtin_strcmp(InterpState &S, CodePtr OpPC,
   S.Stk.push<Integral<32, true>>(Integral<32, true>::from(Result));
   return true;
 }
 
 static bool interp__builtin_nan(InterpState &S, CodePtr OpPC,
                                 const InterpFrame *Frame, const Function *F,
                                 bool Signaling) {
   const Pointer &Arg = getParam<Pointer>(Frame, 0);
 
   if (!CheckLoad(S, OpPC, Arg))
     return false;
 
   assert(Arg.getFieldDesc()->isPrimitiveArray());
 
   // Convert the given string to an integer using StringRef's API.
   llvm::APInt Fill;
   std::string Str;
   assert(Arg.getNumElems() >= 1);
static bool interp__builtin_isnormal(InterpState &S, CodePtr OpPC,
   S.Stk.push<Integral<32, true>>(Integral<32, true>::from(Arg.isNormal()));
   return true;
 }
 
 /// First parameter to __builtin_isfpclass is the floating value, the
 /// second one is an integral value.
 static bool interp__builtin_isfpclass(InterpState &S, CodePtr OpPC,
                                       const InterpFrame *Frame,
-                                      const Function *Func) {
-  const Expr *E = S.Current->getExpr(OpPC);
-  const CallExpr *CE = cast<CallExpr>(E);
-  PrimType FPClassArgT = *S.getContext().classify(CE->getArgs()[1]->getType());
+                                      const Function *Func,
+                                      const CallExpr *Call) {
+  PrimType FPClassArgT = *S.getContext().classify(Call->getArg(1)->getType());
   APSInt FPClassArg = peekToAPSInt(S.Stk, FPClassArgT);
   const Floating &F =
       S.Stk.peek<Floating>(align(primSize(FPClassArgT) + primSize(PT_Float)));
 
   int32_t Result =
       static_cast<int32_t>((F.classify() & FPClassArg).getZExtValue());
   S.Stk.push<Integral<32, true>>(Integral<32, true>::from(Result));
 
static bool interp__builtin_fabs(InterpState &S, CodePtr OpPC,
                                  const InterpFrame *Frame,
                                  const Function *Func) {
   const Floating &Val = getParam<Floating>(Frame, 0);
 
   S.Stk.push<Floating>(Floating::abs(Val));
   return true;
 }
 
-bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F) {
+bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F,
+                      const CallExpr *Call) {
   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>(S, OpPC, Dummy);
   case Builtin::BI__builtin_assume:
case Builtin::BI__builtin_isfinite:
     if (interp__builtin_isfinite(S, OpPC, Frame, F))
       return Ret<PT_Sint32>(S, OpPC, Dummy);
     break;
   case Builtin::BI__builtin_isnormal:
     if (interp__builtin_isnormal(S, OpPC, Frame, F))
       return Ret<PT_Sint32>(S, OpPC, Dummy);
     break;
   case Builtin::BI__builtin_isfpclass:
-    if (interp__builtin_isfpclass(S, OpPC, Frame, F))
+    if (interp__builtin_isfpclass(S, OpPC, Frame, F, Call))
       return Ret<PT_Sint32>(S, OpPC, Dummy);
     break;
   case Builtin::BI__builtin_fpclassify:
     if (interp__builtin_fpclassify(S, OpPC, Frame, F))
       return Ret<PT_Sint32>(S, OpPC, Dummy);
     break;
 
   case Builtin::BI__builtin_fabs:

clang/lib/AST/Interp/Opcodes.td

 
 def ArgFunction : ArgType { let Name = "const Function *"; }
 def ArgRecordDecl : ArgType { let Name = "const RecordDecl *"; }
 def ArgRecordField : ArgType { let Name = "const Record::Field *"; }
 def ArgFltSemantics : ArgType { let Name = "const llvm::fltSemantics *"; }
 def ArgRoundingMode : ArgType { let Name = "llvm::RoundingMode"; }
 def ArgLETD: ArgType { let Name = "const LifetimeExtendedTemporaryDecl *"; }
 def ArgCastKind : ArgType { let Name = "CastKind"; }
+def ArgCallExpr : ArgType { let Name = "const CallExpr *"; }
 
 //===----------------------------------------------------------------------===//
 // Classes of types instructions operate on.
 //===----------------------------------------------------------------------===//
 
 class TypeClass {
   list<Type> Types;
 }

 }
 
 def CallVirt : Opcode {
   let Args = [ArgFunction];
   let Types = [];
 }
 
 def CallBI : Opcode {
-  let Args = [ArgFunction];
+  let Args = [ArgFunction, ArgCallExpr];
   let Types = [];
 }
 
 def CallPtr : Opcode {
   let Args = [];
   let Types = [];
 }