Better mangling for new-expressions. Also, although we can't mangle arbitrary initial...

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@151455 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp
index 91e6ee5c970bc1582fb04a121aafd79c093cb7e4..59e13cbc5eb632a20fe8fa216dfa909add7a5945 100644 (file)
--- a/lib/AST/ItaniumMangle.cpp
+++ b/lib/AST/ItaniumMangle.cpp
@@ -2356,12 +2356,12 @@ recurse:
   case Expr::CXXThisExprClass:
   case Expr::DesignatedInitExprClass:
   case Expr::ImplicitValueInitExprClass:
-  case Expr::InitListExprClass:
   case Expr::ParenListExprClass:
   case Expr::LambdaExprClass:
     llvm_unreachable("unexpected statement kind");
 
   // FIXME: invent manglings for all these.
+  case Expr::InitListExprClass:
   case Expr::BlockExprClass:
   case Expr::CXXPseudoDestructorExprClass:
   case Expr::ChooseExprClass:
@@ -2454,7 +2454,6 @@ recurse:
   }
 
   case Expr::CXXNewExprClass: {
-    // Proposal from David Vandervoorde, 2010.06.30
     const CXXNewExpr *New = cast<CXXNewExpr>(E);
     if (New->isGlobalNew()) Out << "gs";
     Out << (New->isArray() ? "na" : "nw");
@@ -2464,8 +2463,14 @@ recurse:
     Out << '_';
     mangleType(New->getAllocatedType());
     if (New->hasInitializer()) {
-      // FIXME: Does this mean "parenthesized initializer"?
-      Out << "pi";
+      // <initializer> is 'pi <expression>* E' in the current ABI for
+      // parenthesized initializers, but braced initializers are unspecified.
+      // We use 'bl <expression>* E' for "braced list". "bi" is too easy to
+      // confuse.
+      if (New->getInitializationStyle() == CXXNewExpr::ListInit)
+        Out << "bl";
+      else
+        Out << "pi";
       const Expr *Init = New->getInitializer();
       if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
         // Directly inline the initializers.
@@ -2476,6 +2481,12 @@ recurse:
       } else if (const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
         for (unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
           mangleExpression(PLE->getExpr(i));
+      } else if (New->getInitializationStyle() == CXXNewExpr::ListInit &&
+                 isa<InitListExpr>(Init)) {
+        // Only take ParenListExprs apart for list-initialization.
+        const InitListExpr *InitList = cast<InitListExpr>(Init);
+        for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i)
+          mangleExpression(InitList->getInit(i));
       } else
         mangleExpression(Init);
     }

diff --git a/test/CodeGenCXX/mangle-exprs.cpp b/test/CodeGenCXX/mangle-exprs.cpp
index bad564f80f17499e731788047d61a1b5e9f88f14..338cff7515532021eec9c3a48d025ba5b90c1c10 100644 (file)
--- a/test/CodeGenCXX/mangle-exprs.cpp
+++ b/test/CodeGenCXX/mangle-exprs.cpp
@@ -1,5 +1,37 @@
 // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s
 
+namespace std {
+  typedef decltype(sizeof(int)) size_t;
+
+  // libc++'s implementation
+  template <class _E>
+  class initializer_list
+  {
+    const _E* __begin_;
+    size_t    __size_;
+
+    initializer_list(const _E* __b, size_t __s)
+      : __begin_(__b),
+        __size_(__s)
+    {}
+
+  public:
+    typedef _E        value_type;
+    typedef const _E& reference;
+    typedef const _E& const_reference;
+    typedef size_t    size_type;
+
+    typedef const _E* iterator;
+    typedef const _E* const_iterator;
+
+    initializer_list() : __begin_(nullptr), __size_(0) {}
+
+    size_t    size()  const {return __size_;}
+    const _E* begin() const {return __begin_;}
+    const _E* end()   const {return __begin_ + __size_;}
+  };
+}
+
 template < bool condition, typename T = void >
 struct enable_if { typedef T type; };
 
@@ -132,3 +164,31 @@ namespace test3 {
     a(x, &X::member, ip);
   }
 }
+
+namespace test4 {
+  struct X {
+    X(int);
+    X(std::initializer_list<int>);
+  };
+
+  template <typename T>
+  void tf1(decltype(new T(1)) p)
+  {}
+
+  template <typename T>
+  void tf2(decltype(new T({1})) p)
+  {}
+
+  template <typename T>
+  void tf3(decltype(new T{1}) p)
+  {}
+
+  // CHECK: void @_ZN5test43tf1INS_1XEEEvDTnw_T_piLi1EEE
+  template void tf1<X>(X*);
+
+  // FIXME: Need mangling for braced initializers
+  //template void tf2<X>(X*);
+
+  // CHECK: void @_ZN5test43tf3INS_1XEEEvDTnw_T_blLi1EEE
+  template void tf3<X>(X*);
+}