1 //===-- ThreadPlanCallFunction.h --------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef liblldb_ThreadPlanCallFunction_h_ 11 #define liblldb_ThreadPlanCallFunction_h_ 12 13 // C Includes 14 // C++ Includes 15 // Other libraries and framework includes 16 // Project includes 17 #include "lldb/lldb-private.h" 18 #include "lldb/Target/Thread.h" 19 #include "lldb/Target/ThreadPlan.h" 20 21 #include "llvm/ADT/ArrayRef.h" 22 23 namespace lldb_private { 24 25 class ThreadPlanCallFunction : public ThreadPlan 26 { 27 // Create a thread plan to call a function at the address passed in the "function" 28 // argument. If you plan to call GetReturnValueObject, then pass in the 29 // return type, otherwise just pass in an invalid ClangASTType. 30 public: 31 ThreadPlanCallFunction (Thread &thread, 32 const Address &function, 33 const ClangASTType &return_type, 34 llvm::ArrayRef<lldb::addr_t> args, 35 const EvaluateExpressionOptions &options); 36 37 virtual 38 ~ThreadPlanCallFunction (); 39 40 virtual void 41 GetDescription (Stream *s, lldb::DescriptionLevel level); 42 43 virtual bool 44 ValidatePlan (Stream *error); 45 46 virtual bool 47 ShouldStop (Event *event_ptr); 48 49 virtual Vote 50 ShouldReportStop(Event *event_ptr); 51 52 virtual bool 53 StopOthers (); 54 55 virtual void 56 SetStopOthers (bool new_value); 57 58 virtual lldb::StateType 59 GetPlanRunState (); 60 61 virtual void 62 DidPush (); 63 64 virtual bool 65 WillStop (); 66 67 virtual bool 68 MischiefManaged (); 69 70 // To get the return value from a function call you must create a 71 // lldb::ValueSP that contains a valid clang type in its context and call 72 // RequestReturnValue. The ValueSP will be stored and when the function is 73 // done executing, the object will check if there is a requested return 74 // value. If there is, the return value will be retrieved using the 75 // ABI::GetReturnValue() for the ABI in the process. Then after the thread 76 // plan is complete, you can call "GetReturnValue()" to retrieve the value 77 // that was extracted. 78 79 virtual lldb::ValueObjectSP GetReturnValueObject()80 GetReturnValueObject () 81 { 82 return m_return_valobj_sp; 83 } 84 85 // Return the stack pointer that the function received 86 // on entry. Any stack address below this should be 87 // considered invalid after the function has been 88 // cleaned up. 89 lldb::addr_t GetFunctionStackPointer()90 GetFunctionStackPointer() 91 { 92 return m_function_sp; 93 } 94 95 // Classes that derive from ClangFunction, and implement 96 // their own WillPop methods should call this so that the 97 // thread state gets restored if the plan gets discarded. 98 virtual void 99 WillPop (); 100 101 // If the thread plan stops mid-course, this will be the stop reason that interrupted us. 102 // Once DoTakedown is called, this will be the real stop reason at the end of the function call. 103 // If it hasn't been set for one or the other of these reasons, we'll return the PrivateStopReason. 104 // This is needed because we want the CallFunction thread plans not to show up as the stop reason. 105 // But if something bad goes wrong, it is nice to be able to tell the user what really happened. 106 107 virtual lldb::StopInfoSP GetRealStopInfo()108 GetRealStopInfo() 109 { 110 if (m_real_stop_info_sp) 111 return m_real_stop_info_sp; 112 else 113 return GetPrivateStopInfo (); 114 } 115 116 lldb::addr_t GetStopAddress()117 GetStopAddress () 118 { 119 return m_stop_address; 120 } 121 122 virtual bool 123 RestoreThreadState(); 124 125 virtual void ThreadDestroyed()126 ThreadDestroyed () 127 { 128 m_takedown_done = true; 129 } 130 131 protected: 132 void ReportRegisterState (const char *message); 133 134 virtual bool 135 DoPlanExplainsStop (Event *event_ptr); 136 137 private: 138 139 bool 140 ConstructorSetup (Thread &thread, 141 ABI *& abi, 142 lldb::addr_t &start_load_addr, 143 lldb::addr_t &function_load_addr); 144 145 void 146 DoTakedown (bool success); 147 148 void 149 SetBreakpoints (); 150 151 void 152 ClearBreakpoints (); 153 154 bool 155 BreakpointsExplainStop (); 156 157 bool m_valid; 158 bool m_stop_other_threads; 159 bool m_unwind_on_error; 160 bool m_ignore_breakpoints; 161 bool m_debug_execution; 162 bool m_trap_exceptions; 163 Address m_function_addr; 164 Address m_start_addr; 165 lldb::addr_t m_function_sp; 166 lldb::ThreadPlanSP m_subplan_sp; 167 LanguageRuntime *m_cxx_language_runtime; 168 LanguageRuntime *m_objc_language_runtime; 169 Thread::ThreadStateCheckpoint m_stored_thread_state; 170 lldb::StopInfoSP m_real_stop_info_sp; // In general we want to hide call function 171 // thread plans, but for reporting purposes, 172 // it's nice to know the real stop reason. 173 // This gets set in DoTakedown. 174 StreamString m_constructor_errors; 175 ClangASTType m_return_type; 176 lldb::ValueObjectSP m_return_valobj_sp; // If this contains a valid pointer, use the ABI to extract values when complete 177 bool m_takedown_done; // We want to ensure we only do the takedown once. This ensures that. 178 bool m_should_clear_objc_exception_bp; 179 bool m_should_clear_cxx_exception_bp; 180 lldb::addr_t m_stop_address; // This is the address we stopped at. Also set in DoTakedown; 181 182 DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunction); 183 }; 184 185 } // namespace lldb_private 186 187 #endif // liblldb_ThreadPlanCallFunction_h_ 188