Fix for bug 17427 - Assertion failed: "Computed __func__ length differs from type!"

[ABataev]

Summary

Reworked PredefinedExpr representation with internal StringLiteral field for function declaration.

[rsmith]

lib/AST/Expr.cpp

633–634

This existing code is already trying to handle this situation. Did your tests fail without your change? If so, why?

(The existing code is wrong for decltype(auto), auto*, and so on, but that is not the case your tests seem to be covering.)

[rnk]

Coincidentally, I looked at this code the other day. IMO running the mangler twice for FUNCDNAME is silly. Is there a problem with computing the string in Sema and storing it on the PredefinedExpr? It looks like we always have to do this just to build the type.

[rsmith]

lib/AST/Expr.cpp

532

The best fix (for the immediate issue) would probably be to use the declared type rather than the actual type: use Decl->getTypeSourceInfo()->getType() rather than Decl->getType() here.

As Reid points out, we may want to just stash the string into the PredefinedExpr object when we create it, rather than recomputing it each time.

634–635

Remove the existing (broken) handling for this case.

test/CodeGenCXX/predefined-expr-cxx14.cpp

4–5

This test does not seem quite right:

1. Testing all the different kinds of function declarations here is gaining you zero test coverage. The thing that's relevant here is how we handle the return type, and that does not change between these cases.
2. You're missing test coverage for the cases you fixed: decltype(auto) as a return type, and types that contain auto (but are not *exactly* auto).

[ABataev]

Richard, yes, it fails on lines 79, 76, 88

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

16.09.2014 21:07, Richard Smith пишет:

Comment at: lib/AST/Expr.cpp:604
@@ -603,2 +603,3 @@
+ Policy.KeepAutoType = true;

if ((isa<CXXMethodDecl>(FD) &&
     cast<CXXMethodDecl>(FD)->getParent()->isLambda()) ||

---

This existing code is already trying to handle this situation. Did your tests fail without your change? If so, why?

(The existing code is wrong for decltype(auto), auto*, and so on, but that is not the case your tests seem to be covering.)

http://reviews.llvm.org/D5365

[ABataev]

Reid, I though about it too. I also think it is a better solution. I'll
rework the patch.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

16.09.2014 22:03, Reid Kleckner пишет:

Coincidentally, I looked at this code the other day. IMO running the mangler twice for FUNCDNAME is silly. Is there a problem with computing the string in Sema and storing it on the PredefinedExpr? It looks like we always have to do this just to build the type.

http://reviews.llvm.org/D5365

[ABataev]

Comment at: lib/AST/Expr.cpp:501
@@ -500,3 +500,3 @@

  Decl = Pattern;
const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
const FunctionProtoType *FT = nullptr;

---

The best fix (for the immediate issue) would probably be to use the declared type rather than the actual type: use Decl->getTypeSourceInfo()->getType() rather than Decl->getType() here.

As Reid points out, we may want to just stash the string into the PredefinedExpr object when we create it, rather than recomputing it each time.

Richard, I'll rework the patch and store string in PredefinedExpr.

Comment at: test/CodeGenCXX/predefined-expr-cxx14.cpp:3-4
@@ +2,4 @@
+
+ CHECK-DAG: private unnamed_addr constant [15 x i8] c"externFunction\00"
+ CHECK-DAG: private unnamed_addr constant [26 x i8] c"auto NS::externFunction()\00"

+// CHECK-DAG: private unnamed_addr constant [49 x i8] c"auto functionTemplateExplicitSpecialization(int)\00"

This test does not seem quite right:

1. Testing all the different kinds of function declarations here is gaining you zero test coverage. The thing that's relevant here is how we handle the return type, and that does not change between these cases.
2. You're missing test coverage for the cases you fixed: decltype(auto) as a return type, and types that contain auto (but are not *exactly* auto).

http://reviews.llvm.org/D5365

The test is too big, but it has test cases for , I'll reduce it.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

16.09.2014 22:48, Richard Smith пишет:

Comment at: lib/AST/Expr.cpp:501
@@ -500,3 +500,3 @@

  Decl = Pattern;
const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
const FunctionProtoType *FT = nullptr;

---

The best fix (for the immediate issue) would probably be to use the declared type rather than the actual type: use Decl->getTypeSourceInfo()->getType() rather than Decl->getType() here.

As Reid points out, we may want to just stash the string into the PredefinedExpr object when we create it, rather than recomputing it each time.

Comment at: lib/AST/Expr.cpp:606
@@ -604,3 +605,3 @@

   cast<CXXMethodDecl>(FD)->getParent()->isLambda()) ||
  (FT && FT->getReturnType()->getAs<AutoType>()))
Proto = "auto " + Proto;

---

Remove the existing (broken) handling for this case.

Comment at: test/CodeGenCXX/predefined-expr-cxx14.cpp:3-4
@@ +2,4 @@
+
+ CHECK-DAG: private unnamed_addr constant [15 x i8] c"externFunction\00"
+ CHECK-DAG: private unnamed_addr constant [26 x i8] c"auto NS::externFunction()\00"

+// CHECK-DAG: private unnamed_addr constant [49 x i8] c"auto functionTemplateExplicitSpecialization(int)\00"

This test does not seem quite right:

1. Testing all the different kinds of function declarations here is gaining you zero test coverage. The thing that's relevant here is how we handle the return type, and that does not change between these cases.
2. You're missing test coverage for the cases you fixed: decltype(auto) as a return type, and types that contain auto (but are not *exactly* auto).

http://reviews.llvm.org/D5365

[rsmith]

include/clang/AST/Expr.h

1164

Please don't move this class to a different place in the file (and likewise in Expr.cpp); it creates history churn and makes the patch hard to review. Instead, you can move the getStringLiteral method definitions out of the class (either to after the definition of StringLiteral or into the .cpp file).

1637

I don't think you need to pass in T here; it can be obtained from the StringLiteral.

1658

Generally, we prefer to make the ASTReader a friend of the class being deserialized rather than adding setters. Please do that here (you should also be able to remove the other setters in the process).

lib/AST/ExprConstant.cpp

2654

C++ guarantees that __func__ has the same address for all evaluations within the same function. It looks like this patch will make them all be treated as distinct objects.

lib/AST/StmtProfile.cpp

472 ↗

