[Proof of concept] Clang lowering: Add 'writeonce' annotations on constant objects.

[lvoufo]

Summary

[No formal review needed at this time.]

[lvoufo]

Generalized generation of 'writeonce' annotations.

[lvoufo]

Bug Fix:

• the inliner and -gvn were removing or ignoring calls to constructors that were prematurely treated as readonly when their arguments were writeonce.
• As result, calls like call void @_Z3bar1A(i32 %agg.tmp.sroa.0.0.copyload) were eventually replaced with call void @_Z3bar1A(i32 undef).
• This is not the case anymore.

This patch uses the @llvm.invariant.start/end intrinsics to either

• mark that writeonce memory locations have been written into and thus can now be treated as readonly, or
• mark that it's okay to write into a writeonce memory location again.

The intrinsics are generated immediately after writing into a given address location, and, when applicable, at the end of a variable's lifetime.

[lvoufo]

Remove duplicate generation of invariant.start intrisic call for writeonce addresses.

[lvoufo]

Bug Fix: Global const object cases work again.

Solution: Teach BasicAA to not treat @llvm.invariant.start/end() intrinsic calls as potentially writing to memory.

[lvoufo]

Remove explicit 'writeonce' annotations; not worth the overhead of keeping them around (e.g. propagation through new AllocaInst's).

[lvoufo]

POC done (based on the sample programs in the design doc).

Moving towards initial patch submission for review:

• Fix unexpected failures in regression tests: 8
• generalize and add new test cases.

[chandlerc]

FYI, if this is something you'd like to start more active code review on, I
would recommend closing this particular entry on Phabricator and creating a
new one with llvm-commits subscribed from the start. Adding a mailing list
doesn't work well with Phabricator sadly. =/ It will also give a good
chance to update the description because I know you've made a lot of
progress based on the design review, etc.

[lvoufo]

Update diff with more visible context (-U999999).

[ * This was submitted in error -- Please ignore this diff *]

include/clang/AST/Type.h

     return QualType::isConstant(*this, Ctx);
   }
 
+  bool isWriteOnce(ASTContext &Ctx);
+
   /// \brief Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
   bool isPODType(ASTContext &Context) const;
 

lib/AST/Type.cpp

   }
 }
 
+bool QualType::isWriteOnce(ASTContext &Context) {
+
+  if (!Context.getLangOpts().CPlusPlus ||
+      !isConstant(Context) || getTypePtr()->isReferenceType())
+    return false;
+
+  if (const CXXRecordDecl *Record
+        = Context.getBaseElementType(*this)->getAsCXXRecordDecl())
+    return !Record->hasMutableFields();
+
+  return true;
+}
+
 bool QualType::isPODType(ASTContext &Context) const {
   // C++11 has a more relaxed definition of POD.
   if (Context.getLangOpts().CPlusPlus11)

lib/CodeGen/CGDecl.cpp

       CGF.EmitLifetimeEnd(Size, Addr);
     }
   };
+
+  /// A cleanup to call @llvm.invariant.end.
+  class CallInvariantEnd : public EHScopeStack::Cleanup {
+    llvm::CallInst *StartInst;
+    llvm::Value *Addr;
+    llvm::Value *Size;    // TODO: Is this even necessary?
+  public:
+    CallInvariantEnd(llvm::CallInst *C, llvm::Value *addr, llvm::Value *size)
+      : StartInst(C), Addr(addr), Size(size) {}
+
+    void Emit(CodeGenFunction &CGF, Flags flags) override {
+      CGF.EmitInvariantEnd(StartInst, Size, Addr);
+    }
+  };
 }
 
 /// EmitAutoVarWithLifetime - Does the setup required for an automatic

          canEmitInitWithFewStoresAfterMemset(Init, StoreBudget);
 }
 
