[MachineMemOperand] learn about ptr_provenance

[jeroen.dobbelaere]

Summary

For the machine instructions, MachineMemOperand is the better place to track the ptr_provenance.

[jeroen.dobbelaere]

• Rebased

[jeroen.dobbelaere]

Rebase to 49cb4fef02e635bf304906232214166c7531d753

[Zoxc]

Given that the provenance gets dropped in https://reviews.llvm.org/D107356, how does it end up in machine operands?

[jeroen.dobbelaere]

In D107354#3494239, @Zoxc wrote:

Given that the provenance gets dropped in https://reviews.llvm.org/D107356, how does it end up in machine operands?

Good question. The provenance embedded in the MachineOperand here originates from the ptr_provenance operand in load/store instructions.
Your question does point out that https://reviews.llvm.org/D107356 (aka CodeGen/IntrinsicLowering) is too early if we want to track the more complex forms
of provenance after lowering.

[jeroen.dobbelaere]

In D107354#3495878, @jeroen.dobbelaere wrote:

In D107354#3494239, @Zoxc wrote:

Given that the provenance gets dropped in https://reviews.llvm.org/D107356, how does it end up in machine operands?

Good question. The provenance embedded in the MachineOperand here originates from the ptr_provenance operand in load/store instructions.
Your question does point out that https://reviews.llvm.org/D107356 (aka CodeGen/IntrinsicLowering) is too early if we want to track the more complex forms
of provenance after lowering.

Having looked deeper into it: IntrinsicLowering.cpp seems only to be used for the interpreter. There it makes sense to eliminate the noalias/ptr_provenance intrinsics.
During code generation, SelectionDAG is taking care of seeing through the intrinsics while lowering. But, the original llvm-IR (with intrinsics) stays available for the alias analysis. So the machine operands must be able to see it.
(Although you might need to enable AA analysis on machine ir)

[jeroen.dobbelaere]

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

[jeroen.dobbelaere]

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

[vzakhari]

LGTM. Can you please add a LIT test with a check that ptr_provenance is printed or is it useless?

[arsenm]

Needs some testing, especially MIR print and parse. Can you not simply look through the existing Value to find the provenance?

[jeroen.dobbelaere]

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

Added MIR parser support and testcase.

llvm/include/llvm/CodeGen/MachineMemOperand.h

 /// memory operands, relating them back to LLVM IR or to virtual locations (such
 /// as frame indices) that are exposed during codegen.
 struct MachinePointerInfo {
   /// This is the IR pointer value for the access, or it is null if unknown.
   /// If this is null, then the access is to a pointer in the default address
   /// space.
   PointerUnion<const Value *, const PseudoSourceValue *> V;
 
+  /// The provenance of the pointer. When ConstantPointerNull, the provenance
+  /// can be any object.
+  /// FIXME: nullptr here means : use V as provenance. This will change in
+  /// future.
+  const Value *PtrProvenance = nullptr;
+
   /// Offset - This is an offset from the base Value*.
   int64_t Offset;
 
   unsigned AddrSpace = 0;
 
   uint8_t StackID;
 
   explicit MachinePointerInfo(const Value *v, int64_t offset = 0,
-                              uint8_t ID = 0)
-      : V(v), Offset(offset), StackID(ID) {
+                              uint8_t ID = 0,
+                              const Value *ptrProvenance = nullptr)
+      : V(v), PtrProvenance(ptrProvenance), Offset(offset), StackID(ID) {
     AddrSpace = v ? v->getType()->getPointerAddressSpace() : 0;
   }
 
   explicit MachinePointerInfo(const PseudoSourceValue *v, int64_t offset = 0,
                               uint8_t ID = 0)
       : V(v), Offset(offset), StackID(ID) {
     AddrSpace = v ? v->getAddressSpace() : 0;
   }
 
-  explicit MachinePointerInfo(unsigned AddressSpace = 0, int64_t offset = 0)
-      : V((const Value *)nullptr), Offset(offset), AddrSpace(AddressSpace),
-        StackID(0) {}
+  explicit MachinePointerInfo(unsigned AddressSpace = 0, int64_t offset = 0,
+                              const Value *ptrProvenance = nullptr)
+      : V((const Value *)nullptr), PtrProvenance(ptrProvenance), Offset(offset),
+        AddrSpace(AddressSpace), StackID(0) {}
 
   explicit MachinePointerInfo(
       PointerUnion<const Value *, const PseudoSourceValue *> v,
-    int64_t offset = 0,
-    uint8_t ID = 0)
-    : V(v), Offset(offset), StackID(ID) {
+      int64_t offset = 0, uint8_t ID = 0, const Value *ptrProvenance = nullptr)
+      : V(v), PtrProvenance(ptrProvenance), Offset(offset), StackID(ID) {
     if (V) {
       if (const auto *ValPtr = V.dyn_cast<const Value*>())
         AddrSpace = ValPtr->getType()->getPointerAddressSpace();
       else
         AddrSpace = V.get<const PseudoSourceValue*>()->getAddressSpace();
     }
   }
 
public:
   const Value *getValue() const { return PtrInfo.V.dyn_cast<const Value*>(); }
 
   const PseudoSourceValue *getPseudoValue() const {
     return PtrInfo.V.dyn_cast<const PseudoSourceValue*>();
   }
 
   const void *getOpaqueValue() const { return PtrInfo.V.getOpaqueValue(); }
 
+  const Value *getPtrProvenance() const { return PtrInfo.PtrProvenance; }
+
   /// Return the raw flags of the source value, \see Flags.
   Flags getFlags() const { return FlagVals; }
 
   /// Bitwise OR the current flags with the given flags.
   void setFlags(Flags f) { FlagVals |= f; }
 
   /// For normal values, this is a byte offset added to the base address.
   /// For PseudoSourceValue::FPRel values, this is the FrameIndex number.

llvm/lib/CodeGen/MachineOperand.cpp

if (const Value *Val = getValue()) {
     }
   } else if (getOpaqueValue() == nullptr && getOffset() != 0) {
     OS << ((isLoad() && isStore()) ? " on "
            : isLoad()              ? " from "
                                    : " into ")
        << "unknown-address";
   }
   MachineOperand::printOperandOffset(OS, getOffset());
+  if (getPtrProvenance()) {
+    OS << ", ptr_provenance ";
+    MIRFormatter::printIRValue(OS, *getPtrProvenance(), MST);
+  }
   if (getSize() > 0 && getAlign() != getSize())
     OS << ", align " << getAlign().value();
   if (getAlign() != getBaseAlign())
     OS << ", basealign " << getBaseAlign().value();
   auto AAInfo = getAAInfo();
   if (AAInfo.TBAA) {
     OS << ", !tbaa ";
     AAInfo.TBAA->printAsOperand(OS, MST);