(On Diff #13780)

This doesn't seem necessary.

lib/CodeGen/CGExpr.cpp

2058

I think we need to emit this with a specific mangled name in order to merge the func objects across translation units if it's used in an inline function.

lib/Sema/TreeTransform.h

6976–6980

This is wrong: unless this is overridden by the derived class, it would just call itself. Instead you should add a RebuildPredefinedExpr function, call it from here, and make it call into Sema to rebuild the PredefinedExpr.

test/CodeGenCXX/funcsig.cpp

11

If this is supposed to be linkonce_odr, you should also check its mangled name.

[rsmith]

FYI: I'm investigating how to deal with the constraint that __func__ is the same object throughout a function; it's not supported by current ABIs, and it's not even clear that it's supportable without *extreme* heroics. On that basis, I think it's fine to continue treating __func__ like a string literal for now (that is, two different __func__s can evaluate to different arrays).

[ABataev]

Richard, thanks for the review!

include/clang/AST/Expr.h

1164

Ok

1637

Yes, I thought about it too. But decided to make the constructor similar to all others.

1658

Agree, thanks.

lib/AST/StmtProfile.cpp

472 ↗

(On Diff #13780)

Ok

lib/CodeGen/CGExpr.cpp

2058

Agree, I'll try to improve it.

lib/Sema/TreeTransform.h

6976–6980

Ok, I'll fix it

test/CodeGenCXX/funcsig.cpp

11

Ok

[ABataev]

Reworked representation of PredefinedExpr after review.

[rsmith]

include/clang/AST/Expr.h

1184–1185

You can delete these and directly set the members from ASTStmtReader.

lib/AST/Expr.cpp

468

You need an llvm_unreachable here to shut up GCC's -Wreturn-type.

lib/Sema/SemaExpr.cpp

2969–2973

Please remove the static local variable for now; we're discussing this on the standard reflectors and the requirement for this may soon be removed. The above doesn't completely fix the ABI problem anyway (if two compilers did this and came up with different strings, they could give __func__ different types). Sorry for the change in direction here.

[ABataev]

Richard, thanks for the review!

include/clang/AST/Expr.h

1184–1185

Ok

lib/AST/Expr.cpp

468

Ok, I'll break in case for PrettyFunctionNoVirtual and llvm_unreachable at the end of the method.

lib/Sema/SemaExpr.cpp

2969–2973

Ok, I'll return back to StringLiteral then.

[ABataev]

Ping!

[rnk]

Thanks for the cleanup! Looks good with a fix for the func-inside-block-inside-ctor test case.

lib/AST/Expr.cpp

508

I believe this will assert in this code:

struct A {
  const char *s;
  A() {
    const char *(^b)() = ^() {
      return __func__;
    };
    s = b();
};
A a;

You probably need to handle the ctor / dtor cases separately, as is done in CodeGenModule::getBlockMangledName. Using Ctor_Base and Dtor_Base should be correct. I don't think we should ever emit two different block implementations for the base ctor and complete ctor. =/

lib/CodeGen/CGExpr.cpp

2061

I think this can be an array of StringRefs to avoid building two tmp strings.

lib/CodeGen/CodeGenModule.cpp

2751–2752 ↗

(On Diff #14221)

This change will cause duplicate string literals to not be merged across TUs on Windows. Just mangle the string literal if the ABI says we should.

test/CodeGenCXX/ms_wide_predefined_expr.cpp

3

This test in particular should not change.

[ABataev]

Hi Reid, Thanks for the review!

lib/AST/Expr.cpp

508

I'll add this test and fix the code to properly handle it.

lib/CodeGen/CGExpr.cpp

2061

Agree

lib/CodeGen/CodeGenModule.cpp

2751–2752 ↗

(On Diff #14221)

Agree, I'll remove it

test/CodeGenCXX/ms_wide_predefined_expr.cpp

3

Agree, will revert it back

[ABataev]

Closed by commit rL219393 (authored by @ABataev).

include/clang/AST/Expr.h

public:
 
   // Iterators
   child_range children() { return child_range(); }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
 
-/// PredefinedExpr - [C99 6.4.2.2] - A predefined identifier such as __func__.
+/// \brief [C99 6.4.2.2] - A predefined identifier such as __func__.
 class PredefinedExpr : public Expr {
 public:
   enum IdentType {
     Func,
     Function,
     LFunction,  // Same as Function, but as wide string.
     FuncDName,
     FuncSig,
     PrettyFunction,
-    /// PrettyFunctionNoVirtual - The same as PrettyFunction, except that the
+    /// \brief The same as PrettyFunction, except that the
     /// 'virtual' keyword is omitted for virtual member functions.
     PrettyFunctionNoVirtual
   };
 
 private:
   SourceLocation Loc;
   IdentType Type;
+  VarDecl *FNRef;
+
+  void setIdentType(IdentType IT) { Type = IT; }
+  void setFunctionNameRef(VarDecl *D) { FNRef = D; };
+
 public:
-  PredefinedExpr(SourceLocation l, QualType type, IdentType IT)
-    : Expr(PredefinedExprClass, type, VK_LValue, OK_Ordinary,
-           type->isDependentType(), type->isDependentType(),
-           type->isInstantiationDependentType(),
+  PredefinedExpr(SourceLocation L, QualType FNTy, IdentType IT,
+                 VarDecl *FNRef = nullptr)
+      : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary,
+             FNTy->isDependentType(), FNTy->isDependentType(),
+             FNTy->isInstantiationDependentType(),
              /*ContainsUnexpandedParameterPack=*/false),
-      Loc(l), Type(IT) {}
+        Loc(L), Type(IT), FNRef(FNRef) {}
 
   /// \brief Construct an empty predefined expression.
   explicit PredefinedExpr(EmptyShell Empty)
-    : Expr(PredefinedExprClass, Empty) { }
+      : Expr(PredefinedExprClass, Empty), Loc(), Type(Func), FNRef(nullptr) {}
 
   IdentType getIdentType() const { return Type; }
-  void setIdentType(IdentType IT) { Type = IT; }
 
   SourceLocation getLocation() const { return Loc; }
   void setLocation(SourceLocation L) { Loc = L; }
 
+  const VarDecl *getFunctionNameRef() const { return FNRef; }
+  VarDecl *getFunctionNameRef() { return FNRef; }
+
+  static StringRef getIdentTypeName(IdentType IT);
   static std::string ComputeName(IdentType IT, const Decl *CurrentDecl);
 
   SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
   SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == PredefinedExprClass;
   }
 
   // Iterators
   child_range children() { return child_range(); }
+
+  friend class ASTStmtReader;
 };
 
 /// \brief Used by IntegerLiteral/FloatingLiteral to store the numeric without
 /// leaking memory.
 ///
 /// For large floats/integers, APFloat/APInt will allocate memory from the heap
 /// to represent these numbers.  Unfortunately, when we use a BumpPtrAllocator
 /// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
: Expr(ParenExprClass, val->getType(),
       L(l), R(r), Val(val) {}
 
   /// \brief Construct an empty parenthesized expression.
   explicit ParenExpr(EmptyShell Empty)
     : Expr(ParenExprClass, Empty) { }
 
   const Expr *getSubExpr() const { return cast<Expr>(Val); }
   Expr *getSubExpr() { return cast<Expr>(Val); }
   void setSubExpr(Expr *E) { Val = E; }
 
   SourceLocation getLocStart() const LLVM_READONLY { return L; }
   SourceLocation getLocEnd() const LLVM_READONLY { return R; }
 
   /// \brief Get the location of the left parentheses '('.
   SourceLocation getLParen() const { return L; }
   void setLParen(SourceLocation Loc) { L = Loc; }
 
   /// \brief Get the location of the right parentheses ')'.
   SourceLocation getRParen() const { return R; }
   void setRParen(SourceLocation Loc) { R = Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ParenExprClass;
   }
 
   // Iterators
   child_range children() { return child_range(&Val, &Val+1); }
 };
 
 
 /// UnaryOperator - This represents the unary-expression's (except sizeof and
 /// alignof), the postinc/postdec operators from postfix-expression, and various
 /// extensions.
 ///
 /// Notes on various nodes:
 ///
 /// Real/Imag - These return the real/imag part of a complex operand.  If
 ///   applied to a non-complex value, the former returns its operand and the

include/clang/Sema/Sema.h

ExprResult BuildDeclarationNameExpr(
       const TemplateArgumentListInfo *TemplateArgs = nullptr);
 
   ExprResult BuildLiteralOperatorCall(LookupResult &R,
                       DeclarationNameInfo &SuffixInfo,
                       ArrayRef<Expr *> Args,
                       SourceLocation LitEndLoc,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
 
-  ExprResult BuildPredefinedExpr(SourceLocation Loc,
+  ExprResult BuildPredefinedExpr(Scope *S, SourceLocation Loc,
                                  PredefinedExpr::IdentType IT);
-  ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
+  ExprResult ActOnPredefinedExpr(Scope *S, SourceLocation Loc,
+                                 tok::TokenKind Kind);
   ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
   ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
   ExprResult ActOnCharacterConstant(const Token &Tok,
                                     Scope *UDLScope = nullptr);
   ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
   ExprResult ActOnParenListExpr(SourceLocation L,
                                 SourceLocation R,
                                 MultiExprArg Val);

lib/AST/ASTDumper.cpp

void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
   OS << "='" << *Node->getDecl() << "'";
   dumpPointer(Node->getDecl());
   if (Node->isFreeIvar())
     OS << " isFreeIvar";
 }
 
 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
   VisitExpr(Node);
-  switch (Node->getIdentType()) {
-  default: llvm_unreachable("unknown case");
-  case PredefinedExpr::Func:           OS <<  " __func__"; break;
-  case PredefinedExpr::Function:       OS <<  " __FUNCTION__"; break;
-  case PredefinedExpr::FuncDName:      OS <<  " __FUNCDNAME__"; break;
-  case PredefinedExpr::LFunction:      OS <<  " L__FUNCTION__"; break;
-  case PredefinedExpr::PrettyFunction: OS <<  " __PRETTY_FUNCTION__";break;
-  case PredefinedExpr::FuncSig:        OS <<  " __FUNCSIG__"; break;
-  }
+  OS << " " << PredefinedExpr::getIdentTypeName(Node->getIdentType());
 }
 
 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
   VisitExpr(Node);
   ColorScope Color(*this, ValueColor);
   OS << " " << Node->getValue();
 }
 

lib/AST/Expr.cpp

SourceLocation DeclRefExpr::getLocStart() const {
   return getNameInfo().getLocStart();
 }
 SourceLocation DeclRefExpr::getLocEnd() const {
   if (hasExplicitTemplateArgs())
     return getRAngleLoc();
   return getNameInfo().getLocEnd();
 }
 
+StringRef PredefinedExpr::getIdentTypeName(PredefinedExpr::IdentType IT) {
+  switch (IT) {
+  case Func:
+    return "__func__";
+  case Function:
+    return "__FUNCTION__";
+  case FuncDName:
+    return "__FUNCDNAME__";
+  case LFunction:
+    return "L__FUNCTION__";
+  case PrettyFunction:
+    return "__PRETTY_FUNCTION__";
+  case FuncSig:
+    return "__FUNCSIG__";
+  case PrettyFunctionNoVirtual:
+    llvm_unreachable("unknown case");
+  }
+}
+
 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
 // expr" policy instead.
 std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
   ASTContext &Context = CurrentDecl->getASTContext();
 
   if (IT == PredefinedExpr::FuncDName) {
     if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
       std::unique_ptr<MangleContext> MC;
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);
+    auto DC = CurrentDecl->getDeclContext();
+    if (DC->isFileContext())
+      MC->mangleGlobalBlock(BD, /*ID*/ nullptr, Out);
+    else
+      MC->mangleBlock(DC, BD, Out);
+    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)
         Out << "virtual ";
       if (MD->isStatic())
         Out << "static ";
     }
 
     PrintingPolicy Policy(Context.getLangOpts());
     std::string Proto;
     llvm::raw_string_ostream POut(Proto);
 
     const FunctionDecl *Decl = FD;
     if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
       Decl = Pattern;
     const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
     const FunctionProtoType *FT = nullptr;
     if (FD->hasWrittenPrototype())
       FT = dyn_cast<FunctionProtoType>(AFT);
 
     if (IT == FuncSig) {
       switch (FT->getCallConv()) {
       case CC_C: POut << "__cdecl "; break;
       case CC_X86StdCall: POut << "__stdcall "; break;
if (!TemplateParams.empty()) {
       POut << " [" << TemplateParams << "]";
     }
 
     POut.flush();
 
     // Print "auto" for all deduced return types. This includes C++1y return
     // type deduction and lambdas. For trailing return types resolve the
     // decltype expression. Otherwise print the real type when this is
     // not a constructor or destructor.
-    if ((isa<CXXMethodDecl>(FD) &&
-         cast<CXXMethodDecl>(FD)->getParent()->isLambda()) ||
-        (FT && FT->getReturnType()->getAs<AutoType>()))
+    if (isa<CXXMethodDecl>(FD) &&
+         cast<CXXMethodDecl>(FD)->getParent()->isLambda())
       Proto = "auto " + Proto;
     else if (FT && FT->getReturnType()->getAs<DecltypeType>())
       FT->getReturnType()
           ->getAs<DecltypeType>()
           ->getUnderlyingType()
           .getAsStringInternal(Proto, Policy);
     else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
       AFT->getReturnType().getAsStringInternal(Proto, Policy);

lib/AST/ExprConstant.cpp

static unsigned getBaseIndex(const CXXRecordDecl *Derived,
   }
 
   llvm_unreachable("base class missing from derived class's bases list");
 }
 
 /// Extract the value of a character from a string literal.
 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
                                             uint64_t Index) {
-  // FIXME: Support PredefinedExpr, ObjCEncodeExpr, MakeStringConstant
+  // FIXME: Support ObjCEncodeExpr, MakeStringConstant
+  if (auto PE = dyn_cast<PredefinedExpr>(Lit))
+    Lit = PE->getFunctionNameRef()->getInit()->IgnoreImpCasts();
   const StringLiteral *S = cast<StringLiteral>(Lit);
   const ConstantArrayType *CAT =
       Info.Ctx.getAsConstantArrayType(S->getType());
   assert(CAT && "string literal isn't an array");
   QualType CharType = CAT->getElementType();
   assert(CharType->isIntegerType() && "unexpected character type");
 
   APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
         Info.Diag(Conv);
         return false;
       }
       APValue Lit;
       if (!Evaluate(Lit, Info, CLE->getInitializer()))
         return false;
       CompleteObject LitObj(&Lit, Base->getType());
       return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
-    } else if (isa<StringLiteral>(Base)) {
+    } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
       // We represent a string literal array as an lvalue pointing at the
       // corresponding expression, rather than building an array of chars.
