blob: d0dd4a5f0221745f061cbf935507999b2ecce9cf [file] [log] [blame]
Chris Lattner24943d22010-06-08 16:52:24 +00001//===-- ClangExpressionDeclMap.cpp -----------------------------*- 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#include "lldb/Expression/ClangExpressionDeclMap.h"
11
12// C Includes
13// C++ Includes
14// Other libraries and framework includes
15// Project includes
Sean Callanan47a5c4c2010-09-23 03:01:22 +000016#include "clang/AST/DeclarationName.h"
Sean Callanana0744822010-11-01 23:22:47 +000017#include "clang/AST/Decl.h"
Chris Lattner24943d22010-06-08 16:52:24 +000018#include "lldb/lldb-private.h"
19#include "lldb/Core/Address.h"
Sean Callanan810f22d2010-07-16 00:09:46 +000020#include "lldb/Core/Error.h"
Sean Callanan6184dfe2010-06-23 00:47:48 +000021#include "lldb/Core/Log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000022#include "lldb/Core/Module.h"
Greg Clayton061b79d2011-05-09 20:18:18 +000023#include "lldb/Core/RegisterValue.h"
Sean Callanan05a5a1b2010-12-16 03:17:46 +000024#include "lldb/Core/ValueObjectConstResult.h"
Sean Callanan6e74dbb2011-02-01 23:43:26 +000025#include "lldb/Expression/ASTDumper.h"
Chris Lattner24943d22010-06-08 16:52:24 +000026#include "lldb/Expression/ClangASTSource.h"
Sean Callanana48fe162010-08-11 03:57:18 +000027#include "lldb/Expression/ClangPersistentVariables.h"
Greg Claytoncd548032011-02-01 01:31:41 +000028#include "lldb/Host/Endian.h"
Chris Lattner24943d22010-06-08 16:52:24 +000029#include "lldb/Symbol/ClangASTContext.h"
Greg Clayton6916e352010-11-13 03:52:47 +000030#include "lldb/Symbol/ClangNamespaceDecl.h"
Chris Lattner24943d22010-06-08 16:52:24 +000031#include "lldb/Symbol/CompileUnit.h"
32#include "lldb/Symbol/Function.h"
33#include "lldb/Symbol/ObjectFile.h"
34#include "lldb/Symbol/SymbolContext.h"
35#include "lldb/Symbol/Type.h"
36#include "lldb/Symbol/TypeList.h"
37#include "lldb/Symbol/Variable.h"
38#include "lldb/Symbol/VariableList.h"
Sean Callananf328c9f2010-07-20 23:31:16 +000039#include "lldb/Target/ExecutionContext.h"
Sean Callanan810f22d2010-07-16 00:09:46 +000040#include "lldb/Target/Process.h"
Sean Callanan17c6a052010-10-05 20:18:48 +000041#include "lldb/Target/RegisterContext.h"
Chris Lattner24943d22010-06-08 16:52:24 +000042#include "lldb/Target/StackFrame.h"
Sean Callananf328c9f2010-07-20 23:31:16 +000043#include "lldb/Target/Target.h"
Jim Ingham78b9ee82010-12-07 01:56:02 +000044#include "lldb/Target/Thread.h"
Sean Callanana0744822010-11-01 23:22:47 +000045#include "llvm/Support/raw_ostream.h"
Chris Lattner24943d22010-06-08 16:52:24 +000046
Greg Clayton3bc52d02010-11-14 22:13:40 +000047using namespace lldb;
Chris Lattner24943d22010-06-08 16:52:24 +000048using namespace lldb_private;
49using namespace clang;
50
Sean Callanan6a925532011-01-13 08:53:35 +000051ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory) :
Greg Clayton8de27c72010-10-15 22:48:33 +000052 m_found_entities (),
53 m_struct_members (),
Stephen Wilsondbeb3e12011-04-11 19:41:40 +000054 m_keep_result_in_memory (keep_result_in_memory),
Sean Callananaa301c42010-12-03 01:38:59 +000055 m_parser_vars (),
Stephen Wilsondbeb3e12011-04-11 19:41:40 +000056 m_struct_vars ()
Chris Lattner24943d22010-06-08 16:52:24 +000057{
Sean Callananaa301c42010-12-03 01:38:59 +000058 EnableStructVars();
Chris Lattner24943d22010-06-08 16:52:24 +000059}
60
61ClangExpressionDeclMap::~ClangExpressionDeclMap()
Sean Callananaa301c42010-12-03 01:38:59 +000062{
63 DidDematerialize();
64 DisableStructVars();
65}
Sean Callananc2c6f772010-10-26 00:31:56 +000066
Sean Callanan166ba102011-08-01 18:18:33 +000067bool
Greg Clayton427f2902010-12-14 02:59:59 +000068ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx)
Sean Callananaa301c42010-12-03 01:38:59 +000069{
70 EnableParserVars();
71 m_parser_vars->m_exe_ctx = &exe_ctx;
Sean Callanan166ba102011-08-01 18:18:33 +000072
Sean Callananaa301c42010-12-03 01:38:59 +000073 if (exe_ctx.frame)
74 m_parser_vars->m_sym_ctx = exe_ctx.frame->GetSymbolContext(lldb::eSymbolContextEverything);
Jim Ingham78b9ee82010-12-07 01:56:02 +000075 else if (exe_ctx.thread)
76 m_parser_vars->m_sym_ctx = exe_ctx.thread->GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
Jim Inghamef80aab2011-05-02 18:13:59 +000077 else if (exe_ctx.process)
78 m_parser_vars->m_sym_ctx = SymbolContext(exe_ctx.target->GetSP(), ModuleSP());
Sean Callanan97ad47f2011-09-15 18:41:04 +000079 else if (exe_ctx.target)
80 m_parser_vars->m_sym_ctx = SymbolContext(exe_ctx.target->GetSP(), ModuleSP());
81
Greg Clayton427f2902010-12-14 02:59:59 +000082 if (exe_ctx.target)
83 m_parser_vars->m_persistent_vars = &exe_ctx.target->GetPersistentVariables();
Sean Callanan166ba102011-08-01 18:18:33 +000084
85 if (exe_ctx.target && !exe_ctx.target->GetScratchClangASTContext())
86 return false;
87
Sean Callanan47dc4572011-09-15 02:13:07 +000088 m_parser_vars->m_target_info = GetTargetInfo();
89
Sean Callanan166ba102011-08-01 18:18:33 +000090 return true;
Sean Callananaa301c42010-12-03 01:38:59 +000091}
92
Greg Clayton427f2902010-12-14 02:59:59 +000093void
94ClangExpressionDeclMap::DidParse()
Sean Callananaa301c42010-12-03 01:38:59 +000095{
96 if (m_parser_vars.get())
97 {
Greg Clayton427f2902010-12-14 02:59:59 +000098 for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +000099 entity_index < num_entities;
100 ++entity_index)
101 {
Greg Clayton427f2902010-12-14 02:59:59 +0000102 ClangExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
103 if (var_sp &&
104 var_sp->m_parser_vars.get() &&
105 var_sp->m_parser_vars->m_lldb_value)
106 delete var_sp->m_parser_vars->m_lldb_value;
Sean Callananaa301c42010-12-03 01:38:59 +0000107
Greg Clayton427f2902010-12-14 02:59:59 +0000108 var_sp->DisableParserVars();
Sean Callananaa301c42010-12-03 01:38:59 +0000109 }
110
Greg Clayton427f2902010-12-14 02:59:59 +0000111 for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +0000112 pvar_index < num_pvars;
113 ++pvar_index)
114 {
Greg Clayton427f2902010-12-14 02:59:59 +0000115 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
116 if (pvar_sp)
117 pvar_sp->DisableParserVars();
Sean Callananaa301c42010-12-03 01:38:59 +0000118 }
119
120 DisableParserVars();
Sean Callanan7a60b942010-10-08 01:58:41 +0000121 }
Chris Lattner24943d22010-06-08 16:52:24 +0000122}
123
Sean Callanan8bce6652010-07-13 21:41:46 +0000124// Interface for IRForTarget
125
Sean Callanan47dc4572011-09-15 02:13:07 +0000126ClangExpressionDeclMap::TargetInfo
127ClangExpressionDeclMap::GetTargetInfo()
128{
129 assert (m_parser_vars.get());
130
131 TargetInfo ret;
132
133 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
134
135 if (exe_ctx->process)
136 {
137 ret.byte_order = exe_ctx->process->GetByteOrder();
138 ret.address_byte_size = exe_ctx->process->GetAddressByteSize();
139 }
140 else if (exe_ctx->target)
141 {
142 ret.byte_order = exe_ctx->target->GetArchitecture().GetByteOrder();
143 ret.address_byte_size = exe_ctx->target->GetArchitecture().GetAddressByteSize();
144 }
145
146 return ret;
147}
148
Greg Clayton8de27c72010-10-15 22:48:33 +0000149const ConstString &
150ClangExpressionDeclMap::GetPersistentResultName ()
Sean Callanan82b74c82010-08-12 01:56:52 +0000151{
Sean Callananaa301c42010-12-03 01:38:59 +0000152 assert (m_struct_vars.get());
153 assert (m_parser_vars.get());
Sean Callananaa301c42010-12-03 01:38:59 +0000154 if (!m_struct_vars->m_result_name)
Greg Clayton427f2902010-12-14 02:59:59 +0000155 {
156 Target *target = m_parser_vars->GetTarget();
157 assert (target);
158 m_struct_vars->m_result_name = target->GetPersistentVariables().GetNextPersistentVariableName();
159 }
Sean Callananaa301c42010-12-03 01:38:59 +0000160 return m_struct_vars->m_result_name;
Sean Callanan82b74c82010-08-12 01:56:52 +0000161}
162
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000163lldb::ClangExpressionVariableSP
164ClangExpressionDeclMap::BuildIntegerVariable (const ConstString &name,
165 lldb_private::TypeFromParser type,
166 const llvm::APInt& value)
167{
168 assert (m_parser_vars.get());
Sean Callanan166ba102011-08-01 18:18:33 +0000169
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000170 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
Sean Callanan9b6898f2011-07-30 02:42:06 +0000171 ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000172
173 TypeFromUser user_type(ClangASTContext::CopyType(context,
174 type.GetASTContext(),
175 type.GetOpaqueQualType()),
176 context);
Sean Callanan47dc4572011-09-15 02:13:07 +0000177
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000178 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx->GetBestExecutionContextScope (),
179 name,
Sean Callanan0e0817d2011-01-04 02:41:41 +0000180 user_type,
Sean Callanan47dc4572011-09-15 02:13:07 +0000181 m_parser_vars->m_target_info.byte_order,
182 m_parser_vars->m_target_info.address_byte_size))
Sean Callanan0e0817d2011-01-04 02:41:41 +0000183 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000184
Sean Callanan0e0817d2011-01-04 02:41:41 +0000185 ClangExpressionVariableSP pvar_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
186
187 if (!pvar_sp)
188 return lldb::ClangExpressionVariableSP();
189
190 uint8_t *pvar_data = pvar_sp->GetValueBytes();
191 if (pvar_data == NULL)
192 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000193
194 uint64_t value64 = value.getLimitedValue();
Sean Callanan47dc4572011-09-15 02:13:07 +0000195
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000196 size_t num_val_bytes = sizeof(value64);
Sean Callanan0e0817d2011-01-04 02:41:41 +0000197 size_t num_data_bytes = pvar_sp->GetByteSize();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000198
199 size_t num_bytes = num_val_bytes;
200 if (num_bytes > num_data_bytes)
201 num_bytes = num_data_bytes;
202
Johnny Chen2bc9eb32011-07-19 19:48:13 +0000203 for (size_t byte_idx = 0;
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000204 byte_idx < num_bytes;
205 ++byte_idx)
206 {
207 uint64_t shift = byte_idx * 8;
208 uint64_t mask = 0xffll << shift;
209 uint8_t cur_byte = (uint8_t)((value64 & mask) >> shift);
210
Sean Callanan47dc4572011-09-15 02:13:07 +0000211 switch (m_parser_vars->m_target_info.byte_order)
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000212 {
Sean Callanan0e0817d2011-01-04 02:41:41 +0000213 case eByteOrderBig:
214 // High Low
215 // Original: |AABBCCDDEEFFGGHH|
216 // Target: |EEFFGGHH|
217
218 pvar_data[num_data_bytes - (1 + byte_idx)] = cur_byte;
219 break;
220 case eByteOrderLittle:
221 // Target: |HHGGFFEE|
222 pvar_data[byte_idx] = cur_byte;
223 break;
224 default:
225 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000226 }
227 }
Sean Callanan6a925532011-01-13 08:53:35 +0000228
229 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
Sean Callanan696cf5f2011-05-07 01:06:41 +0000230 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
231 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
Sean Callanan0e0817d2011-01-04 02:41:41 +0000232
233 return pvar_sp;
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000234}
235
Sean Callanan696cf5f2011-05-07 01:06:41 +0000236lldb::ClangExpressionVariableSP
237ClangExpressionDeclMap::BuildCastVariable (const ConstString &name,
Sean Callanan9b6898f2011-07-30 02:42:06 +0000238 VarDecl *decl,
Sean Callanan696cf5f2011-05-07 01:06:41 +0000239 lldb_private::TypeFromParser type)
240{
241 assert (m_parser_vars.get());
242
243 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
244
245 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
Sean Callanan9b6898f2011-07-30 02:42:06 +0000246 ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
Sean Callanan696cf5f2011-05-07 01:06:41 +0000247
248 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl));
249
250 if (!var_sp)
251 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl);
252
253 if (!var_sp)
254 return ClangExpressionVariableSP();
255
256 TypeFromUser user_type(ClangASTContext::CopyType(context,
257 type.GetASTContext(),
258 type.GetOpaqueQualType()),
259 context);
260
261 TypeFromUser var_type = var_sp->GetTypeFromUser();
262
263 VariableSP var = FindVariableInScope (*exe_ctx->frame, var_sp->GetName(), &var_type);
264
265 if (!var)
266 return lldb::ClangExpressionVariableSP(); // but we should handle this; it may be a persistent variable
267
268 ValueObjectSP var_valobj = exe_ctx->frame->GetValueObjectForFrameVariable(var, lldb::eNoDynamicValues);
269
270 if (!var_valobj)
271 return lldb::ClangExpressionVariableSP();
272
273 ValueObjectSP var_casted_valobj = var_valobj->CastPointerType(name.GetCString(), user_type);
274
275 if (!var_casted_valobj)
276 return lldb::ClangExpressionVariableSP();
277
278 if (log)
279 {
280 StreamString my_stream_string;
281
282 ClangASTType::DumpTypeDescription (var_type.GetASTContext(),
283 var_type.GetOpaqueQualType(),
284 &my_stream_string);
285
286
287 log->Printf("Building cast variable to type: %s", my_stream_string.GetString().c_str());
288 }
289
290 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->CreatePersistentVariable (var_casted_valobj);
291
292 if (!pvar_sp)
293 return lldb::ClangExpressionVariableSP();
294
295 if (pvar_sp != m_parser_vars->m_persistent_vars->GetVariable(name))
296 return lldb::ClangExpressionVariableSP();
297
298 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
299 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
300 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
301
302 return pvar_sp;
303}
304
Sean Callanan47dc4572011-09-15 02:13:07 +0000305bool
306ClangExpressionDeclMap::ResultIsReference (const ConstString &name)
307{
308 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->GetVariable(name);
309
310 return (pvar_sp->m_flags & ClangExpressionVariable::EVIsProgramReference);
311}
312
313bool
314ClangExpressionDeclMap::CompleteResultVariable (lldb::ClangExpressionVariableSP &valobj,
315 lldb_private::Value &value,
316 const ConstString &name,
317 lldb_private::TypeFromParser type)
318{
319 assert (m_parser_vars.get());
320
321 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->GetVariable(name);
322
323 if (!pvar_sp)
324 return false;
325
326 if (pvar_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
327 !pvar_sp->m_live_sp)
328 {
329 // The reference comes from the program. We need to set up a live SP for it.
330
331 pvar_sp->m_live_sp = ValueObjectConstResult::Create(m_parser_vars->m_exe_ctx->GetBestExecutionContextScope(),
332 pvar_sp->GetTypeFromUser().GetASTContext(),
333 pvar_sp->GetTypeFromUser().GetOpaqueQualType(),
334 pvar_sp->GetName(),
335 value.GetScalar().ULongLong(),
336 value.GetValueAddressType(),
337 pvar_sp->GetByteSize());
338 }
339
340 if (pvar_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry)
341 {
342 pvar_sp->ValueUpdated();
343
344 const size_t pvar_byte_size = pvar_sp->GetByteSize();
345 uint8_t *pvar_data = pvar_sp->GetValueBytes();
346
347 if (!ReadTarget(pvar_data, value, pvar_byte_size))
348 return false;
349
350 pvar_sp->m_flags &= ~(ClangExpressionVariable::EVNeedsFreezeDry);
351 }
352
353 valobj = pvar_sp;
354
355 return true;
356}
357
Sean Callanan8bce6652010-07-13 21:41:46 +0000358bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000359ClangExpressionDeclMap::AddPersistentVariable
360(
Sean Callanan9b6898f2011-07-30 02:42:06 +0000361 const NamedDecl *decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000362 const ConstString &name,
Sean Callanan6a925532011-01-13 08:53:35 +0000363 TypeFromParser parser_type,
364 bool is_result,
365 bool is_lvalue
Greg Clayton8de27c72010-10-15 22:48:33 +0000366)
Sean Callanana48fe162010-08-11 03:57:18 +0000367{
Sean Callananaa301c42010-12-03 01:38:59 +0000368 assert (m_parser_vars.get());
369
Sean Callanan6a925532011-01-13 08:53:35 +0000370 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000371 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
Sean Callanan6a925532011-01-13 08:53:35 +0000372
Sean Callanan9b6898f2011-07-30 02:42:06 +0000373 ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
Sean Callanana48fe162010-08-11 03:57:18 +0000374
Sean Callanana48fe162010-08-11 03:57:18 +0000375 TypeFromUser user_type(ClangASTContext::CopyType(context,
Sean Callanan82b74c82010-08-12 01:56:52 +0000376 parser_type.GetASTContext(),
377 parser_type.GetOpaqueQualType()),
Sean Callanan97678d12011-01-13 21:23:32 +0000378 context);
Sean Callanan47dc4572011-09-15 02:13:07 +0000379
380 if (!m_parser_vars->m_target_info.IsValid())
381 return false;
Sean Callanana48fe162010-08-11 03:57:18 +0000382
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000383 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx->GetBestExecutionContextScope (),
384 name,
Greg Clayton427f2902010-12-14 02:59:59 +0000385 user_type,
Sean Callanan47dc4572011-09-15 02:13:07 +0000386 m_parser_vars->m_target_info.byte_order,
387 m_parser_vars->m_target_info.address_byte_size))
Sean Callanan8c127202010-08-23 23:09:38 +0000388 return false;
389
Greg Clayton427f2902010-12-14 02:59:59 +0000390 ClangExpressionVariableSP var_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
Sean Callanan8c127202010-08-23 23:09:38 +0000391
Greg Clayton427f2902010-12-14 02:59:59 +0000392 if (!var_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000393 return false;
394
Sean Callanan6a925532011-01-13 08:53:35 +0000395 if (is_result)
396 var_sp->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
397 else
398 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
399
400 if (is_lvalue)
401 {
402 var_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
403 }
404 else
405 {
406 var_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
407 var_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
408 }
409
410 if (log)
411 log->Printf("Created persistent variable with flags 0x%hx", var_sp->m_flags);
412
Greg Clayton427f2902010-12-14 02:59:59 +0000413 var_sp->EnableParserVars();
Sean Callanan8c127202010-08-23 23:09:38 +0000414
Greg Clayton427f2902010-12-14 02:59:59 +0000415 var_sp->m_parser_vars->m_named_decl = decl;
416 var_sp->m_parser_vars->m_parser_type = parser_type;
Sean Callanan8c127202010-08-23 23:09:38 +0000417
418 return true;
Sean Callanana48fe162010-08-11 03:57:18 +0000419}
420
421bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000422ClangExpressionDeclMap::AddValueToStruct
423(
Sean Callanan9b6898f2011-07-30 02:42:06 +0000424 const NamedDecl *decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000425 const ConstString &name,
426 llvm::Value *value,
427 size_t size,
428 off_t alignment
429)
Sean Callanan8bce6652010-07-13 21:41:46 +0000430{
Sean Callananaa301c42010-12-03 01:38:59 +0000431 assert (m_struct_vars.get());
432 assert (m_parser_vars.get());
433
Greg Claytone005f2c2010-11-06 01:53:30 +0000434 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan45690fe2010-08-30 22:17:16 +0000435
Sean Callananaa301c42010-12-03 01:38:59 +0000436 m_struct_vars->m_struct_laid_out = false;
Sean Callanan8bce6652010-07-13 21:41:46 +0000437
Sean Callanan8c127202010-08-23 23:09:38 +0000438 if (m_struct_members.GetVariable(decl))
439 return true;
Sean Callanan8bce6652010-07-13 21:41:46 +0000440
Greg Clayton427f2902010-12-14 02:59:59 +0000441 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl));
Sean Callanan8bce6652010-07-13 21:41:46 +0000442
Greg Clayton427f2902010-12-14 02:59:59 +0000443 if (!var_sp)
444 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl);
Sean Callanan8bce6652010-07-13 21:41:46 +0000445
Greg Clayton427f2902010-12-14 02:59:59 +0000446 if (!var_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000447 return false;
448
Sean Callanan45690fe2010-08-30 22:17:16 +0000449 if (log)
450 log->Printf("Adding value for decl %p [%s - %s] to the structure",
451 decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000452 name.GetCString(),
Greg Clayton427f2902010-12-14 02:59:59 +0000453 var_sp->GetName().GetCString());
Sean Callanan45690fe2010-08-30 22:17:16 +0000454
Sean Callanan8c127202010-08-23 23:09:38 +0000455 // We know entity->m_parser_vars is valid because we used a parser variable
456 // to find it
Greg Clayton427f2902010-12-14 02:59:59 +0000457 var_sp->m_parser_vars->m_llvm_value = value;
Sean Callanan8c127202010-08-23 23:09:38 +0000458
Greg Clayton427f2902010-12-14 02:59:59 +0000459 var_sp->EnableJITVars();
460 var_sp->m_jit_vars->m_alignment = alignment;
461 var_sp->m_jit_vars->m_size = size;
Sean Callanan8c127202010-08-23 23:09:38 +0000462
Greg Clayton427f2902010-12-14 02:59:59 +0000463 m_struct_members.AddVariable(var_sp);
Sean Callanan8bce6652010-07-13 21:41:46 +0000464
465 return true;
466}
467
468bool
469ClangExpressionDeclMap::DoStructLayout ()
470{
Sean Callananaa301c42010-12-03 01:38:59 +0000471 assert (m_struct_vars.get());
472
473 if (m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000474 return true;
475
Sean Callanan8bce6652010-07-13 21:41:46 +0000476 off_t cursor = 0;
477
Sean Callananaa301c42010-12-03 01:38:59 +0000478 m_struct_vars->m_struct_alignment = 0;
479 m_struct_vars->m_struct_size = 0;
Sean Callanan8bce6652010-07-13 21:41:46 +0000480
Greg Clayton427f2902010-12-14 02:59:59 +0000481 for (size_t member_index = 0, num_members = m_struct_members.GetSize();
Sean Callanan8c127202010-08-23 23:09:38 +0000482 member_index < num_members;
483 ++member_index)
Sean Callanan8bce6652010-07-13 21:41:46 +0000484 {
Greg Clayton427f2902010-12-14 02:59:59 +0000485 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
486 if (!member_sp)
487 return false;
488
489 if (!member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +0000490 return false;
Sean Callanan8bce6652010-07-13 21:41:46 +0000491
Sean Callanan8c127202010-08-23 23:09:38 +0000492 if (member_index == 0)
Greg Clayton427f2902010-12-14 02:59:59 +0000493 m_struct_vars->m_struct_alignment = member_sp->m_jit_vars->m_alignment;
Sean Callanan8c127202010-08-23 23:09:38 +0000494
Greg Clayton427f2902010-12-14 02:59:59 +0000495 if (cursor % member_sp->m_jit_vars->m_alignment)
496 cursor += (member_sp->m_jit_vars->m_alignment - (cursor % member_sp->m_jit_vars->m_alignment));
Sean Callanan8c127202010-08-23 23:09:38 +0000497
Greg Clayton427f2902010-12-14 02:59:59 +0000498 member_sp->m_jit_vars->m_offset = cursor;
499 cursor += member_sp->m_jit_vars->m_size;
Sean Callanan8bce6652010-07-13 21:41:46 +0000500 }
501
Sean Callananaa301c42010-12-03 01:38:59 +0000502 m_struct_vars->m_struct_size = cursor;
Sean Callanan8bce6652010-07-13 21:41:46 +0000503
Sean Callananaa301c42010-12-03 01:38:59 +0000504 m_struct_vars->m_struct_laid_out = true;
Sean Callanan8bce6652010-07-13 21:41:46 +0000505 return true;
506}
507
Greg Clayton8de27c72010-10-15 22:48:33 +0000508bool ClangExpressionDeclMap::GetStructInfo
509(
510 uint32_t &num_elements,
511 size_t &size,
512 off_t &alignment
513)
Sean Callanan8bce6652010-07-13 21:41:46 +0000514{
Sean Callananaa301c42010-12-03 01:38:59 +0000515 assert (m_struct_vars.get());
516
517 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000518 return false;
519
Greg Clayton427f2902010-12-14 02:59:59 +0000520 num_elements = m_struct_members.GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +0000521 size = m_struct_vars->m_struct_size;
522 alignment = m_struct_vars->m_struct_alignment;
Sean Callanan8bce6652010-07-13 21:41:46 +0000523
524 return true;
525}
526
527bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000528ClangExpressionDeclMap::GetStructElement
529(
Sean Callanan9b6898f2011-07-30 02:42:06 +0000530 const NamedDecl *&decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000531 llvm::Value *&value,
532 off_t &offset,
533 ConstString &name,
534 uint32_t index
535)
Sean Callanan8bce6652010-07-13 21:41:46 +0000536{
Sean Callananaa301c42010-12-03 01:38:59 +0000537 assert (m_struct_vars.get());
538
539 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000540 return false;
541
Greg Clayton427f2902010-12-14 02:59:59 +0000542 if (index >= m_struct_members.GetSize())
Sean Callanan8bce6652010-07-13 21:41:46 +0000543 return false;
544
Greg Clayton427f2902010-12-14 02:59:59 +0000545 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
Sean Callanan8bce6652010-07-13 21:41:46 +0000546
Greg Clayton427f2902010-12-14 02:59:59 +0000547 if (!member_sp ||
548 !member_sp->m_parser_vars.get() ||
549 !member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +0000550 return false;
551
Greg Clayton427f2902010-12-14 02:59:59 +0000552 decl = member_sp->m_parser_vars->m_named_decl;
553 value = member_sp->m_parser_vars->m_llvm_value;
554 offset = member_sp->m_jit_vars->m_offset;
555 name = member_sp->GetName();
Sean Callanan8c127202010-08-23 23:09:38 +0000556
Sean Callanan8bce6652010-07-13 21:41:46 +0000557 return true;
558}
559
Sean Callanan02fbafa2010-07-27 21:39:39 +0000560bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000561ClangExpressionDeclMap::GetFunctionInfo
562(
Sean Callanan9b6898f2011-07-30 02:42:06 +0000563 const NamedDecl *decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000564 llvm::Value**& value,
565 uint64_t &ptr
566)
Sean Callananba992c52010-07-27 02:07:53 +0000567{
Greg Clayton427f2902010-12-14 02:59:59 +0000568 ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl));
Sean Callanan8c127202010-08-23 23:09:38 +0000569
Greg Clayton427f2902010-12-14 02:59:59 +0000570 if (!entity_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000571 return false;
Sean Callananba992c52010-07-27 02:07:53 +0000572
Sean Callanan8c127202010-08-23 23:09:38 +0000573 // We know m_parser_vars is valid since we searched for the variable by
574 // its NamedDecl
Sean Callananba992c52010-07-27 02:07:53 +0000575
Greg Clayton427f2902010-12-14 02:59:59 +0000576 value = &entity_sp->m_parser_vars->m_llvm_value;
577 ptr = entity_sp->m_parser_vars->m_lldb_value->GetScalar().ULongLong();
Sean Callanan8c127202010-08-23 23:09:38 +0000578
579 return true;
Sean Callananba992c52010-07-27 02:07:53 +0000580}
581
Sean Callananca2516d2011-08-16 18:09:29 +0000582static void
583FindCodeSymbolInContext
584(
585 const ConstString &name,
586 SymbolContext &sym_ctx,
587 SymbolContextList &sc_list
588)
589{
590 if (sym_ctx.module_sp)
591 sym_ctx.module_sp->FindSymbolsWithNameAndType(name, eSymbolTypeCode, sc_list);
592
593 if (!sc_list.GetSize())
594 sym_ctx.target_sp->GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeCode, sc_list);
595}
596
Sean Callananf5857a02010-07-31 01:32:05 +0000597bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000598ClangExpressionDeclMap::GetFunctionAddress
599(
600 const ConstString &name,
Greg Claytonda7af842011-05-18 22:01:49 +0000601 uint64_t &func_addr
Greg Clayton8de27c72010-10-15 22:48:33 +0000602)
Sean Callananf5857a02010-07-31 01:32:05 +0000603{
Sean Callananaa301c42010-12-03 01:38:59 +0000604 assert (m_parser_vars.get());
605
Sean Callananaba367e2011-05-13 18:27:02 +0000606 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
607
Sean Callananf5857a02010-07-31 01:32:05 +0000608 // Back out in all cases where we're not fully initialized
Jim Ingham78b9ee82010-12-07 01:56:02 +0000609 if (m_parser_vars->m_exe_ctx->target == NULL)
610 return false;
611 if (!m_parser_vars->m_sym_ctx.target_sp)
Sean Callananf5857a02010-07-31 01:32:05 +0000612 return false;
613
Greg Claytone5748d82010-11-09 23:46:37 +0000614 SymbolContextList sc_list;
Sean Callananf5857a02010-07-31 01:32:05 +0000615
Sean Callananca2516d2011-08-16 18:09:29 +0000616 FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, sc_list);
617
Greg Claytone5748d82010-11-09 23:46:37 +0000618 if (!sc_list.GetSize())
Sean Callananaba367e2011-05-13 18:27:02 +0000619 {
620 // We occasionally get debug information in which a const function is reported
621 // as non-const, so the mangled name is wrong. This is a hack to compensate.
622
623 Mangled mangled(name.GetCString(), true);
624
625 ConstString demangled_name = mangled.GetDemangledName();
626
627 if (strlen(demangled_name.GetCString()))
628 {
629 std::string const_name_scratch(demangled_name.GetCString());
630
631 const_name_scratch.append(" const");
632
633 ConstString const_name(const_name_scratch.c_str());
634
Sean Callananca2516d2011-08-16 18:09:29 +0000635 FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, sc_list);
Sean Callananaba367e2011-05-13 18:27:02 +0000636
637 if (log)
638 log->Printf("Found %d results with const name %s", sc_list.GetSize(), const_name.GetCString());
639 }
640 }
641
642 if (!sc_list.GetSize())
Sean Callananf5857a02010-07-31 01:32:05 +0000643 return false;
644
645 SymbolContext sym_ctx;
Greg Claytone5748d82010-11-09 23:46:37 +0000646 sc_list.GetContextAtIndex(0, sym_ctx);
Sean Callananf5857a02010-07-31 01:32:05 +0000647
Greg Claytonda7af842011-05-18 22:01:49 +0000648 const Address *func_so_addr = NULL;
Sean Callananf5857a02010-07-31 01:32:05 +0000649
650 if (sym_ctx.function)
Greg Claytonda7af842011-05-18 22:01:49 +0000651 func_so_addr = &sym_ctx.function->GetAddressRange().GetBaseAddress();
Sean Callananf5857a02010-07-31 01:32:05 +0000652 else if (sym_ctx.symbol)
Greg Claytonda7af842011-05-18 22:01:49 +0000653 func_so_addr = &sym_ctx.symbol->GetAddressRangeRef().GetBaseAddress();
Sean Callananf5857a02010-07-31 01:32:05 +0000654 else
655 return false;
656
Sean Callananae9f7482011-07-07 23:05:43 +0000657 if (!func_so_addr || !func_so_addr->IsValid())
658 return false;
659
Greg Claytonda7af842011-05-18 22:01:49 +0000660 func_addr = func_so_addr->GetCallableLoadAddress (m_parser_vars->m_exe_ctx->target);
661
Sean Callananf5857a02010-07-31 01:32:05 +0000662 return true;
663}
664
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000665addr_t
666ClangExpressionDeclMap::GetSymbolAddress (Target &target, const ConstString &name)
Sean Callananc7674af2011-01-17 23:42:46 +0000667{
Sean Callananc7674af2011-01-17 23:42:46 +0000668 SymbolContextList sc_list;
669
Sean Callanan81974962011-05-08 02:21:26 +0000670 target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
Sean Callananc7674af2011-01-17 23:42:46 +0000671
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000672 const uint32_t num_matches = sc_list.GetSize();
673 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
674
675 for (uint32_t i=0; i<num_matches && symbol_load_addr == LLDB_INVALID_ADDRESS; i++)
676 {
677 SymbolContext sym_ctx;
678 sc_list.GetContextAtIndex(i, sym_ctx);
Sean Callananc7674af2011-01-17 23:42:46 +0000679
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000680 const Address *sym_address = &sym_ctx.symbol->GetAddressRangeRef().GetBaseAddress();
Sean Callananae9f7482011-07-07 23:05:43 +0000681
682 if (!sym_address || !sym_address->IsValid())
683 return LLDB_INVALID_ADDRESS;
684
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000685 if (sym_address)
686 {
687 switch (sym_ctx.symbol->GetType())
688 {
689 case eSymbolTypeCode:
690 case eSymbolTypeTrampoline:
691 symbol_load_addr = sym_address->GetCallableLoadAddress (&target);
692 break;
693
694 case eSymbolTypeData:
695 case eSymbolTypeRuntime:
696 case eSymbolTypeVariable:
697 case eSymbolTypeLocal:
698 case eSymbolTypeParam:
699 case eSymbolTypeInvalid:
700 case eSymbolTypeAbsolute:
701 case eSymbolTypeExtern:
702 case eSymbolTypeException:
703 case eSymbolTypeSourceFile:
704 case eSymbolTypeHeaderFile:
705 case eSymbolTypeObjectFile:
706 case eSymbolTypeCommonBlock:
707 case eSymbolTypeBlock:
708 case eSymbolTypeVariableType:
709 case eSymbolTypeLineEntry:
710 case eSymbolTypeLineHeader:
711 case eSymbolTypeScopeBegin:
712 case eSymbolTypeScopeEnd:
713 case eSymbolTypeAdditional:
714 case eSymbolTypeCompiler:
715 case eSymbolTypeInstrumentation:
716 case eSymbolTypeUndefined:
717 symbol_load_addr = sym_address->GetLoadAddress (&target);
718 break;
719 }
720 }
721 }
Sean Callananc7674af2011-01-17 23:42:46 +0000722
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000723 return symbol_load_addr;
Sean Callananc7674af2011-01-17 23:42:46 +0000724}
725
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000726addr_t
727ClangExpressionDeclMap::GetSymbolAddress (const ConstString &name)
Sean Callanan81974962011-05-08 02:21:26 +0000728{
729 assert (m_parser_vars.get());
730
731 if (!m_parser_vars->m_exe_ctx ||
732 !m_parser_vars->m_exe_ctx->target)
733 return false;
734
Greg Claytoncbc07cf2011-06-23 04:25:29 +0000735 return GetSymbolAddress(*m_parser_vars->m_exe_ctx->target, name);
Sean Callanan81974962011-05-08 02:21:26 +0000736}
737
Sean Callanan47dc4572011-09-15 02:13:07 +0000738// Interface for IRInterpreter
739
740bool
741ClangExpressionDeclMap::WriteTarget (lldb_private::Value &value,
742 const uint8_t *data,
743 size_t length)
744{
745 assert (m_parser_vars.get());
746
747 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
748
749 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
750 {
751 if (!exe_ctx->process)
752 return false;
753
754 RegisterContext *reg_ctx = exe_ctx->GetRegisterContext();
755 RegisterInfo *reg_info = value.GetRegisterInfo();
756
757 if (!reg_ctx)
758 return false;
759
760 lldb_private::RegisterValue reg_value;
761 Error err;
762
763 if (!reg_value.SetFromMemoryData (reg_info, data, length, exe_ctx->process->GetByteOrder(), err))
764 return false;
765
766 return reg_ctx->WriteRegister(reg_info, reg_value);
767 }
768 else
769 {
770 switch (value.GetValueType())
771 {
772 default:
773 return false;
774 case Value::eValueTypeFileAddress:
775 {
776 if (!exe_ctx->process)
777 return false;
778
779 Address file_addr;
780
781 if (!exe_ctx->target->GetImages().ResolveFileAddress((lldb::addr_t)value.GetScalar().ULongLong(), file_addr))
782 return false;
783
784 lldb::addr_t load_addr = file_addr.GetLoadAddress(exe_ctx->target);
785
786 Error err;
787 exe_ctx->process->WriteMemory(load_addr, data, length, err);
788
789 return err.Success();
790 }
791 case Value::eValueTypeLoadAddress:
792 {
793 if (!exe_ctx->process)
794 return false;
795
796 Error err;
797 exe_ctx->process->WriteMemory((lldb::addr_t)value.GetScalar().ULongLong(), data, length, err);
798
799 return err.Success();
800 }
801 case Value::eValueTypeHostAddress:
802 memcpy ((void *)value.GetScalar().ULongLong(), data, length);
803 return true;
804 case Value::eValueTypeScalar:
805 return false;
806 }
807 }
808}
809
810bool
811ClangExpressionDeclMap::ReadTarget (uint8_t *data,
812 lldb_private::Value &value,
813 size_t length)
814{
815 assert (m_parser_vars.get());
816
817 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
818
819 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
820 {
821 if (!exe_ctx->process)
822 return false;
823
824 RegisterContext *reg_ctx = exe_ctx->GetRegisterContext();
825 RegisterInfo *reg_info = value.GetRegisterInfo();
826
827 if (!reg_ctx)
828 return false;
829
830 lldb_private::RegisterValue reg_value;
831 Error err;
832
833 if (!reg_ctx->ReadRegister(reg_info, reg_value))
834 return false;
835
836 return reg_value.GetAsMemoryData(reg_info, data, length, exe_ctx->process->GetByteOrder(), err);
837 }
838 else
839 {
840 switch (value.GetValueType())
841 {
842 default:
843 return false;
844 case Value::eValueTypeFileAddress:
845 {
846 if (!exe_ctx->target)
847 return false;
848
849 Address file_addr;
850
851 if (!exe_ctx->target->GetImages().ResolveFileAddress((lldb::addr_t)value.GetScalar().ULongLong(), file_addr))
852 return false;
853
854 Error err;
855 exe_ctx->target->ReadMemory(file_addr, true, data, length, err);
856
857 return err.Success();
858 }
859 case Value::eValueTypeLoadAddress:
860 {
861 if (!exe_ctx->process)
862 return false;
863
864 Error err;
865 exe_ctx->process->ReadMemory((lldb::addr_t)value.GetScalar().ULongLong(), data, length, err);
866
867 return err.Success();
868 }
869 case Value::eValueTypeHostAddress:
870 memcpy (data, (const void *)value.GetScalar().ULongLong(), length);
871 return true;
872 case Value::eValueTypeScalar:
873 return false;
874 }
875 }
876}
877
878lldb_private::Value
879ClangExpressionDeclMap::LookupDecl (clang::NamedDecl *decl)
880{
881 assert (m_parser_vars.get());
882
883 ExecutionContext exe_ctx = *m_parser_vars->m_exe_ctx;
884
885 ClangExpressionVariableSP expr_var_sp (m_found_entities.GetVariable(decl));
886 ClangExpressionVariableSP persistent_var_sp (m_parser_vars->m_persistent_vars->GetVariable(decl));
887
888 if (expr_var_sp)
889 {
890 const ConstString &name(expr_var_sp->GetName());
891 TypeFromUser type(expr_var_sp->GetTypeFromUser());
892
893 if (m_parser_vars->m_exe_ctx->frame)
894 {
895 VariableSP var(FindVariableInScope (*exe_ctx.frame, name, &type));
896
897 if (var)
898 return *GetVariableValue(exe_ctx, var, NULL);
899 }
900
901 if (m_parser_vars->m_exe_ctx->target)
902 {
903 VariableSP global(FindGlobalVariable (*exe_ctx.target, name.GetCString(), &type));
904
905 if (global)
906 return *GetVariableValue(exe_ctx, global, NULL);
907
908 lldb::addr_t location_load_addr = GetSymbolAddress(*exe_ctx.target, name);
909
910 if (location_load_addr != LLDB_INVALID_ADDRESS)
911 {
912 lldb_private::Value ret;
913 ret.SetValueType(Value::eValueTypeLoadAddress);
914 ret.SetContext(Value::eContextTypeInvalid, NULL);
915 ret.GetScalar() = location_load_addr;
916 return ret;
917 }
918 }
919
920 return Value();
921 }
922 else if (persistent_var_sp)
923 {
924 lldb_private::Value ret;
925 ret.SetValueType(Value::eValueTypeHostAddress);
926 ret.SetContext(Value::eContextTypeInvalid, NULL);
927 ret.GetScalar() = (lldb::addr_t)persistent_var_sp->GetValueBytes();
928 return ret;
929 }
930 else
931 {
932 return Value();
933 }
934}
935
Sean Callanan810f22d2010-07-16 00:09:46 +0000936// Interface for CommandObjectExpression
Sean Callananf328c9f2010-07-20 23:31:16 +0000937
938bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000939ClangExpressionDeclMap::Materialize
940(
Sean Callananaa301c42010-12-03 01:38:59 +0000941 ExecutionContext &exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +0000942 lldb::addr_t &struct_address,
943 Error &err
944)
Sean Callananf328c9f2010-07-20 23:31:16 +0000945{
Sean Callananaa301c42010-12-03 01:38:59 +0000946 EnableMaterialVars();
947
948 m_material_vars->m_process = exe_ctx.process;
949
Sean Callanan0ddf8062011-05-09 22:04:36 +0000950 bool result = DoMaterialize(false /* dematerialize */,
951 exe_ctx,
952 LLDB_INVALID_ADDRESS /* top of stack frame */,
953 LLDB_INVALID_ADDRESS /* bottom of stack frame */,
954 NULL, /* result SP */
955 err);
Sean Callananf328c9f2010-07-20 23:31:16 +0000956
957 if (result)
Sean Callananaa301c42010-12-03 01:38:59 +0000958 struct_address = m_material_vars->m_materialized_location;
Sean Callananf328c9f2010-07-20 23:31:16 +0000959
960 return result;
961}
962
963bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000964ClangExpressionDeclMap::GetObjectPointer
965(
966 lldb::addr_t &object_ptr,
Sean Callanan3aa7da52010-12-13 22:46:15 +0000967 ConstString &object_name,
Sean Callananaa301c42010-12-03 01:38:59 +0000968 ExecutionContext &exe_ctx,
Sean Callanan047923c2010-12-14 00:42:36 +0000969 Error &err,
970 bool suppress_type_check
Greg Clayton8de27c72010-10-15 22:48:33 +0000971)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000972{
Sean Callananaa301c42010-12-03 01:38:59 +0000973 assert (m_struct_vars.get());
974
975 if (!exe_ctx.frame || !exe_ctx.target || !exe_ctx.process)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000976 {
977 err.SetErrorString("Couldn't load 'this' because the context is incomplete");
978 return false;
979 }
980
Sean Callananaa301c42010-12-03 01:38:59 +0000981 if (!m_struct_vars->m_object_pointer_type.GetOpaqueQualType())
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000982 {
983 err.SetErrorString("Couldn't load 'this' because its type is unknown");
984 return false;
985 }
986
Sean Callanan696cf5f2011-05-07 01:06:41 +0000987 VariableSP object_ptr_var = FindVariableInScope (*exe_ctx.frame,
988 object_name,
989 (suppress_type_check ? NULL : &m_struct_vars->m_object_pointer_type));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000990
991 if (!object_ptr_var)
992 {
Sean Callanan3aa7da52010-12-13 22:46:15 +0000993 err.SetErrorStringWithFormat("Couldn't find '%s' with appropriate type in scope", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000994 return false;
995 }
996
Sean Callananaa301c42010-12-03 01:38:59 +0000997 std::auto_ptr<lldb_private::Value> location_value(GetVariableValue(exe_ctx,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000998 object_ptr_var,
Sean Callananaa301c42010-12-03 01:38:59 +0000999 NULL));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001000
1001 if (!location_value.get())
1002 {
Sean Callanan3aa7da52010-12-13 22:46:15 +00001003 err.SetErrorStringWithFormat("Couldn't get the location for '%s'", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001004 return false;
1005 }
1006
Sean Callanan50339fe2011-03-04 00:23:47 +00001007 switch (location_value->GetValueType())
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001008 {
Sean Callanan50339fe2011-03-04 00:23:47 +00001009 default:
Sean Callanan3aa7da52010-12-13 22:46:15 +00001010 err.SetErrorStringWithFormat("'%s' is not in memory; LLDB must be extended to handle registers", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001011 return false;
Sean Callanan50339fe2011-03-04 00:23:47 +00001012 case Value::eValueTypeLoadAddress:
1013 {
1014 lldb::addr_t value_addr = location_value->GetScalar().ULongLong();
1015 uint32_t address_byte_size = exe_ctx.target->GetArchitecture().GetAddressByteSize();
Sean Callanan50339fe2011-03-04 00:23:47 +00001016
1017 if (ClangASTType::GetClangTypeBitWidth(m_struct_vars->m_object_pointer_type.GetASTContext(),
1018 m_struct_vars->m_object_pointer_type.GetOpaqueQualType()) != address_byte_size * 8)
1019 {
1020 err.SetErrorStringWithFormat("'%s' is not of an expected pointer size", object_name.GetCString());
1021 return false;
1022 }
1023
Sean Callanan50339fe2011-03-04 00:23:47 +00001024 Error read_error;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001025 object_ptr = exe_ctx.process->ReadPointerFromMemory (value_addr, read_error);
1026 if (read_error.Fail() || object_ptr == LLDB_INVALID_ADDRESS)
Sean Callanan50339fe2011-03-04 00:23:47 +00001027 {
1028 err.SetErrorStringWithFormat("Coldn't read '%s' from the target: %s", object_name.GetCString(), read_error.AsCString());
1029 return false;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001030 }
Sean Callanan50339fe2011-03-04 00:23:47 +00001031 return true;
1032 }
1033 case Value::eValueTypeScalar:
1034 {
1035 if (location_value->GetContextType() != Value::eContextTypeRegisterInfo)
1036 {
1037 StreamString ss;
1038 location_value->Dump(&ss);
1039
1040 err.SetErrorStringWithFormat("%s is a scalar of unhandled type: %s", object_name.GetCString(), ss.GetString().c_str());
1041 return false;
1042 }
1043
Greg Clayton061b79d2011-05-09 20:18:18 +00001044 RegisterInfo *reg_info = location_value->GetRegisterInfo();
Sean Callanan50339fe2011-03-04 00:23:47 +00001045
Greg Clayton061b79d2011-05-09 20:18:18 +00001046 if (!reg_info)
Sean Callanan50339fe2011-03-04 00:23:47 +00001047 {
1048 err.SetErrorStringWithFormat("Couldn't get the register information for %s", object_name.GetCString());
1049 return false;
1050 }
1051
Greg Clayton061b79d2011-05-09 20:18:18 +00001052 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
Sean Callanan50339fe2011-03-04 00:23:47 +00001053
Greg Clayton061b79d2011-05-09 20:18:18 +00001054 if (!reg_ctx)
Sean Callanan50339fe2011-03-04 00:23:47 +00001055 {
Greg Clayton061b79d2011-05-09 20:18:18 +00001056 err.SetErrorStringWithFormat("Couldn't read register context to read %s from %s", object_name.GetCString(), reg_info->name);
Sean Callanan50339fe2011-03-04 00:23:47 +00001057 return false;
1058 }
1059
Greg Clayton061b79d2011-05-09 20:18:18 +00001060 uint32_t register_number = reg_info->kinds[lldb::eRegisterKindLLDB];
Sean Callanan50339fe2011-03-04 00:23:47 +00001061
Greg Clayton061b79d2011-05-09 20:18:18 +00001062 object_ptr = reg_ctx->ReadRegisterAsUnsigned(register_number, 0x0);
Sean Callanan50339fe2011-03-04 00:23:47 +00001063
1064 return true;
1065 }
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001066 }
1067}
1068
1069bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001070ClangExpressionDeclMap::Dematerialize
1071(
Sean Callananaa301c42010-12-03 01:38:59 +00001072 ExecutionContext &exe_ctx,
Greg Clayton427f2902010-12-14 02:59:59 +00001073 ClangExpressionVariableSP &result_sp,
Sean Callanan0ddf8062011-05-09 22:04:36 +00001074 lldb::addr_t stack_frame_top,
1075 lldb::addr_t stack_frame_bottom,
Greg Clayton8de27c72010-10-15 22:48:33 +00001076 Error &err
1077)
Sean Callananf328c9f2010-07-20 23:31:16 +00001078{
Sean Callanan0ddf8062011-05-09 22:04:36 +00001079 return DoMaterialize(true, exe_ctx, stack_frame_top, stack_frame_bottom, &result_sp, err);
Sean Callananaa301c42010-12-03 01:38:59 +00001080
1081 DidDematerialize();
1082}
1083
1084void
1085ClangExpressionDeclMap::DidDematerialize()
1086{
1087 if (m_material_vars.get())
1088 {
1089 if (m_material_vars->m_materialized_location)
1090 {
1091 //#define SINGLE_STEP_EXPRESSIONS
1092
1093#ifndef SINGLE_STEP_EXPRESSIONS
1094 m_material_vars->m_process->DeallocateMemory(m_material_vars->m_materialized_location);
1095#endif
1096 m_material_vars->m_materialized_location = 0;
1097 }
1098
1099 DisableMaterialVars();
1100 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001101}
1102
Sean Callanan32824aa2010-07-23 22:19:18 +00001103bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001104ClangExpressionDeclMap::DumpMaterializedStruct
1105(
Sean Callananaa301c42010-12-03 01:38:59 +00001106 ExecutionContext &exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +00001107 Stream &s,
1108 Error &err
1109)
Sean Callanan32824aa2010-07-23 22:19:18 +00001110{
Sean Callananaa301c42010-12-03 01:38:59 +00001111 assert (m_struct_vars.get());
1112 assert (m_material_vars.get());
1113
1114 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan32824aa2010-07-23 22:19:18 +00001115 {
1116 err.SetErrorString("Structure hasn't been laid out yet");
1117 return false;
1118 }
1119
Sean Callananaa301c42010-12-03 01:38:59 +00001120 if (!exe_ctx.process)
Sean Callanan32824aa2010-07-23 22:19:18 +00001121 {
1122 err.SetErrorString("Couldn't find the process");
1123 return false;
1124 }
1125
Sean Callananaa301c42010-12-03 01:38:59 +00001126 if (!exe_ctx.target)
Sean Callanan32824aa2010-07-23 22:19:18 +00001127 {
1128 err.SetErrorString("Couldn't find the target");
1129 return false;
1130 }
1131
Sean Callanan33711022010-12-07 10:00:20 +00001132 if (!m_material_vars->m_materialized_location)
1133 {
1134 err.SetErrorString("No materialized location");
1135 return false;
1136 }
1137
Greg Claytonc0fa5332011-05-22 22:46:53 +00001138 lldb::DataBufferSP data_sp(new DataBufferHeap(m_struct_vars->m_struct_size, 0));
Sean Callanan32824aa2010-07-23 22:19:18 +00001139
1140 Error error;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001141 if (exe_ctx.process->ReadMemory (m_material_vars->m_materialized_location,
1142 data_sp->GetBytes(),
1143 data_sp->GetByteSize(), error) != data_sp->GetByteSize())
Sean Callanan32824aa2010-07-23 22:19:18 +00001144 {
1145 err.SetErrorStringWithFormat ("Couldn't read struct from the target: %s", error.AsCString());
1146 return false;
1147 }
1148
Greg Claytonc0fa5332011-05-22 22:46:53 +00001149 DataExtractor extractor(data_sp, exe_ctx.process->GetByteOrder(), exe_ctx.target->GetArchitecture().GetAddressByteSize());
Sean Callanan32824aa2010-07-23 22:19:18 +00001150
Greg Clayton427f2902010-12-14 02:59:59 +00001151 for (size_t member_idx = 0, num_members = m_struct_members.GetSize();
1152 member_idx < num_members;
1153 ++member_idx)
Sean Callanan32824aa2010-07-23 22:19:18 +00001154 {
Greg Clayton427f2902010-12-14 02:59:59 +00001155 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_idx));
Sean Callanan32824aa2010-07-23 22:19:18 +00001156
Greg Clayton427f2902010-12-14 02:59:59 +00001157 if (!member_sp)
1158 return false;
1159
1160 s.Printf("[%s]\n", member_sp->GetName().GetCString());
Sean Callanan8c127202010-08-23 23:09:38 +00001161
Greg Clayton427f2902010-12-14 02:59:59 +00001162 if (!member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +00001163 return false;
1164
Greg Clayton427f2902010-12-14 02:59:59 +00001165 extractor.Dump (&s, // stream
1166 member_sp->m_jit_vars->m_offset, // offset
1167 lldb::eFormatBytesWithASCII, // format
1168 1, // byte size of individual entries
1169 member_sp->m_jit_vars->m_size, // number of entries
1170 16, // entries per line
1171 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset, // address to print
1172 0, // bit size (bitfields only; 0 means ignore)
1173 0); // bit alignment (bitfields only; 0 means ignore)
Sean Callanan32824aa2010-07-23 22:19:18 +00001174
1175 s.PutChar('\n');
1176 }
1177
1178 return true;
1179}
1180
Sean Callananf328c9f2010-07-20 23:31:16 +00001181bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001182ClangExpressionDeclMap::DoMaterialize
1183(
1184 bool dematerialize,
Sean Callananaa301c42010-12-03 01:38:59 +00001185 ExecutionContext &exe_ctx,
Sean Callanan0ddf8062011-05-09 22:04:36 +00001186 lldb::addr_t stack_frame_top,
1187 lldb::addr_t stack_frame_bottom,
Greg Clayton427f2902010-12-14 02:59:59 +00001188 lldb::ClangExpressionVariableSP *result_sp_ptr,
Greg Clayton8de27c72010-10-15 22:48:33 +00001189 Error &err
1190)
Sean Callanan810f22d2010-07-16 00:09:46 +00001191{
Greg Clayton427f2902010-12-14 02:59:59 +00001192 if (result_sp_ptr)
1193 result_sp_ptr->reset();
1194
Sean Callananaa301c42010-12-03 01:38:59 +00001195 assert (m_struct_vars.get());
1196
Greg Claytone005f2c2010-11-06 01:53:30 +00001197 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan82b74c82010-08-12 01:56:52 +00001198
Sean Callananaa301c42010-12-03 01:38:59 +00001199 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan810f22d2010-07-16 00:09:46 +00001200 {
1201 err.SetErrorString("Structure hasn't been laid out yet");
Greg Clayton57067a02011-09-13 04:03:52 +00001202 return false;
Sean Callanan810f22d2010-07-16 00:09:46 +00001203 }
1204
Sean Callananaa301c42010-12-03 01:38:59 +00001205 if (!exe_ctx.frame)
Sean Callanan45839272010-07-24 01:37:44 +00001206 {
1207 err.SetErrorString("Received null execution frame");
Greg Clayton57067a02011-09-13 04:03:52 +00001208 return false;
Sean Callanan45839272010-07-24 01:37:44 +00001209 }
1210
Greg Clayton427f2902010-12-14 02:59:59 +00001211 ClangPersistentVariables &persistent_vars = exe_ctx.target->GetPersistentVariables();
Sean Callananaa301c42010-12-03 01:38:59 +00001212
1213 if (!m_struct_vars->m_struct_size)
Sean Callanane8a59a82010-09-13 21:34:21 +00001214 {
1215 if (log)
1216 log->PutCString("Not bothering to allocate a struct because no arguments are needed");
1217
Sean Callanan9b6898f2011-07-30 02:42:06 +00001218 m_material_vars->m_allocated_area = NULL;
Sean Callanane8a59a82010-09-13 21:34:21 +00001219
1220 return true;
1221 }
1222
Sean Callananaa301c42010-12-03 01:38:59 +00001223 const SymbolContext &sym_ctx(exe_ctx.frame->GetSymbolContext(lldb::eSymbolContextEverything));
Sean Callanan810f22d2010-07-16 00:09:46 +00001224
Sean Callananf328c9f2010-07-20 23:31:16 +00001225 if (!dematerialize)
Sean Callanan810f22d2010-07-16 00:09:46 +00001226 {
Sean Callananaa301c42010-12-03 01:38:59 +00001227 if (m_material_vars->m_materialized_location)
Sean Callananf328c9f2010-07-20 23:31:16 +00001228 {
Sean Callananaa301c42010-12-03 01:38:59 +00001229 exe_ctx.process->DeallocateMemory(m_material_vars->m_materialized_location);
1230 m_material_vars->m_materialized_location = 0;
Sean Callananf328c9f2010-07-20 23:31:16 +00001231 }
1232
Sean Callanan7a60b942010-10-08 01:58:41 +00001233 if (log)
1234 log->PutCString("Allocating memory for materialized argument struct");
1235
Sean Callananaa301c42010-12-03 01:38:59 +00001236 lldb::addr_t mem = exe_ctx.process->AllocateMemory(m_struct_vars->m_struct_alignment + m_struct_vars->m_struct_size,
1237 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1238 err);
Sean Callananf328c9f2010-07-20 23:31:16 +00001239
1240 if (mem == LLDB_INVALID_ADDRESS)
1241 return false;
1242
Sean Callananaa301c42010-12-03 01:38:59 +00001243 m_material_vars->m_allocated_area = mem;
Sean Callanan810f22d2010-07-16 00:09:46 +00001244 }
1245
Sean Callananaa301c42010-12-03 01:38:59 +00001246 m_material_vars->m_materialized_location = m_material_vars->m_allocated_area;
Sean Callananf328c9f2010-07-20 23:31:16 +00001247
Sean Callananaa301c42010-12-03 01:38:59 +00001248 if (m_material_vars->m_materialized_location % m_struct_vars->m_struct_alignment)
1249 m_material_vars->m_materialized_location += (m_struct_vars->m_struct_alignment - (m_material_vars->m_materialized_location % m_struct_vars->m_struct_alignment));
Sean Callananf328c9f2010-07-20 23:31:16 +00001250
Greg Clayton427f2902010-12-14 02:59:59 +00001251 for (uint64_t member_index = 0, num_members = m_struct_members.GetSize();
Sean Callanan8c127202010-08-23 23:09:38 +00001252 member_index < num_members;
1253 ++member_index)
Sean Callanan810f22d2010-07-16 00:09:46 +00001254 {
Greg Clayton427f2902010-12-14 02:59:59 +00001255 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
Sean Callanan810f22d2010-07-16 00:09:46 +00001256
Greg Claytona875b642011-01-09 21:07:35 +00001257 if (m_found_entities.ContainsVariable (member_sp))
Sean Callanan8c127202010-08-23 23:09:38 +00001258 {
Greg Claytona875b642011-01-09 21:07:35 +00001259 RegisterInfo *reg_info = member_sp->GetRegisterInfo ();
Greg Clayton427f2902010-12-14 02:59:59 +00001260 if (reg_info)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001261 {
1262 // This is a register variable
1263
Sean Callananaa301c42010-12-03 01:38:59 +00001264 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001265
1266 if (!reg_ctx)
1267 return false;
1268
Greg Clayton427f2902010-12-14 02:59:59 +00001269 if (!DoMaterializeOneRegister (dematerialize,
1270 exe_ctx,
1271 *reg_ctx,
1272 *reg_info,
1273 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
1274 err))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001275 return false;
1276 }
1277 else
1278 {
Greg Clayton427f2902010-12-14 02:59:59 +00001279 if (!member_sp->m_jit_vars.get())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001280 return false;
1281
Greg Clayton427f2902010-12-14 02:59:59 +00001282 if (!DoMaterializeOneVariable (dematerialize,
1283 exe_ctx,
Sean Callanan6a925532011-01-13 08:53:35 +00001284 sym_ctx,
1285 member_sp,
Greg Clayton427f2902010-12-14 02:59:59 +00001286 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
1287 err))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001288 return false;
1289 }
Sean Callanan8c127202010-08-23 23:09:38 +00001290 }
Sean Callanan8c127202010-08-23 23:09:38 +00001291 else
1292 {
Greg Claytona875b642011-01-09 21:07:35 +00001293 // No need to look for presistent variables if the name doesn't start
1294 // with with a '$' character...
1295 if (member_sp->GetName().AsCString ("!")[0] == '$' && persistent_vars.ContainsVariable(member_sp))
1296 {
Sean Callanan6a925532011-01-13 08:53:35 +00001297
Greg Claytona875b642011-01-09 21:07:35 +00001298 if (member_sp->GetName() == m_struct_vars->m_result_name)
1299 {
Greg Claytona875b642011-01-09 21:07:35 +00001300 if (log)
1301 log->PutCString("Found result member in the struct");
Sean Callanan6a925532011-01-13 08:53:35 +00001302
Greg Claytona875b642011-01-09 21:07:35 +00001303 if (result_sp_ptr)
1304 *result_sp_ptr = member_sp;
Sean Callanan6a925532011-01-13 08:53:35 +00001305
Greg Claytona875b642011-01-09 21:07:35 +00001306 }
1307
1308 if (!DoMaterializeOnePersistentVariable (dematerialize,
Sean Callanan6a925532011-01-13 08:53:35 +00001309 exe_ctx,
Greg Claytona875b642011-01-09 21:07:35 +00001310 member_sp,
Sean Callanan0ddf8062011-05-09 22:04:36 +00001311 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
1312 stack_frame_top,
1313 stack_frame_bottom,
Greg Claytona875b642011-01-09 21:07:35 +00001314 err))
1315 return false;
1316 }
1317 else
1318 {
1319 err.SetErrorStringWithFormat("Unexpected variable %s", member_sp->GetName().GetCString());
1320 return false;
1321 }
Sean Callanan8c127202010-08-23 23:09:38 +00001322 }
Sean Callanan810f22d2010-07-16 00:09:46 +00001323 }
1324
Sean Callananf328c9f2010-07-20 23:31:16 +00001325 return true;
1326}
1327
Sean Callanana48fe162010-08-11 03:57:18 +00001328bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001329ClangExpressionDeclMap::DoMaterializeOnePersistentVariable
1330(
1331 bool dematerialize,
1332 ExecutionContext &exe_ctx,
Greg Clayton427f2902010-12-14 02:59:59 +00001333 ClangExpressionVariableSP &var_sp,
Greg Clayton8de27c72010-10-15 22:48:33 +00001334 lldb::addr_t addr,
Sean Callanan0ddf8062011-05-09 22:04:36 +00001335 lldb::addr_t stack_frame_top,
1336 lldb::addr_t stack_frame_bottom,
Greg Clayton8de27c72010-10-15 22:48:33 +00001337 Error &err
1338)
Sean Callananaa301c42010-12-03 01:38:59 +00001339{
Sean Callanan6a925532011-01-13 08:53:35 +00001340 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1341
Greg Clayton427f2902010-12-14 02:59:59 +00001342 if (!var_sp)
Sean Callanana48fe162010-08-11 03:57:18 +00001343 {
Greg Clayton427f2902010-12-14 02:59:59 +00001344 err.SetErrorString("Invalid persistent variable");
Sean Callanana48fe162010-08-11 03:57:18 +00001345 return LLDB_INVALID_ADDRESS;
1346 }
1347
Greg Clayton427f2902010-12-14 02:59:59 +00001348 const size_t pvar_byte_size = var_sp->GetByteSize();
Sean Callanana6223432010-08-20 01:02:30 +00001349
Greg Clayton427f2902010-12-14 02:59:59 +00001350 uint8_t *pvar_data = var_sp->GetValueBytes();
1351 if (pvar_data == NULL)
Sean Callanana6223432010-08-20 01:02:30 +00001352 return false;
1353
Sean Callanana48fe162010-08-11 03:57:18 +00001354 Error error;
1355
Sean Callanan6a925532011-01-13 08:53:35 +00001356 lldb::addr_t mem; // The address of a spare memory area used to hold the persistent variable.
1357
Sean Callanana48fe162010-08-11 03:57:18 +00001358 if (dematerialize)
1359 {
Sean Callanan6a925532011-01-13 08:53:35 +00001360 if (log)
1361 log->Printf("Dematerializing persistent variable with flags 0x%hx", var_sp->m_flags);
1362
1363 if ((var_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated) ||
1364 (var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
Sean Callanana48fe162010-08-11 03:57:18 +00001365 {
Sean Callanan6a925532011-01-13 08:53:35 +00001366 // Get the location of the target out of the struct.
1367
1368 Error read_error;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001369 mem = exe_ctx.process->ReadPointerFromMemory (addr, read_error);
Sean Callanan6a925532011-01-13 08:53:35 +00001370
1371 if (mem == LLDB_INVALID_ADDRESS)
1372 {
1373 err.SetErrorStringWithFormat("Couldn't read address of %s from struct: %s", var_sp->GetName().GetCString(), error.AsCString());
1374 return false;
1375 }
1376
1377 if (var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
1378 !var_sp->m_live_sp)
1379 {
1380 // If the reference comes from the program, then the ClangExpressionVariable's
1381 // live variable data hasn't been set up yet. Do this now.
1382
Jim Ingham47da8102011-04-22 23:53:53 +00001383 var_sp->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope (),
1384 var_sp->GetTypeFromUser().GetASTContext(),
1385 var_sp->GetTypeFromUser().GetOpaqueQualType(),
1386 var_sp->GetName(),
1387 mem,
1388 eAddressTypeLoad,
1389 pvar_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001390 }
1391
1392 if (!var_sp->m_live_sp)
1393 {
1394 err.SetErrorStringWithFormat("Couldn't find the memory area used to store %s", var_sp->GetName().GetCString());
1395 return false;
1396 }
1397
Greg Claytonb3448432011-03-24 21:19:54 +00001398 if (var_sp->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
Sean Callanan6a925532011-01-13 08:53:35 +00001399 {
1400 err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", var_sp->GetName().GetCString());
1401 return false;
1402 }
1403
Sean Callanan97678d12011-01-13 21:23:32 +00001404 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry ||
1405 var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
Sean Callanan6a925532011-01-13 08:53:35 +00001406 {
1407 mem = var_sp->m_live_sp->GetValue().GetScalar().ULongLong();
1408
1409 if (log)
1410 log->Printf("Dematerializing %s from 0x%llx", var_sp->GetName().GetCString(), (uint64_t)mem);
1411
1412 // Read the contents of the spare memory area
Sean Callanan0ddf8062011-05-09 22:04:36 +00001413
Sean Callanan6a925532011-01-13 08:53:35 +00001414 var_sp->ValueUpdated ();
1415 if (exe_ctx.process->ReadMemory (mem, pvar_data, pvar_byte_size, error) != pvar_byte_size)
1416 {
1417 err.SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString());
1418 return false;
1419 }
1420
Sean Callanan0ddf8062011-05-09 22:04:36 +00001421 if (stack_frame_top != LLDB_INVALID_ADDRESS &&
1422 stack_frame_bottom != LLDB_INVALID_ADDRESS &&
1423 mem >= stack_frame_bottom &&
1424 mem <= stack_frame_top)
1425 {
1426 // If the variable is resident in the stack frame created by the expression,
1427 // then it cannot be relied upon to stay around. We treat it as needing
1428 // reallocation.
1429
1430 var_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
1431 var_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
1432 var_sp->m_flags &= ~ClangExpressionVariable::EVIsProgramReference;
1433 }
1434
Sean Callanan6a925532011-01-13 08:53:35 +00001435 var_sp->m_flags &= ~ClangExpressionVariable::EVNeedsFreezeDry;
1436 }
1437
1438 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation &&
1439 !(var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget))
1440 {
1441 if (m_keep_result_in_memory)
1442 {
1443 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget;
1444 }
1445 else
1446 {
1447 Error deallocate_error = exe_ctx.process->DeallocateMemory(mem);
1448
1449 if (!err.Success())
1450 {
1451 err.SetErrorStringWithFormat ("Couldn't deallocate memory for %s: %s", var_sp->GetName().GetCString(), deallocate_error.AsCString());
1452 return false;
1453 }
1454 }
1455 }
1456 }
1457 else
1458 {
1459 err.SetErrorStringWithFormat("Persistent variables without separate allocations are not currently supported.");
Sean Callanana48fe162010-08-11 03:57:18 +00001460 return false;
1461 }
1462 }
1463 else
1464 {
Sean Callanan6a925532011-01-13 08:53:35 +00001465 if (log)
1466 log->Printf("Materializing persistent variable with flags 0x%hx", var_sp->m_flags);
1467
1468 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation)
Sean Callanana48fe162010-08-11 03:57:18 +00001469 {
Sean Callanan6a925532011-01-13 08:53:35 +00001470 // Allocate a spare memory area to store the persistent variable's contents.
1471
1472 Error allocate_error;
1473
1474 mem = exe_ctx.process->AllocateMemory(pvar_byte_size,
1475 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1476 allocate_error);
1477
1478 if (mem == LLDB_INVALID_ADDRESS)
1479 {
1480 err.SetErrorStringWithFormat("Couldn't allocate a memory area to store %s: %s", var_sp->GetName().GetCString(), allocate_error.AsCString());
1481 return false;
1482 }
1483
1484 if (log)
1485 log->Printf("Allocated %s (0x%llx) sucessfully", var_sp->GetName().GetCString(), mem);
1486
1487 // Put the location of the spare memory into the live data of the ValueObject.
1488
Jim Ingham47da8102011-04-22 23:53:53 +00001489 var_sp->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
1490 var_sp->GetTypeFromUser().GetASTContext(),
1491 var_sp->GetTypeFromUser().GetOpaqueQualType(),
1492 var_sp->GetName(),
1493 mem,
1494 eAddressTypeLoad,
1495 pvar_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001496
1497 // Clear the flag if the variable will never be deallocated.
1498
1499 if (var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
1500 var_sp->m_flags &= ~ClangExpressionVariable::EVNeedsAllocation;
1501
1502 // Write the contents of the variable to the area.
1503
1504 if (exe_ctx.process->WriteMemory (mem, pvar_data, pvar_byte_size, error) != pvar_byte_size)
1505 {
1506 err.SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString());
1507 return false;
1508 }
1509 }
1510
1511 if ((var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference && var_sp->m_live_sp) ||
1512 var_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated)
1513 {
Sean Callanan6a925532011-01-13 08:53:35 +00001514 // Now write the location of the area into the struct.
Sean Callanan6a925532011-01-13 08:53:35 +00001515 Error write_error;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001516 if (!exe_ctx.process->WriteScalarToMemory (addr,
1517 var_sp->m_live_sp->GetValue().GetScalar(),
1518 exe_ctx.process->GetAddressByteSize(),
1519 write_error))
Sean Callanan6a925532011-01-13 08:53:35 +00001520 {
1521 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", var_sp->GetName().GetCString(), write_error.AsCString());
1522 return false;
1523 }
1524
1525 if (log)
Greg Claytonc0fa5332011-05-22 22:46:53 +00001526 log->Printf("Materialized %s into 0x%llx", var_sp->GetName().GetCString(), var_sp->m_live_sp->GetValue().GetScalar().ULongLong());
Sean Callanan6a925532011-01-13 08:53:35 +00001527 }
Sean Callanan696cf5f2011-05-07 01:06:41 +00001528 else if (!(var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
Sean Callanan6a925532011-01-13 08:53:35 +00001529 {
1530 err.SetErrorStringWithFormat("Persistent variables without separate allocations are not currently supported.");
Sean Callanana48fe162010-08-11 03:57:18 +00001531 return false;
1532 }
1533 }
1534
1535 return true;
1536}
1537
Sean Callananf328c9f2010-07-20 23:31:16 +00001538bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001539ClangExpressionDeclMap::DoMaterializeOneVariable
1540(
1541 bool dematerialize,
1542 ExecutionContext &exe_ctx,
1543 const SymbolContext &sym_ctx,
Sean Callanan6a925532011-01-13 08:53:35 +00001544 ClangExpressionVariableSP &expr_var,
Greg Clayton8de27c72010-10-15 22:48:33 +00001545 lldb::addr_t addr,
1546 Error &err
1547)
Sean Callananf328c9f2010-07-20 23:31:16 +00001548{
Greg Claytone005f2c2010-11-06 01:53:30 +00001549 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananf328c9f2010-07-20 23:31:16 +00001550
Sean Callanan17c6a052010-10-05 20:18:48 +00001551 if (!exe_ctx.frame || !exe_ctx.process)
Sean Callanancc074622010-09-14 21:59:34 +00001552 return false;
1553
Sean Callanan6a925532011-01-13 08:53:35 +00001554 // Vital information about the value
1555
1556 const ConstString &name(expr_var->GetName());
1557 TypeFromUser type(expr_var->GetTypeFromUser());
1558
Sean Callanan696cf5f2011-05-07 01:06:41 +00001559 VariableSP var = FindVariableInScope (*exe_ctx.frame, name, &type);
Sean Callanan81974962011-05-08 02:21:26 +00001560 Symbol *sym = FindGlobalDataSymbol(*exe_ctx.target, name);
Sean Callananf328c9f2010-07-20 23:31:16 +00001561
Sean Callanan81974962011-05-08 02:21:26 +00001562 std::auto_ptr<lldb_private::Value> location_value;
1563
1564 if (var)
1565 {
1566 location_value.reset(GetVariableValue(exe_ctx,
1567 var,
1568 NULL));
1569 }
1570 else if (sym)
Sean Callananae9f7482011-07-07 23:05:43 +00001571 {
Sean Callanan81974962011-05-08 02:21:26 +00001572 location_value.reset(new Value);
1573
Greg Claytoncbc07cf2011-06-23 04:25:29 +00001574 addr_t location_load_addr = GetSymbolAddress(*exe_ctx.target, name);
Sean Callanan81974962011-05-08 02:21:26 +00001575
Greg Claytoncbc07cf2011-06-23 04:25:29 +00001576 if (location_load_addr == LLDB_INVALID_ADDRESS)
Sean Callanan81974962011-05-08 02:21:26 +00001577 {
1578 if (log)
Greg Claytonc0fa5332011-05-22 22:46:53 +00001579 err.SetErrorStringWithFormat ("Couldn't find value for global symbol %s",
1580 name.GetCString());
Sean Callanan81974962011-05-08 02:21:26 +00001581 }
1582
1583 location_value->SetValueType(Value::eValueTypeLoadAddress);
1584 location_value->GetScalar() = location_load_addr;
1585 }
1586 else
Sean Callananf328c9f2010-07-20 23:31:16 +00001587 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001588 err.SetErrorStringWithFormat ("Couldn't find %s with appropriate type",
1589 name.GetCString());
Sean Callananf328c9f2010-07-20 23:31:16 +00001590 return false;
1591 }
1592
Sean Callanan841026f2010-07-23 00:16:21 +00001593 if (log)
Sean Callananfb3058e2011-05-12 23:54:16 +00001594 {
1595 StreamString my_stream_string;
1596
1597 ClangASTType::DumpTypeDescription (type.GetASTContext(),
1598 type.GetOpaqueQualType(),
1599 &my_stream_string);
1600
Greg Claytonc0fa5332011-05-22 22:46:53 +00001601 log->Printf ("%s %s with type %s",
1602 dematerialize ? "Dematerializing" : "Materializing",
1603 name.GetCString(),
1604 my_stream_string.GetString().c_str());
Sean Callananfb3058e2011-05-12 23:54:16 +00001605 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001606
1607 if (!location_value.get())
1608 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001609 err.SetErrorStringWithFormat("Couldn't get value for %s", name.GetCString());
Sean Callananf328c9f2010-07-20 23:31:16 +00001610 return false;
1611 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001612
1613 // The size of the type contained in addr
Sean Callananf328c9f2010-07-20 23:31:16 +00001614
Sean Callanan6a925532011-01-13 08:53:35 +00001615 size_t value_bit_size = ClangASTType::GetClangTypeBitWidth(type.GetASTContext(), type.GetOpaqueQualType());
1616 size_t value_byte_size = value_bit_size % 8 ? ((value_bit_size + 8) / 8) : (value_bit_size / 8);
Sean Callanan17c6a052010-10-05 20:18:48 +00001617
1618 Value::ValueType value_type = location_value->GetValueType();
1619
1620 switch (value_type)
Sean Callananf328c9f2010-07-20 23:31:16 +00001621 {
Sean Callanan17c6a052010-10-05 20:18:48 +00001622 default:
Sean Callananf328c9f2010-07-20 23:31:16 +00001623 {
Sean Callanan17c6a052010-10-05 20:18:48 +00001624 StreamString ss;
1625
1626 location_value->Dump(&ss);
1627
Greg Claytonc0fa5332011-05-22 22:46:53 +00001628 err.SetErrorStringWithFormat ("%s has a value of unhandled type: %s",
1629 name.GetCString(),
1630 ss.GetString().c_str());
Sean Callananf328c9f2010-07-20 23:31:16 +00001631 return false;
1632 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001633 break;
1634 case Value::eValueTypeLoadAddress:
Sean Callananf328c9f2010-07-20 23:31:16 +00001635 {
Sean Callanan6a925532011-01-13 08:53:35 +00001636 if (!dematerialize)
Sean Callanan17c6a052010-10-05 20:18:48 +00001637 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001638 Error write_error;
Sean Callanan6a925532011-01-13 08:53:35 +00001639
Greg Claytonc0fa5332011-05-22 22:46:53 +00001640 if (!exe_ctx.process->WriteScalarToMemory (addr,
1641 location_value->GetScalar(),
1642 exe_ctx.process->GetAddressByteSize(),
1643 write_error))
Sean Callanan6a925532011-01-13 08:53:35 +00001644 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001645 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s",
1646 name.GetCString(),
1647 write_error.AsCString());
Sean Callanan6a925532011-01-13 08:53:35 +00001648 return false;
1649 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001650 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001651 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001652 break;
1653 case Value::eValueTypeScalar:
1654 {
Greg Clayton6916e352010-11-13 03:52:47 +00001655 if (location_value->GetContextType() != Value::eContextTypeRegisterInfo)
Sean Callanan17c6a052010-10-05 20:18:48 +00001656 {
1657 StreamString ss;
Sean Callanan17c6a052010-10-05 20:18:48 +00001658 location_value->Dump(&ss);
1659
Greg Claytonc0fa5332011-05-22 22:46:53 +00001660 err.SetErrorStringWithFormat ("%s is a scalar of unhandled type: %s",
1661 name.GetCString(),
1662 ss.GetString().c_str());
Sean Callanan17c6a052010-10-05 20:18:48 +00001663 return false;
1664 }
1665
Greg Clayton061b79d2011-05-09 20:18:18 +00001666 RegisterInfo *reg_info = location_value->GetRegisterInfo();
Sean Callanan17c6a052010-10-05 20:18:48 +00001667
Greg Clayton061b79d2011-05-09 20:18:18 +00001668 if (!reg_info)
Sean Callanan17c6a052010-10-05 20:18:48 +00001669 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001670 err.SetErrorStringWithFormat ("Couldn't get the register information for %s",
1671 name.GetCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001672 return false;
1673 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001674
Greg Clayton061b79d2011-05-09 20:18:18 +00001675 RegisterValue reg_value;
1676
1677 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
1678
1679 if (!reg_ctx)
Sean Callanan17c6a052010-10-05 20:18:48 +00001680 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001681 err.SetErrorStringWithFormat ("Couldn't read register context to read %s from %s",
1682 name.GetCString(),
1683 reg_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001684 return false;
1685 }
1686
Greg Clayton061b79d2011-05-09 20:18:18 +00001687 uint32_t register_byte_size = reg_info->byte_size;
Sean Callanan17c6a052010-10-05 20:18:48 +00001688
1689 if (dematerialize)
1690 {
Sean Callanan6a925532011-01-13 08:53:35 +00001691 // Get the location of the spare memory area out of the variable's live data.
1692
1693 if (!expr_var->m_live_sp)
1694 {
1695 err.SetErrorStringWithFormat("Couldn't find the memory area used to store %s", name.GetCString());
1696 return false;
1697 }
1698
Greg Claytonb3448432011-03-24 21:19:54 +00001699 if (expr_var->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
Sean Callanan6a925532011-01-13 08:53:35 +00001700 {
1701 err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", name.GetCString());
1702 return false;
1703 }
1704
Greg Claytonc0fa5332011-05-22 22:46:53 +00001705 Scalar &reg_addr = expr_var->m_live_sp->GetValue().GetScalar();
Sean Callanan6a925532011-01-13 08:53:35 +00001706
Greg Claytonc0fa5332011-05-22 22:46:53 +00001707 err = reg_ctx->ReadRegisterValueFromMemory (reg_info,
1708 reg_addr.ULongLong(),
1709 value_byte_size,
1710 reg_value);
Greg Clayton061b79d2011-05-09 20:18:18 +00001711 if (err.Fail())
Sean Callanan17c6a052010-10-05 20:18:48 +00001712 return false;
Greg Clayton061b79d2011-05-09 20:18:18 +00001713
1714 if (!reg_ctx->WriteRegister (reg_info, reg_value))
Sean Callanan17c6a052010-10-05 20:18:48 +00001715 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001716 err.SetErrorStringWithFormat ("Couldn't write %s to register %s",
1717 name.GetCString(),
1718 reg_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001719 return false;
1720 }
Sean Callanan6a925532011-01-13 08:53:35 +00001721
1722 // Deallocate the spare area and clear the variable's live data.
1723
Greg Claytonc0fa5332011-05-22 22:46:53 +00001724 Error deallocate_error = exe_ctx.process->DeallocateMemory(reg_addr.ULongLong());
Sean Callanan6a925532011-01-13 08:53:35 +00001725
1726 if (!deallocate_error.Success())
1727 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001728 err.SetErrorStringWithFormat ("Couldn't deallocate spare memory area for %s: %s",
1729 name.GetCString(),
1730 deallocate_error.AsCString());
Sean Callanan6a925532011-01-13 08:53:35 +00001731 return false;
1732 }
1733
1734 expr_var->m_live_sp.reset();
Sean Callanan17c6a052010-10-05 20:18:48 +00001735 }
1736 else
1737 {
Sean Callanan6a925532011-01-13 08:53:35 +00001738 // Allocate a spare memory area to place the register's contents into. This memory area will be pointed to by the slot in the
1739 // struct.
1740
1741 Error allocate_error;
1742
Greg Claytonc0fa5332011-05-22 22:46:53 +00001743 Scalar reg_addr (exe_ctx.process->AllocateMemory (value_byte_size,
1744 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1745 allocate_error));
Sean Callanan6a925532011-01-13 08:53:35 +00001746
Greg Claytonc0fa5332011-05-22 22:46:53 +00001747 if (reg_addr.ULongLong() == LLDB_INVALID_ADDRESS)
Sean Callanan6a925532011-01-13 08:53:35 +00001748 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001749 err.SetErrorStringWithFormat ("Couldn't allocate a memory area to store %s: %s",
1750 name.GetCString(),
1751 allocate_error.AsCString());
Sean Callanan6a925532011-01-13 08:53:35 +00001752 return false;
1753 }
1754
1755 // Put the location of the spare memory into the live data of the ValueObject.
1756
Jim Ingham47da8102011-04-22 23:53:53 +00001757 expr_var->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
1758 type.GetASTContext(),
1759 type.GetOpaqueQualType(),
1760 name,
Greg Claytonc0fa5332011-05-22 22:46:53 +00001761 reg_addr.ULongLong(),
Jim Ingham47da8102011-04-22 23:53:53 +00001762 eAddressTypeLoad,
1763 value_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001764
1765 // Now write the location of the area into the struct.
1766
1767 Error write_error;
Greg Claytonc0fa5332011-05-22 22:46:53 +00001768
1769 if (!exe_ctx.process->WriteScalarToMemory (addr,
1770 reg_addr,
1771 exe_ctx.process->GetAddressByteSize(),
1772 write_error))
Sean Callanan6a925532011-01-13 08:53:35 +00001773 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001774 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s",
1775 name.GetCString(),
1776 write_error.AsCString());
Sean Callanan6a925532011-01-13 08:53:35 +00001777 return false;
1778 }
1779
Sean Callanan6a925532011-01-13 08:53:35 +00001780 if (value_byte_size > register_byte_size)
Sean Callanan17c6a052010-10-05 20:18:48 +00001781 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001782 err.SetErrorStringWithFormat ("%s is too big to store in %s",
1783 name.GetCString(),
1784 reg_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001785 return false;
1786 }
Greg Clayton061b79d2011-05-09 20:18:18 +00001787
1788 RegisterValue reg_value;
1789
1790 if (!reg_ctx->ReadRegister (reg_info, reg_value))
Sean Callanan17c6a052010-10-05 20:18:48 +00001791 {
Greg Claytonc0fa5332011-05-22 22:46:53 +00001792 err.SetErrorStringWithFormat ("Couldn't read %s from %s",
1793 name.GetCString(),
1794 reg_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001795 return false;
1796 }
1797
Greg Claytonc0fa5332011-05-22 22:46:53 +00001798 err = reg_ctx->WriteRegisterValueToMemory (reg_info,
1799 reg_addr.ULongLong(),
1800 value_byte_size,
1801 reg_value);
Greg Clayton061b79d2011-05-09 20:18:18 +00001802 if (err.Fail())
Sean Callanan17c6a052010-10-05 20:18:48 +00001803 return false;
Sean Callanan17c6a052010-10-05 20:18:48 +00001804 }
1805 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001806 }
1807
1808 return true;
Sean Callanan810f22d2010-07-16 00:09:46 +00001809}
1810
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001811bool
1812ClangExpressionDeclMap::DoMaterializeOneRegister
1813(
1814 bool dematerialize,
1815 ExecutionContext &exe_ctx,
1816 RegisterContext &reg_ctx,
Greg Claytonb3448432011-03-24 21:19:54 +00001817 const RegisterInfo &reg_info,
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001818 lldb::addr_t addr,
1819 Error &err
1820)
1821{
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001822 uint32_t register_byte_size = reg_info.byte_size;
Greg Clayton061b79d2011-05-09 20:18:18 +00001823 RegisterValue reg_value;
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001824 if (dematerialize)
1825 {
Greg Clayton061b79d2011-05-09 20:18:18 +00001826 Error read_error (reg_ctx.ReadRegisterValueFromMemory(&reg_info, addr, register_byte_size, reg_value));
1827 if (read_error.Fail())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001828 {
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00001829 err.SetErrorStringWithFormat ("Couldn't read %s from the target: %s", reg_info.name, read_error.AsCString());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001830 return false;
1831 }
1832
Greg Clayton061b79d2011-05-09 20:18:18 +00001833 if (!reg_ctx.WriteRegister (&reg_info, reg_value))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001834 {
Greg Clayton061b79d2011-05-09 20:18:18 +00001835 err.SetErrorStringWithFormat("Couldn't write register %s (dematerialize)", reg_info.name);
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001836 return false;
1837 }
1838 }
1839 else
1840 {
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001841
Greg Clayton061b79d2011-05-09 20:18:18 +00001842 if (!reg_ctx.ReadRegister(&reg_info, reg_value))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001843 {
Greg Clayton061b79d2011-05-09 20:18:18 +00001844 err.SetErrorStringWithFormat("Couldn't read %s (materialize)", reg_info.name);
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001845 return false;
1846 }
1847
Greg Clayton061b79d2011-05-09 20:18:18 +00001848 Error write_error (reg_ctx.WriteRegisterValueToMemory(&reg_info, addr, register_byte_size, reg_value));
1849 if (write_error.Fail())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001850 {
Greg Clayton061b79d2011-05-09 20:18:18 +00001851 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", write_error.AsCString());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001852 return false;
1853 }
1854 }
1855
1856 return true;
1857}
1858
Sean Callanan696cf5f2011-05-07 01:06:41 +00001859lldb::VariableSP
Greg Clayton8de27c72010-10-15 22:48:33 +00001860ClangExpressionDeclMap::FindVariableInScope
1861(
1862 StackFrame &frame,
1863 const ConstString &name,
1864 TypeFromUser *type
1865)
Sean Callananaa301c42010-12-03 01:38:59 +00001866{
Greg Claytone005f2c2010-11-06 01:53:30 +00001867 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanancc074622010-09-14 21:59:34 +00001868
Sean Callananf8b468e2011-08-06 00:28:14 +00001869 ValueObjectSP valobj;
1870 VariableSP var_sp;
1871 Error err;
Sean Callanancc074622010-09-14 21:59:34 +00001872
Sean Callananf8b468e2011-08-06 00:28:14 +00001873 valobj = frame.GetValueForVariableExpressionPath(name.GetCString(),
1874 eNoDynamicValues,
1875 StackFrame::eExpressionPathOptionCheckPtrVsMember,
1876 var_sp,
1877 err);
Greg Clayton3bc52d02010-11-14 22:13:40 +00001878
Sean Callananf8b468e2011-08-06 00:28:14 +00001879 if (!err.Success() ||
1880 !var_sp ||
Sean Callananae9f7482011-07-07 23:05:43 +00001881 !var_sp->IsInScope(&frame) ||
1882 !var_sp->LocationIsValidForFrame (&frame))
1883 return lldb::VariableSP();
Greg Clayton3bc52d02010-11-14 22:13:40 +00001884
1885 if (var_sp && type)
1886 {
1887 if (type->GetASTContext() == var_sp->GetType()->GetClangAST())
1888 {
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001889 if (!ClangASTContext::AreTypesSame(type->GetASTContext(), type->GetOpaqueQualType(), var_sp->GetType()->GetClangFullType()))
Sean Callanan696cf5f2011-05-07 01:06:41 +00001890 return lldb::VariableSP();
Greg Clayton3bc52d02010-11-14 22:13:40 +00001891 }
1892 else
1893 {
1894 if (log)
1895 log->PutCString("Skipping a candidate variable because of different AST contexts");
Sean Callanan696cf5f2011-05-07 01:06:41 +00001896 return lldb::VariableSP();
Greg Clayton3bc52d02010-11-14 22:13:40 +00001897 }
Sean Callanancc074622010-09-14 21:59:34 +00001898 }
Greg Clayton3bc52d02010-11-14 22:13:40 +00001899
Sean Callanan696cf5f2011-05-07 01:06:41 +00001900 return var_sp;
Sean Callanancc074622010-09-14 21:59:34 +00001901}
Sean Callanan336a0002010-07-17 00:43:37 +00001902
Sean Callanan81974962011-05-08 02:21:26 +00001903Symbol *
1904ClangExpressionDeclMap::FindGlobalDataSymbol
1905(
1906 Target &target,
1907 const ConstString &name
1908)
1909{
1910 SymbolContextList sc_list;
1911
1912 target.GetImages().FindSymbolsWithNameAndType(name,
Sean Callanan47dc4572011-09-15 02:13:07 +00001913 eSymbolTypeData,
1914 sc_list);
Sean Callanan81974962011-05-08 02:21:26 +00001915
1916 if (sc_list.GetSize())
1917 {
1918 SymbolContext sym_ctx;
1919 sc_list.GetContextAtIndex(0, sym_ctx);
1920
1921 return sym_ctx.symbol;
1922 }
1923
1924 return NULL;
1925}
1926
Sean Callanan47dc4572011-09-15 02:13:07 +00001927// This is a callback used with Variable::GetValuesForVariableExpressionPath
1928
1929static uint32_t GetVariableCallback (void *baton,
1930 const char *name,
1931 VariableList &variable_list)
1932{
1933 Target *target = static_cast<Target *>(baton);
1934 if (target)
1935 {
1936 return target->GetImages().FindGlobalVariables (ConstString(name),
1937 true,
1938 UINT32_MAX,
1939 variable_list);
1940 }
1941 return 0;
1942}
1943
1944lldb::VariableSP
1945ClangExpressionDeclMap::FindGlobalVariable
1946(
1947 Target &target,
1948 const char *name,
1949 TypeFromUser *type
1950)
1951{
1952 VariableList vars;
1953 ValueObjectList valobjs;
1954
1955 Error error (Variable::GetValuesForVariableExpressionPath (name,
1956 &target,
1957 GetVariableCallback,
1958 &target,
1959 vars,
1960 valobjs));
1961
1962 if (vars.GetSize())
1963 {
1964 if (type)
1965 {
1966 for (size_t i = 0; i < vars.GetSize(); ++i)
1967 {
1968 VariableSP var_sp = vars.GetVariableAtIndex(i);
1969
1970 if (type->GetASTContext() == var_sp->GetType()->GetClangAST())
1971 {
1972 if (ClangASTContext::AreTypesSame(type->GetASTContext(), type->GetOpaqueQualType(), var_sp->GetType()->GetClangFullType()))
1973 return var_sp;
1974 }
1975 }
1976 }
1977 else
1978 {
1979 return vars.GetVariableAtIndex(0);
1980 }
1981 }
1982
1983 return VariableSP();
1984}
1985
Chris Lattner24943d22010-06-08 16:52:24 +00001986// Interface for ClangASTSource
Sean Callanan47dc4572011-09-15 02:13:07 +00001987
Chris Lattner24943d22010-06-08 16:52:24 +00001988void
Greg Claytone5748d82010-11-09 23:46:37 +00001989ClangExpressionDeclMap::GetDecls (NameSearchContext &context, const ConstString &name)
Chris Lattner24943d22010-06-08 16:52:24 +00001990{
Sean Callananaa301c42010-12-03 01:38:59 +00001991 assert (m_struct_vars.get());
1992 assert (m_parser_vars.get());
1993
Greg Claytone005f2c2010-11-06 01:53:30 +00001994 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001995
Sean Callanan810f22d2010-07-16 00:09:46 +00001996 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00001997 log->Printf("Hunting for a definition for '%s'", name.GetCString());
Chris Lattner24943d22010-06-08 16:52:24 +00001998
Sean Callananaa301c42010-12-03 01:38:59 +00001999 if (m_parser_vars->m_ignore_lookups)
Sean Callananee8fc722010-11-19 20:20:02 +00002000 {
2001 if (log)
2002 log->Printf("Ignoring a query during an import");
2003 return;
2004 }
Greg Claytone6d72ca2011-06-25 00:44:06 +00002005
2006 do
2007 {
2008 if (isa<TranslationUnitDecl>(context.m_decl_context))
2009 break;
2010
Sean Callanan9b6898f2011-07-30 02:42:06 +00002011 if (!isa<NamespaceDecl>(context.m_decl_context))
Greg Claytone6d72ca2011-06-25 00:44:06 +00002012 return;
2013
Sean Callanan9b6898f2011-07-30 02:42:06 +00002014 const Decl *context_decl = dyn_cast<Decl>(context.m_decl_context);
2015
2016 if (log)
2017 log->Printf("Searching for '%s' in a '%s'", name.GetCString(), context_decl->getDeclKindName());
2018
2019 Decl *original_decl = NULL;
2020 ASTContext *original_ctx = NULL;
2021
2022 if (!m_parser_vars->GetASTImporter(context.GetASTContext())->ResolveDeclOrigin(context_decl, &original_decl, &original_ctx))
2023 break;
2024
2025 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
Greg Claytone6d72ca2011-06-25 00:44:06 +00002026 {
Sean Callanan9b6898f2011-07-30 02:42:06 +00002027 ExternalASTSource *external_source = original_ctx->getExternalSource();
Greg Claytone6d72ca2011-06-25 00:44:06 +00002028
Sean Callanan9b6898f2011-07-30 02:42:06 +00002029 if (!external_source)
Greg Claytone6d72ca2011-06-25 00:44:06 +00002030 break;
Greg Claytone6d72ca2011-06-25 00:44:06 +00002031
Sean Callanan9b6898f2011-07-30 02:42:06 +00002032 if (!original_tag_decl)
2033 break;
Greg Claytone6d72ca2011-06-25 00:44:06 +00002034
Sean Callanan9b6898f2011-07-30 02:42:06 +00002035 external_source->CompleteType (original_tag_decl);
2036 }
2037
2038 DeclContext *original_decl_context = dyn_cast<DeclContext>(original_decl);
2039
2040 if (!original_decl_context)
2041 break;
Greg Claytone6d72ca2011-06-25 00:44:06 +00002042
Sean Callanan9b6898f2011-07-30 02:42:06 +00002043 for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
2044 iter != original_decl_context->decls_end();
2045 ++iter)
2046 {
2047 NamedDecl *named_decl = dyn_cast<NamedDecl>(*iter);
2048
2049 if (named_decl && named_decl->getName().equals(name.GetCString()))
2050 {
2051 Decl *copied_decl = m_parser_vars->GetASTImporter(context.GetASTContext())->CopyDecl(original_ctx, named_decl);
2052 NamedDecl *copied_named_decl = dyn_cast<NamedDecl>(copied_decl);
2053
2054 if (!copied_named_decl)
2055 continue;
2056
2057 context.AddNamedDecl (copied_named_decl);
Greg Claytone6d72ca2011-06-25 00:44:06 +00002058 }
2059 }
Sean Callanan9b6898f2011-07-30 02:42:06 +00002060
2061 return;
Greg Claytone6d72ca2011-06-25 00:44:06 +00002062 }
2063 while (0);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002064
Greg Claytone5748d82010-11-09 23:46:37 +00002065 SymbolContextList sc_list;
Chris Lattner24943d22010-06-08 16:52:24 +00002066
Greg Clayton3bc52d02010-11-14 22:13:40 +00002067 const char *name_unique_cstr = name.GetCString();
2068
2069 if (name_unique_cstr == NULL)
2070 return;
2071
Greg Clayton8de27c72010-10-15 22:48:33 +00002072 // Only look for functions by name out in our symbols if the function
2073 // doesn't start with our phony prefix of '$'
Greg Clayton3bc52d02010-11-14 22:13:40 +00002074 if (name_unique_cstr[0] != '$')
Sean Callanan0fc73582010-07-27 00:55:47 +00002075 {
Sean Callananf8b468e2011-08-06 00:28:14 +00002076 ValueObjectSP valobj;
2077 VariableSP var;
2078 Error err;
Sean Callanan47dc4572011-09-15 02:13:07 +00002079 bool found = false;
Sean Callananf8b468e2011-08-06 00:28:14 +00002080
Sean Callanan47dc4572011-09-15 02:13:07 +00002081 if (m_parser_vars->m_exe_ctx->frame)
Greg Clayton8de27c72010-10-15 22:48:33 +00002082 {
Sean Callanan47dc4572011-09-15 02:13:07 +00002083 valobj = m_parser_vars->m_exe_ctx->frame->GetValueForVariableExpressionPath(name_unique_cstr,
2084 eNoDynamicValues,
2085 StackFrame::eExpressionPathOptionCheckPtrVsMember,
2086 var,
2087 err);
2088
2089 // If we found a variable in scope, no need to pull up function names
2090 if (err.Success() && var != NULL)
2091 {
2092 AddOneVariable(context, var);
2093 found = true;
2094 }
Greg Clayton8de27c72010-10-15 22:48:33 +00002095 }
Sean Callanan47dc4572011-09-15 02:13:07 +00002096 else if (m_parser_vars->m_exe_ctx->target)
2097 {
2098 var = FindGlobalVariable(*m_parser_vars->m_exe_ctx->target,
2099 name_unique_cstr,
2100 NULL);
2101
2102 if (var)
2103 {
2104 AddOneVariable(context, var);
2105 found = true;
2106 }
2107 }
2108
2109 if (!found)
Greg Clayton8de27c72010-10-15 22:48:33 +00002110 {
Greg Clayton28d5fcc2011-01-27 06:44:37 +00002111 const bool include_symbols = true;
2112 const bool append = false;
2113 m_parser_vars->m_sym_ctx.FindFunctionsByName (name,
2114 include_symbols,
2115 append,
2116 sc_list);
Greg Clayton8de27c72010-10-15 22:48:33 +00002117
Sean Callanan81974962011-05-08 02:21:26 +00002118 if (sc_list.GetSize())
Greg Clayton8de27c72010-10-15 22:48:33 +00002119 {
Sean Callanan81974962011-05-08 02:21:26 +00002120 bool found_specific = false;
2121 Symbol *generic_symbol = NULL;
2122 Symbol *non_extern_symbol = NULL;
2123
2124 for (uint32_t index = 0, num_indices = sc_list.GetSize();
2125 index < num_indices;
2126 ++index)
Greg Clayton8de27c72010-10-15 22:48:33 +00002127 {
Sean Callanan81974962011-05-08 02:21:26 +00002128 SymbolContext sym_ctx;
2129 sc_list.GetContextAtIndex(index, sym_ctx);
2130
2131 if (sym_ctx.function)
2132 {
2133 // TODO only do this if it's a C function; C++ functions may be
2134 // overloaded
2135 if (!found_specific)
2136 AddOneFunction(context, sym_ctx.function, NULL);
2137 found_specific = true;
Sean Callanan47dc4572011-09-15 02:13:07 +00002138 found = true;
Sean Callanan81974962011-05-08 02:21:26 +00002139 }
2140 else if (sym_ctx.symbol)
2141 {
2142 if (sym_ctx.symbol->IsExternal())
2143 generic_symbol = sym_ctx.symbol;
2144 else
2145 non_extern_symbol = sym_ctx.symbol;
2146 }
Greg Clayton8de27c72010-10-15 22:48:33 +00002147 }
Sean Callanan81974962011-05-08 02:21:26 +00002148
2149 if (!found_specific)
Greg Clayton8de27c72010-10-15 22:48:33 +00002150 {
Sean Callanan81974962011-05-08 02:21:26 +00002151 if (generic_symbol)
Sean Callanan47dc4572011-09-15 02:13:07 +00002152 {
Sean Callanan81974962011-05-08 02:21:26 +00002153 AddOneFunction (context, NULL, generic_symbol);
Sean Callanan47dc4572011-09-15 02:13:07 +00002154 found = true;
2155 }
Sean Callanan81974962011-05-08 02:21:26 +00002156 else if (non_extern_symbol)
Sean Callanan47dc4572011-09-15 02:13:07 +00002157 {
Sean Callanan81974962011-05-08 02:21:26 +00002158 AddOneFunction (context, NULL, non_extern_symbol);
Sean Callanan47dc4572011-09-15 02:13:07 +00002159 found = true;
2160 }
Sean Callanan81974962011-05-08 02:21:26 +00002161 }
Greg Clayton8de27c72010-10-15 22:48:33 +00002162 }
Sean Callanan47dc4572011-09-15 02:13:07 +00002163
2164 if (!found)
Greg Clayton8de27c72010-10-15 22:48:33 +00002165 {
Sean Callanan81974962011-05-08 02:21:26 +00002166 // We couldn't find a variable or function for this. Now we'll hunt for a generic
2167 // data symbol, and -- if it is found -- treat it as a variable.
2168
2169 Symbol *data_symbol = FindGlobalDataSymbol(*m_parser_vars->m_exe_ctx->target, name);
2170
2171 if (data_symbol)
Sean Callanan47dc4572011-09-15 02:13:07 +00002172 {
Sean Callanan81974962011-05-08 02:21:26 +00002173 AddOneGenericVariable(context, *data_symbol);
Sean Callanan47dc4572011-09-15 02:13:07 +00002174 found = true;
2175 }
Greg Clayton6916e352010-11-13 03:52:47 +00002176 }
Sean Callanan92aa6662010-09-07 21:49:41 +00002177 }
Greg Claytone6d72ca2011-06-25 00:44:06 +00002178
2179 ClangNamespaceDecl namespace_decl (m_parser_vars->m_sym_ctx.FindNamespace(name));
2180
2181 if (namespace_decl)
2182 {
2183 if (log)
2184 {
2185 std::string s;
2186 llvm::raw_string_ostream os(s);
2187 namespace_decl.GetNamespaceDecl()->print(os);
2188 os.flush();
2189
2190 log->Printf("Added namespace decl:");
2191 log->Printf("%s", s.c_str());
2192 }
2193
Sean Callanan9b6898f2011-07-30 02:42:06 +00002194 NamespaceDecl *clang_namespace_decl = AddNamespace(context, namespace_decl);
Greg Claytone6d72ca2011-06-25 00:44:06 +00002195 if (clang_namespace_decl)
2196 clang_namespace_decl->setHasExternalLexicalStorage();
Sean Callanan47dc4572011-09-15 02:13:07 +00002197 }
Sean Callanan0fc73582010-07-27 00:55:47 +00002198 }
Greg Clayton8de27c72010-10-15 22:48:33 +00002199 else
Sean Callanan3cfbd332010-10-06 00:10:07 +00002200 {
Greg Clayton57452832010-11-09 04:42:43 +00002201 static ConstString g_lldb_class_name ("$__lldb_class");
Sean Callanan47dc4572011-09-15 02:13:07 +00002202
Greg Clayton57452832010-11-09 04:42:43 +00002203 if (name == g_lldb_class_name)
2204 {
2205 // Clang is looking for the type of "this"
2206
Sean Callanan47dc4572011-09-15 02:13:07 +00002207 if (!m_parser_vars->m_exe_ctx->frame)
2208 return;
2209
Sean Callananaa301c42010-12-03 01:38:59 +00002210 VariableList *vars = m_parser_vars->m_exe_ctx->frame->GetVariableList(false);
Greg Clayton57452832010-11-09 04:42:43 +00002211
2212 if (!vars)
2213 return;
2214
2215 lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
2216
Greg Clayton75a40122011-07-06 18:55:08 +00002217 if (!this_var ||
2218 !this_var->IsInScope(m_parser_vars->m_exe_ctx->frame) ||
2219 !this_var->LocationIsValidForFrame (m_parser_vars->m_exe_ctx->frame))
Greg Clayton57452832010-11-09 04:42:43 +00002220 return;
2221
2222 Type *this_type = this_var->GetType();
2223
2224 if (!this_type)
2225 return;
2226
Greg Clayton2403b5e2010-11-16 02:10:54 +00002227 if (log)
2228 {
2229 log->PutCString ("Type for \"this\" is: ");
2230 StreamString strm;
2231 this_type->Dump(&strm, true);
2232 log->PutCString (strm.GetData());
2233 }
2234
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002235 TypeFromUser this_user_type(this_type->GetClangFullType(),
Greg Clayton57452832010-11-09 04:42:43 +00002236 this_type->GetClangAST());
2237
Sean Callananaa301c42010-12-03 01:38:59 +00002238 m_struct_vars->m_object_pointer_type = this_user_type;
Greg Clayton57452832010-11-09 04:42:43 +00002239
Sean Callanan58baaad2011-07-08 00:39:14 +00002240 void *pointer_target_type = NULL;
Greg Clayton57452832010-11-09 04:42:43 +00002241
2242 if (!ClangASTContext::IsPointerType(this_user_type.GetOpaqueQualType(),
2243 &pointer_target_type))
2244 return;
2245
Sean Callananc617a4c2011-08-05 23:43:37 +00002246 clang::QualType pointer_target_qual_type = QualType::getFromOpaquePtr(pointer_target_type);
2247
2248 if (pointer_target_qual_type.isConstQualified())
2249 pointer_target_qual_type.removeLocalConst();
2250
2251 TypeFromUser class_user_type(pointer_target_qual_type.getAsOpaquePtr(),
Greg Clayton57452832010-11-09 04:42:43 +00002252 this_type->GetClangAST());
2253
Sean Callanan3aa7da52010-12-13 22:46:15 +00002254 if (log)
2255 {
2256 StreamString type_stream;
2257 class_user_type.DumpTypeCode(&type_stream);
2258 type_stream.Flush();
2259 log->Printf("Adding type for $__lldb_class: %s", type_stream.GetString().c_str());
2260 }
2261
Greg Clayton57452832010-11-09 04:42:43 +00002262 AddOneType(context, class_user_type, true);
2263
2264 return;
2265 }
2266
Sean Callanan3aa7da52010-12-13 22:46:15 +00002267 static ConstString g_lldb_objc_class_name ("$__lldb_objc_class");
2268 if (name == g_lldb_objc_class_name)
2269 {
2270 // Clang is looking for the type of "*self"
2271
Sean Callanan47dc4572011-09-15 02:13:07 +00002272 if (!m_parser_vars->m_exe_ctx->frame)
2273 return;
2274
Sean Callanan3aa7da52010-12-13 22:46:15 +00002275 VariableList *vars = m_parser_vars->m_exe_ctx->frame->GetVariableList(false);
2276
2277 if (!vars)
2278 return;
2279
2280 lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
2281
Greg Clayton75a40122011-07-06 18:55:08 +00002282 if (!self_var ||
2283 !self_var->IsInScope(m_parser_vars->m_exe_ctx->frame) ||
2284 !self_var->LocationIsValidForFrame (m_parser_vars->m_exe_ctx->frame))
Sean Callanan3aa7da52010-12-13 22:46:15 +00002285 return;
2286
2287 Type *self_type = self_var->GetType();
2288
2289 if (!self_type)
2290 return;
2291
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002292 TypeFromUser self_user_type(self_type->GetClangFullType(),
Sean Callanan3aa7da52010-12-13 22:46:15 +00002293 self_type->GetClangAST());
2294
2295 m_struct_vars->m_object_pointer_type = self_user_type;
2296
Sean Callanan58baaad2011-07-08 00:39:14 +00002297 void *pointer_target_type = NULL;
Sean Callanan3aa7da52010-12-13 22:46:15 +00002298
2299 if (!ClangASTContext::IsPointerType(self_user_type.GetOpaqueQualType(),
Jim Ingham27a3ad12011-07-08 18:34:32 +00002300 &pointer_target_type)
Greg Clayton19c0d582011-07-08 18:27:39 +00002301 || pointer_target_type == NULL)
Sean Callanan3aa7da52010-12-13 22:46:15 +00002302 return;
2303
2304 TypeFromUser class_user_type(pointer_target_type,
2305 self_type->GetClangAST());
2306
2307 if (log)
2308 {
2309 StreamString type_stream;
2310 class_user_type.DumpTypeCode(&type_stream);
2311 type_stream.Flush();
2312 log->Printf("Adding type for $__lldb_objc_class: %s", type_stream.GetString().c_str());
2313 }
2314
2315 AddOneType(context, class_user_type, false);
2316
2317 return;
2318 }
Greg Clayton427f2902010-12-14 02:59:59 +00002319
Sean Callanan24312442011-08-23 21:20:51 +00002320 do
2321 {
2322 if (!m_parser_vars->m_exe_ctx->target)
2323 break;
2324
2325 ClangASTContext *scratch_clang_ast_context = m_parser_vars->m_exe_ctx->target->GetScratchClangASTContext();
2326
2327 if (!scratch_clang_ast_context)
2328 break;
2329
2330 ASTContext *scratch_ast_context = scratch_clang_ast_context->getASTContext();
2331
2332 if (!scratch_ast_context)
2333 break;
2334
2335 TypeDecl *ptype_type_decl = m_parser_vars->m_persistent_vars->GetPersistentType(name);
2336
2337 if (!ptype_type_decl)
2338 break;
2339
2340 Decl *parser_ptype_decl = ClangASTContext::CopyDecl(context.GetASTContext(), scratch_ast_context, ptype_type_decl);
2341
2342 if (!parser_ptype_decl)
2343 break;
2344
2345 TypeDecl *parser_ptype_type_decl = dyn_cast<TypeDecl>(parser_ptype_decl);
2346
2347 if (!parser_ptype_type_decl)
2348 break;
2349
2350 if (log)
2351 log->Printf("Found persistent type %s", name.GetCString());
2352
2353 context.AddNamedDecl(parser_ptype_type_decl);
2354 } while (0);
2355
Greg Clayton427f2902010-12-14 02:59:59 +00002356 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
Greg Clayton8de27c72010-10-15 22:48:33 +00002357
Greg Clayton427f2902010-12-14 02:59:59 +00002358 if (pvar_sp)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002359 {
Greg Clayton427f2902010-12-14 02:59:59 +00002360 AddOneVariable(context, pvar_sp);
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002361 return;
2362 }
2363
2364 const char *reg_name(&name.GetCString()[1]);
2365
Sean Callananaa301c42010-12-03 01:38:59 +00002366 if (m_parser_vars->m_exe_ctx->GetRegisterContext())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002367 {
Greg Claytonb3448432011-03-24 21:19:54 +00002368 const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx->GetRegisterContext()->GetRegisterInfoByName(reg_name));
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002369
2370 if (reg_info)
2371 AddOneRegister(context, reg_info);
2372 }
Sean Callanan3cfbd332010-10-06 00:10:07 +00002373 }
2374
Sean Callananaa301c42010-12-03 01:38:59 +00002375 lldb::TypeSP type_sp (m_parser_vars->m_sym_ctx.FindTypeByName (name));
Sean Callananee8fc722010-11-19 20:20:02 +00002376
2377 if (type_sp)
Sean Callanan6df08402010-09-27 23:54:58 +00002378 {
Sean Callananee8fc722010-11-19 20:20:02 +00002379 if (log)
Sean Callanan6df08402010-09-27 23:54:58 +00002380 {
Sean Callananee8fc722010-11-19 20:20:02 +00002381 log->Printf ("Matching type found for \"%s\": ", name.GetCString());
2382 StreamString strm;
2383 type_sp->Dump(&strm, true);
2384 log->PutCString (strm.GetData());
2385 }
Greg Clayton2403b5e2010-11-16 02:10:54 +00002386
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002387 TypeFromUser user_type (type_sp->GetClangFullType(),
Greg Claytonb01000f2011-01-17 03:46:26 +00002388 type_sp->GetClangAST());
Sean Callanan6df08402010-09-27 23:54:58 +00002389
Sean Callananee8fc722010-11-19 20:20:02 +00002390 AddOneType(context, user_type, false);
Sean Callanan6df08402010-09-27 23:54:58 +00002391 }
Sean Callanan336a0002010-07-17 00:43:37 +00002392}
Greg Claytone6d72ca2011-06-25 00:44:06 +00002393
Sean Callanan9b6898f2011-07-30 02:42:06 +00002394clang::ExternalLoadResult
2395ClangExpressionDeclMap::FindExternalLexicalDecls (const DeclContext *decl_context,
2396 bool (*predicate)(Decl::Kind),
2397 llvm::SmallVectorImpl<Decl*> &decls)
Greg Claytone6d72ca2011-06-25 00:44:06 +00002398{
Greg Claytone6d72ca2011-06-25 00:44:06 +00002399 assert (m_parser_vars.get());
2400
Sean Callanan9b6898f2011-07-30 02:42:06 +00002401 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2402
2403 const Decl *context_decl = dyn_cast<Decl>(decl_context);
2404
2405 if (!context_decl)
2406 return ELR_Failure;
2407
2408 ASTContext *ast_context = &context_decl->getASTContext();
2409
2410 if (log)
2411 log->Printf("Finding lexical decls in a '%s' with %s predicate", context_decl->getDeclKindName(), (predicate ? "non-null" : "null"));
2412
2413 Decl *original_decl = NULL;
2414 ASTContext *original_ctx = NULL;
2415
2416 ClangASTImporter *ast_importer = m_parser_vars->GetASTImporter(ast_context);
2417
2418 if (!ast_importer)
2419 return ELR_Failure;
2420
2421 if (!ast_importer->ResolveDeclOrigin(context_decl, &original_decl, &original_ctx))
2422 return ELR_Failure;
Greg Claytone6d72ca2011-06-25 00:44:06 +00002423
2424 if (log)
2425 {
Sean Callanan9b6898f2011-07-30 02:42:06 +00002426 std::string decl_print_string;
2427 llvm::raw_string_ostream decl_print_stream(decl_print_string);
2428 original_decl->print(decl_print_stream);
2429 decl_print_stream.flush();
2430 log->Printf("Original decl:\n%s", decl_print_string.c_str());
2431 }
2432
2433 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
2434 {
2435 ExternalASTSource *external_source = original_ctx->getExternalSource();
Greg Claytone6d72ca2011-06-25 00:44:06 +00002436
Sean Callananc6139712011-08-11 23:56:13 +00002437 if (external_source)
2438 external_source->CompleteType (original_tag_decl);
Sean Callanan9b6898f2011-07-30 02:42:06 +00002439 }
2440
2441 DeclContext *original_decl_context = dyn_cast<DeclContext>(original_decl);
2442
2443 if (!original_decl_context)
2444 return ELR_Failure;
2445
2446 for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
2447 iter != original_decl_context->decls_end();
2448 ++iter)
2449 {
2450 Decl *decl = *iter;
2451
2452 if (!predicate || predicate(decl->getKind()))
Greg Claytone6d72ca2011-06-25 00:44:06 +00002453 {
Sean Callanan9b6898f2011-07-30 02:42:06 +00002454 if (log)
2455 {
2456 std::string decl_print_string;
2457 llvm::raw_string_ostream decl_print_stream(decl_print_string);
2458 decl->print(decl_print_stream);
2459 decl_print_stream.flush();
2460 log->Printf(" Adding lexical decl %s", decl_print_string.c_str());
2461 }
2462
2463 Decl *copied_decl = ast_importer->CopyDecl(original_ctx, decl);
Greg Claytone6d72ca2011-06-25 00:44:06 +00002464
Sean Callanan9b6898f2011-07-30 02:42:06 +00002465 decls.push_back(copied_decl);
Greg Claytone6d72ca2011-06-25 00:44:06 +00002466 }
2467 }
2468
Sean Callanan9b6898f2011-07-30 02:42:06 +00002469 return ELR_AlreadyLoaded;
2470}
2471
2472void
2473ClangExpressionDeclMap::CompleteTagDecl (TagDecl *tag_decl)
2474{
2475 assert (m_parser_vars.get());
2476
2477 m_parser_vars->GetASTImporter(&tag_decl->getASTContext())->CompleteTagDecl (tag_decl);
2478}
2479
2480void
2481ClangExpressionDeclMap::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl)
2482{
2483 assert (m_parser_vars.get());
2484
2485 m_parser_vars->GetASTImporter(&interface_decl->getASTContext())->CompleteObjCInterfaceDecl (interface_decl);
Greg Claytone6d72ca2011-06-25 00:44:06 +00002486}
2487
Sean Callanan336a0002010-07-17 00:43:37 +00002488Value *
Greg Clayton8de27c72010-10-15 22:48:33 +00002489ClangExpressionDeclMap::GetVariableValue
2490(
2491 ExecutionContext &exe_ctx,
Sean Callanan696cf5f2011-05-07 01:06:41 +00002492 VariableSP var,
Sean Callanan9b6898f2011-07-30 02:42:06 +00002493 ASTContext *parser_ast_context,
Greg Clayton8de27c72010-10-15 22:48:33 +00002494 TypeFromUser *user_type,
2495 TypeFromParser *parser_type
2496)
Chris Lattner24943d22010-06-08 16:52:24 +00002497{
Greg Claytone005f2c2010-11-06 01:53:30 +00002498 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan6184dfe2010-06-23 00:47:48 +00002499
Chris Lattner24943d22010-06-08 16:52:24 +00002500 Type *var_type = var->GetType();
2501
2502 if (!var_type)
2503 {
Sean Callanan810f22d2010-07-16 00:09:46 +00002504 if (log)
2505 log->PutCString("Skipped a definition because it has no type");
Sean Callanan336a0002010-07-17 00:43:37 +00002506 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002507 }
2508
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002509 clang_type_t var_opaque_type = var_type->GetClangFullType();
Chris Lattner24943d22010-06-08 16:52:24 +00002510
2511 if (!var_opaque_type)
2512 {
Sean Callanan810f22d2010-07-16 00:09:46 +00002513 if (log)
2514 log->PutCString("Skipped a definition because it has no Clang type");
Sean Callanan336a0002010-07-17 00:43:37 +00002515 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002516 }
2517
Sean Callanan9b6898f2011-07-30 02:42:06 +00002518 ASTContext *ast = var_type->GetClangASTContext().getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +00002519
Greg Claytonb01000f2011-01-17 03:46:26 +00002520 if (!ast)
Chris Lattner24943d22010-06-08 16:52:24 +00002521 {
Sean Callanan810f22d2010-07-16 00:09:46 +00002522 if (log)
2523 log->PutCString("There is no AST context for the current execution context");
Sean Callanan336a0002010-07-17 00:43:37 +00002524 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002525 }
2526
Sean Callanan336a0002010-07-17 00:43:37 +00002527 DWARFExpression &var_location_expr = var->LocationExpression();
2528
Chris Lattner24943d22010-06-08 16:52:24 +00002529 std::auto_ptr<Value> var_location(new Value);
2530
Greg Clayton178710c2010-09-14 02:20:48 +00002531 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
2532
2533 if (var_location_expr.IsLocationList())
2534 {
2535 SymbolContext var_sc;
2536 var->CalculateSymbolContext (&var_sc);
Greg Claytoneea26402010-09-14 23:36:40 +00002537 loclist_base_load_addr = var_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.target);
Greg Clayton178710c2010-09-14 02:20:48 +00002538 }
Chris Lattner24943d22010-06-08 16:52:24 +00002539 Error err;
2540
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00002541 if (!var_location_expr.Evaluate(&exe_ctx, ast, NULL, NULL, NULL, loclist_base_load_addr, NULL, *var_location.get(), &err))
Chris Lattner24943d22010-06-08 16:52:24 +00002542 {
Sean Callanan810f22d2010-07-16 00:09:46 +00002543 if (log)
2544 log->Printf("Error evaluating location: %s", err.AsCString());
Sean Callanan336a0002010-07-17 00:43:37 +00002545 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002546 }
Greg Claytonb01000f2011-01-17 03:46:26 +00002547
Sean Callanan58baaad2011-07-08 00:39:14 +00002548 void *type_to_use = NULL;
Sean Callanan336a0002010-07-17 00:43:37 +00002549
Sean Callananf328c9f2010-07-20 23:31:16 +00002550 if (parser_ast_context)
2551 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002552 type_to_use = GuardedCopyType(parser_ast_context, ast, var_opaque_type);
Sean Callananf328c9f2010-07-20 23:31:16 +00002553
Sean Callanan4b5eec62010-11-20 02:19:29 +00002554 if (!type_to_use)
2555 {
2556 if (log)
2557 log->Printf("Couldn't copy a variable's type into the parser's AST context");
2558
2559 return NULL;
2560 }
2561
Sean Callananf328c9f2010-07-20 23:31:16 +00002562 if (parser_type)
2563 *parser_type = TypeFromParser(type_to_use, parser_ast_context);
2564 }
Sean Callanan336a0002010-07-17 00:43:37 +00002565 else
2566 type_to_use = var_opaque_type;
Chris Lattner24943d22010-06-08 16:52:24 +00002567
2568 if (var_location.get()->GetContextType() == Value::eContextTypeInvalid)
Greg Clayton6916e352010-11-13 03:52:47 +00002569 var_location.get()->SetContext(Value::eContextTypeClangType, type_to_use);
Chris Lattner24943d22010-06-08 16:52:24 +00002570
2571 if (var_location.get()->GetValueType() == Value::eValueTypeFileAddress)
2572 {
2573 SymbolContext var_sc;
2574 var->CalculateSymbolContext(&var_sc);
Sean Callanan336a0002010-07-17 00:43:37 +00002575
Chris Lattner24943d22010-06-08 16:52:24 +00002576 if (!var_sc.module_sp)
Sean Callanan336a0002010-07-17 00:43:37 +00002577 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002578
2579 ObjectFile *object_file = var_sc.module_sp->GetObjectFile();
2580
2581 if (!object_file)
Sean Callanan336a0002010-07-17 00:43:37 +00002582 return NULL;
2583
Chris Lattner24943d22010-06-08 16:52:24 +00002584 Address so_addr(var_location->GetScalar().ULongLong(), object_file->GetSectionList());
2585
Sean Callananaa301c42010-12-03 01:38:59 +00002586 lldb::addr_t load_addr = so_addr.GetLoadAddress(exe_ctx.target);
Chris Lattner24943d22010-06-08 16:52:24 +00002587
Sean Callanan47dc4572011-09-15 02:13:07 +00002588 if (load_addr != LLDB_INVALID_ADDRESS)
2589 {
2590 var_location->GetScalar() = load_addr;
2591 var_location->SetValueType(Value::eValueTypeLoadAddress);
2592 }
Chris Lattner24943d22010-06-08 16:52:24 +00002593 }
2594
Sean Callananf328c9f2010-07-20 23:31:16 +00002595 if (user_type)
Greg Claytonb01000f2011-01-17 03:46:26 +00002596 *user_type = TypeFromUser(var_opaque_type, ast);
Sean Callanan336a0002010-07-17 00:43:37 +00002597
2598 return var_location.release();
2599}
2600
2601void
Sean Callanan696cf5f2011-05-07 01:06:41 +00002602ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP var)
Sean Callanan336a0002010-07-17 00:43:37 +00002603{
Sean Callananaa301c42010-12-03 01:38:59 +00002604 assert (m_parser_vars.get());
2605
Greg Claytone005f2c2010-11-06 01:53:30 +00002606 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan47dc4572011-09-15 02:13:07 +00002607
Sean Callananf328c9f2010-07-20 23:31:16 +00002608 TypeFromUser ut;
2609 TypeFromParser pt;
Sean Callanan336a0002010-07-17 00:43:37 +00002610
Sean Callananaa301c42010-12-03 01:38:59 +00002611 Value *var_location = GetVariableValue (*m_parser_vars->m_exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +00002612 var,
2613 context.GetASTContext(),
2614 &ut,
2615 &pt);
Sean Callanan336a0002010-07-17 00:43:37 +00002616
Sean Callanan4b5eec62010-11-20 02:19:29 +00002617 if (!var_location)
2618 return;
2619
Sean Callanan6a925532011-01-13 08:53:35 +00002620 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(pt.GetASTContext(), pt.GetOpaqueQualType()));
Greg Clayton8de27c72010-10-15 22:48:33 +00002621 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00002622 ConstString entity_name(decl_name.c_str());
Jim Inghamfa3a16a2011-03-31 00:19:25 +00002623 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope (),
2624 entity_name,
Greg Clayton427f2902010-12-14 02:59:59 +00002625 ut,
Sean Callanan47dc4572011-09-15 02:13:07 +00002626 m_parser_vars->m_target_info.byte_order,
2627 m_parser_vars->m_target_info.address_byte_size));
Greg Clayton427f2902010-12-14 02:59:59 +00002628 assert (entity.get());
2629 entity->EnableParserVars();
2630 entity->m_parser_vars->m_parser_type = pt;
2631 entity->m_parser_vars->m_named_decl = var_decl;
2632 entity->m_parser_vars->m_llvm_value = NULL;
2633 entity->m_parser_vars->m_lldb_value = var_location;
Sean Callanan696cf5f2011-05-07 01:06:41 +00002634 entity->m_parser_vars->m_lldb_var = var;
Chris Lattner24943d22010-06-08 16:52:24 +00002635
Sean Callanan810f22d2010-07-16 00:09:46 +00002636 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00002637 {
Sean Callanana0744822010-11-01 23:22:47 +00002638 std::string var_decl_print_string;
2639 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2640 var_decl->print(var_decl_print_stream);
2641 var_decl_print_stream.flush();
2642
2643 log->Printf("Found variable %s, returned %s", decl_name.c_str(), var_decl_print_string.c_str());
Sean Callanan6e74dbb2011-02-01 23:43:26 +00002644
Sean Callanan9b6898f2011-07-30 02:42:06 +00002645 //if (log->GetVerbose())
2646 //{
2647 // StreamString var_decl_dump_string;
2648 // ASTDumper::DumpDecl(var_decl_dump_string, var_decl);
2649 // log->Printf("%s\n", var_decl_dump_string.GetData());
2650 //}
Greg Clayton8de27c72010-10-15 22:48:33 +00002651 }
Sean Callanan8f0dc342010-06-22 23:46:24 +00002652}
2653
2654void
Sean Callanana48fe162010-08-11 03:57:18 +00002655ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
Greg Clayton427f2902010-12-14 02:59:59 +00002656 ClangExpressionVariableSP &pvar_sp)
Sean Callanana48fe162010-08-11 03:57:18 +00002657{
Greg Claytone005f2c2010-11-06 01:53:30 +00002658 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan45690fe2010-08-30 22:17:16 +00002659
Greg Clayton427f2902010-12-14 02:59:59 +00002660 TypeFromUser user_type (pvar_sp->GetTypeFromUser());
Sean Callanana48fe162010-08-11 03:57:18 +00002661
Greg Clayton427f2902010-12-14 02:59:59 +00002662 TypeFromParser parser_type (GuardedCopyType(context.GetASTContext(),
2663 user_type.GetASTContext(),
2664 user_type.GetOpaqueQualType()),
2665 context.GetASTContext());
Sean Callanana48fe162010-08-11 03:57:18 +00002666
Sean Callanan6a925532011-01-13 08:53:35 +00002667 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(parser_type.GetASTContext(), parser_type.GetOpaqueQualType()));
Sean Callanan8c127202010-08-23 23:09:38 +00002668
Greg Clayton427f2902010-12-14 02:59:59 +00002669 pvar_sp->EnableParserVars();
2670 pvar_sp->m_parser_vars->m_parser_type = parser_type;
2671 pvar_sp->m_parser_vars->m_named_decl = var_decl;
2672 pvar_sp->m_parser_vars->m_llvm_value = NULL;
2673 pvar_sp->m_parser_vars->m_lldb_value = NULL;
Sean Callanan45690fe2010-08-30 22:17:16 +00002674
2675 if (log)
Sean Callanana0744822010-11-01 23:22:47 +00002676 {
2677 std::string var_decl_print_string;
2678 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2679 var_decl->print(var_decl_print_stream);
2680 var_decl_print_stream.flush();
2681
Greg Clayton427f2902010-12-14 02:59:59 +00002682 log->Printf("Added pvar %s, returned %s", pvar_sp->GetName().GetCString(), var_decl_print_string.c_str());
Sean Callanana0744822010-11-01 23:22:47 +00002683 }
Sean Callanana48fe162010-08-11 03:57:18 +00002684}
2685
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002686void
Sean Callanan81974962011-05-08 02:21:26 +00002687ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
2688 Symbol &symbol)
2689{
2690 assert(m_parser_vars.get());
2691
2692 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2693
Sean Callanan9b6898f2011-07-30 02:42:06 +00002694 ASTContext *scratch_ast_context = m_parser_vars->m_exe_ctx->target->GetScratchClangASTContext()->getASTContext();
Sean Callanan81974962011-05-08 02:21:26 +00002695
Sean Callananfb3058e2011-05-12 23:54:16 +00002696 TypeFromUser user_type (ClangASTContext::CreateLValueReferenceType(scratch_ast_context, ClangASTContext::GetVoidPtrType(scratch_ast_context, true)),
Sean Callanan81974962011-05-08 02:21:26 +00002697 scratch_ast_context);
2698
Sean Callananfb3058e2011-05-12 23:54:16 +00002699 TypeFromParser parser_type (ClangASTContext::CreateLValueReferenceType(scratch_ast_context, ClangASTContext::GetVoidPtrType(context.GetASTContext(), true)),
Sean Callanan81974962011-05-08 02:21:26 +00002700 context.GetASTContext());
2701
Sean Callananfb3058e2011-05-12 23:54:16 +00002702 NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
Sean Callanan81974962011-05-08 02:21:26 +00002703
2704 std::string decl_name(context.m_decl_name.getAsString());
2705 ConstString entity_name(decl_name.c_str());
2706 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope (),
2707 entity_name,
2708 user_type,
Sean Callanan47dc4572011-09-15 02:13:07 +00002709 m_parser_vars->m_target_info.byte_order,
2710 m_parser_vars->m_target_info.address_byte_size));
Sean Callanan81974962011-05-08 02:21:26 +00002711 assert (entity.get());
Sean Callanan81974962011-05-08 02:21:26 +00002712
2713 std::auto_ptr<Value> symbol_location(new Value);
2714
2715 AddressRange &symbol_range = symbol.GetAddressRangeRef();
2716 Address &symbol_address = symbol_range.GetBaseAddress();
2717 lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(m_parser_vars->m_exe_ctx->target);
2718
2719 symbol_location->SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
2720 symbol_location->GetScalar() = symbol_load_addr;
2721 symbol_location->SetValueType(Value::eValueTypeLoadAddress);
2722
Sean Callananfb3058e2011-05-12 23:54:16 +00002723 entity->EnableParserVars();
Sean Callanan81974962011-05-08 02:21:26 +00002724 entity->m_parser_vars->m_parser_type = parser_type;
2725 entity->m_parser_vars->m_named_decl = var_decl;
2726 entity->m_parser_vars->m_llvm_value = NULL;
2727 entity->m_parser_vars->m_lldb_value = symbol_location.release();
2728 entity->m_parser_vars->m_lldb_sym = &symbol;
Sean Callananfb3058e2011-05-12 23:54:16 +00002729 //entity->m_flags |= ClangExpressionVariable::EVUnknownType;
Sean Callanan81974962011-05-08 02:21:26 +00002730
2731 if (log)
2732 {
2733 std::string var_decl_print_string;
2734 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2735 var_decl->print(var_decl_print_stream);
2736 var_decl_print_stream.flush();
2737
2738 log->Printf("Found variable %s, returned %s", decl_name.c_str(), var_decl_print_string.c_str());
2739
Sean Callanan9b6898f2011-07-30 02:42:06 +00002740 //if (log->GetVerbose())
2741 //{
2742 // StreamString var_decl_dump_string;
2743 // ASTDumper::DumpDecl(var_decl_dump_string, var_decl);
2744 // log->Printf("%s\n", var_decl_dump_string.GetData());
2745 //}
Sean Callanan81974962011-05-08 02:21:26 +00002746 }
2747}
2748
Sean Callananfb3058e2011-05-12 23:54:16 +00002749bool
2750ClangExpressionDeclMap::ResolveUnknownTypes()
2751{
2752 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2753
Sean Callanan9b6898f2011-07-30 02:42:06 +00002754 ASTContext *scratch_ast_context = m_parser_vars->m_exe_ctx->target->GetScratchClangASTContext()->getASTContext();
Sean Callananfb3058e2011-05-12 23:54:16 +00002755
2756 for (size_t index = 0, num_entities = m_found_entities.GetSize();
2757 index < num_entities;
2758 ++index)
2759 {
2760 ClangExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
2761
2762 if (entity->m_flags & ClangExpressionVariable::EVUnknownType)
2763 {
2764 const NamedDecl *named_decl = entity->m_parser_vars->m_named_decl;
2765 const VarDecl *var_decl = dyn_cast<VarDecl>(named_decl);
2766
2767 if (!var_decl)
2768 {
2769 if (log)
2770 log->Printf("Entity of unknown type does not have a VarDecl");
2771 return false;
2772 }
2773
2774 if (log)
2775 {
2776 std::string var_decl_print_string;
2777 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2778 var_decl->print(var_decl_print_stream);
2779 var_decl_print_stream.flush();
2780
2781 log->Printf("Variable of unknown type now has Decl %s", var_decl_print_string.c_str());
2782 }
2783
2784 QualType var_type = var_decl->getType();
2785 TypeFromParser parser_type(var_type.getAsOpaquePtr(), &var_decl->getASTContext());
2786
2787 lldb::clang_type_t copied_type = ClangASTContext::CopyType(scratch_ast_context, &var_decl->getASTContext(), var_type.getAsOpaquePtr());
2788
2789 TypeFromUser user_type(copied_type, scratch_ast_context);
2790
2791 entity->m_parser_vars->m_lldb_value->SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
2792 entity->m_parser_vars->m_parser_type = parser_type;
2793
2794 entity->SetClangAST(user_type.GetASTContext());
2795 entity->SetClangType(user_type.GetOpaqueQualType());
2796
2797 entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);
2798 }
2799 }
2800
2801 return true;
2802}
2803
Sean Callanan81974962011-05-08 02:21:26 +00002804void
Greg Clayton427f2902010-12-14 02:59:59 +00002805ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
2806 const RegisterInfo *reg_info)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002807{
2808 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2809
2810 void *ast_type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(context.GetASTContext(),
2811 reg_info->encoding,
2812 reg_info->byte_size * 8);
2813
2814 if (!ast_type)
2815 {
Johnny Chen122204d2011-08-09 22:52:27 +00002816 if (log)
2817 log->Printf("Tried to add a type for %s, but couldn't get one", context.m_decl_name.getAsString().c_str());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002818 return;
2819 }
2820
Greg Clayton427f2902010-12-14 02:59:59 +00002821 TypeFromParser parser_type (ast_type,
2822 context.GetASTContext());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002823
2824 NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
2825
Jim Inghamfa3a16a2011-03-31 00:19:25 +00002826 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope(),
Sean Callanan47dc4572011-09-15 02:13:07 +00002827 m_parser_vars->m_target_info.byte_order,
2828 m_parser_vars->m_target_info.address_byte_size));
Greg Clayton427f2902010-12-14 02:59:59 +00002829 assert (entity.get());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002830 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00002831 entity->SetName (ConstString (decl_name.c_str()));
2832 entity->SetRegisterInfo (reg_info);
2833 entity->EnableParserVars();
2834 entity->m_parser_vars->m_parser_type = parser_type;
2835 entity->m_parser_vars->m_named_decl = var_decl;
2836 entity->m_parser_vars->m_llvm_value = NULL;
2837 entity->m_parser_vars->m_lldb_value = NULL;
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002838
2839 if (log)
2840 {
2841 std::string var_decl_print_string;
2842 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2843 var_decl->print(var_decl_print_stream);
2844 var_decl_print_stream.flush();
2845
2846 log->Printf("Added register %s, returned %s", context.m_decl_name.getAsString().c_str(), var_decl_print_string.c_str());
2847 }
2848}
2849
Sean Callanan9b6898f2011-07-30 02:42:06 +00002850NamespaceDecl *
Greg Clayton6916e352010-11-13 03:52:47 +00002851ClangExpressionDeclMap::AddNamespace (NameSearchContext &context, const ClangNamespaceDecl &namespace_decl)
2852{
2853 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2854
Greg Claytone6d72ca2011-06-25 00:44:06 +00002855 assert (m_parser_vars.get());
2856
Sean Callanan9b6898f2011-07-30 02:42:06 +00002857 Decl *copied_decl = m_parser_vars->GetASTImporter(context.GetASTContext())->CopyDecl(namespace_decl.GetASTContext(),
Greg Claytone6d72ca2011-06-25 00:44:06 +00002858 namespace_decl.GetNamespaceDecl());
Greg Clayton6916e352010-11-13 03:52:47 +00002859
Sean Callanan9b6898f2011-07-30 02:42:06 +00002860 return dyn_cast<NamespaceDecl>(copied_decl);
Greg Clayton6916e352010-11-13 03:52:47 +00002861}
2862
Sean Callanana48fe162010-08-11 03:57:18 +00002863void
Greg Claytonda7af842011-05-18 22:01:49 +00002864ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
2865 Function* fun,
2866 Symbol* symbol)
Sean Callanan8f0dc342010-06-22 23:46:24 +00002867{
Sean Callananaa301c42010-12-03 01:38:59 +00002868 assert (m_parser_vars.get());
2869
Greg Claytone005f2c2010-11-06 01:53:30 +00002870 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan8f0dc342010-06-22 23:46:24 +00002871
Sean Callanan58baaad2011-07-08 00:39:14 +00002872 NamedDecl *fun_decl = NULL;
Sean Callanan8f0dc342010-06-22 23:46:24 +00002873 std::auto_ptr<Value> fun_location(new Value);
Sean Callanan58baaad2011-07-08 00:39:14 +00002874 const Address *fun_address = NULL;
Sean Callanan8f0dc342010-06-22 23:46:24 +00002875
Sean Callanan0fc73582010-07-27 00:55:47 +00002876 // only valid for Functions, not for Symbols
2877 void *fun_opaque_type = NULL;
Sean Callanan9b6898f2011-07-30 02:42:06 +00002878 ASTContext *fun_ast_context = NULL;
Sean Callanan0fc73582010-07-27 00:55:47 +00002879
2880 if (fun)
2881 {
2882 Type *fun_type = fun->GetType();
2883
2884 if (!fun_type)
2885 {
2886 if (log)
2887 log->PutCString("Skipped a function because it has no type");
2888 return;
2889 }
2890
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002891 fun_opaque_type = fun_type->GetClangFullType();
Sean Callanan0fc73582010-07-27 00:55:47 +00002892
2893 if (!fun_opaque_type)
2894 {
2895 if (log)
2896 log->PutCString("Skipped a function because it has no Clang type");
2897 return;
2898 }
2899
2900 fun_address = &fun->GetAddressRange().GetBaseAddress();
2901
Greg Claytonb01000f2011-01-17 03:46:26 +00002902 fun_ast_context = fun_type->GetClangASTContext().getASTContext();
Sean Callananee8fc722010-11-19 20:20:02 +00002903 void *copied_type = GuardedCopyType(context.GetASTContext(), fun_ast_context, fun_opaque_type);
Sean Callanan0fc73582010-07-27 00:55:47 +00002904
2905 fun_decl = context.AddFunDecl(copied_type);
2906 }
2907 else if (symbol)
2908 {
2909 fun_address = &symbol->GetAddressRangeRef().GetBaseAddress();
2910
2911 fun_decl = context.AddGenericFunDecl();
2912 }
2913 else
2914 {
2915 if (log)
2916 log->PutCString("AddOneFunction called with no function and no symbol");
2917 return;
2918 }
2919
Greg Claytonda7af842011-05-18 22:01:49 +00002920 lldb::addr_t load_addr = fun_address->GetCallableLoadAddress(m_parser_vars->m_exe_ctx->target);
Sean Callanan8f0dc342010-06-22 23:46:24 +00002921 fun_location->SetValueType(Value::eValueTypeLoadAddress);
2922 fun_location->GetScalar() = load_addr;
2923
Jim Inghamfa3a16a2011-03-31 00:19:25 +00002924 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope (),
Sean Callanan47dc4572011-09-15 02:13:07 +00002925 m_parser_vars->m_target_info.byte_order,
2926 m_parser_vars->m_target_info.address_byte_size));
Greg Clayton427f2902010-12-14 02:59:59 +00002927 assert (entity.get());
Greg Clayton8de27c72010-10-15 22:48:33 +00002928 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00002929 entity->SetName(ConstString(decl_name.c_str()));
2930 entity->SetClangType (fun_opaque_type);
2931 entity->SetClangAST (fun_ast_context);
Sean Callanan8f0dc342010-06-22 23:46:24 +00002932
Greg Clayton427f2902010-12-14 02:59:59 +00002933 entity->EnableParserVars();
2934 entity->m_parser_vars->m_named_decl = fun_decl;
2935 entity->m_parser_vars->m_llvm_value = NULL;
2936 entity->m_parser_vars->m_lldb_value = fun_location.release();
Sean Callanan8c127202010-08-23 23:09:38 +00002937
Sean Callanan810f22d2010-07-16 00:09:46 +00002938 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00002939 {
Sean Callanana0744822010-11-01 23:22:47 +00002940 std::string fun_decl_print_string;
2941 llvm::raw_string_ostream fun_decl_print_stream(fun_decl_print_string);
2942 fun_decl->print(fun_decl_print_stream);
2943 fun_decl_print_stream.flush();
2944
2945 log->Printf("Found %s function %s, returned %s", (fun ? "specific" : "generic"), decl_name.c_str(), fun_decl_print_string.c_str());
Greg Clayton8de27c72010-10-15 22:48:33 +00002946 }
Chris Lattner24943d22010-06-08 16:52:24 +00002947}
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002948
2949void
2950ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002951 TypeFromUser &ut,
2952 bool add_method)
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002953{
Sean Callanan9b6898f2011-07-30 02:42:06 +00002954 ASTContext *parser_ast_context = context.GetASTContext();
2955 ASTContext *user_ast_context = ut.GetASTContext();
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002956
Sean Callananee8fc722010-11-19 20:20:02 +00002957 void *copied_type = GuardedCopyType(parser_ast_context, user_ast_context, ut.GetOpaqueQualType());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002958
2959 TypeFromParser parser_type(copied_type, parser_ast_context);
2960
2961 if (add_method && ClangASTContext::IsAggregateType(copied_type))
2962 {
2963 void *args[1];
2964
2965 args[0] = ClangASTContext::GetVoidPtrType(parser_ast_context, false);
2966
2967 void *method_type = ClangASTContext::CreateFunctionType (parser_ast_context,
2968 ClangASTContext::GetBuiltInType_void(parser_ast_context),
2969 args,
2970 1,
2971 false,
2972 ClangASTContext::GetTypeQualifiers(copied_type));
Greg Clayton30449d52010-10-01 02:31:07 +00002973
Greg Clayton1d8173f2010-09-24 05:15:53 +00002974 const bool is_virtual = false;
2975 const bool is_static = false;
2976 const bool is_inline = false;
Greg Clayton30449d52010-10-01 02:31:07 +00002977 const bool is_explicit = false;
2978
Greg Clayton1d8173f2010-09-24 05:15:53 +00002979 ClangASTContext::AddMethodToCXXRecordType (parser_ast_context,
2980 copied_type,
Greg Clayton8de27c72010-10-15 22:48:33 +00002981 "$__lldb_expr",
Greg Clayton1d8173f2010-09-24 05:15:53 +00002982 method_type,
2983 lldb::eAccessPublic,
2984 is_virtual,
2985 is_static,
Greg Clayton30449d52010-10-01 02:31:07 +00002986 is_inline,
2987 is_explicit);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002988 }
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002989
2990 context.AddTypeDecl(copied_type);
2991}
Sean Callananee8fc722010-11-19 20:20:02 +00002992
2993void *
2994ClangExpressionDeclMap::GuardedCopyType (ASTContext *dest_context,
2995 ASTContext *source_context,
2996 void *clang_type)
2997{
Sean Callananaa301c42010-12-03 01:38:59 +00002998 assert (m_parser_vars.get());
2999
3000 m_parser_vars->m_ignore_lookups = true;
Sean Callananee8fc722010-11-19 20:20:02 +00003001
Greg Claytone6d72ca2011-06-25 00:44:06 +00003002 lldb_private::ClangASTImporter *importer = m_parser_vars->GetASTImporter(dest_context);
3003
3004 QualType ret_qual_type = importer->CopyType (source_context,
3005 QualType::getFromOpaquePtr(clang_type));
3006
3007 void *ret = ret_qual_type.getAsOpaquePtr();
Sean Callananee8fc722010-11-19 20:20:02 +00003008
Sean Callananaa301c42010-12-03 01:38:59 +00003009 m_parser_vars->m_ignore_lookups = false;
Sean Callananee8fc722010-11-19 20:20:02 +00003010
3011 return ret;
3012}