1 //===-- Function.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/Function.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/Section.h"
13 #include "lldb/Symbol/ClangASTType.h"
14 #include "lldb/Symbol/ClangASTContext.h"
15 #include "lldb/Symbol/CompileUnit.h"
16 #include "lldb/Symbol/LineTable.h"
17 #include "lldb/Symbol/SymbolVendor.h"
18 #include "clang/AST/Type.h"
19 #include "clang/AST/CanonicalType.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
24 //----------------------------------------------------------------------
25 // Basic function information is contained in the FunctionInfo class.
26 // It is designed to contain the name, linkage name, and declaration
27 // location.
28 //----------------------------------------------------------------------
29 FunctionInfo::FunctionInfo (const char *name, const Declaration *decl_ptr) :
30     m_name(name),
31     m_declaration(decl_ptr)
32 {
33 }
34 
35 
36 FunctionInfo::FunctionInfo (const ConstString& name, const Declaration *decl_ptr) :
37     m_name(name),
38     m_declaration(decl_ptr)
39 {
40 }
41 
42 
43 FunctionInfo::~FunctionInfo()
44 {
45 }
46 
47 void
48 FunctionInfo::Dump(Stream *s, bool show_fullpaths) const
49 {
50     if (m_name)
51         *s << ", name = \"" << m_name << "\"";
52     m_declaration.Dump(s, show_fullpaths);
53 }
54 
55 
56 int
57 FunctionInfo::Compare(const FunctionInfo& a, const FunctionInfo& b)
58 {
59     int result = ConstString::Compare(a.GetName(), b.GetName());
60     if (result)
61         return result;
62 
63     return Declaration::Compare(a.m_declaration, b.m_declaration);
64 }
65 
66 
67 Declaration&
68 FunctionInfo::GetDeclaration()
69 {
70     return m_declaration;
71 }
72 
73 const Declaration&
74 FunctionInfo::GetDeclaration() const
75 {
76     return m_declaration;
77 }
78 
79 const ConstString&
80 FunctionInfo::GetName() const
81 {
82     return m_name;
83 }
84 
85 size_t
86 FunctionInfo::MemorySize() const
87 {
88     return m_name.MemorySize() + m_declaration.MemorySize();
89 }
90 
91 
92 InlineFunctionInfo::InlineFunctionInfo
93 (
94     const char *name,
95     const char *mangled,
96     const Declaration *decl_ptr,
97     const Declaration *call_decl_ptr
98 ) :
99     FunctionInfo(name, decl_ptr),
100     m_mangled(mangled, true),
101     m_call_decl (call_decl_ptr)
102 {
103 }
104 
105 InlineFunctionInfo::InlineFunctionInfo
106 (
107     const ConstString& name,
108     const Mangled &mangled,
109     const Declaration *decl_ptr,
110     const Declaration *call_decl_ptr
111 ) :
112     FunctionInfo(name, decl_ptr),
113     m_mangled(mangled),
114     m_call_decl (call_decl_ptr)
115 {
116 }
117 
118 InlineFunctionInfo::~InlineFunctionInfo()
119 {
120 }
121 
122 int
123 InlineFunctionInfo::Compare(const InlineFunctionInfo& a, const InlineFunctionInfo& b)
124 {
125 
126     int result = FunctionInfo::Compare(a, b);
127     if (result)
128         return result;
129     // only compare the mangled names if both have them
130     return Mangled::Compare(a.m_mangled, a.m_mangled);
131 }
132 
133 void
134 InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const
135 {
136     FunctionInfo::Dump(s, show_fullpaths);
137     if (m_mangled)
138         m_mangled.Dump(s);
139 }
140 
141 void
142 InlineFunctionInfo::DumpStopContext (Stream *s) const
143 {
144 //    s->Indent("[inlined] ");
145     s->Indent();
146     if (m_mangled)
147         s->PutCString (m_mangled.GetName().AsCString());
148     else
149         s->PutCString (m_name.AsCString());
150 }
151 
152 
153 const ConstString &
154 InlineFunctionInfo::GetName () const
155 {
156     if (m_mangled)
157         return m_mangled.GetName();
158     return m_name;
159 }
160 
161 
162 Declaration &
163 InlineFunctionInfo::GetCallSite ()
164 {
165     return m_call_decl;
166 }
167 
168 const Declaration &
169 InlineFunctionInfo::GetCallSite () const
170 {
171     return m_call_decl;
172 }
173 
174 
175 Mangled&
176 InlineFunctionInfo::GetMangled()
177 {
178     return m_mangled;
179 }
180 
181 const Mangled&
182 InlineFunctionInfo::GetMangled() const
183 {
184     return m_mangled;
185 }
186 
187 size_t
188 InlineFunctionInfo::MemorySize() const
189 {
190     return FunctionInfo::MemorySize() + m_mangled.MemorySize();
191 }
192 
193 //----------------------------------------------------------------------
194 //
195 //----------------------------------------------------------------------
196 Function::Function
197 (
198     CompileUnit *comp_unit,
199     lldb::user_id_t func_uid,
200     lldb::user_id_t type_uid,
201     const Mangled &mangled,
202     Type * type,
203     const AddressRange& range
204 ) :
205     UserID (func_uid),
206     m_comp_unit (comp_unit),
207     m_type_uid (type_uid),
208     m_type (type),
209     m_mangled (mangled),
210     m_block (func_uid),
211     m_range (range),
212     m_frame_base (),
213     m_flags (),
214     m_prologue_byte_size (0)
215 {
216     m_block.SetParentScope(this);
217     assert(comp_unit != NULL);
218 }
219 
220 Function::Function
221 (
222     CompileUnit *comp_unit,
223     lldb::user_id_t func_uid,
224     lldb::user_id_t type_uid,
225     const char *mangled,
226     Type *type,
227     const AddressRange &range
228 ) :
229     UserID (func_uid),
230     m_comp_unit (comp_unit),
231     m_type_uid (type_uid),
232     m_type (type),
233     m_mangled (mangled, true),
234     m_block (func_uid),
235     m_range (range),
236     m_frame_base (),
237     m_flags (),
238     m_prologue_byte_size (0)
239 {
240     m_block.SetParentScope(this);
241     assert(comp_unit != NULL);
242 }
243 
244 
245 Function::~Function()
246 {
247 }
248 
249 void
250 Function::GetStartLineSourceInfo (FileSpec &source_file, uint32_t &line_no)
251 {
252     line_no = 0;
253     source_file.Clear();
254 
255     if (m_comp_unit == NULL)
256         return;
257 
258     if (m_type != NULL && m_type->GetDeclaration().GetLine() != 0)
259     {
260         source_file = m_type->GetDeclaration().GetFile();
261         line_no = m_type->GetDeclaration().GetLine();
262     }
263     else
264     {
265         LineTable *line_table = m_comp_unit->GetLineTable();
266         if (line_table == NULL)
267             return;
268 
269         LineEntry line_entry;
270         if (line_table->FindLineEntryByAddress (GetAddressRange().GetBaseAddress(), line_entry, NULL))
271         {
272             line_no = line_entry.line;
273             source_file = line_entry.file;
274         }
275     }
276 }
277 
278 void
279 Function::GetEndLineSourceInfo (FileSpec &source_file, uint32_t &line_no)
280 {
281     line_no = 0;
282     source_file.Clear();
283 
284     // The -1 is kind of cheesy, but I want to get the last line entry for the given function, not the
285     // first entry of the next.
286     Address scratch_addr(GetAddressRange().GetBaseAddress());
287     scratch_addr.SetOffset (scratch_addr.GetOffset() + GetAddressRange().GetByteSize() - 1);
288 
289     LineTable *line_table = m_comp_unit->GetLineTable();
290     if (line_table == NULL)
291         return;
292 
293     LineEntry line_entry;
294     if (line_table->FindLineEntryByAddress (scratch_addr, line_entry, NULL))
295     {
296         line_no = line_entry.line;
297         source_file = line_entry.file;
298     }
299 }
300 
301 Block &
302 Function::GetBlock (bool can_create)
303 {
304     if (!m_block.BlockInfoHasBeenParsed() && can_create)
305     {
306         SymbolContext sc;
307         CalculateSymbolContext(&sc);
308         assert(sc.module_sp);
309         sc.module_sp->GetSymbolVendor()->ParseFunctionBlocks(sc);
310         m_block.SetBlockInfoHasBeenParsed (true, true);
311     }
312     return m_block;
313 }
314 
315 CompileUnit*
316 Function::GetCompileUnit()
317 {
318     return m_comp_unit;
319 }
320 
321 const CompileUnit*
322 Function::GetCompileUnit() const
323 {
324     return m_comp_unit;
325 }
326 
327 
328 void
329 Function::GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target)
330 {
331     Type* func_type = GetType();
332     *s << "id = " << (const UserID&)*this << ", name = \"" << func_type->GetName() << "\", range = ";
333 
334     Address::DumpStyle fallback_style;
335     if (level == eDescriptionLevelVerbose)
336         fallback_style = Address::DumpStyleModuleWithFileAddress;
337     else
338         fallback_style = Address::DumpStyleFileAddress;
339     GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, fallback_style);
340 }
341 
342 void
343 Function::Dump(Stream *s, bool show_context) const
344 {
345     s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
346     s->Indent();
347     *s << "Function" << (const UserID&)*this;
348 
349     m_mangled.Dump(s);
350 
351 //  FunctionInfo::Dump(s);
352     if (m_type)
353     {
354         *s << ", type = " << (void*)m_type;
355         /// << " (";
356         ///m_type->DumpTypeName(s);
357         ///s->PutChar(')');
358     }
359     else if (m_type_uid != LLDB_INVALID_UID)
360         *s << ", type_uid = " << m_type_uid;
361 
362     s->EOL();
363     // Dump the root object
364     if (m_block.BlockInfoHasBeenParsed ())
365         m_block.Dump(s, m_range.GetBaseAddress().GetFileAddress(), INT_MAX, show_context);
366 }
367 
368 
369 void
370 Function::CalculateSymbolContext(SymbolContext* sc)
371 {
372     sc->function = this;
373     m_comp_unit->CalculateSymbolContext(sc);
374 }
375 
376 void
377 Function::DumpSymbolContext(Stream *s)
378 {
379     m_comp_unit->DumpSymbolContext(s);
380     s->Printf(", Function{0x%8.8x}", GetID());
381 }
382 
383 size_t
384 Function::MemorySize () const
385 {
386     size_t mem_size = sizeof(Function) + m_block.MemorySize();
387     return mem_size;
388 }
389 
390 Type*
391 Function::GetType()
392 {
393     return m_type;
394 }
395 
396 const Type*
397 Function::GetType() const
398 {
399     return m_type;
400 }
401 
402 Type
403 Function::GetReturnType ()
404 {
405     clang::QualType clang_type (clang::QualType::getFromOpaquePtr(GetType()->GetClangType()));
406     assert (clang_type->isFunctionType());
407     const clang::FunctionType *function_type = dyn_cast<clang::FunctionType> (clang_type);
408     clang::QualType fun_return_qualtype = function_type->getResultType();
409 
410     const ConstString fun_return_name(ClangASTType::GetClangTypeName(fun_return_qualtype.getAsOpaquePtr()));
411 
412     SymbolContext sc;
413     CalculateSymbolContext (&sc);
414     // Null out everything below the CompUnit 'cause we don't actually know these.
415 
416     size_t bit_size = ClangASTType::GetClangTypeBitWidth (GetType()->GetClangASTContext().getASTContext(),
417                                                           fun_return_qualtype.getAsOpaquePtr());
418     Type return_type (0,
419                       GetType()->GetSymbolFile(),
420                       fun_return_name,
421                       bit_size,
422                       sc.comp_unit,
423                       0,
424                       Type::eEncodingIsSyntheticUID,
425                       Declaration(),
426                       fun_return_qualtype.getAsOpaquePtr(),
427                       Type::eResolveStateFull);
428     return return_type;
429 }
430 
431 int
432 Function::GetArgumentCount ()
433 {
434     clang::QualType clang_type (clang::QualType::getFromOpaquePtr(GetType()->GetClangType()));
435     assert (clang_type->isFunctionType());
436     if (!clang_type->isFunctionProtoType())
437         return -1;
438 
439     const clang::FunctionProtoType *function_proto_type = dyn_cast<clang::FunctionProtoType>(clang_type);
440     if (function_proto_type != NULL)
441         return function_proto_type->getNumArgs();
442 
443     return 0;
444 }
445 
446 const Type
447 Function::GetArgumentTypeAtIndex (size_t idx)
448 {
449     clang::QualType clang_type (clang::QualType::getFromOpaquePtr(GetType()->GetClangType()));
450    assert (clang_type->isFunctionType());
451    if (!clang_type->isFunctionProtoType())
452         return Type();
453 
454     const clang::FunctionProtoType *function_proto_type = dyn_cast<clang::FunctionProtoType>(clang_type);
455     if (function_proto_type != NULL)
456     {
457         unsigned num_args = function_proto_type->getNumArgs();
458         if (idx >= num_args)
459             return Type();
460         clang::QualType arg_qualtype = (function_proto_type->arg_type_begin())[idx];
461 
462         const ConstString arg_return_name(ClangASTType::GetClangTypeName(arg_qualtype.getAsOpaquePtr()));
463         SymbolContext sc;
464         CalculateSymbolContext (&sc);
465         // Null out everything below the CompUnit 'cause we don't actually know these.
466 
467         size_t bit_size = ClangASTType::GetClangTypeBitWidth ((GetType()->GetClangASTContext().getASTContext()), arg_qualtype.getAsOpaquePtr());
468         Type arg_type (0,
469                        GetType()->GetSymbolFile(),
470                        arg_return_name,
471                        bit_size,
472                        sc.comp_unit,
473                        0,
474                        Type::eEncodingIsSyntheticUID,
475                        Declaration(),
476                        arg_qualtype.getAsOpaquePtr(),
477                        Type::eResolveStateFull);
478         return arg_type;
479     }
480 
481     return Type();
482 }
483 
484 const char *
485 Function::GetArgumentNameAtIndex (size_t idx)
486 {
487    const clang::Type *clang_type = static_cast<clang::QualType *>(GetType()->GetClangType())->getTypePtr();
488    assert (clang_type->isFunctionType());
489    if (!clang_type->isFunctionProtoType())
490        return NULL;
491     return NULL;
492 }
493 
494 bool
495 Function::IsVariadic ()
496 {
497    const clang::Type *clang_type = static_cast<clang::QualType *>(GetType()->GetClangType())->getTypePtr();
498    assert (clang_type->isFunctionType());
499    if (!clang_type->isFunctionProtoType())
500         return false;
501 
502     const clang::FunctionProtoType *function_proto_type = dyn_cast<clang::FunctionProtoType>(clang_type);
503     if (function_proto_type != NULL)
504     {
505         return function_proto_type->isVariadic();
506     }
507 
508     return false;
509 }
510 
511 uint32_t
512 Function::GetPrologueByteSize ()
513 {
514     if (m_prologue_byte_size == 0 && m_flags.IsClear(flagsCalculatedPrologueSize))
515     {
516         m_flags.Set(flagsCalculatedPrologueSize);
517         LineTable* line_table = m_comp_unit->GetLineTable ();
518         if (line_table)
519         {
520             LineEntry line_entry;
521             if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(), line_entry))
522             {
523                 // We need to take the delta of the end of the first line entry
524                 // as a file address and the start file address of the function
525                 // in case the first line entry doesn't start at the beginning
526                 // of the function.
527                 const addr_t func_start_file_addr = m_range.GetBaseAddress().GetFileAddress();
528                 const addr_t line_entry_end_file_addr = line_entry.range.GetBaseAddress().GetFileAddress() + line_entry.range.GetByteSize();
529                 if (line_entry_end_file_addr > func_start_file_addr)
530                     m_prologue_byte_size = line_entry_end_file_addr - func_start_file_addr;
531             }
532         }
533     }
534     return m_prologue_byte_size;
535 }
536 
537 
538 
539