-      // FIXME: Support PredefinedExpr, ObjCEncodeExpr, MakeStringConstant
+      // FIXME: Support ObjCEncodeExpr, MakeStringConstant
       APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0);
       CompleteObject StrObj(&Str, Base->getType());
       return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal);
     }
   }
 
   CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type);
   return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal);

lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
   
   PrintExpr(Node->getBaseExpr());
   OS << "[";
   PrintExpr(Node->getKeyExpr());
   OS << "]";
 }
 
 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
-  switch (Node->getIdentType()) {
-    default:
-      llvm_unreachable("unknown case");
-    case PredefinedExpr::Func:
-      OS << "__func__";
-      break;
-    case PredefinedExpr::Function:
-      OS << "__FUNCTION__";
-      break;
-    case PredefinedExpr::FuncDName:
-      OS << "__FUNCDNAME__";
-      break;
-    case PredefinedExpr::FuncSig:
-      OS << "__FUNCSIG__";
-      break;
-    case PredefinedExpr::LFunction:
-      OS << "L__FUNCTION__";
-      break;
-    case PredefinedExpr::PrettyFunction:
-      OS << "__PRETTY_FUNCTION__";
-      break;
-  }
+  OS << PredefinedExpr::getIdentTypeName(Node->getIdentType());
 }
 
 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
   unsigned value = Node->getValue();
 
   switch (Node->getKind()) {
   case CharacterLiteral::Ascii: break; // no prefix.
   case CharacterLiteral::Wide:  OS << 'L'; break;

lib/CodeGen/CGExpr.cpp

 #include "CGRecordLayout.h"
 #include "CodeGenModule.h"
 #include "TargetInfo.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Attr.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/ConvertUTF.h"
 
 using namespace clang;
 using namespace CodeGen;
return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
                         E->getType());
 }
 
 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
                         E->getType());
 }
 
-static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
-                                    SmallString<32>& Target) {
-  Target.resize(CharByteWidth * (Source.size() + 1));
-  char *ResultPtr = &Target[0];
-  const UTF8 *ErrorPtr;
-  bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
-  (void)success;
-  assert(success);
-  Target.resize(ResultPtr - &Target[0]);
-}
-
 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
-  switch (E->getIdentType()) {
-  default:
-    return EmitUnsupportedLValue(E, "predefined expression");
-
-  case PredefinedExpr::Func:
-  case PredefinedExpr::Function:
-  case PredefinedExpr::LFunction:
-  case PredefinedExpr::FuncDName:
-  case PredefinedExpr::FuncSig:
-  case PredefinedExpr::PrettyFunction: {
-    PredefinedExpr::IdentType IdentType = E->getIdentType();
-    std::string GVName;
-
-    // FIXME: We should use the string literal mangling for the Microsoft C++
-    // ABI so that strings get merged.
-    switch (IdentType) {
-    default: llvm_unreachable("Invalid type");
-    case PredefinedExpr::Func:           GVName = "__func__."; break;
-    case PredefinedExpr::Function:       GVName = "__FUNCTION__."; break;
-    case PredefinedExpr::FuncDName:      GVName = "__FUNCDNAME__."; break;
-    case PredefinedExpr::FuncSig:        GVName = "__FUNCSIG__."; break;
-    case PredefinedExpr::LFunction:      GVName = "L__FUNCTION__."; break;
-    case PredefinedExpr::PrettyFunction: GVName = "__PRETTY_FUNCTION__."; break;
-    }
-
-    StringRef FnName = CurFn->getName();
-    if (FnName.startswith("\01"))
-      FnName = FnName.substr(1);
-    GVName += FnName;
-
-    // If this is outside of a function use the top level decl.
-    const Decl *CurDecl = CurCodeDecl;
-    if (!CurDecl || isa<VarDecl>(CurDecl))
-      CurDecl = getContext().getTranslationUnitDecl();
-
-    const Type *ElemType = E->getType()->getArrayElementTypeNoTypeQual();
-    std::string FunctionName;
-    if (isa<BlockDecl>(CurDecl)) {
-      // Blocks use the mangled function name.
-      // FIXME: ComputeName should handle blocks.
-      FunctionName = FnName.str();
-    } else if (isa<CapturedDecl>(CurDecl)) {
-      // For a captured statement, the function name is its enclosing
-      // function name not the one compiler generated.
-      FunctionName = PredefinedExpr::ComputeName(IdentType, CurDecl);
-    } else {
-      FunctionName = PredefinedExpr::ComputeName(IdentType, CurDecl);
-      assert(cast<ConstantArrayType>(E->getType())->getSize() - 1 ==
-                 FunctionName.size() &&
-             "Computed __func__ length differs from type!");
-    }
-
-    llvm::Constant *C;
-    if (ElemType->isWideCharType()) {
-      SmallString<32> RawChars;
-      ConvertUTF8ToWideString(
-          getContext().getTypeSizeInChars(ElemType).getQuantity(), FunctionName,
-          RawChars);
-      StringLiteral *SL = StringLiteral::Create(
-          getContext(), RawChars, StringLiteral::Wide,
-          /*Pascal = */ false, E->getType(), E->getLocation());
-      C = CGM.GetAddrOfConstantStringFromLiteral(SL);
-    } else {
-      C = CGM.GetAddrOfConstantCString(FunctionName, GVName.c_str(), 1);
-    }
-    return MakeAddrLValue(C, E->getType());
-  }
-  }
+  auto VD = E->getFunctionNameRef();
+  assert(VD != nullptr && "No variable is associated with PredefinedExpr");
+//  auto SL = cast<StringLiteral>(VD->getInit()->IgnoreImpCasts());
+//  StringRef FnName = CurFn->getName();
+//  if (FnName.startswith("\01"))
+//    FnName = FnName.substr(1);
+//  std::string NameItems[] = {VD->getNameAsString(), FnName};
+//  std::string GVName = llvm::join(NameItems, NameItems + 2, ".");
+//
+//  auto C = CGM.GetAddrOfConstantStringFromLiteral(SL, GVName);
+//  return MakeAddrLValue(C, E->getType());
+  if (LocalDeclMap.count(VD) == 0)
+    EmitStaticVarDecl(
+        *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant*/ false));
+  return MakeAddrLValue(CGM.getStaticLocalDeclAddress(VD), E->getType());
 }
 
 /// Emit a type description suitable for use by a runtime sanitizer library. The
 /// format of a type descriptor is
 ///
 /// \code
 ///   { i16 TypeKind, i16 TypeInfo }
 /// \endcode

