diff --git a/share/qtcreator/dumper/bridge.py b/share/qtcreator/dumper/bridge.py
index edc4542bda5..da75a51e54b 100644
--- a/share/qtcreator/dumper/bridge.py
+++ b/share/qtcreator/dumper/bridge.py
@@ -334,8 +334,8 @@ try:
     #BitStringCode = gdb.TYPE_CODE_BITSTRING
     #ErrorTypeCode = gdb.TYPE_CODE_ERROR
     MethodCode = gdb.TYPE_CODE_METHOD
-    #MethodPointerCode = gdb.TYPE_CODE_METHODPTR
-    #MemberPointerCode = gdb.TYPE_CODE_MEMBERPTR
+    MethodPointerCode = gdb.TYPE_CODE_METHODPTR
+    MemberPointerCode = gdb.TYPE_CODE_MEMBERPTR
     ReferenceCode = gdb.TYPE_CODE_REF
     CharCode = gdb.TYPE_CODE_CHAR
     BoolCode = gdb.TYPE_CODE_BOOL
diff --git a/share/qtcreator/dumper/dumper.py b/share/qtcreator/dumper/dumper.py
index 6868183f4a1..e1a9066764e 100644
--- a/share/qtcreator/dumper/dumper.py
+++ b/share/qtcreator/dumper/dumper.py
@@ -1616,6 +1616,13 @@ class Dumper:
             self.putPointerValue(value.address)
             return
 
+        if type.code == MethodPointerCode or type.code == MemberPointerCode:
+            self.putType(typeName)
+            self.putAddress(value.address)
+            self.putValue(value)
+            self.putNumChild(0)
+            return
+
         if typeName.startswith("<anon"):
             # Anonymous union. We need a dummy name to distinguish
             # multiple anonymous unions in the struct.
diff --git a/tests/manual/debugger/simple/simple_test_app.cpp b/tests/manual/debugger/simple/simple_test_app.cpp
index de9f6ff5807..fd1041158dc 100644
--- a/tests/manual/debugger/simple/simple_test_app.cpp
+++ b/tests/manual/debugger/simple/simple_test_app.cpp
@@ -4971,21 +4971,54 @@ namespace basic {
         dummyStatement(&ba);
     }
 
-    void testFunctionPointerHelper() {}
-
-    static int someData;
+    int testFunctionPointerHelper(int x) { return x; }
 
     void testFunctionPointer()
     {
-        typedef void (*func_t)();
-        func_t f2 = testFunctionPointerHelper;
-        int *p = &someData;
+        typedef int (*func_t)(int);
+        func_t f = testFunctionPointerHelper;
+        int a = f(43);
         BREAK_HERE;
-        // CheckType f2 basic::func_t.
+        // CheckType f basic::func_t.
         // Continue.
 
-        // Check there's a valid display for f2.
-        dummyStatement(&f2, p);
+        // Check there's a valid display for f.
+        dummyStatement(&f, &a);
+    }
+
+    struct Class
+    {
+        Class() : a(34) {}
+        int testFunctionPointerHelper(int x) { return x; }
+        int a;
+    };
+
+    void testMemberFunctionPointer()
+    {
+        Class x;
+        typedef int (Class::*func_t)(int);
+        func_t f = &Class::testFunctionPointerHelper;
+        int a = (x.*f)(43);
+        BREAK_HERE;
+        // CheckType f basic::func_t.
+        // Continue.
+
+        // Check there's a valid display for f.
+        dummyStatement(&f, &a);
+    }
+
+    void testMemberPointer()
+    {
+        Class x;
+        typedef int (Class::*member_t);
+        member_t m = &Class::a;
+        int a = x.*m;
+        BREAK_HERE;
+        // CheckType m basic::member_t.
+        // Continue.
+
+        // Check there's a valid display for m.
+        dummyStatement(&m, &a);
     }
 
     void testPassByReferenceHelper(Foo &f)
@@ -5139,6 +5172,8 @@ namespace basic {
         testLongEvaluation2();
         testFork();
         testFunctionPointer();
+        testMemberPointer();
+        testMemberFunctionPointer();
         testPassByReference();
         testBigInt();
         testHidden();