1 //===-- Variable.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/Symbol/Variable.h"
11 
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/Stream.h"
14 #include "lldb/Core/RegularExpression.h"
15 #include "lldb/Core/ValueObject.h"
16 #include "lldb/Core/ValueObjectVariable.h"
17 #include "lldb/Symbol/Block.h"
18 #include "lldb/Symbol/Function.h"
19 #include "lldb/Symbol/SymbolContext.h"
20 #include "lldb/Symbol/Type.h"
21 #include "lldb/Symbol/VariableList.h"
22 #include "lldb/Target/ABI.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/RegisterContext.h"
25 #include "lldb/Target/StackFrame.h"
26 #include "lldb/Target/Thread.h"
27 #include "lldb/Target/Target.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 //----------------------------------------------------------------------
33 // Variable constructor
34 //----------------------------------------------------------------------
35 Variable::Variable
36 (
37     lldb::user_id_t uid,
38     const char *name,
39     const char *mangled,   // The mangled variable name for variables in namespaces
40     const lldb::SymbolFileTypeSP &symfile_type_sp,
41     ValueType scope,
42     SymbolContextScope *context,
43     Declaration* decl_ptr,
44     const DWARFExpression& location,
45     bool external,
46     bool artificial
47 ) :
48     UserID(uid),
49     m_name(name),
50     m_mangled (ConstString(mangled), true),
51     m_symfile_type_sp(symfile_type_sp),
52     m_scope(scope),
53     m_owner_scope(context),
54     m_declaration(decl_ptr),
55     m_location(location),
56     m_external(external),
57     m_artificial(artificial)
58 {
59 }
60 
61 //----------------------------------------------------------------------
62 // Destructor
63 //----------------------------------------------------------------------
64 Variable::~Variable()
65 {
66 }
67 
68 
69 const ConstString&
70 Variable::GetName() const
71 {
72     if (m_mangled)
73         return m_mangled.GetName();
74     return m_name;
75 }
76 
77 bool
78 Variable::NameMatches (const RegularExpression& regex) const
79 {
80     if (regex.Execute (m_name.AsCString()))
81         return true;
82     return m_mangled.NameMatches (regex);
83 }
84 
85 Type *
86 Variable::GetType()
87 {
88     if (m_symfile_type_sp)
89         return m_symfile_type_sp->GetType();
90     return NULL;
91 }
92 
93 void
94 Variable::Dump(Stream *s, bool show_context) const
95 {
96     s->Printf("%p: ", this);
97     s->Indent();
98     *s << "Variable" << (const UserID&)*this;
99 
100     if (m_name)
101         *s << ", name = \"" << m_name << "\"";
102 
103     if (m_symfile_type_sp)
104     {
105         Type *type = m_symfile_type_sp->GetType();
106         if (type)
107         {
108             *s << ", type = {" << type->GetID() << "} " << (void*)type << " (";
109             type->DumpTypeName(s);
110             s->PutChar(')');
111         }
112     }
113 
114     if (m_scope != eValueTypeInvalid)
115     {
116         s->PutCString(", scope = ");
117         switch (m_scope)
118         {
119         case eValueTypeVariableGlobal:       s->PutCString(m_external ? "global" : "static"); break;
120         case eValueTypeVariableArgument:    s->PutCString("parameter"); break;
121         case eValueTypeVariableLocal:        s->PutCString("local"); break;
122         default:            *s << "??? (" << m_scope << ')';
123         }
124     }
125 
126     if (show_context && m_owner_scope != NULL)
127     {
128         s->PutCString(", context = ( ");
129         m_owner_scope->DumpSymbolContext(s);
130         s->PutCString(" )");
131     }
132 
133     bool show_fullpaths = false;
134     m_declaration.Dump(s, show_fullpaths);
135 
136     if (m_location.IsValid())
137     {
138         s->PutCString(", location = ");
139         lldb::addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
140         if (m_location.IsLocationList())
141         {
142             SymbolContext variable_sc;
143             m_owner_scope->CalculateSymbolContext(&variable_sc);
144             if (variable_sc.function)
145                 loclist_base_addr = variable_sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
146         }
147         ABI *abi = NULL;
148         if (m_owner_scope)
149         {
150             ModuleSP module_sp (m_owner_scope->CalculateSymbolContextModule());
151             if (module_sp)
152                 abi = ABI::FindPlugin (module_sp->GetArchitecture()).get();
153         }
154         m_location.GetDescription(s, lldb::eDescriptionLevelBrief, loclist_base_addr, abi);
155     }
156 
157     if (m_external)
158         s->PutCString(", external");
159 
160     if (m_artificial)
161         s->PutCString(", artificial");
162 
163     s->EOL();
164 }
165 
166 bool
167 Variable::DumpDeclaration (Stream *s, bool show_fullpaths, bool show_module)
168 {
169     bool dumped_declaration_info = false;
170     if (m_owner_scope)
171     {
172         SymbolContext sc;
173         m_owner_scope->CalculateSymbolContext(&sc);
174         sc.block = NULL;
175         sc.line_entry.Clear();
176         bool show_inlined_frames = false;
177 
178         dumped_declaration_info = sc.DumpStopContext (s,
179                                                       NULL,
180                                                       Address(),
181                                                       show_fullpaths,
182                                                       show_module,
183                                                       show_inlined_frames);
184 
185         if (sc.function)
186             s->PutChar(':');
187     }
188     if (m_declaration.DumpStopContext (s, false))
189         dumped_declaration_info = true;
190     return dumped_declaration_info;
191 }
192 
193 size_t
194 Variable::MemorySize() const
195 {
196     return sizeof(Variable);
197 }
198 
199 
200 void
201 Variable::CalculateSymbolContext (SymbolContext *sc)
202 {
203     if (m_owner_scope)
204         m_owner_scope->CalculateSymbolContext(sc);
205     else
206         sc->Clear(false);
207 }
208 
209 bool
210 Variable::LocationIsValidForFrame (StackFrame *frame)
211 {
212     // Is the variable is described by a single location?
213     if (!m_location.IsLocationList())
214     {
215         // Yes it is, the location is valid.
216         return true;
217     }
218 
219     if (frame)
220     {
221         Function *function = frame->GetSymbolContext(eSymbolContextFunction).function;
222         if (function)
223         {
224             TargetSP target_sp (frame->CalculateTarget());
225 
226             addr_t loclist_base_load_addr = function->GetAddressRange().GetBaseAddress().GetLoadAddress (target_sp.get());
227             if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
228                 return false;
229             // It is a location list. We just need to tell if the location
230             // list contains the current address when converted to a load
231             // address
232             return m_location.LocationListContainsAddress (loclist_base_load_addr,
233                                                            frame->GetFrameCodeAddress().GetLoadAddress (target_sp.get()));
234         }
235     }
236     return false;
237 }
238 
239 bool
240 Variable::LocationIsValidForAddress (const Address &address)
241 {
242     // Be sure to resolve the address to section offset prior to
243     // calling this function.
244     if (address.IsSectionOffset())
245     {
246         SymbolContext sc;
247         CalculateSymbolContext(&sc);
248         if (sc.module_sp == address.GetModule())
249         {
250             // Is the variable is described by a single location?
251             if (!m_location.IsLocationList())
252             {
253                 // Yes it is, the location is valid.
254                 return true;
255             }
256 
257             if (sc.function)
258             {
259                 addr_t loclist_base_file_addr = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
260                 if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
261                     return false;
262                 // It is a location list. We just need to tell if the location
263                 // list contains the current address when converted to a load
264                 // address
265                 return m_location.LocationListContainsAddress (loclist_base_file_addr,
266                                                                address.GetFileAddress());
267             }
268         }
269     }
270     return false;
271 }
272 
273 bool
274 Variable::IsInScope (StackFrame *frame)
275 {
276     switch (m_scope)
277     {
278     case eValueTypeRegister:
279     case eValueTypeRegisterSet:
280         return frame != NULL;
281 
282     case eValueTypeConstResult:
283     case eValueTypeVariableGlobal:
284     case eValueTypeVariableStatic:
285         return true;
286 
287     case eValueTypeVariableArgument:
288     case eValueTypeVariableLocal:
289         if (frame)
290         {
291             // We don't have a location list, we just need to see if the block
292             // that this variable was defined in is currently
293             Block *deepest_frame_block = frame->GetSymbolContext(eSymbolContextBlock).block;
294             if (deepest_frame_block)
295             {
296                 SymbolContext variable_sc;
297                 CalculateSymbolContext (&variable_sc);
298                 // Check for static or global variable defined at the compile unit
299                 // level that wasn't defined in a block
300                 if (variable_sc.block == NULL)
301                     return true;
302 
303                 if (variable_sc.block == deepest_frame_block)
304                     return true;
305                 return variable_sc.block->Contains (deepest_frame_block);
306             }
307         }
308         break;
309 
310     default:
311         break;
312     }
313     return false;
314 }
315 
316 Error
317 Variable::GetValuesForVariableExpressionPath (const char *variable_expr_path,
318                                               ExecutionContextScope *scope,
319                                               GetVariableCallback callback,
320                                               void *baton,
321                                               VariableList &variable_list,
322                                               ValueObjectList &valobj_list)
323 {
324     Error error;
325     if (variable_expr_path && callback)
326     {
327         switch (variable_expr_path[0])
328         {
329         case '*':
330             {
331                 error = Variable::GetValuesForVariableExpressionPath (variable_expr_path + 1,
332                                                                       scope,
333                                                                       callback,
334                                                                       baton,
335                                                                       variable_list,
336                                                                       valobj_list);
337                 if (error.Success())
338                 {
339                     for (uint32_t i=0; i<valobj_list.GetSize(); )
340                     {
341                         Error tmp_error;
342                         ValueObjectSP valobj_sp (valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
343                         if (tmp_error.Fail())
344                         {
345                             variable_list.RemoveVariableAtIndex (i);
346                             valobj_list.RemoveValueObjectAtIndex (i);
347                         }
348                         else
349                         {
350                             valobj_list.SetValueObjectAtIndex (i, valobj_sp);
351                             ++i;
352                         }
353                     }
354                 }
355                 else
356                 {
357                     error.SetErrorString ("unknown error");
358                 }
359                 return error;
360             }
361             break;
362 
363         case '&':
364             {
365                 error = Variable::GetValuesForVariableExpressionPath (variable_expr_path + 1,
366                                                                       scope,
367                                                                       callback,
368                                                                       baton,
369                                                                       variable_list,
370                                                                       valobj_list);
371                 if (error.Success())
372                 {
373                     for (uint32_t i=0; i<valobj_list.GetSize(); )
374                     {
375                         Error tmp_error;
376                         ValueObjectSP valobj_sp (valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
377                         if (tmp_error.Fail())
378                         {
379                             variable_list.RemoveVariableAtIndex (i);
380                             valobj_list.RemoveValueObjectAtIndex (i);
381                         }
382                         else
383                         {
384                             valobj_list.SetValueObjectAtIndex (i, valobj_sp);
385                             ++i;
386                         }
387                     }
388                 }
389                 else
390                 {
391                     error.SetErrorString ("unknown error");
392                 }
393                 return error;
394             }
395             break;
396 
397         default:
398             {
399                 static RegularExpression g_regex ("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)");
400                 RegularExpression::Match regex_match(1);
401                 if (g_regex.Execute(variable_expr_path, &regex_match))
402                 {
403                     std::string variable_name;
404                     if (regex_match.GetMatchAtIndex(variable_expr_path, 1, variable_name))
405                     {
406                         variable_list.Clear();
407                         if (callback (baton, variable_name.c_str(), variable_list))
408                         {
409                             uint32_t i=0;
410                             while (i < variable_list.GetSize())
411                             {
412                                 VariableSP var_sp (variable_list.GetVariableAtIndex (i));
413                                 ValueObjectSP valobj_sp;
414                                 if (var_sp)
415                                 {
416                                     ValueObjectSP variable_valobj_sp(ValueObjectVariable::Create (scope, var_sp));
417                                     if (variable_valobj_sp)
418                                     {
419                                         variable_expr_path += variable_name.size();
420                                         if (*variable_expr_path)
421                                         {
422                                             const char* first_unparsed = NULL;
423                                             ValueObject::ExpressionPathScanEndReason reason_to_stop;
424                                             ValueObject::ExpressionPathEndResultType final_value_type;
425                                             ValueObject::GetValueForExpressionPathOptions options;
426                                             ValueObject::ExpressionPathAftermath final_task_on_target;
427 
428                                             valobj_sp = variable_valobj_sp->GetValueForExpressionPath (variable_expr_path,
429                                                                                                        &first_unparsed,
430                                                                                                        &reason_to_stop,
431                                                                                                        &final_value_type,
432                                                                                                        options,
433                                                                                                        &final_task_on_target);
434                                             if (!valobj_sp)
435                                             {
436                                                 error.SetErrorStringWithFormat ("invalid expression path '%s' for variable '%s'",
437                                                                                 variable_expr_path,
438                                                                                 var_sp->GetName().GetCString());
439                                             }
440                                         }
441                                         else
442                                         {
443                                             // Just the name of a variable with no extras
444                                             valobj_sp = variable_valobj_sp;
445                                         }
446                                     }
447                                 }
448 
449                                 if (!var_sp || !valobj_sp)
450                                 {
451                                     variable_list.RemoveVariableAtIndex (i);
452                                 }
453                                 else
454                                 {
455                                     valobj_list.Append(valobj_sp);
456                                     ++i;
457                                 }
458                             }
459 
460                             if (variable_list.GetSize() > 0)
461                             {
462                                 error.Clear();
463                                 return error;
464                             }
465                         }
466                     }
467                 }
468                 error.SetErrorStringWithFormat ("unable to extracta variable name from '%s'", variable_expr_path);
469             }
470             break;
471         }
472     }
473     error.SetErrorString ("unknown error");
474     return error;
475 }
476 
477 bool
478 Variable::DumpLocationForAddress (Stream *s, const Address &address)
479 {
480     // Be sure to resolve the address to section offset prior to
481     // calling this function.
482     if (address.IsSectionOffset())
483     {
484         SymbolContext sc;
485         CalculateSymbolContext(&sc);
486         if (sc.module_sp == address.GetModule())
487         {
488             ABI *abi = NULL;
489             if (m_owner_scope)
490             {
491                 ModuleSP module_sp (m_owner_scope->CalculateSymbolContextModule());
492                 if (module_sp)
493                     abi = ABI::FindPlugin (module_sp->GetArchitecture()).get();
494             }
495 
496             const addr_t file_addr = address.GetFileAddress();
497             if (sc.function)
498             {
499                 if (sc.function->GetAddressRange().ContainsFileAddress(address))
500                 {
501                     addr_t loclist_base_file_addr = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
502                     if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
503                         return false;
504                     return m_location.DumpLocationForAddress (s,
505                                                               eDescriptionLevelBrief,
506                                                               loclist_base_file_addr,
507                                                               file_addr,
508                                                               abi);
509                 }
510             }
511             return m_location.DumpLocationForAddress (s,
512                                                       eDescriptionLevelBrief,
513                                                       LLDB_INVALID_ADDRESS,
514                                                       file_addr,
515                                                       abi);
516         }
517     }
518     return false;
519 
520 }
521 
522