[clang][Inter] Implement __builtin_expect

[tbaeder]

Summary

This adds a InterpStack::discard() version that takes a PrimType argument.

I'm not sure what to do if we actually want to use a value from the stack...

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);
 
-bool InterpretBuiltin(InterpState &S, CodePtr PC, unsigned BuiltinID);
+bool InterpretBuiltin(InterpState &S, CodePtr PC, const FunctionDecl *FuncDecl);
 
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//
 // Add, Sub, Mul
 //===----------------------------------------------------------------------===//
 
 template <typename T, bool (*OpFW)(T, T, unsigned, T *),

 }
 
 inline bool CallBI(InterpState &S, CodePtr &PC, const Function *Func) {
   auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
 
   InterpFrame *FrameBefore = S.Current;
   S.Current = NewFrame.get();
 
-  if (InterpretBuiltin(S, PC, Func->getBuiltinID())) {
+  if (InterpretBuiltin(S, PC, Func->getDecl())) {
     NewFrame.release();
     return true;
   }
   S.Current = FrameBefore;
   return false;
 }
 
 //===----------------------------------------------------------------------===//

clang/lib/AST/Interp/InterpBuiltin.cpp

static bool Ret(InterpState &S, CodePtr &PC) {
   PC = S.Current->getRetPC();
   delete S.Current;
   S.Current = Caller;
   S.Stk.push<T>(Ret);
 
   return true;
 }
 
-bool InterpretBuiltin(InterpState &S, CodePtr PC, unsigned BuiltinID) {
+bool InterpretBuiltin(InterpState &S, CodePtr PC,
+                      const FunctionDecl *FuncDecl) {
+  unsigned BuiltinID = FuncDecl->getBuiltinID();
+  assert(BuiltinID != 0);
+
   switch (BuiltinID) {
   case Builtin::BI__builtin_is_constant_evaluated:
     S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
     Ret<PT_Bool>(S, PC);
     return true;
+
+  case Builtin::BI__builtin_expect: {
+    // __builtin_expect(long, long).
+    //   Pop the last argument from the stack,
+    //   leave the first one and just ignore the function.
+    PrimType LongT = *S.classify(FuncDecl->getParamDecl(1)->getType());
+    S.Stk.discard(LongT);
+    return true;
+  }
   }
 
   return false;
 }
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/InterpStack.h

 //===--- InterpStack.h - Stack implementation for the VM --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the upwards-growing stack used by the interpreter.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 #define LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 
+#include "Pointer.h"
 #include "PrimType.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 namespace interp {
 
 /// Stack frame storing temporaries and parameters.
#ifndef NDEBUG
     assert(ItemTypes.back() == toPrimType<T>());
     ItemTypes.pop_back();
 #endif
     auto *Ptr = &peek<T>();
     Ptr->~T();
     shrink(aligned_size<T>());
   }
 
+  /// Discards the top value of the given PrimType.
+  void discard(PrimType Type) {
+#ifndef NDEBUG
+    assert(ItemTypes.back() == Type);
+    ItemTypes.pop_back();
+#endif
+
+    TYPE_SWITCH(Type, auto *Ptr = &peek<T>(); Ptr->~T();
+                shrink(aligned_size<T>()););
+  }
+
   /// Returns a reference to the value on the top of the stack.
   template <typename T> T &peek() const {
     return *reinterpret_cast<T *>(peek(aligned_size<T>()));
   }
 
   /// Returns a pointer to the top object.
   void *top() const { return Chunk ? peek(0) : nullptr; }
 

clang/lib/AST/Interp/InterpState.h

public:
   /// Deallocates a pointer.
   void deallocate(Block *B);
 
   /// Delegates source mapping to the mapper.
   SourceInfo getSource(const Function *F, CodePtr PC) const override {
     return M ? M->getSource(F, PC) : F->getSource(PC);
   }
 
+  std::optional<PrimType> classify(QualType T) const { return Ctx.classify(T); }
+
 private:
   /// AST Walker state.
   State &Parent;
   /// Dead block chain.
   DeadBlock *DeadBlocks = nullptr;
   /// Reference to the offset-source mapping.
   SourceMapper *M;
 

clang/test/AST/Interp/builtins.cpp

 constexpr bool b = std::is_constant_evaluated();
 static_assert(b, "");
 static_assert(std::is_constant_evaluated() , "");
 
 
 bool is_this_constant() {
   return __builtin_is_constant_evaluated(); // CHECK: ret i1 false
 }
+
+long my_expected() {
+  return __builtin_expect(17, 12); // CHECK: ret {{.*}} 17
+}
+
+long my_expected(long foo) {
+  return __builtin_expect(foo, 100);
+}