+
+/// Emit the code necessary to initialize the given global variable.
+void CodeGenFunction::MarkWriteOnceWritten(const VarDecl& D,
+                                           llvm::Value *Addr) {
+  auto *GV = dyn_cast<llvm::GlobalVariable>(Addr);
+  auto *AI = dyn_cast<llvm::AllocaInst>(Addr);
+
+  // Only GlobalVariable's and AllocaInst's can be writeonce.
+  // Exit if the given address is none of these.
+  if (!GV && !AI) return;
+
+  // If the address is writeonce, then emit @llvm.invariant.start() intrinsic.
+  // Then, for non-global variables, push the emission of the
+  // @llvm.invariant.end() intrinsic onto the cleanup stack.
+  if ((GV && GV->isWriteOnce()) || (AI && AI->isWriteOnce())) {
+    CodeGenModule::InvariantArgs Args = EmitInvariantStart(D, Addr);
+
+    if (AI && Args.StartInst) {
+      assert(!GV && "Can't have it both ways.");
+      EHStack.pushCleanup<CallInvariantEnd>(NormalCleanup, Args.StartInst,
+                                            Args.Addr, Args.Size);
+    }
+  }
+}
+
 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
 /// variable declaration with auto, register, or no storage class specifier.
 /// These turn into simple stack objects, or GlobalValues depending on target.
 void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
   AutoVarEmission emission = EmitAutoVarAlloca(D);
   EmitAutoVarInit(emission);
+  MarkWriteOnceWritten(D, emission.Address);
   EmitAutoVarCleanups(emission);
 }
 

   C->setDoesNotThrow();
 }
 
+/// Emit code to cause the variable at the given address to be considered as
+/// constant from this point onwards.
+CodeGenModule::InvariantArgs
+CodeGenFunction::EmitInvariantStart(const VarDecl &D, llvm::Value *Addr) {
+  // Don't emit the intrinsic if we're not optimizing.
+  if (!CGM.getCodeGenOpts().OptimizationLevel)
+    return CodeGenModule::InvariantArgs{nullptr, 0, nullptr};
+
+  // Grab the llvm.invariant.start intrinsic.
+  llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
+  llvm::Constant *InvariantStart = CGM.getIntrinsic(InvStartID);
+
+  // Emit a call with the size in bytes of the object.
+  CharUnits WidthChars = getContext().getTypeSizeInChars(D.getType());
+  uint64_t Width = WidthChars.getQuantity();
+
+  llvm::Value *Size;
+  if (llvm::Constant* CAddr = dyn_cast<llvm::Constant>(Addr)) {
+    Size = llvm::ConstantInt::getSigned(Int64Ty, Width);
+    Addr = llvm::ConstantExpr::getBitCast(CAddr, Int8PtrTy);
+  }
+  else {
+    //Width = CGM.getDataLayout().getTypeAllocSize(LTy);
+    Size = llvm::ConstantInt::get(Int64Ty, Width);
+    Addr = Builder.CreateBitCast(Addr, Int8PtrTy);
+  }
+  llvm::CallInst *C = Builder.CreateCall(InvariantStart, {Size, Addr});
+  C->setDoesNotThrow();
+
+  return CodeGenModule::InvariantArgs{C, Size, Addr};
+}
+
+void CodeGenFunction::EmitInvariantEnd(llvm::CallInst *Start,
+                                       llvm::Value *Size, llvm::Value *Addr) {
+  // Grab the llvm.invariant.end intrinsic.
+  llvm::Intrinsic::ID InvEndID = llvm::Intrinsic::invariant_end;
+  llvm::Constant *InvariantEnd = CGM.getIntrinsic(InvEndID);
+
+  // Emit a call with the size in bytes of the object.
+  llvm::CallInst *C = Builder.CreateCall(InvariantEnd, {Start, Size, Addr});
+  C->setDoesNotThrow();
+}
+
 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
 /// local variable.  Does not emit initialization or destruction.
 CodeGenFunction::AutoVarEmission

           // to this variable. Set it to zero to indicate that NRVO was not
           // applied.
           llvm::Value *Zero = Builder.getFalse();
-          llvm::Value *NRVOFlag = CreateTempAlloca(Zero->getType(), "nrvo");
+          llvm::AllocaInst *NRVOFlag = CreateTempAlloca(Zero->getType(), "nrvo");
+          NRVOFlag->setWriteOnce(Ty.isWriteOnce(getContext()));
           EnsureInsertPoint();
           Builder.CreateStore(Zero, NRVOFlag);
 

 
       llvm::AllocaInst *Alloc = CreateTempAlloca(LTy);
       Alloc->setName(D.getName());
