diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index c5014d3..75628b7 100644
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -39,8 +39,7 @@
       : Context(C), Out(os), Structor(0), StructorType(0) { }
 
     bool mangle(const NamedDecl *D);
-    void mangleThunkName(const NamedDecl *ND, bool Virtual, int64_t nv,
-                         int64_t v);
+    void mangleThunk(const NamedDecl *ND, bool Virtual, int64_t nv, int64_t v);
     void mangleGuardVariable(const VarDecl *D);
     
     void mangleCXXVtable(QualType Type);
@@ -238,8 +237,8 @@
     mangleNestedName(ND);
 }
 
-void CXXNameMangler::mangleThunkName(const NamedDecl *D, bool Virtual,
-                                     int64_t nv, int64_t v) {
+void CXXNameMangler::mangleThunk(const NamedDecl *D, bool Virtual, int64_t nv,
+                                 int64_t v) {
   //  <special-name> ::= T <call-offset> <base encoding>
   //                      # base is the nominal target function of thunk
   //  <call-offset>  ::= h <nv-offset> _
@@ -833,8 +832,8 @@
   
   /// \brief Mangles the a thunk with the offset n for the declaration D and
   /// emits that name to the given output stream.
-  void mangleThunkName(const NamedDecl *D, bool Virtual, int64_t nv,
-                       int64_t v, ASTContext &Context, llvm::raw_ostream &os) {
+  void mangleThunk(const NamedDecl *D, bool Virtual, int64_t nv, int64_t v,
+                   ASTContext &Context, llvm::raw_ostream &os) {
     // FIXME: Hum, we might have to thunk these, fix.
     assert(!isa<CXXConstructorDecl>(D) &&
            "Use mangleCXXCtor for constructor decls!");
@@ -842,7 +841,7 @@
            "Use mangleCXXDtor for destructor decls!");
     
     CXXNameMangler Mangler(Context, os);
-    Mangler.mangleThunkName(D, Virtual, nv, v);
+    Mangler.mangleThunk(D, Virtual, nv, v);
     os.flush();
   }
   
diff --git a/lib/CodeGen/Mangle.h b/lib/CodeGen/Mangle.h
index a2fba4e..fd88679 100644
--- a/lib/CodeGen/Mangle.h
+++ b/lib/CodeGen/Mangle.h
@@ -34,8 +34,8 @@
   
   bool mangleName(const NamedDecl *D, ASTContext &Context, 
                   llvm::raw_ostream &os);
-  void mangleThunkName(const NamedDecl *D, bool Virtual, int64_t n,
-                       int64_t vn, ASTContext &Context, llvm::raw_ostream &os);
+  void mangleThunk(const NamedDecl *D, bool Virtual, int64_t n, int64_t vn,
+                   ASTContext &Context, llvm::raw_ostream &os);
   void mangleGuardVariable(const VarDecl *D, ASTContext &Context,
                            llvm::raw_ostream &os);
   void mangleCXXVtable(QualType T, ASTContext &Context, llvm::raw_ostream &os);