lib/Parse/ParseExpr.cpp

case tok::utf32_char_constant:
     ConsumeToken();
     break;
   case tok::kw___func__:       // primary-expression: __func__ [C99 6.4.2.2]
   case tok::kw___FUNCTION__:   // primary-expression: __FUNCTION__ [GNU]
   case tok::kw___FUNCDNAME__:   // primary-expression: __FUNCDNAME__ [MS]
   case tok::kw___FUNCSIG__:     // primary-expression: __FUNCSIG__ [MS]
   case tok::kw_L__FUNCTION__:   // primary-expression: L__FUNCTION__ [MS]
   case tok::kw___PRETTY_FUNCTION__:  // primary-expression: __P..Y_F..N__ [GNU]
-    Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
+    Res = Actions.ActOnPredefinedExpr(getCurScope(), Tok.getLocation(),
+                                      SavedKind);
     ConsumeToken();
     break;
   case tok::string_literal:    // primary-expression: string-literal
   case tok::wide_string_literal:
   case tok::utf8_string_literal:
   case tok::utf16_string_literal:
   case tok::utf32_string_literal:
     Res = ParseStringLiteralExpression(true);

lib/Sema/SemaExpr.cpp

 #include "clang/Sema/Designator.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaFixItUtils.h"
 #include "clang/Sema/Template.h"
+#include "llvm/Support/ConvertUTF.h"
 using namespace clang;
 using namespace sema;
 
 /// \brief Determine whether the use of this declaration is valid, without
 /// emitting diagnostics.
 bool Sema::CanUseDecl(NamedDecl *D) {
   // See if this is an auto-typed variable whose initializer we are parsing.
   if (ParsingInitForAutoVars.count(D))
case Decl::CXXConstructor:
       break;
     }
 
     return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
                             TemplateArgs);
   }
 }
 
-ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
+static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
+                                    SmallString<32> &Target) {
+  Target.resize(CharByteWidth * (Source.size() + 1));
+  char *ResultPtr = &Target[0];
+  const UTF8 *ErrorPtr;
+  bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
+  (void)success;
+  assert(success);
+  Target.resize(ResultPtr - &Target[0]);
+}
+
+ExprResult Sema::BuildPredefinedExpr(Scope *S, SourceLocation Loc,
                                      PredefinedExpr::IdentType IT) {
   // Pick the current block, lambda, captured statement or function.
   Decl *currentDecl = nullptr;
   if (const BlockScopeInfo *BSI = getCurBlock())
     currentDecl = BSI->TheDecl;
   else if (const LambdaScopeInfo *LSI = getCurLambda())
     currentDecl = LSI->CallOperator;
   else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
     currentDecl = CSI->TheCapturedDecl;
   else
     currentDecl = getCurFunctionOrMethodDecl();
 
   if (!currentDecl) {
     Diag(Loc, diag::ext_predef_outside_function);
     currentDecl = Context.getTranslationUnitDecl();
   }
 
   QualType ResTy;
+  NamedDecl *ND = nullptr;
   if (cast<DeclContext>(currentDecl)->isDependentContext())
     ResTy = Context.DependentTy;
   else {
     // Pre-defined identifiers are of type char[x], where x is the length of
     // the string.
-    unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
+    auto Str = PredefinedExpr::ComputeName(IT, currentDecl);
+    unsigned Length = Str.length();
 
+    StringLiteral *SL = nullptr;
     llvm::APInt LengthI(32, Length + 1);
-    if (IT == PredefinedExpr::LFunction)
+    if (IT == PredefinedExpr::LFunction) {
       ResTy = Context.WideCharTy.withConst();
-    else
+      SmallString<32> RawChars;
+      ConvertUTF8ToWideString(Context.getTypeSizeInChars(ResTy).getQuantity(),
+                              Str, RawChars);
+      ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
+                                           /*IndexTypeQuals*/ 0);
+      SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide,
+                                 /*Pascal*/ false, ResTy, Loc);
+    } else {
       ResTy = Context.CharTy.withConst();
-    ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
+      ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
+                                           /*IndexTypeQuals*/ 0);
+      SL = StringLiteral::Create(Context, Str, StringLiteral::Ascii,
+                                 /*Pascal*/ false, ResTy, Loc);
+    }
+    auto Id = &Context.Idents.get(PredefinedExpr::getIdentTypeName(IT));
+    DeclarationName DN(Id);
+    auto DC = cast<DeclContext>(currentDecl);
+    ND = LookupSingleName(S, DN, Loc, LookupOrdinaryName);
+    // The variable must be static local for the current decl (required for
+    // blocks).
+    if (ND == nullptr || !DC->containsDecl(ND)) {
+      ND = VarDecl::Create(Context, DC, currentDecl->getLocation(),
+                           currentDecl->getLocation(), Id, ResTy,
+                           Context.getTrivialTypeSourceInfo(ResTy), SC_Static);
+      AddInitializerToDecl(ND, SL, /*DirectInit*/ true,
+                           /*TypeMayContainAuto*/ false);
+      if (S)
+        PushOnScopeChains(ND, S);
+      else
+        DC->addDecl(ND);
+    }
   }
 
-  return new (Context) PredefinedExpr(Loc, ResTy, IT);
+  return new (Context)
+      PredefinedExpr(Loc, ResTy, IT, cast_or_null<VarDecl>(ND));
 }
 
-ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) {
+ExprResult Sema::ActOnPredefinedExpr(Scope *S, SourceLocation Loc,
+                                     tok::TokenKind Kind) {
   PredefinedExpr::IdentType IT;
 
   switch (Kind) {
   default: llvm_unreachable("Unknown simple primary expr!");
   case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
   case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
   case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS]
   case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS]
   case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break;
   case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
   }
 
-  return BuildPredefinedExpr(Loc, IT);
+  return BuildPredefinedExpr(S, Loc, IT);
 }
 
 ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
   SmallString<16> CharBuffer;
   bool Invalid = false;
   StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
   if (Invalid)
     return ExprError();

lib/Sema/SemaTemplateInstantiate.cpp

return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
                                           FirstQualifierInScope);  
 }
 
 ExprResult 
 TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
   if (!E->isTypeDependent())
     return E;
 
-  return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentType());
+  return getSema().BuildPredefinedExpr(/*S*/ nullptr, E->getLocation(),
+                                       E->getIdentType());
 }
 
 ExprResult
 TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
                                                NonTypeTemplateParmDecl *NTTP) {
   // If the corresponding template argument is NULL or non-existent, it's
   // because we are performing instantiation from explicitly-specified
   // template arguments in a function template, but there were some

lib/Sema/TreeTransform.h

StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
                                   Stmt *Block) {
     return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
   }
 
   StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
     return getSema().ActOnSEHFinallyBlock(Loc, Block);
   }
 
+  /// \brief Build a new predefined expression.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildPredefinedExpr(SourceLocation Loc,
+                                   PredefinedExpr::IdentType IT) {
+    return getSema().BuildPredefinedExpr(/*S*/ nullptr, Loc, IT);
+  }
+
   /// \brief Build a new expression that references a declaration.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                         LookupResult &R,
                                         bool RequiresADL) {
     return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);

 }
 
 //===----------------------------------------------------------------------===//
 // Expression transformation
 //===----------------------------------------------------------------------===//
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
+  if (!E->isTypeDependent())
     return E;
+
+  return getDerived().RebuildPredefinedExpr(E->getLocation(),
+                                            E->getIdentType());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
   NestedNameSpecifierLoc QualifierLoc;
   if (E->getQualifierLoc()) {
     QualifierLoc

lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitExpr(Expr *E) {
   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
   assert(Idx == NumExprFields && "Incorrect expression field count");
 }
 
 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation(Record, Idx));
   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
+  E->setFunctionNameRef(ReadDeclAs<VarDecl>(Record, Idx));
 }
 
 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
   E->DeclRefExprBits.HasQualifier = Record[Idx++];
   E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitExpr(Expr *E) {
   Record.push_back(E->getValueKind());
   Record.push_back(E->getObjectKind());
 }
 
 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getLocation(), Record);
   Record.push_back(E->getIdentType()); // FIXME: stable encoding
+  Writer.AddDeclRef(E->getFunctionNameRef(), Record);
   Code = serialization::EXPR_PREDEFINED;
 }
 
 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
   Record.push_back(E->hasQualifier());
   Record.push_back(E->getDecl() != E->getFoundDecl());

lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::ObjCAtFinallyStmtClass:
     case Stmt::ObjCAtTryStmtClass:
     case Stmt::ObjCAutoreleasePoolStmtClass:
     case Stmt::ObjCEncodeExprClass:
     case Stmt::ObjCIsaExprClass:
     case Stmt::ObjCProtocolExprClass:
     case Stmt::ObjCSelectorExprClass:
     case Stmt::ParenListExprClass:
