[clang/DIVar] Emit flag for params that have unchanged values

[djtodoro]

Summary

Emit debug info flag that indicates that a parameter has unchanged value through the course of a function.

This info will be used for emitting DW_OP_entry_value expressions for the parameter.

Authors: @asowda, @NikolaPrica, @djtodoro, @ivanbaev

[djtodoro]

• Rename: VariableNotChanged ===> ArgumentNotModified
• Refactor a test case

[probinson]

include/clang/AST/Decl.h

1482 ↗

(On Diff #186611)

There should be a comment here.
The style in this class appears to omit the 'get' word from the name of the getter, so isArgumentModified for the method name would look more consistent.

lib/Sema/SemaExpr.cpp

11282 ↗

(On Diff #186611)

Does this fit on one line if you use const auto *LHSDeclRef ...? Given you have the dyn_cast on the RHS there's no real need to give the type name twice.

[vsk]

+ rsmith, + bricci for review.

I was under the impression that space inside VarDecl was quite constrained. Pardon the likely naive question, but: is there any way to make the representation more compact (maybe sneak a bit into ParmVarDeclBitfields)?

[riccibruno]

If this bit is relevant to function parameters, why is getIsArgumentModified in VarDecl and not in ParamVarDecl ? What you can do is move the relevant methods to ParamVarDecl, and stash the bit in ParmVarDeclBitfields.

include/clang/AST/Decl.h

843 ↗

(On Diff #186611)

Yeah, please don't waste a whole pointer just to store a bit.

[riccibruno]

Oh and I think that you will also have to update the serialization code/de-serialization code in ASTReaderDecl.cpp / ASTWriterDecl.cpp. You might also have to update TreeTransform but I am less familiar with this.

[riccibruno]

I am wondering about the semantics of this bit. I don't think that you can know for sure within clang whether a variable has been modified. The best you can do is know for sure that some variable has been modified, but I don't think you can prove that it has not been modified.

Consequently I am wondering if you should change the name of this flag to something like IsArgumentKnownToBeModified.

Orthogonal to this you need to also add tests for templates.

[djtodoro]

I was under the impression that space inside VarDecl was quite constrained. Pardon the likely naive question, but: is there any way to make the representation more compact (maybe sneak a bit into ParmVarDeclBitfields)?

@vsk Thanks for the comment! Sure, it is better idea. Initially, we thought this could be used even for local variables, but since we are using it only for parameters it makes more sense.

lib/Sema/SemaExpr.cpp

11282 ↗

(On Diff #186611)

Does this fit on one line if you use const auto *LHSDeclRef ...? Given you have the dyn_cast on the RHS there's no real need to give the type name twice.

@probinson Thanks for the comment! Sure, it will be refactored.

[djtodoro]

@riccibruno Thanks for your comments!

Oh and I think that you will also have to update the serialization code/de-serialization code in ASTReaderDecl.cpp / ASTWriterDecl.cpp. You might also have to update TreeTransform but I am less familiar with this.

I've added ASTReaderDecl.cpp / ASTWriterDecl.cpp, but looking at TreeTransform I'm not sure if there is a place for adding something regarding this.

I am wondering about the semantics of this bit. I don't think that you can know for sure within clang whether a variable has been modified. The best you can do is know for sure that some variable has been modified, but I don't think you can prove that it has not been modified.

Consequently I am wondering if you should change the name of this flag to something like IsArgumentKnownToBeModified.

Orthogonal to this you need to also add tests for templates.

I agree! You are right, good idea!

[djtodoro]

• Add a field in ParmVarDecl instead of VarDecl
• Use a bit in ParmVarDeclBitfields to indicate parameter modification
• Add support for the bit in ASTReaderDecl.cpp / ASTWriterDecl.cpp
• Add test case for templates

[riccibruno]

lib/Sema/SemaExpr.cpp

11301 ↗

(On Diff #187931)

Comments:

1. Shouldn't you mark the variable to be modified only if CheckForModifiableLvalue returns true ?

2. I think that you need to handle way more than just member expressions. For example are you handling (x, y) (comma operator) ? But hard-coding every cases here is probably not ideal. It would be nice if there was already some code somewhere that could help you do this.

3. I believe that a MemberExpr has always a base. Similarly DeclRefExprs always have a referenced declaration (so you can omit the if).

[lebedev.ri]

lib/Sema/SemaExpr.cpp

11301 ↗

(On Diff #187931)

I'm not quite sure what this differential is about, but i feel like mentioning ExprMutationAnalyzer lib in clang-tidy / clang-tools-extra.

[riccibruno]

I'm not quite sure what this differential is about, but i feel like mentioning ExprMutationAnalyzer lib in clang-tidy / clang-tools-extra.

Alternatively perhaps you could re-use getMemoryLocation() from D57660. It would handle for you members, references, structured bindings +more in a relatively self-contained code.

[djtodoro]

I'm not quite sure what this differential is about, but i feel like mentioning ExprMutationAnalyzer lib in clang-tidy / clang-tools-extra.

Alternatively perhaps you could re-use getMemoryLocation() from D57660. It would handle for you members, references, structured bindings +more in a relatively self-contained code.

@lebedev.ri, @riccibruno Thanks for your advices! We'll check this also.

lib/Sema/SemaExpr.cpp

11301 ↗

(On Diff #187931)

@riccibruno Please find inlined replies:

1. Shouldn't you mark the variable to be modified only if CheckForModifiableLvalue returns true ?

Hmm, we should avoid marking variables modification if this emits an error. But, we should emit it if CheckForModifiableLvalue returns false, since in the case of returning true an error will be emitted.

2. I think that you need to handle way more than just member expressions. For example are you handling (x, y) (comma operator) ? But hard-coding every cases here is probably not ideal. It would be nice if there was already some code somewhere that could help you do this.

Hard coding all cases is not good idea. I agree. Since we are only looking for declaration references, we could make just a function that traverses any Expr and find declaration ref.

3. I believe that a MemberExpr has always a base. Similarly DeclRefExprs always have a referenced declaration (so you can omit the if).

I think you are right. Thanks!

[djtodoro]

• Handle all kinds of expressions when mark a param's modification

[riccibruno]

lib/Sema/SemaExpr.cpp

11292 ↗

(On Diff #188110)

Hmm, I don't think that this will work. Suppose that you have an expression like (a, b) += c You want to mark b as modified, but not a. What is needed I believe is:

Given an expression E find the variable that this expression designate if any, and if it is a function parameter mark it "known to be modified".

Visiting all of the children just looking for DeclRefExprs is a bit too blunt I believe.

11316 ↗

(On Diff #188110)

Hmm, we should avoid marking variables modification if this emits an error. But, we should emit it if CheckForModifiableLvalue returns false, since in the case of returning true an error will be emitted.

You are right, I believed for a moment that CheckForModifiableLvalue returned false on error.

[djtodoro]

lib/Sema/SemaExpr.cpp

11292 ↗

(On Diff #188110)

You are right. We thought it is possible implementing this with some basic analysis (with low overhead), but in order to support all cases it would take much time and it is not good idea.

I tried to use ExprMutationAnalyzer (that @lebedev.ri mentioned) and it seems to be useful for this. It seems that it can be used a little bit later than in this phase, because it takes ASTContext, but in this stage we have ASTContext finished up to node we are currently observing (an expression from which we are extracting DeclRef). But, even using it in the right time, it seems that ExprMutationAnalyzer does not have support for comma operator. I'm trying to extend this analyzer in order to add support for that. ASAP I will post new changes.
For the other cases I tried, it works.

[djtodoro]

-Rebase
-Use ExprMutationAnalyzer for parameter's modification check

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

4537 ↗

(On Diff #195192)

Just looking at the type declarations in CGDebugInfo.h: Why not iterate over the SPCache directly? Shouldn't that contain all Function declarations only?

4541 ↗

(On Diff #195192)

clang-format please

4546 ↗

(On Diff #195192)

Could this be a cast<>?

[djtodoro]

lib/CodeGen/CGDebugInfo.cpp

4537 ↗

(On Diff #195192)

I tried it, but SPCache is empty at this point.

[djtodoro]

-Run clang-format
-Use cast instead of 'dyn_cast'

[djtodoro]

-Rebase

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

3885 ↗

(On Diff #199214)

A dyn_cast followed by an unconditional use seems strange. I would expect either a cast or an if (PD) check.

[djtodoro]

lib/CodeGen/CGDebugInfo.cpp

3885 ↗

(On Diff #199214)

Yes, thanks for this!

[djtodoro]

-Careful use of dyn_cast
-Fill the ParamCache only in the case of EnableDebugEntryValues option

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

3885 ↗

(On Diff #199788)

We shouldn't query CGM.getLangOpts().Optimize. If we don't want this to happen at -O0, we shouldn't set EnableDebugEntryValues at a higher level (Driver, CompilerInvocation, ...) ..Otherwise inevitably someone will query one but not the other and things will go out of sync.

4535 ↗

(On Diff #199788)

Please add either a top-level comment about what this block is doing or perhaps factor this out into a descriptively named static function.

4537 ↗

(On Diff #195192)

Where is it emptied? Just grepping through CGDebugInfo did not make this obvious to me.

[djtodoro]

lib/CodeGen/CGDebugInfo.cpp

3885 ↗

(On Diff #199788)

I agree. Thanks!

4535 ↗

(On Diff #199788)

Sure.

4537 ↗

(On Diff #195192)

The SPCache actually gets filled only in the case of CXXMemberFunction.
In the other cases of SP production there is only filling of DeclCache.
Should we use it like this or ?

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

4537 ↗

(On Diff #195192)

If the number of entries in the DeclCache is much larger than the size of SPCache, we should keep them separate to speed up this loop. Otherwise we should join them to conserve memory.

[djtodoro]

-Use SPCache instead of DeclCache
-Refactor the code by addressing suggestions

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

4468 ↗

(On Diff #200486)

/// Analyzes each function parameter to determine whether it is constant throughout the function body.

4478 ↗

(On Diff #200486)

if (FuncAnalyzer.isMutated(Parm))
  continue;

4483 ↗

(On Diff #200486)

should the else be an assertion or are there legitimate failure cases?

[aprantl]

Couple more nitpicks, but otherwise good.

[djtodoro]

-Add SPDefCache to speed up the process
-Add additional assertions that will improve quality of the code

[djtodoro]

-Rebase
-Add a test

cfe/trunk/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLExtensionTypes.def"
 
   /// This is a storage for names that are constructed on demand. For
   /// example, C++ destructors, C++ operators etc..
   llvm::BumpPtrAllocator DebugInfoNames;
   StringRef CWDName;
 
   llvm::DenseMap<const char *, llvm::TrackingMDRef> DIFileCache;
   llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPCache;
+  /// Cache function definitions relevant to use for parameters mutation
+  /// analysis.
+  llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPDefCache;
+  llvm::DenseMap<const ParmVarDecl *, llvm::TrackingMDRef> ParamCache;
   /// Cache declarations relevant to DW_TAG_imported_declarations (C++
   /// using declarations) that aren't covered by other more specific caches.
   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> DeclCache;
   llvm::DenseMap<const NamespaceDecl *, llvm::TrackingMDRef> NamespaceCache;
   llvm::DenseMap<const NamespaceAliasDecl *, llvm::TrackingMDRef>
       NamespaceAliasCache;
   llvm::DenseMap<const Decl *, llvm::TypedTrackingMDRef<llvm::DIDerivedType>>
       StaticDataMemberCache;

cfe/trunk/lib/CodeGen/CGDebugInfo.cpp

 #include "CGDebugInfo.h"
 #include "CGBlocks.h"
 #include "CGCXXABI.h"
 #include "CGObjCRuntime.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "ConstantEmitter.h"
+#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/FileManager.h"
llvm::DISubprogram *SP = DBuilder.createFunction(
       SPFlagsForDef, TParamsArray.get(), getFunctionDeclaration(D));
   Fn->setSubprogram(SP);
   // We might get here with a VarDecl in the case we're generating
   // code for the initialization of globals. Do not record these decls
   // as they will overwrite the actual VarDecl Decl in the cache.
   if (HasDecl && isa<FunctionDecl>(D))
     DeclCache[D->getCanonicalDecl()].reset(SP);
 
+  // We use the SPDefCache only in the case when the debug entry values option
+  // is set, in order to speed up parameters modification analysis.
+  if (CGM.getCodeGenOpts().EnableDebugEntryValues && HasDecl &&
+      isa<FunctionDecl>(D))
+    SPDefCache[cast<FunctionDecl>(D)].reset(SP);
+
   if (CGM.getCodeGenOpts().DwarfVersion >= 5) {
     // Starting with DWARF V5 method declarations are emitted as children of
     // the interface type.
     if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
       const ObjCInterfaceDecl *ID = OMD->getClassInterface();
       QualType QTy(ID->getTypeForDecl(), 0);
       auto It = TypeCache.find(QTy.getAsOpaquePtr());
       if (It != TypeCache.end()) {
auto *D = ArgNo ? DBuilder.createParameterVariable(
                                                 CGM.getLangOpts().Optimize,
                                                 Flags, Align);
 
   // Insert an llvm.dbg.declare into the current block.
   DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
                          llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
                          Builder.GetInsertBlock());
 
+  if (CGM.getCodeGenOpts().EnableDebugEntryValues && ArgNo) {
+    if (auto *PD = dyn_cast<ParmVarDecl>(VD))
+      ParamCache[PD].reset(D);
+  }
+
   return D;
 }
 
 llvm::DILocalVariable *
 CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage,
                                        CGBuilderTy &Builder,
                                        const bool UsePointerValue) {
   assert(DebugKind >= codegenoptions::LimitedDebugInfo);
CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) {
   return NS;
 }
 
 void CGDebugInfo::setDwoId(uint64_t Signature) {
   assert(TheCU && "no main compile unit");
   TheCU->setDWOId(Signature);
 }
 
+/// Analyzes each function parameter to determine whether it is constant
+/// throughout the function body.
+static void analyzeParametersModification(
+    ASTContext &Ctx,
+    llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> &SPDefCache,
+    llvm::DenseMap<const ParmVarDecl *, llvm::TrackingMDRef> &ParamCache) {
+  for (auto &SP : SPDefCache) {
+    auto *FD = SP.first;
+    assert(FD->hasBody() && "Functions must have body here");
+    const Stmt *FuncBody = (*FD).getBody();
+    for (auto Parm : FD->parameters()) {
+      ExprMutationAnalyzer FuncAnalyzer(*FuncBody, Ctx);
+      if (FuncAnalyzer.isMutated(Parm))
+        continue;
+
+      auto I = ParamCache.find(Parm);
+      assert(I != ParamCache.end() && "Parameters should be already cached");
+      auto *DIParm = cast<llvm::DILocalVariable>(I->second);
+      DIParm->setIsNotModified();
+    }
+  }
+}
+
 void CGDebugInfo::finalize() {
   // Creating types might create further types - invalidating the current
   // element and the size(), so don't cache/reference them.
   for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
     ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
     llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
                            ? CreateTypeDefinition(E.Type, E.Unit)
                            : E.Decl;
void CGDebugInfo::finalize() {
   }
 
   // We keep our own list of retained types, because we need to look
   // up the final type in the type cache.
   for (auto &RT : RetainedTypes)
     if (auto MD = TypeCache[RT])
       DBuilder.retainType(cast<llvm::DIType>(MD));
 
+  if (CGM.getCodeGenOpts().EnableDebugEntryValues)
+    // This will be used to emit debug entry values.
+    analyzeParametersModification(CGM.getContext(), SPDefCache, ParamCache);
+
   DBuilder.finalize();
 }
 
 void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
   if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
     return;
 
   if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))

cfe/trunk/test/CodeGen/debug-info-param-modification.c

+// RUN: %clang -Xclang -femit-debug-entry-values -g -O2 -S -target x86_64-none-linux-gnu -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-ENTRY-VAL-OPT
+// CHECK-ENTRY-VAL-OPT: !DILocalVariable(name: "a", arg: 1, scope: {{.*}}, file: {{.*}}, line: {{.*}}, type: {{.*}})
+// CHECK-ENTRY-VAL-OPT: !DILocalVariable(name: "b", arg: 2, scope: {{.*}}, file: {{.*}}, line: {{.*}}, type: {{.*}}, flags: DIFlagArgumentNotModified)
+//
+// RUN: %clang -g -O2 -target x86_64-none-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
+// CHECK-NOT: !DILocalVariable(name: "b", arg: 2, scope: {{.*}}, file: {{.*}}, line: {{.*}}, type: {{.*}}, flags: DIFlagArgumentNotModified)
+//
+
+int fn2 (int a, int b) {
+  ++a;
+  return b;
+}