Make Injective and HyperView parameter attributes

instead of function attributes.

Rewrite Tapir alias analysis to be more independent
of BasicAliasAnalysis.  In the future it should be
a separate alias analysis pass.

Add __tapir_frame builtin to get current frame descriptor.
Pass __tapir_frame as an argument to hyperobject view lookup.

Remove never-used hyper_token builtin and intrinsic.

clang/include/clang/Basic/Attr.td

@@ -4156,21 +4156,14 @@ def StrandMalloc : InheritableAttr {
 }
 
 def Injective : InheritableAttr {
-  // TODO: Associate this with a single argument, not the function.
   let Spellings = [Clang<"injective">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[ParmVar]>;
   let Documentation = [Undocumented];
 }
 
 def HyperView : InheritableAttr {
   let Spellings = [Clang<"hyper_view">];
-  let Subjects = SubjectList<[FunctionLike]>;
-  let Documentation = [StrandMallocDocs];
-}
-
-def HyperToken : InheritableAttr {
-  let Spellings = [Clang<"hyper_token">];
-  let Subjects = SubjectList<[FunctionLike]>;
+  let Subjects = SubjectList<[ParmVar]>;
   let Documentation = [StrandMallocDocs];
 }
 

clang/include/clang/Basic/Builtins.def

@@ -1721,6 +1721,8 @@ BUILTIN(__builtin_ms_va_copy, "vc*&c*&", "n")
 // Arithmetic Fence: to prevent FP reordering and reassociation optimizations
 LANGBUILTIN(__arithmetic_fence, "v.", "tE", ALL_LANGUAGES)
 
+BUILTIN(__tapir_frame, "v*", "n")
+
 // Tapir.  Rewriting of reducer references happens during sema
 // and needs a builtin to carry the information to codegen.
 BUILTIN(__hyper_lookup, "v*vC*z.", "nU")

clang/lib/CodeGen/CGBuiltin.cpp

@@ -5429,15 +5429,27 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                                      Str.getPointer(), Zeros);
     return RValue::get(Ptr);
   }
+  case Builtin::BI__tapir_frame: {
+    Function *FF = CGM.getIntrinsic(Intrinsic::tapir_frame);
+    return RValue::get(Builder.CreateCall(FF, {}));
+  }
   case Builtin::BI__hyper_lookup: {
+    Function *TF = CGM.getIntrinsic(Intrinsic::tapir_frame);
+    llvm::Value *Frame = Builder.CreateCall(TF, {});
     llvm::Value *Size = EmitScalarExpr(E->getArg(1));
     Function *F = CGM.getIntrinsic(Intrinsic::hyper_lookup, Size->getType());
     llvm::Value *Ptr = EmitScalarExpr(E->getArg(0));
     llvm::Value *Identity = EmitScalarExpr(E->getArg(2));
     llvm::Value *Reduce = EmitScalarExpr(E->getArg(3));
-    return RValue::get(Builder.CreateCall(
-        F, {Ptr, Size, Builder.CreateBitCast(Identity, VoidPtrTy),
-            Builder.CreateBitCast(Reduce, VoidPtrTy)}));
+    CallInst *Call =
+      Builder.CreateCall(F,
+                         {Frame, Ptr, Size,
+                          Builder.CreateBitCast(Identity, VoidPtrTy),
+                          Builder.CreateBitCast(Reduce, VoidPtrTy)});
+    // TODO: These should be added automatically based on the function type.
+    Call->addParamAttr(1, Attribute::Injective);
+    Call->addParamAttr(1, Attribute::HyperView);
+    return RValue::get(Call);
   }
   }
   IsSpawnedScope SpawnedScp(this);

clang/lib/Sema/SemaDeclAttr.cpp

@@ -9364,9 +9364,6 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_HyperView:
     handleSimpleAttribute<HyperViewAttr>(S, D, AL);
     break;
-  case ParsedAttr::AT_HyperToken:
-    handleSimpleAttribute<HyperTokenAttr>(S, D, AL);
-    break;
   case ParsedAttr::AT_ReducerUnregister:
     handleSimpleAttribute<ReducerUnregisterAttr>(S, D, AL);
     break;

