In this presentation I talked about how can we improve our application by using advanced debugging techniques

1. Advanced Debugging
Xcode
By
Ali Akhtar

2. LLDB
• Debugger in Xcode
• LLDB replaced GDB
• Xcode 5
• Clang is an "LLVM native" C/C++/Objective-C compiler

3. Optional Types

4. Raw Display

5. Static/Dynamic Types

6. Dynamic Dispatch

7. Dynamic Dispatch

8. Dynamic Dispatch
• Use final keyword
• Declaration can’t be overridden
• Allows the compiler to safely elide dynamic dispatc
indirection.
• final keyword enables the sealing of classes and
methods.

9. Dynamic Type in LLDB

10. Dynamic Type in LLDB

11. Protocol

12. Protocol

13. Protocol

14. Debugging Optimized Swift
Code

15. Objective C and Swift
Variable View

16. Objective C and Swift
Expression

17. Objective C and Swift
Expression

18. Objective C and Swift
Expression
Can’t access utcDate
Expression modify
variable of program

19. Data Formatters for Swift
Objects

20. Data Formatters for Swift
Objects

21. Uniqueness

22. Uniqueness

23. Uniqueness

24. Uniqueness

25. Commands lldb
• bugreport (full report of current app’s state)
• frame info
• refcount (shows you reference count for the specific
object)

26. Commands lldb

27. Control app’s execution
flow
• Automate debugging. Stuffs
• Speedup Debugging Process

28. Add Actions

29. Command Alias

30. Exploring Memory Address

31. Defining Reusable
Functions

32. User Defined Predicate

33. BreakPoint

34. Xcode BreakPoint

35. Multiple Locations

36. Multiple Locations

37. View Hierarchy Debugging
• Ability to inspect UI hierarchy
• app’s hierarchy, views, constraints, and view controllers, displayed as a hierarchical list
• Object inspector and size inspector

38. View Hierarchy Debugging

39. View Debugging

40. View Debugging

41. Address Sanitizer
• Track down memory violations
• Finds memory corruptions
• Finds Memory errors at runtime
• LLVM based tool for C languages and Swift
• These crashes are not deterministic

42. Limitation
• Detect memory errors at runtime
• Cannot detect memory leaks
• Cannot detect access uninitialised memory

43. Address Sanitizer
Advanced_Apple_Debugging_&_Reverse_Engineering_v2.0.pdf

44. Address Sanitizer
• strlen(s) gives you the length of the string held in
the s variable, up to the first NULL character

45. Address Sanitizer

46. use-after-free bug

47. use-after-free bug

48. Out-of-Scope
Solution
1)Variable aren’t accessed outside of their
scope
2)Allocate memory using malloc function

49. Use of Stack Memory After Function
Return

50. Use of Stack Memory After Function Return
• Function returns a pointer to its local variable
• Once the function returns, that pointer is no longer valid
• If we use we are again accessing garbage memory
• Either crash or unexpected behaviour

51. Solution
• Use pointer arguments

52. Memory Graph Debugger
• Find retain cycle
• Find memory leaks
• Pause app execution when activated
• Display objects currently in a heap
• Live Allocations uncheck when not using
• Clean build when using

53. 1) How to Use

54. 2) How to Use

55. Allocations

56. Allocations

57. Allocations

58. Memory Leaks
Controller TableView
Visible Cell
Visible Cell
Visible Cell
Visible Cell
Closure

59. Memory Leaks

60. Thinking
• Pop Controller
• Why it still in heap
• dealloc also not called
• Not a simple leak so Memory Graph Debugger don’t tell
• Using heap content we identify

61. Memory Leaks

62. Memory Leaks

63. Memory Leaks
No controller in heap content also

64. Thread Sanitizer (TSan)
Threading Issues
• Hard to consistently reproduce
• Difficult to debug (Timing matter)
• Lead to unpredictable results

65. Thread Sanitizer (TSan)
• Use of uninitialised mutexes
• Thread leak (missing pthread_join)
• Unsafe calls in signal handlers
• Unlock from wrong thread
• Data races / Race condition (access same memory
location without proper sync )
• Xcode 8

66. Thread Sanitizer (TSan)

67. Data Race

68. Reasons

69. Data Race example

70. Data Race example

71. Data Race example

72. Lazy Initialization in Objective C

73. Lazy Initialization in Swift

74. Race Condition

75. Solution

76. Swift Access Races
• Multiple threads call a mutating method on Structs
• Pass a shared variable as inout without systematic
manner
• Access races can result in unpredictable behavior

77. Swift Access Races

78. Races on Collections and
Other APIs

79. Races on Collections and
Other APIs

80. Uninitialised Mutexes
• Detects when a mutex is used before it’s initialized.
• pthread_mutex_lock(_:) or pthread_mutex_unlock(_:) is
called with a pthread_mutex_t variable that wasn’t
initialized
• Attempting to use an uninitialized mutex results in an error

81. Uninitialised Mutexes

82. Solution

83. Main Thread Checker
• Detect invalid use of AppKit, UIKit, and other APIs from a
background thread.
• Missed UI updates
• Visual defects

84. Main Thread Checker

85. Main Thread Checker

86. Static Analyzer
• Find bugs in your code before you even run your app
• Possible code paths in a few seconds, reporting potential
bugs
• Identifies areas in your code that don’t follow
recommended API

87. Static Analyzer

88. Problems
• Logic flaws, such as accessing uninitialized variables and
dereferencing null pointers
• Dead store (unused variable) flaws
• API usage flaws

89. Examples