llvm.noalias - Clang CodeGen - check restrict variable map only for restrict-qualified lvalues

[hfinkel]

Summary

As part of D9403, John McCall asked to avoid making a DenseMap query per emitted store instruction. This can be done by restricting the query to stores to restrict-qualified LValues. I'm posting this as a separate enhancement patch to D9403 to avoid cluttering it.

[majnemer]

LGTM

lib/CodeGen/CodeGenFunction.h

2752

Multiple bool parameters aren't super great. Could we make it an enum and | the two properties as needed? If it's super painful, this could be done later.

[rjmccall]

lib/CodeGen/CodeGenFunction.h

2752

Alternatively, is there a reason that the qualifiers on Ty aren't sufficient for this? If we're passing down the access type anyway, I'm not sure why we need to be separately passing Volatile.

[hfinkel]

Rebased

[hfinkel]

Rebased.

[shafik]

@rjmccall is this still relevant or can we close it?

lib/CodeGen/CGDeclCXX.cpp

if (!T->isReferenceType()) {
     else
       EmitDeclDestroy(*this, D, DeclAddr);
     return;
   }
 
   assert(PerformInit && "cannot have constant initializer which needs "
          "destruction for reference");
   RValue RV = EmitReferenceBindingToExpr(Init);
-  EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T);
+  EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, false, T);
 }
 
 /// Create a stub function, suitable for being passed to atexit,
 /// which passes the given address to the given destructor function.
 llvm::Constant *CodeGenFunction::createAtExitStub(const VarDecl &VD,
                                                   llvm::Constant *dtor,
                                                   llvm::Constant *addr) {
   // Get the destructor function type, void(*)(void).

lib/CodeGen/CGExpr.cpp

assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) &&
            "wrong value rep of bool");
     return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
   }
 
   return Value;
 }
 
 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr,
-                                        bool Volatile, QualType Ty,
-                                        AlignmentSource AlignSource,
-                                        llvm::MDNode *TBAAInfo,
+                                        bool Volatile, bool Restrict,
+                                        QualType Ty, AlignmentSource
+                                        AlignSource, llvm::MDNode *TBAAInfo,
                                         bool isInit, QualType TBAABaseType,
                                         uint64_t TBAAOffset,
                                         bool isNontemporal) {
 
   // Handle vectors differently to get better performance.
   if (Ty->isVectorType()) {
     llvm::Type *SrcTy = Value->getType();
     auto *VecTy = cast<llvm::VectorType>(SrcTy);
if (Ty->isVectorType()) {
     }
   }
 
   Value = EmitToMemory(Value, Ty);
 
   // If this is an assignment to a restrict-qualified local variable, then we
   // have pointer aliasing assumptions that can be applied to the pointer value
   // being stored.
+  if (Restrict) {
     auto NAI = NoAliasAddrMap.find(Addr.getPointer());
     if (NAI != NoAliasAddrMap.end())
       Value = Builder.CreateNoAliasPointer(Value, NAI->second);
+  }
 
   LValue AtomicLValue =
       LValue::MakeAddr(Addr, Ty, getContext(), AlignSource, TBAAInfo);
   if (Ty->isAtomicType() ||
       (!isInit && LValueIsSuitableForInlineAtomic(AtomicLValue))) {
     EmitAtomicStore(RValue::get(Value), AtomicLValue, isInit);
     return;
   }
if (TBAAPath)
       CGM.DecorateInstructionWithTBAA(Store, TBAAPath,
                                       false /*ConvertTypeToTag*/);
   }
 }
 
 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
                                         bool isInit) {
   EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
-                    lvalue.getType(), lvalue.getAlignmentSource(),
-                    lvalue.getTBAAInfo(), isInit, lvalue.getTBAABaseType(),
-                    lvalue.getTBAAOffset(), lvalue.isNontemporal());
+                    lvalue.isRestrictQualified(), lvalue.getType(),
+                    lvalue.getAlignmentSource(), lvalue.getTBAAInfo(), isInit,
+                    lvalue.getTBAABaseType(), lvalue.getTBAAOffset(),
+                    lvalue.isNontemporal());
 }
 
 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
 /// method emits the address of the lvalue, then loads the result as an rvalue,
 /// returning the rvalue.
 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
   if (LV.isObjCWeak()) {
     // load of a __weak object.

lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::emitDoacrossOrdered(CodeGenFunction &CGF,
   QualType Int64Ty =
       CGM.getContext().getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
   const Expr *CounterVal = C->getCounterValue();
   assert(CounterVal);
   llvm::Value *CntVal = CGF.EmitScalarConversion(CGF.EmitScalarExpr(CounterVal),
                                                  CounterVal->getType(), Int64Ty,
                                                  CounterVal->getExprLoc());
   Address CntAddr = CGF.CreateMemTemp(Int64Ty, ".cnt.addr");
-  CGF.EmitStoreOfScalar(CntVal, CntAddr, /*Volatile=*/false, Int64Ty);
+  CGF.EmitStoreOfScalar(CntVal, CntAddr, /*Volatile=*/false, /*Restrict=*/false,
+                        Int64Ty);
   llvm::Value *Args[] = {emitUpdateLocation(CGF, C->getLocStart()),
                          getThreadID(CGF, C->getLocStart()),
                          CntAddr.getPointer()};
   llvm::Value *RTLFn;
   if (C->getDependencyKind() == OMPC_DEPEND_source)
     RTLFn = createRuntimeFunction(OMPRTL__kmpc_doacross_post);
   else {
     assert(C->getDependencyKind() == OMPC_DEPEND_sink);
     RTLFn = createRuntimeFunction(OMPRTL__kmpc_doacross_wait);
   }
   CGF.EmitRuntimeCall(RTLFn, Args);
 }
 

lib/CodeGen/CGStmtOpenMP.cpp

for (auto *FD : RD->fields()) {
     if (I->capturesVariableByCopy() && FD->getType()->isAnyPointerType()) {
       const VarDecl *CurVD = I->getCapturedVar();
       Address LocalAddr = GetAddrOfLocalVar(Args[Cnt]);
       // If the variable is a reference we need to materialize it here.
       if (CurVD->getType()->isReferenceType()) {
         Address RefAddr = CreateMemTemp(CurVD->getType(), getPointerAlign(),
                                         ".materialized_ref");
         EmitStoreOfScalar(LocalAddr.getPointer(), RefAddr, /*Volatile=*/false,
-                          CurVD->getType());
+                          /*Restrict=*/false, CurVD->getType());
         LocalAddr = RefAddr;
       }
       setAddrOfLocalVar(CurVD, LocalAddr);
       ++Cnt;
       ++I;
       continue;
     }
 

lib/CodeGen/CodeGenFunction.h

public:
   /// the LLVM value representation.  The l-value must be a simple
   /// l-value.
   llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc);
 
   /// EmitStoreOfScalar - Store a scalar value to an address, taking
   /// care to appropriately convert from the memory representation to
   /// the LLVM value representation.
   void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
-                         bool Volatile, QualType Ty,
+                         bool Volatile, bool Restrict, QualType Ty,
                          AlignmentSource AlignSource = AlignmentSource::Type,
                          llvm::MDNode *TBAAInfo = nullptr, bool isInit = false,
                          QualType TBAABaseTy = QualType(),
                          uint64_t TBAAOffset = 0, bool isNontemporal = false);
 
   /// EmitStoreOfScalar - Store a scalar value to an address, taking
   /// care to appropriately convert from the memory representation to
   /// the LLVM value representation.  The l-value must be a simple