-    case Stmt::PredefinedExprClass:
     case Stmt::ShuffleVectorExprClass:
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::AtomicExprClass:
       // Fall through.
 
     // Cases we intentionally don't evaluate, since they don't need
     // to be explicitly evaluated.
+    case Stmt::PredefinedExprClass:
     case Stmt::AddrLabelExprClass:
     case Stmt::AttributedStmtClass:
     case Stmt::IntegerLiteralClass:
     case Stmt::CharacterLiteralClass:
     case Stmt::ImplicitValueInitExprClass:
     case Stmt::CXXScalarValueInitExprClass:
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::ObjCBoolLiteralExprClass:

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]* @__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]* @g25.__func__, i32 0, i32 0)
+// CHECK: @g25.__func__ = internal 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;

test/CodeGen/func-in-block.c

int main()
     B(
        ^{
             PRINTF(__func__);
         }
     );
     return 0; // not reached
 }
 
-// CHECK: @__func__.__main_block_invoke = private unnamed_addr constant [20 x i8] c"__main_block_invoke\00"
-// CHECK: call void @PRINTF({{.*}}@__func__.__main_block_invoke 
+// CHECK: [[BLOCK_FUNC:@.+]] = internal constant [20 x i8] c"__main_block_invoke\00"
+// CHECK: call void @PRINTF({{.*}}[[BLOCK_FUNC]]

test/CodeGen/predefined-expr.c

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 -fms-extensions %s -emit-llvm -o - | FileCheck %s
 
-// CHECK: @__func__.plainFunction = private unnamed_addr constant [14 x i8] c"plainFunction\00"
-// CHECK: @__PRETTY_FUNCTION__.plainFunction = private unnamed_addr constant [21 x i8] c"void plainFunction()\00"
-// CHECK: @__func__.externFunction = private unnamed_addr constant [15 x i8] c"externFunction\00"
-// CHECK: @__PRETTY_FUNCTION__.externFunction = private unnamed_addr constant [22 x i8] c"void externFunction()\00"
-// CHECK: @__func__.privateExternFunction = private unnamed_addr constant [22 x i8] c"privateExternFunction\00"
-// CHECK: @__PRETTY_FUNCTION__.privateExternFunction = private unnamed_addr constant [29 x i8] c"void privateExternFunction()\00"
-// CHECK: @__func__.__captured_stmt = private unnamed_addr constant [25 x i8] c"functionWithCapturedStmt\00"
-// CHECK: @__PRETTY_FUNCTION__.__captured_stmt = private unnamed_addr constant [32 x i8] c"void functionWithCapturedStmt()\00"
-// CHECK: @__func__.staticFunction = private unnamed_addr constant [15 x i8] c"staticFunction\00"
-// CHECK: @__PRETTY_FUNCTION__.staticFunction = private unnamed_addr constant [22 x i8] c"void staticFunction()\00"
+// CHECK: @plainFunction.__func__ = internal constant [14 x i8] c"plainFunction\00"
+// CHECK: @plainFunction.__PRETTY_FUNCTION__ = internal constant [21 x i8] c"void plainFunction()\00"
+// CHECK: @externFunction.__func__ = internal constant [15 x i8] c"externFunction\00"
+// CHECK: @externFunction.__PRETTY_FUNCTION__ = internal constant [22 x i8] c"void externFunction()\00"
+// CHECK: @privateExternFunction.__func__ = internal constant [22 x i8] c"privateExternFunction\00"
+// CHECK: @privateExternFunction.__PRETTY_FUNCTION__ = internal constant [29 x i8] c"void privateExternFunction()\00"
+// CHECK: @functionWithCapturedStmt.__func__ = internal constant [25 x i8] c"functionWithCapturedStmt\00"
+// CHECK: @functionWithCapturedStmt.__PRETTY_FUNCTION__ = internal constant [32 x i8] c"void functionWithCapturedStmt()\00"
+// CHECK: @staticFunction.__func__ = internal constant [15 x i8] c"staticFunction\00"
+// CHECK: @staticFunction.__PRETTY_FUNCTION__ = internal constant [22 x i8] c"void staticFunction()\00"
 
 int printf(const char *, ...);
 
 void plainFunction() {
   printf("__func__ %s\n", __func__);
   printf("__FUNCTION__ %s\n", __FUNCTION__);
   printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
 }

test/CodeGenCXX/funcsig.cpp

 // RUN: %clang_cc1 -std=c++11 -triple i686-pc-win32 %s -fms-extensions -fno-rtti -emit-llvm -o - | FileCheck %s
 
 // Similar to predefined-expr.cpp, but not as exhaustive, since it's basically
 // equivalent to __PRETTY_FUNCTION__.
 
 extern "C" int printf(const char *, ...);
 
 void freeFunc(int *, char) {
   printf("__FUNCSIG__ %s\n\n", __FUNCSIG__);
 }
-// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __cdecl freeFunc(int *, char)\00"
+// CHECK: internal constant [{{.*}} x i8] c"void __cdecl freeFunc(int *, char)\00"
 
 struct TopLevelClass {
   void topLevelMethod(int *, char);
 };
 void TopLevelClass::topLevelMethod(int *, char) {
   printf("__FUNCSIG__ %s\n\n", __FUNCSIG__);
 }
-// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __thiscall TopLevelClass::topLevelMethod(int *, char)\00"
+// CHECK: internal constant [{{.*}} x i8] c"void __thiscall TopLevelClass::topLevelMethod(int *, char)\00"
 
 namespace NS {
 struct NamespacedClass {
   void namespacedMethod(int *, char);
 };
 void NamespacedClass::namespacedMethod(int *, char) {
   printf("__FUNCSIG__ %s\n\n", __FUNCSIG__);
 }
-// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __thiscall NS::NamespacedClass::namespacedMethod(int *, char)\00"
+// CHECK: internal constant [{{.*}} x i8] c"void __thiscall NS::NamespacedClass::namespacedMethod(int *, char)\00"
 }

test/CodeGenCXX/ms_wide_predefined_expr.cpp

 // RUN: %clang_cc1 %s -fms-extensions -triple i686-pc-win32 -emit-llvm -o - | FileCheck %s
 
-// CHECK: @"\01??_C@_19DPFBEKIN@?$AAf?$AAu?$AAn?$AAc?$AA?$AA@" = linkonce_odr unnamed_addr constant [5 x i16] [i16 102, i16 117, i16 110, i16 99, i16 0], align 2
+// CHECK: @"\01?L__FUNCTION__@?0??func@@YAXXZ@4QB_WB" = internal constant [5 x i16] [i16 102, i16 117, i16 110, i16 99, i16 0], align 2
 
 void wprint(const wchar_t*);
 
 #define __STR2WSTR(str) L##str
 #define _STR2WSTR(str) __STR2WSTR(str)
 #define STR2WSTR(str) _STR2WSTR(str)
 
 void func() {

test/CodeGenCXX/predefined-expr-cxx14.cpp

+// RUN: %clang_cc1 -std=c++14 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+// CHECK-DAG: @_ZZN13ClassTemplateIiE21classTemplateFunctionERiE8__func__ = linkonce_odr constant [22 x i8] c"classTemplateFunction\00"
+// CHECK-DAG: @_ZZN13ClassTemplateIiE21classTemplateFunctionERiE19__PRETTY_FUNCTION__ = linkonce_odr constant [69 x i8] c"const auto &ClassTemplate<int>::classTemplateFunction(T &) [T = int]\00"
+
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace16functionTemplateIiEERDaRT_E8__func__ = linkonce_odr constant [17 x i8] c"functionTemplate\00"
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace16functionTemplateIiEERDaRT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [64 x i8] c"auto &ClassInTopLevelNamespace::functionTemplate(T &) [T = int]\00"
+
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace16variadicFunctionEPizE8__func__ = linkonce_odr constant [17 x i8] c"variadicFunction\00"
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace16variadicFunctionEPizE19__PRETTY_FUNCTION__ = linkonce_odr constant [70 x i8] c"decltype(auto) ClassInTopLevelNamespace::variadicFunction(int *, ...)\00"
+
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEvE8__func__ = linkonce_odr constant [26 x i8] c"topLevelNamespaceFunction\00"
+// CHECK-DAG: @_ZZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [60 x i8] c"auto *ClassInTopLevelNamespace::topLevelNamespaceFunction()\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__);
+    return static_cast<int *>(nullptr);
+  }
+
+  decltype(auto) variadicFunction(int *a, ...) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return a;
+  }
+
+  template<typename T>
+  auto &functionTemplate(T &t) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return t;
+  }
+};
+
+template<typename T>
+class ClassTemplate {
+public:
+  const auto &classTemplateFunction(T &t) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return t;
+  }
+};
+
+int main() {
+  int a;
+  ClassInTopLevelNamespace topLevelNamespace;
+  topLevelNamespace.topLevelNamespaceFunction();
+  topLevelNamespace.variadicFunction(&a);
+  topLevelNamespace.functionTemplate(a);
+
+  ClassTemplate<int> t;
+  t.classTemplateFunction(a);
+  return 0;
+}

