[PATCH] D54588: [llvm][IRBuilder] Introspection for CreateAlignmentAssumption*() functions

[Roman Lebedev via Phabricator via llvm-commits]

lebedev.ri updated this revision to Diff 174368.
lebedev.ri marked an inline comment as done.
lebedev.ri added a comment.

Document the `AlignmentAssumptionIntrospection` struct.


Repository:
  rL LLVM

https://reviews.llvm.org/D54588

Files:
  include/llvm/IR/IRBuilder.h


Index: include/llvm/IR/IRBuilder.h
===================================================================
--- include/llvm/IR/IRBuilder.h
+++ include/llvm/IR/IRBuilder.h
@@ -2123,14 +2123,25 @@
     return V;
   }
 
+  /// Used to propagate some additional information from the
+  /// `CreateAlignmentAssumptionHelper` to clang `CreateAlignmentAssumption()`,
+  /// in addition to the normally returned `CallInst *` that was built.
+  struct AlignmentAssumptionIntrospection {
+    /// On which value (after ptr2int conversion, and potentially subtraction
+    /// of the offset value) is the alignment check performed?
+    Value *PtrIntValue = nullptr;
+    /// The alignment check itself (`i1`), which is then used in the assumption.
+    Value *InvCond = nullptr;
+  };
+
 private:
   /// Helper function that creates an assume intrinsic call that
   /// represents an alignment assumption on the provided Ptr, Mask, Type
-  /// and Offset.
-  CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
-                                            Value *PtrValue, Value *Mask,
-                                            Type *IntPtrTy,
-                                            Value *OffsetValue) {
+  /// and Offset. It may be sometimes useful to do some other logic
+  /// based on this alignment check, thus it can be stored into 'Info'.
+  CallInst *CreateAlignmentAssumptionHelper(
+      const DataLayout &DL, Value *PtrValue, Value *Mask, Type *IntPtrTy,
+      Value *OffsetValue, AlignmentAssumptionIntrospection *Info = nullptr) {
     Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
 
     if (OffsetValue) {
@@ -2149,6 +2160,10 @@
     Value *Zero = ConstantInt::get(IntPtrTy, 0);
     Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
     Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
+    if (Info) {
+      Info->PtrIntValue = PtrIntValue;
+      Info->InvCond = InvCond;
+    }
     return CreateAssumption(InvCond);
   }
 
@@ -2159,17 +2174,21 @@
   /// An optional offset can be provided, and if it is provided, the offset
   /// must be subtracted from the provided pointer to get the pointer with the
   /// specified alignment.
-  CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
-                                      unsigned Alignment,
-                                      Value *OffsetValue = nullptr) {
+  ///
+  /// It may be sometimes useful to do some other logic
+  /// based on this alignment check, thus it can be stored into 'Info'.
+  CallInst *
+  CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
+                            unsigned Alignment, Value *OffsetValue = nullptr,
+                            AlignmentAssumptionIntrospection *Info = nullptr) {
     assert(isa<PointerType>(PtrValue->getType()) &&
            "trying to create an alignment assumption on a non-pointer?");
     auto *PtrTy = cast<PointerType>(PtrValue->getType());
     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
 
     Value *Mask = ConstantInt::get(IntPtrTy, Alignment > 0 ? Alignment - 1 : 0);
     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
-                                           OffsetValue);
+                                           OffsetValue, Info);
   }
 
   /// Create an assume intrinsic call that represents an alignment
@@ -2179,11 +2198,15 @@
   /// must be subtracted from the provided pointer to get the pointer with the
   /// specified alignment.
   ///
+  /// It may be sometimes useful to do some other logic
+  /// based on this alignment check, thus it can be stored into 'Info'.
+  ///
   /// This overload handles the condition where the Alignment is dependent
   /// on an existing value rather than a static value.
-  CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
-                                      Value *Alignment,
-                                      Value *OffsetValue = nullptr) {
+  CallInst *
+  CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
+                            Value *Alignment, Value *OffsetValue = nullptr,
+                            AlignmentAssumptionIntrospection *Info = nullptr) {
     assert(isa<PointerType>(PtrValue->getType()) &&
            "trying to create an alignment assumption on a non-pointer?");
     auto *PtrTy = cast<PointerType>(PtrValue->getType());
@@ -2201,7 +2224,7 @@
                                ConstantInt::get(IntPtrTy, 0), "mask");
 
     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
-                                           OffsetValue);
+                                           OffsetValue, Info);
   }
 };
 


-------------- next part --------------
A non-text attachment was scrubbed...
Name: D54588.174368.patch
Type: text/x-patch
Size: 4746 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20181116/60894e88/attachment.bin>