*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 117 insertions, 60 deletions

diff --git a/lldb/examples/python/performance.py b/lldb/examples/python/performance.py
index a225d7b..f1bc94f 100755
--- a/lldb/examples/python/performance.py
+++ b/lldb/examples/python/performance.py
@@ -21,7 +21,7 @@ import types
 #----------------------------------------------------------------------
 # Code that auto imports LLDB
 #----------------------------------------------------------------------
-try: 
+try:
     # Just try for LLDB in case PYTHONPATH is already correctly setup
     import lldb
 except ImportError:
@@ -32,15 +32,20 @@ except ImportError:
         # On Darwin, try the currently selected Xcode directory
         xcode_dir = commands.getoutput("xcode-select --print-path")
         if xcode_dir:
-            lldb_python_dirs.append(os.path.realpath(xcode_dir + '/../SharedFrameworks/LLDB.framework/Resources/Python'))
-            lldb_python_dirs.append(xcode_dir + '/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
-        lldb_python_dirs.append('/System/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
+            lldb_python_dirs.append(
+                os.path.realpath(
+                    xcode_dir +
+                    '/../SharedFrameworks/LLDB.framework/Resources/Python'))
+            lldb_python_dirs.append(
+                xcode_dir + '/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
+        lldb_python_dirs.append(
+            '/System/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
     success = False
     for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
-                try: 
+                try:
                     import lldb
                 except ImportError:
                     pass
@@ -53,7 +58,8 @@ except ImportError:
         sys.exit(1)
 
 
-class Timer:    
+class Timer:
+
     def __enter__(self):
         self.start = time.clock()
         return self
@@ -62,30 +68,45 @@ class Timer:
         self.end = time.clock()
         self.interval = self.end - self.start
 
+
 class Action(object):
     """Class that encapsulates actions to take when a thread stops for a reason."""
-    def __init__(self, callback = None, callback_owner = None):
+
+    def __init__(self, callback=None, callback_owner=None):
         self.callback = callback
         self.callback_owner = callback_owner
-    def ThreadStopped (self, thread):
+
+    def ThreadStopped(self, thread):
         assert False, "performance.Action.ThreadStopped(self, thread) must be overridden in a subclass"
 
+
 class PlanCompleteAction (Action):
-    def __init__(self, callback = None, callback_owner = None):
+
+    def __init__(self, callback=None, callback_owner=None):
         Action.__init__(self, callback, callback_owner)
-    def ThreadStopped (self, thread):
+
+    def ThreadStopped(self, thread):
         if thread.GetStopReason() == lldb.eStopReasonPlanComplete:
             if self.callback:
                 if self.callback_owner:
-                    self.callback (self.callback_owner, thread)
+                    self.callback(self.callback_owner, thread)
                 else:
-                    self.callback (thread)
+                    self.callback(thread)
             return True
         return False
 
 
 class BreakpointAction (Action):
-    def __init__(self, callback = None, callback_owner = None, name = None, module = None, file = None, line = None, breakpoint = None):
+
+    def __init__(
+            self,
+            callback=None,
+            callback_owner=None,
+            name=None,
+            module=None,
+            file=None,
+            line=None,
+            breakpoint=None):
         Action.__init__(self, callback, callback_owner)
         self.modules = lldb.SBFileSpecList()
         self.files = lldb.SBFileSpecList()
@@ -97,7 +118,8 @@ class BreakpointAction (Action):
             if module:
                 if isinstance(module, types.ListType):
                     for module_path in module:
-                        self.modules.Append(lldb.SBFileSpec(module_path, False))
+                        self.modules.Append(
+                            lldb.SBFileSpec(module_path, False))
                 elif isinstance(module, types.StringTypes):
                     self.modules.Append(lldb.SBFileSpec(module, False))
             if name:
@@ -109,22 +131,30 @@ class BreakpointAction (Action):
                             self.files.Append(lldb.SBFileSpec(f, False))
                     elif isinstance(file, types.StringTypes):
                         self.files.Append(lldb.SBFileSpec(file, False))
-                self.breakpoints.append (self.target.BreakpointCreateByName(name, self.modules, self.files))
+                self.breakpoints.append(
+                    self.target.BreakpointCreateByName(
+                        name, self.modules, self.files))
             elif file and line:
-                self.breakpoints.append (self.target.BreakpointCreateByLocation(file, line))
-    def ThreadStopped (self, thread):
+                self.breakpoints.append(
+                    self.target.BreakpointCreateByLocation(
+                        file, line))
+
+    def ThreadStopped(self, thread):
         if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
             for bp in self.breakpoints:
                 if bp.GetID() == thread.GetStopReasonDataAtIndex(0):
                     if self.callback:
                         if self.callback_owner:
-                            self.callback (self.callback_owner, thread)
+                            self.callback(self.callback_owner, thread)
                         else:
-                            self.callback (thread)
+                            self.callback(thread)
                     return True
         return False
+
+
 class TestCase:
     """Class that aids in running performance tests."""
+
     def __init__(self):
         self.verbose = False
         self.debugger = lldb.SBDebugger.Create()
@@ -137,36 +167,37 @@ class TestCase:
         self.user_actions = list()
         self.builtin_actions = list()
         self.bp_id_to_dict = dict()
-        
+
     def Setup(self, args):
         self.launch_info = lldb.SBLaunchInfo(args)
-        
-    def Run (self, args):
+
+    def Run(self, args):
         assert False, "performance.TestCase.Run(self, args) must be subclassed"
-    
+
     def Launch(self):
         if self.target:
             error = lldb.SBError()
-            self.process = self.target.Launch (self.launch_info, error)
+            self.process = self.target.Launch(self.launch_info, error)
             if not error.Success():
                 print "error: %s" % error.GetCString()
             if self.process:
-                self.process.GetBroadcaster().AddListener(self.listener, lldb.SBProcess.eBroadcastBitStateChanged | lldb.SBProcess.eBroadcastBitInterrupt)
+                self.process.GetBroadcaster().AddListener(self.listener,
+                                                          lldb.SBProcess.eBroadcastBitStateChanged | lldb.SBProcess.eBroadcastBitInterrupt)
                 return True
         return False
-        
-    def WaitForNextProcessEvent (self):
+
+    def WaitForNextProcessEvent(self):
         event = None
         if self.process:
             while event is None:
                 process_event = lldb.SBEvent()
-                if self.listener.WaitForEvent (lldb.UINT32_MAX, process_event):
-                    state = lldb.SBProcess.GetStateFromEvent (process_event)
+                if self.listener.WaitForEvent(lldb.UINT32_MAX, process_event):
+                    state = lldb.SBProcess.GetStateFromEvent(process_event)
                     if self.verbose:
                         print "event = %s" % (lldb.SBDebugger.StateAsCString(state))
                     if lldb.SBProcess.GetRestartedFromEvent(process_event):
                         continue
-                    if state == lldb.eStateInvalid or state == lldb.eStateDetached or state == lldb.eStateCrashed or  state == lldb.eStateUnloaded or state == lldb.eStateExited:
+                    if state == lldb.eStateInvalid or state == lldb.eStateDetached or state == lldb.eStateCrashed or state == lldb.eStateUnloaded or state == lldb.eStateExited:
                         event = process_event
                         self.done = True
                     elif state == lldb.eStateConnected or state == lldb.eStateAttaching or state == lldb.eStateLaunching or state == lldb.eStateRunning or state == lldb.eStateStepping or state == lldb.eStateSuspended:
@@ -179,10 +210,10 @@ class TestCase:
                         for thread in self.process:
                             frame = thread.GetFrameAtIndex(0)
                             select_thread = False
-                            
+
                             stop_reason = thread.GetStopReason()
                             if self.verbose:
-                                print "tid = %#x pc = %#x " % (thread.GetThreadID(),frame.GetPC()),
+                                print "tid = %#x pc = %#x " % (thread.GetThreadID(), frame.GetPC()),
                             if stop_reason == lldb.eStopReasonNone:
                                 if self.verbose:
                                     print "none"
@@ -222,37 +253,53 @@ class TestCase:
                                 select_thread = True
                                 if self.verbose:
                                     print "signal %d" % (thread.GetStopReasonDataAtIndex(0))
-                            
+
                             if select_thread and not selected_thread:
                                 self.thread = thread
-                                selected_thread = self.process.SetSelectedThread(thread)
-                            
+                                selected_thread = self.process.SetSelectedThread(
+                                    thread)
+
                             for action in self.user_actions:
-                                action.ThreadStopped (thread)
-                                    
+                                action.ThreadStopped(thread)
 
                         if fatal:
-                            # if self.verbose: 
+                            # if self.verbose:
                             #     Xcode.RunCommand(self.debugger,"bt all",true)
                             sys.exit(1)
         return event
-    
+
+
 class Measurement:
     '''A class that encapsulates a measurement'''
+
     def __init__(self):
         object.__init__(self)
+
     def Measure(self):
         assert False, "performance.Measurement.Measure() must be subclassed"
-        
+
+
 class MemoryMeasurement(Measurement):
     '''A class that can measure memory statistics for a process.'''
+
     def __init__(self, pid):
         Measurement.__init__(self)
         self.pid = pid
-        self.stats = ["rprvt","rshrd","rsize","vsize","vprvt","kprvt","kshrd","faults","cow","pageins"]
-        self.command = "top -l 1 -pid %u -stats %s" % (self.pid, ",".join(self.stats))
+        self.stats = [
+            "rprvt",
+            "rshrd",
+            "rsize",
+            "vsize",
+            "vprvt",
+            "kprvt",
+            "kshrd",
+            "faults",
+            "cow",
+            "pageins"]
+        self.command = "top -l 1 -pid %u -stats %s" % (
+            self.pid, ",".join(self.stats))
         self.value = dict()
-    
+
     def Measure(self):
         output = commands.getoutput(self.command).split("\n")[-1]
         values = re.split('[-+\s]+', output)
@@ -263,14 +310,14 @@ class MemoryMeasurement(Measurement):
                     multiplier = 1024
                     stat = stat[:-1]
                 elif stat[-1] == 'M':
-                    multiplier = 1024*1024
+                    multiplier = 1024 * 1024
                     stat = stat[:-1]
                 elif stat[-1] == 'G':
-                    multiplier = 1024*1024*1024
+                    multiplier = 1024 * 1024 * 1024
                 elif stat[-1] == 'T':
-                    multiplier = 1024*1024*1024*1024
+                    multiplier = 1024 * 1024 * 1024 * 1024
                     stat = stat[:-1]
-                self.value[self.stats[idx]] = int (stat) * multiplier
+                self.value[self.stats[idx]] = int(stat) * multiplier
 
     def __str__(self):
         '''Dump the MemoryMeasurement current value'''
@@ -282,37 +329,47 @@ class MemoryMeasurement(Measurement):
         return s
 
 
-class TesterTestCase(TestCase):    
+class TesterTestCase(TestCase):
+
     def __init__(self):
         TestCase.__init__(self)
         self.verbose = True
         self.num_steps = 5
-    
-    def BreakpointHit (self, thread):
+
+    def BreakpointHit(self, thread):
         bp_id = thread.GetStopReasonDataAtIndex(0)
         loc_id = thread.GetStopReasonDataAtIndex(1)
         print "Breakpoint %i.%i hit: %s" % (bp_id, loc_id, thread.process.target.FindBreakpointByID(bp_id))
         thread.StepOver()
-    
-    def PlanComplete (self, thread):
+
+    def PlanComplete(self, thread):
         if self.num_steps > 0:
             thread.StepOver()
             self.num_steps = self.num_steps - 1
         else:
             thread.process.Kill()
 
-    def Run (self, args):
+    def Run(self, args):
         self.Setup(args)
         with Timer() as total_time:
             self.target = self.debugger.CreateTarget(args[0])
             if self.target:
                 with Timer() as breakpoint_timer:
                     bp = self.target.BreakpointCreateByName("main")
-                print('Breakpoint time = %.03f sec.' % breakpoint_timer.interval)
-                
-                self.user_actions.append (BreakpointAction(breakpoint=bp, callback=TesterTestCase.BreakpointHit, callback_owner=self))
-                self.user_actions.append (PlanCompleteAction(callback=TesterTestCase.PlanComplete, callback_owner=self))
-                
+                print(
+                    'Breakpoint time = %.03f sec.' %
+                    breakpoint_timer.interval)
+
+                self.user_actions.append(
+                    BreakpointAction(
+                        breakpoint=bp,
+                        callback=TesterTestCase.BreakpointHit,
+                        callback_owner=self))
+                self.user_actions.append(
+                    PlanCompleteAction(
+                        callback=TesterTestCase.PlanComplete,
+                        callback_owner=self))
+
                 if self.Launch():
                     while not self.done:
                         self.WaitForNextProcessEvent()
@@ -321,12 +378,12 @@ class TesterTestCase(TestCase):
             else:
                 print "error: failed to create target with '%s'" % (args[0])
         print('Total time = %.03f sec.' % total_time.interval)
-        
+
 
 if __name__ == '__main__':
     lldb.SBDebugger.Initialize()
     test = TesterTestCase()
-    test.Run (sys.argv[1:])
+    test.Run(sys.argv[1:])
     mem = MemoryMeasurement(os.getpid())
     mem.Measure()
     print str(mem)