test/CodeGenCXX/predefined-expr.cpp

 // RUN: %clang_cc1 -std=c++11 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
 
-// CHECK: private unnamed_addr constant [15 x i8] c"externFunction\00"
-// CHECK: private unnamed_addr constant [26 x i8] c"void NS::externFunction()\00"
-// CHECK: private unnamed_addr constant [49 x i8] c"void functionTemplateExplicitSpecialization(int)\00"
+// CHECK: internal constant [15 x i8] c"externFunction\00"
+// CHECK: internal constant [26 x i8] c"void NS::externFunction()\00"
+// CHECK: _ZZ38functionTemplateExplicitSpecializationIiEvT_E19__PRETTY_FUNCTION__ = constant [49 x i8] c"void functionTemplateExplicitSpecialization(int)\00"
 
-// CHECK: private unnamed_addr constant [95 x i8] c"void SpecializedClassTemplate<char>::memberFunctionTemplate(T, U) const [T = char, U = double]\00"
-// CHECK: private unnamed_addr constant [85 x i8] c"void SpecializedClassTemplate<int>::memberFunctionTemplate(int, U) const [U = float]\00"
-// CHECK: private unnamed_addr constant [57 x i8] c"void NonTypeTemplateParam<42>::size() const [Count = 42]\00"
-// CHECK: private unnamed_addr constant [122 x i8] c"static void ClassWithTemplateTemplateParam<char, NS::ClassTemplate>::staticMember() [T = char, Param = NS::ClassTemplate]\00"
-// CHECK: private unnamed_addr constant [106 x i8] c"void OuterClass<int *>::MiddleClass::InnerClass<float>::memberFunction(T, U) const [T = int *, U = float]\00"
-// CHECK: private unnamed_addr constant [51 x i8] c"void functionTemplateWithCapturedStmt(T) [T = int]\00"
-// CHECK: private unnamed_addr constant [76 x i8] c"auto functionTemplateWithLambda(int)::(anonymous class)::operator()() const\00"
-// CHECK: private unnamed_addr constant [65 x i8] c"void functionTemplateWithUnnamedTemplateParameter(T) [T = float]\00"
+// CHECK: @_ZZNK24SpecializedClassTemplateIcE22memberFunctionTemplateIdEEvcT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [95 x i8] c"void SpecializedClassTemplate<char>::memberFunctionTemplate(T, U) const [T = char, U = double]\00"
+// CHECK: @_ZZNK24SpecializedClassTemplateIiE22memberFunctionTemplateIfEEviT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [85 x i8] c"void SpecializedClassTemplate<int>::memberFunctionTemplate(int, U) const [U = float]\00"
+// CHECK: @_ZZNK20NonTypeTemplateParamILi42EE4sizeEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [57 x i8] c"void NonTypeTemplateParam<42>::size() const [Count = 42]\00"
+// CHECK: @_ZZN30ClassWithTemplateTemplateParamIcN2NS13ClassTemplateEE12staticMemberEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [122 x i8] c"static void ClassWithTemplateTemplateParam<char, NS::ClassTemplate>::staticMember() [T = char, Param = NS::ClassTemplate]\00"
+// CHECK: @_ZZNK10OuterClassIPiE11MiddleClass10InnerClassIfE14memberFunctionES0_fE19__PRETTY_FUNCTION__ = linkonce_odr constant [106 x i8] c"void OuterClass<int *>::MiddleClass::InnerClass<float>::memberFunction(T, U) const [T = int *, U = float]\00"
+// CHECK: @_ZZ32functionTemplateWithCapturedStmtIiEvT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [51 x i8] c"void functionTemplateWithCapturedStmt(T) [T = int]\00"
+// CHECK: @_ZZZ26functionTemplateWithLambdaIiEvT_ENKUlvE_clEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [76 x i8] c"auto functionTemplateWithLambda(int)::(anonymous class)::operator()() const\00"
+// CHECK: @_ZZ44functionTemplateWithUnnamedTemplateParameterIifEvT0_E19__PRETTY_FUNCTION__ = linkonce_odr constant [65 x i8] c"void functionTemplateWithUnnamedTemplateParameter(T) [T = float]\00"
 
-// CHECK: private unnamed_addr constant [60 x i8] c"void functionTemplateExplicitSpecialization(T) [T = double]\00"
-// CHECK: private unnamed_addr constant [52 x i8] c"T *functionTemplateWithCompoundTypes(T *) [T = int]\00" 
-// CHECK: private unnamed_addr constant [54 x i8] c"T functionTemplateWithTemplateReturnType() [T = char]\00"
-// CHECK: private unnamed_addr constant [57 x i8] c"void functionTemplateWithoutParameterList() [T = double]\00"
-// CHECK: private unnamed_addr constant [62 x i8] c"void functionTemplateWithTwoParams(T, U) [T = int, U = float]\00"
+// CHECK: @_ZZ38functionTemplateExplicitSpecializationIdEvT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [60 x i8] c"void functionTemplateExplicitSpecialization(T) [T = double]\00"
+// CHECK: @_ZZ33functionTemplateWithCompoundTypesIiEPT_S1_E19__PRETTY_FUNCTION__ = linkonce_odr constant [52 x i8] c"T *functionTemplateWithCompoundTypes(T *) [T = int]\00" 
+// CHECK: @_ZZ38functionTemplateWithTemplateReturnTypeIcET_vE19__PRETTY_FUNCTION__ = linkonce_odr constant [54 x i8] c"T functionTemplateWithTemplateReturnType() [T = char]\00"
+// CHECK: @_ZZ36functionTemplateWithoutParameterListIdEvvE19__PRETTY_FUNCTION__ = linkonce_odr constant [57 x i8] c"void functionTemplateWithoutParameterList() [T = double]\00"
+// CHECK: @_ZZ29functionTemplateWithTwoParamsIifEvT_T0_E19__PRETTY_FUNCTION__ = linkonce_odr constant [62 x i8] c"void functionTemplateWithTwoParams(T, U) [T = int, U = float]\00"
 
-// CHECK: private unnamed_addr constant [22 x i8] c"classTemplateFunction\00"
-// CHECK: private unnamed_addr constant [77 x i8] c"void NS::ClassTemplate<NS::Base *>::classTemplateFunction() [T = NS::Base *]\00"
-// CHECK: private unnamed_addr constant [63 x i8] c"void NS::ClassTemplate<int>::classTemplateFunction() [T = int]\00"
+// CHECK: @_ZZN2NS13ClassTemplateIPNS_4BaseEE21classTemplateFunctionEvE8__func__ = linkonce_odr constant [22 x i8] c"classTemplateFunction\00"
+// CHECK: @_ZZN2NS13ClassTemplateIPNS_4BaseEE21classTemplateFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [77 x i8] c"void NS::ClassTemplate<NS::Base *>::classTemplateFunction() [T = NS::Base *]\00"
+// CHECK: @_ZZN2NS13ClassTemplateIiE21classTemplateFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [63 x i8] c"void NS::ClassTemplate<int>::classTemplateFunction() [T = int]\00"
 
-// CHECK: private unnamed_addr constant [18 x i8] c"functionTemplate1\00"
-// CHECK: private unnamed_addr constant [53 x i8] c"void NS::Base::functionTemplate1(T) [T = NS::Base *]\00"
-// CHECK: private unnamed_addr constant [46 x i8] c"void NS::Base::functionTemplate1(T) [T = int]\00"
+// CHECK: @_ZZN2NS4Base17functionTemplate1IPS0_EEvT_E8__func__ = linkonce_odr constant [18 x i8] c"functionTemplate1\00"
+// CHECK: @_ZZN2NS4Base17functionTemplate1IPS0_EEvT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [53 x i8] c"void NS::Base::functionTemplate1(T) [T = NS::Base *]\00"
+// CHECK: @_ZZN2NS4Base17functionTemplate1IiEEvT_E19__PRETTY_FUNCTION__ = linkonce_odr constant [46 x i8] c"void NS::Base::functionTemplate1(T) [T = int]\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"anonymousUnionFunction\00"
-// CHECK: private unnamed_addr constant [83 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous union)::anonymousUnionFunction()\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt1_22anonymousUnionFunctionEvE8__func__ = linkonce_odr constant [23 x i8] c"anonymousUnionFunction\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt1_22anonymousUnionFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [83 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous union)::anonymousUnionFunction()\00"
 
-// CHECK: private unnamed_addr constant [24 x i8] c"anonymousStructFunction\00"
-// CHECK: private unnamed_addr constant [85 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous struct)::anonymousStructFunction()\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt0_23anonymousStructFunctionEvE8__func__ = linkonce_odr constant [24 x i8] c"anonymousStructFunction\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt0_23anonymousStructFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [85 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous struct)::anonymousStructFunction()\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"anonymousClassFunction\00"
-// CHECK: private unnamed_addr constant [83 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous class)::anonymousClassFunction()\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt_22anonymousClassFunctionEvE8__func__ = linkonce_odr constant [23 x i8] c"anonymousClassFunction\00"
+// CHECK: @_ZZN2NS28ContainerForAnonymousRecordsUt_22anonymousClassFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [83 x i8] c"void NS::ContainerForAnonymousRecords::(anonymous class)::anonymousClassFunction()\00"
 
