[MS] Change the metadata for heapallocsite calls when the function return type is cast.

[akhuang]

.

[rnk]

Nice, this is way less complicated than we thought originally.

clang/lib/CodeGen/CGExprScalar.cpp

572

Please revert unrelated whitespace changes.

2067

One thought I had here was, should this look through casts? I guess, what does MSVC do in wacky cases like this:

struct Foo; struct Bar;
Foo *p = (Foo*)(Bar*)malloc(42);

I tested locally, and MSVC emits the first cast as the allocated type, so I guess that's consistent with what you have. Let's add the double cast test case to be thorough, though.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1093 ↗

(On Diff #197651)

This change is unrelated, and also surprising to me, usually any symbol record wants to refer to the complete type index if it can.

[akhuang]

• Add test case for multiple casts
• Remove unrelated changes

[akhuang]

Reverted getCompleteTypeIndex change, to be fixed elsewhere

[rnk]

lgtm, with a minor tweak

clang/lib/CodeGen/CGExprScalar.cpp

2068

It's more idiomatic to say isa<ExplicitCastExpr>(CE) than to use dyn_cast and test for nullness. The casting API actually has reasonably good documentation on it if you're curious:
http://llvm.org/docs/ProgrammersManual.html#the-isa-cast-and-dyn-cast-templates

[akhuang]

Change dyn_cast to isa

[akhuang]

Committed in r359823

clang/lib/CodeGen/CGCall.cpp

#endif
 
   // Suppress tail calls if requested.
   if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(CI)) {
     if (TargetDecl && TargetDecl->hasAttr<NotTailCalledAttr>())
       Call->setTailCallKind(llvm::CallInst::TCK_NoTail);
   }
 
   // Add metadata for calls to MSAllocator functions
-  // FIXME: Get the type that the return value is cast to.
   if (getDebugInfo() && TargetDecl &&
       TargetDecl->hasAttr<MSAllocatorAttr>())
     getDebugInfo()->addHeapAllocSiteMetadata(CI, RetTy, Loc);
 
   // 4. Finish the call.
 
   // If the call doesn't return, finish the basic block and clear the
   // insertion point; this allows the rest of IRGen to discard

clang/lib/CodeGen/CGExprScalar.cpp

Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
     return CGF.getArrayInitIndex();
   }
 
   Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
     return EmitNullValue(E->getType());
   }
   Value *VisitExplicitCastExpr(ExplicitCastExpr *E) {
     CGF.CGM.EmitExplicitCastExprType(E, &CGF);
     return VisitCastExpr(E);
   }
   Value *VisitCastExpr(CastExpr *E);
 
   Value *VisitCallExpr(const CallExpr *E) {
     if (E->getCallReturnType(CGF.getContext())->isReferenceType())
       return EmitLoadOfLValue(E);
 
     Value *V = CGF.EmitCallExpr(E).getScalarVal();
if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
         // if the source could not be dynamic type and destination could be
         // dynamic because dynamic information is already laundered.  It is
         // because launder(strip(src)) == launder(src), so there is no need to
         // add extra strip before launder.
         Src = Builder.CreateStripInvariantGroup(Src);
       }
     }
 
+    // Update heapallocsite metadata when there is an explicit cast.
+    if (llvm::CallInst *CI = dyn_cast<llvm::CallInst>(Src))
+      if (CI->getMetadata("heapallocsite") && isa<ExplicitCastExpr>(CE))
+          CGF.getDebugInfo()->
+              addHeapAllocSiteMetadata(CI, CE->getType(), CE->getExprLoc());
+
     return Builder.CreateBitCast(Src, DstTy);
   }
   case CK_AddressSpaceConversion: {
     Expr::EvalResult Result;
     if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
         Result.Val.isNullPointer()) {
       // If E has side effect, it is emitted even if its final result is a
       // null pointer. In that case, a DCE pass should be able to

clang/test/CodeGen/debug-info-codeview-heapallocsite.c

 // RUN: %clang_cc1 -triple x86_64-windows-msvc -debug-info-kind=limited -gcodeview -fdeclspec -S -emit-llvm < %s | FileCheck %s
 
-struct Foo {
-  int x;
-};
+struct Foo;
+struct Bar;
 
 __declspec(allocator) void *alloc_void();
-__declspec(allocator) struct Foo *alloc_foo();
 
-void call_alloc_void() {
-  struct Foo *p = (struct Foo*)alloc_void();
+void call_alloc() {
+  struct Foo *p = alloc_void();
+  struct Foo *q = (struct Foo*)alloc_void();
+  struct Foo *r = (struct Foo*)(struct Bar*)alloc_void();
 }
 
-void call_alloc_foo() {
-  struct Foo *p = alloc_foo();
-}
-
-// CHECK-LABEL: define {{.*}}void @call_alloc_void
+// CHECK-LABEL: define {{.*}}void @call_alloc
 // CHECK: call i8* {{.*}}@alloc_void{{.*}} !heapallocsite [[DBG1:!.*]]
-
-// CHECK-LABEL: define {{.*}}void @call_alloc_foo
-// CHECK: call %struct.Foo* {{.*}}@alloc_foo{{.*}} !heapallocsite [[DBG2:!.*]]
+// CHECK: call i8* {{.*}}@alloc_void{{.*}} !heapallocsite [[DBG2:!.*]]
+// CHECK: call i8* {{.*}}@alloc_void{{.*}} !heapallocsite [[DBG3:!.*]]
 
 // CHECK: [[DBG1]] = !{}
-// CHECK: [[DBG2]] = distinct !DICompositeType(tag: DW_TAG_structure_type,
+// CHECK: [[DBG2]] = !DICompositeType(tag: DW_TAG_structure_type,
 // CHECK-SAME:                                 name: "Foo"
-
+// CHECK: [[DBG3]] = !DICompositeType(tag: DW_TAG_structure_type,
+// CHECK-SAME:                                 name: "Bar"