Improve handling of __FUNCTION__ and other predefined expression for Objective-C Blocks

[mehdi_amini]

Summary

Instead of always displaying the mangled name, try to do better
and get something closer to regular functions.

[arphaman]

clang/lib/AST/Expr.cpp

538

I think it's possible to avoid the braces by simplifying down to something like this:

if (auto *DCFunc = dyn_cast<FunctionDecl>(DC))
  Out << ComputeName(IT, DCFunc) << "_block_invoke";
else
  // For nested blocks, propagate up to the parent.
  Out << ComputeName(IT, cast<BlockDecl>(DC));

clang/lib/CodeGen/CGExpr.cpp

2325

discriminator should be Discriminator

2327

!= 0 is redundant here

clang/test/CodeGen/block-with-perdefinedexpr.cpp

67

I think you should maybe add/change one of the tests to be a block inside of a lambda.

[mehdi_amini]

Address Alex's comment.

[mehdi_amini]

Fix warning for unused variable

[mehdi_amini]

Add a test inside a lambda

[arphaman]

LGTM, Thanks

[vitalybuka]

This is probably caused by this patch
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/649/steps/check-clang%20msan/logs/stdio

[mehdi_amini]

Already reverted

clang/lib/AST/Expr.cpp

if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
         if (!Buffer.empty() && Buffer.front() == '\01')
           return Buffer.substr(1);
         return Buffer.str();
       } else
         return ND->getIdentifier()->getName();
     }
     return "";
   }
-  if (auto *BD = dyn_cast<BlockDecl>(CurrentDecl)) {
-    std::unique_ptr<MangleContext> MC;
-    MC.reset(Context.createMangleContext());
-    SmallString<256> Buffer;
-    llvm::raw_svector_ostream Out(Buffer);
+  if (isa<BlockDecl>(CurrentDecl)) {
+    // For blocks we only emit something if it is enclosed in a function
+    // For top-level block we'd like to include the name of variable, but we
+    // don't have it at this point.
     auto DC = CurrentDecl->getDeclContext();
     if (DC->isFileContext())
-      MC->mangleGlobalBlock(BD, /*ID*/ nullptr, Out);
-    else if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
-      MC->mangleCtorBlock(CD, /*CT*/ Ctor_Complete, BD, Out);
-    else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
-      MC->mangleDtorBlock(DD, /*DT*/ Dtor_Complete, BD, Out);
+      return "";
+
+    SmallString<256> Buffer;
+    llvm::raw_svector_ostream Out(Buffer);
+    if (auto *DCFunc = dyn_cast<FunctionDecl>(DC))
+      Out << ComputeName(IT, DCFunc) << "_block_invoke";
     else
-      MC->mangleBlock(DC, BD, Out);
+      // For nested blocks, propagate up to the parent.
+      Out << ComputeName(IT, cast<BlockDecl>(DC));
     return Out.str();
   }
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
     if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual && IT != FuncSig)
       return FD->getNameAsString();
 
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
 
     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
       if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
   auto SL = E->getFunctionName();
   assert(SL != nullptr && "No StringLiteral name in PredefinedExpr");
   StringRef FnName = CurFn->getName();
   if (FnName.startswith("\01"))
     FnName = FnName.substr(1);
   StringRef NameItems[] = {
       PredefinedExpr::getIdentTypeName(E->getIdentType()), FnName};
   std::string GVName = llvm::join(NameItems, NameItems + 2, ".");
-  if (CurCodeDecl && isa<BlockDecl>(CurCodeDecl)) {
+  if (auto *BD = dyn_cast<BlockDecl>(CurCodeDecl)) {
+    std::string Name = SL->getString();
+    if (!Name.empty()) {
+      unsigned Discriminator =
+          CGM.getCXXABI().getMangleContext().getBlockId(BD, true);
+      if (Discriminator)
+        Name += "_" + Twine(Discriminator + 1).str();
+      auto C = CGM.GetAddrOfConstantCString(Name, GVName.c_str());
+      return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl);
+    } else {
       auto C = CGM.GetAddrOfConstantCString(FnName, GVName.c_str());
       return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl);
     }
+  }
   auto C = CGM.GetAddrOfConstantStringFromLiteral(SL, GVName);
   return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl);
 }
 
 /// Emit a type description suitable for use by a runtime sanitizer library. The
 /// format of a type descriptor is
 ///
 /// \code

clang/test/CodeGen/block-with-perdefinedexpr.cpp

