diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 1b73679..c474084 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -2118,9 +2118,25 @@
 
   // If this template name refers to a set of overloaded function templates, 
   /// the canonical template name merely stores the set of function templates.
-  if (OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl())
-    // FIXME: Can't really canonicalize a set of overloaded functions, can we?
-    return TemplateName(Ovl);
+  if (OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl()) {
+    OverloadedFunctionDecl *CanonOvl = 0;
+    for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
+                                                FEnd = Ovl->function_end();
+         F != FEnd; ++F) {
+      Decl *Canon = F->get()->getCanonicalDecl();
+      if (CanonOvl || Canon != F->get()) {
+        if (!CanonOvl)
+          CanonOvl = OverloadedFunctionDecl::Create(*this, 
+                                                    Ovl->getDeclContext(), 
+                                                    Ovl->getDeclName());
+        
+        CanonOvl->addOverload(
+                    AnyFunctionDecl::getFromNamedDecl(cast<NamedDecl>(Canon)));
+      }
+    }
+    
+    return TemplateName(CanonOvl? CanonOvl : Ovl);
+  }
   
   DependentTemplateName *DTN = Name.getAsDependentTemplateName();
   assert(DTN && "Non-dependent template names must refer to template decls.");
diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp
index 8039d97..5714c68 100644
--- a/lib/AST/StmtProfile.cpp
+++ b/lib/AST/StmtProfile.cpp
@@ -603,8 +603,7 @@
 
 void StmtProfiler::VisitDecl(Decl *D) {
   if (Canonical && D) {
-    if (NonTypeTemplateParmDecl *NTTP 
-        = dyn_cast<NonTypeTemplateParmDecl>(D)) {
+    if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
       ID.AddInteger(NTTP->getDepth());
       ID.AddInteger(NTTP->getIndex());
       VisitType(NTTP->getType());
@@ -612,6 +611,29 @@
     }
     
     // FIXME: Template template parameters?
+    
+    if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) {
+      // Canonicalize all of the function declarations within the overload
+      // set.
+      llvm::SmallVector<Decl *, 4> Functions;
+      for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
+                                                  FEnd = Ovl->function_end();
+           F != FEnd; ++F)
+        Functions.push_back(F->get()->getCanonicalDecl());
+      
+      // Sorting the functions based on the point means that the ID generated
+      // will be different from one execution of the compiler to another.
+      // Since these IDs don't persist over time, the change in ordering will
+      // not affect compilation.
+      std::sort(Functions.begin(), Functions.end());
+      
+      for (llvm::SmallVector<Decl *, 4>::iterator F = Functions.begin(),
+                                               FEnd = Functions.end();
+           F != FEnd; ++F)
+        VisitDecl(*F);
+
+      return;
+    }
   }
   
   ID.AddPointer(D? D->getCanonicalDecl() : 0);