clang/test/Cilk/hyper-array-extern-1.cpp

@@ -10,7 +10,7 @@ int read_array_hyper(unsigned i)
 {
   return x[i];
   // CHECK: %[[ARRAYIDX:.+]] = getelementptr inbounds
-  // CHECK: %[[VIEWRAW:.+]] = call ptr @llvm.hyper.lookup.i64(ptr %[[ARRAYIDX]], i64 4, ptr null, ptr null)
+  // CHECK: %[[VIEWRAW:.+]] = call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[ARRAYIDX]], i64 4, ptr null, ptr null)
   // CHECK-NOT: call ptr @llvm.hyper.lookup
   // CHECK: %[[VAL:.+]] = load i32, ptr %[[VIEWRAW]]
   // CHECK: ret i32 %[[VAL]]

clang/test/Cilk/hyper-assign.c

@@ -6,18 +6,18 @@ extern long _Hyperobject x, _Hyperobject y;
 
 long chain_assign()
 {
-  // CHECK: %[[Y1RAW:.+]] = call ptr @llvm.hyper.lookup.i64(ptr @y, i64 8, ptr null, ptr null)
+  // CHECK: %[[Y1RAW:.+]] = call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @y, i64 8, ptr null, ptr null)
   // CHECK: %[[Y1VAL:.+]] = load i64, ptr %[[Y1RAW]]
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 8, ptr null, ptr null)
   // CHECK: store i64 %[[Y1VAL]]
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @y, i64 8, ptr null, ptr null)
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @y, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 8, ptr null, ptr null)
   return x = y = x = y;
 }
 
 long simple_assign(long val)
 {
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 8, ptr null, ptr null)
   // CHECK-NOT: call ptr @llvm.hyper.lookup
   // CHECK: store i64
   return x = val;
@@ -26,11 +26,11 @@ long simple_assign(long val)
 long subtract()
 {
   // The order is not fixed here.
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @y, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @y, i64 8, ptr null, ptr null)
   // CHECK: load i64
   // CHECK: add nsw i64 %[[Y:.+]], 1
   // CHECK: store i64
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 8, ptr null, ptr null)
   // CHECK: load i64
   // CHECK: sub nsw
   // CHECK: store i64

clang/test/Cilk/hyper-complex.c