+// RUN: %clang_cc1 %s -emit-llvm -o - -fblocks -triple x86_64-apple-darwin10 -std=c++11 | FileCheck %s
+
+void bar() {
+  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke = private unnamed_addr constant [17 x i8] c"bar_block_invoke\00", align 1
+  const char * (^block1)() = ^() {
+    return __FUNCTION__;
+  };
+  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke_2 = private unnamed_addr constant [19 x i8] c"bar_block_invoke_2\00", align 1
+  const char * (^block2)() = ^() {
+    return __FUNCTION__;
+  };
+}
+
+void baz() {
+  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke = private unnamed_addr constant [24 x i8] c"void baz()_block_invoke\00", align 1
+  const char * (^block1)() = ^() {
+    return __PRETTY_FUNCTION__;
+  };
+  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke_2 = private unnamed_addr constant [26 x i8] c"void baz()_block_invoke_2\00", align 1
+  const char * (^block2)() = ^() {
+    return __PRETTY_FUNCTION__;
+  };
+}
+
+namespace foonamespace {
+class Foo {
+public:
+  Foo() {
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke = private unnamed_addr constant [38 x i8] c"foonamespace::Foo::Foo()_block_invoke\00", align 1
+    const char * (^block1)() = ^() {
+      return __PRETTY_FUNCTION__;
+    };
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke_2 = private unnamed_addr constant [40 x i8] c"foonamespace::Foo::Foo()_block_invoke_2\00", align 1
+    const char * (^block2)() = ^() {
+      return __PRETTY_FUNCTION__;
+    };
+    // CHECK-DAG: @__func__.___ZN12foonamespace3FooC2Ev_block_invoke_3 = private unnamed_addr constant [19 x i8] c"Foo_block_invoke_3\00", align 1
+    const char * (^block3)() = ^() {
+      return __func__;
+    };
+    bar();
+    inside_lambda();
+  }
+  ~Foo() {
+    // CHECK-DAG: @__func__.___ZN12foonamespace3FooD2Ev_block_invoke = private unnamed_addr constant [18 x i8] c"~Foo_block_invoke\00", align 1
+    const char * (^block1)() = ^() {
+      return __func__;
+    };
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooD2Ev_block_invoke_2 = private unnamed_addr constant [41 x i8] c"foonamespace::Foo::~Foo()_block_invoke_2\00", align 1
+    const char * (^block2)() = ^() {
+      return __PRETTY_FUNCTION__;
+    };
+  }
+  void bar() {
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke = private unnamed_addr constant [43 x i8] c"void foonamespace::Foo::bar()_block_invoke\00", align 1
+    const char * (^block1)() = ^() {
+      return __PRETTY_FUNCTION__;
+    };
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke_2 = private unnamed_addr constant [45 x i8] c"void foonamespace::Foo::bar()_block_invoke_2\00", align 1
+    const char * (^block2)() = ^() {
+      return __PRETTY_FUNCTION__;
+    };
+    // CHECK-DAG: @__func__.___ZN12foonamespace3Foo3barEv_block_invoke_3 = private unnamed_addr constant [19 x i8] c"bar_block_invoke_3\00", align 1
+    const char * (^block3)() = ^() {
+      return __func__;
+    };
+  }
+  void inside_lambda() {
+  auto lambda = []() {
+      // CHECK-DAG: @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke = private unnamed_addr constant [92 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke\00", align 1
+      const char * (^block1)() = ^() {
+        return __PRETTY_FUNCTION__;
+      };
+      // CHECK-DAG:     @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_2 = private unnamed_addr constant [94 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke_2\00", align 1
+      const char * (^block2)() = ^() {
+        return __PRETTY_FUNCTION__;
+      };
+      // CHECK-DAG: @__func__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_3 = private unnamed_addr constant [26 x i8] c"operator()_block_invoke_3\00", align 1
+      const char * (^block3)() = ^() {
+        return __func__;
+      };
+  };
+      lambda();
+  }
+};
+Foo f;
+}

clang/test/CodeGenCXX/predefined-expr-cxx14.cpp

 // CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace16functionTemplateIiEERDaRT_ = private unnamed_addr constant [64 x i8] c"auto &ClassInTopLevelNamespace::functionTemplate(T &) [T = int]\00"
 
 // CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace16variadicFunctionEPiz = private unnamed_addr constant [17 x i8] c"variadicFunction\00"
 // CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace16variadicFunctionEPiz = private unnamed_addr constant [70 x i8] c"decltype(auto) ClassInTopLevelNamespace::variadicFunction(int *, ...)\00"
 
 // CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [26 x i8] c"topLevelNamespaceFunction\00"
 // CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [60 x i8] c"auto *ClassInTopLevelNamespace::topLevelNamespaceFunction()\00"
 
-// CHECK-DAG: @__func__.___ZN16ClassBlockConstrD2Ev_block_invoke = private unnamed_addr constant [41 x i8] c"___ZN16ClassBlockConstrD2Ev_block_invoke\00"
-// CHECK-DAG: @__func__.___ZN16ClassBlockConstrC2Ev_block_invoke = private unnamed_addr constant [41 x i8] c"___ZN16ClassBlockConstrC2Ev_block_invoke\00"
+// CHECK-DAG: @__func__.___ZN16ClassBlockConstrD2Ev_block_invoke = private unnamed_addr constant [31 x i8] c"~ClassBlockConstr_block_invoke\00"
+// CHECK-DAG: @__func__.___ZN16ClassBlockConstrC2Ev_block_invoke = private unnamed_addr constant [30 x i8] c"ClassBlockConstr_block_invoke\00"
 
 int printf(const char * _Format, ...);
 
 class ClassInTopLevelNamespace {
 public:
   auto *topLevelNamespaceFunction() {
     printf("__func__ %s\n", __func__);
     printf("__FUNCTION__ %s\n", __FUNCTION__);