diff -r b1f214165471 Lib/inspect.py
--- a/Lib/inspect.py	Sat Feb 01 13:49:29 2014 -0500
+++ b/Lib/inspect.py	Sat Feb 01 16:47:18 2014 -0500
@@ -1594,7 +1594,9 @@
 def _signature_is_builtin(obj):
     # Internal helper to test if `obj` is a callable that might
     # support Argument Clinic's __text_signature__ protocol.
-    return (isinstance(obj, _NonUserDefinedCallables) or
+
+    return (isbuiltin(obj) or
+            isinstance(obj, _NonUserDefinedCallables) or
             ismethoddescriptor(obj) or
             # Can't test 'isinstance(type)' here, as it would
             # also be True for regular python classes
@@ -1696,7 +1698,7 @@
 
     if isfunction(obj) or _signature_is_functionlike(obj):
         # If it's a pure Python function, or an object that is duck type
-        # of a Python function (Cython functions, for instance), then:
+        # of a Python function:
         return Signature.from_function(obj)
 
     if isinstance(obj, functools.partial):
@@ -2193,6 +2195,16 @@
 
         s = getattr(func, "__text_signature__", None)
         if not s:
+            if _signature_is_functionlike(func):
+                # If we have a builtin function that properly supports the
+                # pure Python function protocol, i.e. has proper __code__,
+                # __defaults__, etc attributes, and does not have a
+                # '__text_signature__' attribute, we use 'from_function'
+                # method to build a signature for it.
+                # A good example of such builtin functions are Cython
+                # functions.
+                return cls.from_function(func)
+
             raise ValueError("no signature found for builtin {!r}".format(func))
 
         Parameter = cls._parameter_cls
diff -r b1f214165471 Lib/test/test_inspect.py
--- a/Lib/test/test_inspect.py	Sat Feb 01 13:49:29 2014 -0500
+++ b/Lib/test/test_inspect.py	Sat Feb 01 16:47:18 2014 -0500
@@ -15,6 +15,7 @@
 import types
 import unicodedata
 import unittest
+import unittest.mock
 
 try:
     from concurrent.futures import ThreadPoolExecutor
@@ -1778,6 +1779,29 @@
                            ('kwargs', ..., ..., "var_keyword")),
                            ...))
 
+        # Test from_builtin:
+        _orig_isbuiltin = inspect.isbuiltin
+        def _isbuiltin(obj):
+            if hasattr(obj, '_builtinmock'):
+                return True
+            return _orig_isbuiltin(obj)
+
+        builtin_func = funclike(func)
+        builtin_func._builtinmock = True
+
+        with unittest.mock.patch('inspect.isbuiltin', _isbuiltin):
+            self.assertTrue(inspect.isbuiltin(builtin_func))
+
+            self.assertEqual(inspect.Signature.from_builtin(builtin_func),
+                             sig_func)
+            self.assertEqual(inspect.signature(builtin_func), sig_func)
+
+            # __text_signature__ has a priority
+            builtin_func.__text_signature__ = '(foobar)'
+            self.assertEqual(str(inspect.Signature.from_builtin(builtin_func)),
+                             '(foobar)')
+            self.assertEqual(str(inspect.signature(builtin_func)), '(foobar)')
+
     def test_signature_functionlike_class(self):
         # We only want to duck type function-like objects,
         # not classes.