-// CHECK: private unnamed_addr constant [12 x i8] c"~Destructor\00"
-// CHECK: private unnamed_addr constant [30 x i8] c"NS::Destructor::~Destructor()\00"
+// CHECK: @_ZZN2NS10DestructorD1EvE8__func__ = linkonce_odr constant [12 x i8] c"~Destructor\00"
+// CHECK: @_ZZN2NS10DestructorD1EvE19__PRETTY_FUNCTION__ = linkonce_odr constant [30 x i8] c"NS::Destructor::~Destructor()\00"
 
-// CHECK: private unnamed_addr constant [12 x i8] c"Constructor\00"
-// CHECK: private unnamed_addr constant [41 x i8] c"NS::Constructor::Constructor(NS::Base *)\00"
-// CHECK: private unnamed_addr constant [34 x i8] c"NS::Constructor::Constructor(int)\00"
-// CHECK: private unnamed_addr constant [31 x i8] c"NS::Constructor::Constructor()\00"
+// CHECK: @_ZZN2NS11ConstructorC1EPNS_4BaseEE8__func__ = linkonce_odr constant [12 x i8] c"Constructor\00"
+// CHECK: @_ZZN2NS11ConstructorC1EPNS_4BaseEE19__PRETTY_FUNCTION__ = linkonce_odr constant [41 x i8] c"NS::Constructor::Constructor(NS::Base *)\00"
+// CHECK: @_ZZN2NS11ConstructorC1EiE19__PRETTY_FUNCTION__ = linkonce_odr constant [34 x i8] c"NS::Constructor::Constructor(int)\00"
+// CHECK: @_ZZN2NS11ConstructorC1EvE19__PRETTY_FUNCTION__ = linkonce_odr constant [31 x i8] c"NS::Constructor::Constructor()\00"
 
-// CHECK: private unnamed_addr constant [16 x i8] c"virtualFunction\00"
-// CHECK: private unnamed_addr constant [44 x i8] c"virtual void NS::Derived::virtualFunction()\00"
+// CHECK: @_ZZN2NS7Derived15virtualFunctionEvE8__func__ = linkonce_odr constant [16 x i8] c"virtualFunction\00"
+// CHECK: @_ZZN2NS7Derived15virtualFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [44 x i8] c"virtual void NS::Derived::virtualFunction()\00"
 
-// CHECK: private unnamed_addr constant [21 x i8] c"refQualifiedFunction\00"
-// CHECK: private unnamed_addr constant [41 x i8] c"void NS::Base::refQualifiedFunction() &&\00"
-// CHECK: private unnamed_addr constant [40 x i8] c"void NS::Base::refQualifiedFunction() &\00"
+// CHECK: @_ZZNO2NS4Base20refQualifiedFunctionEvE8__func__ = linkonce_odr constant [21 x i8] c"refQualifiedFunction\00"
+// CHECK: @_ZZNO2NS4Base20refQualifiedFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [41 x i8] c"void NS::Base::refQualifiedFunction() &&\00"
+// CHECK: @_ZZNR2NS4Base20refQualifiedFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [40 x i8] c"void NS::Base::refQualifiedFunction() &\00"
 
-// CHECK: private unnamed_addr constant [22 x i8] c"constVolatileFunction\00"
-// CHECK: private unnamed_addr constant [54 x i8] c"void NS::Base::constVolatileFunction() const volatile\00"
+// CHECK: @_ZZNVK2NS4Base21constVolatileFunctionEvE8__func__ = linkonce_odr constant [22 x i8] c"constVolatileFunction\00"
+// CHECK: @_ZZNVK2NS4Base21constVolatileFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [54 x i8] c"void NS::Base::constVolatileFunction() const volatile\00"
 
-// CHECK: private unnamed_addr constant [17 x i8] c"volatileFunction\00"
-// CHECK: private unnamed_addr constant [43 x i8] c"void NS::Base::volatileFunction() volatile\00"
+// CHECK: @_ZZNV2NS4Base16volatileFunctionEvE8__func__ = linkonce_odr constant [17 x i8] c"volatileFunction\00"
+// CHECK: @_ZZNV2NS4Base16volatileFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [43 x i8] c"void NS::Base::volatileFunction() volatile\00"
 
-// CHECK: private unnamed_addr constant [14 x i8] c"constFunction\00"
-// CHECK: private unnamed_addr constant [37 x i8] c"void NS::Base::constFunction() const\00"
+// CHECK: @_ZZNK2NS4Base13constFunctionEvE8__func__ = linkonce_odr constant [14 x i8] c"constFunction\00"
+// CHECK: @_ZZNK2NS4Base13constFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [37 x i8] c"void NS::Base::constFunction() const\00"
 
-// CHECK: private unnamed_addr constant [26 x i8] c"functionReturingTemplate2\00"
-// CHECK: private unnamed_addr constant [64 x i8] c"ClassTemplate<NS::Base *> NS::Base::functionReturingTemplate2()\00"
+// CHECK: @_ZZN2NS4Base25functionReturingTemplate2EvE8__func__ = linkonce_odr constant [26 x i8] c"functionReturingTemplate2\00"
+// CHECK: @_ZZN2NS4Base25functionReturingTemplate2EvE19__PRETTY_FUNCTION__ = linkonce_odr constant [64 x i8] c"ClassTemplate<NS::Base *> NS::Base::functionReturingTemplate2()\00"
 
-// CHECK: private unnamed_addr constant [26 x i8] c"functionReturingTemplate1\00"
-// CHECK: private unnamed_addr constant [57 x i8] c"ClassTemplate<int> NS::Base::functionReturingTemplate1()\00"
+// CHECK: @_ZZN2NS4Base25functionReturingTemplate1EvE8__func__ = linkonce_odr constant [26 x i8] c"functionReturingTemplate1\00"
+// CHECK: @_ZZN2NS4Base25functionReturingTemplate1EvE19__PRETTY_FUNCTION__ = linkonce_odr constant [57 x i8] c"ClassTemplate<int> NS::Base::functionReturingTemplate1()\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"withTemplateParameter2\00"
-// CHECK: private unnamed_addr constant [65 x i8] c"void NS::Base::withTemplateParameter2(ClassTemplate<NS::Base *>)\00"
+// CHECK: @_ZZN2NS4Base22withTemplateParameter2ENS_13ClassTemplateIPS0_EEE8__func__ = linkonce_odr constant [23 x i8] c"withTemplateParameter2\00"
+// CHECK: @_ZZN2NS4Base22withTemplateParameter2ENS_13ClassTemplateIPS0_EEE19__PRETTY_FUNCTION__ = linkonce_odr constant [65 x i8] c"void NS::Base::withTemplateParameter2(ClassTemplate<NS::Base *>)\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"withTemplateParameter1\00"
-// CHECK: private unnamed_addr constant [58 x i8] c"void NS::Base::withTemplateParameter1(ClassTemplate<int>)\00"
+// CHECK: @_ZZN2NS4Base22withTemplateParameter1ENS_13ClassTemplateIiEEE8__func__ = linkonce_odr constant [23 x i8] c"withTemplateParameter1\00"
+// CHECK: @_ZZN2NS4Base22withTemplateParameter1ENS_13ClassTemplateIiEEE19__PRETTY_FUNCTION__ = linkonce_odr constant [58 x i8] c"void NS::Base::withTemplateParameter1(ClassTemplate<int>)\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"functionReturningClass\00"
-// CHECK: private unnamed_addr constant [45 x i8] c"NS::Base *NS::Base::functionReturningClass()\00"
+// CHECK: @_ZZN2NS4Base22functionReturningClassEvE8__func__ = linkonce_odr constant [23 x i8] c"functionReturningClass\00"
+// CHECK: @_ZZN2NS4Base22functionReturningClassEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [45 x i8] c"NS::Base *NS::Base::functionReturningClass()\00"
 
-// CHECK: private unnamed_addr constant [23 x i8] c"functionWithParameters\00"
-// CHECK: private unnamed_addr constant [64 x i8] c"void NS::Base::functionWithParameters(int, float *, NS::Base *)\00"
+// CHECK: @_ZZN2NS4Base22functionWithParametersEiPfPS0_E8__func__ = linkonce_odr constant [23 x i8] c"functionWithParameters\00"
+// CHECK: @_ZZN2NS4Base22functionWithParametersEiPfPS0_E19__PRETTY_FUNCTION__ = linkonce_odr constant [64 x i8] c"void NS::Base::functionWithParameters(int, float *, NS::Base *)\00"
 
