Index: lib/CodeGen/CGExprCXX.cpp
===================================================================
--- lib/CodeGen/CGExprCXX.cpp	(revision 122624)
+++ lib/CodeGen/CGExprCXX.cpp	(working copy)
@@ -93,6 +93,8 @@
   return false;
 }
 
+// Note: This function also emit constructor calls to support a MSVC
+// extensions allowing explicit constructor function call.
 RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
                                               ReturnValueSlot ReturnValue) {
   if (isa<BinaryOperator>(CE->getCallee()->IgnoreParens())) 
@@ -127,25 +129,40 @@
 
   if (MD->isTrivial()) {
     if (isa<CXXDestructorDecl>(MD)) return RValue::get(0);
+    if (isa<CXXConstructorDecl>(MD) && 
+        cast<CXXConstructorDecl>(MD)->isDefaultConstructor())
+      return RValue::get(0);
 
-    assert(MD->isCopyAssignmentOperator() && "unknown trivial member function");
-    // We don't like to generate the trivial copy assignment operator when
-    // it isn't necessary; just produce the proper effect here.
-    llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
-    EmitAggregateCopy(This, RHS, CE->getType());
-    return RValue::get(This);
+    if (MD->isCopyAssignmentOperator()) {
+      // We don't like to generate the trivial copy assignment operator when
+      // it isn't necessary; just produce the proper effect here.
+      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
+      EmitAggregateCopy(This, RHS, CE->getType());
+      return RValue::get(This);
+    } else if (isa<CXXConstructorDecl>(MD) && 
+               cast<CXXConstructorDecl>(MD)->isCopyConstructor()) {
+      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
+      EmitSynthesizedCXXCopyCtorCall(cast<CXXConstructorDecl>(MD), This, RHS,
+                                     CE->arg_begin(), CE->arg_end());
+      return RValue::get(This);
+    }
+    llvm_unreachable("unknown trivial member function");
   }
 
   // Compute the function type we're calling.
-  const CGFunctionInfo &FInfo =
-    (isa<CXXDestructorDecl>(MD)
-     ? CGM.getTypes().getFunctionInfo(cast<CXXDestructorDecl>(MD),
-                                      Dtor_Complete)
-     : CGM.getTypes().getFunctionInfo(MD));
+  const CGFunctionInfo *FInfo = 0;
+  if (isa<CXXDestructorDecl>(MD))
+    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXDestructorDecl>(MD),
+                                           Dtor_Complete);
+  else if (isa<CXXConstructorDecl>(MD))
+    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXConstructorDecl>(MD),
+                                            Ctor_Complete);
+  else
+    FInfo = &CGM.getTypes().getFunctionInfo(MD);
 
   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
   const llvm::Type *Ty
-    = CGM.getTypes().GetFunctionType(FInfo, FPT->isVariadic());
+    = CGM.getTypes().GetFunctionType(*FInfo, FPT->isVariadic());
 
   // C++ [class.virtual]p12:
   //   Explicit qualification with the scope operator (5.1) suppresses the
@@ -163,6 +180,9 @@
     } else {
       Callee = CGM.GetAddrOfFunction(GlobalDecl(Dtor, Dtor_Complete), Ty);
     }
+  } else if (const CXXConstructorDecl *Ctor =
+               dyn_cast<CXXConstructorDecl>(MD)) {
+    Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty);
   } else if (UseVirtualCall) {
     Callee = BuildVirtualCall(MD, This, Ty); 
   } else {
Index: lib/Parse/ParseExpr.cpp
===================================================================
--- lib/Parse/ParseExpr.cpp	(revision 122624)
+++ lib/Parse/ParseExpr.cpp	(working copy)
@@ -1175,7 +1175,7 @@
       if (ParseUnqualifiedId(SS, 
                              /*EnteringContext=*/false, 
                              /*AllowDestructorName=*/true,
-                             /*AllowConstructorName=*/false, 
+                             /*AllowConstructorName=*/ getLang().Microsoft, 
                              ObjectType,
                              Name))
         LHS = ExprError();
Index: lib/Sema/SemaOverload.cpp
===================================================================
--- lib/Sema/SemaOverload.cpp	(revision 122624)
+++ lib/Sema/SemaOverload.cpp	(working copy)
@@ -7888,7 +7888,11 @@
       if (isa<UsingShadowDecl>(Func))
         Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
 
-      if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
+      
+      if (getLangOptions().Microsoft && isa<CXXConstructorDecl>(Func)) {
+        AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args, NumArgs,
+                             CandidateSet);
+      } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
         // If explicit template arguments were provided, we can't call a
         // non-template member function.
         if (TemplateArgs)
Index: test/CodeGenCXX/constructor-direct-call.cpp
===================================================================
--- test/CodeGenCXX/constructor-direct-call.cpp	(revision 0)
+++ test/CodeGenCXX/constructor-direct-call.cpp	(revision 0)
@@ -0,0 +1,60 @@
+// RUN: %clang_cc1 -fms-extensions %s -emit-llvm -o - | FileCheck %s
+
+class Test1 {
+public:
+   int a;
+};
+
+void f1() {
+  Test1 var;
+  var.Test1::Test1();
+
+  // CHECK:   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %{{.*}}, i8* %{{.*}}, i32 4, i32 4, i1 false)
+  var.Test1::Test1(var);
+}
+
+class Test2 {
+public:
+  Test2() { a = 10; b = 10; }
+   int a;
+   int b;
+};
+
+void f2() {
+  // CHECK:  %var = alloca %class.Test2, align 4
+  // CHECK-NEXT:  call void @_ZN5Test2C1Ev(%class.Test2* %var)
+  Test2 var;
+
+  // CHECK-NEXT:  call void @_ZN5Test2C1Ev(%class.Test2* %var)
+  var.Test2::Test2();
+
+  // CHECK:  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %{{.*}}, i8* %{{.*}}, i32 8, i32 4, i1 false)
+  var.Test2::Test2(var);
+}
+
+
+
+
+class Test3 {
+public:
+  Test3() { a = 10; b = 15; c = 20; }
+  Test3(const Test3& that) { a = that.a; b = that.b; c = that.c; }
+   int a;
+   int b;
+   int c;
+};
+
+void f3() {
+  // CHECK: call void @_ZN5Test3C1Ev(%class.Test3* %var)
+  Test3 var;
+
+  // CHECK-NEXT: call void @_ZN5Test3C1Ev(%class.Test3* %var2)
+  Test3 var2;
+
+  // CHECK-NEXT: call void @_ZN5Test3C1Ev(%class.Test3* %var)
+  var.Test3::Test3();
+
+  // CHECK-NEXT: call void @_ZN5Test3C1ERKS_(%class.Test3* %var, %class.Test3* %var2)
+  var.Test3::Test3(var2);
+}
+
Index: test/Parser/MicrosoftExtensions.cpp
===================================================================
--- test/Parser/MicrosoftExtensions.cpp	(revision 122624)
+++ test/Parser/MicrosoftExtensions.cpp	(working copy)
@@ -85,3 +85,21 @@
    __uuidof(T);
    __uuidof(expr);
 }
+
+
+
+class CtorCall { 
+public:
+  CtorCall& operator=(const CtorCall& that);
+
+  int a;
+};
+
+CtorCall& CtorCall::operator=(const CtorCall& that)
+{
+    if (this != &that) {
+        this->CtorCall::~CtorCall();
+        this->CtorCall::CtorCall(that);
+    }
+    return *this;
+}
\ No newline at end of file