Clang added a new feature to the ObjC compiler that will translate me…

lldb/include/lldb/Target/ThreadPlan.h

@@ -461,8 +461,12 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
   virtual void WillPop();
 
   // This pushes a plan onto the plan stack of the current plan's thread.
+  // Also sets the plans to private and not master plans.  A plan pushed by 
+  // another thread plan is never either of the above.
   void PushPlan(lldb::ThreadPlanSP &thread_plan_sp) {
     m_thread.PushPlan(thread_plan_sp);
+    thread_plan_sp->SetPrivate(false);
+    thread_plan_sp->SetIsMasterPlan(false);
   }
 
   ThreadPlanKind GetKind() const { return m_kind; }

lldb/include/lldb/Target/ThreadPlanStepInRange.h

@@ -49,6 +49,12 @@ class ThreadPlanStepInRange : public ThreadPlanStepRange,
 
   bool IsVirtualStep() override;
 
+  // Plans that are implementing parts of a step in might need to follow the
+  // behavior of this plan w.r.t. StepThrough.  They can get that from here.
+  static uint32_t GetDefaultFlagsValue() {
+    return s_default_flag_values;
+  }
+
 protected:
   static bool DefaultShouldStopHereCallback(ThreadPlan *current_plan,
                                             Flags &flags,

lldb/packages/Python/lldbsuite/test/lang/objc/direct-dispatch-step/Makefile

@@ -0,0 +1,4 @@
+OBJC_SOURCES := stepping-tests.m
+LD_EXTRAS := -lobjc -framework Foundation
+
+include Makefile.rules

lldb/packages/Python/lldbsuite/test/lang/objc/direct-dispatch-step/TestObjCDirectDispatchStepping.py

@@ -0,0 +1,50 @@
+"""Test stepping through ObjC method dispatch in various forms."""
+
+from __future__ import print_function
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestObjCDirectDispatchStepping(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers that we will step to in main:
+        self.main_source = lldb.SBFileSpec("stepping-tests.m")
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi', 'basic_process'])
+    def test_with_python_api(self):
+        """Test stepping through the 'direct dispatch' optimized method calls."""
+        self.build()
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                                                            "Stop here to start stepping",
+                                                                            self.main_source)
+        stop_bkpt = target.BreakpointCreateBySourceRegex("// Stop Location [0-9]+", self.main_source)
+        self.assertEqual(stop_bkpt.GetNumLocations(), 15)
+
+        # Here we step through all the overridden methods of OverridesALot
+        # The last continue will get us to the call ot OverridesInit.
+        for idx in range(2,16):
+            thread.StepInto()
+            func_name = thread.GetFrameAtIndex(0).GetFunctionName()
+            self.assertTrue("OverridesALot" in func_name, "%d'th step did not match name: %s"%(idx, func_name))
+            stop_threads = lldbutil.continue_to_breakpoint(process, stop_bkpt)
+            self.assertEqual(len(stop_threads), 1)
+            self.assertEqual(stop_threads[0], thread)
+
+        thread.StepInto()
+        func_name = thread.GetFrameAtIndex(0).GetFunctionName()
+        self.assertEqual(func_name, "-[OverridesInit init]", "Stopped in [OverridesInit init]")
+
+
+

lldb/packages/Python/lldbsuite/test/lang/objc/direct-dispatch-step/stepping-tests.m

@@ -0,0 +1,117 @@
+#import <Foundation/Foundation.h>
+
+@interface OverridesALot: NSObject
+
+- (void)boring;
+
+@end
+
+@implementation OverridesALot
+
++ (id)alloc {
+  NSLog(@"alloc");
+  return [super alloc];
+}
+
++ (id)allocWithZone: (NSZone *)z {
+  NSLog(@"allocWithZone:");
+  return [super allocWithZone: z];
+}
+
++ (id)new {
+  NSLog(@"new");
+  return [super new];
+}
+
+- (id)init {
+  NSLog(@"init");
+  return [super init];
+}
+
+- (id)self {
+  NSLog(@"self");
+  return [super self];
+}
+
++ (id)class {
+  NSLog(@"class");
+  return [super class];
+}
+
+- (BOOL)isKindOfClass: (Class)c {
+  NSLog(@"isKindOfClass:");
+  return [super isKindOfClass: c];
+}
+
+- (BOOL)respondsToSelector: (SEL)s {
+  NSLog(@"respondsToSelector:");
+  return [super respondsToSelector: s];
+}
+
+- (id)retain {
+  NSLog(@"retain");
+  return [super retain];
+}
+
+- (oneway void)release {
+  NSLog(@"release");
+  [super release];
+}
+
+- (id)autorelease { 
+  NSLog(@"autorelease");
+  return [super autorelease];
+}
+
+- (void)boring {
+  NSLog(@"boring");
+}
+
+@end
+
+@interface OverridesInit: NSObject
+
+- (void)boring;
+
+@end
+
+@implementation OverridesInit
+
+- (id)init {
+  NSLog(@"init");
+  return [super init];
+}
+
+@end
+
+int main() {
+  id obj;
+
+  // First make an object of the class that overrides everything,
+  // and make sure we step into all the methods:
+
+  obj = [OverridesALot alloc]; // Stop here to start stepping
+  [obj release]; // Stop Location 2
+
+  obj = [OverridesALot allocWithZone: NULL]; // Stop Location 3
+  [obj release]; // Stop Location 4
+
+  obj = [OverridesALot new]; // Stop Location 5
+  [obj release]; // Stop Location 6
+
+  obj = [[OverridesALot alloc] init]; // Stop Location 7
+  [obj self]; // Stop Location 8
+  [obj isKindOfClass: [OverridesALot class]]; // Stop Location 9
+  [obj respondsToSelector: @selector(hello)]; // Stop Location 10
+  [obj retain];  // Stop Location 11
+  [obj autorelease]; // Stop Location 12
+  [obj boring]; // Stop Location 13
+  [obj release]; // Stop Location 14
+
+  // Now try a class that only overrides init but not alloc, to make
+  // sure we get into the second method in a combined call:
+
+  obj = [[OverridesInit alloc] init]; // Stop Location 15
+
+  return 0; // Stop Location 15
+}