565bdb5545
The main change is the addition of a new SBTypeStaticField class, representing a static member of a class. It can be retrieved created through SBType::GetStaticFieldWithName. It contains several methods (GetName, GetMangledName, etc.) whose meaning is hopefully obvious. The most interesting method is lldb::SBValue GetConstantValue(lldb::SBTarget) which returns a the value of the field -- if it is a compile time constant. The reason for that is that only constants have their values represented in the clang AST. For non-constants, we need to go back to the module containing that constant, and ask retrieve the associated ValueObjectVariable. That's easy enough if the we are still in the type system of the module (because then the type system will contain the pointer to the module symbol file), but it's hard when the type has been copied into another AST (e.g. during expression evaluation). To do that we would need to walk the ast import chain backwards to find the source TypeSystem, and I haven't found a nice way to do that. Another possibility would be to use the mangled name of the variable to perform a lookup (in all modules). That is sort of what happens when evaluating the variable in an expression (which does work), but I did not want to commit to that implementation as it's not necessary for my use case (and if anyone wants to, he can use the GetMangledName function and perform the lookup manually). The patch adds a couple of new TypeSystem functions to surface the information needed to implement this functionality.
64 lines
2.1 KiB
C++
64 lines
2.1 KiB
C++
//===-- CompilerDecl.cpp --------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Symbol/CompilerDecl.h"
|
|
#include "lldb/Symbol/CompilerDeclContext.h"
|
|
#include "lldb/Symbol/TypeSystem.h"
|
|
#include "lldb/Utility/Scalar.h"
|
|
|
|
using namespace lldb_private;
|
|
|
|
ConstString CompilerDecl::GetName() const {
|
|
return m_type_system->DeclGetName(m_opaque_decl);
|
|
}
|
|
|
|
ConstString CompilerDecl::GetMangledName() const {
|
|
return m_type_system->DeclGetMangledName(m_opaque_decl);
|
|
}
|
|
|
|
CompilerDeclContext CompilerDecl::GetDeclContext() const {
|
|
return m_type_system->DeclGetDeclContext(m_opaque_decl);
|
|
}
|
|
|
|
CompilerType CompilerDecl::GetType() const {
|
|
return m_type_system->GetTypeForDecl(m_opaque_decl);
|
|
}
|
|
|
|
CompilerType CompilerDecl::GetFunctionReturnType() const {
|
|
return m_type_system->DeclGetFunctionReturnType(m_opaque_decl);
|
|
}
|
|
|
|
size_t CompilerDecl::GetNumFunctionArguments() const {
|
|
return m_type_system->DeclGetFunctionNumArguments(m_opaque_decl);
|
|
}
|
|
|
|
CompilerType CompilerDecl::GetFunctionArgumentType(size_t arg_idx) const {
|
|
return m_type_system->DeclGetFunctionArgumentType(m_opaque_decl, arg_idx);
|
|
}
|
|
|
|
bool lldb_private::operator==(const lldb_private::CompilerDecl &lhs,
|
|
const lldb_private::CompilerDecl &rhs) {
|
|
return lhs.GetTypeSystem() == rhs.GetTypeSystem() &&
|
|
lhs.GetOpaqueDecl() == rhs.GetOpaqueDecl();
|
|
}
|
|
|
|
bool lldb_private::operator!=(const lldb_private::CompilerDecl &lhs,
|
|
const lldb_private::CompilerDecl &rhs) {
|
|
return lhs.GetTypeSystem() != rhs.GetTypeSystem() ||
|
|
lhs.GetOpaqueDecl() != rhs.GetOpaqueDecl();
|
|
}
|
|
|
|
std::vector<lldb_private::CompilerContext>
|
|
CompilerDecl::GetCompilerContext() const {
|
|
return m_type_system->DeclGetCompilerContext(m_opaque_decl);
|
|
}
|
|
|
|
Scalar CompilerDecl::GetConstantValue() const {
|
|
return m_type_system->DeclGetConstantValue(m_opaque_decl);
|
|
}
|