blob: 754b6ee34b9dcbfedf37bb1de3c7030704ea24de [file] [log] [blame]
Chris Lattner30fdc8d2010-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 Callanan3d654b32012-09-24 22:25:51 +000016#include "clang/AST/ASTContext.h"
Sean Callanane2ef6e32010-09-23 03:01:22 +000017#include "clang/AST/DeclarationName.h"
Sean Callanan530782942010-11-01 23:22:47 +000018#include "clang/AST/Decl.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000019#include "lldb/lldb-private.h"
20#include "lldb/Core/Address.h"
Sean Callananea22d422010-07-16 00:09:46 +000021#include "lldb/Core/Error.h"
Sean Callananf06ba8d2010-06-23 00:47:48 +000022#include "lldb/Core/Log.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000023#include "lldb/Core/Module.h"
Greg Clayton7349bd92011-05-09 20:18:18 +000024#include "lldb/Core/RegisterValue.h"
Sean Callanane4ec90e2010-12-16 03:17:46 +000025#include "lldb/Core/ValueObjectConstResult.h"
Sean Callanan9b3569b2011-12-10 03:12:34 +000026#include "lldb/Core/ValueObjectVariable.h"
Sean Callanan0917d6e2011-02-01 23:43:26 +000027#include "lldb/Expression/ASTDumper.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000028#include "lldb/Expression/ClangASTSource.h"
Sean Callanan2235f322010-08-11 03:57:18 +000029#include "lldb/Expression/ClangPersistentVariables.h"
Sean Callanan96d27302013-04-11 00:09:05 +000030#include "lldb/Expression/Materializer.h"
Greg Clayton7fb56d02011-02-01 01:31:41 +000031#include "lldb/Host/Endian.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000032#include "lldb/Symbol/ClangASTContext.h"
Greg Clayton526e5af2010-11-13 03:52:47 +000033#include "lldb/Symbol/ClangNamespaceDecl.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000034#include "lldb/Symbol/CompileUnit.h"
35#include "lldb/Symbol/Function.h"
36#include "lldb/Symbol/ObjectFile.h"
37#include "lldb/Symbol/SymbolContext.h"
Sean Callanan503aa522011-10-12 00:12:34 +000038#include "lldb/Symbol/SymbolVendor.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000039#include "lldb/Symbol/Type.h"
40#include "lldb/Symbol/TypeList.h"
41#include "lldb/Symbol/Variable.h"
42#include "lldb/Symbol/VariableList.h"
Sean Callanan1d180662010-07-20 23:31:16 +000043#include "lldb/Target/ExecutionContext.h"
Sean Callanane0b23b52012-11-15 02:02:04 +000044#include "lldb/Target/ObjCLanguageRuntime.h"
Sean Callananea22d422010-07-16 00:09:46 +000045#include "lldb/Target/Process.h"
Sean Callananf4b9bd32010-10-05 20:18:48 +000046#include "lldb/Target/RegisterContext.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000047#include "lldb/Target/StackFrame.h"
Sean Callanan1d180662010-07-20 23:31:16 +000048#include "lldb/Target/Target.h"
Jim Ingham895c9822010-12-07 01:56:02 +000049#include "lldb/Target/Thread.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000050
Greg Clayton83c5cd92010-11-14 22:13:40 +000051using namespace lldb;
Chris Lattner30fdc8d2010-06-08 16:52:24 +000052using namespace lldb_private;
53using namespace clang;
54
Sean Callanan1ee44b72011-10-29 01:58:46 +000055ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory, ExecutionContext &exe_ctx) :
56 ClangASTSource (exe_ctx.GetTargetSP()),
Greg Clayton7b462cc2010-10-15 22:48:33 +000057 m_found_entities (),
58 m_struct_members (),
Stephen Wilson71c21d12011-04-11 19:41:40 +000059 m_keep_result_in_memory (keep_result_in_memory),
Sean Callanan979f74d2010-12-03 01:38:59 +000060 m_parser_vars (),
Stephen Wilson71c21d12011-04-11 19:41:40 +000061 m_struct_vars ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +000062{
Sean Callanan979f74d2010-12-03 01:38:59 +000063 EnableStructVars();
Chris Lattner30fdc8d2010-06-08 16:52:24 +000064}
65
66ClangExpressionDeclMap::~ClangExpressionDeclMap()
Sean Callanan979f74d2010-12-03 01:38:59 +000067{
Sean Callanane3aef1d2011-10-12 22:20:02 +000068 // Note: The model is now that the parser's AST context and all associated
69 // data does not vanish until the expression has been executed. This means
70 // that valuable lookup data (like namespaces) doesn't vanish, but
71
72 DidParse();
Sean Callanan979f74d2010-12-03 01:38:59 +000073 DidDematerialize();
74 DisableStructVars();
75}
Sean Callananbe3a1b12010-10-26 00:31:56 +000076
Sean Callananb9951192011-08-01 18:18:33 +000077bool
Sean Callanan96d27302013-04-11 00:09:05 +000078ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
79 Materializer *materializer)
Sean Callanan8106d802013-03-08 20:04:57 +000080{
81 ClangASTMetrics::ClearLocalCounters();
82
Sean Callanan979f74d2010-12-03 01:38:59 +000083 EnableParserVars();
Sean Callanan933693b2012-02-10 01:22:05 +000084 m_parser_vars->m_exe_ctx = exe_ctx;
Greg Claytonc14ee322011-09-22 04:58:26 +000085
86 Target *target = exe_ctx.GetTargetPtr();
87 if (exe_ctx.GetFramePtr())
88 m_parser_vars->m_sym_ctx = exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
Sean Callanand4fac252013-02-21 22:01:43 +000089 else if (exe_ctx.GetThreadPtr() && exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
Greg Claytonc14ee322011-09-22 04:58:26 +000090 m_parser_vars->m_sym_ctx = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
91 else if (exe_ctx.GetProcessPtr())
Greg Clayton4d122c42011-09-17 08:33:22 +000092 {
Greg Clayton72310352013-02-23 04:12:47 +000093 m_parser_vars->m_sym_ctx.Clear(true);
Greg Claytonc14ee322011-09-22 04:58:26 +000094 m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
Greg Clayton4d122c42011-09-17 08:33:22 +000095 }
Greg Claytonc14ee322011-09-22 04:58:26 +000096 else if (target)
Greg Clayton4d122c42011-09-17 08:33:22 +000097 {
Greg Clayton72310352013-02-23 04:12:47 +000098 m_parser_vars->m_sym_ctx.Clear(true);
Greg Claytonc14ee322011-09-22 04:58:26 +000099 m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
Greg Clayton4d122c42011-09-17 08:33:22 +0000100 }
Sean Callananc2ff2742011-09-15 18:41:04 +0000101
Greg Claytonc14ee322011-09-22 04:58:26 +0000102 if (target)
103 {
104 m_parser_vars->m_persistent_vars = &target->GetPersistentVariables();
Sean Callananb9951192011-08-01 18:18:33 +0000105
Greg Claytonc14ee322011-09-22 04:58:26 +0000106 if (!target->GetScratchClangASTContext())
107 return false;
108 }
Sean Callananb9951192011-08-01 18:18:33 +0000109
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000110 m_parser_vars->m_target_info = GetTargetInfo();
Sean Callanan96d27302013-04-11 00:09:05 +0000111 m_parser_vars->m_materializer = materializer;
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000112
Sean Callananb9951192011-08-01 18:18:33 +0000113 return true;
Sean Callanan979f74d2010-12-03 01:38:59 +0000114}
115
Sean Callanan96d27302013-04-11 00:09:05 +0000116void
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000117ClangExpressionDeclMap::DidParse()
Sean Callanan979f74d2010-12-03 01:38:59 +0000118{
Greg Clayton5160ce52013-03-27 23:08:40 +0000119 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan8106d802013-03-08 20:04:57 +0000120
121 if (log)
122 ClangASTMetrics::DumpCounters(log);
123
Sean Callanan979f74d2010-12-03 01:38:59 +0000124 if (m_parser_vars.get())
125 {
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000126 for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000127 entity_index < num_entities;
128 ++entity_index)
129 {
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000130 ClangExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
Jim Ingham28eb5712012-10-12 17:34:26 +0000131 if (var_sp)
132 {
Sean Callanan3c495c12013-01-15 23:29:36 +0000133 ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
134
135 if (parser_vars && parser_vars->m_lldb_value)
136 delete parser_vars->m_lldb_value;
Sean Callanan979f74d2010-12-03 01:38:59 +0000137
Sean Callanan3c495c12013-01-15 23:29:36 +0000138 var_sp->DisableParserVars(GetParserID());
Jim Ingham28eb5712012-10-12 17:34:26 +0000139 }
Sean Callanan979f74d2010-12-03 01:38:59 +0000140 }
141
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000142 for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000143 pvar_index < num_pvars;
144 ++pvar_index)
145 {
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000146 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
147 if (pvar_sp)
Sean Callanan3c495c12013-01-15 23:29:36 +0000148 pvar_sp->DisableParserVars(GetParserID());
Sean Callanan979f74d2010-12-03 01:38:59 +0000149 }
150
151 DisableParserVars();
Sean Callanan6b1b9532010-10-08 01:58:41 +0000152 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000153}
154
Sean Callanan549c9f72010-07-13 21:41:46 +0000155// Interface for IRForTarget
156
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000157ClangExpressionDeclMap::TargetInfo
158ClangExpressionDeclMap::GetTargetInfo()
159{
160 assert (m_parser_vars.get());
161
162 TargetInfo ret;
163
Sean Callanan933693b2012-02-10 01:22:05 +0000164 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
165
166 Process *process = exe_ctx.GetProcessPtr();
167 if (process)
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000168 {
Sean Callanan933693b2012-02-10 01:22:05 +0000169 ret.byte_order = process->GetByteOrder();
170 ret.address_byte_size = process->GetAddressByteSize();
171 }
172 else
173 {
174 Target *target = exe_ctx.GetTargetPtr();
175 if (target)
Greg Claytonc14ee322011-09-22 04:58:26 +0000176 {
Sean Callanan933693b2012-02-10 01:22:05 +0000177 ret.byte_order = target->GetArchitecture().GetByteOrder();
178 ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
Greg Claytonc14ee322011-09-22 04:58:26 +0000179 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000180 }
Sean Callanan933693b2012-02-10 01:22:05 +0000181
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000182 return ret;
183}
184
Greg Clayton7b462cc2010-10-15 22:48:33 +0000185const ConstString &
186ClangExpressionDeclMap::GetPersistentResultName ()
Sean Callanand1e5b432010-08-12 01:56:52 +0000187{
Sean Callanan979f74d2010-12-03 01:38:59 +0000188 assert (m_struct_vars.get());
189 assert (m_parser_vars.get());
Sean Callanan979f74d2010-12-03 01:38:59 +0000190 if (!m_struct_vars->m_result_name)
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000191 {
192 Target *target = m_parser_vars->GetTarget();
193 assert (target);
194 m_struct_vars->m_result_name = target->GetPersistentVariables().GetNextPersistentVariableName();
195 }
Sean Callanan979f74d2010-12-03 01:38:59 +0000196 return m_struct_vars->m_result_name;
Sean Callanand1e5b432010-08-12 01:56:52 +0000197}
198
Sean Callanane4ec90e2010-12-16 03:17:46 +0000199lldb::ClangExpressionVariableSP
200ClangExpressionDeclMap::BuildIntegerVariable (const ConstString &name,
201 lldb_private::TypeFromParser type,
202 const llvm::APInt& value)
203{
204 assert (m_parser_vars.get());
Sean Callananb9951192011-08-01 18:18:33 +0000205
Sean Callanan933693b2012-02-10 01:22:05 +0000206 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
207
208 Target *target = exe_ctx.GetTargetPtr();
209
210 if (!target)
211 return ClangExpressionVariableSP();
Greg Claytonc14ee322011-09-22 04:58:26 +0000212
213 ASTContext *context(target->GetScratchClangASTContext()->getASTContext());
Sean Callanane4ec90e2010-12-16 03:17:46 +0000214
Sean Callanan00f43622011-11-18 03:28:09 +0000215 TypeFromUser user_type(m_ast_importer->CopyType(context,
216 type.GetASTContext(),
217 type.GetOpaqueQualType()),
Sean Callanane4ec90e2010-12-16 03:17:46 +0000218 context);
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000219
Sean Callanane0a64f72011-12-01 21:04:37 +0000220 if (!user_type.GetOpaqueQualType())
221 {
Greg Clayton5160ce52013-03-27 23:08:40 +0000222 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanane0a64f72011-12-01 21:04:37 +0000223
224 if (log)
225 log->Printf("ClangExpressionDeclMap::BuildIntegerVariable - Couldn't export the type for a constant integer result");
226
227 return lldb::ClangExpressionVariableSP();
228 }
229
Sean Callanan933693b2012-02-10 01:22:05 +0000230 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
Jim Ingham6035b672011-03-31 00:19:25 +0000231 name,
Sean Callanane4f987222011-01-04 02:41:41 +0000232 user_type,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000233 m_parser_vars->m_target_info.byte_order,
234 m_parser_vars->m_target_info.address_byte_size))
Sean Callanane4f987222011-01-04 02:41:41 +0000235 return lldb::ClangExpressionVariableSP();
Sean Callanane4ec90e2010-12-16 03:17:46 +0000236
Sean Callanane4f987222011-01-04 02:41:41 +0000237 ClangExpressionVariableSP pvar_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
238
239 if (!pvar_sp)
240 return lldb::ClangExpressionVariableSP();
241
242 uint8_t *pvar_data = pvar_sp->GetValueBytes();
243 if (pvar_data == NULL)
244 return lldb::ClangExpressionVariableSP();
Sean Callanane4ec90e2010-12-16 03:17:46 +0000245
246 uint64_t value64 = value.getLimitedValue();
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000247
Sean Callanane4ec90e2010-12-16 03:17:46 +0000248 size_t num_val_bytes = sizeof(value64);
Sean Callanane4f987222011-01-04 02:41:41 +0000249 size_t num_data_bytes = pvar_sp->GetByteSize();
Sean Callanane4ec90e2010-12-16 03:17:46 +0000250
251 size_t num_bytes = num_val_bytes;
252 if (num_bytes > num_data_bytes)
253 num_bytes = num_data_bytes;
254
Johnny Chen44805302011-07-19 19:48:13 +0000255 for (size_t byte_idx = 0;
Sean Callanane4ec90e2010-12-16 03:17:46 +0000256 byte_idx < num_bytes;
257 ++byte_idx)
258 {
259 uint64_t shift = byte_idx * 8;
260 uint64_t mask = 0xffll << shift;
261 uint8_t cur_byte = (uint8_t)((value64 & mask) >> shift);
262
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000263 switch (m_parser_vars->m_target_info.byte_order)
Sean Callanane4ec90e2010-12-16 03:17:46 +0000264 {
Sean Callanane4f987222011-01-04 02:41:41 +0000265 case eByteOrderBig:
266 // High Low
267 // Original: |AABBCCDDEEFFGGHH|
268 // Target: |EEFFGGHH|
269
270 pvar_data[num_data_bytes - (1 + byte_idx)] = cur_byte;
271 break;
272 case eByteOrderLittle:
273 // Target: |HHGGFFEE|
274 pvar_data[byte_idx] = cur_byte;
275 break;
276 default:
277 return lldb::ClangExpressionVariableSP();
Sean Callanane4ec90e2010-12-16 03:17:46 +0000278 }
279 }
Sean Callanan92adcac2011-01-13 08:53:35 +0000280
281 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
Sean Callanan63697e52011-05-07 01:06:41 +0000282 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
283 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
Sean Callanane4f987222011-01-04 02:41:41 +0000284
285 return pvar_sp;
Sean Callanane4ec90e2010-12-16 03:17:46 +0000286}
287
Sean Callanan63697e52011-05-07 01:06:41 +0000288lldb::ClangExpressionVariableSP
289ClangExpressionDeclMap::BuildCastVariable (const ConstString &name,
Sean Callanancc427fa2011-07-30 02:42:06 +0000290 VarDecl *decl,
Sean Callanan63697e52011-05-07 01:06:41 +0000291 lldb_private::TypeFromParser type)
292{
293 assert (m_parser_vars.get());
294
Greg Clayton5160ce52013-03-27 23:08:40 +0000295 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan63697e52011-05-07 01:06:41 +0000296
Sean Callanan933693b2012-02-10 01:22:05 +0000297 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
298 Target *target = exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +0000299 if (target == NULL)
300 return lldb::ClangExpressionVariableSP();
301
302 ASTContext *context(target->GetScratchClangASTContext()->getASTContext());
Sean Callanan63697e52011-05-07 01:06:41 +0000303
Sean Callanan3c495c12013-01-15 23:29:36 +0000304 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl, GetParserID()));
Sean Callanan63697e52011-05-07 01:06:41 +0000305
306 if (!var_sp)
Sean Callanan3c495c12013-01-15 23:29:36 +0000307 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl, GetParserID());
Sean Callanan63697e52011-05-07 01:06:41 +0000308
309 if (!var_sp)
310 return ClangExpressionVariableSP();
311
Sean Callanan00f43622011-11-18 03:28:09 +0000312 TypeFromUser user_type(m_ast_importer->CopyType(context,
313 type.GetASTContext(),
314 type.GetOpaqueQualType()),
Sean Callanan63697e52011-05-07 01:06:41 +0000315 context);
316
Sean Callanane0a64f72011-12-01 21:04:37 +0000317 if (!user_type.GetOpaqueQualType())
Jason Molendaccd41e52012-10-04 22:47:07 +0000318 {
Sean Callanane0a64f72011-12-01 21:04:37 +0000319 if (log)
320 log->Printf("ClangExpressionDeclMap::BuildCastVariable - Couldn't export the type for a constant cast result");
321
322 return lldb::ClangExpressionVariableSP();
323 }
324
Sean Callanan63697e52011-05-07 01:06:41 +0000325 TypeFromUser var_type = var_sp->GetTypeFromUser();
326
Sean Callanan933693b2012-02-10 01:22:05 +0000327 StackFrame *frame = exe_ctx.GetFramePtr();
Greg Claytonc14ee322011-09-22 04:58:26 +0000328 if (frame == NULL)
329 return lldb::ClangExpressionVariableSP();
330
331 VariableSP var = FindVariableInScope (*frame, var_sp->GetName(), &var_type);
Sean Callanan63697e52011-05-07 01:06:41 +0000332
333 if (!var)
334 return lldb::ClangExpressionVariableSP(); // but we should handle this; it may be a persistent variable
335
Greg Claytonc14ee322011-09-22 04:58:26 +0000336 ValueObjectSP var_valobj = frame->GetValueObjectForFrameVariable(var, lldb::eNoDynamicValues);
Sean Callanan63697e52011-05-07 01:06:41 +0000337
338 if (!var_valobj)
339 return lldb::ClangExpressionVariableSP();
340
341 ValueObjectSP var_casted_valobj = var_valobj->CastPointerType(name.GetCString(), user_type);
342
343 if (!var_casted_valobj)
344 return lldb::ClangExpressionVariableSP();
345
346 if (log)
347 {
348 StreamString my_stream_string;
349
350 ClangASTType::DumpTypeDescription (var_type.GetASTContext(),
351 var_type.GetOpaqueQualType(),
352 &my_stream_string);
353
354
355 log->Printf("Building cast variable to type: %s", my_stream_string.GetString().c_str());
356 }
357
358 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->CreatePersistentVariable (var_casted_valobj);
359
360 if (!pvar_sp)
361 return lldb::ClangExpressionVariableSP();
362
363 if (pvar_sp != m_parser_vars->m_persistent_vars->GetVariable(name))
364 return lldb::ClangExpressionVariableSP();
365
366 pvar_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
367 pvar_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
368 pvar_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
369
370 return pvar_sp;
371}
372
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000373bool
374ClangExpressionDeclMap::ResultIsReference (const ConstString &name)
375{
376 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->GetVariable(name);
377
378 return (pvar_sp->m_flags & ClangExpressionVariable::EVIsProgramReference);
379}
380
381bool
Sean Callanan08052af2013-04-17 07:50:58 +0000382ClangExpressionDeclMap::CompleteResultVariable (lldb::ClangExpressionVariableSP &valobj,
383 IRMemoryMap &map,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000384 lldb_private::Value &value,
385 const ConstString &name,
Sean Callanan0886e562011-09-22 00:41:11 +0000386 lldb_private::TypeFromParser type,
Sean Callanan80c48c12011-10-21 05:18:02 +0000387 bool transient,
388 bool maybe_make_load)
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000389{
390 assert (m_parser_vars.get());
391
392 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->GetVariable(name);
393
394 if (!pvar_sp)
395 return false;
Sean Callanan80c48c12011-10-21 05:18:02 +0000396
397 if (maybe_make_load &&
398 value.GetValueType() == Value::eValueTypeFileAddress &&
Sean Callanan933693b2012-02-10 01:22:05 +0000399 m_parser_vars->m_exe_ctx.GetProcessPtr())
Sean Callanan80c48c12011-10-21 05:18:02 +0000400 {
401 value.SetValueType(Value::eValueTypeLoadAddress);
402 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000403
404 if (pvar_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
Sean Callanan0886e562011-09-22 00:41:11 +0000405 !pvar_sp->m_live_sp &&
406 !transient)
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000407 {
408 // The reference comes from the program. We need to set up a live SP for it.
409
Johnny Chenb456b792011-12-16 23:04:52 +0000410 unsigned long long address = value.GetScalar().ULongLong();
411 AddressType address_type = value.GetValueAddressType();
412
Sean Callanan933693b2012-02-10 01:22:05 +0000413 pvar_sp->m_live_sp = ValueObjectConstResult::Create(m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000414 pvar_sp->GetTypeFromUser().GetASTContext(),
415 pvar_sp->GetTypeFromUser().GetOpaqueQualType(),
416 pvar_sp->GetName(),
Johnny Chenb456b792011-12-16 23:04:52 +0000417 address,
418 address_type,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000419 pvar_sp->GetByteSize());
420 }
421
422 if (pvar_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry)
423 {
424 pvar_sp->ValueUpdated();
425
426 const size_t pvar_byte_size = pvar_sp->GetByteSize();
427 uint8_t *pvar_data = pvar_sp->GetValueBytes();
428
Sean Callanan08052af2013-04-17 07:50:58 +0000429 if (!ReadTarget(map, pvar_data, value, pvar_byte_size))
Sean Callanan5b26f272012-02-04 08:49:35 +0000430 return false;
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000431
432 pvar_sp->m_flags &= ~(ClangExpressionVariable::EVNeedsFreezeDry);
433 }
434
435 valobj = pvar_sp;
436
437 return true;
438}
439
Sean Callanan5b26f272012-02-04 08:49:35 +0000440void
441ClangExpressionDeclMap::RemoveResultVariable
442(
443 const ConstString &name
444)
445{
446 ClangExpressionVariableSP pvar_sp = m_parser_vars->m_persistent_vars->GetVariable(name);
447 m_parser_vars->m_persistent_vars->RemovePersistentVariable(pvar_sp);
448}
449
Sean Callanan549c9f72010-07-13 21:41:46 +0000450bool
Greg Clayton7b462cc2010-10-15 22:48:33 +0000451ClangExpressionDeclMap::AddPersistentVariable
452(
Sean Callanancc427fa2011-07-30 02:42:06 +0000453 const NamedDecl *decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000454 const ConstString &name,
Sean Callanan92adcac2011-01-13 08:53:35 +0000455 TypeFromParser parser_type,
456 bool is_result,
457 bool is_lvalue
Greg Clayton7b462cc2010-10-15 22:48:33 +0000458)
Sean Callanan2235f322010-08-11 03:57:18 +0000459{
Sean Callanan979f74d2010-12-03 01:38:59 +0000460 assert (m_parser_vars.get());
461
Sean Callanan1582ee62013-04-18 22:06:33 +0000462 if (m_parser_vars->m_materializer && is_result)
463 {
464 Error err;
465
466 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
467 Target *target = exe_ctx.GetTargetPtr();
468 if (target == NULL)
469 return false;
470
471 ASTContext *context(target->GetScratchClangASTContext()->getASTContext());
472
473 TypeFromUser user_type(m_ast_importer->DeportType(context,
474 parser_type.GetASTContext(),
475 parser_type.GetOpaqueQualType()),
476 context);
477
478 uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(user_type, is_lvalue, m_keep_result_in_memory, err);
479
480 m_found_entities.CreateVariable(exe_ctx.GetBestExecutionContextScope(),
481 name,
482 user_type,
483 m_parser_vars->m_target_info.byte_order,
484 m_parser_vars->m_target_info.address_byte_size);
485
486 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(name));
487
488 if (!var_sp)
489 return false;
490
491 var_sp->EnableParserVars(GetParserID());
492
493 ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
494
495 parser_vars->m_named_decl = decl;
496 parser_vars->m_parser_type = parser_type;
497
498 var_sp->EnableJITVars(GetParserID());
499
500 ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID());
501
502 jit_vars->m_offset = offset;
503
504 return true;
505 }
506
Greg Clayton5160ce52013-03-27 23:08:40 +0000507 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +0000508 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
509 Target *target = exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +0000510 if (target == NULL)
511 return false;
512
513 ASTContext *context(target->GetScratchClangASTContext()->getASTContext());
Sean Callanan2235f322010-08-11 03:57:18 +0000514
Sean Callananbb120042011-12-16 21:06:35 +0000515 TypeFromUser user_type(m_ast_importer->DeportType(context,
516 parser_type.GetASTContext(),
517 parser_type.GetOpaqueQualType()),
Sean Callanane1175b72011-01-13 21:23:32 +0000518 context);
Sean Callanan00f43622011-11-18 03:28:09 +0000519
520 if (!user_type.GetOpaqueQualType())
521 {
522 if (log)
523 log->Printf("Persistent variable's type wasn't copied successfully");
524 return false;
525 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000526
527 if (!m_parser_vars->m_target_info.IsValid())
528 return false;
Sean Callanan2235f322010-08-11 03:57:18 +0000529
Sean Callanan933693b2012-02-10 01:22:05 +0000530 if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
Jim Ingham6035b672011-03-31 00:19:25 +0000531 name,
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000532 user_type,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000533 m_parser_vars->m_target_info.byte_order,
534 m_parser_vars->m_target_info.address_byte_size))
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000535 return false;
536
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000537 ClangExpressionVariableSP var_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000538
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000539 if (!var_sp)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000540 return false;
541
Sean Callanan2cb5e522012-09-20 23:21:16 +0000542 var_sp->m_frozen_sp->SetHasCompleteType();
543
Sean Callanan92adcac2011-01-13 08:53:35 +0000544 if (is_result)
545 var_sp->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
546 else
547 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
548
549 if (is_lvalue)
550 {
551 var_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
552 }
553 else
554 {
555 var_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
556 var_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
557 }
558
Sean Callanan35005f72013-04-12 18:10:34 +0000559 if (m_keep_result_in_memory)
560 {
561 var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget;
562 }
563
Sean Callanan92adcac2011-01-13 08:53:35 +0000564 if (log)
565 log->Printf("Created persistent variable with flags 0x%hx", var_sp->m_flags);
566
Sean Callanan3c495c12013-01-15 23:29:36 +0000567 var_sp->EnableParserVars(GetParserID());
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000568
Sean Callanan3c495c12013-01-15 23:29:36 +0000569 ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
570
571 parser_vars->m_named_decl = decl;
572 parser_vars->m_parser_type = parser_type;
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000573
574 return true;
Sean Callanan2235f322010-08-11 03:57:18 +0000575}
576
577bool
Greg Clayton7b462cc2010-10-15 22:48:33 +0000578ClangExpressionDeclMap::AddValueToStruct
579(
Sean Callanancc427fa2011-07-30 02:42:06 +0000580 const NamedDecl *decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000581 const ConstString &name,
582 llvm::Value *value,
583 size_t size,
584 off_t alignment
585)
Sean Callanan549c9f72010-07-13 21:41:46 +0000586{
Sean Callanan979f74d2010-12-03 01:38:59 +0000587 assert (m_struct_vars.get());
588 assert (m_parser_vars.get());
589
Sean Callanandf667652013-04-11 02:05:11 +0000590 bool is_persistent_variable = false;
591
Greg Clayton5160ce52013-03-27 23:08:40 +0000592 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan823bb4c2010-08-30 22:17:16 +0000593
Sean Callanan979f74d2010-12-03 01:38:59 +0000594 m_struct_vars->m_struct_laid_out = false;
Sean Callanan549c9f72010-07-13 21:41:46 +0000595
Sean Callanan3c495c12013-01-15 23:29:36 +0000596 if (m_struct_members.GetVariable(decl, GetParserID()))
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000597 return true;
Sean Callanan549c9f72010-07-13 21:41:46 +0000598
Sean Callanan3c495c12013-01-15 23:29:36 +0000599 ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl, GetParserID()));
Sean Callanan549c9f72010-07-13 21:41:46 +0000600
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000601 if (!var_sp)
Sean Callanandf667652013-04-11 02:05:11 +0000602 {
Sean Callanan3c495c12013-01-15 23:29:36 +0000603 var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl, GetParserID());
Sean Callanandf667652013-04-11 02:05:11 +0000604 is_persistent_variable = true;
605 }
Sean Callanan549c9f72010-07-13 21:41:46 +0000606
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000607 if (!var_sp)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000608 return false;
609
Sean Callanan823bb4c2010-08-30 22:17:16 +0000610 if (log)
Sean Callanan00f43622011-11-18 03:28:09 +0000611 log->Printf("Adding value for (NamedDecl*)%p [%s - %s] to the structure",
Sean Callanan823bb4c2010-08-30 22:17:16 +0000612 decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000613 name.GetCString(),
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000614 var_sp->GetName().GetCString());
Sean Callanan823bb4c2010-08-30 22:17:16 +0000615
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000616 // We know entity->m_parser_vars is valid because we used a parser variable
617 // to find it
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000618
Sean Callanan3c495c12013-01-15 23:29:36 +0000619 ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
620
621 parser_vars->m_llvm_value = value;
622
Sean Callanan1582ee62013-04-18 22:06:33 +0000623 if (ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID()))
624 {
625 // We already laid this out; do not touch
626
627 if (log)
628 log->Printf("Already placed at 0x%llx", (unsigned long long)jit_vars->m_offset);
629 }
630
Sean Callanan3c495c12013-01-15 23:29:36 +0000631 var_sp->EnableJITVars(GetParserID());
632
633 ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID());
634
635 jit_vars->m_alignment = alignment;
636 jit_vars->m_size = size;
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000637
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000638 m_struct_members.AddVariable(var_sp);
Sean Callanan549c9f72010-07-13 21:41:46 +0000639
Sean Callanandf667652013-04-11 02:05:11 +0000640 if (m_parser_vars->m_materializer)
641 {
Sean Callanan3dd6a422013-04-11 21:16:36 +0000642 uint32_t offset = 0;
643
Sean Callanandf667652013-04-11 02:05:11 +0000644 Error err;
645
646 if (is_persistent_variable)
647 {
Sean Callanan3dd6a422013-04-11 21:16:36 +0000648 offset = m_parser_vars->m_materializer->AddPersistentVariable(var_sp, err);
Sean Callanandf667652013-04-11 02:05:11 +0000649 }
650 else
651 {
652 if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
Sean Callanan3dd6a422013-04-11 21:16:36 +0000653 offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
Sean Callanandf667652013-04-11 02:05:11 +0000654 else if (const RegisterInfo *reg_info = var_sp->GetRegisterInfo())
Sean Callanan3dd6a422013-04-11 21:16:36 +0000655 offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
Sean Callanandf667652013-04-11 02:05:11 +0000656 else if (parser_vars->m_lldb_var)
Sean Callanan3dd6a422013-04-11 21:16:36 +0000657 offset = m_parser_vars->m_materializer->AddVariable(parser_vars->m_lldb_var, err);
Sean Callanandf667652013-04-11 02:05:11 +0000658 }
Sean Callanan3dd6a422013-04-11 21:16:36 +0000659
660 if (!err.Success())
661 return false;
662
663 if (log)
664 log->Printf("Placed at 0x%llx", (unsigned long long)offset);
665
666 jit_vars->m_offset = offset; // TODO DoStructLayout() should not change this.
Sean Callanandf667652013-04-11 02:05:11 +0000667 }
668
Sean Callanan549c9f72010-07-13 21:41:46 +0000669 return true;
670}
671
672bool
673ClangExpressionDeclMap::DoStructLayout ()
674{
Sean Callanan979f74d2010-12-03 01:38:59 +0000675 assert (m_struct_vars.get());
676
677 if (m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000678 return true;
679
Sean Callanan14b1bae2013-04-16 23:25:35 +0000680 if (!m_parser_vars->m_materializer)
681 return false;
Sean Callanan3dd6a422013-04-11 21:16:36 +0000682
Sean Callanan14b1bae2013-04-16 23:25:35 +0000683 m_struct_vars->m_struct_alignment = m_parser_vars->m_materializer->GetStructAlignment();
684 m_struct_vars->m_struct_size = m_parser_vars->m_materializer->GetStructByteSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000685 m_struct_vars->m_struct_laid_out = true;
Sean Callanan549c9f72010-07-13 21:41:46 +0000686 return true;
687}
688
Greg Clayton7b462cc2010-10-15 22:48:33 +0000689bool ClangExpressionDeclMap::GetStructInfo
690(
691 uint32_t &num_elements,
692 size_t &size,
693 off_t &alignment
694)
Sean Callanan549c9f72010-07-13 21:41:46 +0000695{
Sean Callanan979f74d2010-12-03 01:38:59 +0000696 assert (m_struct_vars.get());
697
698 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000699 return false;
700
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000701 num_elements = m_struct_members.GetSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000702 size = m_struct_vars->m_struct_size;
703 alignment = m_struct_vars->m_struct_alignment;
Sean Callanan549c9f72010-07-13 21:41:46 +0000704
705 return true;
706}
707
708bool
Greg Clayton7b462cc2010-10-15 22:48:33 +0000709ClangExpressionDeclMap::GetStructElement
710(
Sean Callanancc427fa2011-07-30 02:42:06 +0000711 const NamedDecl *&decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000712 llvm::Value *&value,
713 off_t &offset,
714 ConstString &name,
715 uint32_t index
716)
Sean Callanan549c9f72010-07-13 21:41:46 +0000717{
Sean Callanan979f74d2010-12-03 01:38:59 +0000718 assert (m_struct_vars.get());
719
720 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000721 return false;
722
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000723 if (index >= m_struct_members.GetSize())
Sean Callanan549c9f72010-07-13 21:41:46 +0000724 return false;
725
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000726 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
Sean Callanan549c9f72010-07-13 21:41:46 +0000727
Sean Callanan3c495c12013-01-15 23:29:36 +0000728 if (!member_sp)
729 return false;
730
731 ClangExpressionVariable::ParserVars *parser_vars = member_sp->GetParserVars(GetParserID());
732 ClangExpressionVariable::JITVars *jit_vars = member_sp->GetJITVars(GetParserID());
733
734 if (!parser_vars ||
735 !jit_vars ||
Sean Callanan6f3e5ad2012-04-12 16:58:26 +0000736 !member_sp->GetValueObject())
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000737 return false;
738
Sean Callanan3c495c12013-01-15 23:29:36 +0000739 decl = parser_vars->m_named_decl;
740 value = parser_vars->m_llvm_value;
741 offset = jit_vars->m_offset;
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000742 name = member_sp->GetName();
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000743
Sean Callanan549c9f72010-07-13 21:41:46 +0000744 return true;
745}
746
Sean Callanan7ea35012010-07-27 21:39:39 +0000747bool
Greg Clayton7b462cc2010-10-15 22:48:33 +0000748ClangExpressionDeclMap::GetFunctionInfo
749(
Sean Callanancc427fa2011-07-30 02:42:06 +0000750 const NamedDecl *decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000751 uint64_t &ptr
752)
Sean Callanan4edba2d2010-07-27 02:07:53 +0000753{
Sean Callanan3c495c12013-01-15 23:29:36 +0000754 ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl, GetParserID()));
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000755
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000756 if (!entity_sp)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000757 return false;
Sean Callanan4edba2d2010-07-27 02:07:53 +0000758
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000759 // We know m_parser_vars is valid since we searched for the variable by
760 // its NamedDecl
Sean Callanan4edba2d2010-07-27 02:07:53 +0000761
Sean Callanan3c495c12013-01-15 23:29:36 +0000762 ClangExpressionVariable::ParserVars *parser_vars = entity_sp->GetParserVars(GetParserID());
763
764 ptr = parser_vars->m_lldb_value->GetScalar().ULongLong();
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000765
766 return true;
Sean Callanan4edba2d2010-07-27 02:07:53 +0000767}
768
Sean Callananefe9a422011-08-16 18:09:29 +0000769static void
770FindCodeSymbolInContext
771(
772 const ConstString &name,
773 SymbolContext &sym_ctx,
774 SymbolContextList &sc_list
775)
776{
Matt Kopec00049b82013-02-27 20:13:38 +0000777 SymbolContextList temp_sc_list;
Sean Callananefe9a422011-08-16 18:09:29 +0000778 if (sym_ctx.module_sp)
Matt Kopec00049b82013-02-27 20:13:38 +0000779 sym_ctx.module_sp->FindSymbolsWithNameAndType(name, eSymbolTypeAny, temp_sc_list);
Sean Callananefe9a422011-08-16 18:09:29 +0000780
Matt Kopec00049b82013-02-27 20:13:38 +0000781 if (!sc_list.GetSize() && sym_ctx.target_sp)
782 sym_ctx.target_sp->GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, temp_sc_list);
783
784 unsigned temp_sc_list_size = temp_sc_list.GetSize();
785 for (unsigned i = 0; i < temp_sc_list_size; i++)
786 {
787 SymbolContext sym_ctx;
788 temp_sc_list.GetContextAtIndex(i, sym_ctx);
789 if (sym_ctx.symbol)
790 {
791 switch (sym_ctx.symbol->GetType())
792 {
793 case eSymbolTypeCode:
794 case eSymbolTypeResolver:
795 sc_list.Append(sym_ctx);
796 break;
797
798 default:
799 break;
800 }
801 }
802 }
Sean Callananefe9a422011-08-16 18:09:29 +0000803}
804
Sean Callanan5300d372010-07-31 01:32:05 +0000805bool
Greg Clayton7b462cc2010-10-15 22:48:33 +0000806ClangExpressionDeclMap::GetFunctionAddress
807(
808 const ConstString &name,
Greg Clayton3f5c08f2011-05-18 22:01:49 +0000809 uint64_t &func_addr
Greg Clayton7b462cc2010-10-15 22:48:33 +0000810)
Sean Callanan5300d372010-07-31 01:32:05 +0000811{
Sean Callanan979f74d2010-12-03 01:38:59 +0000812 assert (m_parser_vars.get());
813
Greg Clayton5160ce52013-03-27 23:08:40 +0000814 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +0000815 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
816 Target *target = exe_ctx.GetTargetPtr();
Sean Callanan5300d372010-07-31 01:32:05 +0000817 // Back out in all cases where we're not fully initialized
Greg Claytonc14ee322011-09-22 04:58:26 +0000818 if (target == NULL)
Jim Ingham895c9822010-12-07 01:56:02 +0000819 return false;
820 if (!m_parser_vars->m_sym_ctx.target_sp)
Sean Callanan5300d372010-07-31 01:32:05 +0000821 return false;
822
Greg Clayton7a345282010-11-09 23:46:37 +0000823 SymbolContextList sc_list;
Sean Callanan5300d372010-07-31 01:32:05 +0000824
Sean Callananefe9a422011-08-16 18:09:29 +0000825 FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, sc_list);
Matt Kopec00049b82013-02-27 20:13:38 +0000826
Greg Clayton7a345282010-11-09 23:46:37 +0000827 if (!sc_list.GetSize())
Sean Callanan19b6afe2011-05-13 18:27:02 +0000828 {
829 // We occasionally get debug information in which a const function is reported
830 // as non-const, so the mangled name is wrong. This is a hack to compensate.
831
Sean Callananf4638562011-10-25 18:02:05 +0000832 if (!strncmp(name.GetCString(), "_ZN", 3) &&
833 strncmp(name.GetCString(), "_ZNK", 4))
Sean Callanan19b6afe2011-05-13 18:27:02 +0000834 {
Sean Callananf4638562011-10-25 18:02:05 +0000835 std::string fixed_scratch("_ZNK");
836 fixed_scratch.append(name.GetCString() + 3);
837 ConstString fixed_name(fixed_scratch.c_str());
Sean Callanan19b6afe2011-05-13 18:27:02 +0000838
839 if (log)
Sean Callananf4638562011-10-25 18:02:05 +0000840 log->Printf("Failed to find symbols given non-const name %s; trying %s", name.GetCString(), fixed_name.GetCString());
841
842 FindCodeSymbolInContext(fixed_name, m_parser_vars->m_sym_ctx, sc_list);
Sean Callanan19b6afe2011-05-13 18:27:02 +0000843 }
844 }
845
846 if (!sc_list.GetSize())
Sean Callanan5300d372010-07-31 01:32:05 +0000847 return false;
Matt Kopec00049b82013-02-27 20:13:38 +0000848
Sean Callanan5300d372010-07-31 01:32:05 +0000849 SymbolContext sym_ctx;
Greg Clayton7a345282010-11-09 23:46:37 +0000850 sc_list.GetContextAtIndex(0, sym_ctx);
Matt Kopec00049b82013-02-27 20:13:38 +0000851
Greg Clayton3f5c08f2011-05-18 22:01:49 +0000852 const Address *func_so_addr = NULL;
Matt Kopec00049b82013-02-27 20:13:38 +0000853 bool is_indirect_function = false;
854
Sean Callanan5300d372010-07-31 01:32:05 +0000855 if (sym_ctx.function)
Greg Clayton3f5c08f2011-05-18 22:01:49 +0000856 func_so_addr = &sym_ctx.function->GetAddressRange().GetBaseAddress();
Matt Kopec00049b82013-02-27 20:13:38 +0000857 else if (sym_ctx.symbol) {
Greg Claytone7612132012-03-07 21:03:09 +0000858 func_so_addr = &sym_ctx.symbol->GetAddress();
Matt Kopec00049b82013-02-27 20:13:38 +0000859 is_indirect_function = sym_ctx.symbol->IsIndirect();
860 } else
Sean Callanan5300d372010-07-31 01:32:05 +0000861 return false;
Matt Kopec00049b82013-02-27 20:13:38 +0000862
Sean Callananc6466fc2011-07-07 23:05:43 +0000863 if (!func_so_addr || !func_so_addr->IsValid())
864 return false;
Matt Kopec00049b82013-02-27 20:13:38 +0000865
866 func_addr = func_so_addr->GetCallableLoadAddress (target, is_indirect_function);
Greg Clayton3f5c08f2011-05-18 22:01:49 +0000867
Sean Callanan5300d372010-07-31 01:32:05 +0000868 return true;
869}
870
Greg Clayton084db102011-06-23 04:25:29 +0000871addr_t
Sean Callanane0b23b52012-11-15 02:02:04 +0000872ClangExpressionDeclMap::GetSymbolAddress (Target &target, Process *process, const ConstString &name, lldb::SymbolType symbol_type)
Sean Callananc3a16002011-01-17 23:42:46 +0000873{
Sean Callananc3a16002011-01-17 23:42:46 +0000874 SymbolContextList sc_list;
875
Sean Callanan947ccc72011-12-01 02:04:16 +0000876 target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
Sean Callananc3a16002011-01-17 23:42:46 +0000877
Greg Clayton084db102011-06-23 04:25:29 +0000878 const uint32_t num_matches = sc_list.GetSize();
879 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
880
Sean Callanan947ccc72011-12-01 02:04:16 +0000881 for (uint32_t i=0; i<num_matches && (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS); i++)
Greg Clayton084db102011-06-23 04:25:29 +0000882 {
883 SymbolContext sym_ctx;
884 sc_list.GetContextAtIndex(i, sym_ctx);
Sean Callananc3a16002011-01-17 23:42:46 +0000885
Greg Claytone7612132012-03-07 21:03:09 +0000886 const Address *sym_address = &sym_ctx.symbol->GetAddress();
Sean Callananc6466fc2011-07-07 23:05:43 +0000887
888 if (!sym_address || !sym_address->IsValid())
889 return LLDB_INVALID_ADDRESS;
890
Greg Clayton084db102011-06-23 04:25:29 +0000891 if (sym_address)
892 {
893 switch (sym_ctx.symbol->GetType())
894 {
895 case eSymbolTypeCode:
896 case eSymbolTypeTrampoline:
897 symbol_load_addr = sym_address->GetCallableLoadAddress (&target);
898 break;
Matt Kopec00049b82013-02-27 20:13:38 +0000899
900 case eSymbolTypeResolver:
901 symbol_load_addr = sym_address->GetCallableLoadAddress (&target, true);
902 break;
903
Greg Clayton084db102011-06-23 04:25:29 +0000904 case eSymbolTypeData:
905 case eSymbolTypeRuntime:
906 case eSymbolTypeVariable:
907 case eSymbolTypeLocal:
908 case eSymbolTypeParam:
909 case eSymbolTypeInvalid:
910 case eSymbolTypeAbsolute:
Greg Clayton084db102011-06-23 04:25:29 +0000911 case eSymbolTypeException:
912 case eSymbolTypeSourceFile:
913 case eSymbolTypeHeaderFile:
914 case eSymbolTypeObjectFile:
915 case eSymbolTypeCommonBlock:
916 case eSymbolTypeBlock:
917 case eSymbolTypeVariableType:
918 case eSymbolTypeLineEntry:
919 case eSymbolTypeLineHeader:
920 case eSymbolTypeScopeBegin:
921 case eSymbolTypeScopeEnd:
922 case eSymbolTypeAdditional:
923 case eSymbolTypeCompiler:
924 case eSymbolTypeInstrumentation:
925 case eSymbolTypeUndefined:
Greg Clayton456809c2011-12-03 02:30:59 +0000926 case eSymbolTypeObjCClass:
927 case eSymbolTypeObjCMetaClass:
928 case eSymbolTypeObjCIVar:
Greg Clayton084db102011-06-23 04:25:29 +0000929 symbol_load_addr = sym_address->GetLoadAddress (&target);
930 break;
931 }
932 }
933 }
Sean Callananc3a16002011-01-17 23:42:46 +0000934
Sean Callanane0b23b52012-11-15 02:02:04 +0000935 if (symbol_load_addr == LLDB_INVALID_ADDRESS && process)
936 {
937 ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
938
939 if (runtime)
940 {
941 symbol_load_addr = runtime->LookupRuntimeSymbol(name);
942 }
943 }
944
Greg Clayton084db102011-06-23 04:25:29 +0000945 return symbol_load_addr;
Sean Callananc3a16002011-01-17 23:42:46 +0000946}
947
Greg Clayton084db102011-06-23 04:25:29 +0000948addr_t
Sean Callanan947ccc72011-12-01 02:04:16 +0000949ClangExpressionDeclMap::GetSymbolAddress (const ConstString &name, lldb::SymbolType symbol_type)
Sean Callanand9ca42a2011-05-08 02:21:26 +0000950{
951 assert (m_parser_vars.get());
952
Sean Callanan933693b2012-02-10 01:22:05 +0000953 if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
Sean Callanand9ca42a2011-05-08 02:21:26 +0000954 return false;
955
Sean Callanane0b23b52012-11-15 02:02:04 +0000956 return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(), m_parser_vars->m_exe_ctx.GetProcessPtr(), name, symbol_type);
Sean Callanand9ca42a2011-05-08 02:21:26 +0000957}
958
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000959// Interface for IRInterpreter
960
Sean Callanan80c48c12011-10-21 05:18:02 +0000961Value
962ClangExpressionDeclMap::WrapBareAddress (lldb::addr_t addr)
963{
964 Value ret;
965
966 ret.SetContext(Value::eContextTypeInvalid, NULL);
967
Sean Callanan933693b2012-02-10 01:22:05 +0000968 if (m_parser_vars->m_exe_ctx.GetProcessPtr())
Sean Callanan80c48c12011-10-21 05:18:02 +0000969 ret.SetValueType(Value::eValueTypeLoadAddress);
970 else
971 ret.SetValueType(Value::eValueTypeFileAddress);
972
973 ret.GetScalar() = (unsigned long long)addr;
974
975 return ret;
976}
977
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000978bool
Sean Callanan08052af2013-04-17 07:50:58 +0000979ClangExpressionDeclMap::WriteTarget (lldb_private::IRMemoryMap &map,
980 lldb_private::Value &value,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000981 const uint8_t *data,
982 size_t length)
983{
984 assert (m_parser_vars.get());
985
Sean Callanan933693b2012-02-10 01:22:05 +0000986 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000987
Sean Callanan933693b2012-02-10 01:22:05 +0000988 Process *process = exe_ctx.GetProcessPtr();
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000989 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
990 {
Greg Claytonc14ee322011-09-22 04:58:26 +0000991 if (!process)
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000992 return false;
993
Sean Callanan933693b2012-02-10 01:22:05 +0000994 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000995 RegisterInfo *reg_info = value.GetRegisterInfo();
996
997 if (!reg_ctx)
998 return false;
999
1000 lldb_private::RegisterValue reg_value;
1001 Error err;
1002
Greg Claytonc14ee322011-09-22 04:58:26 +00001003 if (!reg_value.SetFromMemoryData (reg_info, data, length, process->GetByteOrder(), err))
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001004 return false;
1005
1006 return reg_ctx->WriteRegister(reg_info, reg_value);
1007 }
1008 else
1009 {
1010 switch (value.GetValueType())
1011 {
1012 default:
1013 return false;
1014 case Value::eValueTypeFileAddress:
1015 {
Greg Claytonc14ee322011-09-22 04:58:26 +00001016 if (!process)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001017 return false;
1018
Sean Callanan933693b2012-02-10 01:22:05 +00001019 Target *target = exe_ctx.GetTargetPtr();
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001020 Address file_addr;
1021
Greg Claytonc14ee322011-09-22 04:58:26 +00001022 if (!target->GetImages().ResolveFileAddress((lldb::addr_t)value.GetScalar().ULongLong(), file_addr))
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001023 return false;
1024
Greg Claytonc14ee322011-09-22 04:58:26 +00001025 lldb::addr_t load_addr = file_addr.GetLoadAddress(target);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001026
1027 Error err;
Sean Callanan08052af2013-04-17 07:50:58 +00001028 map.WriteMemory(load_addr, data, length, err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001029
1030 return err.Success();
1031 }
1032 case Value::eValueTypeLoadAddress:
1033 {
Greg Claytonc14ee322011-09-22 04:58:26 +00001034 if (!process)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001035 return false;
1036
1037 Error err;
Sean Callanan08052af2013-04-17 07:50:58 +00001038 map.WriteMemory((lldb::addr_t)value.GetScalar().ULongLong(), data, length, err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001039
1040 return err.Success();
1041 }
1042 case Value::eValueTypeHostAddress:
Sean Callanan0eed0d42011-12-06 03:41:14 +00001043 {
1044 if (value.GetScalar().ULongLong() == 0 || data == NULL)
1045 return false;
1046 memcpy ((void *)value.GetScalar().ULongLong(), data, length);
1047 return true;
1048 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001049 case Value::eValueTypeScalar:
1050 return false;
1051 }
1052 }
1053}
1054
1055bool
Sean Callanan08052af2013-04-17 07:50:58 +00001056ClangExpressionDeclMap::ReadTarget (IRMemoryMap &map,
1057 uint8_t *data,
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001058 lldb_private::Value &value,
1059 size_t length)
1060{
1061 assert (m_parser_vars.get());
1062
Sean Callanan933693b2012-02-10 01:22:05 +00001063 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
Greg Claytonc14ee322011-09-22 04:58:26 +00001064
Sean Callanan933693b2012-02-10 01:22:05 +00001065 Process *process = exe_ctx.GetProcessPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001066
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001067 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
1068 {
Greg Claytonc14ee322011-09-22 04:58:26 +00001069 if (!process)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001070 return false;
1071
Sean Callanan933693b2012-02-10 01:22:05 +00001072 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001073 RegisterInfo *reg_info = value.GetRegisterInfo();
1074
1075 if (!reg_ctx)
1076 return false;
1077
1078 lldb_private::RegisterValue reg_value;
1079 Error err;
1080
1081 if (!reg_ctx->ReadRegister(reg_info, reg_value))
1082 return false;
1083
Greg Claytonc14ee322011-09-22 04:58:26 +00001084 return reg_value.GetAsMemoryData(reg_info, data, length, process->GetByteOrder(), err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001085 }
1086 else
1087 {
1088 switch (value.GetValueType())
1089 {
1090 default:
1091 return false;
1092 case Value::eValueTypeFileAddress:
1093 {
Sean Callanan933693b2012-02-10 01:22:05 +00001094 Target *target = exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001095 if (target == NULL)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001096 return false;
1097
1098 Address file_addr;
1099
Greg Claytonc14ee322011-09-22 04:58:26 +00001100 if (!target->GetImages().ResolveFileAddress((lldb::addr_t)value.GetScalar().ULongLong(), file_addr))
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001101 return false;
1102
1103 Error err;
Sean Callanan80ef1242012-02-08 21:55:14 +00001104 target->ReadMemory(file_addr, false, data, length, err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001105
1106 return err.Success();
1107 }
1108 case Value::eValueTypeLoadAddress:
1109 {
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001110 Error err;
Sean Callanan08052af2013-04-17 07:50:58 +00001111 map.ReadMemory(data, (lldb::addr_t)value.GetScalar().ULongLong(), length, err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001112
1113 return err.Success();
1114 }
1115 case Value::eValueTypeHostAddress:
Sean Callanan00f43622011-11-18 03:28:09 +00001116 {
1117 void *host_addr = (void*)value.GetScalar().ULongLong();
1118
1119 if (!host_addr)
1120 return false;
1121
1122 memcpy (data, host_addr, length);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001123 return true;
Sean Callanan00f43622011-11-18 03:28:09 +00001124 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001125 case Value::eValueTypeScalar:
1126 return false;
1127 }
1128 }
1129}
1130
1131lldb_private::Value
Sean Callananf673e762012-02-15 01:40:39 +00001132ClangExpressionDeclMap::LookupDecl (clang::NamedDecl *decl, ClangExpressionVariable::FlagType &flags)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001133{
1134 assert (m_parser_vars.get());
Sean Callanan933693b2012-02-10 01:22:05 +00001135
Sean Callanan3c495c12013-01-15 23:29:36 +00001136 ClangExpressionVariableSP expr_var_sp (m_found_entities.GetVariable(decl, GetParserID()));
1137 ClangExpressionVariableSP persistent_var_sp (m_parser_vars->m_persistent_vars->GetVariable(decl, GetParserID()));
Sean Callanan9c95fd22011-11-02 23:24:30 +00001138
Sean Callanan9be9d172013-03-19 01:45:02 +00001139 if (isa<FunctionDecl>(decl))
1140 {
1141 ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl, GetParserID()));
1142
1143 if (!entity_sp)
1144 return Value();
1145
1146 // We know m_parser_vars is valid since we searched for the variable by
1147 // its NamedDecl
1148
1149 ClangExpressionVariable::ParserVars *parser_vars = entity_sp->GetParserVars(GetParserID());
1150
1151 return *parser_vars->m_lldb_value;
1152 }
1153
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001154 if (expr_var_sp)
1155 {
Sean Callananf673e762012-02-15 01:40:39 +00001156 flags = expr_var_sp->m_flags;
1157
Sean Callanan3c495c12013-01-15 23:29:36 +00001158 ClangExpressionVariable::ParserVars *parser_vars = expr_var_sp->GetParserVars(GetParserID());
1159
1160 if (!parser_vars)
Sean Callanane3aef1d2011-10-12 22:20:02 +00001161 return Value();
1162
Sean Callanan9c95fd22011-11-02 23:24:30 +00001163 bool is_reference = expr_var_sp->m_flags & ClangExpressionVariable::EVTypeIsReference;
Sean Callanan80ef1242012-02-08 21:55:14 +00001164
Sean Callanan3c495c12013-01-15 23:29:36 +00001165 if (parser_vars->m_lldb_var)
Sean Callanan9c95fd22011-11-02 23:24:30 +00001166 {
Greg Clayton7b0992d2013-04-18 22:45:39 +00001167 std::unique_ptr<Value> value(GetVariableValue(parser_vars->m_lldb_var, NULL));
Sean Callanan9c95fd22011-11-02 23:24:30 +00001168
Sean Callanan80ef1242012-02-08 21:55:14 +00001169 if (is_reference && value.get() && value->GetValueType() == Value::eValueTypeLoadAddress)
1170 {
Sean Callanan933693b2012-02-10 01:22:05 +00001171 Process *process = m_parser_vars->m_exe_ctx.GetProcessPtr();
Sean Callanan80ef1242012-02-08 21:55:14 +00001172
1173 if (!process)
1174 return Value();
1175
1176 lldb::addr_t value_addr = value->GetScalar().ULongLong();
1177 Error read_error;
1178 addr_t ref_value = process->ReadPointerFromMemory (value_addr, read_error);
1179
1180 if (!read_error.Success())
1181 return Value();
1182
1183 value->GetScalar() = (unsigned long long)ref_value;
1184 }
Sean Callanan9c95fd22011-11-02 23:24:30 +00001185
Sean Callanan80ef1242012-02-08 21:55:14 +00001186 if (value.get())
1187 return *value;
1188 else
1189 return Value();
1190 }
Sean Callanan3c495c12013-01-15 23:29:36 +00001191 else if (parser_vars->m_lldb_sym)
Sean Callanan80ef1242012-02-08 21:55:14 +00001192 {
Sean Callanan3c495c12013-01-15 23:29:36 +00001193 const Address sym_address = parser_vars->m_lldb_sym->GetAddress();
Sean Callanan80ef1242012-02-08 21:55:14 +00001194
1195 if (!sym_address.IsValid())
1196 return Value();
1197
1198 Value ret;
1199
Sean Callanan378ecbe2012-02-28 17:55:31 +00001200 ProcessSP process_sp (m_parser_vars->m_exe_ctx.GetProcessSP());
1201
1202 if (process_sp)
1203 {
1204 uint64_t symbol_load_addr = sym_address.GetLoadAddress(&process_sp->GetTarget());
1205
1206 ret.GetScalar() = symbol_load_addr;
1207 ret.SetValueType(Value::eValueTypeLoadAddress);
1208 }
1209 else
1210 {
1211 uint64_t symbol_file_addr = sym_address.GetFileAddress();
1212
1213 ret.GetScalar() = symbol_file_addr;
1214 ret.SetValueType(Value::eValueTypeFileAddress);
1215 }
Sean Callanan80ef1242012-02-08 21:55:14 +00001216
1217 return ret;
1218 }
Sean Callananf673e762012-02-15 01:40:39 +00001219 else if (RegisterInfo *reg_info = expr_var_sp->GetRegisterInfo())
1220 {
1221 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1222
1223 if (!frame)
1224 return Value();
1225
1226 RegisterContextSP reg_context_sp(frame->GetRegisterContextSP());
1227
1228 RegisterValue reg_value;
1229
1230 if (!reg_context_sp->ReadRegister(reg_info, reg_value))
1231 return Value();
1232
1233 Value ret;
1234
1235 ret.SetContext(Value::eContextTypeRegisterInfo, reg_info);
Greg Clayton0665a0f2012-10-30 18:18:43 +00001236 if (reg_info->encoding == eEncodingVector)
1237 {
1238 if (ret.SetVectorBytes((uint8_t *)reg_value.GetBytes(), reg_value.GetByteSize(), reg_value.GetByteOrder()))
1239 ret.SetScalarFromVector();
1240 }
1241 else if (!reg_value.GetScalarValue(ret.GetScalar()))
1242 return Value();
Sean Callananf673e762012-02-15 01:40:39 +00001243
1244 return ret;
1245 }
Sean Callanand2cb6262011-10-26 21:20:00 +00001246 else
Sean Callanan80ef1242012-02-08 21:55:14 +00001247 {
Sean Callanand2cb6262011-10-26 21:20:00 +00001248 return Value();
Sean Callanan80ef1242012-02-08 21:55:14 +00001249 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001250 }
1251 else if (persistent_var_sp)
1252 {
Sean Callananf673e762012-02-15 01:40:39 +00001253 flags = persistent_var_sp->m_flags;
1254
Sean Callanan0886e562011-09-22 00:41:11 +00001255 if ((persistent_var_sp->m_flags & ClangExpressionVariable::EVIsProgramReference ||
1256 persistent_var_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated) &&
Sean Callanana76eadd2011-10-22 01:58:08 +00001257 persistent_var_sp->m_live_sp &&
Sean Callanan9b3569b2011-12-10 03:12:34 +00001258 ((persistent_var_sp->m_live_sp->GetValue().GetValueType() == Value::eValueTypeLoadAddress &&
Sean Callanan933693b2012-02-10 01:22:05 +00001259 m_parser_vars->m_exe_ctx.GetProcessSP() &&
1260 m_parser_vars->m_exe_ctx.GetProcessSP()->IsAlive()) ||
Sean Callanan9b3569b2011-12-10 03:12:34 +00001261 (persistent_var_sp->m_live_sp->GetValue().GetValueType() == Value::eValueTypeFileAddress)))
Sean Callanan0886e562011-09-22 00:41:11 +00001262 {
Sean Callanand2cb6262011-10-26 21:20:00 +00001263 return persistent_var_sp->m_live_sp->GetValue();
Sean Callanan0886e562011-09-22 00:41:11 +00001264 }
1265 else
1266 {
1267 lldb_private::Value ret;
1268 ret.SetValueType(Value::eValueTypeHostAddress);
1269 ret.SetContext(Value::eContextTypeInvalid, NULL);
1270 ret.GetScalar() = (lldb::addr_t)persistent_var_sp->GetValueBytes();
1271 return ret;
1272 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001273 }
1274 else
1275 {
1276 return Value();
1277 }
1278}
1279
Sean Callanand2cb6262011-10-26 21:20:00 +00001280Value
1281ClangExpressionDeclMap::GetSpecialValue (const ConstString &name)
1282{
1283 assert(m_parser_vars.get());
1284
Sean Callanan933693b2012-02-10 01:22:05 +00001285 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
Sean Callanand2cb6262011-10-26 21:20:00 +00001286
1287 if (!frame)
1288 return Value();
1289
1290 VariableList *vars = frame->GetVariableList(false);
1291
1292 if (!vars)
1293 return Value();
1294
1295 lldb::VariableSP var = vars->FindVariable(name);
1296
1297 if (!var ||
1298 !var->IsInScope(frame) ||
1299 !var->LocationIsValidForFrame (frame))
1300 return Value();
1301
Greg Clayton7b0992d2013-04-18 22:45:39 +00001302 std::unique_ptr<Value> value(GetVariableValue(var, NULL));
Sean Callanand2cb6262011-10-26 21:20:00 +00001303
Sean Callanan3dea5c72011-11-03 22:48:37 +00001304 if (value.get() && value->GetValueType() == Value::eValueTypeLoadAddress)
1305 {
Sean Callanan933693b2012-02-10 01:22:05 +00001306 Process *process = m_parser_vars->m_exe_ctx.GetProcessPtr();
Sean Callanan3dea5c72011-11-03 22:48:37 +00001307
1308 if (!process)
1309 return Value();
1310
1311 lldb::addr_t value_addr = value->GetScalar().ULongLong();
1312 Error read_error;
1313 addr_t ptr_value = process->ReadPointerFromMemory (value_addr, read_error);
1314
1315 if (!read_error.Success())
1316 return Value();
1317
1318 value->GetScalar() = (unsigned long long)ptr_value;
1319 }
1320
Sean Callanand2cb6262011-10-26 21:20:00 +00001321 if (value.get())
1322 return *value;
1323 else
1324 return Value();
1325}
1326
Sean Callananea22d422010-07-16 00:09:46 +00001327// Interface for CommandObjectExpression
Sean Callanan1d180662010-07-20 23:31:16 +00001328
1329bool
Greg Clayton7b462cc2010-10-15 22:48:33 +00001330ClangExpressionDeclMap::Materialize
1331(
Sean Callanan14b1bae2013-04-16 23:25:35 +00001332 IRMemoryMap &map,
Greg Clayton7b462cc2010-10-15 22:48:33 +00001333 lldb::addr_t &struct_address,
1334 Error &err
1335)
Sean Callanan1d180662010-07-20 23:31:16 +00001336{
Sean Callanan933693b2012-02-10 01:22:05 +00001337 if (!m_parser_vars.get())
1338 return false;
1339
Sean Callanan979f74d2010-12-03 01:38:59 +00001340 EnableMaterialVars();
1341
Sean Callanan933693b2012-02-10 01:22:05 +00001342 m_material_vars->m_process = m_parser_vars->m_exe_ctx.GetProcessPtr();
Sean Callanan979f74d2010-12-03 01:38:59 +00001343
Sean Callanan14b1bae2013-04-16 23:25:35 +00001344 bool result = DoMaterialize(false /* dematerialize */,
1345 map,
Sean Callanane359d9b2011-05-09 22:04:36 +00001346 LLDB_INVALID_ADDRESS /* top of stack frame */,
1347 LLDB_INVALID_ADDRESS /* bottom of stack frame */,
1348 NULL, /* result SP */
1349 err);
Sean Callanan1d180662010-07-20 23:31:16 +00001350
1351 if (result)
Sean Callanan979f74d2010-12-03 01:38:59 +00001352 struct_address = m_material_vars->m_materialized_location;
Sean Callanan1d180662010-07-20 23:31:16 +00001353
1354 return result;
1355}
1356
1357bool
Greg Clayton7b462cc2010-10-15 22:48:33 +00001358ClangExpressionDeclMap::GetObjectPointer
1359(
1360 lldb::addr_t &object_ptr,
Sean Callanan17827832010-12-13 22:46:15 +00001361 ConstString &object_name,
Sean Callanan9d48e802010-12-14 00:42:36 +00001362 Error &err,
1363 bool suppress_type_check
Greg Clayton7b462cc2010-10-15 22:48:33 +00001364)
Sean Callananfc55f5d2010-09-21 00:44:12 +00001365{
Sean Callanan979f74d2010-12-03 01:38:59 +00001366 assert (m_struct_vars.get());
1367
Sean Callanan933693b2012-02-10 01:22:05 +00001368 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1369 Process *process = m_parser_vars->m_exe_ctx.GetProcessPtr();
1370 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001371
1372 if (frame == NULL || process == NULL || target == NULL)
Sean Callananfc55f5d2010-09-21 00:44:12 +00001373 {
Sean Callanand5c17ed2011-11-15 02:11:17 +00001374 err.SetErrorStringWithFormat("Couldn't load '%s' because the context is incomplete", object_name.AsCString());
Sean Callananfc55f5d2010-09-21 00:44:12 +00001375 return false;
1376 }
1377
Sean Callanan979f74d2010-12-03 01:38:59 +00001378 if (!m_struct_vars->m_object_pointer_type.GetOpaqueQualType())
Sean Callananfc55f5d2010-09-21 00:44:12 +00001379 {
Sean Callanand5c17ed2011-11-15 02:11:17 +00001380 err.SetErrorStringWithFormat("Couldn't load '%s' because its type is unknown", object_name.AsCString());
Sean Callananfc55f5d2010-09-21 00:44:12 +00001381 return false;
1382 }
1383
Sean Callanan0259e512012-05-21 21:29:52 +00001384 const bool object_pointer = true;
Sean Callanan5056ab02012-02-18 02:01:03 +00001385
Greg Claytonc14ee322011-09-22 04:58:26 +00001386 VariableSP object_ptr_var = FindVariableInScope (*frame,
Sean Callanan63697e52011-05-07 01:06:41 +00001387 object_name,
Sean Callanan5056ab02012-02-18 02:01:03 +00001388 (suppress_type_check ? NULL : &m_struct_vars->m_object_pointer_type),
Sean Callanan0259e512012-05-21 21:29:52 +00001389 object_pointer);
Sean Callananfc55f5d2010-09-21 00:44:12 +00001390
1391 if (!object_ptr_var)
1392 {
Sean Callanand5c17ed2011-11-15 02:11:17 +00001393 err.SetErrorStringWithFormat("Couldn't find '%s' with appropriate type in scope", object_name.AsCString());
Sean Callananfc55f5d2010-09-21 00:44:12 +00001394 return false;
1395 }
1396
Greg Clayton7b0992d2013-04-18 22:45:39 +00001397 std::unique_ptr<lldb_private::Value> location_value(GetVariableValue(object_ptr_var,
Sean Callanan979f74d2010-12-03 01:38:59 +00001398 NULL));
Sean Callananfc55f5d2010-09-21 00:44:12 +00001399
1400 if (!location_value.get())
1401 {
Sean Callanan17827832010-12-13 22:46:15 +00001402 err.SetErrorStringWithFormat("Couldn't get the location for '%s'", object_name.GetCString());
Sean Callananfc55f5d2010-09-21 00:44:12 +00001403 return false;
1404 }
1405
Sean Callanan54366f12011-03-04 00:23:47 +00001406 switch (location_value->GetValueType())
Sean Callananfc55f5d2010-09-21 00:44:12 +00001407 {
Sean Callanan54366f12011-03-04 00:23:47 +00001408 default:
Sean Callanan17827832010-12-13 22:46:15 +00001409 err.SetErrorStringWithFormat("'%s' is not in memory; LLDB must be extended to handle registers", object_name.GetCString());
Sean Callananfc55f5d2010-09-21 00:44:12 +00001410 return false;
Sean Callanan54366f12011-03-04 00:23:47 +00001411 case Value::eValueTypeLoadAddress:
1412 {
1413 lldb::addr_t value_addr = location_value->GetScalar().ULongLong();
Greg Claytonc14ee322011-09-22 04:58:26 +00001414 uint32_t address_byte_size = target->GetArchitecture().GetAddressByteSize();
Sean Callanan54366f12011-03-04 00:23:47 +00001415
1416 if (ClangASTType::GetClangTypeBitWidth(m_struct_vars->m_object_pointer_type.GetASTContext(),
1417 m_struct_vars->m_object_pointer_type.GetOpaqueQualType()) != address_byte_size * 8)
1418 {
1419 err.SetErrorStringWithFormat("'%s' is not of an expected pointer size", object_name.GetCString());
1420 return false;
1421 }
1422
Sean Callanan54366f12011-03-04 00:23:47 +00001423 Error read_error;
Greg Claytonc14ee322011-09-22 04:58:26 +00001424 object_ptr = process->ReadPointerFromMemory (value_addr, read_error);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001425 if (read_error.Fail() || object_ptr == LLDB_INVALID_ADDRESS)
Sean Callanan54366f12011-03-04 00:23:47 +00001426 {
1427 err.SetErrorStringWithFormat("Coldn't read '%s' from the target: %s", object_name.GetCString(), read_error.AsCString());
1428 return false;
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001429 }
Sean Callanan54366f12011-03-04 00:23:47 +00001430 return true;
1431 }
1432 case Value::eValueTypeScalar:
1433 {
1434 if (location_value->GetContextType() != Value::eContextTypeRegisterInfo)
1435 {
1436 StreamString ss;
1437 location_value->Dump(&ss);
1438
1439 err.SetErrorStringWithFormat("%s is a scalar of unhandled type: %s", object_name.GetCString(), ss.GetString().c_str());
1440 return false;
1441 }
1442
Greg Clayton7349bd92011-05-09 20:18:18 +00001443 RegisterInfo *reg_info = location_value->GetRegisterInfo();
Sean Callanan54366f12011-03-04 00:23:47 +00001444
Greg Clayton7349bd92011-05-09 20:18:18 +00001445 if (!reg_info)
Sean Callanan54366f12011-03-04 00:23:47 +00001446 {
1447 err.SetErrorStringWithFormat("Couldn't get the register information for %s", object_name.GetCString());
1448 return false;
1449 }
1450
Sean Callanan933693b2012-02-10 01:22:05 +00001451 RegisterContext *reg_ctx = m_parser_vars->m_exe_ctx.GetRegisterContext();
Sean Callanan54366f12011-03-04 00:23:47 +00001452
Greg Clayton7349bd92011-05-09 20:18:18 +00001453 if (!reg_ctx)
Sean Callanan54366f12011-03-04 00:23:47 +00001454 {
Greg Clayton7349bd92011-05-09 20:18:18 +00001455 err.SetErrorStringWithFormat("Couldn't read register context to read %s from %s", object_name.GetCString(), reg_info->name);
Sean Callanan54366f12011-03-04 00:23:47 +00001456 return false;
1457 }
1458
Greg Clayton7349bd92011-05-09 20:18:18 +00001459 uint32_t register_number = reg_info->kinds[lldb::eRegisterKindLLDB];
Sean Callanan54366f12011-03-04 00:23:47 +00001460
Greg Clayton7349bd92011-05-09 20:18:18 +00001461 object_ptr = reg_ctx->ReadRegisterAsUnsigned(register_number, 0x0);
Sean Callanan54366f12011-03-04 00:23:47 +00001462
1463 return true;
1464 }
Sean Callananfc55f5d2010-09-21 00:44:12 +00001465 }
1466}
1467
1468bool
Greg Clayton7b462cc2010-10-15 22:48:33 +00001469ClangExpressionDeclMap::Dematerialize
1470(
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001471 ClangExpressionVariableSP &result_sp,
Sean Callanan14b1bae2013-04-16 23:25:35 +00001472 IRMemoryMap &map,
Sean Callanane359d9b2011-05-09 22:04:36 +00001473 lldb::addr_t stack_frame_top,
1474 lldb::addr_t stack_frame_bottom,
Greg Clayton7b462cc2010-10-15 22:48:33 +00001475 Error &err
1476)
Sean Callanan1d180662010-07-20 23:31:16 +00001477{
Sean Callanan14b1bae2013-04-16 23:25:35 +00001478 return DoMaterialize(true, map, stack_frame_top, stack_frame_bottom, &result_sp, err);
Sean Callanan979f74d2010-12-03 01:38:59 +00001479
1480 DidDematerialize();
1481}
1482
1483void
1484ClangExpressionDeclMap::DidDematerialize()
1485{
1486 if (m_material_vars.get())
1487 {
1488 if (m_material_vars->m_materialized_location)
1489 {
1490 //#define SINGLE_STEP_EXPRESSIONS
1491
1492#ifndef SINGLE_STEP_EXPRESSIONS
1493 m_material_vars->m_process->DeallocateMemory(m_material_vars->m_materialized_location);
1494#endif
1495 m_material_vars->m_materialized_location = 0;
1496 }
1497
1498 DisableMaterialVars();
1499 }
Sean Callanan1d180662010-07-20 23:31:16 +00001500}
1501
Sean Callanan289e07b2010-07-23 22:19:18 +00001502bool
Greg Clayton7b462cc2010-10-15 22:48:33 +00001503ClangExpressionDeclMap::DumpMaterializedStruct
1504(
Greg Clayton7b462cc2010-10-15 22:48:33 +00001505 Stream &s,
1506 Error &err
1507)
Sean Callanan289e07b2010-07-23 22:19:18 +00001508{
Sean Callanan979f74d2010-12-03 01:38:59 +00001509 assert (m_struct_vars.get());
1510 assert (m_material_vars.get());
1511
1512 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan289e07b2010-07-23 22:19:18 +00001513 {
1514 err.SetErrorString("Structure hasn't been laid out yet");
1515 return false;
1516 }
Sean Callanan933693b2012-02-10 01:22:05 +00001517 Process *process = m_parser_vars->m_exe_ctx.GetProcessPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001518
1519 if (!process)
Sean Callanan289e07b2010-07-23 22:19:18 +00001520 {
1521 err.SetErrorString("Couldn't find the process");
1522 return false;
1523 }
1524
Sean Callanan933693b2012-02-10 01:22:05 +00001525 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001526 if (!target)
Sean Callanan289e07b2010-07-23 22:19:18 +00001527 {
1528 err.SetErrorString("Couldn't find the target");
1529 return false;
1530 }
1531
Sean Callananc673a6e2010-12-07 10:00:20 +00001532 if (!m_material_vars->m_materialized_location)
1533 {
1534 err.SetErrorString("No materialized location");
1535 return false;
1536 }
1537
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001538 lldb::DataBufferSP data_sp(new DataBufferHeap(m_struct_vars->m_struct_size, 0));
Sean Callanan289e07b2010-07-23 22:19:18 +00001539
1540 Error error;
Greg Claytonc14ee322011-09-22 04:58:26 +00001541 if (process->ReadMemory (m_material_vars->m_materialized_location,
Greg Claytonf3ef3d22011-05-22 22:46:53 +00001542 data_sp->GetBytes(),
1543 data_sp->GetByteSize(), error) != data_sp->GetByteSize())
Sean Callanan289e07b2010-07-23 22:19:18 +00001544 {
1545 err.SetErrorStringWithFormat ("Couldn't read struct from the target: %s", error.AsCString());
1546 return false;
1547 }
1548
Greg Claytonc14ee322011-09-22 04:58:26 +00001549 DataExtractor extractor(data_sp, process->GetByteOrder(), target->GetArchitecture().GetAddressByteSize());
Sean Callanan289e07b2010-07-23 22:19:18 +00001550
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001551 for (size_t member_idx = 0, num_members = m_struct_members.GetSize();
1552 member_idx < num_members;
1553 ++member_idx)
Sean Callanan289e07b2010-07-23 22:19:18 +00001554 {
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001555 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_idx));
Sean Callanan289e07b2010-07-23 22:19:18 +00001556
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001557 if (!member_sp)
1558 return false;
1559
1560 s.Printf("[%s]\n", member_sp->GetName().GetCString());
Sean Callanan64dfc9a2010-08-23 23:09:38 +00001561
Sean Callanan3c495c12013-01-15 23:29:36 +00001562 ClangExpressionVariable::JITVars *jit_vars = member_sp->GetJITVars(GetParserID());
1563
1564 if (!jit_vars)
Sean Callanan64dfc9a2010-08-23 23:09:38 +00001565 return false;
1566
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001567 extractor.Dump (&s, // stream
Sean Callanan3c495c12013-01-15 23:29:36 +00001568 jit_vars->m_offset, // offset
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001569 lldb::eFormatBytesWithASCII, // format
1570 1, // byte size of individual entries
Sean Callanan3c495c12013-01-15 23:29:36 +00001571 jit_vars->m_size, // number of entries
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001572 16, // entries per line
Sean Callanan3c495c12013-01-15 23:29:36 +00001573 m_material_vars->m_materialized_location + jit_vars->m_offset, // address to print
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001574 0, // bit size (bitfields only; 0 means ignore)
1575 0); // bit alignment (bitfields only; 0 means ignore)
Sean Callanan289e07b2010-07-23 22:19:18 +00001576
1577 s.PutChar('\n');
1578 }
1579
1580 return true;
1581}
1582
Sean Callanan1d180662010-07-20 23:31:16 +00001583bool
Greg Clayton7b462cc2010-10-15 22:48:33 +00001584ClangExpressionDeclMap::DoMaterialize
1585(
1586 bool dematerialize,
Sean Callanan14b1bae2013-04-16 23:25:35 +00001587 IRMemoryMap &map,
Sean Callanane359d9b2011-05-09 22:04:36 +00001588 lldb::addr_t stack_frame_top,
1589 lldb::addr_t stack_frame_bottom,
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001590 lldb::ClangExpressionVariableSP *result_sp_ptr,
Greg Clayton7b462cc2010-10-15 22:48:33 +00001591 Error &err
1592)
Sean Callananea22d422010-07-16 00:09:46 +00001593{
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001594 if (result_sp_ptr)
1595 result_sp_ptr->reset();
1596
Sean Callanan979f74d2010-12-03 01:38:59 +00001597 assert (m_struct_vars.get());
1598
Greg Clayton5160ce52013-03-27 23:08:40 +00001599 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanand1e5b432010-08-12 01:56:52 +00001600
Sean Callanan979f74d2010-12-03 01:38:59 +00001601 if (!m_struct_vars->m_struct_laid_out)
Sean Callananea22d422010-07-16 00:09:46 +00001602 {
1603 err.SetErrorString("Structure hasn't been laid out yet");
Greg Claytoncce86712011-09-13 04:03:52 +00001604 return false;
Sean Callananea22d422010-07-16 00:09:46 +00001605 }
1606
Sean Callanan933693b2012-02-10 01:22:05 +00001607 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001608 if (!frame)
Sean Callananddb46ef2010-07-24 01:37:44 +00001609 {
1610 err.SetErrorString("Received null execution frame");
Greg Claytoncce86712011-09-13 04:03:52 +00001611 return false;
Sean Callananddb46ef2010-07-24 01:37:44 +00001612 }
Sean Callanan933693b2012-02-10 01:22:05 +00001613 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Sean Callananddb46ef2010-07-24 01:37:44 +00001614
Greg Claytonc14ee322011-09-22 04:58:26 +00001615 ClangPersistentVariables &persistent_vars = target->GetPersistentVariables();
Sean Callanan979f74d2010-12-03 01:38:59 +00001616
1617 if (!m_struct_vars->m_struct_size)
Sean Callanan9e6ed532010-09-13 21:34:21 +00001618 {
1619 if (log)
1620 log->PutCString("Not bothering to allocate a struct because no arguments are needed");
1621
Filipe Cabecinhasd0b87d82012-09-11 18:11:16 +00001622 m_material_vars->m_allocated_area = 0UL;
Sean Callanan9e6ed532010-09-13 21:34:21 +00001623
1624 return true;
1625 }
1626
Sean Callanan14b1bae2013-04-16 23:25:35 +00001627 if (!m_parser_vars->m_materializer)
Sean Callananea22d422010-07-16 00:09:46 +00001628 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001629 err.SetErrorString("No materializer");
Sean Callanan1d180662010-07-20 23:31:16 +00001630
Sean Callanand0ef0ef2010-08-20 01:02:30 +00001631 return false;
Sean Callanan00f43622011-11-18 03:28:09 +00001632 }
Sean Callanand0ef0ef2010-08-20 01:02:30 +00001633
Sean Callanan14b1bae2013-04-16 23:25:35 +00001634 lldb::StackFrameSP frame_sp = frame->shared_from_this();
1635 ClangExpressionVariableSP result_sp;
Sean Callanan92adcac2011-01-13 08:53:35 +00001636
Sean Callanan2235f322010-08-11 03:57:18 +00001637 if (dematerialize)
1638 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001639 Error dematerialize_error;
Sean Callanan92adcac2011-01-13 08:53:35 +00001640
Sean Callanan14b1bae2013-04-16 23:25:35 +00001641 bool ret = true;
1642
Sean Callanan1582ee62013-04-18 22:06:33 +00001643 ClangExpressionVariableSP result;
1644
1645 m_material_vars->m_dematerializer_sp->Dematerialize(dematerialize_error, result, stack_frame_top, stack_frame_bottom);
Sean Callanan14b1bae2013-04-16 23:25:35 +00001646 m_material_vars->m_dematerializer_sp.reset();
1647
1648 if (!dematerialize_error.Success())
Sean Callanan2235f322010-08-11 03:57:18 +00001649 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001650 err.SetErrorStringWithFormat("Couldn't dematerialize: %s", dematerialize_error.AsCString());
1651 ret = false;
Sean Callanan92adcac2011-01-13 08:53:35 +00001652 }
1653 else
1654 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001655 Error free_error;
1656 map.Free(m_material_vars->m_materialized_location, free_error);
1657 if (!free_error.Success())
Sean Callanan92adcac2011-01-13 08:53:35 +00001658 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001659 err.SetErrorStringWithFormat("Couldn't free struct from materialization: %s", free_error.AsCString());
1660 ret = false;
Sean Callanan92adcac2011-01-13 08:53:35 +00001661 }
1662 }
1663
Sean Callanan14b1bae2013-04-16 23:25:35 +00001664 if (ret)
Sean Callanan92adcac2011-01-13 08:53:35 +00001665 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001666 for (uint64_t member_index = 0, num_members = m_struct_members.GetSize();
1667 member_index < num_members;
1668 ++member_index)
Sean Callanan92adcac2011-01-13 08:53:35 +00001669 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001670 ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
1671
1672 if (!m_found_entities.ContainsVariable (member_sp))
1673 {
1674 // No need to look for presistent variables if the name doesn't start
1675 // with with a '$' character...
1676 if (member_sp->GetName().AsCString ("!")[0] == '$' && persistent_vars.ContainsVariable(member_sp))
1677 {
1678 if (member_sp->GetName() == m_struct_vars->m_result_name)
1679 {
1680 if (log)
1681 log->PutCString("Found result member in the struct");
1682
1683 if (result_sp_ptr)
1684 *result_sp_ptr = member_sp;
1685
1686 break;
1687 }
1688 }
1689 }
Sean Callanan92adcac2011-01-13 08:53:35 +00001690 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00001691 }
1692
Sean Callanan14b1bae2013-04-16 23:25:35 +00001693 return ret;
Sean Callanand9ca42a2011-05-08 02:21:26 +00001694 }
1695 else
Sean Callanan1d180662010-07-20 23:31:16 +00001696 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001697 Error malloc_error;
Sean Callanan77502262011-05-12 23:54:16 +00001698
Sean Callanan14b1bae2013-04-16 23:25:35 +00001699 m_material_vars->m_allocated_area = LLDB_INVALID_ADDRESS;
1700 m_material_vars->m_materialized_location = map.Malloc(m_parser_vars->m_materializer->GetStructByteSize(),
1701 m_parser_vars->m_materializer->GetStructAlignment(),
1702 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
1703 IRMemoryMap::eAllocationPolicyMirror,
1704 malloc_error);
Sean Callanan77502262011-05-12 23:54:16 +00001705
Sean Callanan14b1bae2013-04-16 23:25:35 +00001706 if (!malloc_error.Success())
Sean Callanan1d180662010-07-20 23:31:16 +00001707 {
Sean Callanan14b1bae2013-04-16 23:25:35 +00001708 err.SetErrorStringWithFormat("Couldn't malloc struct for materialization: %s", malloc_error.AsCString());
Sean Callananf4b9bd32010-10-05 20:18:48 +00001709
Sean Callanan14b1bae2013-04-16 23:25:35 +00001710 return false;
1711 }
1712
1713 Error materialize_error;
1714
Sean Callanan1582ee62013-04-18 22:06:33 +00001715 m_material_vars->m_dematerializer_sp = m_parser_vars->m_materializer->Materialize(frame_sp, map, m_material_vars->m_materialized_location, materialize_error);
Sean Callanan14b1bae2013-04-16 23:25:35 +00001716
1717 if (!materialize_error.Success())
1718 {
1719 err.SetErrorStringWithFormat("Couldn't materialize: %s", materialize_error.AsCString());
Sean Callananf4b9bd32010-10-05 20:18:48 +00001720
Sean Callanan348b5892010-11-30 00:27:43 +00001721 return false;
1722 }
1723
Sean Callanan14b1bae2013-04-16 23:25:35 +00001724 return true;
Sean Callanan348b5892010-11-30 00:27:43 +00001725 }
Sean Callanan348b5892010-11-30 00:27:43 +00001726}
1727
Sean Callanan63697e52011-05-07 01:06:41 +00001728lldb::VariableSP
Greg Clayton7b462cc2010-10-15 22:48:33 +00001729ClangExpressionDeclMap::FindVariableInScope
1730(
1731 StackFrame &frame,
1732 const ConstString &name,
Sean Callanan5056ab02012-02-18 02:01:03 +00001733 TypeFromUser *type,
Sean Callanan0259e512012-05-21 21:29:52 +00001734 bool object_pointer
Greg Clayton7b462cc2010-10-15 22:48:33 +00001735)
Sean Callanan979f74d2010-12-03 01:38:59 +00001736{
Greg Clayton5160ce52013-03-27 23:08:40 +00001737 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan44096b12010-09-14 21:59:34 +00001738
Sean Callanan69b53412011-08-06 00:28:14 +00001739 ValueObjectSP valobj;
1740 VariableSP var_sp;
1741 Error err;
Sean Callanan44096b12010-09-14 21:59:34 +00001742
Sean Callananaf776172013-02-12 07:56:36 +00001743 valobj = frame.GetValueForVariableExpressionPath(name.GetCString(),
Sean Callanan69b53412011-08-06 00:28:14 +00001744 eNoDynamicValues,
Sean Callananaf776172013-02-12 07:56:36 +00001745 StackFrame::eExpressionPathOptionCheckPtrVsMember ||
1746 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess ||
1747 StackFrame::eExpressionPathOptionsNoFragileObjcIvar ||
1748 StackFrame::eExpressionPathOptionsNoSyntheticChildren ||
1749 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
Sean Callanan69b53412011-08-06 00:28:14 +00001750 var_sp,
1751 err);
Greg Clayton83c5cd92010-11-14 22:13:40 +00001752
Sean Callanan69b53412011-08-06 00:28:14 +00001753 if (!err.Success() ||
1754 !var_sp ||
Sean Callananc6466fc2011-07-07 23:05:43 +00001755 !var_sp->IsInScope(&frame) ||
1756 !var_sp->LocationIsValidForFrame (&frame))
1757 return lldb::VariableSP();
Greg Clayton83c5cd92010-11-14 22:13:40 +00001758
Sean Callanan3e606ea2012-05-21 22:25:52 +00001759 if (var_sp)
Greg Clayton83c5cd92010-11-14 22:13:40 +00001760 {
Sean Callanan3e606ea2012-05-21 22:25:52 +00001761 if (!type)
1762 return var_sp;
1763
Sean Callanan0259e512012-05-21 21:29:52 +00001764 TypeFromUser candidate_type(var_sp->GetType()->GetClangFullType(),
1765 var_sp->GetType()->GetClangAST());
1766
1767 if (candidate_type.GetASTContext() != type->GetASTContext())
Greg Clayton83c5cd92010-11-14 22:13:40 +00001768 {
1769 if (log)
1770 log->PutCString("Skipping a candidate variable because of different AST contexts");
Sean Callanan63697e52011-05-07 01:06:41 +00001771 return lldb::VariableSP();
Greg Clayton83c5cd92010-11-14 22:13:40 +00001772 }
Sean Callanan0259e512012-05-21 21:29:52 +00001773
1774 if (object_pointer)
1775 {
1776 clang::QualType desired_qual_type = clang::QualType::getFromOpaquePtr(type->GetOpaqueQualType());
1777 clang::QualType candidate_qual_type = clang::QualType::getFromOpaquePtr(candidate_type.GetOpaqueQualType());
1778
Sean Callanan3e606ea2012-05-21 22:25:52 +00001779 const clang::ObjCObjectPointerType *desired_objc_ptr_type = desired_qual_type->getAs<clang::ObjCObjectPointerType>();
1780 const clang::ObjCObjectPointerType *candidate_objc_ptr_type = desired_qual_type->getAs<clang::ObjCObjectPointerType>();
1781
1782 if (desired_objc_ptr_type && candidate_objc_ptr_type) {
1783 clang::QualType desired_target_type = desired_objc_ptr_type->getPointeeType().getUnqualifiedType();
1784 clang::QualType candidate_target_type = candidate_objc_ptr_type->getPointeeType().getUnqualifiedType();
1785
1786 if (ClangASTContext::AreTypesSame(type->GetASTContext(),
1787 desired_target_type.getAsOpaquePtr(),
1788 candidate_target_type.getAsOpaquePtr()))
1789 return var_sp;
1790 }
1791
Sean Callanan0259e512012-05-21 21:29:52 +00001792 const clang::PointerType *desired_ptr_type = desired_qual_type->getAs<clang::PointerType>();
1793 const clang::PointerType *candidate_ptr_type = candidate_qual_type->getAs<clang::PointerType>();
1794
Sean Callanan3e606ea2012-05-21 22:25:52 +00001795 if (desired_ptr_type && candidate_ptr_type) {
1796 clang::QualType desired_target_type = desired_ptr_type->getPointeeType().getUnqualifiedType();
1797 clang::QualType candidate_target_type = candidate_ptr_type->getPointeeType().getUnqualifiedType();
1798
1799 if (ClangASTContext::AreTypesSame(type->GetASTContext(),
1800 desired_target_type.getAsOpaquePtr(),
1801 candidate_target_type.getAsOpaquePtr()))
1802 return var_sp;
1803 }
Sean Callanan0259e512012-05-21 21:29:52 +00001804
Sean Callanan3e606ea2012-05-21 22:25:52 +00001805 return lldb::VariableSP();
Sean Callanan0259e512012-05-21 21:29:52 +00001806 }
1807 else
1808 {
Sean Callanan3e606ea2012-05-21 22:25:52 +00001809 if (ClangASTContext::AreTypesSame(type->GetASTContext(),
Sean Callanan0259e512012-05-21 21:29:52 +00001810 type->GetOpaqueQualType(),
1811 var_sp->GetType()->GetClangFullType()))
Sean Callanan3e606ea2012-05-21 22:25:52 +00001812 return var_sp;
Sean Callanan0259e512012-05-21 21:29:52 +00001813 }
Sean Callanan44096b12010-09-14 21:59:34 +00001814 }
Greg Clayton83c5cd92010-11-14 22:13:40 +00001815
Sean Callanan3e606ea2012-05-21 22:25:52 +00001816 return lldb::VariableSP();
Sean Callanan44096b12010-09-14 21:59:34 +00001817}
Sean Callanan6b4067c2010-07-17 00:43:37 +00001818
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001819const Symbol *
1820ClangExpressionDeclMap::FindGlobalDataSymbol (Target &target,
1821 const ConstString &name)
Sean Callanand9ca42a2011-05-08 02:21:26 +00001822{
1823 SymbolContextList sc_list;
1824
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001825 target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
Sean Callanand9ca42a2011-05-08 02:21:26 +00001826
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001827 const uint32_t matches = sc_list.GetSize();
1828 for (uint32_t i=0; i<matches; ++i)
Sean Callanand9ca42a2011-05-08 02:21:26 +00001829 {
1830 SymbolContext sym_ctx;
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001831 sc_list.GetContextAtIndex(i, sym_ctx);
1832 if (sym_ctx.symbol)
1833 {
1834 const Symbol *symbol = sym_ctx.symbol;
1835 const Address *sym_address = &symbol->GetAddress();
1836
1837 if (sym_address && sym_address->IsValid())
1838 {
1839 switch (symbol->GetType())
1840 {
1841 case eSymbolTypeData:
1842 case eSymbolTypeRuntime:
1843 case eSymbolTypeAbsolute:
1844 case eSymbolTypeObjCClass:
1845 case eSymbolTypeObjCMetaClass:
1846 case eSymbolTypeObjCIVar:
1847 if (symbol->GetDemangledNameIsSynthesized())
1848 {
1849 // If the demangled name was synthesized, then don't use it
1850 // for expressions. Only let the symbol match if the mangled
1851 // named matches for these symbols.
1852 if (symbol->GetMangled().GetMangledName() != name)
1853 break;
1854 }
1855 return symbol;
1856
1857 case eSymbolTypeCode: // We already lookup functions elsewhere
1858 case eSymbolTypeVariable:
1859 case eSymbolTypeLocal:
1860 case eSymbolTypeParam:
1861 case eSymbolTypeTrampoline:
1862 case eSymbolTypeInvalid:
1863 case eSymbolTypeException:
1864 case eSymbolTypeSourceFile:
1865 case eSymbolTypeHeaderFile:
1866 case eSymbolTypeObjectFile:
1867 case eSymbolTypeCommonBlock:
1868 case eSymbolTypeBlock:
1869 case eSymbolTypeVariableType:
1870 case eSymbolTypeLineEntry:
1871 case eSymbolTypeLineHeader:
1872 case eSymbolTypeScopeBegin:
1873 case eSymbolTypeScopeEnd:
1874 case eSymbolTypeAdditional:
1875 case eSymbolTypeCompiler:
1876 case eSymbolTypeInstrumentation:
1877 case eSymbolTypeUndefined:
Matt Kopec00049b82013-02-27 20:13:38 +00001878 case eSymbolTypeResolver:
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001879 break;
1880 }
1881 }
1882 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00001883 }
1884
1885 return NULL;
1886}
1887
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001888lldb::VariableSP
1889ClangExpressionDeclMap::FindGlobalVariable
1890(
1891 Target &target,
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00001892 ModuleSP &module,
1893 const ConstString &name,
1894 ClangNamespaceDecl *namespace_decl,
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001895 TypeFromUser *type
1896)
1897{
1898 VariableList vars;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001899
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00001900 if (module && namespace_decl)
1901 module->FindGlobalVariables (name, namespace_decl, true, -1, vars);
1902 else
1903 target.GetImages().FindGlobalVariables(name, true, -1, vars);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001904
1905 if (vars.GetSize())
1906 {
1907 if (type)
1908 {
1909 for (size_t i = 0; i < vars.GetSize(); ++i)
1910 {
1911 VariableSP var_sp = vars.GetVariableAtIndex(i);
1912
1913 if (type->GetASTContext() == var_sp->GetType()->GetClangAST())
1914 {
1915 if (ClangASTContext::AreTypesSame(type->GetASTContext(), type->GetOpaqueQualType(), var_sp->GetType()->GetClangFullType()))
1916 return var_sp;
1917 }
1918 }
1919 }
1920 else
1921 {
1922 return vars.GetVariableAtIndex(0);
1923 }
1924 }
1925
1926 return VariableSP();
1927}
1928
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001929// Interface for ClangASTSource
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001930
Sean Callanan503aa522011-10-12 00:12:34 +00001931void
Sean Callananeddeb3b2011-10-28 23:38:38 +00001932ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001933{
Sean Callananeddeb3b2011-10-28 23:38:38 +00001934 assert (m_ast_context);
1935
Sean Callanan8106d802013-03-08 20:04:57 +00001936 ClangASTMetrics::RegisterVisibleQuery();
1937
Sean Callananeddeb3b2011-10-28 23:38:38 +00001938 const ConstString name(context.m_decl_name.getAsString().c_str());
1939
Greg Clayton5160ce52013-03-27 23:08:40 +00001940 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001941
Sean Callananfb3e4302011-10-29 19:50:43 +00001942 if (GetImportInProgress())
Sean Callanan6abfabf2010-11-19 20:20:02 +00001943 {
Sean Callanan7dd98122011-10-14 20:34:21 +00001944 if (log && log->GetVerbose())
Sean Callanan6abfabf2010-11-19 20:20:02 +00001945 log->Printf("Ignoring a query during an import");
1946 return;
1947 }
Greg Claytona2721472011-06-25 00:44:06 +00001948
Sean Callanan7dd98122011-10-14 20:34:21 +00001949 static unsigned int invocation_id = 0;
1950 unsigned int current_id = invocation_id++;
1951
Sean Callanan503aa522011-10-12 00:12:34 +00001952 if (log)
1953 {
1954 if (!context.m_decl_context)
Sean Callananfb3e4302011-10-29 19:50:43 +00001955 log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in a NULL DeclContext", current_id, name.GetCString());
Sean Callanan503aa522011-10-12 00:12:34 +00001956 else if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context.m_decl_context))
Sean Callananfb3e4302011-10-29 19:50:43 +00001957 log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in '%s'", current_id, name.GetCString(), context_named_decl->getNameAsString().c_str());
Sean Callanan503aa522011-10-12 00:12:34 +00001958 else
Sean Callananfb3e4302011-10-29 19:50:43 +00001959 log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in a '%s'", current_id, name.GetCString(), context.m_decl_context->getDeclKindName());
Sean Callanan503aa522011-10-12 00:12:34 +00001960 }
Sean Callananfb3e4302011-10-29 19:50:43 +00001961
Sean Callanan503aa522011-10-12 00:12:34 +00001962 if (const NamespaceDecl *namespace_context = dyn_cast<NamespaceDecl>(context.m_decl_context))
1963 {
Sean Callanan1ee44b72011-10-29 01:58:46 +00001964 ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer->GetNamespaceMap(namespace_context);
Sean Callananc41e68b2011-10-13 21:08:11 +00001965
Sean Callanan7dd98122011-10-14 20:34:21 +00001966 if (log && log->GetVerbose())
Sean Callanan00f43622011-11-18 03:28:09 +00001967 log->Printf(" CEDM::FEVD[%u] Inspecting (NamespaceMap*)%p (%d entries)",
Sean Callanan7dd98122011-10-14 20:34:21 +00001968 current_id,
1969 namespace_map.get(),
1970 (int)namespace_map->size());
Sean Callananc41e68b2011-10-13 21:08:11 +00001971
Sean Callananb2269162011-10-21 22:18:07 +00001972 if (!namespace_map)
1973 return;
1974
Sean Callanan503aa522011-10-12 00:12:34 +00001975 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end();
1976 i != e;
1977 ++i)
1978 {
1979 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00001980 log->Printf(" CEDM::FEVD[%u] Searching namespace %s in module %s",
Sean Callanan7dd98122011-10-14 20:34:21 +00001981 current_id,
Sean Callanan503aa522011-10-12 00:12:34 +00001982 i->second.GetNamespaceDecl()->getNameAsString().c_str(),
1983 i->first->GetFileSpec().GetFilename().GetCString());
1984
Sean Callananebe60672011-10-13 21:50:33 +00001985 FindExternalVisibleDecls(context,
1986 i->first,
1987 i->second,
Sean Callanan7dd98122011-10-14 20:34:21 +00001988 current_id);
Sean Callanan503aa522011-10-12 00:12:34 +00001989 }
1990 }
Sean Callanand5c17ed2011-11-15 02:11:17 +00001991 else if (isa<TranslationUnitDecl>(context.m_decl_context))
Sean Callanan503aa522011-10-12 00:12:34 +00001992 {
1993 ClangNamespaceDecl namespace_decl;
1994
1995 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00001996 log->Printf(" CEDM::FEVD[%u] Searching the root namespace", current_id);
Sean Callanan503aa522011-10-12 00:12:34 +00001997
1998 FindExternalVisibleDecls(context,
1999 lldb::ModuleSP(),
2000 namespace_decl,
Sean Callanan7dd98122011-10-14 20:34:21 +00002001 current_id);
Sean Callanan503aa522011-10-12 00:12:34 +00002002 }
Sean Callananc41e68b2011-10-13 21:08:11 +00002003
Sean Callananfb3e4302011-10-29 19:50:43 +00002004 if (!context.m_found.variable)
2005 ClangASTSource::FindExternalVisibleDecls(context);
Sean Callanan503aa522011-10-12 00:12:34 +00002006}
2007
2008void
2009ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
Sean Callanan1a2c5382011-10-12 18:44:30 +00002010 lldb::ModuleSP module_sp,
Sean Callanan88972242011-10-12 01:39:28 +00002011 ClangNamespaceDecl &namespace_decl,
Sean Callanan7dd98122011-10-14 20:34:21 +00002012 unsigned int current_id)
Sean Callanan503aa522011-10-12 00:12:34 +00002013{
Sean Callananeddeb3b2011-10-28 23:38:38 +00002014 assert (m_ast_context);
Sean Callanan503aa522011-10-12 00:12:34 +00002015
Greg Clayton5160ce52013-03-27 23:08:40 +00002016 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananfb3e4302011-10-29 19:50:43 +00002017
Greg Clayton7a345282010-11-09 23:46:37 +00002018 SymbolContextList sc_list;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002019
Sean Callananfb3e4302011-10-29 19:50:43 +00002020 const ConstString name(context.m_decl_name.getAsString().c_str());
2021
Greg Clayton83c5cd92010-11-14 22:13:40 +00002022 const char *name_unique_cstr = name.GetCString();
2023
2024 if (name_unique_cstr == NULL)
2025 return;
Sean Callananfb3e4302011-10-29 19:50:43 +00002026
Sean Callanan5b26f272012-02-04 08:49:35 +00002027 static ConstString id_name("id");
2028 static ConstString Class_name("Class");
2029
2030 if (name == id_name || name == Class_name)
2031 return;
2032
Greg Clayton7b462cc2010-10-15 22:48:33 +00002033 // Only look for functions by name out in our symbols if the function
2034 // doesn't start with our phony prefix of '$'
Sean Callanan933693b2012-02-10 01:22:05 +00002035 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
2036 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
Sean Callanan88972242011-10-12 01:39:28 +00002037 if (name_unique_cstr[0] == '$' && !namespace_decl)
2038 {
2039 static ConstString g_lldb_class_name ("$__lldb_class");
2040
2041 if (name == g_lldb_class_name)
2042 {
2043 // Clang is looking for the type of "this"
Sean Callananc03bdd92012-02-08 03:45:08 +00002044
2045 if (frame == NULL)
Sean Callanan88972242011-10-12 01:39:28 +00002046 return;
2047
Sean Callananc03bdd92012-02-08 03:45:08 +00002048 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction);
Sean Callanan88972242011-10-12 01:39:28 +00002049
Sean Callananc03bdd92012-02-08 03:45:08 +00002050 if (!sym_ctx.function)
Sean Callanan88972242011-10-12 01:39:28 +00002051 return;
2052
Greg Clayton685c88c2012-07-14 00:53:55 +00002053 // Get the block that defines the function
2054 Block *function_block = sym_ctx.GetFunctionBlock();
2055
2056 if (!function_block)
2057 return;
2058
2059 clang::DeclContext *decl_context = function_block->GetClangDeclContext();
Sean Callananc03bdd92012-02-08 03:45:08 +00002060
2061 if (!decl_context)
Sean Callanan88972242011-10-12 01:39:28 +00002062 return;
2063
Sean Callananc03bdd92012-02-08 03:45:08 +00002064 clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_context);
Sean Callanan88972242011-10-12 01:39:28 +00002065
Jim Ingham5fdeed42012-10-30 23:35:54 +00002066 if (method_decl)
Sean Callanan88972242011-10-12 01:39:28 +00002067 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00002068 clang::CXXRecordDecl *class_decl = method_decl->getParent();
2069
2070 QualType class_qual_type(class_decl->getTypeForDecl(), 0);
2071
2072 TypeFromUser class_user_type (class_qual_type.getAsOpaquePtr(),
2073 &class_decl->getASTContext());
2074
2075 if (log)
2076 {
2077 ASTDumper ast_dumper(class_qual_type);
2078 log->Printf(" CEDM::FEVD[%u] Adding type for $__lldb_class: %s", current_id, ast_dumper.GetCString());
2079 }
2080
Sean Callananfa4fab72013-02-01 06:55:48 +00002081 TypeFromParser class_type = CopyClassType(class_user_type, current_id);
2082
2083 if (!class_type.IsValid())
2084 return;
2085
Sean Callanan34cf8202013-03-12 21:22:00 +00002086 TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(QualType::getFromOpaquePtr(class_type.GetOpaqueQualType()));
Sean Callananfa4fab72013-02-01 06:55:48 +00002087
2088 if (!type_source_info)
2089 return;
2090
2091 TypedefDecl *typedef_decl = TypedefDecl::Create(*m_ast_context,
2092 m_ast_context->getTranslationUnitDecl(),
2093 SourceLocation(),
2094 SourceLocation(),
2095 context.m_decl_name.getAsIdentifierInfo(),
2096 type_source_info);
2097
2098
2099 if (!typedef_decl)
2100 return;
2101
2102 context.AddNamedDecl(typedef_decl);
Jim Ingham5fdeed42012-10-30 23:35:54 +00002103
2104 if (method_decl->isInstance())
2105 {
2106 // self is a pointer to the object
2107
2108 QualType class_pointer_type = method_decl->getASTContext().getPointerType(class_qual_type);
2109
2110 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
2111 &method_decl->getASTContext());
2112
2113 m_struct_vars->m_object_pointer_type = self_user_type;
2114 }
Sean Callanan88972242011-10-12 01:39:28 +00002115 }
Jim Ingham5fdeed42012-10-30 23:35:54 +00002116 else
Sean Callananbb6e7ed2012-03-05 22:08:20 +00002117 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00002118 // This branch will get hit if we are executing code in the context of a function that
2119 // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
2120 // method of the class. In that case, just look up the "this" variable in the the current
2121 // scope and use its type.
2122 // FIXME: This code is formally correct, but clang doesn't currently emit DW_AT_object_pointer
2123 // for C++ so it hasn't actually been tested.
Sean Callananbb6e7ed2012-03-05 22:08:20 +00002124
Jim Ingham5fdeed42012-10-30 23:35:54 +00002125 VariableList *vars = frame->GetVariableList(false);
Sean Callananbb6e7ed2012-03-05 22:08:20 +00002126
Jim Ingham5fdeed42012-10-30 23:35:54 +00002127 lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
Sean Callananbb6e7ed2012-03-05 22:08:20 +00002128
Jim Ingham5fdeed42012-10-30 23:35:54 +00002129 if (this_var &&
2130 this_var->IsInScope(frame) &&
2131 this_var->LocationIsValidForFrame (frame))
2132 {
2133 Type *this_type = this_var->GetType();
2134
2135 if (!this_type)
2136 return;
2137
2138 QualType this_qual_type = QualType::getFromOpaquePtr(this_type->GetClangFullType());
2139 const PointerType *class_pointer_type = this_qual_type->getAs<PointerType>();
2140
2141 if (class_pointer_type)
2142 {
2143 QualType class_type = class_pointer_type->getPointeeType();
2144
2145 if (log)
2146 {
2147 ASTDumper ast_dumper(this_type->GetClangFullType());
2148 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
2149 }
2150
2151 TypeFromUser class_user_type (class_type.getAsOpaquePtr(),
2152 this_type->GetClangAST());
Sean Callananfa4fab72013-02-01 06:55:48 +00002153 AddOneType(context, class_user_type, current_id);
Jim Ingham5fdeed42012-10-30 23:35:54 +00002154
2155
2156 TypeFromUser this_user_type(this_type->GetClangFullType(),
2157 this_type->GetClangAST());
2158
2159 m_struct_vars->m_object_pointer_type = this_user_type;
2160 return;
2161 }
2162 }
Sean Callananbb6e7ed2012-03-05 22:08:20 +00002163 }
2164
Sean Callanan88972242011-10-12 01:39:28 +00002165 return;
2166 }
2167
2168 static ConstString g_lldb_objc_class_name ("$__lldb_objc_class");
2169 if (name == g_lldb_objc_class_name)
2170 {
2171 // Clang is looking for the type of "*self"
2172
2173 if (!frame)
2174 return;
Sean Callanand5c17ed2011-11-15 02:11:17 +00002175
2176 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction);
2177
2178 if (!sym_ctx.function)
2179 return;
2180
Greg Clayton685c88c2012-07-14 00:53:55 +00002181 // Get the block that defines the function
2182 Block *function_block = sym_ctx.GetFunctionBlock();
Sean Callanand5c17ed2011-11-15 02:11:17 +00002183
Greg Clayton685c88c2012-07-14 00:53:55 +00002184 if (!function_block)
2185 return;
2186
2187 clang::DeclContext *decl_context = function_block->GetClangDeclContext();
Sean Callanand5c17ed2011-11-15 02:11:17 +00002188
2189 if (!decl_context)
2190 return;
2191
2192 clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_context);
2193
Jim Ingham5fdeed42012-10-30 23:35:54 +00002194 if (method_decl)
Sean Callanand5c17ed2011-11-15 02:11:17 +00002195 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00002196 ObjCInterfaceDecl* self_interface = method_decl->getClassInterface();
Sean Callanand5c17ed2011-11-15 02:11:17 +00002197
Jim Ingham5fdeed42012-10-30 23:35:54 +00002198 if (!self_interface)
Sean Callananc03bdd92012-02-08 03:45:08 +00002199 return;
2200
Jim Ingham5fdeed42012-10-30 23:35:54 +00002201 const clang::Type *interface_type = self_interface->getTypeForDecl();
Sean Callanandfb87d62013-04-09 21:30:48 +00002202
2203 if (!interface_type)
2204 return; // This is unlikely, but we have seen crashes where this occurred
Jim Ingham5fdeed42012-10-30 23:35:54 +00002205
2206 TypeFromUser class_user_type(QualType(interface_type, 0).getAsOpaquePtr(),
2207 &method_decl->getASTContext());
Sean Callananc03bdd92012-02-08 03:45:08 +00002208
Jim Ingham5fdeed42012-10-30 23:35:54 +00002209 if (log)
2210 {
2211 ASTDumper ast_dumper(interface_type);
2212 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
2213 }
2214
Sean Callananfa4fab72013-02-01 06:55:48 +00002215 AddOneType(context, class_user_type, current_id);
Jim Ingham5fdeed42012-10-30 23:35:54 +00002216
2217 if (method_decl->isInstanceMethod())
2218 {
2219 // self is a pointer to the object
2220
2221 QualType class_pointer_type = method_decl->getASTContext().getObjCObjectPointerType(QualType(interface_type, 0));
2222
2223 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
2224 &method_decl->getASTContext());
2225
2226 m_struct_vars->m_object_pointer_type = self_user_type;
2227 }
2228 else
2229 {
2230 // self is a Class pointer
2231 QualType class_type = method_decl->getASTContext().getObjCClassType();
2232
2233 TypeFromUser self_user_type(class_type.getAsOpaquePtr(),
2234 &method_decl->getASTContext());
2235
2236 m_struct_vars->m_object_pointer_type = self_user_type;
2237 }
2238
2239 return;
Sean Callananc03bdd92012-02-08 03:45:08 +00002240 }
2241 else
2242 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00002243 // This branch will get hit if we are executing code in the context of a function that
2244 // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
2245 // method of the class. In that case, just look up the "self" variable in the the current
2246 // scope and use its type.
Sean Callananc03bdd92012-02-08 03:45:08 +00002247
Jim Ingham5fdeed42012-10-30 23:35:54 +00002248 VariableList *vars = frame->GetVariableList(false);
Sean Callananc03bdd92012-02-08 03:45:08 +00002249
Jim Ingham5fdeed42012-10-30 23:35:54 +00002250 lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
2251
2252 if (self_var &&
2253 self_var->IsInScope(frame) &&
2254 self_var->LocationIsValidForFrame (frame))
2255 {
2256 Type *self_type = self_var->GetType();
2257
2258 if (!self_type)
2259 return;
2260
2261 QualType self_qual_type = QualType::getFromOpaquePtr(self_type->GetClangFullType());
Jim Ingham5fdeed42012-10-30 23:35:54 +00002262
Sean Callanana2868d42013-01-19 01:49:02 +00002263 if (self_qual_type->isObjCClassType())
Jim Ingham5fdeed42012-10-30 23:35:54 +00002264 {
Sean Callanana2868d42013-01-19 01:49:02 +00002265 return;
2266 }
2267 else if (self_qual_type->isObjCObjectPointerType())
2268 {
2269 const ObjCObjectPointerType *class_pointer_type = self_qual_type->getAs<ObjCObjectPointerType>();
2270
Jim Ingham5fdeed42012-10-30 23:35:54 +00002271 QualType class_type = class_pointer_type->getPointeeType();
2272
2273 if (log)
2274 {
2275 ASTDumper ast_dumper(self_type->GetClangFullType());
2276 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
2277 }
2278
2279 TypeFromUser class_user_type (class_type.getAsOpaquePtr(),
Sean Callanana2868d42013-01-19 01:49:02 +00002280 self_type->GetClangAST());
2281
Sean Callananfa4fab72013-02-01 06:55:48 +00002282 AddOneType(context, class_user_type, current_id);
Jim Ingham5fdeed42012-10-30 23:35:54 +00002283
Jim Ingham5fdeed42012-10-30 23:35:54 +00002284 TypeFromUser self_user_type(self_type->GetClangFullType(),
2285 self_type->GetClangAST());
2286
2287 m_struct_vars->m_object_pointer_type = self_user_type;
2288 return;
2289 }
2290 }
Sean Callananc03bdd92012-02-08 03:45:08 +00002291 }
2292
Sean Callanan88972242011-10-12 01:39:28 +00002293 return;
2294 }
2295
2296 // any other $__lldb names should be weeded out now
2297 if (!::strncmp(name_unique_cstr, "$__lldb", sizeof("$__lldb") - 1))
2298 return;
2299
2300 do
2301 {
2302 if (!target)
2303 break;
2304
2305 ClangASTContext *scratch_clang_ast_context = target->GetScratchClangASTContext();
2306
2307 if (!scratch_clang_ast_context)
2308 break;
2309
2310 ASTContext *scratch_ast_context = scratch_clang_ast_context->getASTContext();
2311
2312 if (!scratch_ast_context)
2313 break;
2314
2315 TypeDecl *ptype_type_decl = m_parser_vars->m_persistent_vars->GetPersistentType(name);
2316
2317 if (!ptype_type_decl)
2318 break;
2319
Sean Callanan0eed0d42011-12-06 03:41:14 +00002320 Decl *parser_ptype_decl = m_ast_importer->CopyDecl(m_ast_context, scratch_ast_context, ptype_type_decl);
Sean Callanan88972242011-10-12 01:39:28 +00002321
2322 if (!parser_ptype_decl)
2323 break;
2324
2325 TypeDecl *parser_ptype_type_decl = dyn_cast<TypeDecl>(parser_ptype_decl);
2326
2327 if (!parser_ptype_type_decl)
2328 break;
2329
2330 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00002331 log->Printf(" CEDM::FEVD[%u] Found persistent type %s", current_id, name.GetCString());
Sean Callanan88972242011-10-12 01:39:28 +00002332
2333 context.AddNamedDecl(parser_ptype_type_decl);
2334 } while (0);
2335
2336 ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
2337
2338 if (pvar_sp)
2339 {
Sean Callanan7dd98122011-10-14 20:34:21 +00002340 AddOneVariable(context, pvar_sp, current_id);
Sean Callanan88972242011-10-12 01:39:28 +00002341 return;
2342 }
2343
2344 const char *reg_name(&name.GetCString()[1]);
2345
Sean Callanan933693b2012-02-10 01:22:05 +00002346 if (m_parser_vars->m_exe_ctx.GetRegisterContext())
Sean Callanan88972242011-10-12 01:39:28 +00002347 {
Sean Callanan933693b2012-02-10 01:22:05 +00002348 const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(reg_name));
Sean Callananfb3e4302011-10-29 19:50:43 +00002349
Sean Callanan88972242011-10-12 01:39:28 +00002350 if (reg_info)
Sean Callanan35c7f982011-10-18 16:46:55 +00002351 {
2352 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00002353 log->Printf(" CEDM::FEVD[%u] Found register %s", current_id, reg_info->name);
Sean Callanan35c7f982011-10-18 16:46:55 +00002354
Sean Callanan7dd98122011-10-14 20:34:21 +00002355 AddOneRegister(context, reg_info, current_id);
Sean Callanan35c7f982011-10-18 16:46:55 +00002356 }
Sean Callanan88972242011-10-12 01:39:28 +00002357 }
2358 }
2359 else
Sean Callanan8ade1042010-07-27 00:55:47 +00002360 {
Sean Callanan69b53412011-08-06 00:28:14 +00002361 ValueObjectSP valobj;
2362 VariableSP var;
2363 Error err;
2364
Sean Callanan88972242011-10-12 01:39:28 +00002365 if (frame && !namespace_decl)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002366 {
Greg Claytonc14ee322011-09-22 04:58:26 +00002367 valobj = frame->GetValueForVariableExpressionPath(name_unique_cstr,
Sean Callanan503aa522011-10-12 00:12:34 +00002368 eNoDynamicValues,
Sean Callananaf776172013-02-12 07:56:36 +00002369 StackFrame::eExpressionPathOptionCheckPtrVsMember ||
2370 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess ||
2371 StackFrame::eExpressionPathOptionsNoFragileObjcIvar ||
2372 StackFrame::eExpressionPathOptionsNoSyntheticChildren ||
2373 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
Sean Callanan503aa522011-10-12 00:12:34 +00002374 var,
2375 err);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002376
2377 // If we found a variable in scope, no need to pull up function names
Sean Callanan9a028512012-08-09 00:50:26 +00002378 if (err.Success() && var)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002379 {
Sean Callanan0712f462011-11-29 22:03:21 +00002380 AddOneVariable(context, var, valobj, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002381 context.m_found.variable = true;
Sean Callananefa7d1f2011-10-25 20:36:57 +00002382 return;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002383 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00002384 }
Sean Callananfd1ba912011-12-10 04:03:38 +00002385
2386 if (target)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002387 {
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00002388 var = FindGlobalVariable (*target,
Sean Callanan1a2c5382011-10-12 18:44:30 +00002389 module_sp,
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00002390 name,
2391 &namespace_decl,
Greg Claytonc14ee322011-09-22 04:58:26 +00002392 NULL);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002393
2394 if (var)
2395 {
Sean Callanan9b3569b2011-12-10 03:12:34 +00002396 valobj = ValueObjectVariable::Create(target, var);
Sean Callanan0712f462011-11-29 22:03:21 +00002397 AddOneVariable(context, var, valobj, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002398 context.m_found.variable = true;
Sean Callananfd1ba912011-12-10 04:03:38 +00002399 return;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002400 }
2401 }
2402
Sean Callananca4e0fd2011-10-12 20:29:25 +00002403 if (!context.m_found.variable)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002404 {
Sean Callanan9df05fb2012-02-10 22:52:19 +00002405 const bool include_inlines = false;
Greg Clayton931180e2011-01-27 06:44:37 +00002406 const bool append = false;
Sean Callanan25ea08e2011-10-12 17:38:09 +00002407
Sean Callanan1a2c5382011-10-12 18:44:30 +00002408 if (namespace_decl && module_sp)
Sean Callanan25ea08e2011-10-12 17:38:09 +00002409 {
Sean Callanan3ae61792012-02-15 17:14:49 +00002410 const bool include_symbols = false;
2411
Sean Callanan1a2c5382011-10-12 18:44:30 +00002412 module_sp->FindFunctions(name,
2413 &namespace_decl,
2414 eFunctionNameTypeBase,
2415 include_symbols,
Sean Callanan9df05fb2012-02-10 22:52:19 +00002416 include_inlines,
Sean Callanan1a2c5382011-10-12 18:44:30 +00002417 append,
2418 sc_list);
Sean Callanan25ea08e2011-10-12 17:38:09 +00002419 }
Jim Ingham28eb5712012-10-12 17:34:26 +00002420 else if (target && !namespace_decl)
Sean Callanan25ea08e2011-10-12 17:38:09 +00002421 {
Sean Callanan3ae61792012-02-15 17:14:49 +00002422 const bool include_symbols = true;
2423
Sean Callanan308a3c52012-07-28 00:21:01 +00002424 // TODO Fix FindFunctions so that it doesn't return
2425 // instance methods for eFunctionNameTypeBase.
2426
Sean Callanan25ea08e2011-10-12 17:38:09 +00002427 target->GetImages().FindFunctions(name,
Greg Clayton43fe2172013-04-03 02:00:15 +00002428 eFunctionNameTypeFull,
Sean Callanan25ea08e2011-10-12 17:38:09 +00002429 include_symbols,
Sean Callanan9df05fb2012-02-10 22:52:19 +00002430 include_inlines,
Sean Callanan25ea08e2011-10-12 17:38:09 +00002431 append,
2432 sc_list);
2433 }
2434
Sean Callanand9ca42a2011-05-08 02:21:26 +00002435 if (sc_list.GetSize())
Greg Clayton7b462cc2010-10-15 22:48:33 +00002436 {
Sean Callanand9ca42a2011-05-08 02:21:26 +00002437 Symbol *generic_symbol = NULL;
2438 Symbol *non_extern_symbol = NULL;
2439
2440 for (uint32_t index = 0, num_indices = sc_list.GetSize();
2441 index < num_indices;
2442 ++index)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002443 {
Sean Callanand9ca42a2011-05-08 02:21:26 +00002444 SymbolContext sym_ctx;
2445 sc_list.GetContextAtIndex(index, sym_ctx);
2446
2447 if (sym_ctx.function)
2448 {
Sean Callanan308a3c52012-07-28 00:21:01 +00002449 clang::DeclContext *decl_ctx = sym_ctx.function->GetClangDeclContext();
2450
2451 // Filter out class/instance methods.
2452 if (dyn_cast<clang::ObjCMethodDecl>(decl_ctx))
2453 continue;
2454 if (dyn_cast<clang::CXXMethodDecl>(decl_ctx))
2455 continue;
2456
Sean Callanand9ca42a2011-05-08 02:21:26 +00002457 // TODO only do this if it's a C function; C++ functions may be
2458 // overloaded
Sean Callananca4e0fd2011-10-12 20:29:25 +00002459 if (!context.m_found.function_with_type_info)
Sean Callanan7dd98122011-10-14 20:34:21 +00002460 AddOneFunction(context, sym_ctx.function, NULL, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002461 context.m_found.function_with_type_info = true;
2462 context.m_found.function = true;
Sean Callanand9ca42a2011-05-08 02:21:26 +00002463 }
2464 else if (sym_ctx.symbol)
2465 {
2466 if (sym_ctx.symbol->IsExternal())
2467 generic_symbol = sym_ctx.symbol;
2468 else
2469 non_extern_symbol = sym_ctx.symbol;
2470 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00002471 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00002472
Sean Callananca4e0fd2011-10-12 20:29:25 +00002473 if (!context.m_found.function_with_type_info)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002474 {
Sean Callanand9ca42a2011-05-08 02:21:26 +00002475 if (generic_symbol)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002476 {
Sean Callanan7dd98122011-10-14 20:34:21 +00002477 AddOneFunction (context, NULL, generic_symbol, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002478 context.m_found.function = true;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002479 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00002480 else if (non_extern_symbol)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002481 {
Sean Callanan7dd98122011-10-14 20:34:21 +00002482 AddOneFunction (context, NULL, non_extern_symbol, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002483 context.m_found.function = true;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002484 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00002485 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00002486 }
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002487
Sean Callanan20a33d52012-03-06 20:53:06 +00002488 if (!context.m_found.variable && !namespace_decl)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002489 {
Sean Callananca4e0fd2011-10-12 20:29:25 +00002490 // We couldn't find a non-symbol variable for this. Now we'll hunt for a generic
Sean Callanand9ca42a2011-05-08 02:21:26 +00002491 // data symbol, and -- if it is found -- treat it as a variable.
2492
Greg Clayton3d51b9f2012-11-27 01:52:16 +00002493 const Symbol *data_symbol = FindGlobalDataSymbol(*target, name);
Sean Callanand9ca42a2011-05-08 02:21:26 +00002494
2495 if (data_symbol)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002496 {
Sean Callanan7dd98122011-10-14 20:34:21 +00002497 AddOneGenericVariable(context, *data_symbol, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00002498 context.m_found.variable = true;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002499 }
Greg Clayton526e5af2010-11-13 03:52:47 +00002500 }
Sean Callanan3883b5a2010-09-07 21:49:41 +00002501 }
Sean Callananfb40b0d2011-10-27 02:06:03 +00002502 }
Sean Callanan6b4067c2010-07-17 00:43:37 +00002503}
Greg Claytona2721472011-06-25 00:44:06 +00002504
Sean Callanan75383bf2012-03-06 21:56:33 +00002505static clang_type_t
2506MaybePromoteToBlockPointerType
2507(
2508 ASTContext *ast_context,
2509 clang_type_t candidate_type
2510)
2511{
2512 if (!candidate_type)
2513 return candidate_type;
2514
2515 QualType candidate_qual_type = QualType::getFromOpaquePtr(candidate_type);
2516
2517 const PointerType *candidate_pointer_type = dyn_cast<PointerType>(candidate_qual_type);
2518
2519 if (!candidate_pointer_type)
2520 return candidate_type;
2521
2522 QualType pointee_qual_type = candidate_pointer_type->getPointeeType();
2523
2524 const RecordType *pointee_record_type = dyn_cast<RecordType>(pointee_qual_type);
2525
2526 if (!pointee_record_type)
2527 return candidate_type;
2528
2529 RecordDecl *pointee_record_decl = pointee_record_type->getDecl();
2530
2531 if (!pointee_record_decl->isRecord())
2532 return candidate_type;
2533
2534 if (!pointee_record_decl->getName().startswith(llvm::StringRef("__block_literal_")))
2535 return candidate_type;
2536
2537 QualType generic_function_type = ast_context->getFunctionNoProtoType(ast_context->UnknownAnyTy);
2538 QualType block_pointer_type = ast_context->getBlockPointerType(generic_function_type);
2539
2540 return block_pointer_type.getAsOpaquePtr();
2541}
2542
Sean Callanan6b4067c2010-07-17 00:43:37 +00002543Value *
Greg Clayton7b462cc2010-10-15 22:48:33 +00002544ClangExpressionDeclMap::GetVariableValue
2545(
Sean Callanan8e5b8b92011-10-13 00:09:20 +00002546 VariableSP &var,
Sean Callanancc427fa2011-07-30 02:42:06 +00002547 ASTContext *parser_ast_context,
Greg Clayton7b462cc2010-10-15 22:48:33 +00002548 TypeFromUser *user_type,
2549 TypeFromParser *parser_type
2550)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002551{
Greg Clayton5160ce52013-03-27 23:08:40 +00002552 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananf06ba8d2010-06-23 00:47:48 +00002553
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002554 Type *var_type = var->GetType();
2555
2556 if (!var_type)
2557 {
Sean Callananea22d422010-07-16 00:09:46 +00002558 if (log)
2559 log->PutCString("Skipped a definition because it has no type");
Sean Callanan6b4067c2010-07-17 00:43:37 +00002560 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002561 }
2562
Greg Claytonf4ecaa52011-02-16 23:00:21 +00002563 clang_type_t var_opaque_type = var_type->GetClangFullType();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002564
2565 if (!var_opaque_type)
2566 {
Sean Callananea22d422010-07-16 00:09:46 +00002567 if (log)
2568 log->PutCString("Skipped a definition because it has no Clang type");
Sean Callanan6b4067c2010-07-17 00:43:37 +00002569 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002570 }
2571
Sean Callanancc427fa2011-07-30 02:42:06 +00002572 ASTContext *ast = var_type->GetClangASTContext().getASTContext();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002573
Greg Clayton6beaaa62011-01-17 03:46:26 +00002574 if (!ast)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002575 {
Sean Callananea22d422010-07-16 00:09:46 +00002576 if (log)
2577 log->PutCString("There is no AST context for the current execution context");
Sean Callanan6b4067c2010-07-17 00:43:37 +00002578 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002579 }
Sean Callanan75383bf2012-03-06 21:56:33 +00002580
Enrico Granata7f3296a2012-03-30 16:58:37 +00002581 // commented out because of <rdar://problem/11024417>
2582 //var_opaque_type = MaybePromoteToBlockPointerType (ast, var_opaque_type);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002583
Sean Callanan6b4067c2010-07-17 00:43:37 +00002584 DWARFExpression &var_location_expr = var->LocationExpression();
2585
Greg Clayton7b0992d2013-04-18 22:45:39 +00002586 std::unique_ptr<Value> var_location(new Value);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002587
Greg Clayton016a95e2010-09-14 02:20:48 +00002588 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
2589
Sean Callanan933693b2012-02-10 01:22:05 +00002590 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00002591
Greg Clayton016a95e2010-09-14 02:20:48 +00002592 if (var_location_expr.IsLocationList())
2593 {
2594 SymbolContext var_sc;
2595 var->CalculateSymbolContext (&var_sc);
Greg Claytonc14ee322011-09-22 04:58:26 +00002596 loclist_base_load_addr = var_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target);
Greg Clayton016a95e2010-09-14 02:20:48 +00002597 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002598 Error err;
2599
Sean Callanan7b5805d2013-01-18 21:20:51 +00002600 if (var->GetLocationIsConstantValueData())
2601 {
2602 DataExtractor const_value_extractor;
2603
2604 if (var_location_expr.GetExpressionData(const_value_extractor))
2605 {
2606 var_location->operator=(Value(const_value_extractor.GetDataStart(), const_value_extractor.GetByteSize()));
2607 var_location->SetValueType(Value::eValueTypeHostAddress);
2608 }
2609 else
2610 {
2611 if (log)
2612 log->Printf("Error evaluating constant variable: %s", err.AsCString());
2613 return NULL;
2614 }
2615 }
2616 else if (!var_location_expr.Evaluate(&m_parser_vars->m_exe_ctx, ast, NULL, NULL, NULL, loclist_base_load_addr, NULL, *var_location.get(), &err))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002617 {
Sean Callananea22d422010-07-16 00:09:46 +00002618 if (log)
2619 log->Printf("Error evaluating location: %s", err.AsCString());
Sean Callanan6b4067c2010-07-17 00:43:37 +00002620 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002621 }
Greg Clayton6beaaa62011-01-17 03:46:26 +00002622
Sean Callanan77eaf442011-07-08 00:39:14 +00002623 void *type_to_use = NULL;
Sean Callanan6b4067c2010-07-17 00:43:37 +00002624
Sean Callanan1d180662010-07-20 23:31:16 +00002625 if (parser_ast_context)
2626 {
Greg Clayton6beaaa62011-01-17 03:46:26 +00002627 type_to_use = GuardedCopyType(parser_ast_context, ast, var_opaque_type);
Sean Callanan1d180662010-07-20 23:31:16 +00002628
Sean Callanana3aa0cf2010-11-20 02:19:29 +00002629 if (!type_to_use)
2630 {
2631 if (log)
2632 log->Printf("Couldn't copy a variable's type into the parser's AST context");
2633
2634 return NULL;
2635 }
2636
Sean Callanan1d180662010-07-20 23:31:16 +00002637 if (parser_type)
2638 *parser_type = TypeFromParser(type_to_use, parser_ast_context);
2639 }
Sean Callanan6b4067c2010-07-17 00:43:37 +00002640 else
2641 type_to_use = var_opaque_type;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002642
2643 if (var_location.get()->GetContextType() == Value::eContextTypeInvalid)
Greg Clayton526e5af2010-11-13 03:52:47 +00002644 var_location.get()->SetContext(Value::eContextTypeClangType, type_to_use);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002645
2646 if (var_location.get()->GetValueType() == Value::eValueTypeFileAddress)
2647 {
2648 SymbolContext var_sc;
2649 var->CalculateSymbolContext(&var_sc);
Sean Callanan6b4067c2010-07-17 00:43:37 +00002650
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002651 if (!var_sc.module_sp)
Sean Callanan6b4067c2010-07-17 00:43:37 +00002652 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002653
2654 ObjectFile *object_file = var_sc.module_sp->GetObjectFile();
2655
2656 if (!object_file)
Sean Callanan6b4067c2010-07-17 00:43:37 +00002657 return NULL;
2658
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002659 Address so_addr(var_location->GetScalar().ULongLong(), object_file->GetSectionList());
2660
Greg Claytonc14ee322011-09-22 04:58:26 +00002661 lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002662
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002663 if (load_addr != LLDB_INVALID_ADDRESS)
2664 {
2665 var_location->GetScalar() = load_addr;
2666 var_location->SetValueType(Value::eValueTypeLoadAddress);
2667 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002668 }
2669
Sean Callanan1d180662010-07-20 23:31:16 +00002670 if (user_type)
Greg Clayton6beaaa62011-01-17 03:46:26 +00002671 *user_type = TypeFromUser(var_opaque_type, ast);
Sean Callanan6b4067c2010-07-17 00:43:37 +00002672
2673 return var_location.release();
2674}
2675
2676void
Sean Callanan0712f462011-11-29 22:03:21 +00002677ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP var, ValueObjectSP valobj, unsigned int current_id)
Sean Callanan6b4067c2010-07-17 00:43:37 +00002678{
Sean Callanan979f74d2010-12-03 01:38:59 +00002679 assert (m_parser_vars.get());
2680
Greg Clayton5160ce52013-03-27 23:08:40 +00002681 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002682
Sean Callanan1d180662010-07-20 23:31:16 +00002683 TypeFromUser ut;
2684 TypeFromParser pt;
Sean Callanan6b4067c2010-07-17 00:43:37 +00002685
Sean Callanan933693b2012-02-10 01:22:05 +00002686 Value *var_location = GetVariableValue (var,
Sean Callananeddeb3b2011-10-28 23:38:38 +00002687 m_ast_context,
Greg Clayton7b462cc2010-10-15 22:48:33 +00002688 &ut,
2689 &pt);
Sean Callanan6b4067c2010-07-17 00:43:37 +00002690
Sean Callanancf128622012-03-15 01:53:17 +00002691 clang::QualType parser_opaque_type = QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
2692
Sean Callanane2d47482012-03-21 17:13:20 +00002693 if (parser_opaque_type.isNull())
2694 return;
2695
Sean Callanancf128622012-03-15 01:53:17 +00002696 if (const clang::Type *parser_type = parser_opaque_type.getTypePtr())
2697 {
2698 if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
2699 CompleteType(tag_type->getDecl());
2700 }
2701
Sean Callanana3aa0cf2010-11-20 02:19:29 +00002702 if (!var_location)
2703 return;
2704
Sean Callanan98298012011-10-27 19:41:13 +00002705 NamedDecl *var_decl;
2706
2707 bool is_reference = ClangASTContext::IsReferenceType(pt.GetOpaqueQualType());
2708
2709 if (is_reference)
2710 var_decl = context.AddVarDecl(pt.GetOpaqueQualType());
2711 else
2712 var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(pt.GetASTContext(), pt.GetOpaqueQualType()));
2713
Greg Clayton7b462cc2010-10-15 22:48:33 +00002714 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002715 ConstString entity_name(decl_name.c_str());
Sean Callanan0712f462011-11-29 22:03:21 +00002716 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (valobj));
2717
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002718 assert (entity.get());
Sean Callanan3c495c12013-01-15 23:29:36 +00002719 entity->EnableParserVars(GetParserID());
2720 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
2721 parser_vars->m_parser_type = pt;
2722 parser_vars->m_named_decl = var_decl;
2723 parser_vars->m_llvm_value = NULL;
2724 parser_vars->m_lldb_value = var_location;
2725 parser_vars->m_lldb_var = var;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002726
Sean Callanan98298012011-10-27 19:41:13 +00002727 if (is_reference)
2728 entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
2729
Sean Callananea22d422010-07-16 00:09:46 +00002730 if (log)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002731 {
Sean Callanan82695d62011-11-07 23:32:52 +00002732 ASTDumper orig_dumper(ut.GetOpaqueQualType());
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002733 ASTDumper ast_dumper(var_decl);
Sean Callanan82695d62011-11-07 23:32:52 +00002734 log->Printf(" CEDM::FEVD[%u] Found variable %s, returned %s (original %s)", current_id, decl_name.c_str(), ast_dumper.GetCString(), orig_dumper.GetCString());
Greg Clayton7b462cc2010-10-15 22:48:33 +00002735 }
Sean Callanan468574b2010-06-22 23:46:24 +00002736}
2737
2738void
Sean Callanan2235f322010-08-11 03:57:18 +00002739ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
Sean Callanan7dd98122011-10-14 20:34:21 +00002740 ClangExpressionVariableSP &pvar_sp,
2741 unsigned int current_id)
Sean Callanan2235f322010-08-11 03:57:18 +00002742{
Greg Clayton5160ce52013-03-27 23:08:40 +00002743 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan823bb4c2010-08-30 22:17:16 +00002744
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002745 TypeFromUser user_type (pvar_sp->GetTypeFromUser());
Sean Callanan2235f322010-08-11 03:57:18 +00002746
Sean Callananeddeb3b2011-10-28 23:38:38 +00002747 TypeFromParser parser_type (GuardedCopyType(m_ast_context,
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002748 user_type.GetASTContext(),
2749 user_type.GetOpaqueQualType()),
Sean Callananeddeb3b2011-10-28 23:38:38 +00002750 m_ast_context);
Sean Callanan2235f322010-08-11 03:57:18 +00002751
Sean Callanane0a64f72011-12-01 21:04:37 +00002752 if (!parser_type.GetOpaqueQualType())
2753 {
2754 if (log)
2755 log->Printf(" CEDM::FEVD[%u] Couldn't import type for pvar %s", current_id, pvar_sp->GetName().GetCString());
2756 return;
2757 }
2758
Sean Callanan92adcac2011-01-13 08:53:35 +00002759 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::CreateLValueReferenceType(parser_type.GetASTContext(), parser_type.GetOpaqueQualType()));
Sean Callanan64dfc9a2010-08-23 23:09:38 +00002760
Sean Callanan3c495c12013-01-15 23:29:36 +00002761 pvar_sp->EnableParserVars(GetParserID());
2762 ClangExpressionVariable::ParserVars *parser_vars = pvar_sp->GetParserVars(GetParserID());
2763 parser_vars->m_parser_type = parser_type;
2764 parser_vars->m_named_decl = var_decl;
2765 parser_vars->m_llvm_value = NULL;
2766 parser_vars->m_lldb_value = NULL;
Sean Callanan823bb4c2010-08-30 22:17:16 +00002767
2768 if (log)
Sean Callanan530782942010-11-01 23:22:47 +00002769 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002770 ASTDumper ast_dumper(var_decl);
Sean Callananfb3e4302011-10-29 19:50:43 +00002771 log->Printf(" CEDM::FEVD[%u] Added pvar %s, returned %s", current_id, pvar_sp->GetName().GetCString(), ast_dumper.GetCString());
Sean Callanan530782942010-11-01 23:22:47 +00002772 }
Sean Callanan2235f322010-08-11 03:57:18 +00002773}
2774
Sean Callanan348b5892010-11-30 00:27:43 +00002775void
Sean Callanand9ca42a2011-05-08 02:21:26 +00002776ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
Greg Clayton3d51b9f2012-11-27 01:52:16 +00002777 const Symbol &symbol,
Sean Callanan7dd98122011-10-14 20:34:21 +00002778 unsigned int current_id)
Sean Callanand9ca42a2011-05-08 02:21:26 +00002779{
2780 assert(m_parser_vars.get());
2781
Greg Clayton5160ce52013-03-27 23:08:40 +00002782 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanand9ca42a2011-05-08 02:21:26 +00002783
Sean Callanan933693b2012-02-10 01:22:05 +00002784 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00002785
2786 if (target == NULL)
2787 return;
2788
2789 ASTContext *scratch_ast_context = target->GetScratchClangASTContext()->getASTContext();
Sean Callanand9ca42a2011-05-08 02:21:26 +00002790
Greg Clayton68510992012-12-14 00:26:21 +00002791 TypeFromUser user_type (ClangASTContext::CreateLValueReferenceType(scratch_ast_context, ClangASTContext::GetVoidPtrType(scratch_ast_context, false)),
Sean Callanand9ca42a2011-05-08 02:21:26 +00002792 scratch_ast_context);
2793
Greg Clayton68510992012-12-14 00:26:21 +00002794 TypeFromParser parser_type (ClangASTContext::CreateLValueReferenceType(m_ast_context, ClangASTContext::GetVoidPtrType(m_ast_context, false)),
Sean Callananeddeb3b2011-10-28 23:38:38 +00002795 m_ast_context);
Sean Callanand9ca42a2011-05-08 02:21:26 +00002796
Sean Callanan77502262011-05-12 23:54:16 +00002797 NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
Sean Callanand9ca42a2011-05-08 02:21:26 +00002798
2799 std::string decl_name(context.m_decl_name.getAsString());
2800 ConstString entity_name(decl_name.c_str());
Sean Callanan933693b2012-02-10 01:22:05 +00002801 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
Sean Callanand9ca42a2011-05-08 02:21:26 +00002802 entity_name,
2803 user_type,
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002804 m_parser_vars->m_target_info.byte_order,
2805 m_parser_vars->m_target_info.address_byte_size));
Sean Callanand9ca42a2011-05-08 02:21:26 +00002806 assert (entity.get());
Sean Callanand9ca42a2011-05-08 02:21:26 +00002807
Greg Clayton7b0992d2013-04-18 22:45:39 +00002808 std::unique_ptr<Value> symbol_location(new Value);
Sean Callanand9ca42a2011-05-08 02:21:26 +00002809
Greg Clayton3d51b9f2012-11-27 01:52:16 +00002810 const Address &symbol_address = symbol.GetAddress();
Greg Claytonc14ee322011-09-22 04:58:26 +00002811 lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
Sean Callanand9ca42a2011-05-08 02:21:26 +00002812
2813 symbol_location->SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
2814 symbol_location->GetScalar() = symbol_load_addr;
2815 symbol_location->SetValueType(Value::eValueTypeLoadAddress);
2816
Sean Callanan3c495c12013-01-15 23:29:36 +00002817 entity->EnableParserVars(GetParserID());
2818 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
2819 parser_vars->m_parser_type = parser_type;
2820 parser_vars->m_named_decl = var_decl;
2821 parser_vars->m_llvm_value = NULL;
2822 parser_vars->m_lldb_value = symbol_location.release();
2823 parser_vars->m_lldb_sym = &symbol;
Sean Callanand9ca42a2011-05-08 02:21:26 +00002824
2825 if (log)
2826 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002827 ASTDumper ast_dumper(var_decl);
Sean Callanand9ca42a2011-05-08 02:21:26 +00002828
Sean Callananfb3e4302011-10-29 19:50:43 +00002829 log->Printf(" CEDM::FEVD[%u] Found variable %s, returned %s", current_id, decl_name.c_str(), ast_dumper.GetCString());
Sean Callanand9ca42a2011-05-08 02:21:26 +00002830 }
2831}
2832
Sean Callanan77502262011-05-12 23:54:16 +00002833bool
2834ClangExpressionDeclMap::ResolveUnknownTypes()
2835{
Greg Clayton5160ce52013-03-27 23:08:40 +00002836 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +00002837 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00002838
2839 ASTContext *scratch_ast_context = target->GetScratchClangASTContext()->getASTContext();
Sean Callanan77502262011-05-12 23:54:16 +00002840
2841 for (size_t index = 0, num_entities = m_found_entities.GetSize();
2842 index < num_entities;
2843 ++index)
2844 {
2845 ClangExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
2846
Sean Callanan3c495c12013-01-15 23:29:36 +00002847 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
2848
Sean Callanan77502262011-05-12 23:54:16 +00002849 if (entity->m_flags & ClangExpressionVariable::EVUnknownType)
2850 {
Sean Callanan3c495c12013-01-15 23:29:36 +00002851 const NamedDecl *named_decl = parser_vars->m_named_decl;
Sean Callanan77502262011-05-12 23:54:16 +00002852 const VarDecl *var_decl = dyn_cast<VarDecl>(named_decl);
2853
2854 if (!var_decl)
2855 {
2856 if (log)
2857 log->Printf("Entity of unknown type does not have a VarDecl");
2858 return false;
2859 }
2860
2861 if (log)
2862 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002863 ASTDumper ast_dumper(const_cast<VarDecl*>(var_decl));
2864 log->Printf("Variable of unknown type now has Decl %s", ast_dumper.GetCString());
Sean Callanan77502262011-05-12 23:54:16 +00002865 }
2866
2867 QualType var_type = var_decl->getType();
2868 TypeFromParser parser_type(var_type.getAsOpaquePtr(), &var_decl->getASTContext());
2869
Sean Callanan00f43622011-11-18 03:28:09 +00002870 lldb::clang_type_t copied_type = m_ast_importer->CopyType(scratch_ast_context, &var_decl->getASTContext(), var_type.getAsOpaquePtr());
Sean Callanan77502262011-05-12 23:54:16 +00002871
Sean Callanane0a64f72011-12-01 21:04:37 +00002872 if (!copied_type)
2873 {
2874 if (log)
2875 log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't import the type for a variable");
2876
Jim Inghamf94e1792012-08-11 00:35:26 +00002877 return (bool) lldb::ClangExpressionVariableSP();
Sean Callanane0a64f72011-12-01 21:04:37 +00002878 }
2879
Sean Callanan77502262011-05-12 23:54:16 +00002880 TypeFromUser user_type(copied_type, scratch_ast_context);
2881
Sean Callanan3c495c12013-01-15 23:29:36 +00002882 parser_vars->m_lldb_value->SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
2883 parser_vars->m_parser_type = parser_type;
Sean Callanan77502262011-05-12 23:54:16 +00002884
2885 entity->SetClangAST(user_type.GetASTContext());
2886 entity->SetClangType(user_type.GetOpaqueQualType());
2887
2888 entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);
2889 }
2890 }
2891
2892 return true;
2893}
2894
Sean Callanand9ca42a2011-05-08 02:21:26 +00002895void
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002896ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
Sean Callanan7dd98122011-10-14 20:34:21 +00002897 const RegisterInfo *reg_info,
2898 unsigned int current_id)
Sean Callanan348b5892010-11-30 00:27:43 +00002899{
Greg Clayton5160ce52013-03-27 23:08:40 +00002900 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan348b5892010-11-30 00:27:43 +00002901
Sean Callananeddeb3b2011-10-28 23:38:38 +00002902 void *ast_type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(m_ast_context,
Sean Callanan348b5892010-11-30 00:27:43 +00002903 reg_info->encoding,
2904 reg_info->byte_size * 8);
2905
2906 if (!ast_type)
2907 {
Johnny Chene95fcf72011-08-09 22:52:27 +00002908 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002909 log->Printf(" Tried to add a type for %s, but couldn't get one", context.m_decl_name.getAsString().c_str());
Sean Callanan348b5892010-11-30 00:27:43 +00002910 return;
2911 }
2912
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002913 TypeFromParser parser_type (ast_type,
Sean Callananeddeb3b2011-10-28 23:38:38 +00002914 m_ast_context);
Sean Callanan348b5892010-11-30 00:27:43 +00002915
2916 NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
2917
Sean Callanan933693b2012-02-10 01:22:05 +00002918 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
Sean Callanan3bfdaa22011-09-15 02:13:07 +00002919 m_parser_vars->m_target_info.byte_order,
2920 m_parser_vars->m_target_info.address_byte_size));
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002921 assert (entity.get());
Sean Callanan96d27302013-04-11 00:09:05 +00002922
Sean Callanan348b5892010-11-30 00:27:43 +00002923 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00002924 entity->SetName (ConstString (decl_name.c_str()));
2925 entity->SetRegisterInfo (reg_info);
Sean Callanan3c495c12013-01-15 23:29:36 +00002926 entity->EnableParserVars(GetParserID());
2927 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
2928 parser_vars->m_parser_type = parser_type;
2929 parser_vars->m_named_decl = var_decl;
2930 parser_vars->m_llvm_value = NULL;
2931 parser_vars->m_lldb_value = NULL;
Sean Callananf673e762012-02-15 01:40:39 +00002932 entity->m_flags |= ClangExpressionVariable::EVBareRegister;
Sean Callanan348b5892010-11-30 00:27:43 +00002933
Sean Callananf673e762012-02-15 01:40:39 +00002934 if (log)
Sean Callanan348b5892010-11-30 00:27:43 +00002935 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002936 ASTDumper ast_dumper(var_decl);
Sean Callananfb3e4302011-10-29 19:50:43 +00002937 log->Printf(" CEDM::FEVD[%d] Added register %s, returned %s", current_id, context.m_decl_name.getAsString().c_str(), ast_dumper.GetCString());
Sean Callanan348b5892010-11-30 00:27:43 +00002938 }
2939}
2940
Sean Callanan2235f322010-08-11 03:57:18 +00002941void
Greg Clayton3f5c08f2011-05-18 22:01:49 +00002942ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
2943 Function* fun,
Sean Callanan7dd98122011-10-14 20:34:21 +00002944 Symbol* symbol,
2945 unsigned int current_id)
Sean Callanan468574b2010-06-22 23:46:24 +00002946{
Sean Callanan979f74d2010-12-03 01:38:59 +00002947 assert (m_parser_vars.get());
2948
Greg Clayton5160ce52013-03-27 23:08:40 +00002949 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan468574b2010-06-22 23:46:24 +00002950
Sean Callanan77eaf442011-07-08 00:39:14 +00002951 NamedDecl *fun_decl = NULL;
Greg Clayton7b0992d2013-04-18 22:45:39 +00002952 std::unique_ptr<Value> fun_location(new Value);
Sean Callanan77eaf442011-07-08 00:39:14 +00002953 const Address *fun_address = NULL;
Sean Callanan468574b2010-06-22 23:46:24 +00002954
Sean Callanan8ade1042010-07-27 00:55:47 +00002955 // only valid for Functions, not for Symbols
2956 void *fun_opaque_type = NULL;
Sean Callanancc427fa2011-07-30 02:42:06 +00002957 ASTContext *fun_ast_context = NULL;
Matt Kopec00049b82013-02-27 20:13:38 +00002958
2959 bool is_indirect_function = false;
2960
Sean Callanan8ade1042010-07-27 00:55:47 +00002961 if (fun)
2962 {
2963 Type *fun_type = fun->GetType();
2964
2965 if (!fun_type)
2966 {
2967 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002968 log->PutCString(" Skipped a function because it has no type");
Sean Callanan8ade1042010-07-27 00:55:47 +00002969 return;
2970 }
2971
Greg Claytonf4ecaa52011-02-16 23:00:21 +00002972 fun_opaque_type = fun_type->GetClangFullType();
Sean Callanan8ade1042010-07-27 00:55:47 +00002973
2974 if (!fun_opaque_type)
2975 {
2976 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002977 log->PutCString(" Skipped a function because it has no Clang type");
Sean Callanan8ade1042010-07-27 00:55:47 +00002978 return;
2979 }
2980
2981 fun_address = &fun->GetAddressRange().GetBaseAddress();
2982
Greg Clayton6beaaa62011-01-17 03:46:26 +00002983 fun_ast_context = fun_type->GetClangASTContext().getASTContext();
Sean Callananeddeb3b2011-10-28 23:38:38 +00002984 void *copied_type = GuardedCopyType(m_ast_context, fun_ast_context, fun_opaque_type);
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002985 if (copied_type)
2986 {
2987 fun_decl = context.AddFunDecl(copied_type);
2988 }
2989 else
2990 {
2991 // We failed to copy the type we found
2992 if (log)
2993 {
Daniel Malead01b2952012-11-29 21:49:15 +00002994 log->Printf (" Failed to import the function type '%s' {0x%8.8" PRIx64 "} into the expression parser AST contenxt",
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002995 fun_type->GetName().GetCString(),
2996 fun_type->GetID());
2997 }
Sean Callananed8d58f2011-11-16 00:40:13 +00002998
2999 return;
Greg Clayton64bc6ca2011-10-20 00:47:21 +00003000 }
Sean Callanan8ade1042010-07-27 00:55:47 +00003001 }
3002 else if (symbol)
3003 {
Greg Claytone7612132012-03-07 21:03:09 +00003004 fun_address = &symbol->GetAddress();
Sean Callanan8ade1042010-07-27 00:55:47 +00003005 fun_decl = context.AddGenericFunDecl();
Matt Kopec00049b82013-02-27 20:13:38 +00003006 is_indirect_function = symbol->IsIndirect();
Sean Callanan8ade1042010-07-27 00:55:47 +00003007 }
3008 else
3009 {
3010 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00003011 log->PutCString(" AddOneFunction called with no function and no symbol");
Sean Callanan8ade1042010-07-27 00:55:47 +00003012 return;
3013 }
3014
Sean Callanan933693b2012-02-10 01:22:05 +00003015 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00003016
Matt Kopec00049b82013-02-27 20:13:38 +00003017 lldb::addr_t load_addr = fun_address->GetCallableLoadAddress(target, is_indirect_function);
Sean Callanan9be9d172013-03-19 01:45:02 +00003018
3019 if (load_addr != LLDB_INVALID_ADDRESS)
3020 {
3021 fun_location->SetValueType(Value::eValueTypeLoadAddress);
3022 fun_location->GetScalar() = load_addr;
3023 }
3024 else
3025 {
3026 // We have to try finding a file address.
3027
3028 lldb::addr_t file_addr = fun_address->GetFileAddress();
3029
3030 fun_location->SetValueType(Value::eValueTypeFileAddress);
3031 fun_location->GetScalar() = file_addr;
3032 }
Sean Callanan468574b2010-06-22 23:46:24 +00003033
Sean Callanan933693b2012-02-10 01:22:05 +00003034 ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
Sean Callanan3bfdaa22011-09-15 02:13:07 +00003035 m_parser_vars->m_target_info.byte_order,
3036 m_parser_vars->m_target_info.address_byte_size));
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00003037 assert (entity.get());
Greg Clayton7b462cc2010-10-15 22:48:33 +00003038 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00003039 entity->SetName(ConstString(decl_name.c_str()));
3040 entity->SetClangType (fun_opaque_type);
3041 entity->SetClangAST (fun_ast_context);
Sean Callanan468574b2010-06-22 23:46:24 +00003042
Sean Callanan3c495c12013-01-15 23:29:36 +00003043 entity->EnableParserVars(GetParserID());
3044 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
3045 parser_vars->m_named_decl = fun_decl;
3046 parser_vars->m_llvm_value = NULL;
3047 parser_vars->m_lldb_value = fun_location.release();
Sean Callanan64dfc9a2010-08-23 23:09:38 +00003048
Sean Callananea22d422010-07-16 00:09:46 +00003049 if (log)
Greg Clayton7b462cc2010-10-15 22:48:33 +00003050 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00003051 ASTDumper ast_dumper(fun_decl);
Sean Callanan530782942010-11-01 23:22:47 +00003052
Sean Callanan308a3c52012-07-28 00:21:01 +00003053 StreamString ss;
3054
3055 fun_address->Dump(&ss, m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), Address::DumpStyleResolvedDescription);
3056
3057 log->Printf(" CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
Sean Callanan7dd98122011-10-14 20:34:21 +00003058 current_id,
3059 (fun ? "specific" : "generic"),
Sean Callanan308a3c52012-07-28 00:21:01 +00003060 decl_name.c_str(),
3061 ss.GetData(),
Greg Clayton64bc6ca2011-10-20 00:47:21 +00003062 ast_dumper.GetCString());
Greg Clayton7b462cc2010-10-15 22:48:33 +00003063 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003064}
Sean Callanan5666b672010-08-04 01:02:13 +00003065
Sean Callananfa4fab72013-02-01 06:55:48 +00003066TypeFromParser
3067ClangExpressionDeclMap::CopyClassType(TypeFromUser &ut,
3068 unsigned int current_id)
Sean Callanan5666b672010-08-04 01:02:13 +00003069{
Sean Callananeddeb3b2011-10-28 23:38:38 +00003070 ASTContext *parser_ast_context = m_ast_context;
Sean Callanancc427fa2011-07-30 02:42:06 +00003071 ASTContext *user_ast_context = ut.GetASTContext();
Sean Callananfa4fab72013-02-01 06:55:48 +00003072
Sean Callanan6abfabf2010-11-19 20:20:02 +00003073 void *copied_type = GuardedCopyType(parser_ast_context, user_ast_context, ut.GetOpaqueQualType());
Sean Callanane0a64f72011-12-01 21:04:37 +00003074
3075 if (!copied_type)
3076 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003077 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanane0a64f72011-12-01 21:04:37 +00003078
Sean Callananfa4fab72013-02-01 06:55:48 +00003079 if (log)
3080 log->Printf("ClangExpressionDeclMap::CopyClassType - Couldn't import the type");
3081
3082 return TypeFromParser();
Sean Callanane0a64f72011-12-01 21:04:37 +00003083 }
Sean Callananfa4fab72013-02-01 06:55:48 +00003084
3085 if (ClangASTContext::IsAggregateType(copied_type) && ClangASTContext::GetCompleteType (parser_ast_context, copied_type))
Sean Callananfc55f5d2010-09-21 00:44:12 +00003086 {
3087 void *args[1];
3088
3089 args[0] = ClangASTContext::GetVoidPtrType(parser_ast_context, false);
3090
Sean Callananc1b732d2011-11-01 18:07:13 +00003091 clang_type_t method_type = ClangASTContext::CreateFunctionType (parser_ast_context,
3092 ClangASTContext::GetBuiltInType_void(parser_ast_context),
3093 args,
3094 1,
3095 false,
3096 ClangASTContext::GetTypeQualifiers(copied_type));
3097
Greg Clayton0fffff52010-09-24 05:15:53 +00003098 const bool is_virtual = false;
3099 const bool is_static = false;
3100 const bool is_inline = false;
Greg Claytonf51de672010-10-01 02:31:07 +00003101 const bool is_explicit = false;
Sean Callananc8324752011-11-02 18:09:01 +00003102 const bool is_attr_used = true;
Sean Callanandbb58392011-11-02 01:38:59 +00003103 const bool is_artificial = false;
Greg Claytonf51de672010-10-01 02:31:07 +00003104
Greg Clayton0fffff52010-09-24 05:15:53 +00003105 ClangASTContext::AddMethodToCXXRecordType (parser_ast_context,
3106 copied_type,
Greg Clayton7b462cc2010-10-15 22:48:33 +00003107 "$__lldb_expr",
Greg Clayton0fffff52010-09-24 05:15:53 +00003108 method_type,
3109 lldb::eAccessPublic,
3110 is_virtual,
3111 is_static,
Greg Claytonf51de672010-10-01 02:31:07 +00003112 is_inline,
Sean Callananc1b732d2011-11-01 18:07:13 +00003113 is_explicit,
Sean Callanandbb58392011-11-02 01:38:59 +00003114 is_attr_used,
3115 is_artificial);
Sean Callananfc55f5d2010-09-21 00:44:12 +00003116 }
Sean Callanan5666b672010-08-04 01:02:13 +00003117
Sean Callananfa4fab72013-02-01 06:55:48 +00003118 return TypeFromParser(copied_type, parser_ast_context);
3119}
3120
3121void
3122ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
3123 TypeFromUser &ut,
3124 unsigned int current_id)
3125{
3126 ASTContext *parser_ast_context = m_ast_context;
3127 ASTContext *user_ast_context = ut.GetASTContext();
3128
3129 void *copied_type = GuardedCopyType(parser_ast_context, user_ast_context, ut.GetOpaqueQualType());
3130
3131 if (!copied_type)
3132 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003133 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananfa4fab72013-02-01 06:55:48 +00003134
3135 if (log)
3136 log->Printf("ClangExpressionDeclMap::AddOneType - Couldn't import the type");
3137
3138 return;
3139 }
3140
Sean Callanan5666b672010-08-04 01:02:13 +00003141 context.AddTypeDecl(copied_type);
3142}