1 /* 2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 #include "StackFrame.h" 7 8 #include <new> 9 10 #include "CpuState.h" 11 #include "FunctionInstance.h" 12 #include "Image.h" 13 #include "StackFrameDebugInfo.h" 14 #include "StackFrameValueInfos.h" 15 #include "StackFrameValues.h" 16 #include "Variable.h" 17 18 19 // #pragma mark - StackFrame 20 21 22 StackFrame::StackFrame(stack_frame_type type, CpuState* cpuState, 23 target_addr_t frameAddress, target_addr_t instructionPointer, 24 StackFrameDebugInfo* debugInfo) 25 : 26 fType(type), 27 fCpuState(cpuState), 28 fPreviousCpuState(NULL), 29 fFrameAddress(frameAddress), 30 fInstructionPointer(instructionPointer), 31 fReturnAddress(0), 32 fDebugInfo(debugInfo), 33 fImage(NULL), 34 fFunction(NULL), 35 fValues(NULL), 36 fValueInfos(NULL) 37 { 38 fCpuState->AcquireReference(); 39 fDebugInfo->AcquireReference(); 40 } 41 42 43 StackFrame::~StackFrame() 44 { 45 for (int32 i = 0; Variable* variable = fParameters.ItemAt(i); i++) 46 variable->ReleaseReference(); 47 48 for (int32 i = 0; Variable* variable = fLocalVariables.ItemAt(i); i++) 49 variable->ReleaseReference(); 50 51 SetImage(NULL); 52 SetFunction(NULL); 53 SetPreviousCpuState(NULL); 54 55 fDebugInfo->ReleaseReference(); 56 fCpuState->ReleaseReference(); 57 } 58 59 60 status_t 61 StackFrame::Init() 62 { 63 // create values map 64 fValues = new(std::nothrow) StackFrameValues; 65 if (fValues == NULL) 66 return B_NO_MEMORY; 67 68 status_t error = fValues->Init(); 69 if (error != B_OK) 70 return error; 71 72 // create value infos map 73 fValueInfos = new(std::nothrow) StackFrameValueInfos; 74 if (fValueInfos == NULL) 75 return B_NO_MEMORY; 76 77 error = fValueInfos->Init(); 78 if (error != B_OK) 79 return error; 80 81 return B_OK; 82 } 83 84 85 void 86 StackFrame::SetPreviousCpuState(CpuState* state) 87 { 88 if (fPreviousCpuState != NULL) 89 fPreviousCpuState->ReleaseReference(); 90 91 fPreviousCpuState = state; 92 93 if (fPreviousCpuState != NULL) 94 fPreviousCpuState->AcquireReference(); 95 } 96 97 void 98 StackFrame::SetReturnAddress(target_addr_t address) 99 { 100 fReturnAddress = address; 101 } 102 103 104 void 105 StackFrame::SetImage(Image* image) 106 { 107 if (fImage != NULL) 108 fImage->ReleaseReference(); 109 110 fImage = image; 111 112 if (fImage != NULL) 113 fImage->AcquireReference(); 114 } 115 116 117 void 118 StackFrame::SetFunction(FunctionInstance* function) 119 { 120 if (fFunction != NULL) 121 fFunction->ReleaseReference(); 122 123 fFunction = function; 124 125 if (fFunction != NULL) 126 fFunction->AcquireReference(); 127 } 128 129 130 int32 131 StackFrame::CountParameters() const 132 { 133 return fParameters.CountItems(); 134 } 135 136 137 Variable* 138 StackFrame::ParameterAt(int32 index) const 139 { 140 return fParameters.ItemAt(index); 141 } 142 143 144 bool 145 StackFrame::AddParameter(Variable* parameter) 146 { 147 if (!fParameters.AddItem(parameter)) 148 return false; 149 150 parameter->AcquireReference(); 151 return true; 152 } 153 154 155 int32 156 StackFrame::CountLocalVariables() const 157 { 158 return fLocalVariables.CountItems(); 159 } 160 161 162 Variable* 163 StackFrame::LocalVariableAt(int32 index) const 164 { 165 return fLocalVariables.ItemAt(index); 166 } 167 168 169 bool 170 StackFrame::AddLocalVariable(Variable* variable) 171 { 172 if (!fLocalVariables.AddItem(variable)) 173 return false; 174 175 variable->AcquireReference(); 176 return true; 177 } 178 179 180 void 181 StackFrame::AddListener(Listener* listener) 182 { 183 fListeners.Add(listener); 184 } 185 186 187 void 188 StackFrame::RemoveListener(Listener* listener) 189 { 190 fListeners.Remove(listener); 191 } 192 193 194 void 195 StackFrame::NotifyValueRetrieved(Variable* variable, TypeComponentPath* path) 196 { 197 for (ListenerList::Iterator it = fListeners.GetIterator(); 198 Listener* listener = it.Next();) { 199 listener->StackFrameValueRetrieved(this, variable, path); 200 } 201 } 202 203 204 // #pragma mark - StackFrame 205 206 207 StackFrame::Listener::~Listener() 208 { 209 } 210 211 212 void 213 StackFrame::Listener::StackFrameValueRetrieved(StackFrame* stackFrame, 214 Variable* variable, TypeComponentPath* path) 215 { 216 } 217