blob: db05cbb42403f2aa1fa7fa6f050f04f58aa1b649 [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"
Sean Callanan80c97592015-05-01 00:47:29 +000011#include "clang/AST/ASTConsumer.h"
Sean Callanan3d654b32012-09-24 22:25:51 +000012#include "clang/AST/ASTContext.h"
Sean Callanane2ef6e32010-09-23 03:01:22 +000013#include "clang/AST/DeclarationName.h"
Sean Callanan530782942010-11-01 23:22:47 +000014#include "clang/AST/Decl.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000015#include "lldb/lldb-private.h"
16#include "lldb/Core/Address.h"
Sean Callananea22d422010-07-16 00:09:46 +000017#include "lldb/Core/Error.h"
Sean Callananf06ba8d2010-06-23 00:47:48 +000018#include "lldb/Core/Log.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000019#include "lldb/Core/Module.h"
Greg Clayton9191db42013-10-21 18:40:51 +000020#include "lldb/Core/ModuleSpec.h"
Greg Clayton7349bd92011-05-09 20:18:18 +000021#include "lldb/Core/RegisterValue.h"
Sean Callanane4ec90e2010-12-16 03:17:46 +000022#include "lldb/Core/ValueObjectConstResult.h"
Sean Callanan9b3569b2011-12-10 03:12:34 +000023#include "lldb/Core/ValueObjectVariable.h"
Sean Callanan0917d6e2011-02-01 23:43:26 +000024#include "lldb/Expression/ASTDumper.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000025#include "lldb/Expression/ClangASTSource.h"
Zachary Turner32abc6e2015-03-03 19:23:09 +000026#include "lldb/Expression/ClangModulesDeclVendor.h"
Sean Callanan2235f322010-08-11 03:57:18 +000027#include "lldb/Expression/ClangPersistentVariables.h"
Sean Callanan96d27302013-04-11 00:09:05 +000028#include "lldb/Expression/Materializer.h"
Greg Clayton7fb56d02011-02-01 01:31:41 +000029#include "lldb/Host/Endian.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000030#include "lldb/Symbol/ClangASTContext.h"
Greg Clayton99558cc42015-08-24 23:46:31 +000031#include "lldb/Symbol/CompilerDeclContext.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000032#include "lldb/Symbol/CompileUnit.h"
33#include "lldb/Symbol/Function.h"
34#include "lldb/Symbol/ObjectFile.h"
35#include "lldb/Symbol/SymbolContext.h"
Sean Callanan503aa522011-10-12 00:12:34 +000036#include "lldb/Symbol/SymbolVendor.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000037#include "lldb/Symbol/Type.h"
38#include "lldb/Symbol/TypeList.h"
39#include "lldb/Symbol/Variable.h"
40#include "lldb/Symbol/VariableList.h"
Sean Callanana0d56432014-11-11 02:49:44 +000041#include "lldb/Target/CPPLanguageRuntime.h"
Sean Callanan1d180662010-07-20 23:31:16 +000042#include "lldb/Target/ExecutionContext.h"
Sean Callanane0b23b52012-11-15 02:02:04 +000043#include "lldb/Target/ObjCLanguageRuntime.h"
Sean Callananea22d422010-07-16 00:09:46 +000044#include "lldb/Target/Process.h"
Sean Callananf4b9bd32010-10-05 20:18:48 +000045#include "lldb/Target/RegisterContext.h"
Jason Molendab57e4a12013-11-04 09:33:30 +000046#include "lldb/Target/StackFrame.h"
Sean Callanan1d180662010-07-20 23:31:16 +000047#include "lldb/Target/Target.h"
Jim Ingham895c9822010-12-07 01:56:02 +000048#include "lldb/Target/Thread.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000049
Siva Chandra0f4873d2015-09-03 23:27:10 +000050#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
51
Greg Clayton83c5cd92010-11-14 22:13:40 +000052using namespace lldb;
Chris Lattner30fdc8d2010-06-08 16:52:24 +000053using namespace lldb_private;
54using namespace clang;
55
Sean Callanan1ee44b72011-10-29 01:58:46 +000056ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory, ExecutionContext &exe_ctx) :
57 ClangASTSource (exe_ctx.GetTargetSP()),
Greg Clayton7b462cc2010-10-15 22:48:33 +000058 m_found_entities (),
59 m_struct_members (),
Stephen Wilson71c21d12011-04-11 19:41:40 +000060 m_keep_result_in_memory (keep_result_in_memory),
Sean Callanan979f74d2010-12-03 01:38:59 +000061 m_parser_vars (),
Stephen Wilson71c21d12011-04-11 19:41:40 +000062 m_struct_vars ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +000063{
Sean Callanan979f74d2010-12-03 01:38:59 +000064 EnableStructVars();
Chris Lattner30fdc8d2010-06-08 16:52:24 +000065}
66
67ClangExpressionDeclMap::~ClangExpressionDeclMap()
Sean Callanan979f74d2010-12-03 01:38:59 +000068{
Sean Callanane3aef1d2011-10-12 22:20:02 +000069 // Note: The model is now that the parser's AST context and all associated
70 // data does not vanish until the expression has been executed. This means
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +000071 // that valuable lookup data (like namespaces) doesn't vanish, but
72
Sean Callanane3aef1d2011-10-12 22:20:02 +000073 DidParse();
Sean Callanan979f74d2010-12-03 01:38:59 +000074 DisableStructVars();
75}
Sean Callananbe3a1b12010-10-26 00:31:56 +000076
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +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();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +000082
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;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +000085
Greg Claytonc14ee322011-09-22 04:58:26 +000086 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 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000101
Greg Claytonc14ee322011-09-22 04:58:26 +0000102 if (target)
103 {
104 m_parser_vars->m_persistent_vars = &target->GetPersistentVariables();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000105
Greg Claytonc14ee322011-09-22 04:58:26 +0000106 if (!target->GetScratchClangASTContext())
107 return false;
108 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +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;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +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
Sean Callanan80c97592015-05-01 00:47:29 +0000117ClangExpressionDeclMap::InstallCodeGenerator (clang::ASTConsumer *code_gen)
118{
119 assert(m_parser_vars);
120 m_parser_vars->m_code_gen = code_gen;
121}
122
123void
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000124ClangExpressionDeclMap::DidParse()
Sean Callanan979f74d2010-12-03 01:38:59 +0000125{
Greg Clayton5160ce52013-03-27 23:08:40 +0000126 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan8106d802013-03-08 20:04:57 +0000127
128 if (log)
129 ClangASTMetrics::DumpCounters(log);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000130
Sean Callanan979f74d2010-12-03 01:38:59 +0000131 if (m_parser_vars.get())
132 {
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000133 for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000134 entity_index < num_entities;
135 ++entity_index)
136 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000137 ExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
Jim Ingham28eb5712012-10-12 17:34:26 +0000138 if (var_sp)
Sean Callanan3820e9c2015-09-08 22:23:39 +0000139 llvm::cast<ClangExpressionVariable>(var_sp.get())->DisableParserVars(GetParserID());
Sean Callanan979f74d2010-12-03 01:38:59 +0000140 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000141
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 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000146 ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000147 if (pvar_sp)
Sean Callanan3820e9c2015-09-08 22:23:39 +0000148 llvm::cast<ClangExpressionVariable>(pvar_sp.get())->DisableParserVars(GetParserID());
Sean Callanan979f74d2010-12-03 01:38:59 +0000149 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000150
Sean Callanan979f74d2010-12-03 01:38:59 +0000151 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
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000157ClangExpressionDeclMap::TargetInfo
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000158ClangExpressionDeclMap::GetTargetInfo()
159{
160 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000161
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000162 TargetInfo ret;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000163
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 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000172 else
Sean Callanan933693b2012-02-10 01:22:05 +0000173 {
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
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000185bool
186ClangExpressionDeclMap::AddPersistentVariable
Greg Clayton7b462cc2010-10-15 22:48:33 +0000187(
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000188 const NamedDecl *decl,
189 const ConstString &name,
Sean Callanan92adcac2011-01-13 08:53:35 +0000190 TypeFromParser parser_type,
191 bool is_result,
192 bool is_lvalue
Greg Clayton7b462cc2010-10-15 22:48:33 +0000193)
Sean Callanan2235f322010-08-11 03:57:18 +0000194{
Sean Callanan979f74d2010-12-03 01:38:59 +0000195 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000196
Greg Claytonf73034f2015-09-08 18:15:05 +0000197 ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem());
198 if (ast == nullptr)
199 return false;
200
Sean Callanan1582ee62013-04-18 22:06:33 +0000201 if (m_parser_vars->m_materializer && is_result)
202 {
203 Error err;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000204
Sean Callanan1582ee62013-04-18 22:06:33 +0000205 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
206 Target *target = exe_ctx.GetTargetPtr();
Greg Claytonf73034f2015-09-08 18:15:05 +0000207 if (target == nullptr)
Sean Callanan1582ee62013-04-18 22:06:33 +0000208 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000209
Greg Claytond8d4a572015-08-11 21:38:15 +0000210 ClangASTContext *context(target->GetScratchClangASTContext());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000211
Greg Claytond8d4a572015-08-11 21:38:15 +0000212 TypeFromUser user_type(m_ast_importer->DeportType(context->getASTContext(),
Greg Claytonf73034f2015-09-08 18:15:05 +0000213 ast->getASTContext(),
Sean Callanan1582ee62013-04-18 22:06:33 +0000214 parser_type.GetOpaqueQualType()),
215 context);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000216
Sean Callanan1582ee62013-04-18 22:06:33 +0000217 uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(user_type, is_lvalue, m_keep_result_in_memory, err);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000218
Sean Callananbc8ac342015-09-04 20:49:51 +0000219 ClangExpressionVariable *var = ClangExpressionVariable::CreateVariableInList(m_found_entities,
220 exe_ctx.GetBestExecutionContextScope(),
221 name,
222 user_type,
223 m_parser_vars->m_target_info.byte_order,
224 m_parser_vars->m_target_info.address_byte_size);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000225
Sean Callananbc8ac342015-09-04 20:49:51 +0000226 if (!var)
Sean Callanan1582ee62013-04-18 22:06:33 +0000227 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000228
Sean Callananbc8ac342015-09-04 20:49:51 +0000229 var->EnableParserVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000230
Sean Callananbc8ac342015-09-04 20:49:51 +0000231 ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
Sean Callanan1582ee62013-04-18 22:06:33 +0000232
233 parser_vars->m_named_decl = decl;
234 parser_vars->m_parser_type = parser_type;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000235
Sean Callananbc8ac342015-09-04 20:49:51 +0000236 var->EnableJITVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000237
Sean Callananbc8ac342015-09-04 20:49:51 +0000238 ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000239
Sean Callanan1582ee62013-04-18 22:06:33 +0000240 jit_vars->m_offset = offset;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000241
Sean Callanan1582ee62013-04-18 22:06:33 +0000242 return true;
243 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000244
Greg Clayton5160ce52013-03-27 23:08:40 +0000245 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +0000246 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
247 Target *target = exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +0000248 if (target == NULL)
249 return false;
250
Greg Claytond8d4a572015-08-11 21:38:15 +0000251 ClangASTContext *context(target->GetScratchClangASTContext());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000252
Greg Claytond8d4a572015-08-11 21:38:15 +0000253 TypeFromUser user_type(m_ast_importer->DeportType(context->getASTContext(),
Greg Claytonf73034f2015-09-08 18:15:05 +0000254 ast->getASTContext(),
Sean Callananbb120042011-12-16 21:06:35 +0000255 parser_type.GetOpaqueQualType()),
Sean Callanane1175b72011-01-13 21:23:32 +0000256 context);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000257
Sean Callanan00f43622011-11-18 03:28:09 +0000258 if (!user_type.GetOpaqueQualType())
259 {
260 if (log)
261 log->Printf("Persistent variable's type wasn't copied successfully");
262 return false;
263 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000264
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000265 if (!m_parser_vars->m_target_info.IsValid())
266 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000267
Sean Callananbc8ac342015-09-04 20:49:51 +0000268 ClangExpressionVariable *var = m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
269 name,
270 user_type,
271 m_parser_vars->m_target_info.byte_order,
272 m_parser_vars->m_target_info.address_byte_size);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000273
Sean Callananbc8ac342015-09-04 20:49:51 +0000274 if (!var)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000275 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000276
Sean Callananbc8ac342015-09-04 20:49:51 +0000277 var->m_frozen_sp->SetHasCompleteType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000278
Sean Callanan92adcac2011-01-13 08:53:35 +0000279 if (is_result)
Sean Callananbc8ac342015-09-04 20:49:51 +0000280 var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
Sean Callanan92adcac2011-01-13 08:53:35 +0000281 else
Sean Callananbc8ac342015-09-04 20:49:51 +0000282 var->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000283
Sean Callanan92adcac2011-01-13 08:53:35 +0000284 if (is_lvalue)
285 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000286 var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
Sean Callanan92adcac2011-01-13 08:53:35 +0000287 }
288 else
289 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000290 var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
291 var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
Sean Callanan92adcac2011-01-13 08:53:35 +0000292 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000293
Sean Callanan35005f72013-04-12 18:10:34 +0000294 if (m_keep_result_in_memory)
295 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000296 var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
Sean Callanan35005f72013-04-12 18:10:34 +0000297 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000298
Sean Callanan92adcac2011-01-13 08:53:35 +0000299 if (log)
Sean Callananbc8ac342015-09-04 20:49:51 +0000300 log->Printf("Created persistent variable with flags 0x%hx", var->m_flags);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000301
Sean Callananbc8ac342015-09-04 20:49:51 +0000302 var->EnableParserVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000303
Sean Callananbc8ac342015-09-04 20:49:51 +0000304 ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000305
Sean Callanan3c495c12013-01-15 23:29:36 +0000306 parser_vars->m_named_decl = decl;
307 parser_vars->m_parser_type = parser_type;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000308
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000309 return true;
Sean Callanan2235f322010-08-11 03:57:18 +0000310}
311
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000312bool
313ClangExpressionDeclMap::AddValueToStruct
Greg Clayton7b462cc2010-10-15 22:48:33 +0000314(
Sean Callanancc427fa2011-07-30 02:42:06 +0000315 const NamedDecl *decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000316 const ConstString &name,
317 llvm::Value *value,
318 size_t size,
Zachary Turnera746e8e2014-07-02 17:24:07 +0000319 lldb::offset_t alignment
Greg Clayton7b462cc2010-10-15 22:48:33 +0000320)
Sean Callanan549c9f72010-07-13 21:41:46 +0000321{
Sean Callanan979f74d2010-12-03 01:38:59 +0000322 assert (m_struct_vars.get());
323 assert (m_parser_vars.get());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000324
Sean Callanandf667652013-04-11 02:05:11 +0000325 bool is_persistent_variable = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000326
Greg Clayton5160ce52013-03-27 23:08:40 +0000327 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000328
Sean Callanan979f74d2010-12-03 01:38:59 +0000329 m_struct_vars->m_struct_laid_out = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000330
Sean Callananbc8ac342015-09-04 20:49:51 +0000331 if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl, GetParserID()))
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000332 return true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000333
Sean Callananbc8ac342015-09-04 20:49:51 +0000334 ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000335
Sean Callananbc8ac342015-09-04 20:49:51 +0000336 if (!var)
Sean Callanandf667652013-04-11 02:05:11 +0000337 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000338 var = ClangExpressionVariable::FindVariableInList(*m_parser_vars->m_persistent_vars, decl, GetParserID());
Sean Callanandf667652013-04-11 02:05:11 +0000339 is_persistent_variable = true;
340 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000341
Sean Callananbc8ac342015-09-04 20:49:51 +0000342 if (!var)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000343 return false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000344
Sean Callanan823bb4c2010-08-30 22:17:16 +0000345 if (log)
Sean Callanan00f43622011-11-18 03:28:09 +0000346 log->Printf("Adding value for (NamedDecl*)%p [%s - %s] to the structure",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000347 static_cast<const void*>(decl), name.GetCString(),
Sean Callananbc8ac342015-09-04 20:49:51 +0000348 var->GetName().GetCString());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000349
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000350 // We know entity->m_parser_vars is valid because we used a parser variable
351 // to find it
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000352
Sean Callanan3820e9c2015-09-08 22:23:39 +0000353 ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
Sean Callanan3c495c12013-01-15 23:29:36 +0000354
355 parser_vars->m_llvm_value = value;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000356
Sean Callanan3820e9c2015-09-08 22:23:39 +0000357 if (ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID()))
Sean Callanan1582ee62013-04-18 22:06:33 +0000358 {
359 // We already laid this out; do not touch
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000360
Sean Callanan1582ee62013-04-18 22:06:33 +0000361 if (log)
362 log->Printf("Already placed at 0x%llx", (unsigned long long)jit_vars->m_offset);
363 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000364
Sean Callanan3820e9c2015-09-08 22:23:39 +0000365 llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000366
Sean Callanan3820e9c2015-09-08 22:23:39 +0000367 ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());
Sean Callanan3c495c12013-01-15 23:29:36 +0000368
369 jit_vars->m_alignment = alignment;
370 jit_vars->m_size = size;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000371
Sean Callananbc8ac342015-09-04 20:49:51 +0000372 m_struct_members.AddVariable(var->shared_from_this());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000373
Sean Callanandf667652013-04-11 02:05:11 +0000374 if (m_parser_vars->m_materializer)
375 {
Sean Callanan3dd6a422013-04-11 21:16:36 +0000376 uint32_t offset = 0;
377
Sean Callanandf667652013-04-11 02:05:11 +0000378 Error err;
379
380 if (is_persistent_variable)
381 {
Sean Callananbc8ac342015-09-04 20:49:51 +0000382 ExpressionVariableSP var_sp(var->shared_from_this());
Sean Callanan3dd6a422013-04-11 21:16:36 +0000383 offset = m_parser_vars->m_materializer->AddPersistentVariable(var_sp, err);
Sean Callanandf667652013-04-11 02:05:11 +0000384 }
385 else
386 {
387 if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
Sean Callanan3dd6a422013-04-11 21:16:36 +0000388 offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
Sean Callananbc8ac342015-09-04 20:49:51 +0000389 else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
Sean Callanan3dd6a422013-04-11 21:16:36 +0000390 offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
Sean Callanandf667652013-04-11 02:05:11 +0000391 else if (parser_vars->m_lldb_var)
Sean Callanan3dd6a422013-04-11 21:16:36 +0000392 offset = m_parser_vars->m_materializer->AddVariable(parser_vars->m_lldb_var, err);
Sean Callanandf667652013-04-11 02:05:11 +0000393 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000394
Sean Callanan3dd6a422013-04-11 21:16:36 +0000395 if (!err.Success())
396 return false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000397
Sean Callanan3dd6a422013-04-11 21:16:36 +0000398 if (log)
399 log->Printf("Placed at 0x%llx", (unsigned long long)offset);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000400
Sean Callanan3dd6a422013-04-11 21:16:36 +0000401 jit_vars->m_offset = offset; // TODO DoStructLayout() should not change this.
Sean Callanandf667652013-04-11 02:05:11 +0000402 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000403
Sean Callanan549c9f72010-07-13 21:41:46 +0000404 return true;
405}
406
407bool
408ClangExpressionDeclMap::DoStructLayout ()
409{
Sean Callanan979f74d2010-12-03 01:38:59 +0000410 assert (m_struct_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000411
Sean Callanan979f74d2010-12-03 01:38:59 +0000412 if (m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000413 return true;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000414
Sean Callanan14b1bae2013-04-16 23:25:35 +0000415 if (!m_parser_vars->m_materializer)
416 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000417
Sean Callanan14b1bae2013-04-16 23:25:35 +0000418 m_struct_vars->m_struct_alignment = m_parser_vars->m_materializer->GetStructAlignment();
419 m_struct_vars->m_struct_size = m_parser_vars->m_materializer->GetStructByteSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000420 m_struct_vars->m_struct_laid_out = true;
Sean Callanan549c9f72010-07-13 21:41:46 +0000421 return true;
422}
423
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000424bool ClangExpressionDeclMap::GetStructInfo
Greg Clayton7b462cc2010-10-15 22:48:33 +0000425(
426 uint32_t &num_elements,
427 size_t &size,
Zachary Turnera746e8e2014-07-02 17:24:07 +0000428 lldb::offset_t &alignment
Greg Clayton7b462cc2010-10-15 22:48:33 +0000429)
Sean Callanan549c9f72010-07-13 21:41:46 +0000430{
Sean Callanan979f74d2010-12-03 01:38:59 +0000431 assert (m_struct_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000432
Sean Callanan979f74d2010-12-03 01:38:59 +0000433 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000434 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000435
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000436 num_elements = m_struct_members.GetSize();
Sean Callanan979f74d2010-12-03 01:38:59 +0000437 size = m_struct_vars->m_struct_size;
438 alignment = m_struct_vars->m_struct_alignment;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000439
Sean Callanan549c9f72010-07-13 21:41:46 +0000440 return true;
441}
442
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000443bool
444ClangExpressionDeclMap::GetStructElement
Greg Clayton7b462cc2010-10-15 22:48:33 +0000445(
Sean Callanancc427fa2011-07-30 02:42:06 +0000446 const NamedDecl *&decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000447 llvm::Value *&value,
Zachary Turnera746e8e2014-07-02 17:24:07 +0000448 lldb::offset_t &offset,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000449 ConstString &name,
450 uint32_t index
451)
Sean Callanan549c9f72010-07-13 21:41:46 +0000452{
Sean Callanan979f74d2010-12-03 01:38:59 +0000453 assert (m_struct_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000454
Sean Callanan979f74d2010-12-03 01:38:59 +0000455 if (!m_struct_vars->m_struct_laid_out)
Sean Callanan549c9f72010-07-13 21:41:46 +0000456 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000457
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000458 if (index >= m_struct_members.GetSize())
Sean Callanan549c9f72010-07-13 21:41:46 +0000459 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000460
Sean Callananbc8ac342015-09-04 20:49:51 +0000461 ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000462
Sean Callanan3c495c12013-01-15 23:29:36 +0000463 if (!member_sp)
464 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000465
Sean Callanan3820e9c2015-09-08 22:23:39 +0000466 ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(member_sp.get())->GetParserVars(GetParserID());
467 ClangExpressionVariable::JITVars *jit_vars = llvm::cast<ClangExpressionVariable>(member_sp.get())->GetJITVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000468
Sean Callanan3c495c12013-01-15 23:29:36 +0000469 if (!parser_vars ||
470 !jit_vars ||
Sean Callanan6f3e5ad2012-04-12 16:58:26 +0000471 !member_sp->GetValueObject())
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000472 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000473
Sean Callanan3c495c12013-01-15 23:29:36 +0000474 decl = parser_vars->m_named_decl;
475 value = parser_vars->m_llvm_value;
476 offset = jit_vars->m_offset;
Greg Clayton8b2fe6d2010-12-14 02:59:59 +0000477 name = member_sp->GetName();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000478
Sean Callanan549c9f72010-07-13 21:41:46 +0000479 return true;
480}
481
Sean Callanan7ea35012010-07-27 21:39:39 +0000482bool
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000483ClangExpressionDeclMap::GetFunctionInfo
Greg Clayton7b462cc2010-10-15 22:48:33 +0000484(
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000485 const NamedDecl *decl,
Greg Clayton7b462cc2010-10-15 22:48:33 +0000486 uint64_t &ptr
487)
Sean Callanan4edba2d2010-07-27 02:07:53 +0000488{
Sean Callananbc8ac342015-09-04 20:49:51 +0000489 ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000490
Sean Callananbc8ac342015-09-04 20:49:51 +0000491 if (!entity)
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000492 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000493
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000494 // We know m_parser_vars is valid since we searched for the variable by
495 // its NamedDecl
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000496
Sean Callananbc8ac342015-09-04 20:49:51 +0000497 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
Sean Callanan3c495c12013-01-15 23:29:36 +0000498
Greg Clayton57ee3062013-07-11 22:46:58 +0000499 ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000500
Sean Callanan64dfc9a2010-08-23 23:09:38 +0000501 return true;
Sean Callanan4edba2d2010-07-27 02:07:53 +0000502}
503
Sean Callananefe9a422011-08-16 18:09:29 +0000504static void
505FindCodeSymbolInContext
506(
507 const ConstString &name,
508 SymbolContext &sym_ctx,
Siva Chandra0f4873d2015-09-03 23:27:10 +0000509 uint32_t name_type_mask,
Sean Callananefe9a422011-08-16 18:09:29 +0000510 SymbolContextList &sc_list
511)
512{
Greg Clayton58ea3e32015-03-09 16:46:57 +0000513 sc_list.Clear();
Matt Kopec00049b82013-02-27 20:13:38 +0000514 SymbolContextList temp_sc_list;
Sean Callananefe9a422011-08-16 18:09:29 +0000515 if (sym_ctx.module_sp)
Greg Clayton58ea3e32015-03-09 16:46:57 +0000516 sym_ctx.module_sp->FindFunctions(name,
517 NULL,
Siva Chandra0f4873d2015-09-03 23:27:10 +0000518 name_type_mask,
Greg Clayton58ea3e32015-03-09 16:46:57 +0000519 true, // include_symbols
520 false, // include_inlines
521 true, // append
522 temp_sc_list);
523 if (temp_sc_list.GetSize() == 0)
524 {
525 if (sym_ctx.target_sp)
526 sym_ctx.target_sp->GetImages().FindFunctions(name,
Siva Chandra0f4873d2015-09-03 23:27:10 +0000527 name_type_mask,
Greg Clayton58ea3e32015-03-09 16:46:57 +0000528 true, // include_symbols
529 false, // include_inlines
530 true, // append
531 temp_sc_list);
532 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000533
Greg Clayton58ea3e32015-03-09 16:46:57 +0000534 SymbolContextList internal_symbol_sc_list;
Matt Kopec00049b82013-02-27 20:13:38 +0000535 unsigned temp_sc_list_size = temp_sc_list.GetSize();
536 for (unsigned i = 0; i < temp_sc_list_size; i++)
537 {
Greg Clayton58ea3e32015-03-09 16:46:57 +0000538 SymbolContext sc;
539 temp_sc_list.GetContextAtIndex(i, sc);
540 if (sc.function)
Matt Kopec00049b82013-02-27 20:13:38 +0000541 {
Greg Clayton58ea3e32015-03-09 16:46:57 +0000542 sc_list.Append(sc);
543 }
544 else if (sc.symbol)
545 {
546 if (sc.symbol->IsExternal())
Matt Kopec00049b82013-02-27 20:13:38 +0000547 {
Greg Clayton58ea3e32015-03-09 16:46:57 +0000548 sc_list.Append(sc);
549 }
550 else
551 {
552 internal_symbol_sc_list.Append(sc);
Matt Kopec00049b82013-02-27 20:13:38 +0000553 }
554 }
555 }
Greg Clayton58ea3e32015-03-09 16:46:57 +0000556
557 // If we had internal symbols and we didn't find any external symbols or
558 // functions in debug info, then fallback to the internal symbols
559 if (sc_list.GetSize() == 0 && internal_symbol_sc_list.GetSize())
560 {
561 sc_list = internal_symbol_sc_list;
562 }
Sean Callananefe9a422011-08-16 18:09:29 +0000563}
564
Sean Callanan5300d372010-07-31 01:32:05 +0000565bool
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000566ClangExpressionDeclMap::GetFunctionAddress
Greg Clayton7b462cc2010-10-15 22:48:33 +0000567(
568 const ConstString &name,
Greg Clayton3f5c08f2011-05-18 22:01:49 +0000569 uint64_t &func_addr
Greg Clayton7b462cc2010-10-15 22:48:33 +0000570)
Sean Callanan5300d372010-07-31 01:32:05 +0000571{
Sean Callanan979f74d2010-12-03 01:38:59 +0000572 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000573
Greg Clayton5160ce52013-03-27 23:08:40 +0000574 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +0000575 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
576 Target *target = exe_ctx.GetTargetPtr();
Sean Callanan5300d372010-07-31 01:32:05 +0000577 // Back out in all cases where we're not fully initialized
Greg Claytonc14ee322011-09-22 04:58:26 +0000578 if (target == NULL)
Jim Ingham895c9822010-12-07 01:56:02 +0000579 return false;
580 if (!m_parser_vars->m_sym_ctx.target_sp)
Sean Callanan5300d372010-07-31 01:32:05 +0000581 return false;
582
Greg Clayton7a345282010-11-09 23:46:37 +0000583 SymbolContextList sc_list;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000584
Siva Chandra0f4873d2015-09-03 23:27:10 +0000585 FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, eFunctionNameTypeAuto, sc_list);
Matt Kopec00049b82013-02-27 20:13:38 +0000586
Greg Claytonf32db512013-10-30 21:37:46 +0000587 uint32_t sc_list_size = sc_list.GetSize();
Siva Chandra0f4873d2015-09-03 23:27:10 +0000588
589 if (sc_list_size == 0)
590 {
591 SymbolContext &sc = m_parser_vars->m_sym_ctx;
592 if (sc.comp_unit)
593 {
594 LanguageType lang_type = sc.comp_unit->GetLanguage();
595 if (Language::LanguageIsCPlusPlus(lang_type) &&
596 CPlusPlusLanguage::IsCPPMangledName(name.AsCString()))
597 {
598 // 1. Demangle the name
599 Mangled mangled(name, true);
600 ConstString demangled = mangled.GetDemangledName(lang_type);
601
602 if (demangled)
603 {
604 FindCodeSymbolInContext(
605 demangled, m_parser_vars->m_sym_ctx, eFunctionNameTypeFull, sc_list);
606 sc_list_size = sc_list.GetSize();
607 }
608 }
609 }
610 }
611
Greg Claytonf32db512013-10-30 21:37:46 +0000612 if (sc_list_size == 0)
Sean Callanan19b6afe2011-05-13 18:27:02 +0000613 {
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000614 // We occasionally get debug information in which a const function is reported
Sean Callanan19b6afe2011-05-13 18:27:02 +0000615 // as non-const, so the mangled name is wrong. This is a hack to compensate.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000616
Sean Callananf4638562011-10-25 18:02:05 +0000617 if (!strncmp(name.GetCString(), "_ZN", 3) &&
618 strncmp(name.GetCString(), "_ZNK", 4))
Sean Callanan19b6afe2011-05-13 18:27:02 +0000619 {
Sean Callananf4638562011-10-25 18:02:05 +0000620 std::string fixed_scratch("_ZNK");
621 fixed_scratch.append(name.GetCString() + 3);
622 ConstString fixed_name(fixed_scratch.c_str());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000623
Sean Callanan19b6afe2011-05-13 18:27:02 +0000624 if (log)
Sean Callananf4638562011-10-25 18:02:05 +0000625 log->Printf("Failed to find symbols given non-const name %s; trying %s", name.GetCString(), fixed_name.GetCString());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000626
Siva Chandra0f4873d2015-09-03 23:27:10 +0000627 FindCodeSymbolInContext(
628 fixed_name, m_parser_vars->m_sym_ctx, eFunctionNameTypeAuto, sc_list);
Greg Claytonf32db512013-10-30 21:37:46 +0000629 sc_list_size = sc_list.GetSize();
Sean Callanan19b6afe2011-05-13 18:27:02 +0000630 }
631 }
Matt Kopec00049b82013-02-27 20:13:38 +0000632
Greg Clayton12ba7332015-03-05 23:12:02 +0000633 lldb::addr_t intern_callable_load_addr = LLDB_INVALID_ADDRESS;
634
Greg Claytonf32db512013-10-30 21:37:46 +0000635 for (uint32_t i=0; i<sc_list_size; ++i)
636 {
637 SymbolContext sym_ctx;
638 sc_list.GetContextAtIndex(i, sym_ctx);
Matt Kopec00049b82013-02-27 20:13:38 +0000639
Greg Clayton12ba7332015-03-05 23:12:02 +0000640
Sean Callanan25ea6a12014-05-23 02:30:48 +0000641 lldb::addr_t callable_load_addr = LLDB_INVALID_ADDRESS;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000642
Greg Claytonf32db512013-10-30 21:37:46 +0000643 if (sym_ctx.function)
Greg Claytonf32db512013-10-30 21:37:46 +0000644 {
Sean Callanan25ea6a12014-05-23 02:30:48 +0000645 const Address func_so_addr = sym_ctx.function->GetAddressRange().GetBaseAddress();
646 if (func_so_addr.IsValid())
Greg Claytonf32db512013-10-30 21:37:46 +0000647 {
Sean Callanan25ea6a12014-05-23 02:30:48 +0000648 callable_load_addr = func_so_addr.GetCallableLoadAddress(target, false);
Greg Claytonf32db512013-10-30 21:37:46 +0000649 }
650 }
Sean Callanan25ea6a12014-05-23 02:30:48 +0000651 else if (sym_ctx.symbol)
Greg Claytonf32db512013-10-30 21:37:46 +0000652 {
Greg Clayton12ba7332015-03-05 23:12:02 +0000653 if (sym_ctx.symbol->IsExternal())
654 callable_load_addr = sym_ctx.symbol->ResolveCallableAddress(*target);
655 else
656 {
657 if (intern_callable_load_addr == LLDB_INVALID_ADDRESS)
658 intern_callable_load_addr = sym_ctx.symbol->ResolveCallableAddress(*target);
659 }
Sean Callanan25ea6a12014-05-23 02:30:48 +0000660 }
661
662 if (callable_load_addr != LLDB_INVALID_ADDRESS)
663 {
664 func_addr = callable_load_addr;
665 return true;
Greg Claytonf32db512013-10-30 21:37:46 +0000666 }
667 }
Greg Clayton12ba7332015-03-05 23:12:02 +0000668
669 // See if we found an internal symbol
670 if (intern_callable_load_addr != LLDB_INVALID_ADDRESS)
671 {
672 func_addr = intern_callable_load_addr;
673 return true;
674 }
675
Greg Claytonf32db512013-10-30 21:37:46 +0000676 return false;
Sean Callanan5300d372010-07-31 01:32:05 +0000677}
678
Greg Clayton084db102011-06-23 04:25:29 +0000679addr_t
Greg Clayton9191db42013-10-21 18:40:51 +0000680ClangExpressionDeclMap::GetSymbolAddress (Target &target,
681 Process *process,
682 const ConstString &name,
683 lldb::SymbolType symbol_type,
Deepak Panickald66b50c2013-10-22 12:27:43 +0000684 lldb_private::Module *module)
Sean Callananc3a16002011-01-17 23:42:46 +0000685{
Sean Callananc3a16002011-01-17 23:42:46 +0000686 SymbolContextList sc_list;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000687
Greg Clayton9191db42013-10-21 18:40:51 +0000688 if (module)
689 module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
690 else
691 target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000692
Greg Clayton084db102011-06-23 04:25:29 +0000693 const uint32_t num_matches = sc_list.GetSize();
694 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
695
Sean Callanan947ccc72011-12-01 02:04:16 +0000696 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 +0000697 {
698 SymbolContext sym_ctx;
699 sc_list.GetContextAtIndex(i, sym_ctx);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000700
Greg Clayton358cf1e2015-06-25 21:46:34 +0000701 const Address sym_address = sym_ctx.symbol->GetAddress();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000702
Greg Clayton358cf1e2015-06-25 21:46:34 +0000703 if (!sym_address.IsValid())
Sean Callanan116ace22013-04-30 00:21:42 +0000704 continue;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000705
Greg Clayton358cf1e2015-06-25 21:46:34 +0000706 switch (sym_ctx.symbol->GetType())
Greg Clayton084db102011-06-23 04:25:29 +0000707 {
Greg Clayton358cf1e2015-06-25 21:46:34 +0000708 case eSymbolTypeCode:
709 case eSymbolTypeTrampoline:
710 symbol_load_addr = sym_address.GetCallableLoadAddress (&target);
711 break;
Matt Kopec00049b82013-02-27 20:13:38 +0000712
Greg Clayton358cf1e2015-06-25 21:46:34 +0000713 case eSymbolTypeResolver:
714 symbol_load_addr = sym_address.GetCallableLoadAddress (&target, true);
715 break;
Matt Kopec00049b82013-02-27 20:13:38 +0000716
Greg Clayton358cf1e2015-06-25 21:46:34 +0000717 case eSymbolTypeReExported:
718 {
719 ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
720 if (reexport_name)
Greg Clayton9191db42013-10-21 18:40:51 +0000721 {
Greg Clayton358cf1e2015-06-25 21:46:34 +0000722 ModuleSP reexport_module_sp;
723 ModuleSpec reexport_module_spec;
724 reexport_module_spec.GetPlatformFileSpec() = sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
725 if (reexport_module_spec.GetPlatformFileSpec())
Greg Clayton9191db42013-10-21 18:40:51 +0000726 {
Greg Clayton358cf1e2015-06-25 21:46:34 +0000727 reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
728 if (!reexport_module_sp)
Greg Clayton9191db42013-10-21 18:40:51 +0000729 {
Greg Clayton358cf1e2015-06-25 21:46:34 +0000730 reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
Greg Clayton9191db42013-10-21 18:40:51 +0000731 reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
Greg Clayton9191db42013-10-21 18:40:51 +0000732 }
Greg Clayton9191db42013-10-21 18:40:51 +0000733 }
Greg Clayton358cf1e2015-06-25 21:46:34 +0000734 symbol_load_addr = GetSymbolAddress(target, process, sym_ctx.symbol->GetReExportedSymbolName(), symbol_type, reexport_module_sp.get());
Greg Clayton9191db42013-10-21 18:40:51 +0000735 }
Greg Clayton358cf1e2015-06-25 21:46:34 +0000736 }
737 break;
Greg Clayton9191db42013-10-21 18:40:51 +0000738
Greg Clayton358cf1e2015-06-25 21:46:34 +0000739 case eSymbolTypeData:
740 case eSymbolTypeRuntime:
741 case eSymbolTypeVariable:
742 case eSymbolTypeLocal:
743 case eSymbolTypeParam:
744 case eSymbolTypeInvalid:
745 case eSymbolTypeAbsolute:
746 case eSymbolTypeException:
747 case eSymbolTypeSourceFile:
748 case eSymbolTypeHeaderFile:
749 case eSymbolTypeObjectFile:
750 case eSymbolTypeCommonBlock:
751 case eSymbolTypeBlock:
752 case eSymbolTypeVariableType:
753 case eSymbolTypeLineEntry:
754 case eSymbolTypeLineHeader:
755 case eSymbolTypeScopeBegin:
756 case eSymbolTypeScopeEnd:
757 case eSymbolTypeAdditional:
758 case eSymbolTypeCompiler:
759 case eSymbolTypeInstrumentation:
760 case eSymbolTypeUndefined:
761 case eSymbolTypeObjCClass:
762 case eSymbolTypeObjCMetaClass:
763 case eSymbolTypeObjCIVar:
764 symbol_load_addr = sym_address.GetLoadAddress (&target);
765 break;
Greg Clayton084db102011-06-23 04:25:29 +0000766 }
767 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000768
Sean Callanane0b23b52012-11-15 02:02:04 +0000769 if (symbol_load_addr == LLDB_INVALID_ADDRESS && process)
770 {
771 ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000772
Sean Callanane0b23b52012-11-15 02:02:04 +0000773 if (runtime)
774 {
775 symbol_load_addr = runtime->LookupRuntimeSymbol(name);
776 }
777 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000778
Greg Clayton084db102011-06-23 04:25:29 +0000779 return symbol_load_addr;
Sean Callananc3a16002011-01-17 23:42:46 +0000780}
781
Greg Clayton084db102011-06-23 04:25:29 +0000782addr_t
Sean Callanan947ccc72011-12-01 02:04:16 +0000783ClangExpressionDeclMap::GetSymbolAddress (const ConstString &name, lldb::SymbolType symbol_type)
Sean Callanand9ca42a2011-05-08 02:21:26 +0000784{
785 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000786
Sean Callanan933693b2012-02-10 01:22:05 +0000787 if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
Sean Callanand9ca42a2011-05-08 02:21:26 +0000788 return false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000789
Sean Callanane0b23b52012-11-15 02:02:04 +0000790 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 +0000791}
792
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000793const Symbol *
794ClangExpressionDeclMap::FindGlobalDataSymbol (Target &target,
Greg Clayton9191db42013-10-21 18:40:51 +0000795 const ConstString &name,
Deepak Panickald66b50c2013-10-22 12:27:43 +0000796 lldb_private::Module *module)
Sean Callanand9ca42a2011-05-08 02:21:26 +0000797{
798 SymbolContextList sc_list;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000799
Greg Clayton9191db42013-10-21 18:40:51 +0000800 if (module)
801 module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
802 else
803 target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000804
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000805 const uint32_t matches = sc_list.GetSize();
806 for (uint32_t i=0; i<matches; ++i)
Sean Callanand9ca42a2011-05-08 02:21:26 +0000807 {
808 SymbolContext sym_ctx;
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000809 sc_list.GetContextAtIndex(i, sym_ctx);
810 if (sym_ctx.symbol)
811 {
812 const Symbol *symbol = sym_ctx.symbol;
Greg Clayton358cf1e2015-06-25 21:46:34 +0000813 const Address sym_address = symbol->GetAddress();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000814
Greg Clayton358cf1e2015-06-25 21:46:34 +0000815 if (sym_address.IsValid())
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000816 {
817 switch (symbol->GetType())
818 {
819 case eSymbolTypeData:
820 case eSymbolTypeRuntime:
821 case eSymbolTypeAbsolute:
822 case eSymbolTypeObjCClass:
823 case eSymbolTypeObjCMetaClass:
824 case eSymbolTypeObjCIVar:
825 if (symbol->GetDemangledNameIsSynthesized())
826 {
827 // If the demangled name was synthesized, then don't use it
828 // for expressions. Only let the symbol match if the mangled
829 // named matches for these symbols.
830 if (symbol->GetMangled().GetMangledName() != name)
831 break;
832 }
833 return symbol;
834
Greg Clayton9191db42013-10-21 18:40:51 +0000835 case eSymbolTypeReExported:
836 {
837 ConstString reexport_name = symbol->GetReExportedSymbolName();
838 if (reexport_name)
839 {
840 ModuleSP reexport_module_sp;
841 ModuleSpec reexport_module_spec;
842 reexport_module_spec.GetPlatformFileSpec() = symbol->GetReExportedSymbolSharedLibrary();
843 if (reexport_module_spec.GetPlatformFileSpec())
844 {
845 reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
846 if (!reexport_module_sp)
847 {
848 reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
849 reexport_module_sp = target.GetImages().FindFirstModule(reexport_module_spec);
850 }
851 }
Greg Clayton67d49482015-05-15 21:27:16 +0000852 // Don't allow us to try and resolve a re-exported symbol if it is the same
853 // as the current symbol
854 if (name == symbol->GetReExportedSymbolName() && module == reexport_module_sp.get())
855 return NULL;
856
Greg Clayton9191db42013-10-21 18:40:51 +0000857 return FindGlobalDataSymbol(target, symbol->GetReExportedSymbolName(), reexport_module_sp.get());
858 }
859 }
860 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000861
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000862 case eSymbolTypeCode: // We already lookup functions elsewhere
863 case eSymbolTypeVariable:
864 case eSymbolTypeLocal:
865 case eSymbolTypeParam:
866 case eSymbolTypeTrampoline:
867 case eSymbolTypeInvalid:
868 case eSymbolTypeException:
869 case eSymbolTypeSourceFile:
870 case eSymbolTypeHeaderFile:
871 case eSymbolTypeObjectFile:
872 case eSymbolTypeCommonBlock:
873 case eSymbolTypeBlock:
874 case eSymbolTypeVariableType:
875 case eSymbolTypeLineEntry:
876 case eSymbolTypeLineHeader:
877 case eSymbolTypeScopeBegin:
878 case eSymbolTypeScopeEnd:
879 case eSymbolTypeAdditional:
880 case eSymbolTypeCompiler:
881 case eSymbolTypeInstrumentation:
882 case eSymbolTypeUndefined:
Matt Kopec00049b82013-02-27 20:13:38 +0000883 case eSymbolTypeResolver:
Greg Clayton3d51b9f2012-11-27 01:52:16 +0000884 break;
885 }
886 }
887 }
Sean Callanand9ca42a2011-05-08 02:21:26 +0000888 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000889
Sean Callanand9ca42a2011-05-08 02:21:26 +0000890 return NULL;
891}
892
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000893lldb::VariableSP
894ClangExpressionDeclMap::FindGlobalVariable
895(
896 Target &target,
Sean Callanan1fd3f4f2011-10-12 16:59:31 +0000897 ModuleSP &module,
898 const ConstString &name,
Greg Clayton99558cc42015-08-24 23:46:31 +0000899 CompilerDeclContext *namespace_decl,
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000900 TypeFromUser *type
901)
902{
903 VariableList vars;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000904
Sean Callanan1fd3f4f2011-10-12 16:59:31 +0000905 if (module && namespace_decl)
906 module->FindGlobalVariables (name, namespace_decl, true, -1, vars);
907 else
908 target.GetImages().FindGlobalVariables(name, true, -1, vars);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000909
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000910 if (vars.GetSize())
911 {
912 if (type)
913 {
914 for (size_t i = 0; i < vars.GetSize(); ++i)
915 {
916 VariableSP var_sp = vars.GetVariableAtIndex(i);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000917
Greg Clayton99558cc42015-08-24 23:46:31 +0000918 if (ClangASTContext::AreTypesSame(*type, var_sp->GetType()->GetFullCompilerType ()))
Greg Clayton57ee3062013-07-11 22:46:58 +0000919 return var_sp;
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000920 }
921 }
922 else
923 {
924 return vars.GetVariableAtIndex(0);
925 }
926 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000927
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000928 return VariableSP();
929}
930
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000931// Interface for ClangASTSource
Sean Callanan3bfdaa22011-09-15 02:13:07 +0000932
Sean Callanan503aa522011-10-12 00:12:34 +0000933void
Sean Callananeddeb3b2011-10-28 23:38:38 +0000934ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000935{
Sean Callananeddeb3b2011-10-28 23:38:38 +0000936 assert (m_ast_context);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000937
Sean Callanan8106d802013-03-08 20:04:57 +0000938 ClangASTMetrics::RegisterVisibleQuery();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000939
Sean Callananeddeb3b2011-10-28 23:38:38 +0000940 const ConstString name(context.m_decl_name.getAsString().c_str());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000941
Greg Clayton5160ce52013-03-27 23:08:40 +0000942 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000943
Sean Callananfb3e4302011-10-29 19:50:43 +0000944 if (GetImportInProgress())
Sean Callanan6abfabf2010-11-19 20:20:02 +0000945 {
Sean Callanan7dd98122011-10-14 20:34:21 +0000946 if (log && log->GetVerbose())
Sean Callanan6abfabf2010-11-19 20:20:02 +0000947 log->Printf("Ignoring a query during an import");
948 return;
949 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000950
Sean Callanan7dd98122011-10-14 20:34:21 +0000951 static unsigned int invocation_id = 0;
952 unsigned int current_id = invocation_id++;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000953
Sean Callanan503aa522011-10-12 00:12:34 +0000954 if (log)
955 {
956 if (!context.m_decl_context)
Sean Callananfb3e4302011-10-29 19:50:43 +0000957 log->Printf("ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for '%s' in a NULL DeclContext", current_id, name.GetCString());
Sean Callanan503aa522011-10-12 00:12:34 +0000958 else if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context.m_decl_context))
Sean Callananfb3e4302011-10-29 19:50:43 +0000959 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 +0000960 else
Sean Callananfb3e4302011-10-29 19:50:43 +0000961 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 +0000962 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000963
Sean Callanan503aa522011-10-12 00:12:34 +0000964 if (const NamespaceDecl *namespace_context = dyn_cast<NamespaceDecl>(context.m_decl_context))
965 {
Sean Callanan1ee44b72011-10-29 01:58:46 +0000966 ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer->GetNamespaceMap(namespace_context);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000967
Sean Callanan7dd98122011-10-14 20:34:21 +0000968 if (log && log->GetVerbose())
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +0000969 log->Printf(" CEDM::FEVD[%u] Inspecting (NamespaceMap*)%p (%d entries)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000970 current_id, static_cast<void*>(namespace_map.get()),
Sean Callanan7dd98122011-10-14 20:34:21 +0000971 (int)namespace_map->size());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000972
Sean Callananb2269162011-10-21 22:18:07 +0000973 if (!namespace_map)
974 return;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000975
Sean Callanan503aa522011-10-12 00:12:34 +0000976 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end();
977 i != e;
978 ++i)
979 {
980 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +0000981 log->Printf(" CEDM::FEVD[%u] Searching namespace %s in module %s",
Sean Callanan7dd98122011-10-14 20:34:21 +0000982 current_id,
Greg Clayton99558cc42015-08-24 23:46:31 +0000983 i->second.GetName().AsCString(),
Sean Callanan503aa522011-10-12 00:12:34 +0000984 i->first->GetFileSpec().GetFilename().GetCString());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000985
Sean Callananebe60672011-10-13 21:50:33 +0000986 FindExternalVisibleDecls(context,
987 i->first,
988 i->second,
Sean Callanan7dd98122011-10-14 20:34:21 +0000989 current_id);
Sean Callanan503aa522011-10-12 00:12:34 +0000990 }
991 }
Sean Callanand5c17ed2011-11-15 02:11:17 +0000992 else if (isa<TranslationUnitDecl>(context.m_decl_context))
Sean Callanan503aa522011-10-12 00:12:34 +0000993 {
Greg Clayton99558cc42015-08-24 23:46:31 +0000994 CompilerDeclContext namespace_decl;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000995
Sean Callanan503aa522011-10-12 00:12:34 +0000996 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +0000997 log->Printf(" CEDM::FEVD[%u] Searching the root namespace", current_id);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000998
Sean Callanan503aa522011-10-12 00:12:34 +0000999 FindExternalVisibleDecls(context,
1000 lldb::ModuleSP(),
1001 namespace_decl,
Sean Callanan7dd98122011-10-14 20:34:21 +00001002 current_id);
Sean Callanan503aa522011-10-12 00:12:34 +00001003 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001004
Sean Callananfb3e4302011-10-29 19:50:43 +00001005 if (!context.m_found.variable)
1006 ClangASTSource::FindExternalVisibleDecls(context);
Sean Callanan503aa522011-10-12 00:12:34 +00001007}
1008
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001009void
1010ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
Sean Callanan1a2c5382011-10-12 18:44:30 +00001011 lldb::ModuleSP module_sp,
Greg Clayton99558cc42015-08-24 23:46:31 +00001012 CompilerDeclContext &namespace_decl,
Sean Callanan7dd98122011-10-14 20:34:21 +00001013 unsigned int current_id)
Sean Callanan503aa522011-10-12 00:12:34 +00001014{
Sean Callananeddeb3b2011-10-28 23:38:38 +00001015 assert (m_ast_context);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001016
Greg Clayton5160ce52013-03-27 23:08:40 +00001017 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001018
Greg Clayton7a345282010-11-09 23:46:37 +00001019 SymbolContextList sc_list;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001020
Sean Callananfb3e4302011-10-29 19:50:43 +00001021 const ConstString name(context.m_decl_name.getAsString().c_str());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001022
Greg Clayton83c5cd92010-11-14 22:13:40 +00001023 const char *name_unique_cstr = name.GetCString();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001024
Greg Clayton83c5cd92010-11-14 22:13:40 +00001025 if (name_unique_cstr == NULL)
1026 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001027
Sean Callanan5b26f272012-02-04 08:49:35 +00001028 static ConstString id_name("id");
1029 static ConstString Class_name("Class");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001030
Sean Callanan5b26f272012-02-04 08:49:35 +00001031 if (name == id_name || name == Class_name)
1032 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001033
1034 // Only look for functions by name out in our symbols if the function
Greg Clayton7b462cc2010-10-15 22:48:33 +00001035 // doesn't start with our phony prefix of '$'
Sean Callanan933693b2012-02-10 01:22:05 +00001036 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Jason Molendab57e4a12013-11-04 09:33:30 +00001037 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
Sean Callanan88972242011-10-12 01:39:28 +00001038 if (name_unique_cstr[0] == '$' && !namespace_decl)
1039 {
1040 static ConstString g_lldb_class_name ("$__lldb_class");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001041
Sean Callanan88972242011-10-12 01:39:28 +00001042 if (name == g_lldb_class_name)
1043 {
1044 // Clang is looking for the type of "this"
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001045
Sean Callananc03bdd92012-02-08 03:45:08 +00001046 if (frame == NULL)
Sean Callanan88972242011-10-12 01:39:28 +00001047 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001048
Greg Clayton99558cc42015-08-24 23:46:31 +00001049 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001050
Greg Clayton99558cc42015-08-24 23:46:31 +00001051 // Find the block that defines the function represented by "sym_ctx"
Greg Clayton685c88c2012-07-14 00:53:55 +00001052 Block *function_block = sym_ctx.GetFunctionBlock();
1053
1054 if (!function_block)
1055 return;
1056
Greg Clayton99558cc42015-08-24 23:46:31 +00001057 CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001058
Greg Clayton99558cc42015-08-24 23:46:31 +00001059 if (!function_decl_ctx)
Sean Callanan88972242011-10-12 01:39:28 +00001060 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001061
Greg Clayton99558cc42015-08-24 23:46:31 +00001062 clang::CXXMethodDecl *method_decl = ClangASTContext::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001063
Jim Ingham5fdeed42012-10-30 23:35:54 +00001064 if (method_decl)
Sean Callanan88972242011-10-12 01:39:28 +00001065 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00001066 clang::CXXRecordDecl *class_decl = method_decl->getParent();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001067
Jim Ingham5fdeed42012-10-30 23:35:54 +00001068 QualType class_qual_type(class_decl->getTypeForDecl(), 0);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001069
Jim Ingham5fdeed42012-10-30 23:35:54 +00001070 TypeFromUser class_user_type (class_qual_type.getAsOpaquePtr(),
Greg Claytond8d4a572015-08-11 21:38:15 +00001071 ClangASTContext::GetASTContext(&class_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001072
Jim Ingham5fdeed42012-10-30 23:35:54 +00001073 if (log)
1074 {
1075 ASTDumper ast_dumper(class_qual_type);
1076 log->Printf(" CEDM::FEVD[%u] Adding type for $__lldb_class: %s", current_id, ast_dumper.GetCString());
1077 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001078
Sean Callananfa4fab72013-02-01 06:55:48 +00001079 TypeFromParser class_type = CopyClassType(class_user_type, current_id);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001080
Sean Callananfa4fab72013-02-01 06:55:48 +00001081 if (!class_type.IsValid())
1082 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001083
Sean Callanan34cf8202013-03-12 21:22:00 +00001084 TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(QualType::getFromOpaquePtr(class_type.GetOpaqueQualType()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001085
Sean Callananfa4fab72013-02-01 06:55:48 +00001086 if (!type_source_info)
1087 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001088
Sean Callananfa4fab72013-02-01 06:55:48 +00001089 TypedefDecl *typedef_decl = TypedefDecl::Create(*m_ast_context,
1090 m_ast_context->getTranslationUnitDecl(),
1091 SourceLocation(),
1092 SourceLocation(),
1093 context.m_decl_name.getAsIdentifierInfo(),
1094 type_source_info);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001095
1096
Sean Callananfa4fab72013-02-01 06:55:48 +00001097 if (!typedef_decl)
1098 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001099
Sean Callananfa4fab72013-02-01 06:55:48 +00001100 context.AddNamedDecl(typedef_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001101
Jim Ingham5fdeed42012-10-30 23:35:54 +00001102 if (method_decl->isInstance())
1103 {
1104 // self is a pointer to the object
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001105
Jim Ingham5fdeed42012-10-30 23:35:54 +00001106 QualType class_pointer_type = method_decl->getASTContext().getPointerType(class_qual_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001107
Jim Ingham5fdeed42012-10-30 23:35:54 +00001108 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
Greg Claytond8d4a572015-08-11 21:38:15 +00001109 ClangASTContext::GetASTContext(&method_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001110
Jim Ingham5fdeed42012-10-30 23:35:54 +00001111 m_struct_vars->m_object_pointer_type = self_user_type;
1112 }
Sean Callanan88972242011-10-12 01:39:28 +00001113 }
Jim Ingham5fdeed42012-10-30 23:35:54 +00001114 else
Sean Callananbb6e7ed2012-03-05 22:08:20 +00001115 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00001116 // This branch will get hit if we are executing code in the context of a function that
1117 // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
Bruce Mitchener58ef3912015-06-18 05:27:05 +00001118 // method of the class. In that case, just look up the "this" variable in the current
Jim Ingham5fdeed42012-10-30 23:35:54 +00001119 // scope and use its type.
1120 // FIXME: This code is formally correct, but clang doesn't currently emit DW_AT_object_pointer
1121 // for C++ so it hasn't actually been tested.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001122
Jim Ingham5fdeed42012-10-30 23:35:54 +00001123 VariableList *vars = frame->GetVariableList(false);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001124
Jim Ingham5fdeed42012-10-30 23:35:54 +00001125 lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001126
Jim Ingham5fdeed42012-10-30 23:35:54 +00001127 if (this_var &&
1128 this_var->IsInScope(frame) &&
1129 this_var->LocationIsValidForFrame (frame))
1130 {
1131 Type *this_type = this_var->GetType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001132
Jim Ingham5fdeed42012-10-30 23:35:54 +00001133 if (!this_type)
1134 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001135
Greg Clayton99558cc42015-08-24 23:46:31 +00001136 CompilerType pointee_type = this_type->GetForwardCompilerType ().GetPointeeType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001137
Greg Clayton57ee3062013-07-11 22:46:58 +00001138 if (pointee_type.IsValid())
Jim Ingham5fdeed42012-10-30 23:35:54 +00001139 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00001140 if (log)
1141 {
Greg Clayton99558cc42015-08-24 23:46:31 +00001142 ASTDumper ast_dumper(this_type->GetFullCompilerType ());
Jim Ingham5fdeed42012-10-30 23:35:54 +00001143 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
1144 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001145
Greg Clayton57ee3062013-07-11 22:46:58 +00001146 TypeFromUser class_user_type(pointee_type);
Sean Callananfa4fab72013-02-01 06:55:48 +00001147 AddOneType(context, class_user_type, current_id);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001148
1149
Greg Clayton99558cc42015-08-24 23:46:31 +00001150 TypeFromUser this_user_type(this_type->GetFullCompilerType ());
Jim Ingham5fdeed42012-10-30 23:35:54 +00001151 m_struct_vars->m_object_pointer_type = this_user_type;
1152 return;
1153 }
1154 }
Sean Callananbb6e7ed2012-03-05 22:08:20 +00001155 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001156
Sean Callanan88972242011-10-12 01:39:28 +00001157 return;
1158 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001159
Sean Callanan88972242011-10-12 01:39:28 +00001160 static ConstString g_lldb_objc_class_name ("$__lldb_objc_class");
1161 if (name == g_lldb_objc_class_name)
1162 {
1163 // Clang is looking for the type of "*self"
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001164
Sean Callanan88972242011-10-12 01:39:28 +00001165 if (!frame)
1166 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001167
Greg Clayton99558cc42015-08-24 23:46:31 +00001168 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction|lldb::eSymbolContextBlock);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001169
Greg Clayton99558cc42015-08-24 23:46:31 +00001170 // Find the block that defines the function represented by "sym_ctx"
Greg Clayton685c88c2012-07-14 00:53:55 +00001171 Block *function_block = sym_ctx.GetFunctionBlock();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001172
Greg Clayton685c88c2012-07-14 00:53:55 +00001173 if (!function_block)
1174 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001175
Greg Clayton99558cc42015-08-24 23:46:31 +00001176 CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001177
Greg Clayton99558cc42015-08-24 23:46:31 +00001178 if (!function_decl_ctx)
Sean Callanand5c17ed2011-11-15 02:11:17 +00001179 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001180
Greg Clayton99558cc42015-08-24 23:46:31 +00001181 clang::ObjCMethodDecl *method_decl = ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001182
Jim Ingham5fdeed42012-10-30 23:35:54 +00001183 if (method_decl)
Sean Callanand5c17ed2011-11-15 02:11:17 +00001184 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00001185 ObjCInterfaceDecl* self_interface = method_decl->getClassInterface();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001186
Jim Ingham5fdeed42012-10-30 23:35:54 +00001187 if (!self_interface)
Sean Callananc03bdd92012-02-08 03:45:08 +00001188 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001189
Jim Ingham5fdeed42012-10-30 23:35:54 +00001190 const clang::Type *interface_type = self_interface->getTypeForDecl();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001191
Sean Callanandfb87d62013-04-09 21:30:48 +00001192 if (!interface_type)
1193 return; // This is unlikely, but we have seen crashes where this occurred
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001194
Jim Ingham5fdeed42012-10-30 23:35:54 +00001195 TypeFromUser class_user_type(QualType(interface_type, 0).getAsOpaquePtr(),
Greg Claytond8d4a572015-08-11 21:38:15 +00001196 ClangASTContext::GetASTContext(&method_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001197
Jim Ingham5fdeed42012-10-30 23:35:54 +00001198 if (log)
1199 {
1200 ASTDumper ast_dumper(interface_type);
1201 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
1202 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001203
Sean Callananfa4fab72013-02-01 06:55:48 +00001204 AddOneType(context, class_user_type, current_id);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001205
Jim Ingham5fdeed42012-10-30 23:35:54 +00001206 if (method_decl->isInstanceMethod())
1207 {
1208 // self is a pointer to the object
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001209
Jim Ingham5fdeed42012-10-30 23:35:54 +00001210 QualType class_pointer_type = method_decl->getASTContext().getObjCObjectPointerType(QualType(interface_type, 0));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001211
Jim Ingham5fdeed42012-10-30 23:35:54 +00001212 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
Greg Claytond8d4a572015-08-11 21:38:15 +00001213 ClangASTContext::GetASTContext(&method_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001214
Jim Ingham5fdeed42012-10-30 23:35:54 +00001215 m_struct_vars->m_object_pointer_type = self_user_type;
1216 }
1217 else
1218 {
1219 // self is a Class pointer
1220 QualType class_type = method_decl->getASTContext().getObjCClassType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001221
Jim Ingham5fdeed42012-10-30 23:35:54 +00001222 TypeFromUser self_user_type(class_type.getAsOpaquePtr(),
Greg Claytond8d4a572015-08-11 21:38:15 +00001223 ClangASTContext::GetASTContext(&method_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001224
Jim Ingham5fdeed42012-10-30 23:35:54 +00001225 m_struct_vars->m_object_pointer_type = self_user_type;
1226 }
1227
1228 return;
Sean Callananc03bdd92012-02-08 03:45:08 +00001229 }
1230 else
1231 {
Jim Ingham5fdeed42012-10-30 23:35:54 +00001232 // This branch will get hit if we are executing code in the context of a function that
1233 // claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
Bruce Mitchener58ef3912015-06-18 05:27:05 +00001234 // method of the class. In that case, just look up the "self" variable in the current
Jim Ingham5fdeed42012-10-30 23:35:54 +00001235 // scope and use its type.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001236
Jim Ingham5fdeed42012-10-30 23:35:54 +00001237 VariableList *vars = frame->GetVariableList(false);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001238
Jim Ingham5fdeed42012-10-30 23:35:54 +00001239 lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001240
Jim Ingham5fdeed42012-10-30 23:35:54 +00001241 if (self_var &&
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001242 self_var->IsInScope(frame) &&
Jim Ingham5fdeed42012-10-30 23:35:54 +00001243 self_var->LocationIsValidForFrame (frame))
1244 {
1245 Type *self_type = self_var->GetType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001246
Jim Ingham5fdeed42012-10-30 23:35:54 +00001247 if (!self_type)
1248 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001249
Greg Clayton99558cc42015-08-24 23:46:31 +00001250 CompilerType self_clang_type = self_type->GetFullCompilerType ();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001251
Greg Claytond8d4a572015-08-11 21:38:15 +00001252 if (ClangASTContext::IsObjCClassType(self_clang_type))
Jim Ingham5fdeed42012-10-30 23:35:54 +00001253 {
Sean Callanana2868d42013-01-19 01:49:02 +00001254 return;
1255 }
Greg Claytond8d4a572015-08-11 21:38:15 +00001256 else if (ClangASTContext::IsObjCObjectPointerType(self_clang_type))
Sean Callanana2868d42013-01-19 01:49:02 +00001257 {
Greg Clayton57ee3062013-07-11 22:46:58 +00001258 self_clang_type = self_clang_type.GetPointeeType();
1259
1260 if (!self_clang_type)
Sean Callanane5270592013-04-26 22:54:19 +00001261 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001262
Jim Ingham5fdeed42012-10-30 23:35:54 +00001263 if (log)
1264 {
Greg Clayton99558cc42015-08-24 23:46:31 +00001265 ASTDumper ast_dumper(self_type->GetFullCompilerType ());
Jim Ingham5fdeed42012-10-30 23:35:54 +00001266 log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", current_id, ast_dumper.GetCString());
1267 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001268
Greg Clayton57ee3062013-07-11 22:46:58 +00001269 TypeFromUser class_user_type (self_clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001270
Sean Callananfa4fab72013-02-01 06:55:48 +00001271 AddOneType(context, class_user_type, current_id);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001272
Greg Clayton99558cc42015-08-24 23:46:31 +00001273 TypeFromUser self_user_type(self_type->GetFullCompilerType ());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001274
Jim Ingham5fdeed42012-10-30 23:35:54 +00001275 m_struct_vars->m_object_pointer_type = self_user_type;
1276 return;
1277 }
1278 }
Sean Callananc03bdd92012-02-08 03:45:08 +00001279 }
1280
Sean Callanan88972242011-10-12 01:39:28 +00001281 return;
1282 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001283
Sean Callanan88972242011-10-12 01:39:28 +00001284 // any other $__lldb names should be weeded out now
1285 if (!::strncmp(name_unique_cstr, "$__lldb", sizeof("$__lldb") - 1))
1286 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001287
Sean Callanan88972242011-10-12 01:39:28 +00001288 do
1289 {
1290 if (!target)
1291 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001292
Sean Callanan88972242011-10-12 01:39:28 +00001293 ClangASTContext *scratch_clang_ast_context = target->GetScratchClangASTContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001294
Sean Callanan88972242011-10-12 01:39:28 +00001295 if (!scratch_clang_ast_context)
1296 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001297
Sean Callanan88972242011-10-12 01:39:28 +00001298 ASTContext *scratch_ast_context = scratch_clang_ast_context->getASTContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001299
Sean Callanan88972242011-10-12 01:39:28 +00001300 if (!scratch_ast_context)
1301 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001302
Sean Callanan88972242011-10-12 01:39:28 +00001303 TypeDecl *ptype_type_decl = m_parser_vars->m_persistent_vars->GetPersistentType(name);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001304
Sean Callanan88972242011-10-12 01:39:28 +00001305 if (!ptype_type_decl)
1306 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001307
Sean Callanan0eed0d42011-12-06 03:41:14 +00001308 Decl *parser_ptype_decl = m_ast_importer->CopyDecl(m_ast_context, scratch_ast_context, ptype_type_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001309
Sean Callanan88972242011-10-12 01:39:28 +00001310 if (!parser_ptype_decl)
1311 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001312
Sean Callanan88972242011-10-12 01:39:28 +00001313 TypeDecl *parser_ptype_type_decl = dyn_cast<TypeDecl>(parser_ptype_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001314
Sean Callanan88972242011-10-12 01:39:28 +00001315 if (!parser_ptype_type_decl)
1316 break;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001317
Sean Callanan88972242011-10-12 01:39:28 +00001318 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00001319 log->Printf(" CEDM::FEVD[%u] Found persistent type %s", current_id, name.GetCString());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001320
Sean Callanan88972242011-10-12 01:39:28 +00001321 context.AddNamedDecl(parser_ptype_type_decl);
1322 } while (0);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001323
Sean Callananbc8ac342015-09-04 20:49:51 +00001324 ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001325
Sean Callanan88972242011-10-12 01:39:28 +00001326 if (pvar_sp)
1327 {
Sean Callanan7dd98122011-10-14 20:34:21 +00001328 AddOneVariable(context, pvar_sp, current_id);
Sean Callanan88972242011-10-12 01:39:28 +00001329 return;
1330 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001331
Sean Callanan88972242011-10-12 01:39:28 +00001332 const char *reg_name(&name.GetCString()[1]);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001333
Sean Callanan933693b2012-02-10 01:22:05 +00001334 if (m_parser_vars->m_exe_ctx.GetRegisterContext())
Sean Callanan88972242011-10-12 01:39:28 +00001335 {
Sean Callanan933693b2012-02-10 01:22:05 +00001336 const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(reg_name));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001337
Sean Callanan88972242011-10-12 01:39:28 +00001338 if (reg_info)
Sean Callanan35c7f982011-10-18 16:46:55 +00001339 {
1340 if (log)
Sean Callananfb3e4302011-10-29 19:50:43 +00001341 log->Printf(" CEDM::FEVD[%u] Found register %s", current_id, reg_info->name);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001342
Sean Callanan7dd98122011-10-14 20:34:21 +00001343 AddOneRegister(context, reg_info, current_id);
Sean Callanan35c7f982011-10-18 16:46:55 +00001344 }
Sean Callanan88972242011-10-12 01:39:28 +00001345 }
1346 }
1347 else
Sean Callanan8ade1042010-07-27 00:55:47 +00001348 {
Sean Callanan69b53412011-08-06 00:28:14 +00001349 ValueObjectSP valobj;
1350 VariableSP var;
1351 Error err;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001352
Sean Callanan88972242011-10-12 01:39:28 +00001353 if (frame && !namespace_decl)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001354 {
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001355 valobj = frame->GetValueForVariableExpressionPath(name_unique_cstr,
1356 eNoDynamicValues,
Jason Molenda0060a382014-10-16 08:15:11 +00001357 StackFrame::eExpressionPathOptionCheckPtrVsMember |
Jason Molenda0060a382014-10-16 08:15:11 +00001358 StackFrame::eExpressionPathOptionsNoFragileObjcIvar |
1359 StackFrame::eExpressionPathOptionsNoSyntheticChildren |
Jason Molendab57e4a12013-11-04 09:33:30 +00001360 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
Sean Callanan503aa522011-10-12 00:12:34 +00001361 var,
1362 err);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001363
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001364 // If we found a variable in scope, no need to pull up function names
Sean Callanan9a028512012-08-09 00:50:26 +00001365 if (err.Success() && var)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001366 {
Sean Callanan0712f462011-11-29 22:03:21 +00001367 AddOneVariable(context, var, valobj, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00001368 context.m_found.variable = true;
Sean Callananefa7d1f2011-10-25 20:36:57 +00001369 return;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001370 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00001371 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001372
Sean Callananfd1ba912011-12-10 04:03:38 +00001373 if (target)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001374 {
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00001375 var = FindGlobalVariable (*target,
Sean Callanan1a2c5382011-10-12 18:44:30 +00001376 module_sp,
Sean Callanan1fd3f4f2011-10-12 16:59:31 +00001377 name,
1378 &namespace_decl,
Greg Claytonc14ee322011-09-22 04:58:26 +00001379 NULL);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001380
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001381 if (var)
1382 {
Sean Callanan9b3569b2011-12-10 03:12:34 +00001383 valobj = ValueObjectVariable::Create(target, var);
Sean Callanan0712f462011-11-29 22:03:21 +00001384 AddOneVariable(context, var, valobj, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00001385 context.m_found.variable = true;
Sean Callananfd1ba912011-12-10 04:03:38 +00001386 return;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001387 }
1388 }
Sean Callananc8278af2014-12-05 01:27:35 +00001389
1390 std::vector<clang::NamedDecl *> decls_from_modules;
1391
1392 if (target)
1393 {
1394 if (ClangModulesDeclVendor *decl_vendor = target->GetClangModulesDeclVendor())
1395 {
1396 decl_vendor->FindDecls(name, false, UINT32_MAX, decls_from_modules);
1397 }
1398 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001399
Sean Callananca4e0fd2011-10-12 20:29:25 +00001400 if (!context.m_found.variable)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001401 {
Sean Callanan9df05fb2012-02-10 22:52:19 +00001402 const bool include_inlines = false;
Greg Clayton931180e2011-01-27 06:44:37 +00001403 const bool append = false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001404
Sean Callanan1a2c5382011-10-12 18:44:30 +00001405 if (namespace_decl && module_sp)
Sean Callanan25ea08e2011-10-12 17:38:09 +00001406 {
Sean Callanan3ae61792012-02-15 17:14:49 +00001407 const bool include_symbols = false;
1408
Sean Callanan1a2c5382011-10-12 18:44:30 +00001409 module_sp->FindFunctions(name,
1410 &namespace_decl,
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001411 eFunctionNameTypeBase,
Sean Callanan1a2c5382011-10-12 18:44:30 +00001412 include_symbols,
Sean Callanan9df05fb2012-02-10 22:52:19 +00001413 include_inlines,
Sean Callanan1a2c5382011-10-12 18:44:30 +00001414 append,
1415 sc_list);
Sean Callanan25ea08e2011-10-12 17:38:09 +00001416 }
Jim Ingham28eb5712012-10-12 17:34:26 +00001417 else if (target && !namespace_decl)
Sean Callanan25ea08e2011-10-12 17:38:09 +00001418 {
Sean Callanan3ae61792012-02-15 17:14:49 +00001419 const bool include_symbols = true;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001420
Sean Callanan308a3c52012-07-28 00:21:01 +00001421 // TODO Fix FindFunctions so that it doesn't return
1422 // instance methods for eFunctionNameTypeBase.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001423
Sean Callanan25ea08e2011-10-12 17:38:09 +00001424 target->GetImages().FindFunctions(name,
Greg Clayton43fe2172013-04-03 02:00:15 +00001425 eFunctionNameTypeFull,
Sean Callanan25ea08e2011-10-12 17:38:09 +00001426 include_symbols,
Sean Callanan9df05fb2012-02-10 22:52:19 +00001427 include_inlines,
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001428 append,
Sean Callanan25ea08e2011-10-12 17:38:09 +00001429 sc_list);
1430 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001431
Sean Callanand9ca42a2011-05-08 02:21:26 +00001432 if (sc_list.GetSize())
Greg Clayton7b462cc2010-10-15 22:48:33 +00001433 {
Greg Claytondc25a0b2013-10-31 16:59:47 +00001434 Symbol *extern_symbol = NULL;
1435 Symbol *non_extern_symbol = NULL;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001436
Sean Callanand9ca42a2011-05-08 02:21:26 +00001437 for (uint32_t index = 0, num_indices = sc_list.GetSize();
1438 index < num_indices;
1439 ++index)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001440 {
Sean Callanand9ca42a2011-05-08 02:21:26 +00001441 SymbolContext sym_ctx;
1442 sc_list.GetContextAtIndex(index, sym_ctx);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001443
Sean Callanand9ca42a2011-05-08 02:21:26 +00001444 if (sym_ctx.function)
1445 {
Greg Clayton99558cc42015-08-24 23:46:31 +00001446 CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001447
Sean Callanan956dca92013-04-27 01:57:44 +00001448 if (!decl_ctx)
1449 continue;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001450
Sean Callanan308a3c52012-07-28 00:21:01 +00001451 // Filter out class/instance methods.
Greg Clayton99558cc42015-08-24 23:46:31 +00001452 if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
Sean Callanan308a3c52012-07-28 00:21:01 +00001453 continue;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001454
Sean Callanan485f7322013-04-24 00:34:41 +00001455 AddOneFunction(context, sym_ctx.function, NULL, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00001456 context.m_found.function_with_type_info = true;
1457 context.m_found.function = true;
Sean Callanand9ca42a2011-05-08 02:21:26 +00001458 }
1459 else if (sym_ctx.symbol)
1460 {
Greg Claytonfc56a012014-06-13 21:57:58 +00001461 if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target)
Greg Claytondc25a0b2013-10-31 16:59:47 +00001462 {
1463 sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
1464 if (sym_ctx.symbol == NULL)
1465 continue;
1466 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001467
Greg Claytondc25a0b2013-10-31 16:59:47 +00001468 if (sym_ctx.symbol->IsExternal())
1469 extern_symbol = sym_ctx.symbol;
Sean Callanand9ca42a2011-05-08 02:21:26 +00001470 else
Greg Claytondc25a0b2013-10-31 16:59:47 +00001471 non_extern_symbol = sym_ctx.symbol;
Sean Callanand9ca42a2011-05-08 02:21:26 +00001472 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00001473 }
Sean Callananc8278af2014-12-05 01:27:35 +00001474
1475 if (!context.m_found.function_with_type_info)
1476 {
1477 for (clang::NamedDecl *decl : decls_from_modules)
1478 {
1479 if (llvm::isa<clang::FunctionDecl>(decl))
1480 {
1481 clang::NamedDecl *copied_decl = llvm::cast<FunctionDecl>(m_ast_importer->CopyDecl(m_ast_context, &decl->getASTContext(), decl));
1482 context.AddNamedDecl(copied_decl);
1483 context.m_found.function_with_type_info = true;
1484 }
1485 }
1486 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001487
Sean Callananca4e0fd2011-10-12 20:29:25 +00001488 if (!context.m_found.function_with_type_info)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001489 {
Greg Claytondc25a0b2013-10-31 16:59:47 +00001490 if (extern_symbol)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001491 {
Greg Claytondc25a0b2013-10-31 16:59:47 +00001492 AddOneFunction (context, NULL, extern_symbol, current_id);
1493 context.m_found.function = true;
1494 }
1495 else if (non_extern_symbol)
1496 {
1497 AddOneFunction (context, NULL, non_extern_symbol, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00001498 context.m_found.function = true;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001499 }
Sean Callanand9ca42a2011-05-08 02:21:26 +00001500 }
Greg Clayton7b462cc2010-10-15 22:48:33 +00001501 }
Sean Callanan80c97592015-05-01 00:47:29 +00001502
1503 if (!context.m_found.function_with_type_info)
1504 {
1505 // Try the modules next.
1506
1507 do
1508 {
1509 if (ClangModulesDeclVendor *modules_decl_vendor = m_target->GetClangModulesDeclVendor())
1510 {
1511 bool append = false;
1512 uint32_t max_matches = 1;
1513 std::vector <clang::NamedDecl *> decls;
1514
1515 if (!modules_decl_vendor->FindDecls(name,
1516 append,
1517 max_matches,
1518 decls))
1519 break;
1520
1521 clang::NamedDecl *const decl_from_modules = decls[0];
1522
1523 if (llvm::isa<clang::FunctionDecl>(decl_from_modules))
1524 {
1525 if (log)
1526 {
1527 log->Printf(" CAS::FEVD[%u] Matching function found for \"%s\" in the modules",
1528 current_id,
1529 name.GetCString());
1530 }
1531
1532 clang::Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, &decl_from_modules->getASTContext(), decl_from_modules);
1533 clang::FunctionDecl *copied_function_decl = copied_decl ? dyn_cast<clang::FunctionDecl>(copied_decl) : nullptr;
1534
1535 if (!copied_function_decl)
1536 {
1537 if (log)
1538 log->Printf(" CAS::FEVD[%u] - Couldn't export a function declaration from the modules",
1539 current_id);
1540
1541 break;
1542 }
1543
1544 if (copied_function_decl->getBody() && m_parser_vars->m_code_gen)
1545 {
1546 DeclGroupRef decl_group_ref(copied_function_decl);
1547 m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
1548 }
1549
1550 context.AddNamedDecl(copied_function_decl);
1551
1552 context.m_found.function_with_type_info = true;
1553 context.m_found.function = true;
1554 }
Sean Callanan9ff456c2015-07-10 17:34:23 +00001555 else if (llvm::isa<clang::VarDecl>(decl_from_modules))
1556 {
1557 if (log)
1558 {
1559 log->Printf(" CAS::FEVD[%u] Matching variable found for \"%s\" in the modules",
1560 current_id,
1561 name.GetCString());
1562 }
1563
1564 clang::Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, &decl_from_modules->getASTContext(), decl_from_modules);
1565 clang::VarDecl *copied_var_decl = copied_decl ? dyn_cast_or_null<clang::VarDecl>(copied_decl) : nullptr;
1566
1567 if (!copied_var_decl)
1568 {
1569 if (log)
1570 log->Printf(" CAS::FEVD[%u] - Couldn't export a variable declaration from the modules",
1571 current_id);
1572
1573 break;
1574 }
1575
1576 context.AddNamedDecl(copied_var_decl);
1577
1578 context.m_found.variable = true;
1579 }
Sean Callanan80c97592015-05-01 00:47:29 +00001580 }
1581 } while (0);
1582 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001583
Jim Ingham5c42d8a2013-05-15 18:27:08 +00001584 if (target && !context.m_found.variable && !namespace_decl)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001585 {
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001586 // We couldn't find a non-symbol variable for this. Now we'll hunt for a generic
Sean Callanand9ca42a2011-05-08 02:21:26 +00001587 // data symbol, and -- if it is found -- treat it as a variable.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001588
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001589 const Symbol *data_symbol = FindGlobalDataSymbol(*target, name);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001590
Sean Callanand9ca42a2011-05-08 02:21:26 +00001591 if (data_symbol)
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001592 {
Sean Callanan92cdbc82014-02-19 23:37:25 +00001593 std::string warning("got name from symbols: ");
1594 warning.append(name.AsCString());
1595 const unsigned diag_id = m_ast_context->getDiagnostics().getCustomDiagID(clang::DiagnosticsEngine::Level::Warning, "%0");
1596 m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
Sean Callanan7dd98122011-10-14 20:34:21 +00001597 AddOneGenericVariable(context, *data_symbol, current_id);
Sean Callananca4e0fd2011-10-12 20:29:25 +00001598 context.m_found.variable = true;
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001599 }
Greg Clayton526e5af2010-11-13 03:52:47 +00001600 }
Sean Callanan3883b5a2010-09-07 21:49:41 +00001601 }
Sean Callananfb40b0d2011-10-27 02:06:03 +00001602 }
Sean Callanan6b4067c2010-07-17 00:43:37 +00001603}
Greg Claytona2721472011-06-25 00:44:06 +00001604
Saleem Abdulrasoola68f7b62014-03-20 06:08:36 +00001605//static clang_type_t
1606//MaybePromoteToBlockPointerType
1607//(
1608// ASTContext *ast_context,
1609// clang_type_t candidate_type
1610//)
1611//{
1612// if (!candidate_type)
1613// return candidate_type;
1614//
1615// QualType candidate_qual_type = QualType::getFromOpaquePtr(candidate_type);
1616//
1617// const PointerType *candidate_pointer_type = dyn_cast<PointerType>(candidate_qual_type);
1618//
1619// if (!candidate_pointer_type)
1620// return candidate_type;
1621//
1622// QualType pointee_qual_type = candidate_pointer_type->getPointeeType();
1623//
1624// const RecordType *pointee_record_type = dyn_cast<RecordType>(pointee_qual_type);
1625//
1626// if (!pointee_record_type)
1627// return candidate_type;
1628//
1629// RecordDecl *pointee_record_decl = pointee_record_type->getDecl();
1630//
1631// if (!pointee_record_decl->isRecord())
1632// return candidate_type;
1633//
1634// if (!pointee_record_decl->getName().startswith(llvm::StringRef("__block_literal_")))
1635// return candidate_type;
1636//
1637// QualType generic_function_type = ast_context->getFunctionNoProtoType(ast_context->UnknownAnyTy);
1638// QualType block_pointer_type = ast_context->getBlockPointerType(generic_function_type);
1639//
1640// return block_pointer_type.getAsOpaquePtr();
1641//}
Sean Callanan75383bf2012-03-06 21:56:33 +00001642
Greg Clayton57ee3062013-07-11 22:46:58 +00001643bool
1644ClangExpressionDeclMap::GetVariableValue (VariableSP &var,
1645 lldb_private::Value &var_location,
1646 TypeFromUser *user_type,
1647 TypeFromParser *parser_type)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001648{
Greg Clayton5160ce52013-03-27 23:08:40 +00001649 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001650
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001651 Type *var_type = var->GetType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001652
1653 if (!var_type)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001654 {
Sean Callananea22d422010-07-16 00:09:46 +00001655 if (log)
1656 log->PutCString("Skipped a definition because it has no type");
Greg Clayton57ee3062013-07-11 22:46:58 +00001657 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001658 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001659
Greg Clayton99558cc42015-08-24 23:46:31 +00001660 CompilerType var_clang_type = var_type->GetFullCompilerType ();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001661
Greg Clayton57ee3062013-07-11 22:46:58 +00001662 if (!var_clang_type)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001663 {
Sean Callananea22d422010-07-16 00:09:46 +00001664 if (log)
1665 log->PutCString("Skipped a definition because it has no Clang type");
Greg Clayton57ee3062013-07-11 22:46:58 +00001666 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001667 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001668
Sean Callanancc427fa2011-07-30 02:42:06 +00001669 ASTContext *ast = var_type->GetClangASTContext().getASTContext();
Greg Clayton57ee3062013-07-11 22:46:58 +00001670
Greg Clayton6beaaa62011-01-17 03:46:26 +00001671 if (!ast)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001672 {
Sean Callananea22d422010-07-16 00:09:46 +00001673 if (log)
1674 log->PutCString("There is no AST context for the current execution context");
Greg Clayton57ee3062013-07-11 22:46:58 +00001675 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001676 }
Greg Clayton57ee3062013-07-11 22:46:58 +00001677 //var_clang_type = MaybePromoteToBlockPointerType (ast, var_clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001678
Sean Callanan6b4067c2010-07-17 00:43:37 +00001679 DWARFExpression &var_location_expr = var->LocationExpression();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001680
Sean Callanan933693b2012-02-10 01:22:05 +00001681 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001682 Error err;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001683
Sean Callanan7b5805d2013-01-18 21:20:51 +00001684 if (var->GetLocationIsConstantValueData())
1685 {
1686 DataExtractor const_value_extractor;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001687
Sean Callanan7b5805d2013-01-18 21:20:51 +00001688 if (var_location_expr.GetExpressionData(const_value_extractor))
1689 {
Greg Clayton57ee3062013-07-11 22:46:58 +00001690 var_location = Value(const_value_extractor.GetDataStart(), const_value_extractor.GetByteSize());
1691 var_location.SetValueType(Value::eValueTypeHostAddress);
Sean Callanan7b5805d2013-01-18 21:20:51 +00001692 }
1693 else
1694 {
1695 if (log)
1696 log->Printf("Error evaluating constant variable: %s", err.AsCString());
Greg Clayton57ee3062013-07-11 22:46:58 +00001697 return false;
Sean Callanan7b5805d2013-01-18 21:20:51 +00001698 }
1699 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001700
Greg Claytona1e5dc82015-08-11 22:53:00 +00001701 CompilerType type_to_use = GuardedCopyType(var_clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001702
Greg Clayton57ee3062013-07-11 22:46:58 +00001703 if (!type_to_use)
Sean Callanan1d180662010-07-20 23:31:16 +00001704 {
Greg Clayton57ee3062013-07-11 22:46:58 +00001705 if (log)
1706 log->Printf("Couldn't copy a variable's type into the parser's AST context");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001707
Greg Clayton57ee3062013-07-11 22:46:58 +00001708 return false;
Sean Callanan1d180662010-07-20 23:31:16 +00001709 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001710
Greg Clayton57ee3062013-07-11 22:46:58 +00001711 if (parser_type)
1712 *parser_type = TypeFromParser(type_to_use);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001713
Greg Clayton57ee3062013-07-11 22:46:58 +00001714 if (var_location.GetContextType() == Value::eContextTypeInvalid)
Greg Clayton99558cc42015-08-24 23:46:31 +00001715 var_location.SetCompilerType(type_to_use);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001716
Greg Clayton57ee3062013-07-11 22:46:58 +00001717 if (var_location.GetValueType() == Value::eValueTypeFileAddress)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001718 {
1719 SymbolContext var_sc;
1720 var->CalculateSymbolContext(&var_sc);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001721
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001722 if (!var_sc.module_sp)
Michael Sartain89c862f2013-08-07 19:05:15 +00001723 return false;
Greg Clayton3046e662013-07-10 01:23:25 +00001724
Greg Clayton57ee3062013-07-11 22:46:58 +00001725 Address so_addr(var_location.GetScalar().ULongLong(), var_sc.module_sp->GetSectionList());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001726
Greg Claytonc14ee322011-09-22 04:58:26 +00001727 lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001728
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001729 if (load_addr != LLDB_INVALID_ADDRESS)
1730 {
Greg Clayton57ee3062013-07-11 22:46:58 +00001731 var_location.GetScalar() = load_addr;
1732 var_location.SetValueType(Value::eValueTypeLoadAddress);
Sean Callanan3bfdaa22011-09-15 02:13:07 +00001733 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001734 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001735
Sean Callanan1d180662010-07-20 23:31:16 +00001736 if (user_type)
Greg Clayton57ee3062013-07-11 22:46:58 +00001737 *user_type = TypeFromUser(var_clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001738
Greg Clayton57ee3062013-07-11 22:46:58 +00001739 return true;
Sean Callanan6b4067c2010-07-17 00:43:37 +00001740}
1741
1742void
Sean Callanan0712f462011-11-29 22:03:21 +00001743ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP var, ValueObjectSP valobj, unsigned int current_id)
Sean Callanan6b4067c2010-07-17 00:43:37 +00001744{
Sean Callanan979f74d2010-12-03 01:38:59 +00001745 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001746
Greg Clayton5160ce52013-03-27 23:08:40 +00001747 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001748
Sean Callanan1d180662010-07-20 23:31:16 +00001749 TypeFromUser ut;
1750 TypeFromParser pt;
Greg Clayton57ee3062013-07-11 22:46:58 +00001751 Value var_location;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001752
Greg Clayton57ee3062013-07-11 22:46:58 +00001753 if (!GetVariableValue (var, var_location, &ut, &pt))
1754 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001755
Sean Callanancf128622012-03-15 01:53:17 +00001756 clang::QualType parser_opaque_type = QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001757
Sean Callanane2d47482012-03-21 17:13:20 +00001758 if (parser_opaque_type.isNull())
1759 return;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001760
Sean Callanancf128622012-03-15 01:53:17 +00001761 if (const clang::Type *parser_type = parser_opaque_type.getTypePtr())
1762 {
1763 if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
1764 CompleteType(tag_type->getDecl());
Sean Callananf4c0a222013-12-20 04:09:05 +00001765 if (const ObjCObjectPointerType *objc_object_ptr_type = dyn_cast<ObjCObjectPointerType>(parser_type))
1766 CompleteType(objc_object_ptr_type->getInterfaceDecl());
Sean Callanancf128622012-03-15 01:53:17 +00001767 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001768
1769
Greg Clayton57ee3062013-07-11 22:46:58 +00001770 bool is_reference = pt.IsReferenceType();
Sean Callanan98298012011-10-27 19:41:13 +00001771
Greg Clayton57ee3062013-07-11 22:46:58 +00001772 NamedDecl *var_decl = NULL;
Sean Callanan98298012011-10-27 19:41:13 +00001773 if (is_reference)
Greg Clayton57ee3062013-07-11 22:46:58 +00001774 var_decl = context.AddVarDecl(pt);
Sean Callanan98298012011-10-27 19:41:13 +00001775 else
Greg Claytond8d4a572015-08-11 21:38:15 +00001776 var_decl = context.AddVarDecl(ClangASTContext::GetLValueReferenceType(pt));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001777
Greg Clayton7b462cc2010-10-15 22:48:33 +00001778 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001779 ConstString entity_name(decl_name.c_str());
Sean Callananbc8ac342015-09-04 20:49:51 +00001780 ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities, valobj));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001781
Sean Callananbc8ac342015-09-04 20:49:51 +00001782 assert (entity);
Sean Callanan3c495c12013-01-15 23:29:36 +00001783 entity->EnableParserVars(GetParserID());
1784 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
1785 parser_vars->m_parser_type = pt;
1786 parser_vars->m_named_decl = var_decl;
1787 parser_vars->m_llvm_value = NULL;
1788 parser_vars->m_lldb_value = var_location;
1789 parser_vars->m_lldb_var = var;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001790
Sean Callanan98298012011-10-27 19:41:13 +00001791 if (is_reference)
1792 entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001793
Sean Callananea22d422010-07-16 00:09:46 +00001794 if (log)
Greg Clayton7b462cc2010-10-15 22:48:33 +00001795 {
Sean Callanan82695d62011-11-07 23:32:52 +00001796 ASTDumper orig_dumper(ut.GetOpaqueQualType());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001797 ASTDumper ast_dumper(var_decl);
Sean Callanan82695d62011-11-07 23:32:52 +00001798 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 +00001799 }
Sean Callanan468574b2010-06-22 23:46:24 +00001800}
1801
1802void
Sean Callanan2235f322010-08-11 03:57:18 +00001803ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
Sean Callananbc8ac342015-09-04 20:49:51 +00001804 ExpressionVariableSP &pvar_sp,
Sean Callanan7dd98122011-10-14 20:34:21 +00001805 unsigned int current_id)
Sean Callanan2235f322010-08-11 03:57:18 +00001806{
Greg Clayton5160ce52013-03-27 23:08:40 +00001807 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001808
Sean Callanan3820e9c2015-09-08 22:23:39 +00001809 TypeFromUser user_type (llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001810
Greg Clayton57ee3062013-07-11 22:46:58 +00001811 TypeFromParser parser_type (GuardedCopyType(user_type));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001812
Sean Callanane0a64f72011-12-01 21:04:37 +00001813 if (!parser_type.GetOpaqueQualType())
1814 {
1815 if (log)
1816 log->Printf(" CEDM::FEVD[%u] Couldn't import type for pvar %s", current_id, pvar_sp->GetName().GetCString());
1817 return;
1818 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001819
Greg Claytond8d4a572015-08-11 21:38:15 +00001820 NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::GetLValueReferenceType(parser_type));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001821
Sean Callanan3820e9c2015-09-08 22:23:39 +00001822 llvm::cast<ClangExpressionVariable>(pvar_sp.get())->EnableParserVars(GetParserID());
1823 ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetParserVars(GetParserID());
Sean Callanan3c495c12013-01-15 23:29:36 +00001824 parser_vars->m_parser_type = parser_type;
Greg Clayton57ee3062013-07-11 22:46:58 +00001825 parser_vars->m_named_decl = var_decl;
1826 parser_vars->m_llvm_value = NULL;
1827 parser_vars->m_lldb_value.Clear();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001828
Sean Callanan823bb4c2010-08-30 22:17:16 +00001829 if (log)
Sean Callanan530782942010-11-01 23:22:47 +00001830 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00001831 ASTDumper ast_dumper(var_decl);
Sean Callananfb3e4302011-10-29 19:50:43 +00001832 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 +00001833 }
Sean Callanan2235f322010-08-11 03:57:18 +00001834}
1835
Sean Callanan348b5892010-11-30 00:27:43 +00001836void
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001837ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
Greg Clayton3d51b9f2012-11-27 01:52:16 +00001838 const Symbol &symbol,
Sean Callanan7dd98122011-10-14 20:34:21 +00001839 unsigned int current_id)
Sean Callanand9ca42a2011-05-08 02:21:26 +00001840{
1841 assert(m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001842
Greg Clayton5160ce52013-03-27 23:08:40 +00001843 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001844
Sean Callanan933693b2012-02-10 01:22:05 +00001845 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001846
1847 if (target == NULL)
1848 return;
1849
1850 ASTContext *scratch_ast_context = target->GetScratchClangASTContext()->getASTContext();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001851
Greg Claytond8d4a572015-08-11 21:38:15 +00001852 TypeFromUser user_type (ClangASTContext::GetLValueReferenceType(ClangASTContext::GetBasicType(scratch_ast_context, eBasicTypeVoid).GetPointerType()));
1853 TypeFromParser parser_type (ClangASTContext::GetLValueReferenceType(ClangASTContext::GetBasicType(m_ast_context, eBasicTypeVoid).GetPointerType()));
Greg Clayton57ee3062013-07-11 22:46:58 +00001854 NamedDecl *var_decl = context.AddVarDecl(parser_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001855
Sean Callanand9ca42a2011-05-08 02:21:26 +00001856 std::string decl_name(context.m_decl_name.getAsString());
1857 ConstString entity_name(decl_name.c_str());
Sean Callananbc8ac342015-09-04 20:49:51 +00001858 ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities,
1859 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
1860 entity_name,
1861 user_type,
1862 m_parser_vars->m_target_info.byte_order,
1863 m_parser_vars->m_target_info.address_byte_size));
1864 assert (entity);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001865
Greg Clayton57ee3062013-07-11 22:46:58 +00001866 entity->EnableParserVars(GetParserID());
1867 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
1868
Greg Clayton358cf1e2015-06-25 21:46:34 +00001869 const Address symbol_address = symbol.GetAddress();
Greg Claytonc14ee322011-09-22 04:58:26 +00001870 lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001871
Greg Clayton57ee3062013-07-11 22:46:58 +00001872 //parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
Greg Clayton99558cc42015-08-24 23:46:31 +00001873 parser_vars->m_lldb_value.SetCompilerType(user_type);
Greg Clayton57ee3062013-07-11 22:46:58 +00001874 parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
1875 parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001876
Sean Callanan3c495c12013-01-15 23:29:36 +00001877 parser_vars->m_parser_type = parser_type;
1878 parser_vars->m_named_decl = var_decl;
1879 parser_vars->m_llvm_value = NULL;
Sean Callanan3c495c12013-01-15 23:29:36 +00001880 parser_vars->m_lldb_sym = &symbol;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001881
Sean Callanand9ca42a2011-05-08 02:21:26 +00001882 if (log)
1883 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00001884 ASTDumper ast_dumper(var_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001885
Sean Callananfb3e4302011-10-29 19:50:43 +00001886 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 +00001887 }
1888}
1889
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001890bool
Sean Callanan77502262011-05-12 23:54:16 +00001891ClangExpressionDeclMap::ResolveUnknownTypes()
1892{
Greg Clayton5160ce52013-03-27 23:08:40 +00001893 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan933693b2012-02-10 01:22:05 +00001894 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00001895
Greg Claytond8d4a572015-08-11 21:38:15 +00001896 ClangASTContext *scratch_ast_context = target->GetScratchClangASTContext();
Sean Callanan77502262011-05-12 23:54:16 +00001897
1898 for (size_t index = 0, num_entities = m_found_entities.GetSize();
1899 index < num_entities;
1900 ++index)
1901 {
Sean Callananbc8ac342015-09-04 20:49:51 +00001902 ExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001903
Sean Callanan3820e9c2015-09-08 22:23:39 +00001904 ClangExpressionVariable::ParserVars *parser_vars = llvm::cast<ClangExpressionVariable>(entity.get())->GetParserVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001905
Sean Callanan77502262011-05-12 23:54:16 +00001906 if (entity->m_flags & ClangExpressionVariable::EVUnknownType)
1907 {
Sean Callanan3c495c12013-01-15 23:29:36 +00001908 const NamedDecl *named_decl = parser_vars->m_named_decl;
Sean Callanan77502262011-05-12 23:54:16 +00001909 const VarDecl *var_decl = dyn_cast<VarDecl>(named_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001910
Sean Callanan77502262011-05-12 23:54:16 +00001911 if (!var_decl)
1912 {
1913 if (log)
1914 log->Printf("Entity of unknown type does not have a VarDecl");
1915 return false;
1916 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001917
Sean Callanan77502262011-05-12 23:54:16 +00001918 if (log)
1919 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00001920 ASTDumper ast_dumper(const_cast<VarDecl*>(var_decl));
1921 log->Printf("Variable of unknown type now has Decl %s", ast_dumper.GetCString());
Sean Callanan77502262011-05-12 23:54:16 +00001922 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001923
Sean Callanan77502262011-05-12 23:54:16 +00001924 QualType var_type = var_decl->getType();
Greg Claytond8d4a572015-08-11 21:38:15 +00001925 TypeFromParser parser_type(var_type.getAsOpaquePtr(), ClangASTContext::GetASTContext(&var_decl->getASTContext()));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001926
Greg Claytond8d4a572015-08-11 21:38:15 +00001927 lldb::clang_type_t copied_type = m_ast_importer->CopyType(scratch_ast_context->getASTContext(), &var_decl->getASTContext(), var_type.getAsOpaquePtr());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001928
Sean Callanane0a64f72011-12-01 21:04:37 +00001929 if (!copied_type)
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001930 {
Sean Callanane0a64f72011-12-01 21:04:37 +00001931 if (log)
1932 log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't import the type for a variable");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001933
Sean Callananbc8ac342015-09-04 20:49:51 +00001934 return (bool) lldb::ExpressionVariableSP();
Sean Callanane0a64f72011-12-01 21:04:37 +00001935 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001936
Sean Callanan77502262011-05-12 23:54:16 +00001937 TypeFromUser user_type(copied_type, scratch_ast_context);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001938
Greg Clayton57ee3062013-07-11 22:46:58 +00001939// parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType, user_type.GetOpaqueQualType());
Greg Clayton99558cc42015-08-24 23:46:31 +00001940 parser_vars->m_lldb_value.SetCompilerType(user_type);
Sean Callanan3c495c12013-01-15 23:29:36 +00001941 parser_vars->m_parser_type = parser_type;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001942
Greg Clayton99558cc42015-08-24 23:46:31 +00001943 entity->SetCompilerType(user_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001944
Sean Callanan77502262011-05-12 23:54:16 +00001945 entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);
1946 }
1947 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001948
Sean Callanan77502262011-05-12 23:54:16 +00001949 return true;
1950}
1951
Sean Callanand9ca42a2011-05-08 02:21:26 +00001952void
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001953ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001954 const RegisterInfo *reg_info,
Sean Callanan7dd98122011-10-14 20:34:21 +00001955 unsigned int current_id)
Sean Callanan348b5892010-11-30 00:27:43 +00001956{
Greg Clayton5160ce52013-03-27 23:08:40 +00001957 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001958
Greg Claytona1e5dc82015-08-11 22:53:00 +00001959 CompilerType clang_type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (m_ast_context,
Greg Clayton57ee3062013-07-11 22:46:58 +00001960 reg_info->encoding,
1961 reg_info->byte_size * 8);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001962
Greg Clayton57ee3062013-07-11 22:46:58 +00001963 if (!clang_type)
Sean Callanan348b5892010-11-30 00:27:43 +00001964 {
Johnny Chene95fcf72011-08-09 22:52:27 +00001965 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00001966 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 +00001967 return;
1968 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001969
Greg Clayton57ee3062013-07-11 22:46:58 +00001970 TypeFromParser parser_clang_type (clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001971
Greg Clayton57ee3062013-07-11 22:46:58 +00001972 NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001973
Sean Callananbc8ac342015-09-04 20:49:51 +00001974 ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities,
1975 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1976 m_parser_vars->m_target_info.byte_order,
1977 m_parser_vars->m_target_info.address_byte_size));
1978 assert (entity);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001979
Sean Callanan348b5892010-11-30 00:27:43 +00001980 std::string decl_name(context.m_decl_name.getAsString());
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00001981 entity->SetName (ConstString (decl_name.c_str()));
1982 entity->SetRegisterInfo (reg_info);
Sean Callanan3c495c12013-01-15 23:29:36 +00001983 entity->EnableParserVars(GetParserID());
1984 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
Greg Clayton57ee3062013-07-11 22:46:58 +00001985 parser_vars->m_parser_type = parser_clang_type;
1986 parser_vars->m_named_decl = var_decl;
1987 parser_vars->m_llvm_value = NULL;
1988 parser_vars->m_lldb_value.Clear();
Sean Callananf673e762012-02-15 01:40:39 +00001989 entity->m_flags |= ClangExpressionVariable::EVBareRegister;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00001990
Sean Callananf673e762012-02-15 01:40:39 +00001991 if (log)
Sean Callanan348b5892010-11-30 00:27:43 +00001992 {
Greg Clayton64bc6ca2011-10-20 00:47:21 +00001993 ASTDumper ast_dumper(var_decl);
Sean Callananfb3e4302011-10-29 19:50:43 +00001994 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 +00001995 }
1996}
1997
Sean Callanan2235f322010-08-11 03:57:18 +00001998void
Greg Clayton3f5c08f2011-05-18 22:01:49 +00001999ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
Greg Clayton57ee3062013-07-11 22:46:58 +00002000 Function* function,
Sean Callanan7dd98122011-10-14 20:34:21 +00002001 Symbol* symbol,
2002 unsigned int current_id)
Sean Callanan468574b2010-06-22 23:46:24 +00002003{
Sean Callanan979f74d2010-12-03 01:38:59 +00002004 assert (m_parser_vars.get());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002005
Greg Clayton5160ce52013-03-27 23:08:40 +00002006 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002007
Greg Clayton57ee3062013-07-11 22:46:58 +00002008 NamedDecl *function_decl = NULL;
Greg Clayton358cf1e2015-06-25 21:46:34 +00002009 Address fun_address;
Greg Claytona1e5dc82015-08-11 22:53:00 +00002010 CompilerType function_clang_type;
Matt Kopec00049b82013-02-27 20:13:38 +00002011
2012 bool is_indirect_function = false;
2013
Greg Clayton57ee3062013-07-11 22:46:58 +00002014 if (function)
Sean Callanan8ade1042010-07-27 00:55:47 +00002015 {
Greg Clayton57ee3062013-07-11 22:46:58 +00002016 Type *function_type = function->GetType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002017
Greg Clayton57ee3062013-07-11 22:46:58 +00002018 if (!function_type)
Sean Callanan8ade1042010-07-27 00:55:47 +00002019 {
2020 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002021 log->PutCString(" Skipped a function because it has no type");
Sean Callanan8ade1042010-07-27 00:55:47 +00002022 return;
2023 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002024
Greg Clayton99558cc42015-08-24 23:46:31 +00002025 function_clang_type = function_type->GetFullCompilerType ();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002026
Greg Clayton57ee3062013-07-11 22:46:58 +00002027 if (!function_clang_type)
Sean Callanan8ade1042010-07-27 00:55:47 +00002028 {
2029 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002030 log->PutCString(" Skipped a function because it has no Clang type");
Sean Callanan8ade1042010-07-27 00:55:47 +00002031 return;
2032 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002033
Greg Clayton358cf1e2015-06-25 21:46:34 +00002034 fun_address = function->GetAddressRange().GetBaseAddress();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002035
Greg Claytona1e5dc82015-08-11 22:53:00 +00002036 CompilerType copied_function_type = GuardedCopyType(function_clang_type);
Greg Clayton57ee3062013-07-11 22:46:58 +00002037 if (copied_function_type)
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002038 {
Greg Clayton57ee3062013-07-11 22:46:58 +00002039 function_decl = context.AddFunDecl(copied_function_type);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002040
Greg Clayton57ee3062013-07-11 22:46:58 +00002041 if (!function_decl)
Sean Callanan485f7322013-04-24 00:34:41 +00002042 {
2043 if (log)
2044 {
2045 log->Printf (" Failed to create a function decl for '%s' {0x%8.8" PRIx64 "}",
Greg Clayton57ee3062013-07-11 22:46:58 +00002046 function_type->GetName().GetCString(),
2047 function_type->GetID());
Sean Callanan485f7322013-04-24 00:34:41 +00002048 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002049
Sean Callanan485f7322013-04-24 00:34:41 +00002050 return;
2051 }
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002052 }
2053 else
2054 {
2055 // We failed to copy the type we found
2056 if (log)
2057 {
Daniel Malead01b2952012-11-29 21:49:15 +00002058 log->Printf (" Failed to import the function type '%s' {0x%8.8" PRIx64 "} into the expression parser AST contenxt",
Greg Clayton57ee3062013-07-11 22:46:58 +00002059 function_type->GetName().GetCString(),
2060 function_type->GetID());
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002061 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002062
Sean Callananed8d58f2011-11-16 00:40:13 +00002063 return;
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002064 }
Sean Callanan8ade1042010-07-27 00:55:47 +00002065 }
2066 else if (symbol)
2067 {
Greg Clayton358cf1e2015-06-25 21:46:34 +00002068 fun_address = symbol->GetAddress();
Greg Clayton57ee3062013-07-11 22:46:58 +00002069 function_decl = context.AddGenericFunDecl();
Matt Kopec00049b82013-02-27 20:13:38 +00002070 is_indirect_function = symbol->IsIndirect();
Sean Callanan8ade1042010-07-27 00:55:47 +00002071 }
2072 else
2073 {
2074 if (log)
Sean Callanan7dd98122011-10-14 20:34:21 +00002075 log->PutCString(" AddOneFunction called with no function and no symbol");
Sean Callanan8ade1042010-07-27 00:55:47 +00002076 return;
2077 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002078
Sean Callanan933693b2012-02-10 01:22:05 +00002079 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Greg Claytonc14ee322011-09-22 04:58:26 +00002080
Greg Clayton358cf1e2015-06-25 21:46:34 +00002081 lldb::addr_t load_addr = fun_address.GetCallableLoadAddress(target, is_indirect_function);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002082
Sean Callananbc8ac342015-09-04 20:49:51 +00002083 ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList (m_found_entities,
2084 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
2085 m_parser_vars->m_target_info.byte_order,
2086 m_parser_vars->m_target_info.address_byte_size));
2087 assert (entity);
Greg Clayton57ee3062013-07-11 22:46:58 +00002088
2089 std::string decl_name(context.m_decl_name.getAsString());
2090 entity->SetName(ConstString(decl_name.c_str()));
Greg Clayton99558cc42015-08-24 23:46:31 +00002091 entity->SetCompilerType (function_clang_type);
Greg Clayton57ee3062013-07-11 22:46:58 +00002092 entity->EnableParserVars(GetParserID());
2093
2094 ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002095
Sean Callanan9be9d172013-03-19 01:45:02 +00002096 if (load_addr != LLDB_INVALID_ADDRESS)
2097 {
Greg Clayton57ee3062013-07-11 22:46:58 +00002098 parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
2099 parser_vars->m_lldb_value.GetScalar() = load_addr;
Sean Callanan9be9d172013-03-19 01:45:02 +00002100 }
2101 else
2102 {
2103 // We have to try finding a file address.
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002104
Greg Clayton358cf1e2015-06-25 21:46:34 +00002105 lldb::addr_t file_addr = fun_address.GetFileAddress();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002106
Greg Clayton57ee3062013-07-11 22:46:58 +00002107 parser_vars->m_lldb_value.SetValueType(Value::eValueTypeFileAddress);
2108 parser_vars->m_lldb_value.GetScalar() = file_addr;
Sean Callanan9be9d172013-03-19 01:45:02 +00002109 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002110
Greg Clayton57ee3062013-07-11 22:46:58 +00002111
2112 parser_vars->m_named_decl = function_decl;
Sean Callanan3c495c12013-01-15 23:29:36 +00002113 parser_vars->m_llvm_value = NULL;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002114
Sean Callananea22d422010-07-16 00:09:46 +00002115 if (log)
Greg Clayton7b462cc2010-10-15 22:48:33 +00002116 {
Greg Clayton57ee3062013-07-11 22:46:58 +00002117 ASTDumper ast_dumper(function_decl);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002118
Sean Callanan308a3c52012-07-28 00:21:01 +00002119 StreamString ss;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002120
Greg Clayton358cf1e2015-06-25 21:46:34 +00002121 fun_address.Dump(&ss, m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), Address::DumpStyleResolvedDescription);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002122
Sean Callanan308a3c52012-07-28 00:21:01 +00002123 log->Printf(" CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
Sean Callanan7dd98122011-10-14 20:34:21 +00002124 current_id,
Greg Clayton57ee3062013-07-11 22:46:58 +00002125 (function ? "specific" : "generic"),
Sean Callanan308a3c52012-07-28 00:21:01 +00002126 decl_name.c_str(),
2127 ss.GetData(),
Greg Clayton64bc6ca2011-10-20 00:47:21 +00002128 ast_dumper.GetCString());
Greg Clayton7b462cc2010-10-15 22:48:33 +00002129 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002130}
Sean Callanan5666b672010-08-04 01:02:13 +00002131
Sean Callananfa4fab72013-02-01 06:55:48 +00002132TypeFromParser
2133ClangExpressionDeclMap::CopyClassType(TypeFromUser &ut,
2134 unsigned int current_id)
Sean Callanan5666b672010-08-04 01:02:13 +00002135{
Greg Claytona1e5dc82015-08-11 22:53:00 +00002136 CompilerType copied_clang_type = GuardedCopyType(ut);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002137
Greg Clayton57ee3062013-07-11 22:46:58 +00002138 if (!copied_clang_type)
Sean Callanane0a64f72011-12-01 21:04:37 +00002139 {
Greg Clayton5160ce52013-03-27 23:08:40 +00002140 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002141
Sean Callananfa4fab72013-02-01 06:55:48 +00002142 if (log)
2143 log->Printf("ClangExpressionDeclMap::CopyClassType - Couldn't import the type");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002144
Sean Callananfa4fab72013-02-01 06:55:48 +00002145 return TypeFromParser();
Sean Callanane0a64f72011-12-01 21:04:37 +00002146 }
Sean Callananfa4fab72013-02-01 06:55:48 +00002147
Greg Clayton57ee3062013-07-11 22:46:58 +00002148 if (copied_clang_type.IsAggregateType() && copied_clang_type.GetCompleteType ())
Sean Callananfc55f5d2010-09-21 00:44:12 +00002149 {
Greg Claytona1e5dc82015-08-11 22:53:00 +00002150 CompilerType void_clang_type = ClangASTContext::GetBasicType(m_ast_context, eBasicTypeVoid);
2151 CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002152
Greg Claytona1e5dc82015-08-11 22:53:00 +00002153 CompilerType method_type = ClangASTContext::CreateFunctionType (m_ast_context,
Greg Clayton57ee3062013-07-11 22:46:58 +00002154 void_clang_type,
2155 &void_ptr_clang_type,
Sean Callananc1b732d2011-11-01 18:07:13 +00002156 1,
2157 false,
Greg Clayton57ee3062013-07-11 22:46:58 +00002158 copied_clang_type.GetTypeQualifiers());
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002159
Greg Clayton0fffff52010-09-24 05:15:53 +00002160 const bool is_virtual = false;
2161 const bool is_static = false;
2162 const bool is_inline = false;
Greg Claytonf51de672010-10-01 02:31:07 +00002163 const bool is_explicit = false;
Sean Callananc8324752011-11-02 18:09:01 +00002164 const bool is_attr_used = true;
Sean Callanandbb58392011-11-02 01:38:59 +00002165 const bool is_artificial = false;
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002166
Greg Claytond8d4a572015-08-11 21:38:15 +00002167 ClangASTContext::GetASTContext(m_ast_context)->
2168 AddMethodToCXXRecordType (copied_clang_type.GetOpaqueQualType(),
2169 "$__lldb_expr",
2170 method_type,
2171 lldb::eAccessPublic,
2172 is_virtual,
2173 is_static,
2174 is_inline,
2175 is_explicit,
2176 is_attr_used,
2177 is_artificial);
Sean Callananfc55f5d2010-09-21 00:44:12 +00002178 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002179
Greg Clayton57ee3062013-07-11 22:46:58 +00002180 return TypeFromParser(copied_clang_type);
Sean Callananfa4fab72013-02-01 06:55:48 +00002181}
2182
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002183void
2184ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
Sean Callananfa4fab72013-02-01 06:55:48 +00002185 TypeFromUser &ut,
2186 unsigned int current_id)
2187{
Greg Claytona1e5dc82015-08-11 22:53:00 +00002188 CompilerType copied_clang_type = GuardedCopyType(ut);
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002189
Greg Clayton57ee3062013-07-11 22:46:58 +00002190 if (!copied_clang_type)
Sean Callananfa4fab72013-02-01 06:55:48 +00002191 {
Greg Clayton5160ce52013-03-27 23:08:40 +00002192 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callananfa4fab72013-02-01 06:55:48 +00002193
2194 if (log)
2195 log->Printf("ClangExpressionDeclMap::AddOneType - Couldn't import the type");
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002196
Sean Callananfa4fab72013-02-01 06:55:48 +00002197 return;
2198 }
Sylvestre Ledruceab3ac2014-07-06 17:54:58 +00002199
Greg Clayton57ee3062013-07-11 22:46:58 +00002200 context.AddTypeDecl(copied_clang_type);
Sean Callanan5666b672010-08-04 01:02:13 +00002201}