LLDB mainline
ItaniumABILanguageRuntime.h
Go to the documentation of this file.
1//===-- ItaniumABILanguageRuntime.h -----------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_CPLUSPLUS_ITANIUMABI_ITANIUMABILANGUAGERUNTIME_H
10#define LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_CPLUSPLUS_ITANIUMABI_ITANIUMABILANGUAGERUNTIME_H
11
12#include <map>
13#include <mutex>
14#include <vector>
15
17#include "lldb/Core/Value.h"
18#include "lldb/Symbol/Type.h"
20#include "lldb/lldb-private.h"
21
23
24namespace lldb_private {
25
27public:
28 ~ItaniumABILanguageRuntime() override = default;
29
30 // Static Functions
31 static void Initialize();
32
33 static void Terminate();
34
36 CreateInstance(Process *process, lldb::LanguageType language);
37
38 static llvm::StringRef GetPluginNameStatic() { return "itanium"; }
39
40 static char ID;
41
42 bool isA(const void *ClassID) const override {
43 return ClassID == &ID || CPPLanguageRuntime::isA(ClassID);
44 }
45
46 static bool classof(const LanguageRuntime *runtime) {
47 return runtime->isA(&ID);
48 }
49
50
51 llvm::Expected<LanguageRuntime::VTableInfo>
52 GetVTableInfo(ValueObject &in_value, bool check_type) override;
53
55 lldb::DynamicValueType use_dynamic,
56 TypeAndOrName &class_type_or_name,
57 Address &address,
58 Value::ValueType &value_type) override;
59
60 TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
61 ValueObject &static_value) override;
62
63 bool CouldHaveDynamicValue(ValueObject &in_value) override;
64
65 void SetExceptionBreakpoints() override;
66
67 void ClearExceptionBreakpoints() override;
68
69 bool ExceptionBreakpointsAreSet() override;
70
71 bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
72
75 bool catch_bp, bool throw_bp) override;
76
78
80 lldb::ThreadSP thread_sp) override;
81
82 // PluginInterface protocol
83 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
84
85protected:
88 bool catch_bp, bool throw_bp, bool for_expressions);
89
90 lldb::BreakpointSP CreateExceptionBreakpoint(bool catch_bp, bool throw_bp,
91 bool for_expressions,
92 bool is_internal);
93
94private:
95 typedef std::map<lldb_private::Address, TypeAndOrName> DynamicTypeCache;
96 typedef std::map<lldb_private::Address, VTableInfo> VTableInfoCache;
97
99 : // Call CreateInstance instead.
101
105 std::mutex m_mutex;
106
108 const VTableInfo &vtable_info);
109
111
112 void SetDynamicTypeInfo(const lldb_private::Address &vtable_addr,
113 const TypeAndOrName &type_info);
114
115 // Check if a compiler type has a vtable.
116 //
117 // If the compiler type is a pointer or a reference, this function will check
118 // if the pointee type has a vtable, else it will check the type passed in.
119 //
120 // Returns an error if the type of the value doesn't have a vtable with an
121 // explanation why, or returns an Error::success() if the type has a vtable.
122 llvm::Error TypeHasVTable(CompilerType compiler_type);
123};
124
125} // namespace lldb_private
126
127#endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_CPLUSPLUS_ITANIUMABI_ITANIUMABILANGUAGERUNTIME_H
A section + offset based address class.
Definition: Address.h:62
bool isA(const void *ClassID) const override
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
llvm::Error TypeHasVTable(CompilerType compiler_type)
std::map< lldb_private::Address, VTableInfo > VTableInfoCache
bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name, Address &address, Value::ValueType &value_type) override
bool isA(const void *ClassID) const override
lldb::BreakpointSP CreateExceptionBreakpoint(bool catch_bp, bool throw_bp, bool for_expressions, bool is_internal)
TypeAndOrName GetTypeInfo(ValueObject &in_value, const VTableInfo &vtable_info)
static lldb_private::LanguageRuntime * CreateInstance(Process *process, lldb::LanguageType language)
lldb::SearchFilterSP CreateExceptionSearchFilter() override
TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value) override
lldb::BreakpointResolverSP CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp, bool throw_bp) override
void SetDynamicTypeInfo(const lldb_private::Address &vtable_addr, const TypeAndOrName &type_info)
bool CouldHaveDynamicValue(ValueObject &in_value) override
std::map< lldb_private::Address, TypeAndOrName > DynamicTypeCache
bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override
~ItaniumABILanguageRuntime() override=default
static bool classof(const LanguageRuntime *runtime)
TypeAndOrName GetDynamicTypeInfo(const lldb_private::Address &vtable_addr)
llvm::Expected< LanguageRuntime::VTableInfo > GetVTableInfo(ValueObject &in_value, bool check_type) override
Get the vtable information for a given value.
lldb::ValueObjectSP GetExceptionObjectForThread(lldb::ThreadSP thread_sp) override
virtual bool isA(const void *ClassID) const
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
Sometimes you can find the name of the type corresponding to an object, but we don't have debug infor...
Definition: Type.h:745
ValueType
Type that describes Value::m_value.
Definition: Value.h:41
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::SearchFilter > SearchFilterSP
Definition: lldb-forward.h:418
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
Definition: lldb-forward.h:326
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:446
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:480
LanguageType
Programming language type.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:319
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:427