@@ -7,7 +7,7 @@ extern __complex__ float _Hyperobject c;
 // CHECK-LABEL: get_real 
 float get_real()
 {
-  // CHECK: %[[RAW1:.+]] = call ptr @llvm.hyper.lookup.i64(ptr @c, i64 8, ptr null, ptr null)
+  // CHECK: %[[RAW1:.+]] = call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @c, i64 8, ptr null, ptr null)
   // CHECK: %[[FIELD1:.+]] = getelementptr inbounds { float, float }, ptr %[[RAW1]], i32 0, i32 0
   // CHECK: %[[RET1:.+]] = load float, ptr %[[FIELD1]]
   // CHECK: ret float %[[RET1]]
@@ -16,7 +16,7 @@ float get_real()
 // CHECK-LABEL: get_imag
 float get_imag()
 {
-  // CHECK: %[[RAW2:.+]] = call ptr @llvm.hyper.lookup.i64(ptr @c, i64 8, ptr null, ptr null)
+  // CHECK: %[[RAW2:.+]] = call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @c, i64 8, ptr null, ptr null)
   // CHECK: %[[FIELD2:.+]] = getelementptr inbounds { float, float }, ptr %[[RAW2]], i32 0, i32 1
   // CHECK: load float, ptr %[[FIELD2]]
   // CHECK: ret float
@@ -27,7 +27,7 @@ float get_imag()
 float get_abs()
 {
   // Only one call to llvm.hyper.lookup.
-  // CHECK: @llvm.hyper.lookup.i64(ptr @c, i64 8, ptr null, ptr null)
+  // CHECK: @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @c, i64 8, ptr null, ptr null)
   // CHECK-NOT: @llvm.hyper.lookup
   // CHECK: call float @cabsf
   // CHECK: ret float

clang/test/Cilk/hyper-copy.c

@@ -9,9 +9,9 @@ extern struct S b __attribute__((aligned(8)));
 // CHECK-LABEL: scopy
 void scopy()
 {
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @a, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @a, i64 8, ptr null, ptr null)
   // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 @b,
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @a, i64 8, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @a, i64 8, ptr null, ptr null)
   // CHECK: call void @llvm.memcpy.p0.p0.i64
   // CHECK: ret void
   b = a;

clang/test/Cilk/hyper-template.cpp

@@ -5,7 +5,8 @@ template<typename T> struct S { T member; };
 S<long> _Hyperobject S_long;
 
 // CHECK-LABEL: @_Z1fv
-// CHECK: %0 = call ptr @llvm.hyper.lookup.i64(ptr @S_long, i64 8, ptr null, ptr null)
+// CHECK: %0 = call ptr @llvm.tapir.frame()
+// CHECK: %1 = call ptr @llvm.hyper.lookup.i64(ptr %0, ptr hyper_view injective @S_long, i64 8, ptr null, ptr null)
 // CHECK-NOT: call ptr @llvm.hyper.lookup
 // CHECK: getelementptr
 // CHECK: %[[RET:.+]] = load i64

clang/test/Cilk/hyper-unary.c

@@ -11,9 +11,9 @@ void function1()
 {
   // CHECK: store i32 1, ptr %[[Y:.+]],
   int _Hyperobject y = 1;
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 4, ptr null, ptr null)
   // CHECK: load i32
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %[[Y]], i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[Y]], i64 4, ptr null, ptr null)
   // CHECK: load i32
   (void)x; (void)y;
 }
@@ -23,9 +23,9 @@ void function2()
 {
   // CHECK: store i32 1, ptr %[[Y:.+]],
   int _Hyperobject y = 1;
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 4, ptr null, ptr null)
   // CHECK: load i32
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %[[Y]], i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[Y]], i64 4, ptr null, ptr null)
   // CHECK: load i32
   (void)!x; (void)!y;
 }
@@ -35,18 +35,18 @@ void function3()
 {
   // CHECK: store i32 1, ptr %[[Y:.+]],
   int _Hyperobject y = 1;
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 4, ptr null, ptr null)
   // CHECK: load i32
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %[[Y]], i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[Y]], i64 4, ptr null, ptr null)
   // CHECK: load i32
   (void)-x; (void)-y;
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr @x, i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective @x, i64 4, ptr null, ptr null)
   // CHECK: load i32
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %[[Y]], i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[Y]], i64 4, ptr null, ptr null)
   // CHECK: load i32
   (void)~x; (void)~y;
   // CHECK: %[[XP:.+]] = load ptr, ptr @xp
-  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %[[XP]], i64 4, ptr null, ptr null)
+  // CHECK: call ptr @llvm.hyper.lookup.i64(ptr %{{[0-9]+}}, ptr hyper_view injective %[[XP]], i64 4, ptr null, ptr null)
   // CHECK: load i32
   (void)*xp;
 }

clang/test/Cilk/tapir-frame.c

@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 %s -x c -O1 -fopencilk -mllvm -use-opencilk-runtime-bc=false -mllvm -debug-abi-calls=true -verify -S -emit-llvm -o - | FileCheck %s
+// expected-no-diagnostics
+
+// CHECK-LABEL: zero
+int zero()
+{
+  return __tapir_frame() != 0;
+  // CHECK: ret i32 0
+}
+
+// CHECK-LABEL: one
+int one()
+{
+  extern void f(int);
+  _Cilk_spawn f(0);
+  _Cilk_spawn f(1);
+  // CHECK: ret i32 1
+  return __tapir_frame() != 0;
+}
+
+// CHECK-LABEL: function3
+int function3()
+{
+  extern void f(int);
+  extern int g(void *);
+  _Cilk_spawn f(0);
+  // CHECK: call i32 @g(ptr noundef nonnull %__cilkrts_sf)
+  return g(__tapir_frame());
+}

