1 /* 2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. 3 * Copyright 2011-2016, Rene Gollent, rene@gollent.com. 4 * Distributed under the terms of the MIT License. 5 */ 6 #ifndef JOBS_H 7 #define JOBS_H 8 9 #include <Entry.h> 10 #include <String.h> 11 12 #include "ImageDebugInfoLoadingState.h" 13 #include "ImageDebugInfoProvider.h" 14 #include "Types.h" 15 #include "Worker.h" 16 17 18 class Architecture; 19 class BVariant; 20 class CpuState; 21 class DebuggerInterface; 22 class ExpressionInfo; 23 class ExpressionResult; 24 class Function; 25 class FunctionInstance; 26 class Image; 27 class SourceLanguage; 28 class StackFrame; 29 class StackFrameValues; 30 class Team; 31 class TeamMemory; 32 class TeamMemoryBlock; 33 class TeamTypeInformation; 34 class Thread; 35 class Type; 36 class TypeComponentPath; 37 class Value; 38 class ValueLocation; 39 class ValueNode; 40 class ValueNodeChild; 41 class ValueNodeContainer; 42 class ValueNodeManager; 43 class Variable; 44 45 46 // job types 47 enum { 48 JOB_TYPE_GET_THREAD_STATE, 49 JOB_TYPE_GET_CPU_STATE, 50 JOB_TYPE_GET_STACK_TRACE, 51 JOB_TYPE_LOAD_IMAGE_DEBUG_INFO, 52 JOB_TYPE_LOAD_SOURCE_CODE, 53 JOB_TYPE_GET_STACK_FRAME_VALUE, 54 JOB_TYPE_RESOLVE_VALUE_NODE_VALUE, 55 JOB_TYPE_WRITE_VALUE_NODE_VALUE, 56 JOB_TYPE_GET_MEMORY_BLOCK, 57 JOB_TYPE_WRITE_MEMORY, 58 JOB_TYPE_EVALUATE_EXPRESSION, 59 JOB_TYPE_WRITE_CORE_FILE 60 }; 61 62 63 class GetThreadStateJob : public Job { 64 public: 65 GetThreadStateJob( 66 DebuggerInterface* debuggerInterface, 67 Thread* thread); 68 virtual ~GetThreadStateJob(); 69 70 virtual const JobKey& Key() const; 71 virtual status_t Do(); 72 73 private: 74 SimpleJobKey fKey; 75 DebuggerInterface* fDebuggerInterface; 76 Thread* fThread; 77 }; 78 79 80 class GetCpuStateJob : public Job { 81 public: 82 GetCpuStateJob( 83 DebuggerInterface* debuggerInterface, 84 ::Thread* thread); 85 virtual ~GetCpuStateJob(); 86 87 virtual const JobKey& Key() const; 88 virtual status_t Do(); 89 90 private: 91 SimpleJobKey fKey; 92 DebuggerInterface* fDebuggerInterface; 93 ::Thread* fThread; 94 }; 95 96 97 class GetStackTraceJob : public Job, private ImageDebugInfoProvider { 98 public: 99 GetStackTraceJob( 100 DebuggerInterface* debuggerInterface, 101 JobListener* jobListener, 102 Architecture* architecture, 103 ::Thread* thread); 104 virtual ~GetStackTraceJob(); 105 106 virtual const JobKey& Key() const; 107 virtual status_t Do(); 108 109 private: 110 // ImageDebugInfoProvider 111 virtual status_t GetImageDebugInfo(Image* image, 112 ImageDebugInfo*& _info); 113 114 private: 115 SimpleJobKey fKey; 116 DebuggerInterface* fDebuggerInterface; 117 JobListener* fJobListener; 118 Architecture* fArchitecture; 119 ::Thread* fThread; 120 CpuState* fCpuState; 121 }; 122 123 124 class LoadImageDebugInfoJob : public Job { 125 public: 126 LoadImageDebugInfoJob(Image* image); 127 virtual ~LoadImageDebugInfoJob(); 128 129 virtual const JobKey& Key() const; 130 virtual status_t Do(); 131 132 static status_t ScheduleIfNecessary(Worker* worker, 133 Image* image, 134 JobListener* jobListener, 135 ImageDebugInfo** _imageDebugInfo = NULL); 136 // If already loaded returns a 137 // reference, if desired. If not loaded 138 // schedules a job, but does not wait; 139 // returns B_OK and NULL. An error, 140 // if scheduling the job failed, or the 141 // debug info already failed to load 142 // earlier. 143 144 ImageDebugInfoLoadingState* 145 GetLoadingState() 146 { return &fState; } 147 148 private: 149 SimpleJobKey fKey; 150 Image* fImage; 151 ImageDebugInfoLoadingState 152 fState; 153 }; 154 155 156 class LoadSourceCodeJob : public Job { 157 public: 158 LoadSourceCodeJob( 159 DebuggerInterface* debuggerInterface, 160 Architecture* architecture, Team* team, 161 FunctionInstance* functionInstance, 162 bool loadForFunction); 163 virtual ~LoadSourceCodeJob(); 164 165 virtual const JobKey& Key() const; 166 virtual status_t Do(); 167 168 private: 169 SimpleJobKey fKey; 170 DebuggerInterface* fDebuggerInterface; 171 Architecture* fArchitecture; 172 Team* fTeam; 173 FunctionInstance* fFunctionInstance; 174 bool fLoadForFunction; 175 }; 176 177 178 class ResolveValueNodeValueJob : public Job { 179 public: 180 ResolveValueNodeValueJob( 181 DebuggerInterface* debuggerInterface, 182 Architecture* architecture, 183 CpuState* cpuState, 184 TeamTypeInformation* typeInformation, 185 ValueNodeContainer* container, 186 ValueNode* valueNode); 187 virtual ~ResolveValueNodeValueJob(); 188 189 virtual const JobKey& Key() const; 190 virtual status_t Do(); 191 192 private: 193 status_t _ResolveNodeValue(); 194 status_t _ResolveNodeChildLocation( 195 ValueNodeChild* nodeChild); 196 status_t _ResolveParentNodeValue(ValueNode* parentNode); 197 198 199 private: 200 SimpleJobKey fKey; 201 DebuggerInterface* fDebuggerInterface; 202 Architecture* fArchitecture; 203 CpuState* fCpuState; 204 TeamTypeInformation* 205 fTypeInformation; 206 ValueNodeContainer* fContainer; 207 ValueNode* fValueNode; 208 }; 209 210 211 class WriteValueNodeValueJob : public Job { 212 public: 213 WriteValueNodeValueJob( 214 DebuggerInterface* debuggerInterface, 215 Architecture* architecture, 216 CpuState* cpuState, 217 TeamTypeInformation* typeInformation, 218 ValueNode* valueNode, 219 Value* newValue); 220 virtual ~WriteValueNodeValueJob(); 221 222 virtual const JobKey& Key() const; 223 virtual status_t Do(); 224 225 private: 226 SimpleJobKey fKey; 227 DebuggerInterface* fDebuggerInterface; 228 Architecture* fArchitecture; 229 CpuState* fCpuState; 230 TeamTypeInformation* 231 fTypeInformation; 232 ValueNode* fValueNode; 233 Value* fNewValue; 234 }; 235 236 237 class RetrieveMemoryBlockJob : public Job { 238 public: 239 RetrieveMemoryBlockJob(Team* team, 240 TeamMemory* teamMemory, 241 TeamMemoryBlock* memoryBlock); 242 virtual ~RetrieveMemoryBlockJob(); 243 244 virtual const JobKey& Key() const; 245 virtual status_t Do(); 246 247 private: 248 SimpleJobKey fKey; 249 Team* fTeam; 250 TeamMemory* fTeamMemory; 251 TeamMemoryBlock* fMemoryBlock; 252 }; 253 254 255 class WriteMemoryJob : public Job { 256 public: 257 WriteMemoryJob(Team* team, 258 TeamMemory* teamMemory, 259 target_addr_t address, void* data, 260 target_size_t size); 261 virtual ~WriteMemoryJob(); 262 263 virtual const JobKey& Key() const; 264 virtual status_t Do(); 265 266 private: 267 SimpleJobKey fKey; 268 Team* fTeam; 269 TeamMemory* fTeamMemory; 270 target_addr_t fTargetAddress; 271 void* fData; 272 target_size_t fSize; 273 }; 274 275 276 class ExpressionEvaluationJob : public Job { 277 public: 278 ExpressionEvaluationJob(Team* team, 279 DebuggerInterface* debuggerInterface, 280 SourceLanguage* language, 281 ExpressionInfo* info, 282 StackFrame* frame, 283 Thread* thread); 284 virtual ~ExpressionEvaluationJob(); 285 286 virtual const JobKey& Key() const; 287 virtual status_t Do(); 288 289 ExpressionResult* GetResult() const { return fResultValue; } 290 291 private: 292 status_t ResolveNodeValue(ValueNode* node); 293 294 private: 295 SimpleJobKey fKey; 296 Team* fTeam; 297 DebuggerInterface* fDebuggerInterface; 298 Architecture* fArchitecture; 299 TeamTypeInformation* fTypeInformation; 300 SourceLanguage* fLanguage; 301 ExpressionInfo* fExpressionInfo; 302 StackFrame* fFrame; 303 Thread* fThread; 304 ValueNodeManager* fManager; 305 ExpressionResult* fResultValue; 306 }; 307 308 309 class WriteCoreFileJob : public Job { 310 public: 311 WriteCoreFileJob(Team* team, 312 DebuggerInterface* debuggerInterface, 313 const entry_ref& targetPath); 314 virtual ~WriteCoreFileJob(); 315 316 virtual const JobKey& Key() const; 317 virtual status_t Do(); 318 319 private: 320 SimpleJobKey fKey; 321 Team* fTeam; 322 DebuggerInterface* fDebuggerInterface; 323 entry_ref fTargetPath; 324 }; 325 326 327 #endif // JOBS_H 328