-// CHECK: private unnamed_addr constant [17 x i8] c"variadicFunction\00"
-// CHECK: private unnamed_addr constant [42 x i8] c"void NS::Base::variadicFunction(int, ...)\00"
+// CHECK: @_ZZN2NS4Base16variadicFunctionEizE8__func__ = linkonce_odr constant [17 x i8] c"variadicFunction\00"
+// CHECK: @_ZZN2NS4Base16variadicFunctionEizE19__PRETTY_FUNCTION__ = linkonce_odr constant [42 x i8] c"void NS::Base::variadicFunction(int, ...)\00"
 
-// CHECK: private unnamed_addr constant [41 x i8] c"virtual void NS::Base::virtualFunction()\00"
+// CHECK: @_ZZN2NS4Base15virtualFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [41 x i8] c"virtual void NS::Base::virtualFunction()\00"
 
-// CHECK: private unnamed_addr constant [15 x i8] c"inlineFunction\00"
-// CHECK: private unnamed_addr constant [32 x i8] c"void NS::Base::inlineFunction()\00"
+// CHECK: @_ZZN2NS4Base14inlineFunctionEvE8__func__ = linkonce_odr constant [15 x i8] c"inlineFunction\00"
+// CHECK: @_ZZN2NS4Base14inlineFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [32 x i8] c"void NS::Base::inlineFunction()\00"
 
-// CHECK: private unnamed_addr constant [15 x i8] c"staticFunction\00"
-// CHECK: private unnamed_addr constant [39 x i8] c"static void NS::Base::staticFunction()\00"
+// CHECK: @_ZZN2NS4Base14staticFunctionEvE8__func__ = linkonce_odr constant [15 x i8] c"staticFunction\00"
+// CHECK: @_ZZN2NS4Base14staticFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [39 x i8] c"static void NS::Base::staticFunction()\00"
 
-// CHECK: private unnamed_addr constant [26 x i8] c"topLevelNamespaceFunction\00"
-// CHECK: private unnamed_addr constant [59 x i8] c"void ClassInTopLevelNamespace::topLevelNamespaceFunction()\00"
+// CHECK: @_ZZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEvE8__func__ = linkonce_odr constant [26 x i8] c"topLevelNamespaceFunction\00"
+// CHECK: @_ZZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEvE19__PRETTY_FUNCTION__ = linkonce_odr constant [59 x i8] c"void ClassInTopLevelNamespace::topLevelNamespaceFunction()\00"
 
-// CHECK: private unnamed_addr constant [27 x i8] c"anonymousNamespaceFunction\00"
-// CHECK: private unnamed_addr constant [84 x i8] c"void (anonymous namespace)::ClassInAnonymousNamespace::anonymousNamespaceFunction()\00"
+// CHECK: internal constant [27 x i8] c"anonymousNamespaceFunction\00"
+// CHECK: internal constant [84 x i8] c"void (anonymous namespace)::ClassInAnonymousNamespace::anonymousNamespaceFunction()\00"
 
-// CHECK: private unnamed_addr constant [19 x i8] c"localClassFunction\00"
-// CHECK: private unnamed_addr constant [59 x i8] c"void NS::localClass(int)::LocalClass::localClassFunction()\00"
+// CHECK: internal constant [19 x i8] c"localClassFunction\00"
+// CHECK: internal constant [59 x i8] c"void NS::localClass(int)::LocalClass::localClassFunction()\00"
 
 
 
 int printf(const char * _Format, ...);
 
 class ClassInTopLevelNamespace {
 public:
   void topLevelNamespaceFunction() {

test/CodeGenObjC/predefined-expr.m

 // RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 %s -emit-llvm -o - | FileCheck %s
 
-// CHECK: @"__func__.-[Foo instanceTest1]" = private unnamed_addr constant [21 x i8] c"-[Foo instanceTest1]\00"
-// CHECK: @"__func__.-[Foo instanceTest2:]" = private unnamed_addr constant [22 x i8] c"-[Foo instanceTest2:]\00"
-// CHECK: @"__func__.-[Foo instanceTest3:withB:]" = private unnamed_addr constant [28 x i8] c"-[Foo instanceTest3:withB:]\00"
-// CHECK: @"__func__.-[Foo instanceTest4]" = private unnamed_addr constant [21 x i8] c"-[Foo instanceTest4]\00"
-// CHECK: @"__func__.+[Foo classTest1]" = private unnamed_addr constant [18 x i8] c"+[Foo classTest1]\00"
-// CHECK: @"__func__.+[Foo classTest2:]" = private unnamed_addr constant [19 x i8] c"+[Foo classTest2:]\00"
-// CHECK: @"__func__.+[Foo classTest3:withB:]" = private unnamed_addr constant [25 x i8] c"+[Foo classTest3:withB:]\00"
-// CHECK: @"__func__.+[Foo classTest4]" = private unnamed_addr constant [18 x i8] c"+[Foo classTest4]\00"
-// CHECK: @"__func__.-[Foo(Category) instanceTestWithCategory]" = private unnamed_addr constant [42 x i8] c"-[Foo(Category) instanceTestWithCategory]\00"
-// CHECK: @"__func__.+[Foo(Category) classTestWithCategory]" = private unnamed_addr constant [39 x i8] c"+[Foo(Category) classTestWithCategory]\00"
+// CHECK: @"\01-[Foo instanceTest1].__func__" = internal constant [21 x i8] c"-[Foo instanceTest1]\00"
+// CHECK: @"\01-[Foo instanceTest2:].__func__" = internal constant [22 x i8] c"-[Foo instanceTest2:]\00"
+// CHECK: @"\01-[Foo instanceTest3:withB:].__func__" = internal constant [28 x i8] c"-[Foo instanceTest3:withB:]\00"
+// CHECK: @"\01-[Foo instanceTest4].__func__" = internal constant [21 x i8] c"-[Foo instanceTest4]\00"
+// CHECK: @"\01+[Foo classTest1].__func__" = internal constant [18 x i8] c"+[Foo classTest1]\00"
+// CHECK: @"\01+[Foo classTest2:].__func__" = internal constant [19 x i8] c"+[Foo classTest2:]\00"
+// CHECK: @"\01+[Foo classTest3:withB:].__func__" = internal constant [25 x i8] c"+[Foo classTest3:withB:]\00"
+// CHECK: @"\01+[Foo classTest4].__func__" = internal constant [18 x i8] c"+[Foo classTest4]\00"
+// CHECK: @"\01-[Foo(Category) instanceTestWithCategory].__func__" = internal constant [42 x i8] c"-[Foo(Category) instanceTestWithCategory]\00"
+// CHECK: @"\01+[Foo(Category) classTestWithCategory].__func__" = internal constant [39 x i8] c"+[Foo(Category) classTestWithCategory]\00"
 
 int printf(const char * _Format, ...);
 
 @interface Foo
 @end
 
 @implementation Foo
 

test/SemaCXX/predefined-expr.cpp

[]() {
     static_assert(sizeof(__FUNCTION__) == 11, "operator()");
     static_assert(sizeof(__PRETTY_FUNCTION__) == 50,
                   "auto baz()::<anonymous class>::operator()() const");
     return 0;
   }
   ();
 
   ^{
-    // FIXME: This is obviously wrong.
-    static_assert(sizeof(__func__) == 1, "__baz_block_invoke");
-    static_assert(sizeof(__FUNCTION__) == 1, "__baz_block_invoke");
-    static_assert(sizeof(__PRETTY_FUNCTION__) == 1, "__baz_block_invoke");
+    static_assert(sizeof(__func__) == 27, "___Z3bazIiEiv_block_invoke");
+    static_assert(sizeof(__FUNCTION__) == 27, "___Z3bazIiEiv_block_invoke");
+    static_assert(sizeof(__PRETTY_FUNCTION__) == 27, "___Z3bazIiEiv_block_invoke");
   }
   ();
 
   #pragma clang __debug captured
   {
     static_assert(sizeof(__func__) == 4, "baz");
     static_assert(sizeof(__FUNCTION__) == 4, "baz");
     static_assert(sizeof(__PRETTY_FUNCTION__) == 20, "int baz() [T = int]");
[]() {
     static_assert(sizeof(__FUNCTION__) == 11, "operator()");
     static_assert(sizeof(__PRETTY_FUNCTION__) == 51,
                   "auto main()::<anonymous class>::operator()() const");
     return 0;
   }
   ();
 
   ^{
-    // FIXME: This is obviously wrong.
-    static_assert(sizeof(__func__) == 1, "__main_block_invoke");
-    static_assert(sizeof(__FUNCTION__) == 1, "__main_block_invoke");
-    static_assert(sizeof(__PRETTY_FUNCTION__) == 1, "__main_block_invoke");
+    static_assert(sizeof(__func__) == 20, "__main_block_invoke");
+    static_assert(sizeof(__FUNCTION__) == 20, "__main_block_invoke");
+    static_assert(sizeof(__PRETTY_FUNCTION__) == 20, "__main_block_invoke");
   }
   ();
 
   #pragma clang __debug captured
   {
     static_assert(sizeof(__func__) == 5, "main");
     static_assert(sizeof(__FUNCTION__) == 5, "main");
     static_assert(sizeof(__PRETTY_FUNCTION__) == 11, "int main()");