diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td
index 8811e6a..5f01d59 100644
--- a/include/clang/Basic/DiagnosticGroups.td
+++ b/include/clang/Basic/DiagnosticGroups.td
@@ -34,6 +34,7 @@ def SignConversion : DiagGroup<"sign-conversion">;
 def BoolConversion : DiagGroup<"bool-conversion">;
 def IntConversion : DiagGroup<"int-conversion">;
 def NullConversion : DiagGroup<"null-conversion">;
+def ImplicitConversionFloatingPointToBool : DiagGroup<"implicit-conversion-floating-point-to-bool">;
 def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">;
 def CXXCompat: DiagGroup<"c++-compat">;
 def CastAlign : DiagGroup<"cast-align">;
diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 4df26cf..9c675d8 100644
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1899,6 +1899,9 @@ def warn_impcast_bool_to_null_pointer : Warning<
 def warn_impcast_null_pointer_to_integer : Warning<
     "implicit conversion of NULL constant to %0">,
     InGroup<NullConversion>;
+def warn_impcast_floating_point_to_bool : Warning<
+    "implicit conversion turns floating-point number into bool: %0 to %1">,
+    InGroup<ImplicitConversionFloatingPointToBool>, DefaultIgnore;
 def warn_impcast_function_to_bool : Warning<
     "address of function %q0 will always evaluate to 'true'">,
     InGroup<BoolConversion>;
diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index dce912c..327c368 100644
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -431,6 +431,7 @@ bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   return false;
 }
 
+
 bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   unsigned i = 0, l = 0, u = 0;
   switch (BuiltinID) {
@@ -4344,6 +4345,43 @@ std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range) {
   return ValueInRange.toString(10);
 }
 
+static bool ImplicitBoolToFloatArgumentConversion(Sema &S, Expr *Ex) {
+  if (!isa<ImplicitCastExpr>(Ex))
+    return false;
+  Expr *InnerE = Ex->IgnoreParenImpCasts();
+  const Type *Target = S.Context.getCanonicalType(Ex->getType()).getTypePtr();
+  const Type *Source = S.Context.getCanonicalType(InnerE->getType()).getTypePtr();
+  const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
+  if ((!Target->isDependentType())&&(Source!=Target)&&
+      Source->isSpecificBuiltinType(BuiltinType::Bool)&&
+      TargetBT&&(TargetBT->isFloatingPoint())) {
+    return true;
+  }
+  return false;
+}
+
+void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC) {
+  unsigned NumArgs = TheCall->getNumArgs();
+  for (unsigned i = 0; i < NumArgs; ++i) {
+    Expr *CurrA = TheCall->getArg(i);
+    if (isa<ImplicitCastExpr>(CurrA)) {
+      Expr *InnerE = CurrA->IgnoreParenImpCasts();
+      const Type *Target = S.Context.getCanonicalType(CurrA->getType()).getTypePtr();
+      const Type *Source = S.Context.getCanonicalType(InnerE->getType()).getTypePtr();
+      const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
+      if ((!Target->isDependentType())&&(Source!=Target)&&
+          Target->isSpecificBuiltinType(BuiltinType::Bool)&&
+	  SourceBT&&(SourceBT->isFloatingPoint())) {
+        if (((i>0) && ImplicitBoolToFloatArgumentConversion(S,TheCall->getArg(i-1))) ||
+            ((i<(NumArgs-1)) && ImplicitBoolToFloatArgumentConversion(S,TheCall->getArg(i+1)))) {
+          // Warn on this floating-point to bool conversion
+          DiagnoseImpCast(S, InnerE, CurrA->getType(), CC, diag::warn_impcast_floating_point_to_bool);
+        }
+      }
+    }
+  }
+}
+
 void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
                              SourceLocation CC, bool *ICContext = 0) {
   if (E->isTypeDependent() || E->isValueDependent()) return;
@@ -4479,6 +4517,24 @@ void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
       }
     }
 
+    // If the target is bool, warn if expr is a function or method call 
+    if (Target->isSpecificBuiltinType(BuiltinType::Bool) &&
+        isa<CallExpr>(E)) {
+      // Check last argument of function or method call to see if it is an
+      // implicit cast from a type matching the type the method result 
+      // is being cast to
+      CallExpr *CEx = static_cast<CallExpr*>(E);
+      unsigned NumArgs = CEx->getNumArgs();
+      if (NumArgs>0) {
+	Expr *LastA = CEx->getArg(NumArgs-1);
+  	Expr *InnerE = LastA->IgnoreParenImpCasts();
+	if (isa<ImplicitCastExpr>(LastA) &&
+	   (S.Context.getCanonicalType(InnerE->getType()).getTypePtr()==Target)) {      
+	  // Warn on this floating-point to bool conversion 
+          DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_floating_point_to_bool);
+	}
+      }
+    }
     return;
   }
 
@@ -4649,6 +4705,10 @@ void AnalyzeImplicitConversions(Sema &S, Expr *OrigE, SourceLocation CC) {
     return;
   }
 
+  // Check implicit argument conversions for function calls
+  if (isa<CallExpr>(E))
+    CheckImplicitArgumentConversions(S, static_cast<CallExpr*>(E), CC);
+
   // Go ahead and check any implicit conversions we might have skipped.
   // The non-canonical typecheck is just an optimization;
   // CheckImplicitConversion will filter out dead implicit conversions.
diff --git a/test/SemaCXX/warn-implicit-conversion-floating-point-to-bool.cpp b/test/SemaCXX/warn-implicit-conversion-floating-point-to-bool.cpp
new file mode 100644
index 0000000..a943f6a
--- /dev/null
+++ b/test/SemaCXX/warn-implicit-conversion-floating-point-to-bool.cpp
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -x c++ -verify -fsyntax-only -Wimplicit-conversion-floating-point-to-bool %s
+
+float foof(float x) {
+  return x;
+}
+
+double food(double x) {
+  return x;
+}
+
+void foo(bool b, float f) { }
+
+void bar() {
+
+  float c = 1.7;
+  bool b = c;  
+  
+  double e = 1.7;
+  b = e;  
+  
+  b = foof(4.0);
+
+  b = foof(c<1); // expected-warning {{implicit conversion turns floating-point number into bool: 'float' to 'bool'}} 
+  
+  b = food(e<2); // expected-warning {{implicit conversion turns floating-point number into bool: 'double' to 'bool'}} 
+  
+  foo(c, b);    // expected-warning {{implicit conversion turns floating-point number into bool: 'float' to 'bool'}} 
+  foo(c, c);
+
+}