+      Alloc->setWriteOnce(Ty.isWriteOnce(getContext()));
 
       CharUnits allocaAlignment = alignment;
       if (isByRef)

 
     if (!DidCallStackSave) {
       // Save the stack.
-      llvm::Value *Stack = CreateTempAlloca(Int8PtrTy, "saved_stack");
+      llvm::AllocaInst *Stack = CreateTempAlloca(Int8PtrTy, "saved_stack");
+      Stack->setWriteOnce(Ty.isWriteOnce(getContext()));
 
       llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
       llvm::Value *V = Builder.CreateCall(F);

     // Allocate memory for the array.
     llvm::AllocaInst *vla = Builder.CreateAlloca(llvmTy, elementCount, "vla");
     vla->setAlignment(alignment.getQuantity());
+    vla->setWriteOnce(Ty.isWriteOnce(getContext()));
 
     DeclPtr = vla;
   }

         llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty),
                                                    D.getName() + ".addr");
         Alloc->setAlignment(getContext().getDeclAlign(&D).getQuantity());
+        Alloc->setWriteOnce(Ty.isWriteOnce(getContext()));
         LValue lv = MakeAddrLValue(Alloc, Ty, getContext().getDeclAlign(&D));
         EmitStoreOfScalar(Arg, lv, /* isInitialization */ true);
         LocalAddr = Builder.CreateLoad(Alloc);

     llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty),
                                                D.getName() + ".addr");
     Alloc->setAlignment(Align.getQuantity());
+    Alloc->setWriteOnce(Ty.isWriteOnce(getContext()));
     DeclPtr = Alloc;
     DoStore = true;
   }

lib/CodeGen/CGDeclCXX.cpp

   CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument);
 }
 
-/// Emit code to cause the variable at the given address to be considered as
-/// constant from this point onwards.
-static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
-                              llvm::Constant *Addr) {
-  // Don't emit the intrinsic if we're not optimizing.
-  if (!CGF.CGM.getCodeGenOpts().OptimizationLevel)
-    return;
-
-  // Grab the llvm.invariant.start intrinsic.
-  llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
-  llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID);
-
-  // Emit a call with the size in bytes of the object.
-  CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType());
-  uint64_t Width = WidthChars.getQuantity();
-  llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width),
-                           llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)};
-  CGF.Builder.CreateCall(InvariantStart, Args);
-}
-
 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
                                                llvm::Constant *DeclPtr,
                                                bool PerformInit) {

           PerformInit, this);
     if (PerformInit)
       EmitDeclInit(*this, D, DeclPtr);
-    if (CGM.isTypeConstant(D.getType(), true))
-      EmitDeclInvariant(*this, D, DeclPtr);
-    else
+    if (CGM.isTypeConstant(D.getType(), true)) {
+      (void) EmitInvariantStart(D, DeclPtr);
+    } else
       EmitDeclDestroy(*this, D, DeclPtr);
     return;
   }

   } else {
     EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
   }
+  MarkWriteOnceWritten(*D, Addr);
 
   FinishFunction();
 }

lib/CodeGen/CGExprAgg.cpp

 
   // Optimize the slot if possible.
   CheckAggExprForMemSetUse(Slot, E, *this);
- 
   AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
 }
 

lib/CodeGen/CodeGenFunction.h

 
   llvm::Value *EmitLifetimeStart(uint64_t Size, llvm::Value *Addr);
   void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
+  void EmitInvariantEnd(llvm::CallInst *C,
+                        llvm::Value *Size, llvm::Value *Addr);
 
   llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
   void EmitCXXDeleteExpr(const CXXDeleteExpr *E);

   AddInitializerToStaticVarDecl(const VarDecl &D,
                                 llvm::GlobalVariable *GV);
 
+  void MarkWriteOnceWritten(const VarDecl& D, llvm::Value *Addr);
+  CodeGenModule::InvariantArgs EmitInvariantStart(const VarDecl &D,
+                                                  llvm::Value *Addr);
 
   /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
   /// variable with global storage.

lib/CodeGen/CodeGenModule.h

 
   typedef std::vector<Structor> CtorList;
 
+  struct InvariantArgs {
+    llvm::CallInst *StartInst;
+    llvm::Value *Size;
+    llvm::Value *Addr;
+    InvariantArgs(llvm::CallInst *C, llvm::Value *size, llvm::Value *addr)
+    : StartInst(C), Size(size), Addr(addr) {}
+  };
+
 private:
   ASTContext &Context;
   const LangOptions &LangOpts;

lib/CodeGen/CodeGenModule.cpp

     // common vars aren't constant even if declared const.
     GV->setConstant(false);
 
+  // Mark const variables 'writeonce', if global is not 'constant'.
+  GV->setWriteOnce(!GV->isConstant() && D->getType().isWriteOnce(Context));
+
   setNonAliasAttributes(D, GV);
 
   if (D->getTLSKind() && !GV->isThreadLocal()) {