blob: 9e0f67c9c1db6bc833d62a15a6553c7e87ba350d [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"
Sean Callanan05a5a1b2010-12-16 03:17:46 +000023#include "lldb/Core/ValueObjectConstResult.h"
Sean Callanan6e74dbb2011-02-01 23:43:26 +000024#include "lldb/Expression/ASTDumper.h"
Chris Lattner24943d22010-06-08 16:52:24 +000025#include "lldb/Expression/ClangASTSource.h"
Sean Callanana48fe162010-08-11 03:57:18 +000026#include "lldb/Expression/ClangPersistentVariables.h"
Greg Claytoncd548032011-02-01 01:31:41 +000027#include "lldb/Host/Endian.h"
Chris Lattner24943d22010-06-08 16:52:24 +000028#include "lldb/Symbol/ClangASTContext.h"
Greg Clayton6916e352010-11-13 03:52:47 +000029#include "lldb/Symbol/ClangNamespaceDecl.h"
Chris Lattner24943d22010-06-08 16:52:24 +000030#include "lldb/Symbol/CompileUnit.h"
31#include "lldb/Symbol/Function.h"
32#include "lldb/Symbol/ObjectFile.h"
33#include "lldb/Symbol/SymbolContext.h"
34#include "lldb/Symbol/Type.h"
35#include "lldb/Symbol/TypeList.h"
36#include "lldb/Symbol/Variable.h"
37#include "lldb/Symbol/VariableList.h"
Sean Callananf328c9f2010-07-20 23:31:16 +000038#include "lldb/Target/ExecutionContext.h"
Sean Callanan810f22d2010-07-16 00:09:46 +000039#include "lldb/Target/Process.h"
Sean Callanan17c6a052010-10-05 20:18:48 +000040#include "lldb/Target/RegisterContext.h"
Chris Lattner24943d22010-06-08 16:52:24 +000041#include "lldb/Target/StackFrame.h"
Sean Callananf328c9f2010-07-20 23:31:16 +000042#include "lldb/Target/Target.h"
Jim Ingham78b9ee82010-12-07 01:56:02 +000043#include "lldb/Target/Thread.h"
Sean Callanana0744822010-11-01 23:22:47 +000044#include "llvm/Support/raw_ostream.h"
Chris Lattner24943d22010-06-08 16:52:24 +000045
Greg Clayton3bc52d02010-11-14 22:13:40 +000046using namespace lldb;
Chris Lattner24943d22010-06-08 16:52:24 +000047using namespace lldb_private;
48using namespace clang;
49
Sean Callanan6a925532011-01-13 08:53:35 +000050ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory) :
Greg Clayton8de27c72010-10-15 22:48:33 +000051 m_found_entities (),
52 m_struct_members (),
Stephen Wilsondbeb3e12011-04-11 19:41:40 +000053 m_keep_result_in_memory (keep_result_in_memory),
Sean Callananaa301c42010-12-03 01:38:59 +000054 m_parser_vars (),
Stephen Wilsondbeb3e12011-04-11 19:41:40 +000055 m_struct_vars ()
Chris Lattner24943d22010-06-08 16:52:24 +000056{
Sean Callananaa301c42010-12-03 01:38:59 +000057 EnableStructVars();
Chris Lattner24943d22010-06-08 16:52:24 +000058}
59
60ClangExpressionDeclMap::~ClangExpressionDeclMap()
Sean Callananaa301c42010-12-03 01:38:59 +000061{
62 DidDematerialize();
63 DisableStructVars();
64}
Sean Callananc2c6f772010-10-26 00:31:56 +000065
Greg Clayton427f2902010-12-14 02:59:59 +000066void
67ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx)
Sean Callananaa301c42010-12-03 01:38:59 +000068{
69 EnableParserVars();
70 m_parser_vars->m_exe_ctx = &exe_ctx;
71
72 if (exe_ctx.frame)
73 m_parser_vars->m_sym_ctx = exe_ctx.frame->GetSymbolContext(lldb::eSymbolContextEverything);
Jim Ingham78b9ee82010-12-07 01:56:02 +000074 else if (exe_ctx.thread)
75 m_parser_vars->m_sym_ctx = exe_ctx.thread->GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
Jim Inghamef80aab2011-05-02 18:13:59 +000076 else if (exe_ctx.process)
77 m_parser_vars->m_sym_ctx = SymbolContext(exe_ctx.target->GetSP(), ModuleSP());
Greg Clayton427f2902010-12-14 02:59:59 +000078 if (exe_ctx.target)
79 m_parser_vars->m_persistent_vars = &exe_ctx.target->GetPersistentVariables();
Sean Callananaa301c42010-12-03 01:38:59 +000080}
81
Greg Clayton427f2902010-12-14 02:59:59 +000082void
83ClangExpressionDeclMap::DidParse()
Sean Callananaa301c42010-12-03 01:38:59 +000084{
85 if (m_parser_vars.get())
86 {
Greg Clayton427f2902010-12-14 02:59:59 +000087 for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +000088 entity_index < num_entities;
89 ++entity_index)
90 {
Greg Clayton427f2902010-12-14 02:59:59 +000091 ClangExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
92 if (var_sp &&
93 var_sp->m_parser_vars.get() &&
94 var_sp->m_parser_vars->m_lldb_value)
95 delete var_sp->m_parser_vars->m_lldb_value;
Sean Callananaa301c42010-12-03 01:38:59 +000096
Greg Clayton427f2902010-12-14 02:59:59 +000097 var_sp->DisableParserVars();
Sean Callananaa301c42010-12-03 01:38:59 +000098 }
99
Greg Clayton427f2902010-12-14 02:59:59 +0000100 for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +0000101 pvar_index < num_pvars;
102 ++pvar_index)
103 {
Greg Clayton427f2902010-12-14 02:59:59 +0000104 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
105 if (pvar_sp)
106 pvar_sp->DisableParserVars();
Sean Callananaa301c42010-12-03 01:38:59 +0000107 }
108
109 DisableParserVars();
Sean Callanan7a60b942010-10-08 01:58:41 +0000110 }
Chris Lattner24943d22010-06-08 16:52:24 +0000111}
112
Sean Callanan8bce6652010-07-13 21:41:46 +0000113// Interface for IRForTarget
114
Greg Clayton8de27c72010-10-15 22:48:33 +0000115const ConstString &
116ClangExpressionDeclMap::GetPersistentResultName ()
Sean Callanan82b74c82010-08-12 01:56:52 +0000117{
Sean Callananaa301c42010-12-03 01:38:59 +0000118 assert (m_struct_vars.get());
119 assert (m_parser_vars.get());
Sean Callananaa301c42010-12-03 01:38:59 +0000120 if (!m_struct_vars->m_result_name)
Greg Clayton427f2902010-12-14 02:59:59 +0000121 {
122 Target *target = m_parser_vars->GetTarget();
123 assert (target);
124 m_struct_vars->m_result_name = target->GetPersistentVariables().GetNextPersistentVariableName();
125 }
Sean Callananaa301c42010-12-03 01:38:59 +0000126 return m_struct_vars->m_result_name;
Sean Callanan82b74c82010-08-12 01:56:52 +0000127}
128
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000129lldb::ClangExpressionVariableSP
130ClangExpressionDeclMap::BuildIntegerVariable (const ConstString &name,
131 lldb_private::TypeFromParser type,
132 const llvm::APInt& value)
133{
134 assert (m_parser_vars.get());
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000135 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
136 clang::ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000137
138 TypeFromUser user_type(ClangASTContext::CopyType(context,
139 type.GetASTContext(),
140 type.GetOpaqueQualType()),
141 context);
Sean Callanan696cf5f2011-05-07 01:06:41 +0000142
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000143 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx->GetBestExecutionContextScope (),
144 name,
Sean Callanan0e0817d2011-01-04 02:41:41 +0000145 user_type,
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000146 exe_ctx->process->GetByteOrder(),
147 exe_ctx->process->GetAddressByteSize()))
Sean Callanan0e0817d2011-01-04 02:41:41 +0000148 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000149
Sean Callanan0e0817d2011-01-04 02:41:41 +0000150 ClangExpressionVariableSP pvar_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
151
152 if (!pvar_sp)
153 return lldb::ClangExpressionVariableSP();
154
155 uint8_t *pvar_data = pvar_sp->GetValueBytes();
156 if (pvar_data == NULL)
157 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000158
159 uint64_t value64 = value.getLimitedValue();
160
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000161 ByteOrder byte_order = exe_ctx->process->GetByteOrder();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000162
163 size_t num_val_bytes = sizeof(value64);
Sean Callanan0e0817d2011-01-04 02:41:41 +0000164 size_t num_data_bytes = pvar_sp->GetByteSize();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000165
166 size_t num_bytes = num_val_bytes;
167 if (num_bytes > num_data_bytes)
168 num_bytes = num_data_bytes;
169
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000170 for (off_t byte_idx = 0;
171 byte_idx < num_bytes;
172 ++byte_idx)
173 {
174 uint64_t shift = byte_idx * 8;
175 uint64_t mask = 0xffll << shift;
176 uint8_t cur_byte = (uint8_t)((value64 & mask) >> shift);
177
178 switch (byte_order)
179 {
Sean Callanan0e0817d2011-01-04 02:41:41 +0000180 case eByteOrderBig:
181 // High Low
182 // Original: |AABBCCDDEEFFGGHH|
183 // Target: |EEFFGGHH|
184
185 pvar_data[num_data_bytes - (1 + byte_idx)] = cur_byte;
186 break;
187 case eByteOrderLittle:
188 // Target: |HHGGFFEE|
189 pvar_data[byte_idx] = cur_byte;
190 break;
191 default:
192 return lldb::ClangExpressionVariableSP();
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000193 }
194 }
Sean Callanan6a925532011-01-13 08:53:35 +0000195
196 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
Sean Callanan696cf5f2011-05-07 01:06:41 +0000197 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
198 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
Sean Callanan0e0817d2011-01-04 02:41:41 +0000199
200 return pvar_sp;
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000201}
202
Sean Callanan696cf5f2011-05-07 01:06:41 +0000203lldb::ClangExpressionVariableSP
204ClangExpressionDeclMap::BuildCastVariable (const ConstString &name,
205 clang::VarDecl *decl,
206 lldb_private::TypeFromParser type)
207{
208 assert (m_parser_vars.get());
209
210 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
211
212 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
213 clang::ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
214
215 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl));
216
217 if (!var_sp)
218 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl);
219
220 if (!var_sp)
221 return ClangExpressionVariableSP();
222
223 TypeFromUser user_type(ClangASTContext::CopyType(context,
224 type.GetASTContext(),
225 type.GetOpaqueQualType()),
226 context);
227
228 TypeFromUser var_type = var_sp->GetTypeFromUser();
229
230 VariableSP var = FindVariableInScope (*exe_ctx->frame, var_sp->GetName(), &var_type);
231
232 if (!var)
233 return lldb::ClangExpressionVariableSP(); // but we should handle this; it may be a persistent variable
234
235 ValueObjectSP var_valobj = exe_ctx->frame->GetValueObjectForFrameVariable(var, lldb::eNoDynamicValues);
236
237 if (!var_valobj)
238 return lldb::ClangExpressionVariableSP();
239
240 ValueObjectSP var_casted_valobj = var_valobj->CastPointerType(name.GetCString(), user_type);
241
242 if (!var_casted_valobj)
243 return lldb::ClangExpressionVariableSP();
244
245 if (log)
246 {
247 StreamString my_stream_string;
248
249 ClangASTType::DumpTypeDescription (var_type.GetASTContext(),
250 var_type.GetOpaqueQualType(),
251 &my_stream_string);
252
253
254 log->Printf("Building cast variable to type: %s", my_stream_string.GetString().c_str());
255 }
256
257 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->CreatePersistentVariable (var_casted_valobj);
258
259 if (!pvar_sp)
260 return lldb::ClangExpressionVariableSP();
261
262 if (pvar_sp != m_parser_vars->m_persistent_vars->GetVariable(name))
263 return lldb::ClangExpressionVariableSP();
264
265 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
266 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
267 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
268
269 return pvar_sp;
270}
271
Sean Callanan8bce6652010-07-13 21:41:46 +0000272bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000273ClangExpressionDeclMap::AddPersistentVariable
274(
275 const clang::NamedDecl *decl,
276 const ConstString &name,
Sean Callanan6a925532011-01-13 08:53:35 +0000277 TypeFromParser parser_type,
278 bool is_result,
279 bool is_lvalue
Greg Clayton8de27c72010-10-15 22:48:33 +0000280)
Sean Callanana48fe162010-08-11 03:57:18 +0000281{
Sean Callananaa301c42010-12-03 01:38:59 +0000282 assert (m_parser_vars.get());
283
Sean Callanan6a925532011-01-13 08:53:35 +0000284 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000285 ExecutionContext *exe_ctx = m_parser_vars->m_exe_ctx;
Sean Callanan6a925532011-01-13 08:53:35 +0000286
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000287 clang::ASTContext *context(exe_ctx->target->GetScratchClangASTContext()->getASTContext());
Sean Callanana48fe162010-08-11 03:57:18 +0000288
Sean Callanana48fe162010-08-11 03:57:18 +0000289 TypeFromUser user_type(ClangASTContext::CopyType(context,
Sean Callanan82b74c82010-08-12 01:56:52 +0000290 parser_type.GetASTContext(),
291 parser_type.GetOpaqueQualType()),
Sean Callanan97678d12011-01-13 21:23:32 +0000292 context);
Sean Callanana48fe162010-08-11 03:57:18 +0000293
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000294 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx->GetBestExecutionContextScope (),
295 name,
Greg Clayton427f2902010-12-14 02:59:59 +0000296 user_type,
Jim Inghamfa3a16a2011-03-31 00:19:25 +0000297 exe_ctx->process->GetByteOrder(),
298 exe_ctx->process->GetAddressByteSize()))
Sean Callanan8c127202010-08-23 23:09:38 +0000299 return false;
300
Greg Clayton427f2902010-12-14 02:59:59 +0000301 ClangExpressionVariableSP var_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
Sean Callanan8c127202010-08-23 23:09:38 +0000302
Greg Clayton427f2902010-12-14 02:59:59 +0000303 if (!var_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000304 return false;
305
Sean Callanan6a925532011-01-13 08:53:35 +0000306 if (is_result)
307 var_sp->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
308 else
309 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
310
311 if (is_lvalue)
312 {
313 var_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
314 }
315 else
316 {
317 var_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
318 var_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
319 }
320
321 if (log)
322 log->Printf("Created persistent variable with flags 0x%hx", var_sp->m_flags);
323
Greg Clayton427f2902010-12-14 02:59:59 +0000324 var_sp->EnableParserVars();
Sean Callanan8c127202010-08-23 23:09:38 +0000325
Greg Clayton427f2902010-12-14 02:59:59 +0000326 var_sp->m_parser_vars->m_named_decl = decl;
327 var_sp->m_parser_vars->m_parser_type = parser_type;
Sean Callanan8c127202010-08-23 23:09:38 +0000328
329 return true;
Sean Callanana48fe162010-08-11 03:57:18 +0000330}
331
332bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000333ClangExpressionDeclMap::AddValueToStruct
334(
335 const clang::NamedDecl *decl,
336 const ConstString &name,
337 llvm::Value *value,
338 size_t size,
339 off_t alignment
340)
Sean Callanan8bce6652010-07-13 21:41:46 +0000341{
Sean Callananaa301c42010-12-03 01:38:59 +0000342 assert (m_struct_vars.get());
343 assert (m_parser_vars.get());
344
Greg Claytone005f2c2010-11-06 01:53:30 +0000345 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan45690fe2010-08-30 22:17:16 +0000346
Sean Callananaa301c42010-12-03 01:38:59 +0000347 m_struct_vars->m_struct_laid_out = false;
Sean Callanan8bce6652010-07-13 21:41:46 +0000348
Sean Callanan8c127202010-08-23 23:09:38 +0000349 if (m_struct_members.GetVariable(decl))
350 return true;
Sean Callanan8bce6652010-07-13 21:41:46 +0000351
Greg Clayton427f2902010-12-14 02:59:59 +0000352 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl));
Sean Callanan8bce6652010-07-13 21:41:46 +0000353
Greg Clayton427f2902010-12-14 02:59:59 +0000354 if (!var_sp)
355 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl);
Sean Callanan8bce6652010-07-13 21:41:46 +0000356
Greg Clayton427f2902010-12-14 02:59:59 +0000357 if (!var_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000358 return false;
359
Sean Callanan45690fe2010-08-30 22:17:16 +0000360 if (log)
361 log->Printf("Adding value for decl %p [%s - %s] to the structure",
362 decl,
Greg Clayton8de27c72010-10-15 22:48:33 +0000363 name.GetCString(),
Greg Clayton427f2902010-12-14 02:59:59 +0000364 var_sp->GetName().GetCString());
Sean Callanan45690fe2010-08-30 22:17:16 +0000365
Sean Callanan8c127202010-08-23 23:09:38 +0000366 // We know entity->m_parser_vars is valid because we used a parser variable
367 // to find it
Greg Clayton427f2902010-12-14 02:59:59 +0000368 var_sp->m_parser_vars->m_llvm_value = value;
Sean Callanan8c127202010-08-23 23:09:38 +0000369
Greg Clayton427f2902010-12-14 02:59:59 +0000370 var_sp->EnableJITVars();
371 var_sp->m_jit_vars->m_alignment = alignment;
372 var_sp->m_jit_vars->m_size = size;
Sean Callanan8c127202010-08-23 23:09:38 +0000373
Greg Clayton427f2902010-12-14 02:59:59 +0000374 m_struct_members.AddVariable(var_sp);
Sean Callanan8bce6652010-07-13 21:41:46 +0000375
376 return true;
377}
378
379bool
380ClangExpressionDeclMap::DoStructLayout ()
381{
Sean Callananaa301c42010-12-03 01:38:59 +0000382 assert (m_struct_vars.get());
383
384 if (m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000385 return true;
386
Sean Callanan8bce6652010-07-13 21:41:46 +0000387 off_t cursor = 0;
388
Sean Callananaa301c42010-12-03 01:38:59 +0000389 m_struct_vars->m_struct_alignment = 0;
390 m_struct_vars->m_struct_size = 0;
Sean Callanan8bce6652010-07-13 21:41:46 +0000391
Greg Clayton427f2902010-12-14 02:59:59 +0000392 for (size_t member_index = 0, num_members = m_struct_members.GetSize();
Sean Callanan8c127202010-08-23 23:09:38 +0000393 member_index < num_members;
394 ++member_index)
Sean Callanan8bce6652010-07-13 21:41:46 +0000395 {
Greg Clayton427f2902010-12-14 02:59:59 +0000396 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
397 if (!member_sp)
398 return false;
399
400 if (!member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +0000401 return false;
Sean Callanan8bce6652010-07-13 21:41:46 +0000402
Sean Callanan8c127202010-08-23 23:09:38 +0000403 if (member_index == 0)
Greg Clayton427f2902010-12-14 02:59:59 +0000404 m_struct_vars->m_struct_alignment = member_sp->m_jit_vars->m_alignment;
Sean Callanan8c127202010-08-23 23:09:38 +0000405
Greg Clayton427f2902010-12-14 02:59:59 +0000406 if (cursor % member_sp->m_jit_vars->m_alignment)
407 cursor += (member_sp->m_jit_vars->m_alignment - (cursor % member_sp->m_jit_vars->m_alignment));
Sean Callanan8c127202010-08-23 23:09:38 +0000408
Greg Clayton427f2902010-12-14 02:59:59 +0000409 member_sp->m_jit_vars->m_offset = cursor;
410 cursor += member_sp->m_jit_vars->m_size;
Sean Callanan8bce6652010-07-13 21:41:46 +0000411 }
412
Sean Callananaa301c42010-12-03 01:38:59 +0000413 m_struct_vars->m_struct_size = cursor;
Sean Callanan8bce6652010-07-13 21:41:46 +0000414
Sean Callananaa301c42010-12-03 01:38:59 +0000415 m_struct_vars->m_struct_laid_out = true;
Sean Callanan8bce6652010-07-13 21:41:46 +0000416 return true;
417}
418
Greg Clayton8de27c72010-10-15 22:48:33 +0000419bool ClangExpressionDeclMap::GetStructInfo
420(
421 uint32_t &num_elements,
422 size_t &size,
423 off_t &alignment
424)
Sean Callanan8bce6652010-07-13 21:41:46 +0000425{
Sean Callananaa301c42010-12-03 01:38:59 +0000426 assert (m_struct_vars.get());
427
428 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000429 return false;
430
Greg Clayton427f2902010-12-14 02:59:59 +0000431 num_elements = m_struct_members.GetSize();
Sean Callananaa301c42010-12-03 01:38:59 +0000432 size = m_struct_vars->m_struct_size;
433 alignment = m_struct_vars->m_struct_alignment;
Sean Callanan8bce6652010-07-13 21:41:46 +0000434
435 return true;
436}
437
438bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000439ClangExpressionDeclMap::GetStructElement
440(
441 const clang::NamedDecl *&decl,
442 llvm::Value *&value,
443 off_t &offset,
444 ConstString &name,
445 uint32_t index
446)
Sean Callanan8bce6652010-07-13 21:41:46 +0000447{
Sean Callananaa301c42010-12-03 01:38:59 +0000448 assert (m_struct_vars.get());
449
450 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan8bce6652010-07-13 21:41:46 +0000451 return false;
452
Greg Clayton427f2902010-12-14 02:59:59 +0000453 if (index >= m_struct_members.GetSize())
Sean Callanan8bce6652010-07-13 21:41:46 +0000454 return false;
455
Greg Clayton427f2902010-12-14 02:59:59 +0000456 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
Sean Callanan8bce6652010-07-13 21:41:46 +0000457
Greg Clayton427f2902010-12-14 02:59:59 +0000458 if (!member_sp ||
459 !member_sp->m_parser_vars.get() ||
460 !member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +0000461 return false;
462
Greg Clayton427f2902010-12-14 02:59:59 +0000463 decl = member_sp->m_parser_vars->m_named_decl;
464 value = member_sp->m_parser_vars->m_llvm_value;
465 offset = member_sp->m_jit_vars->m_offset;
466 name = member_sp->GetName();
Sean Callanan8c127202010-08-23 23:09:38 +0000467
Sean Callanan8bce6652010-07-13 21:41:46 +0000468 return true;
469}
470
Sean Callanan02fbafa2010-07-27 21:39:39 +0000471bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000472ClangExpressionDeclMap::GetFunctionInfo
473(
474 const clang::NamedDecl *decl,
475 llvm::Value**& value,
476 uint64_t &ptr
477)
Sean Callananba992c52010-07-27 02:07:53 +0000478{
Greg Clayton427f2902010-12-14 02:59:59 +0000479 ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl));
Sean Callanan8c127202010-08-23 23:09:38 +0000480
Greg Clayton427f2902010-12-14 02:59:59 +0000481 if (!entity_sp)
Sean Callanan8c127202010-08-23 23:09:38 +0000482 return false;
Sean Callananba992c52010-07-27 02:07:53 +0000483
Sean Callanan8c127202010-08-23 23:09:38 +0000484 // We know m_parser_vars is valid since we searched for the variable by
485 // its NamedDecl
Sean Callananba992c52010-07-27 02:07:53 +0000486
Greg Clayton427f2902010-12-14 02:59:59 +0000487 value = &entity_sp->m_parser_vars->m_llvm_value;
488 ptr = entity_sp->m_parser_vars->m_lldb_value->GetScalar().ULongLong();
Sean Callanan8c127202010-08-23 23:09:38 +0000489
490 return true;
Sean Callananba992c52010-07-27 02:07:53 +0000491}
492
Sean Callananf5857a02010-07-31 01:32:05 +0000493bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000494ClangExpressionDeclMap::GetFunctionAddress
495(
496 const ConstString &name,
497 uint64_t &ptr
498)
Sean Callananf5857a02010-07-31 01:32:05 +0000499{
Sean Callananaa301c42010-12-03 01:38:59 +0000500 assert (m_parser_vars.get());
501
Sean Callananf5857a02010-07-31 01:32:05 +0000502 // Back out in all cases where we're not fully initialized
Jim Ingham78b9ee82010-12-07 01:56:02 +0000503 if (m_parser_vars->m_exe_ctx->target == NULL)
504 return false;
505 if (!m_parser_vars->m_sym_ctx.target_sp)
Sean Callananf5857a02010-07-31 01:32:05 +0000506 return false;
507
Greg Claytone5748d82010-11-09 23:46:37 +0000508 SymbolContextList sc_list;
Greg Clayton28d5fcc2011-01-27 06:44:37 +0000509 const bool include_symbols = true;
510 const bool append = false;
511 m_parser_vars->m_sym_ctx.FindFunctionsByName(name, include_symbols, append, sc_list);
Sean Callananf5857a02010-07-31 01:32:05 +0000512
Greg Claytone5748d82010-11-09 23:46:37 +0000513 if (!sc_list.GetSize())
Sean Callananf5857a02010-07-31 01:32:05 +0000514 return false;
515
516 SymbolContext sym_ctx;
Greg Claytone5748d82010-11-09 23:46:37 +0000517 sc_list.GetContextAtIndex(0, sym_ctx);
Sean Callananf5857a02010-07-31 01:32:05 +0000518
519 const Address *fun_address;
520
521 if (sym_ctx.function)
522 fun_address = &sym_ctx.function->GetAddressRange().GetBaseAddress();
523 else if (sym_ctx.symbol)
524 fun_address = &sym_ctx.symbol->GetAddressRangeRef().GetBaseAddress();
525 else
526 return false;
527
Sean Callananaa301c42010-12-03 01:38:59 +0000528 ptr = fun_address->GetLoadAddress (m_parser_vars->m_exe_ctx->target);
Sean Callananf5857a02010-07-31 01:32:05 +0000529
530 return true;
531}
532
Sean Callananc7674af2011-01-17 23:42:46 +0000533bool
534ClangExpressionDeclMap::GetSymbolAddress
535(
536 const ConstString &name,
537 uint64_t &ptr
538)
539{
540 assert (m_parser_vars.get());
541
542 // Back out in all cases where we're not fully initialized
543 if (m_parser_vars->m_exe_ctx->target == NULL)
544 return false;
545
546 SymbolContextList sc_list;
547
Greg Claytonb3448432011-03-24 21:19:54 +0000548 m_parser_vars->m_exe_ctx->target->GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
Sean Callananc7674af2011-01-17 23:42:46 +0000549
550 if (!sc_list.GetSize())
551 return false;
552
553 SymbolContext sym_ctx;
554 sc_list.GetContextAtIndex(0, sym_ctx);
555
556 const Address *sym_address = &sym_ctx.symbol->GetAddressRangeRef().GetBaseAddress();
557
558 ptr = sym_address->GetLoadAddress (m_parser_vars->m_exe_ctx->target);
559
560 return true;
561}
562
Sean Callanan810f22d2010-07-16 00:09:46 +0000563// Interface for CommandObjectExpression
Sean Callananf328c9f2010-07-20 23:31:16 +0000564
565bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000566ClangExpressionDeclMap::Materialize
567(
Sean Callananaa301c42010-12-03 01:38:59 +0000568 ExecutionContext &exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +0000569 lldb::addr_t &struct_address,
570 Error &err
571)
Sean Callananf328c9f2010-07-20 23:31:16 +0000572{
Sean Callananaa301c42010-12-03 01:38:59 +0000573 EnableMaterialVars();
574
575 m_material_vars->m_process = exe_ctx.process;
576
Sean Callanan6a925532011-01-13 08:53:35 +0000577 bool result = DoMaterialize(false /* dematerialize */, exe_ctx, NULL, err);
Sean Callananf328c9f2010-07-20 23:31:16 +0000578
579 if (result)
Sean Callananaa301c42010-12-03 01:38:59 +0000580 struct_address = m_material_vars->m_materialized_location;
Sean Callananf328c9f2010-07-20 23:31:16 +0000581
582 return result;
583}
584
585bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000586ClangExpressionDeclMap::GetObjectPointer
587(
588 lldb::addr_t &object_ptr,
Sean Callanan3aa7da52010-12-13 22:46:15 +0000589 ConstString &object_name,
Sean Callananaa301c42010-12-03 01:38:59 +0000590 ExecutionContext &exe_ctx,
Sean Callanan047923c2010-12-14 00:42:36 +0000591 Error &err,
592 bool suppress_type_check
Greg Clayton8de27c72010-10-15 22:48:33 +0000593)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000594{
Sean Callananaa301c42010-12-03 01:38:59 +0000595 assert (m_struct_vars.get());
596
597 if (!exe_ctx.frame || !exe_ctx.target || !exe_ctx.process)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000598 {
599 err.SetErrorString("Couldn't load 'this' because the context is incomplete");
600 return false;
601 }
602
Sean Callananaa301c42010-12-03 01:38:59 +0000603 if (!m_struct_vars->m_object_pointer_type.GetOpaqueQualType())
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000604 {
605 err.SetErrorString("Couldn't load 'this' because its type is unknown");
606 return false;
607 }
608
Sean Callanan696cf5f2011-05-07 01:06:41 +0000609 VariableSP object_ptr_var = FindVariableInScope (*exe_ctx.frame,
610 object_name,
611 (suppress_type_check ? NULL : &m_struct_vars->m_object_pointer_type));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000612
613 if (!object_ptr_var)
614 {
Sean Callanan3aa7da52010-12-13 22:46:15 +0000615 err.SetErrorStringWithFormat("Couldn't find '%s' with appropriate type in scope", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000616 return false;
617 }
618
Sean Callananaa301c42010-12-03 01:38:59 +0000619 std::auto_ptr<lldb_private::Value> location_value(GetVariableValue(exe_ctx,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000620 object_ptr_var,
Sean Callananaa301c42010-12-03 01:38:59 +0000621 NULL));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000622
623 if (!location_value.get())
624 {
Sean Callanan3aa7da52010-12-13 22:46:15 +0000625 err.SetErrorStringWithFormat("Couldn't get the location for '%s'", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000626 return false;
627 }
628
Sean Callanan50339fe2011-03-04 00:23:47 +0000629 switch (location_value->GetValueType())
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000630 {
Sean Callanan50339fe2011-03-04 00:23:47 +0000631 default:
Sean Callanan3aa7da52010-12-13 22:46:15 +0000632 err.SetErrorStringWithFormat("'%s' is not in memory; LLDB must be extended to handle registers", object_name.GetCString());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000633 return false;
Sean Callanan50339fe2011-03-04 00:23:47 +0000634 case Value::eValueTypeLoadAddress:
635 {
636 lldb::addr_t value_addr = location_value->GetScalar().ULongLong();
637 uint32_t address_byte_size = exe_ctx.target->GetArchitecture().GetAddressByteSize();
638 lldb::ByteOrder address_byte_order = exe_ctx.process->GetByteOrder();
639
640 if (ClangASTType::GetClangTypeBitWidth(m_struct_vars->m_object_pointer_type.GetASTContext(),
641 m_struct_vars->m_object_pointer_type.GetOpaqueQualType()) != address_byte_size * 8)
642 {
643 err.SetErrorStringWithFormat("'%s' is not of an expected pointer size", object_name.GetCString());
644 return false;
645 }
646
647 DataBufferHeap data;
648 data.SetByteSize(address_byte_size);
649 Error read_error;
650
651 if (exe_ctx.process->ReadMemory (value_addr, data.GetBytes(), address_byte_size, read_error) != address_byte_size)
652 {
653 err.SetErrorStringWithFormat("Coldn't read '%s' from the target: %s", object_name.GetCString(), read_error.AsCString());
654 return false;
655 }
656
657 DataExtractor extractor(data.GetBytes(), data.GetByteSize(), address_byte_order, address_byte_size);
658
659 uint32_t offset = 0;
660
661 object_ptr = extractor.GetPointer(&offset);
662
663 return true;
664 }
665 case Value::eValueTypeScalar:
666 {
667 if (location_value->GetContextType() != Value::eContextTypeRegisterInfo)
668 {
669 StreamString ss;
670 location_value->Dump(&ss);
671
672 err.SetErrorStringWithFormat("%s is a scalar of unhandled type: %s", object_name.GetCString(), ss.GetString().c_str());
673 return false;
674 }
675
Greg Claytonb3448432011-03-24 21:19:54 +0000676 RegisterInfo *register_info = location_value->GetRegisterInfo();
Sean Callanan50339fe2011-03-04 00:23:47 +0000677
678 if (!register_info)
679 {
680 err.SetErrorStringWithFormat("Couldn't get the register information for %s", object_name.GetCString());
681 return false;
682 }
683
684 RegisterContext *register_context = exe_ctx.GetRegisterContext();
685
686 if (!register_context)
687 {
688 err.SetErrorStringWithFormat("Couldn't read register context to read %s from %s", object_name.GetCString(), register_info->name);
689 return false;
690 }
691
692 uint32_t register_number = register_info->kinds[lldb::eRegisterKindLLDB];
693
694 object_ptr = register_context->ReadRegisterAsUnsigned(register_number, 0x0);
695
696 return true;
697 }
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000698 }
699}
700
701bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000702ClangExpressionDeclMap::Dematerialize
703(
Sean Callananaa301c42010-12-03 01:38:59 +0000704 ExecutionContext &exe_ctx,
Greg Clayton427f2902010-12-14 02:59:59 +0000705 ClangExpressionVariableSP &result_sp,
Greg Clayton8de27c72010-10-15 22:48:33 +0000706 Error &err
707)
Sean Callananf328c9f2010-07-20 23:31:16 +0000708{
Greg Clayton427f2902010-12-14 02:59:59 +0000709 return DoMaterialize(true, exe_ctx, &result_sp, err);
Sean Callananaa301c42010-12-03 01:38:59 +0000710
711 DidDematerialize();
712}
713
714void
715ClangExpressionDeclMap::DidDematerialize()
716{
717 if (m_material_vars.get())
718 {
719 if (m_material_vars->m_materialized_location)
720 {
721 //#define SINGLE_STEP_EXPRESSIONS
722
723#ifndef SINGLE_STEP_EXPRESSIONS
724 m_material_vars->m_process->DeallocateMemory(m_material_vars->m_materialized_location);
725#endif
726 m_material_vars->m_materialized_location = 0;
727 }
728
729 DisableMaterialVars();
730 }
Sean Callananf328c9f2010-07-20 23:31:16 +0000731}
732
Sean Callanan32824aa2010-07-23 22:19:18 +0000733bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000734ClangExpressionDeclMap::DumpMaterializedStruct
735(
Sean Callananaa301c42010-12-03 01:38:59 +0000736 ExecutionContext &exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +0000737 Stream &s,
738 Error &err
739)
Sean Callanan32824aa2010-07-23 22:19:18 +0000740{
Sean Callananaa301c42010-12-03 01:38:59 +0000741 assert (m_struct_vars.get());
742 assert (m_material_vars.get());
743
744 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan32824aa2010-07-23 22:19:18 +0000745 {
746 err.SetErrorString("Structure hasn't been laid out yet");
747 return false;
748 }
749
Sean Callananaa301c42010-12-03 01:38:59 +0000750 if (!exe_ctx.process)
Sean Callanan32824aa2010-07-23 22:19:18 +0000751 {
752 err.SetErrorString("Couldn't find the process");
753 return false;
754 }
755
Sean Callananaa301c42010-12-03 01:38:59 +0000756 if (!exe_ctx.target)
Sean Callanan32824aa2010-07-23 22:19:18 +0000757 {
758 err.SetErrorString("Couldn't find the target");
759 return false;
760 }
761
Sean Callanan33711022010-12-07 10:00:20 +0000762 if (!m_material_vars->m_materialized_location)
763 {
764 err.SetErrorString("No materialized location");
765 return false;
766 }
767
Sean Callananaa301c42010-12-03 01:38:59 +0000768 lldb::DataBufferSP data(new DataBufferHeap(m_struct_vars->m_struct_size, 0));
Sean Callanan32824aa2010-07-23 22:19:18 +0000769
770 Error error;
Sean Callananaa301c42010-12-03 01:38:59 +0000771 if (exe_ctx.process->ReadMemory (m_material_vars->m_materialized_location, data->GetBytes(), data->GetByteSize(), error) != data->GetByteSize())
Sean Callanan32824aa2010-07-23 22:19:18 +0000772 {
773 err.SetErrorStringWithFormat ("Couldn't read struct from the target: %s", error.AsCString());
774 return false;
775 }
776
Sean Callananaa301c42010-12-03 01:38:59 +0000777 DataExtractor extractor(data, exe_ctx.process->GetByteOrder(), exe_ctx.target->GetArchitecture().GetAddressByteSize());
Sean Callanan32824aa2010-07-23 22:19:18 +0000778
Greg Clayton427f2902010-12-14 02:59:59 +0000779 for (size_t member_idx = 0, num_members = m_struct_members.GetSize();
780 member_idx < num_members;
781 ++member_idx)
Sean Callanan32824aa2010-07-23 22:19:18 +0000782 {
Greg Clayton427f2902010-12-14 02:59:59 +0000783 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_idx));
Sean Callanan32824aa2010-07-23 22:19:18 +0000784
Greg Clayton427f2902010-12-14 02:59:59 +0000785 if (!member_sp)
786 return false;
787
788 s.Printf("[%s]\n", member_sp->GetName().GetCString());
Sean Callanan8c127202010-08-23 23:09:38 +0000789
Greg Clayton427f2902010-12-14 02:59:59 +0000790 if (!member_sp->m_jit_vars.get())
Sean Callanan8c127202010-08-23 23:09:38 +0000791 return false;
792
Greg Clayton427f2902010-12-14 02:59:59 +0000793 extractor.Dump (&s, // stream
794 member_sp->m_jit_vars->m_offset, // offset
795 lldb::eFormatBytesWithASCII, // format
796 1, // byte size of individual entries
797 member_sp->m_jit_vars->m_size, // number of entries
798 16, // entries per line
799 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset, // address to print
800 0, // bit size (bitfields only; 0 means ignore)
801 0); // bit alignment (bitfields only; 0 means ignore)
Sean Callanan32824aa2010-07-23 22:19:18 +0000802
803 s.PutChar('\n');
804 }
805
806 return true;
807}
808
Sean Callananf328c9f2010-07-20 23:31:16 +0000809bool
Greg Clayton8de27c72010-10-15 22:48:33 +0000810ClangExpressionDeclMap::DoMaterialize
811(
812 bool dematerialize,
Sean Callananaa301c42010-12-03 01:38:59 +0000813 ExecutionContext &exe_ctx,
Greg Clayton427f2902010-12-14 02:59:59 +0000814 lldb::ClangExpressionVariableSP *result_sp_ptr,
Greg Clayton8de27c72010-10-15 22:48:33 +0000815 Error &err
816)
Sean Callanan810f22d2010-07-16 00:09:46 +0000817{
Greg Clayton427f2902010-12-14 02:59:59 +0000818 if (result_sp_ptr)
819 result_sp_ptr->reset();
820
Sean Callananaa301c42010-12-03 01:38:59 +0000821 assert (m_struct_vars.get());
822
Greg Claytone005f2c2010-11-06 01:53:30 +0000823 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan82b74c82010-08-12 01:56:52 +0000824
Sean Callananaa301c42010-12-03 01:38:59 +0000825 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan810f22d2010-07-16 00:09:46 +0000826 {
827 err.SetErrorString("Structure hasn't been laid out yet");
828 return LLDB_INVALID_ADDRESS;
829 }
830
Sean Callananaa301c42010-12-03 01:38:59 +0000831 if (!exe_ctx.frame)
Sean Callanan45839272010-07-24 01:37:44 +0000832 {
833 err.SetErrorString("Received null execution frame");
834 return LLDB_INVALID_ADDRESS;
835 }
836
Greg Clayton427f2902010-12-14 02:59:59 +0000837 ClangPersistentVariables &persistent_vars = exe_ctx.target->GetPersistentVariables();
Sean Callananaa301c42010-12-03 01:38:59 +0000838
839 if (!m_struct_vars->m_struct_size)
Sean Callanane8a59a82010-09-13 21:34:21 +0000840 {
841 if (log)
842 log->PutCString("Not bothering to allocate a struct because no arguments are needed");
843
Sean Callananaa301c42010-12-03 01:38:59 +0000844 m_material_vars->m_allocated_area = NULL;
Sean Callanane8a59a82010-09-13 21:34:21 +0000845
846 return true;
847 }
848
Sean Callananaa301c42010-12-03 01:38:59 +0000849 const SymbolContext &sym_ctx(exe_ctx.frame->GetSymbolContext(lldb::eSymbolContextEverything));
Sean Callanan810f22d2010-07-16 00:09:46 +0000850
Sean Callananf328c9f2010-07-20 23:31:16 +0000851 if (!dematerialize)
Sean Callanan810f22d2010-07-16 00:09:46 +0000852 {
Sean Callananaa301c42010-12-03 01:38:59 +0000853 if (m_material_vars->m_materialized_location)
Sean Callananf328c9f2010-07-20 23:31:16 +0000854 {
Sean Callananaa301c42010-12-03 01:38:59 +0000855 exe_ctx.process->DeallocateMemory(m_material_vars->m_materialized_location);
856 m_material_vars->m_materialized_location = 0;
Sean Callananf328c9f2010-07-20 23:31:16 +0000857 }
858
Sean Callanan7a60b942010-10-08 01:58:41 +0000859 if (log)
860 log->PutCString("Allocating memory for materialized argument struct");
861
Sean Callananaa301c42010-12-03 01:38:59 +0000862 lldb::addr_t mem = exe_ctx.process->AllocateMemory(m_struct_vars->m_struct_alignment + m_struct_vars->m_struct_size,
863 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
864 err);
Sean Callananf328c9f2010-07-20 23:31:16 +0000865
866 if (mem == LLDB_INVALID_ADDRESS)
867 return false;
868
Sean Callananaa301c42010-12-03 01:38:59 +0000869 m_material_vars->m_allocated_area = mem;
Sean Callanan810f22d2010-07-16 00:09:46 +0000870 }
871
Sean Callananaa301c42010-12-03 01:38:59 +0000872 m_material_vars->m_materialized_location = m_material_vars->m_allocated_area;
Sean Callananf328c9f2010-07-20 23:31:16 +0000873
Sean Callananaa301c42010-12-03 01:38:59 +0000874 if (m_material_vars->m_materialized_location % m_struct_vars->m_struct_alignment)
875 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 +0000876
Greg Clayton427f2902010-12-14 02:59:59 +0000877 for (uint64_t member_index = 0, num_members = m_struct_members.GetSize();
Sean Callanan8c127202010-08-23 23:09:38 +0000878 member_index < num_members;
879 ++member_index)
Sean Callanan810f22d2010-07-16 00:09:46 +0000880 {
Greg Clayton427f2902010-12-14 02:59:59 +0000881 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
Sean Callanan810f22d2010-07-16 00:09:46 +0000882
Greg Claytona875b642011-01-09 21:07:35 +0000883 if (m_found_entities.ContainsVariable (member_sp))
Sean Callanan8c127202010-08-23 23:09:38 +0000884 {
Greg Claytona875b642011-01-09 21:07:35 +0000885 RegisterInfo *reg_info = member_sp->GetRegisterInfo ();
Greg Clayton427f2902010-12-14 02:59:59 +0000886 if (reg_info)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +0000887 {
888 // This is a register variable
889
Sean Callananaa301c42010-12-03 01:38:59 +0000890 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
Sean Callanan1ddd9fe2010-11-30 00:27:43 +0000891
892 if (!reg_ctx)
893 return false;
894
Greg Clayton427f2902010-12-14 02:59:59 +0000895 if (!DoMaterializeOneRegister (dematerialize,
896 exe_ctx,
897 *reg_ctx,
898 *reg_info,
899 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
900 err))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +0000901 return false;
902 }
903 else
904 {
Greg Clayton427f2902010-12-14 02:59:59 +0000905 if (!member_sp->m_jit_vars.get())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +0000906 return false;
907
Greg Clayton427f2902010-12-14 02:59:59 +0000908 if (!DoMaterializeOneVariable (dematerialize,
909 exe_ctx,
Sean Callanan6a925532011-01-13 08:53:35 +0000910 sym_ctx,
911 member_sp,
Greg Clayton427f2902010-12-14 02:59:59 +0000912 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
913 err))
Sean Callanan1ddd9fe2010-11-30 00:27:43 +0000914 return false;
915 }
Sean Callanan8c127202010-08-23 23:09:38 +0000916 }
Sean Callanan8c127202010-08-23 23:09:38 +0000917 else
918 {
Greg Claytona875b642011-01-09 21:07:35 +0000919 // No need to look for presistent variables if the name doesn't start
920 // with with a '$' character...
921 if (member_sp->GetName().AsCString ("!")[0] == '$' && persistent_vars.ContainsVariable(member_sp))
922 {
Sean Callanan6a925532011-01-13 08:53:35 +0000923
Greg Claytona875b642011-01-09 21:07:35 +0000924 if (member_sp->GetName() == m_struct_vars->m_result_name)
925 {
Greg Claytona875b642011-01-09 21:07:35 +0000926 if (log)
927 log->PutCString("Found result member in the struct");
Sean Callanan6a925532011-01-13 08:53:35 +0000928
Greg Claytona875b642011-01-09 21:07:35 +0000929 if (result_sp_ptr)
930 *result_sp_ptr = member_sp;
Sean Callanan6a925532011-01-13 08:53:35 +0000931
Greg Claytona875b642011-01-09 21:07:35 +0000932 }
933
934 if (!DoMaterializeOnePersistentVariable (dematerialize,
Sean Callanan6a925532011-01-13 08:53:35 +0000935 exe_ctx,
Greg Claytona875b642011-01-09 21:07:35 +0000936 member_sp,
937 m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
938 err))
939 return false;
940 }
941 else
942 {
943 err.SetErrorStringWithFormat("Unexpected variable %s", member_sp->GetName().GetCString());
944 return false;
945 }
Sean Callanan8c127202010-08-23 23:09:38 +0000946 }
Sean Callanan810f22d2010-07-16 00:09:46 +0000947 }
948
Sean Callananf328c9f2010-07-20 23:31:16 +0000949 return true;
950}
951
Sean Callanan6a925532011-01-13 08:53:35 +0000952static bool WriteAddressInto
953(
954 ExecutionContext &exe_ctx,
955 lldb::addr_t target,
956 lldb::addr_t address,
957 Error &err
958)
959{
960 size_t pointer_byte_size = exe_ctx.process->GetAddressByteSize();
961
962 StreamString str (0 | Stream::eBinary,
963 pointer_byte_size,
964 exe_ctx.process->GetByteOrder());
965
966 switch (pointer_byte_size)
967 {
968 default:
969 assert(!"Unhandled byte size");
970 case 4:
971 {
972 uint32_t address32 = address & 0xffffffffll;
Greg Claytoncd548032011-02-01 01:31:41 +0000973 str.PutRawBytes(&address32, sizeof(address32), endian::InlHostByteOrder(), eByteOrderInvalid);
Sean Callanan6a925532011-01-13 08:53:35 +0000974 }
975 break;
976 case 8:
977 {
978 uint64_t address64 = address;
Greg Claytoncd548032011-02-01 01:31:41 +0000979 str.PutRawBytes(&address64, sizeof(address64), endian::InlHostByteOrder(), eByteOrderInvalid);
Sean Callanan6a925532011-01-13 08:53:35 +0000980 }
981 break;
982 }
983
984 return (exe_ctx.process->WriteMemory (target, str.GetData(), pointer_byte_size, err) == pointer_byte_size);
985}
986
987static lldb::addr_t ReadAddressFrom
988(
989 ExecutionContext &exe_ctx,
990 lldb::addr_t source,
991 Error &err
992)
993{
994 size_t pointer_byte_size = exe_ctx.process->GetAddressByteSize();
995
996 DataBufferHeap *buf = new DataBufferHeap(pointer_byte_size, 0);
997 DataBufferSP buf_sp(buf);
998
999 if (exe_ctx.process->ReadMemory (source, buf->GetBytes(), pointer_byte_size, err) != pointer_byte_size)
1000 return LLDB_INVALID_ADDRESS;
1001
1002 DataExtractor extractor (buf_sp, exe_ctx.process->GetByteOrder(), exe_ctx.process->GetAddressByteSize());
1003
1004 uint32_t offset = 0;
1005
1006 return (lldb::addr_t)extractor.GetPointer(&offset);
1007}
1008
Sean Callanana48fe162010-08-11 03:57:18 +00001009bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001010ClangExpressionDeclMap::DoMaterializeOnePersistentVariable
1011(
1012 bool dematerialize,
1013 ExecutionContext &exe_ctx,
Greg Clayton427f2902010-12-14 02:59:59 +00001014 ClangExpressionVariableSP &var_sp,
Greg Clayton8de27c72010-10-15 22:48:33 +00001015 lldb::addr_t addr,
1016 Error &err
1017)
Sean Callananaa301c42010-12-03 01:38:59 +00001018{
Sean Callanan6a925532011-01-13 08:53:35 +00001019 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1020
Greg Clayton427f2902010-12-14 02:59:59 +00001021 if (!var_sp)
Sean Callanana48fe162010-08-11 03:57:18 +00001022 {
Greg Clayton427f2902010-12-14 02:59:59 +00001023 err.SetErrorString("Invalid persistent variable");
Sean Callanana48fe162010-08-11 03:57:18 +00001024 return LLDB_INVALID_ADDRESS;
1025 }
1026
Greg Clayton427f2902010-12-14 02:59:59 +00001027 const size_t pvar_byte_size = var_sp->GetByteSize();
Sean Callanana6223432010-08-20 01:02:30 +00001028
Greg Clayton427f2902010-12-14 02:59:59 +00001029 uint8_t *pvar_data = var_sp->GetValueBytes();
1030 if (pvar_data == NULL)
Sean Callanana6223432010-08-20 01:02:30 +00001031 return false;
1032
Sean Callanana48fe162010-08-11 03:57:18 +00001033 Error error;
1034
Sean Callanan6a925532011-01-13 08:53:35 +00001035 lldb::addr_t mem; // The address of a spare memory area used to hold the persistent variable.
1036
Sean Callanana48fe162010-08-11 03:57:18 +00001037 if (dematerialize)
1038 {
Sean Callanan6a925532011-01-13 08:53:35 +00001039 if (log)
1040 log->Printf("Dematerializing persistent variable with flags 0x%hx", var_sp->m_flags);
1041
1042 if ((var_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated) ||
1043 (var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
Sean Callanana48fe162010-08-11 03:57:18 +00001044 {
Sean Callanan6a925532011-01-13 08:53:35 +00001045 // Get the location of the target out of the struct.
1046
1047 Error read_error;
1048 mem = ReadAddressFrom(exe_ctx, addr, read_error);
1049
1050 if (mem == LLDB_INVALID_ADDRESS)
1051 {
1052 err.SetErrorStringWithFormat("Couldn't read address of %s from struct: %s", var_sp->GetName().GetCString(), error.AsCString());
1053 return false;
1054 }
1055
1056 if (var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
1057 !var_sp->m_live_sp)
1058 {
1059 // If the reference comes from the program, then the ClangExpressionVariable's
1060 // live variable data hasn't been set up yet. Do this now.
1061
Jim Ingham47da8102011-04-22 23:53:53 +00001062 var_sp->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope (),
1063 var_sp->GetTypeFromUser().GetASTContext(),
1064 var_sp->GetTypeFromUser().GetOpaqueQualType(),
1065 var_sp->GetName(),
1066 mem,
1067 eAddressTypeLoad,
1068 pvar_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001069 }
1070
1071 if (!var_sp->m_live_sp)
1072 {
1073 err.SetErrorStringWithFormat("Couldn't find the memory area used to store %s", var_sp->GetName().GetCString());
1074 return false;
1075 }
1076
Greg Claytonb3448432011-03-24 21:19:54 +00001077 if (var_sp->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
Sean Callanan6a925532011-01-13 08:53:35 +00001078 {
1079 err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", var_sp->GetName().GetCString());
1080 return false;
1081 }
1082
Sean Callanan97678d12011-01-13 21:23:32 +00001083 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry ||
1084 var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
Sean Callanan6a925532011-01-13 08:53:35 +00001085 {
1086 mem = var_sp->m_live_sp->GetValue().GetScalar().ULongLong();
1087
1088 if (log)
1089 log->Printf("Dematerializing %s from 0x%llx", var_sp->GetName().GetCString(), (uint64_t)mem);
1090
1091 // Read the contents of the spare memory area
1092
1093 if (log)
1094 log->Printf("Read");
1095
1096 var_sp->ValueUpdated ();
1097 if (exe_ctx.process->ReadMemory (mem, pvar_data, pvar_byte_size, error) != pvar_byte_size)
1098 {
1099 err.SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString());
1100 return false;
1101 }
1102
1103 var_sp->m_flags &= ~ClangExpressionVariable::EVNeedsFreezeDry;
1104 }
1105
1106 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation &&
1107 !(var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget))
1108 {
1109 if (m_keep_result_in_memory)
1110 {
1111 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget;
1112 }
1113 else
1114 {
1115 Error deallocate_error = exe_ctx.process->DeallocateMemory(mem);
1116
1117 if (!err.Success())
1118 {
1119 err.SetErrorStringWithFormat ("Couldn't deallocate memory for %s: %s", var_sp->GetName().GetCString(), deallocate_error.AsCString());
1120 return false;
1121 }
1122 }
1123 }
1124 }
1125 else
1126 {
1127 err.SetErrorStringWithFormat("Persistent variables without separate allocations are not currently supported.");
Sean Callanana48fe162010-08-11 03:57:18 +00001128 return false;
1129 }
1130 }
1131 else
1132 {
Sean Callanan6a925532011-01-13 08:53:35 +00001133 if (log)
1134 log->Printf("Materializing persistent variable with flags 0x%hx", var_sp->m_flags);
1135
1136 if (var_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation)
Sean Callanana48fe162010-08-11 03:57:18 +00001137 {
Sean Callanan6a925532011-01-13 08:53:35 +00001138 // Allocate a spare memory area to store the persistent variable's contents.
1139
1140 Error allocate_error;
1141
1142 mem = exe_ctx.process->AllocateMemory(pvar_byte_size,
1143 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1144 allocate_error);
1145
1146 if (mem == LLDB_INVALID_ADDRESS)
1147 {
1148 err.SetErrorStringWithFormat("Couldn't allocate a memory area to store %s: %s", var_sp->GetName().GetCString(), allocate_error.AsCString());
1149 return false;
1150 }
1151
1152 if (log)
1153 log->Printf("Allocated %s (0x%llx) sucessfully", var_sp->GetName().GetCString(), mem);
1154
1155 // Put the location of the spare memory into the live data of the ValueObject.
1156
Jim Ingham47da8102011-04-22 23:53:53 +00001157 var_sp->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
1158 var_sp->GetTypeFromUser().GetASTContext(),
1159 var_sp->GetTypeFromUser().GetOpaqueQualType(),
1160 var_sp->GetName(),
1161 mem,
1162 eAddressTypeLoad,
1163 pvar_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001164
1165 // Clear the flag if the variable will never be deallocated.
1166
1167 if (var_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
1168 var_sp->m_flags &= ~ClangExpressionVariable::EVNeedsAllocation;
1169
1170 // Write the contents of the variable to the area.
1171
1172 if (exe_ctx.process->WriteMemory (mem, pvar_data, pvar_byte_size, error) != pvar_byte_size)
1173 {
1174 err.SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString());
1175 return false;
1176 }
1177 }
1178
1179 if ((var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference && var_sp->m_live_sp) ||
1180 var_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated)
1181 {
1182 mem = var_sp->m_live_sp->GetValue().GetScalar().ULongLong();
1183
1184 // Now write the location of the area into the struct.
1185
1186 Error write_error;
1187 if (!WriteAddressInto(exe_ctx, addr, mem, write_error))
1188 {
1189 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", var_sp->GetName().GetCString(), write_error.AsCString());
1190 return false;
1191 }
1192
1193 if (log)
1194 log->Printf("Materialized %s into 0x%llx", var_sp->GetName().GetCString(), (uint64_t)mem);
1195 }
Sean Callanan696cf5f2011-05-07 01:06:41 +00001196 else if (!(var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
Sean Callanan6a925532011-01-13 08:53:35 +00001197 {
1198 err.SetErrorStringWithFormat("Persistent variables without separate allocations are not currently supported.");
Sean Callanana48fe162010-08-11 03:57:18 +00001199 return false;
1200 }
1201 }
1202
1203 return true;
1204}
1205
Sean Callananf328c9f2010-07-20 23:31:16 +00001206bool
Greg Clayton8de27c72010-10-15 22:48:33 +00001207ClangExpressionDeclMap::DoMaterializeOneVariable
1208(
1209 bool dematerialize,
1210 ExecutionContext &exe_ctx,
1211 const SymbolContext &sym_ctx,
Sean Callanan6a925532011-01-13 08:53:35 +00001212 ClangExpressionVariableSP &expr_var,
Greg Clayton8de27c72010-10-15 22:48:33 +00001213 lldb::addr_t addr,
1214 Error &err
1215)
Sean Callananf328c9f2010-07-20 23:31:16 +00001216{
Greg Claytone005f2c2010-11-06 01:53:30 +00001217 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananf328c9f2010-07-20 23:31:16 +00001218
Sean Callanan17c6a052010-10-05 20:18:48 +00001219 if (!exe_ctx.frame || !exe_ctx.process)
Sean Callanancc074622010-09-14 21:59:34 +00001220 return false;
1221
Sean Callanan6a925532011-01-13 08:53:35 +00001222 // Vital information about the value
1223
1224 const ConstString &name(expr_var->GetName());
1225 TypeFromUser type(expr_var->GetTypeFromUser());
1226
Sean Callanan696cf5f2011-05-07 01:06:41 +00001227 VariableSP var = FindVariableInScope (*exe_ctx.frame, name, &type);
Sean Callananf328c9f2010-07-20 23:31:16 +00001228
1229 if (!var)
1230 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001231 err.SetErrorStringWithFormat("Couldn't find %s with appropriate type", name.GetCString());
Sean Callananf328c9f2010-07-20 23:31:16 +00001232 return false;
1233 }
1234
Sean Callanan841026f2010-07-23 00:16:21 +00001235 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00001236 log->Printf("%s %s with type %p", (dematerialize ? "Dematerializing" : "Materializing"), name.GetCString(), type.GetOpaqueQualType());
Sean Callananf328c9f2010-07-20 23:31:16 +00001237
1238 std::auto_ptr<lldb_private::Value> location_value(GetVariableValue(exe_ctx,
1239 var,
Sean Callananaa301c42010-12-03 01:38:59 +00001240 NULL));
Sean Callananf328c9f2010-07-20 23:31:16 +00001241
1242 if (!location_value.get())
1243 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001244 err.SetErrorStringWithFormat("Couldn't get value for %s", name.GetCString());
Sean Callananf328c9f2010-07-20 23:31:16 +00001245 return false;
1246 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001247
1248 // The size of the type contained in addr
Sean Callananf328c9f2010-07-20 23:31:16 +00001249
Sean Callanan6a925532011-01-13 08:53:35 +00001250 size_t value_bit_size = ClangASTType::GetClangTypeBitWidth(type.GetASTContext(), type.GetOpaqueQualType());
1251 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 +00001252
1253 Value::ValueType value_type = location_value->GetValueType();
1254
1255 switch (value_type)
Sean Callananf328c9f2010-07-20 23:31:16 +00001256 {
Sean Callanan17c6a052010-10-05 20:18:48 +00001257 default:
Sean Callananf328c9f2010-07-20 23:31:16 +00001258 {
Sean Callanan17c6a052010-10-05 20:18:48 +00001259 StreamString ss;
1260
1261 location_value->Dump(&ss);
1262
Greg Clayton8de27c72010-10-15 22:48:33 +00001263 err.SetErrorStringWithFormat("%s has a value of unhandled type: %s", name.GetCString(), ss.GetString().c_str());
Sean Callananf328c9f2010-07-20 23:31:16 +00001264 return false;
1265 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001266 break;
1267 case Value::eValueTypeLoadAddress:
Sean Callananf328c9f2010-07-20 23:31:16 +00001268 {
Sean Callanan6a925532011-01-13 08:53:35 +00001269 if (!dematerialize)
Sean Callanan17c6a052010-10-05 20:18:48 +00001270 {
Sean Callanan6a925532011-01-13 08:53:35 +00001271 lldb::addr_t value_addr = location_value->GetScalar().ULongLong();
1272
1273 Error error;
1274
1275 if (!WriteAddressInto(exe_ctx,
1276 addr,
1277 value_addr,
1278 error))
1279 {
1280 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", name.GetCString(), error.AsCString());
1281 return false;
1282 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001283 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001284 }
Sean Callanan17c6a052010-10-05 20:18:48 +00001285 break;
1286 case Value::eValueTypeScalar:
1287 {
Greg Clayton6916e352010-11-13 03:52:47 +00001288 if (location_value->GetContextType() != Value::eContextTypeRegisterInfo)
Sean Callanan17c6a052010-10-05 20:18:48 +00001289 {
1290 StreamString ss;
Sean Callanan17c6a052010-10-05 20:18:48 +00001291 location_value->Dump(&ss);
1292
Greg Clayton8de27c72010-10-15 22:48:33 +00001293 err.SetErrorStringWithFormat("%s is a scalar of unhandled type: %s", name.GetCString(), ss.GetString().c_str());
Sean Callanan17c6a052010-10-05 20:18:48 +00001294 return false;
1295 }
1296
Sean Callanan6a925532011-01-13 08:53:35 +00001297 lldb::addr_t mem; // The address of a spare memory area aused to hold the variable.
1298
Greg Claytonb3448432011-03-24 21:19:54 +00001299 RegisterInfo *register_info = location_value->GetRegisterInfo();
Sean Callanan17c6a052010-10-05 20:18:48 +00001300
1301 if (!register_info)
1302 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001303 err.SetErrorStringWithFormat("Couldn't get the register information for %s", name.GetCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001304 return false;
1305 }
1306
1307 RegisterContext *register_context = exe_ctx.GetRegisterContext();
1308
1309 if (!register_context)
1310 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001311 err.SetErrorStringWithFormat("Couldn't read register context to read %s from %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001312 return false;
1313 }
1314
1315 uint32_t register_number = register_info->kinds[lldb::eRegisterKindLLDB];
1316 uint32_t register_byte_size = register_info->byte_size;
1317
1318 if (dematerialize)
1319 {
Sean Callanan6a925532011-01-13 08:53:35 +00001320 // Get the location of the spare memory area out of the variable's live data.
1321
1322 if (!expr_var->m_live_sp)
1323 {
1324 err.SetErrorStringWithFormat("Couldn't find the memory area used to store %s", name.GetCString());
1325 return false;
1326 }
1327
Greg Claytonb3448432011-03-24 21:19:54 +00001328 if (expr_var->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
Sean Callanan6a925532011-01-13 08:53:35 +00001329 {
1330 err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", name.GetCString());
1331 return false;
1332 }
1333
1334 mem = expr_var->m_live_sp->GetValue().GetScalar().ULongLong();
1335
Sean Callanan17c6a052010-10-05 20:18:48 +00001336 // Moving from addr into a register
1337 //
1338 // Case 1: addr_byte_size and register_byte_size are the same
1339 //
1340 // |AABBCCDD| Address contents
1341 // |AABBCCDD| Register contents
1342 //
1343 // Case 2: addr_byte_size is bigger than register_byte_size
1344 //
1345 // Error! (The register should always be big enough to hold the data)
1346 //
1347 // Case 3: register_byte_size is bigger than addr_byte_size
1348 //
1349 // |AABB| Address contents
1350 // |AABB0000| Register contents [on little-endian hardware]
1351 // |0000AABB| Register contents [on big-endian hardware]
1352
Sean Callanan6a925532011-01-13 08:53:35 +00001353 if (value_byte_size > register_byte_size)
Sean Callanan17c6a052010-10-05 20:18:48 +00001354 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001355 err.SetErrorStringWithFormat("%s is too big to store in %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001356 return false;
1357 }
1358
1359 uint32_t register_offset;
1360
1361 switch (exe_ctx.process->GetByteOrder())
1362 {
1363 default:
Greg Clayton8de27c72010-10-15 22:48:33 +00001364 err.SetErrorStringWithFormat("%s is stored with an unhandled byte order", name.GetCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001365 return false;
1366 case lldb::eByteOrderLittle:
1367 register_offset = 0;
1368 break;
1369 case lldb::eByteOrderBig:
Sean Callanan6a925532011-01-13 08:53:35 +00001370 register_offset = register_byte_size - value_byte_size;
Sean Callanan17c6a052010-10-05 20:18:48 +00001371 break;
1372 }
1373
1374 DataBufferHeap register_data (register_byte_size, 0);
1375
1376 Error error;
Sean Callanan6a925532011-01-13 08:53:35 +00001377 if (exe_ctx.process->ReadMemory (mem, register_data.GetBytes() + register_offset, value_byte_size, error) != value_byte_size)
Sean Callanan17c6a052010-10-05 20:18:48 +00001378 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001379 err.SetErrorStringWithFormat ("Couldn't read %s from the target: %s", name.GetCString(), error.AsCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001380 return false;
1381 }
1382
1383 DataExtractor register_extractor (register_data.GetBytes(), register_byte_size, exe_ctx.process->GetByteOrder(), exe_ctx.process->GetAddressByteSize());
1384
1385 if (!register_context->WriteRegisterBytes(register_number, register_extractor, 0))
1386 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001387 err.SetErrorStringWithFormat("Couldn't read %s from %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001388 return false;
1389 }
Sean Callanan6a925532011-01-13 08:53:35 +00001390
1391 // Deallocate the spare area and clear the variable's live data.
1392
1393 Error deallocate_error = exe_ctx.process->DeallocateMemory(mem);
1394
1395 if (!deallocate_error.Success())
1396 {
1397 err.SetErrorStringWithFormat("Couldn't deallocate spare memory area for %s: %s", name.GetCString(), deallocate_error.AsCString());
1398 return false;
1399 }
1400
1401 expr_var->m_live_sp.reset();
Sean Callanan17c6a052010-10-05 20:18:48 +00001402 }
1403 else
1404 {
Sean Callanan6a925532011-01-13 08:53:35 +00001405 // Allocate a spare memory area to place the register's contents into. This memory area will be pointed to by the slot in the
1406 // struct.
1407
1408 Error allocate_error;
1409
1410 mem = exe_ctx.process->AllocateMemory(value_byte_size,
1411 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1412 allocate_error);
1413
1414 if (mem == LLDB_INVALID_ADDRESS)
1415 {
1416 err.SetErrorStringWithFormat("Couldn't allocate a memory area to store %s: %s", name.GetCString(), allocate_error.AsCString());
1417 return false;
1418 }
1419
1420 // Put the location of the spare memory into the live data of the ValueObject.
1421
Jim Ingham47da8102011-04-22 23:53:53 +00001422 expr_var->m_live_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
1423 type.GetASTContext(),
1424 type.GetOpaqueQualType(),
1425 name,
1426 mem,
1427 eAddressTypeLoad,
1428 value_byte_size);
Sean Callanan6a925532011-01-13 08:53:35 +00001429
1430 // Now write the location of the area into the struct.
1431
1432 Error write_error;
1433 if (!WriteAddressInto(exe_ctx, addr, mem, write_error))
1434 {
1435 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", name.GetCString(), write_error.AsCString());
1436 return false;
1437 }
1438
Sean Callanan17c6a052010-10-05 20:18:48 +00001439 // Moving from a register into addr
1440 //
1441 // Case 1: addr_byte_size and register_byte_size are the same
1442 //
1443 // |AABBCCDD| Register contents
1444 // |AABBCCDD| Address contents
1445 //
1446 // Case 2: addr_byte_size is bigger than register_byte_size
1447 //
1448 // Error! (The register should always be big enough to hold the data)
1449 //
1450 // Case 3: register_byte_size is bigger than addr_byte_size
1451 //
1452 // |AABBCCDD| Register contents
1453 // |AABB| Address contents on little-endian hardware
1454 // |CCDD| Address contents on big-endian hardware
1455
Sean Callanan6a925532011-01-13 08:53:35 +00001456 if (value_byte_size > register_byte_size)
Sean Callanan17c6a052010-10-05 20:18:48 +00001457 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001458 err.SetErrorStringWithFormat("%s is too big to store in %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001459 return false;
1460 }
1461
1462 uint32_t register_offset;
1463
1464 switch (exe_ctx.process->GetByteOrder())
1465 {
1466 default:
Greg Clayton8de27c72010-10-15 22:48:33 +00001467 err.SetErrorStringWithFormat("%s is stored with an unhandled byte order", name.GetCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001468 return false;
1469 case lldb::eByteOrderLittle:
1470 register_offset = 0;
1471 break;
1472 case lldb::eByteOrderBig:
Sean Callanan6a925532011-01-13 08:53:35 +00001473 register_offset = register_byte_size - value_byte_size;
Sean Callanan17c6a052010-10-05 20:18:48 +00001474 break;
1475 }
1476
1477 DataExtractor register_extractor;
1478
1479 if (!register_context->ReadRegisterBytes(register_number, register_extractor))
1480 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001481 err.SetErrorStringWithFormat("Couldn't read %s from %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001482 return false;
1483 }
1484
Sean Callanan6a925532011-01-13 08:53:35 +00001485 const void *register_data = register_extractor.GetData(&register_offset, value_byte_size);
Sean Callanan17c6a052010-10-05 20:18:48 +00001486
1487 if (!register_data)
1488 {
Greg Clayton8de27c72010-10-15 22:48:33 +00001489 err.SetErrorStringWithFormat("Read but couldn't extract data for %s from %s", name.GetCString(), register_info->name);
Sean Callanan17c6a052010-10-05 20:18:48 +00001490 return false;
1491 }
1492
Sean Callanan6a925532011-01-13 08:53:35 +00001493 if (exe_ctx.process->WriteMemory (mem, register_data, value_byte_size, write_error) != value_byte_size)
Sean Callanan17c6a052010-10-05 20:18:48 +00001494 {
Sean Callanan6a925532011-01-13 08:53:35 +00001495 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", write_error.AsCString());
Sean Callanan17c6a052010-10-05 20:18:48 +00001496 return false;
1497 }
1498 }
1499 }
Sean Callananf328c9f2010-07-20 23:31:16 +00001500 }
1501
1502 return true;
Sean Callanan810f22d2010-07-16 00:09:46 +00001503}
1504
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001505bool
1506ClangExpressionDeclMap::DoMaterializeOneRegister
1507(
1508 bool dematerialize,
1509 ExecutionContext &exe_ctx,
1510 RegisterContext &reg_ctx,
Greg Claytonb3448432011-03-24 21:19:54 +00001511 const RegisterInfo &reg_info,
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001512 lldb::addr_t addr,
1513 Error &err
1514)
1515{
1516 uint32_t register_number = reg_info.kinds[lldb::eRegisterKindLLDB];
1517 uint32_t register_byte_size = reg_info.byte_size;
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00001518
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001519 if (dematerialize)
1520 {
1521 DataBufferHeap register_data (register_byte_size, 0);
1522
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00001523 Error read_error;
1524 if (exe_ctx.process->ReadMemory (addr, register_data.GetBytes(), register_byte_size, read_error) != register_byte_size)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001525 {
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00001526 err.SetErrorStringWithFormat ("Couldn't read %s from the target: %s", reg_info.name, read_error.AsCString());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001527 return false;
1528 }
1529
1530 DataExtractor register_extractor (register_data.GetBytes(), register_byte_size, exe_ctx.process->GetByteOrder(), exe_ctx.process->GetAddressByteSize());
1531
1532 if (!reg_ctx.WriteRegisterBytes(register_number, register_extractor, 0))
1533 {
1534 err.SetErrorStringWithFormat("Couldn't read %s", reg_info.name);
1535 return false;
1536 }
1537 }
1538 else
1539 {
1540 DataExtractor register_extractor;
1541
1542 if (!reg_ctx.ReadRegisterBytes(register_number, register_extractor))
1543 {
1544 err.SetErrorStringWithFormat("Couldn't read %s", reg_info.name);
1545 return false;
1546 }
1547
1548 uint32_t register_offset = 0;
1549
1550 const void *register_data = register_extractor.GetData(&register_offset, register_byte_size);
1551
1552 if (!register_data)
1553 {
1554 err.SetErrorStringWithFormat("Read but couldn't extract data for %s", reg_info.name);
1555 return false;
1556 }
1557
1558 Error error;
1559 if (exe_ctx.process->WriteMemory (addr, register_data, register_byte_size, error) != register_byte_size)
1560 {
1561 err.SetErrorStringWithFormat ("Couldn't write %s to the target: %s", error.AsCString());
1562 return false;
1563 }
1564 }
1565
1566 return true;
1567}
1568
Sean Callanan696cf5f2011-05-07 01:06:41 +00001569lldb::VariableSP
Greg Clayton8de27c72010-10-15 22:48:33 +00001570ClangExpressionDeclMap::FindVariableInScope
1571(
1572 StackFrame &frame,
1573 const ConstString &name,
1574 TypeFromUser *type
1575)
Sean Callananaa301c42010-12-03 01:38:59 +00001576{
Greg Claytone005f2c2010-11-06 01:53:30 +00001577 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanancc074622010-09-14 21:59:34 +00001578
Sean Callanancc074622010-09-14 21:59:34 +00001579 VariableList *var_list = frame.GetVariableList(true);
1580
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001581 if (!var_list)
Sean Callanan696cf5f2011-05-07 01:06:41 +00001582 return lldb::VariableSP();
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001583
Greg Clayton3bc52d02010-11-14 22:13:40 +00001584 lldb::VariableSP var_sp (var_list->FindVariable(name));
1585
1586 const bool append = true;
1587 const uint32_t max_matches = 1;
1588 if (!var_sp)
Sean Callanancc074622010-09-14 21:59:34 +00001589 {
Greg Clayton3bc52d02010-11-14 22:13:40 +00001590 // Look for globals elsewhere in the module for the frame
Sean Callananaa301c42010-12-03 01:38:59 +00001591 ModuleSP module_sp (frame.GetSymbolContext(eSymbolContextModule).module_sp);
Greg Clayton3bc52d02010-11-14 22:13:40 +00001592 if (module_sp)
1593 {
1594 VariableList module_globals;
1595 if (module_sp->FindGlobalVariables (name, append, max_matches, module_globals))
1596 var_sp = module_globals.GetVariableAtIndex (0);
1597 }
1598 }
1599
1600 if (!var_sp)
1601 {
1602 // Look for globals elsewhere in the program (all images)
Sean Callananaa301c42010-12-03 01:38:59 +00001603 TargetSP target_sp (frame.GetSymbolContext(eSymbolContextTarget).target_sp);
Greg Clayton3bc52d02010-11-14 22:13:40 +00001604 if (target_sp)
1605 {
1606 VariableList program_globals;
1607 if (target_sp->GetImages().FindGlobalVariables (name, append, max_matches, program_globals))
1608 var_sp = program_globals.GetVariableAtIndex (0);
1609 }
1610 }
1611
1612 if (var_sp && type)
1613 {
1614 if (type->GetASTContext() == var_sp->GetType()->GetClangAST())
1615 {
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001616 if (!ClangASTContext::AreTypesSame(type->GetASTContext(), type->GetOpaqueQualType(), var_sp->GetType()->GetClangFullType()))
Sean Callanan696cf5f2011-05-07 01:06:41 +00001617 return lldb::VariableSP();
Greg Clayton3bc52d02010-11-14 22:13:40 +00001618 }
1619 else
1620 {
1621 if (log)
1622 log->PutCString("Skipping a candidate variable because of different AST contexts");
Sean Callanan696cf5f2011-05-07 01:06:41 +00001623 return lldb::VariableSP();
Greg Clayton3bc52d02010-11-14 22:13:40 +00001624 }
Sean Callanancc074622010-09-14 21:59:34 +00001625 }
Greg Clayton3bc52d02010-11-14 22:13:40 +00001626
Sean Callanan696cf5f2011-05-07 01:06:41 +00001627 return var_sp;
Sean Callanancc074622010-09-14 21:59:34 +00001628}
Sean Callanan336a0002010-07-17 00:43:37 +00001629
Chris Lattner24943d22010-06-08 16:52:24 +00001630// Interface for ClangASTSource
1631void
Greg Claytone5748d82010-11-09 23:46:37 +00001632ClangExpressionDeclMap::GetDecls (NameSearchContext &context, const ConstString &name)
Chris Lattner24943d22010-06-08 16:52:24 +00001633{
Sean Callananaa301c42010-12-03 01:38:59 +00001634 assert (m_struct_vars.get());
1635 assert (m_parser_vars.get());
1636
Greg Claytone005f2c2010-11-06 01:53:30 +00001637 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001638
Sean Callanan810f22d2010-07-16 00:09:46 +00001639 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00001640 log->Printf("Hunting for a definition for '%s'", name.GetCString());
Chris Lattner24943d22010-06-08 16:52:24 +00001641
1642 // Back out in all cases where we're not fully initialized
Sean Callananaa301c42010-12-03 01:38:59 +00001643 if (m_parser_vars->m_exe_ctx->frame == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +00001644 return;
Sean Callananee8fc722010-11-19 20:20:02 +00001645
Sean Callananaa301c42010-12-03 01:38:59 +00001646 if (m_parser_vars->m_ignore_lookups)
Sean Callananee8fc722010-11-19 20:20:02 +00001647 {
1648 if (log)
1649 log->Printf("Ignoring a query during an import");
1650 return;
1651 }
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001652
Greg Claytone5748d82010-11-09 23:46:37 +00001653 SymbolContextList sc_list;
Chris Lattner24943d22010-06-08 16:52:24 +00001654
Greg Clayton3bc52d02010-11-14 22:13:40 +00001655 const char *name_unique_cstr = name.GetCString();
1656
1657 if (name_unique_cstr == NULL)
1658 return;
1659
Greg Clayton8de27c72010-10-15 22:48:33 +00001660 // Only look for functions by name out in our symbols if the function
1661 // doesn't start with our phony prefix of '$'
Greg Clayton3bc52d02010-11-14 22:13:40 +00001662 if (name_unique_cstr[0] != '$')
Sean Callanan0fc73582010-07-27 00:55:47 +00001663 {
Sean Callanan696cf5f2011-05-07 01:06:41 +00001664 VariableSP var = FindVariableInScope(*m_parser_vars->m_exe_ctx->frame, name);
Greg Clayton8de27c72010-10-15 22:48:33 +00001665
1666 // If we found a variable in scope, no need to pull up function names
1667 if (var != NULL)
1668 {
1669 AddOneVariable(context, var);
1670 }
1671 else
1672 {
Greg Clayton28d5fcc2011-01-27 06:44:37 +00001673 const bool include_symbols = true;
1674 const bool append = false;
1675 m_parser_vars->m_sym_ctx.FindFunctionsByName (name,
1676 include_symbols,
1677 append,
1678 sc_list);
Greg Clayton8de27c72010-10-15 22:48:33 +00001679
1680 bool found_specific = false;
1681 Symbol *generic_symbol = NULL;
1682 Symbol *non_extern_symbol = NULL;
1683
Greg Claytone5748d82010-11-09 23:46:37 +00001684 for (uint32_t index = 0, num_indices = sc_list.GetSize();
Greg Clayton8de27c72010-10-15 22:48:33 +00001685 index < num_indices;
1686 ++index)
1687 {
1688 SymbolContext sym_ctx;
Greg Claytone5748d82010-11-09 23:46:37 +00001689 sc_list.GetContextAtIndex(index, sym_ctx);
Sean Callanan3cfbd332010-10-06 00:10:07 +00001690
Greg Clayton8de27c72010-10-15 22:48:33 +00001691 if (sym_ctx.function)
1692 {
1693 // TODO only do this if it's a C function; C++ functions may be
1694 // overloaded
1695 if (!found_specific)
1696 AddOneFunction(context, sym_ctx.function, NULL);
1697 found_specific = true;
1698 }
1699 else if (sym_ctx.symbol)
1700 {
1701 if (sym_ctx.symbol->IsExternal())
1702 generic_symbol = sym_ctx.symbol;
1703 else
1704 non_extern_symbol = sym_ctx.symbol;
1705 }
1706 }
1707
Sean Callanan92aa6662010-09-07 21:49:41 +00001708 if (!found_specific)
Greg Clayton8de27c72010-10-15 22:48:33 +00001709 {
1710 if (generic_symbol)
Greg Clayton28d5fcc2011-01-27 06:44:37 +00001711 AddOneFunction (context, NULL, generic_symbol);
Greg Clayton8de27c72010-10-15 22:48:33 +00001712 else if (non_extern_symbol)
Greg Clayton28d5fcc2011-01-27 06:44:37 +00001713 AddOneFunction (context, NULL, non_extern_symbol);
Greg Clayton8de27c72010-10-15 22:48:33 +00001714 }
Greg Clayton6916e352010-11-13 03:52:47 +00001715
Sean Callananaa301c42010-12-03 01:38:59 +00001716 ClangNamespaceDecl namespace_decl (m_parser_vars->m_sym_ctx.FindNamespace(name));
Greg Clayton6916e352010-11-13 03:52:47 +00001717 if (namespace_decl)
1718 {
Greg Clayton9ceed1e2010-11-13 04:18:24 +00001719 clang::NamespaceDecl *clang_namespace_decl = AddNamespace(context, namespace_decl);
1720 if (clang_namespace_decl)
Greg Clayton9ceed1e2010-11-13 04:18:24 +00001721 clang_namespace_decl->setHasExternalLexicalStorage();
Greg Clayton6916e352010-11-13 03:52:47 +00001722 }
Sean Callanan92aa6662010-09-07 21:49:41 +00001723 }
Sean Callanan0fc73582010-07-27 00:55:47 +00001724 }
Greg Clayton8de27c72010-10-15 22:48:33 +00001725 else
Sean Callanan3cfbd332010-10-06 00:10:07 +00001726 {
Greg Clayton57452832010-11-09 04:42:43 +00001727 static ConstString g_lldb_class_name ("$__lldb_class");
1728 if (name == g_lldb_class_name)
1729 {
1730 // Clang is looking for the type of "this"
1731
Sean Callananaa301c42010-12-03 01:38:59 +00001732 VariableList *vars = m_parser_vars->m_exe_ctx->frame->GetVariableList(false);
Greg Clayton57452832010-11-09 04:42:43 +00001733
1734 if (!vars)
1735 return;
1736
1737 lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
1738
1739 if (!this_var)
1740 return;
1741
1742 Type *this_type = this_var->GetType();
1743
1744 if (!this_type)
1745 return;
1746
Greg Clayton2403b5e2010-11-16 02:10:54 +00001747 if (log)
1748 {
1749 log->PutCString ("Type for \"this\" is: ");
1750 StreamString strm;
1751 this_type->Dump(&strm, true);
1752 log->PutCString (strm.GetData());
1753 }
1754
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001755 TypeFromUser this_user_type(this_type->GetClangFullType(),
Greg Clayton57452832010-11-09 04:42:43 +00001756 this_type->GetClangAST());
1757
Sean Callananaa301c42010-12-03 01:38:59 +00001758 m_struct_vars->m_object_pointer_type = this_user_type;
Greg Clayton57452832010-11-09 04:42:43 +00001759
1760 void *pointer_target_type;
1761
1762 if (!ClangASTContext::IsPointerType(this_user_type.GetOpaqueQualType(),
1763 &pointer_target_type))
1764 return;
1765
1766 TypeFromUser class_user_type(pointer_target_type,
1767 this_type->GetClangAST());
1768
Sean Callanan3aa7da52010-12-13 22:46:15 +00001769 if (log)
1770 {
1771 StreamString type_stream;
1772 class_user_type.DumpTypeCode(&type_stream);
1773 type_stream.Flush();
1774 log->Printf("Adding type for $__lldb_class: %s", type_stream.GetString().c_str());
1775 }
1776
Greg Clayton57452832010-11-09 04:42:43 +00001777 AddOneType(context, class_user_type, true);
1778
1779 return;
1780 }
1781
Sean Callanan3aa7da52010-12-13 22:46:15 +00001782 static ConstString g_lldb_objc_class_name ("$__lldb_objc_class");
1783 if (name == g_lldb_objc_class_name)
1784 {
1785 // Clang is looking for the type of "*self"
1786
1787 VariableList *vars = m_parser_vars->m_exe_ctx->frame->GetVariableList(false);
1788
1789 if (!vars)
1790 return;
1791
1792 lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
1793
1794 if (!self_var)
1795 return;
1796
1797 Type *self_type = self_var->GetType();
1798
1799 if (!self_type)
1800 return;
1801
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001802 TypeFromUser self_user_type(self_type->GetClangFullType(),
Sean Callanan3aa7da52010-12-13 22:46:15 +00001803 self_type->GetClangAST());
1804
1805 m_struct_vars->m_object_pointer_type = self_user_type;
1806
1807 void *pointer_target_type;
1808
1809 if (!ClangASTContext::IsPointerType(self_user_type.GetOpaqueQualType(),
1810 &pointer_target_type))
1811 return;
1812
1813 TypeFromUser class_user_type(pointer_target_type,
1814 self_type->GetClangAST());
1815
1816 if (log)
1817 {
1818 StreamString type_stream;
1819 class_user_type.DumpTypeCode(&type_stream);
1820 type_stream.Flush();
1821 log->Printf("Adding type for $__lldb_objc_class: %s", type_stream.GetString().c_str());
1822 }
1823
1824 AddOneType(context, class_user_type, false);
1825
1826 return;
1827 }
Greg Clayton427f2902010-12-14 02:59:59 +00001828
1829 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
Greg Clayton8de27c72010-10-15 22:48:33 +00001830
Greg Clayton427f2902010-12-14 02:59:59 +00001831 if (pvar_sp)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001832 {
Greg Clayton427f2902010-12-14 02:59:59 +00001833 AddOneVariable(context, pvar_sp);
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001834 return;
1835 }
1836
1837 const char *reg_name(&name.GetCString()[1]);
1838
Sean Callananaa301c42010-12-03 01:38:59 +00001839 if (m_parser_vars->m_exe_ctx->GetRegisterContext())
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001840 {
Greg Claytonb3448432011-03-24 21:19:54 +00001841 const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx->GetRegisterContext()->GetRegisterInfoByName(reg_name));
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00001842
1843 if (reg_info)
1844 AddOneRegister(context, reg_info);
1845 }
Sean Callanan3cfbd332010-10-06 00:10:07 +00001846 }
1847
Sean Callananaa301c42010-12-03 01:38:59 +00001848 lldb::TypeSP type_sp (m_parser_vars->m_sym_ctx.FindTypeByName (name));
Sean Callananee8fc722010-11-19 20:20:02 +00001849
1850 if (type_sp)
Sean Callanan6df08402010-09-27 23:54:58 +00001851 {
Sean Callananee8fc722010-11-19 20:20:02 +00001852 if (log)
Sean Callanan6df08402010-09-27 23:54:58 +00001853 {
Sean Callananee8fc722010-11-19 20:20:02 +00001854 log->Printf ("Matching type found for \"%s\": ", name.GetCString());
1855 StreamString strm;
1856 type_sp->Dump(&strm, true);
1857 log->PutCString (strm.GetData());
1858 }
Greg Clayton2403b5e2010-11-16 02:10:54 +00001859
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001860 TypeFromUser user_type (type_sp->GetClangFullType(),
Greg Claytonb01000f2011-01-17 03:46:26 +00001861 type_sp->GetClangAST());
Sean Callanan6df08402010-09-27 23:54:58 +00001862
Sean Callananee8fc722010-11-19 20:20:02 +00001863 AddOneType(context, user_type, false);
Sean Callanan6df08402010-09-27 23:54:58 +00001864 }
Sean Callanan336a0002010-07-17 00:43:37 +00001865}
1866
1867Value *
Greg Clayton8de27c72010-10-15 22:48:33 +00001868ClangExpressionDeclMap::GetVariableValue
1869(
1870 ExecutionContext &exe_ctx,
Sean Callanan696cf5f2011-05-07 01:06:41 +00001871 VariableSP var,
Greg Clayton8de27c72010-10-15 22:48:33 +00001872 clang::ASTContext *parser_ast_context,
1873 TypeFromUser *user_type,
1874 TypeFromParser *parser_type
1875)
Chris Lattner24943d22010-06-08 16:52:24 +00001876{
Greg Claytone005f2c2010-11-06 01:53:30 +00001877 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan6184dfe2010-06-23 00:47:48 +00001878
Chris Lattner24943d22010-06-08 16:52:24 +00001879 Type *var_type = var->GetType();
1880
1881 if (!var_type)
1882 {
Sean Callanan810f22d2010-07-16 00:09:46 +00001883 if (log)
1884 log->PutCString("Skipped a definition because it has no type");
Sean Callanan336a0002010-07-17 00:43:37 +00001885 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00001886 }
1887
Greg Clayton04c9c7b2011-02-16 23:00:21 +00001888 clang_type_t var_opaque_type = var_type->GetClangFullType();
Chris Lattner24943d22010-06-08 16:52:24 +00001889
1890 if (!var_opaque_type)
1891 {
Sean Callanan810f22d2010-07-16 00:09:46 +00001892 if (log)
1893 log->PutCString("Skipped a definition because it has no Clang type");
Sean Callanan336a0002010-07-17 00:43:37 +00001894 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00001895 }
1896
Greg Claytonb01000f2011-01-17 03:46:26 +00001897 clang::ASTContext *ast = var_type->GetClangASTContext().getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +00001898
Greg Claytonb01000f2011-01-17 03:46:26 +00001899 if (!ast)
Chris Lattner24943d22010-06-08 16:52:24 +00001900 {
Sean Callanan810f22d2010-07-16 00:09:46 +00001901 if (log)
1902 log->PutCString("There is no AST context for the current execution context");
Sean Callanan336a0002010-07-17 00:43:37 +00001903 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00001904 }
1905
Sean Callanan336a0002010-07-17 00:43:37 +00001906 DWARFExpression &var_location_expr = var->LocationExpression();
1907
Chris Lattner24943d22010-06-08 16:52:24 +00001908 std::auto_ptr<Value> var_location(new Value);
1909
Greg Clayton178710c2010-09-14 02:20:48 +00001910 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
1911
1912 if (var_location_expr.IsLocationList())
1913 {
1914 SymbolContext var_sc;
1915 var->CalculateSymbolContext (&var_sc);
Greg Claytoneea26402010-09-14 23:36:40 +00001916 loclist_base_load_addr = var_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.target);
Greg Clayton178710c2010-09-14 02:20:48 +00001917 }
Chris Lattner24943d22010-06-08 16:52:24 +00001918 Error err;
1919
Greg Claytonbdcb6ab2011-01-25 23:55:37 +00001920 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 +00001921 {
Sean Callanan810f22d2010-07-16 00:09:46 +00001922 if (log)
1923 log->Printf("Error evaluating location: %s", err.AsCString());
Sean Callanan336a0002010-07-17 00:43:37 +00001924 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00001925 }
Greg Claytonb01000f2011-01-17 03:46:26 +00001926
Sean Callanan336a0002010-07-17 00:43:37 +00001927 void *type_to_use;
1928
Sean Callananf328c9f2010-07-20 23:31:16 +00001929 if (parser_ast_context)
1930 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001931 type_to_use = GuardedCopyType(parser_ast_context, ast, var_opaque_type);
Sean Callananf328c9f2010-07-20 23:31:16 +00001932
Sean Callanan4b5eec62010-11-20 02:19:29 +00001933 if (!type_to_use)
1934 {
1935 if (log)
1936 log->Printf("Couldn't copy a variable's type into the parser's AST context");
1937
1938 return NULL;
1939 }
1940
Sean Callananf328c9f2010-07-20 23:31:16 +00001941 if (parser_type)
1942 *parser_type = TypeFromParser(type_to_use, parser_ast_context);
1943 }
Sean Callanan336a0002010-07-17 00:43:37 +00001944 else
1945 type_to_use = var_opaque_type;
Chris Lattner24943d22010-06-08 16:52:24 +00001946
1947 if (var_location.get()->GetContextType() == Value::eContextTypeInvalid)
Greg Clayton6916e352010-11-13 03:52:47 +00001948 var_location.get()->SetContext(Value::eContextTypeClangType, type_to_use);
Chris Lattner24943d22010-06-08 16:52:24 +00001949
1950 if (var_location.get()->GetValueType() == Value::eValueTypeFileAddress)
1951 {
1952 SymbolContext var_sc;
1953 var->CalculateSymbolContext(&var_sc);
Sean Callanan336a0002010-07-17 00:43:37 +00001954
Chris Lattner24943d22010-06-08 16:52:24 +00001955 if (!var_sc.module_sp)
Sean Callanan336a0002010-07-17 00:43:37 +00001956 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00001957
1958 ObjectFile *object_file = var_sc.module_sp->GetObjectFile();
1959
1960 if (!object_file)
Sean Callanan336a0002010-07-17 00:43:37 +00001961 return NULL;
1962
Chris Lattner24943d22010-06-08 16:52:24 +00001963 Address so_addr(var_location->GetScalar().ULongLong(), object_file->GetSectionList());
1964
Sean Callananaa301c42010-12-03 01:38:59 +00001965 lldb::addr_t load_addr = so_addr.GetLoadAddress(exe_ctx.target);
Chris Lattner24943d22010-06-08 16:52:24 +00001966
1967 var_location->GetScalar() = load_addr;
1968 var_location->SetValueType(Value::eValueTypeLoadAddress);
1969 }
1970
Sean Callananf328c9f2010-07-20 23:31:16 +00001971 if (user_type)
Greg Claytonb01000f2011-01-17 03:46:26 +00001972 *user_type = TypeFromUser(var_opaque_type, ast);
Sean Callanan336a0002010-07-17 00:43:37 +00001973
1974 return var_location.release();
1975}
1976
1977void
Sean Callanan696cf5f2011-05-07 01:06:41 +00001978ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP var)
Sean Callanan336a0002010-07-17 00:43:37 +00001979{
Sean Callananaa301c42010-12-03 01:38:59 +00001980 assert (m_parser_vars.get());
1981
Greg Claytone005f2c2010-11-06 01:53:30 +00001982 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan336a0002010-07-17 00:43:37 +00001983
Sean Callananf328c9f2010-07-20 23:31:16 +00001984 TypeFromUser ut;
1985 TypeFromParser pt;
Sean Callanan336a0002010-07-17 00:43:37 +00001986
Sean Callananaa301c42010-12-03 01:38:59 +00001987 Value *var_location = GetVariableValue (*m_parser_vars->m_exe_ctx,
Greg Clayton8de27c72010-10-15 22:48:33 +00001988 var,
1989 context.GetASTContext(),
1990 &ut,
1991 &pt);
Sean Callanan336a0002010-07-17 00:43:37 +00001992
Sean Callanan4b5eec62010-11-20 02:19:29 +00001993 if (!var_location)
1994 return;
1995
Sean Callanan6a925532011-01-13 08:53:35 +00001996 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(pt.GetASTContext(), pt.GetOpaqueQualType()));
Greg Clayton8de27c72010-10-15 22:48:33 +00001997 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00001998 ConstString entity_name(decl_name.c_str());
Jim Inghamfa3a16a2011-03-31 00:19:25 +00001999 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope (),
2000 entity_name,
Greg Clayton427f2902010-12-14 02:59:59 +00002001 ut,
2002 m_parser_vars->m_exe_ctx->process->GetByteOrder(),
2003 m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
2004 assert (entity.get());
2005 entity->EnableParserVars();
2006 entity->m_parser_vars->m_parser_type = pt;
2007 entity->m_parser_vars->m_named_decl = var_decl;
2008 entity->m_parser_vars->m_llvm_value = NULL;
2009 entity->m_parser_vars->m_lldb_value = var_location;
Sean Callanan696cf5f2011-05-07 01:06:41 +00002010 entity->m_parser_vars->m_lldb_var = var;
Chris Lattner24943d22010-06-08 16:52:24 +00002011
Sean Callanan810f22d2010-07-16 00:09:46 +00002012 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00002013 {
Sean Callanana0744822010-11-01 23:22:47 +00002014 std::string var_decl_print_string;
2015 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2016 var_decl->print(var_decl_print_stream);
2017 var_decl_print_stream.flush();
2018
2019 log->Printf("Found variable %s, returned %s", decl_name.c_str(), var_decl_print_string.c_str());
Sean Callanan6e74dbb2011-02-01 23:43:26 +00002020
2021 if (log->GetVerbose())
2022 {
2023 StreamString var_decl_dump_string;
2024 ASTDumper::DumpDecl(var_decl_dump_string, var_decl);
2025 log->Printf("%s\n", var_decl_dump_string.GetData());
2026 }
Greg Clayton8de27c72010-10-15 22:48:33 +00002027 }
Sean Callanan8f0dc342010-06-22 23:46:24 +00002028}
2029
2030void
Sean Callanana48fe162010-08-11 03:57:18 +00002031ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
Greg Clayton427f2902010-12-14 02:59:59 +00002032 ClangExpressionVariableSP &pvar_sp)
Sean Callanana48fe162010-08-11 03:57:18 +00002033{
Greg Claytone005f2c2010-11-06 01:53:30 +00002034 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan45690fe2010-08-30 22:17:16 +00002035
Greg Clayton427f2902010-12-14 02:59:59 +00002036 TypeFromUser user_type (pvar_sp->GetTypeFromUser());
Sean Callanana48fe162010-08-11 03:57:18 +00002037
Greg Clayton427f2902010-12-14 02:59:59 +00002038 TypeFromParser parser_type (GuardedCopyType(context.GetASTContext(),
2039 user_type.GetASTContext(),
2040 user_type.GetOpaqueQualType()),
2041 context.GetASTContext());
Sean Callanana48fe162010-08-11 03:57:18 +00002042
Sean Callanan6a925532011-01-13 08:53:35 +00002043 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(parser_type.GetASTContext(), parser_type.GetOpaqueQualType()));
Sean Callanan8c127202010-08-23 23:09:38 +00002044
Greg Clayton427f2902010-12-14 02:59:59 +00002045 pvar_sp->EnableParserVars();
2046 pvar_sp->m_parser_vars->m_parser_type = parser_type;
2047 pvar_sp->m_parser_vars->m_named_decl = var_decl;
2048 pvar_sp->m_parser_vars->m_llvm_value = NULL;
2049 pvar_sp->m_parser_vars->m_lldb_value = NULL;
Sean Callanan45690fe2010-08-30 22:17:16 +00002050
2051 if (log)
Sean Callanana0744822010-11-01 23:22:47 +00002052 {
2053 std::string var_decl_print_string;
2054 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2055 var_decl->print(var_decl_print_stream);
2056 var_decl_print_stream.flush();
2057
Greg Clayton427f2902010-12-14 02:59:59 +00002058 log->Printf("Added pvar %s, returned %s", pvar_sp->GetName().GetCString(), var_decl_print_string.c_str());
Sean Callanana0744822010-11-01 23:22:47 +00002059 }
Sean Callanana48fe162010-08-11 03:57:18 +00002060}
2061
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002062void
Greg Clayton427f2902010-12-14 02:59:59 +00002063ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
2064 const RegisterInfo *reg_info)
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002065{
2066 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2067
2068 void *ast_type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(context.GetASTContext(),
2069 reg_info->encoding,
2070 reg_info->byte_size * 8);
2071
2072 if (!ast_type)
2073 {
2074 log->Printf("Tried to add a type for %s, but couldn't get one", context.m_decl_name.getAsString().c_str());
2075 return;
2076 }
2077
Greg Clayton427f2902010-12-14 02:59:59 +00002078 TypeFromParser parser_type (ast_type,
2079 context.GetASTContext());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002080
2081 NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
2082
Jim Inghamfa3a16a2011-03-31 00:19:25 +00002083 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope(),
2084 m_parser_vars->m_exe_ctx->process->GetByteOrder(),
Greg Clayton427f2902010-12-14 02:59:59 +00002085 m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
2086 assert (entity.get());
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002087 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00002088 entity->SetName (ConstString (decl_name.c_str()));
2089 entity->SetRegisterInfo (reg_info);
2090 entity->EnableParserVars();
2091 entity->m_parser_vars->m_parser_type = parser_type;
2092 entity->m_parser_vars->m_named_decl = var_decl;
2093 entity->m_parser_vars->m_llvm_value = NULL;
2094 entity->m_parser_vars->m_lldb_value = NULL;
Sean Callanan1ddd9fe2010-11-30 00:27:43 +00002095
2096 if (log)
2097 {
2098 std::string var_decl_print_string;
2099 llvm::raw_string_ostream var_decl_print_stream(var_decl_print_string);
2100 var_decl->print(var_decl_print_stream);
2101 var_decl_print_stream.flush();
2102
2103 log->Printf("Added register %s, returned %s", context.m_decl_name.getAsString().c_str(), var_decl_print_string.c_str());
2104 }
2105}
2106
Greg Clayton6916e352010-11-13 03:52:47 +00002107clang::NamespaceDecl *
2108ClangExpressionDeclMap::AddNamespace (NameSearchContext &context, const ClangNamespaceDecl &namespace_decl)
2109{
2110 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2111
Greg Clayton6916e352010-11-13 03:52:47 +00002112 clang::Decl *copied_decl = ClangASTContext::CopyDecl (context.GetASTContext(),
2113 namespace_decl.GetASTContext(),
2114 namespace_decl.GetNamespaceDecl());
2115
2116 return dyn_cast<clang::NamespaceDecl>(copied_decl);
2117}
2118
Sean Callanana48fe162010-08-11 03:57:18 +00002119void
Sean Callanan8f0dc342010-06-22 23:46:24 +00002120ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
Sean Callanan0fc73582010-07-27 00:55:47 +00002121 Function* fun,
2122 Symbol* symbol)
Sean Callanan8f0dc342010-06-22 23:46:24 +00002123{
Sean Callananaa301c42010-12-03 01:38:59 +00002124 assert (m_parser_vars.get());
2125
Greg Claytone005f2c2010-11-06 01:53:30 +00002126 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan8f0dc342010-06-22 23:46:24 +00002127
Sean Callanan0fc73582010-07-27 00:55:47 +00002128 NamedDecl *fun_decl;
Sean Callanan8f0dc342010-06-22 23:46:24 +00002129 std::auto_ptr<Value> fun_location(new Value);
Sean Callanan0fc73582010-07-27 00:55:47 +00002130 const Address *fun_address;
Sean Callanan8f0dc342010-06-22 23:46:24 +00002131
Sean Callanan0fc73582010-07-27 00:55:47 +00002132 // only valid for Functions, not for Symbols
2133 void *fun_opaque_type = NULL;
2134 clang::ASTContext *fun_ast_context = NULL;
2135
2136 if (fun)
2137 {
2138 Type *fun_type = fun->GetType();
2139
2140 if (!fun_type)
2141 {
2142 if (log)
2143 log->PutCString("Skipped a function because it has no type");
2144 return;
2145 }
2146
Greg Clayton04c9c7b2011-02-16 23:00:21 +00002147 fun_opaque_type = fun_type->GetClangFullType();
Sean Callanan0fc73582010-07-27 00:55:47 +00002148
2149 if (!fun_opaque_type)
2150 {
2151 if (log)
2152 log->PutCString("Skipped a function because it has no Clang type");
2153 return;
2154 }
2155
2156 fun_address = &fun->GetAddressRange().GetBaseAddress();
2157
Greg Claytonb01000f2011-01-17 03:46:26 +00002158 fun_ast_context = fun_type->GetClangASTContext().getASTContext();
Sean Callananee8fc722010-11-19 20:20:02 +00002159 void *copied_type = GuardedCopyType(context.GetASTContext(), fun_ast_context, fun_opaque_type);
Sean Callanan0fc73582010-07-27 00:55:47 +00002160
2161 fun_decl = context.AddFunDecl(copied_type);
2162 }
2163 else if (symbol)
2164 {
2165 fun_address = &symbol->GetAddressRangeRef().GetBaseAddress();
2166
2167 fun_decl = context.AddGenericFunDecl();
2168 }
2169 else
2170 {
2171 if (log)
2172 log->PutCString("AddOneFunction called with no function and no symbol");
2173 return;
2174 }
2175
Sean Callananaa301c42010-12-03 01:38:59 +00002176 lldb::addr_t load_addr = fun_address->GetLoadAddress(m_parser_vars->m_exe_ctx->target);
Sean Callanan8f0dc342010-06-22 23:46:24 +00002177 fun_location->SetValueType(Value::eValueTypeLoadAddress);
2178 fun_location->GetScalar() = load_addr;
2179
Jim Inghamfa3a16a2011-03-31 00:19:25 +00002180 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->GetBestExecutionContextScope (),
2181 m_parser_vars->m_exe_ctx->process->GetByteOrder(),
Greg Clayton427f2902010-12-14 02:59:59 +00002182 m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
2183 assert (entity.get());
Greg Clayton8de27c72010-10-15 22:48:33 +00002184 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton427f2902010-12-14 02:59:59 +00002185 entity->SetName(ConstString(decl_name.c_str()));
2186 entity->SetClangType (fun_opaque_type);
2187 entity->SetClangAST (fun_ast_context);
Sean Callanan8f0dc342010-06-22 23:46:24 +00002188
Greg Clayton427f2902010-12-14 02:59:59 +00002189 entity->EnableParserVars();
2190 entity->m_parser_vars->m_named_decl = fun_decl;
2191 entity->m_parser_vars->m_llvm_value = NULL;
2192 entity->m_parser_vars->m_lldb_value = fun_location.release();
Sean Callanan8c127202010-08-23 23:09:38 +00002193
Sean Callanan810f22d2010-07-16 00:09:46 +00002194 if (log)
Greg Clayton8de27c72010-10-15 22:48:33 +00002195 {
Sean Callanana0744822010-11-01 23:22:47 +00002196 std::string fun_decl_print_string;
2197 llvm::raw_string_ostream fun_decl_print_stream(fun_decl_print_string);
2198 fun_decl->print(fun_decl_print_stream);
2199 fun_decl_print_stream.flush();
2200
2201 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 +00002202 }
Chris Lattner24943d22010-06-08 16:52:24 +00002203}
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002204
2205void
2206ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002207 TypeFromUser &ut,
2208 bool add_method)
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002209{
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002210 clang::ASTContext *parser_ast_context = context.GetASTContext();
2211 clang::ASTContext *user_ast_context = ut.GetASTContext();
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002212
Sean Callananee8fc722010-11-19 20:20:02 +00002213 void *copied_type = GuardedCopyType(parser_ast_context, user_ast_context, ut.GetOpaqueQualType());
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002214
2215 TypeFromParser parser_type(copied_type, parser_ast_context);
2216
2217 if (add_method && ClangASTContext::IsAggregateType(copied_type))
2218 {
2219 void *args[1];
2220
2221 args[0] = ClangASTContext::GetVoidPtrType(parser_ast_context, false);
2222
2223 void *method_type = ClangASTContext::CreateFunctionType (parser_ast_context,
2224 ClangASTContext::GetBuiltInType_void(parser_ast_context),
2225 args,
2226 1,
2227 false,
2228 ClangASTContext::GetTypeQualifiers(copied_type));
Greg Clayton30449d52010-10-01 02:31:07 +00002229
Greg Clayton1d8173f2010-09-24 05:15:53 +00002230 const bool is_virtual = false;
2231 const bool is_static = false;
2232 const bool is_inline = false;
Greg Clayton30449d52010-10-01 02:31:07 +00002233 const bool is_explicit = false;
2234
Greg Clayton1d8173f2010-09-24 05:15:53 +00002235 ClangASTContext::AddMethodToCXXRecordType (parser_ast_context,
2236 copied_type,
Greg Clayton8de27c72010-10-15 22:48:33 +00002237 "$__lldb_expr",
Greg Clayton1d8173f2010-09-24 05:15:53 +00002238 method_type,
2239 lldb::eAccessPublic,
2240 is_virtual,
2241 is_static,
Greg Clayton30449d52010-10-01 02:31:07 +00002242 is_inline,
2243 is_explicit);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00002244 }
Sean Callanan93a4b1a2010-08-04 01:02:13 +00002245
2246 context.AddTypeDecl(copied_type);
2247}
Sean Callananee8fc722010-11-19 20:20:02 +00002248
2249void *
2250ClangExpressionDeclMap::GuardedCopyType (ASTContext *dest_context,
2251 ASTContext *source_context,
2252 void *clang_type)
2253{
Sean Callananaa301c42010-12-03 01:38:59 +00002254 assert (m_parser_vars.get());
2255
2256 m_parser_vars->m_ignore_lookups = true;
Sean Callananee8fc722010-11-19 20:20:02 +00002257
2258 void *ret = ClangASTContext::CopyType (dest_context,
2259 source_context,
2260 clang_type);
2261
Sean Callananaa301c42010-12-03 01:38:59 +00002262 m_parser_vars->m_ignore_lookups = false;
Sean Callananee8fc722010-11-19 20:20:02 +00002263
2264 return ret;
2265}