commit d553f8c57fc77a46f6a1a1c90d7fd8f2d0e96073
author Anders Carlsson <andersca@mac.com> Mon Sep 21 01:21:10 2009 +0000
committer Anders Carlsson <andersca@mac.com> Mon Sep 21 01:21:10 2009 +0000
tree 3778a7bb29a38c35d1379d5f5fe65264d6150cf1
parent 62d1fc0945ebde28ebfa150a039cb05f055122af

Start mangling expressions.

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

lib/CodeGen/Mangle.cpp

diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index 057d57e..48445e6 100644
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -96,7 +96,7 @@
     void mangleType(const TagType*);
     void mangleBareFunctionType(const FunctionType *T,
                                 bool MangleReturnType);
-    void mangleExpression(Expr *E);
+    void mangleExpression(const Expr *E);
     void mangleCXXCtorType(CXXCtorType T);
     void mangleCXXDtorType(CXXDtorType T);
 
@@ -917,8 +917,41 @@
   mangleType(QualType(T->getBaseType(), 0));
 }
 
-void CXXNameMangler::mangleExpression(Expr *E) {
-  assert(false && "Cannot mangle expressions yet");
+void CXXNameMangler::mangleExpression(const Expr *E) {
+  // <expression> ::= <unary operator-name> <expression>
+	//              ::= <binary operator-name> <expression> <expression>
+	//              ::= <trinary operator-name> <expression> <expression> <expression>
+  //              ::= cl <expression>* E	        # call
+  //              ::= cv <type> expression           # conversion with one argument
+  //              ::= cv <type> _ <expression>* E # conversion with a different number of arguments
+  //              ::= st <type>		        # sizeof (a type)
+  //              ::= at <type>                      # alignof (a type)
+  //              ::= <template-param>
+  //              ::= <function-param>
+  //              ::= sr <type> <unqualified-name>                   # dependent name
+  //              ::= sr <type> <unqualified-name> <template-args>   # dependent template-id
+  //              ::= sZ <template-param>                            # size of a parameter pack
+	//              ::= <expr-primary>
+  switch (E->getStmtClass()) {
+  default: assert(false && "Unhandled expression kind!");
+  case Expr::DeclRefExprClass: {
+    const Decl *D = cast<DeclRefExpr>(E)->getDecl();
+    
+    switch (D->getKind()) {
+    default: assert(false && "Unhandled decl kind!");
+    case Decl::NonTypeTemplateParm: {
+      const NonTypeTemplateParmDecl *PD = cast<NonTypeTemplateParmDecl>(D);
+      
+      if (PD->getIndex() == 0)
+        Out << "T_";
+      else
+        Out << 'T' << (PD->getIndex() - 1) << '_';
+      break;
+    }
+
+    }
+  }
+  }
 }
 
 // FIXME: <type> ::= G <type>   # imaginary (C 2000)
@@ -997,6 +1030,11 @@
   case TemplateArgument::Type:
     mangleType(A.getAsType());
     break;
+  case TemplateArgument::Expression:
+    Out << 'X';
+    mangleExpression(A.getAsExpr());
+    Out << 'E';
+    break;
   case TemplateArgument::Integral:
     //  <expr-primary> ::= L <type> <value number> E # integer literal