[CodeGen] Always use string computed in Sema for PredefinedExpr

[efriedma]

Summary

We can't use any other string, anyway, because its type wouldn't match the type of the PredefinedExpr.

With this change, we don't compute a "nice" name for the __func__ global when it's used in the initializer for a constant. This doesn't seem like a great loss, so I'm not sure it's worth fixing. We would either need to store more information in the AST, or somehow make constant evaluation keep track of the parent function of the PredefinedExpr.

This could change behavior in some situations involving BlockDecl. Currently, CodeGenFunction::EmitPredefinedLValue has some logic to intentionally emit a string different from what Sema computed. Specifically, it does two things: one, it appends numbers to the string if there are multiple block expressions in the function that use __func__, and two, it rewrites __func__ for blocks in the initializer for a global variable. This code skips that logic... but changing the string in CodeGen is fundamentally broken anyway. (For example, sizeof(__func__) returns the wrong result.) Hopefully this doesn't affect practical code.

Fixes https://bugs.llvm.org/show_bug.cgi?id=40313 .

[rjmccall]

I agree that this is the right thing to do. If we want to make those improvements, they're doable within Sema.

cfe/trunk/lib/CodeGen/CGExprConstant.cpp

 ConstantLValue
 ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) {
   auto C = CGM.getObjCRuntime().GenerateConstantString(E->getString());
   return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(E->getType()));
 }
 
 ConstantLValue
 ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) {
-  if (auto CGF = Emitter.CGF) {
-    LValue Res = CGF->EmitPredefinedLValue(E);
-    return cast<ConstantAddress>(Res.getAddress());
-  }
-
-  auto kind = E->getIdentKind();
-  if (kind == PredefinedExpr::PrettyFunction) {
-    return CGM.GetAddrOfConstantCString("top level", ".tmp");
-  }
-
-  return CGM.GetAddrOfConstantCString("", ".tmp");
+  return CGM.GetAddrOfConstantStringFromLiteral(E->getFunctionName());
 }
 
 ConstantLValue
 ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) {
   assert(Emitter.CGF && "Invalid address of label expression outside function");
   llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel());
   Ptr = llvm::ConstantExpr::getBitCast(Ptr,
                                    CGM.getTypes().ConvertType(E->getType()));

cfe/trunk/test/CodeGen/const-init.c

 struct g21 {int g21;};
 const struct g21 g21 = (struct g21){1};
 
 // PR5474
 struct g22 {int x;} __attribute((packed));
 struct g23 {char a; short b; char c; struct g22 d;};
 struct g23 g24 = {1,2,3,4};
 
-// CHECK: @g25.g26 = internal global i8* getelementptr inbounds ([4 x i8], [4 x i8]* @__func__.g25, i32 0, i32 0)
-// CHECK: @__func__.g25 = private unnamed_addr constant [4 x i8] c"g25\00"
+// CHECK: @g25.g26 = internal global i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[FUNC:.*]], i32 0, i32 0)
+// CHECK: @[[FUNC]] = private unnamed_addr constant [4 x i8] c"g25\00"
 int g25() {
   static const char *g26 = __func__;
   return *g26;
 }
 
 // CHECK: @g27.x = internal global i8* bitcast (i8** @g27.x to i8*), align 4
 void g27() { // PR8073
   static void *x = &x;

 // PR13643
 void g29() {
   typedef char DCC_PASSWD[2];
   typedef struct
   {
       DCC_PASSWD passwd;
   } DCC_SRVR_NM;
   // CHECK: @g29.a = internal global %struct.DCC_SRVR_NM { [2 x i8] c"@\00" }, align 1
-  // CHECK: @g29.b = internal global [1 x i32] [i32 ptrtoint ([5 x i8]* @.str to i32)], align 4
+  // CHECK: @g29.b = internal global [1 x i32] [i32 ptrtoint ([5 x i8]* @.str.1 to i32)], align 4
   // CHECK: @g29.c = internal global [1 x i32] [i32 97], align 4
   static DCC_SRVR_NM a = { {"@"} };
   static int b[1] = { "asdf" }; // expected-warning {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [5]'}}
   static int c[1] = { L"a" };
 }
 
 // PR21300
 void g30() {

cfe/trunk/test/CodeGenCXX/predefined-expr-cxx14.cpp

 // 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 [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"
 
+// CHECK-DAG: private unnamed_addr constant [32 x i8] c"const char *ConstexprPrettyFn()\00"
+
 int printf(const char * _Format, ...);
 
 class ClassInTopLevelNamespace {
 public:
   auto *topLevelNamespaceFunction() {
     printf("__func__ %s\n", __func__);
     printf("__FUNCTION__ %s\n", __FUNCTION__);
     printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);

 class FuncTemplate {
   const char *Func;
 
 public:
   FuncTemplate() : Func(__func__) {}
   const char *getFunc() const { return Func; }
 };
 
+constexpr const char* ConstexprPrettyFn() {
+  return __PRETTY_FUNCTION__;
+}
+const char* ConstexprPrettyVar = ConstexprPrettyFn();
+
 int
 main() {
   int a;
   ClassInTopLevelNamespace topLevelNamespace;
   ClassBlockConstr classBlockConstr;
   topLevelNamespace.topLevelNamespaceFunction();
   topLevelNamespace.variadicFunction(&a);
   topLevelNamespace.functionTemplate(a);