clang/test/Misc/pragma-attribute-supported-attributes-list.test

@@ -74,12 +74,11 @@
 // CHECK-NEXT: GNUInline (SubjectMatchRule_function)
 // CHECK-NEXT: HIPManaged (SubjectMatchRule_variable)
 // CHECK-NEXT: Hot (SubjectMatchRule_function)
-// CHECK-NEXT: HyperToken (SubjectMatchRule_hasType_functionType)
-// CHECK-NEXT: HyperView (SubjectMatchRule_hasType_functionType)
+// CHECK-NEXT: HyperView (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: IBAction (SubjectMatchRule_objc_method_is_instance)
 // CHECK-NEXT: IFunc (SubjectMatchRule_function)
 // CHECK-NEXT: InitPriority (SubjectMatchRule_variable)
-// CHECK-NEXT: Injective (SubjectMatchRule_function)
+// CHECK-NEXT: Injective (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: InternalLinkage (SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_record)
 // CHECK-NEXT: LTOVisibilityPublic (SubjectMatchRule_record)
 // CHECK-NEXT: Leaf (SubjectMatchRule_function)

llvm/include/llvm/Analysis/BasicAliasAnalysis.h

@@ -137,15 +137,19 @@ class BasicAAResult : public AAResultBase {
   AliasResult aliasCheck(const Value *V1, LocationSize V1Size, const Value *V2,
                          LocationSize V2Size, AAQueryInfo &AAQI,
                          const Instruction *CtxI);
+  AliasResult aliasCheckTapir(const Value *V1,  const Value *V2,
+                              LocationSize Size, AAQueryInfo &AAQI,
+                              const Instruction *CtxI);
 
   AliasResult aliasCheckRecursive(const Value *V1, LocationSize V1Size,
                                   const Value *V2, LocationSize V2Size,
                                   AAQueryInfo &AAQI, const Value *O1,
                                   const Value *O2);
 
-  AliasResult checkInjectiveArguments(const Value *V1, const Value *O1,
-                                      const Value *V2, const Value *O2,
+  const Value *getViewClass(const CallBase *V, AAQueryInfo &AAQI);
+  AliasResult checkInjectiveArguments(const CallBase *C1, const CallBase *C2,
                                       AAQueryInfo &AAQI);
+
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.

llvm/include/llvm/IR/Attributes.td

@@ -107,7 +107,7 @@ def FnRetThunkExtern : EnumAttr<"fn_ret_thunk_extern", [FnAttr]>;
 def InAlloca : TypeAttr<"inalloca", [ParamAttr]>;
 
 /// Distinct arguments to this function yield distinct return values.
-def Injective : EnumAttr<"injective", [FnAttr]>;
+def Injective : EnumAttr<"injective", [ParamAttr]>;
 
 /// Source said inlining was desirable.
 def InlineHint : EnumAttr<"inlinehint", [FnAttr]>;
@@ -216,7 +216,7 @@ def ReadNone : EnumAttr<"readnone", [ParamAttr]>;
 def ReadOnly : EnumAttr<"readonly", [ParamAttr]>;
 
 /// Tapir reducer-related attributes.
-def HyperView : EnumAttr<"hyper_view", [FnAttr]>;
+def HyperView : EnumAttr<"hyper_view", [ParamAttr]>;
 def ReducerRegister : EnumAttr<"reducer_register", [FnAttr]>;
 def ReducerUnregister : EnumAttr<"reducer_unregister", [FnAttr]>;
 

llvm/include/llvm/IR/Intrinsics.td

@@ -60,18 +60,10 @@ def Commutative : IntrinsicProperty;
 // Throws - This intrinsic can throw.
 def Throws : IntrinsicProperty;
 
-// Injective - This intrinsic returns different values given different
-// arguments.
-def IntrInjective : IntrinsicProperty;
 // Strand pure - (Tapir) This intrinsic has no visible side effects and
 // returns the same result given the same argument, but only within a
 // single strand of execution.
 def IntrStrandPure : IntrinsicProperty;
-// HyperView - (Tapir) This intrinsic lowers to a runtime call to
-// find the address of the current view of a hyperobject.  It does not
-// return the address of anything in the current frame other than its
-// argument.
-def IntrHyperView : IntrinsicProperty;
 // ReducerRegister / ReducerUnregister - (Tapir) This intrinsic registers
 // or unregisters a reducer.  These calls have no side effects on visible
 // memory but can not be moved past other reducer and hyperobject calls
@@ -92,6 +84,22 @@ class NoCapture<AttrIndex idx> : IntrinsicProperty {
   int ArgNo = idx.Value;
 }
 
+// Injective - This intrinsic returns different values given different
+// arguments.
+class IntrInjective<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+  int Align = 1;
+}
+
+// HyperView - (Tapir) This intrinsic lowers to a runtime call to
+// find the address of the current view of a hyperobject.  It does not
+// return the address of anything in the current frame other than its
+// argument.
+class IntrHyperView<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+  int Align = 1;
+}
+
 // NoAlias - The specified argument pointer is not aliasing other "noalias" pointer
 // arguments of the intrinsic wrt. the intrinsic scope.
 class NoAlias<AttrIndex idx> : IntrinsicProperty {
@@ -1430,25 +1438,33 @@ def int_tapir_loop_grainsize
 // lowering transforms this intrinsic into ordinary frameaddress
 // intrinsics.
 def int_task_frameaddress
-    : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrWillReturn]>;
+    : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty],
+    [IntrWillReturn,IntrStrandPure]>;
+
+// Return the stack_frame in an OpenCilk function, otherwise null.
+def int_tapir_frame
+    : Intrinsic<[llvm_ptr_ty], [], [IntrWillReturn,IntrReadMem,IntrStrandPure]>;
 
 // Ideally the types would be [llvm_anyptr_ty], [LLVMMatchType<0>]
 // but that does not work, so rely on the front end to insert bitcasts.
 def int_hyper_lookup
     : Intrinsic<[llvm_ptr_ty],
-                [llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_ptr_ty], [
+                [llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty,
+                llvm_ptr_ty, llvm_ptr_ty], [
+                  NonNull<RetIndex>, NonNull<ArgIndex<1>>,
                   IntrWillReturn, IntrReadMem, IntrInaccessibleMemOnly,
-                  IntrStrandPure, IntrHyperView, IntrInjective
-                ]>;
+                  IntrStrandPure, IntrHyperView<ArgIndex<1>>,
+                  IntrInjective<ArgIndex<1>>]>; // Dereferenceable,
 
 // TODO: Change tablegen to allow function pointer types in intrinsics.
 def int_reducer_register
     : Intrinsic<[], [llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_ptr_ty],
-     [IntrWillReturn, IntrInaccessibleMemOnly, IntrReducerRegister]>;
+        [NonNull<ArgIndex<0>>, IntrWillReturn, IntrInaccessibleMemOnly,
+         IntrReducerRegister]>;
 
 def int_reducer_unregister
-    : Intrinsic<[], [llvm_ptr_ty], [IntrWillReturn, IntrInaccessibleMemOnly,
-     IntrReducerUnregister]>;
+    : Intrinsic<[], [llvm_ptr_ty], [NonNull<ArgIndex<0>>, IntrWillReturn,
+      IntrInaccessibleMemOnly, IntrReducerUnregister]>;
 
 ///===-------------------------- Other Intrinsics --------------------------===//
 //

llvm/include/llvm/Transforms/Tapir/LoweringUtils.h

@@ -245,6 +245,9 @@ class TapirTarget {
   /// Lower a Tapir sync instruction SI.
   virtual void lowerSync(SyncInst &SI) = 0;
 
+  virtual void lowerFrameCall(CallBase *Call, DominatorTree &DT) {
+  }
+
   virtual void lowerReducerOperation(CallBase *Call) {
   }