mirror of
https://github.com/intel/llvm.git
synced 2026-01-25 01:07:04 +08:00
b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
670 lines
20 KiB
C++
670 lines
20 KiB
C++
//===-- OCamlASTContext.cpp ----------------------------------------*- C++
|
|
//-*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Symbol/OCamlASTContext.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/ValueObject.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
#include "lldb/Symbol/Type.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
#include "Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
namespace lldb_private {
|
|
class OCamlASTContext::OCamlType {
|
|
public:
|
|
enum LLVMCastKind {
|
|
eKindPrimitive,
|
|
eKindObject,
|
|
eKindReference,
|
|
eKindArray,
|
|
kNumKinds
|
|
};
|
|
|
|
OCamlType(LLVMCastKind kind) : m_kind(kind) {}
|
|
|
|
virtual ~OCamlType() = default;
|
|
|
|
virtual ConstString GetName() = 0;
|
|
|
|
virtual void Dump(Stream *s) = 0;
|
|
|
|
virtual bool IsCompleteType() = 0;
|
|
|
|
LLVMCastKind getKind() const { return m_kind; }
|
|
|
|
private:
|
|
LLVMCastKind m_kind;
|
|
};
|
|
|
|
} // end of namespace lldb_private
|
|
|
|
namespace {
|
|
|
|
class OCamlPrimitiveType : public OCamlASTContext::OCamlType {
|
|
public:
|
|
enum TypeKind {
|
|
eTypeInt,
|
|
};
|
|
|
|
OCamlPrimitiveType(TypeKind type_kind, uint32_t byte_size)
|
|
: OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind),
|
|
m_type(ConstString()), m_byte_size(byte_size) {}
|
|
|
|
OCamlPrimitiveType(TypeKind type_kind, ConstString s, uint32_t byte_size)
|
|
: OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind), m_type(s),
|
|
m_byte_size(byte_size) {}
|
|
|
|
ConstString GetName() override {
|
|
switch (m_type_kind) {
|
|
case eTypeInt:
|
|
return m_type;
|
|
}
|
|
return ConstString();
|
|
}
|
|
|
|
TypeKind GetTypeKind() { return m_type_kind; }
|
|
|
|
void Dump(Stream *s) override { s->Printf("%s\n", GetName().GetCString()); }
|
|
|
|
bool IsCompleteType() override { return true; }
|
|
|
|
static bool classof(const OCamlType *ot) {
|
|
return ot->getKind() == OCamlType::eKindPrimitive;
|
|
}
|
|
|
|
uint64_t GetByteSize() const { return m_byte_size; }
|
|
|
|
private:
|
|
const TypeKind m_type_kind;
|
|
const ConstString m_type;
|
|
uint64_t m_byte_size;
|
|
};
|
|
}
|
|
|
|
OCamlASTContext::OCamlASTContext()
|
|
: TypeSystem(eKindOCaml), m_pointer_byte_size(0) {}
|
|
|
|
OCamlASTContext::~OCamlASTContext() {}
|
|
|
|
ConstString OCamlASTContext::GetPluginNameStatic() {
|
|
return ConstString("ocaml");
|
|
}
|
|
|
|
ConstString OCamlASTContext::GetPluginName() {
|
|
return OCamlASTContext::GetPluginNameStatic();
|
|
}
|
|
|
|
uint32_t OCamlASTContext::GetPluginVersion() { return 1; }
|
|
|
|
lldb::TypeSystemSP OCamlASTContext::CreateInstance(lldb::LanguageType language,
|
|
Module *module,
|
|
Target *target) {
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
|
|
|
|
if (language == lldb::eLanguageTypeOCaml) {
|
|
std::shared_ptr<OCamlASTContext> ocaml_ast_sp;
|
|
ArchSpec arch;
|
|
|
|
if (module) {
|
|
arch = module->GetArchitecture();
|
|
|
|
ObjectFile *objfile = module->GetObjectFile();
|
|
ArchSpec object_arch;
|
|
|
|
if (!objfile || !objfile->GetArchitecture(object_arch))
|
|
return lldb::TypeSystemSP();
|
|
|
|
ocaml_ast_sp = std::shared_ptr<OCamlASTContext>(new OCamlASTContext);
|
|
|
|
if (log) {
|
|
log->Printf(
|
|
"((Module*)%p) [%s]->GetOCamlASTContext() = %p", (void *)module,
|
|
module->GetFileSpec().GetFilename().AsCString("<anonymous>"),
|
|
(void *)ocaml_ast_sp.get());
|
|
}
|
|
|
|
} else if (target) {
|
|
arch = target->GetArchitecture();
|
|
ocaml_ast_sp = std::shared_ptr<OCamlASTContextForExpr>(
|
|
new OCamlASTContextForExpr(target->shared_from_this()));
|
|
|
|
if (log) {
|
|
log->Printf("((Target*)%p)->GetOCamlASTContext() = %p", (void *)target,
|
|
(void *)ocaml_ast_sp.get());
|
|
}
|
|
}
|
|
|
|
if (arch.IsValid()) {
|
|
ocaml_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
|
|
return ocaml_ast_sp;
|
|
}
|
|
}
|
|
|
|
return lldb::TypeSystemSP();
|
|
}
|
|
|
|
void OCamlASTContext::EnumerateSupportedLanguages(
|
|
std::set<lldb::LanguageType> &languages_for_types,
|
|
std::set<lldb::LanguageType> &languages_for_expressions) {
|
|
static std::vector<lldb::LanguageType> s_supported_languages_for_types(
|
|
{lldb::eLanguageTypeOCaml});
|
|
static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
|
|
{});
|
|
|
|
languages_for_types.insert(s_supported_languages_for_types.begin(),
|
|
s_supported_languages_for_types.end());
|
|
languages_for_expressions.insert(
|
|
s_supported_languages_for_expressions.begin(),
|
|
s_supported_languages_for_expressions.end());
|
|
}
|
|
|
|
void OCamlASTContext::Initialize() {
|
|
PluginManager::RegisterPlugin(GetPluginNameStatic(),
|
|
"OCaml AST context plug-in", CreateInstance,
|
|
EnumerateSupportedLanguages);
|
|
}
|
|
|
|
void OCamlASTContext::Terminate() {
|
|
PluginManager::UnregisterPlugin(CreateInstance);
|
|
}
|
|
|
|
DWARFASTParser *OCamlASTContext::GetDWARFParser() {
|
|
if (!m_dwarf_ast_parser_ap) {
|
|
m_dwarf_ast_parser_ap.reset(new DWARFASTParserOCaml(*this));
|
|
}
|
|
|
|
return m_dwarf_ast_parser_ap.get();
|
|
}
|
|
|
|
bool OCamlASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
|
|
CompilerType *element_type, uint64_t *size,
|
|
bool *is_incomplete) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
|
|
CompilerType *element_type, uint64_t *size) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
|
|
return static_cast<OCamlPrimitiveType *>(type)->IsCompleteType();
|
|
}
|
|
|
|
bool OCamlASTContext::IsConst(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
|
|
uint32_t &length) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
|
|
return type != nullptr;
|
|
}
|
|
|
|
bool OCamlASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
|
|
uint32_t &count, bool &is_complex) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
|
|
bool *is_variadic_ptr) {
|
|
return false;
|
|
}
|
|
|
|
uint32_t
|
|
OCamlASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
|
|
CompilerType *base_type_ptr) {
|
|
return false;
|
|
}
|
|
|
|
size_t OCamlASTContext::GetNumberOfFunctionArguments(
|
|
lldb::opaque_compiler_type_t type) {
|
|
return 0;
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
|
|
const size_t index) {
|
|
return CompilerType();
|
|
}
|
|
|
|
bool OCamlASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
|
|
return IsFunctionType(type);
|
|
}
|
|
|
|
bool OCamlASTContext::IsBlockPointerType(
|
|
lldb::opaque_compiler_type_t type,
|
|
CompilerType *function_pointer_type_ptr) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
|
|
bool &is_signed) {
|
|
if (OCamlPrimitiveType *ptype =
|
|
llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
|
|
switch (ptype->GetTypeKind()) {
|
|
case OCamlPrimitiveType::eTypeInt:
|
|
is_signed = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
is_signed = false;
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
|
|
CompilerType *target_type,
|
|
bool check_cplusplus,
|
|
bool check_objc) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsRuntimeGeneratedType(
|
|
lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
|
|
CompilerType *pointee_type) {
|
|
if (pointee_type)
|
|
pointee_type->Clear();
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsPointerOrReferenceType(
|
|
lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
|
|
return IsPointerType(type, pointee_type);
|
|
}
|
|
|
|
bool OCamlASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
|
|
CompilerType *pointee_type,
|
|
bool *is_rvalue) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
|
|
return llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type));
|
|
}
|
|
|
|
bool OCamlASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
|
|
return false;
|
|
}
|
|
|
|
bool OCamlASTContext::SupportsLanguage(lldb::LanguageType language) {
|
|
return language == lldb::eLanguageTypeOCaml;
|
|
}
|
|
|
|
bool OCamlASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
|
|
if (IsCompleteType(type))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32_t OCamlASTContext::GetPointerByteSize() { return m_pointer_byte_size; }
|
|
|
|
ConstString OCamlASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
|
|
if (type)
|
|
return static_cast<OCamlPrimitiveType *>(type)->GetName();
|
|
|
|
return ConstString();
|
|
}
|
|
|
|
uint32_t
|
|
OCamlASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
|
|
CompilerType *pointee_or_element_compiler_type) {
|
|
if (pointee_or_element_compiler_type)
|
|
pointee_or_element_compiler_type->Clear();
|
|
if (!type)
|
|
return 0;
|
|
|
|
if (OCamlPrimitiveType *ptype =
|
|
llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
|
|
switch (ptype->GetTypeKind()) {
|
|
case OCamlPrimitiveType::eTypeInt:
|
|
return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsInteger |
|
|
eTypeIsSigned;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
lldb::TypeClass
|
|
OCamlASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
|
|
if (llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
|
|
return eTypeClassBuiltin;
|
|
|
|
return lldb::eTypeClassInvalid;
|
|
}
|
|
|
|
lldb::BasicType
|
|
OCamlASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
|
|
return lldb::eBasicTypeInvalid;
|
|
}
|
|
|
|
lldb::LanguageType
|
|
OCamlASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
|
|
return lldb::eLanguageTypeOCaml;
|
|
}
|
|
|
|
unsigned OCamlASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Creating related types
|
|
//----------------------------------------------------------------------
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
|
|
uint64_t *stride) {
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType(this, type);
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType(this, type);
|
|
}
|
|
|
|
int OCamlASTContext::GetFunctionArgumentCount(
|
|
lldb::opaque_compiler_type_t type) {
|
|
return GetNumberOfFunctionArguments(type);
|
|
}
|
|
|
|
CompilerType OCamlASTContext::GetFunctionArgumentTypeAtIndex(
|
|
lldb::opaque_compiler_type_t type, size_t idx) {
|
|
return GetFunctionArgumentAtIndex(type, idx);
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType();
|
|
}
|
|
|
|
size_t
|
|
OCamlASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
|
|
return 0;
|
|
}
|
|
|
|
TypeMemberFunctionImpl
|
|
OCamlASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
|
|
size_t idx) {
|
|
return TypeMemberFunctionImpl();
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType(this, type);
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType OCamlASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
OCamlASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
|
|
size_t bit_size) {
|
|
return CompilerType();
|
|
}
|
|
|
|
uint64_t OCamlASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
|
|
ExecutionContextScope *exe_scope) {
|
|
if (OCamlPrimitiveType *ptype =
|
|
llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
|
|
switch (ptype->GetTypeKind()) {
|
|
case OCamlPrimitiveType::eTypeInt:
|
|
return ptype->GetByteSize() * 8;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
lldb::Encoding OCamlASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
|
|
uint64_t &count) {
|
|
count = 1;
|
|
bool is_signed;
|
|
if (IsIntegerType(type, is_signed))
|
|
return is_signed ? lldb::eEncodingSint : lldb::eEncodingUint;
|
|
bool is_complex;
|
|
uint32_t complex_count;
|
|
if (IsFloatingPointType(type, complex_count, is_complex)) {
|
|
count = complex_count;
|
|
return lldb::eEncodingIEEE754;
|
|
}
|
|
if (IsPointerType(type))
|
|
return lldb::eEncodingUint;
|
|
return lldb::eEncodingInvalid;
|
|
}
|
|
|
|
lldb::Format OCamlASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
|
|
if (!type)
|
|
return lldb::eFormatDefault;
|
|
return lldb::eFormatBytes;
|
|
}
|
|
|
|
size_t OCamlASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
|
|
return 0;
|
|
}
|
|
|
|
uint32_t OCamlASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
|
|
bool omit_empty_base_classes) {
|
|
if (!type || !GetCompleteType(type))
|
|
return 0;
|
|
|
|
return GetNumFields(type);
|
|
}
|
|
|
|
uint32_t OCamlASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
|
|
if (!type || !GetCompleteType(type))
|
|
return 0;
|
|
return 0;
|
|
}
|
|
|
|
CompilerType OCamlASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
|
|
size_t idx, std::string &name,
|
|
uint64_t *bit_offset_ptr,
|
|
uint32_t *bitfield_bit_size_ptr,
|
|
bool *is_bitfield_ptr) {
|
|
if (bit_offset_ptr)
|
|
*bit_offset_ptr = 0;
|
|
if (bitfield_bit_size_ptr)
|
|
*bitfield_bit_size_ptr = 0;
|
|
if (is_bitfield_ptr)
|
|
*is_bitfield_ptr = false;
|
|
|
|
if (!type || !GetCompleteType(type))
|
|
return CompilerType();
|
|
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType OCamlASTContext::GetChildCompilerTypeAtIndex(
|
|
lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
|
|
bool transparent_pointers, bool omit_empty_base_classes,
|
|
bool ignore_array_bounds, std::string &child_name,
|
|
uint32_t &child_byte_size, int32_t &child_byte_offset,
|
|
uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
|
|
bool &child_is_base_class, bool &child_is_deref_of_parent,
|
|
ValueObject *valobj, uint64_t &language_flags) {
|
|
child_name.clear();
|
|
child_byte_size = 0;
|
|
child_byte_offset = 0;
|
|
child_bitfield_bit_size = 0;
|
|
child_bitfield_bit_offset = 0;
|
|
child_is_base_class = false;
|
|
child_is_deref_of_parent = false;
|
|
language_flags = 0;
|
|
|
|
if (!type || !GetCompleteType(type))
|
|
return CompilerType();
|
|
|
|
return CompilerType();
|
|
}
|
|
|
|
uint32_t
|
|
OCamlASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
|
|
const char *name,
|
|
bool omit_empty_base_classes) {
|
|
if (!type || !GetCompleteType(type))
|
|
return UINT_MAX;
|
|
|
|
return UINT_MAX;
|
|
}
|
|
|
|
size_t OCamlASTContext::GetIndexOfChildMemberWithName(
|
|
lldb::opaque_compiler_type_t type, const char *name,
|
|
bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
|
|
uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
|
|
if (index == UINT_MAX)
|
|
return 0;
|
|
child_indexes.push_back(index);
|
|
return 1;
|
|
}
|
|
|
|
size_t
|
|
OCamlASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
|
|
const char *s, uint8_t *dst,
|
|
size_t dst_size) {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Dumping types
|
|
//----------------------------------------------------------------------
|
|
|
|
void OCamlASTContext::DumpValue(
|
|
lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
|
|
lldb::Format format, const DataExtractor &data,
|
|
lldb::offset_t data_byte_offset, size_t data_byte_size,
|
|
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
|
|
bool show_summary, bool verbose, uint32_t depth) {
|
|
if (!type) {
|
|
s->Printf("no type\n");
|
|
return;
|
|
}
|
|
|
|
s->Printf("no value\n");
|
|
|
|
if (show_summary)
|
|
DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
|
|
}
|
|
|
|
bool OCamlASTContext::DumpTypeValue(
|
|
lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
|
|
const DataExtractor &data, lldb::offset_t byte_offset, size_t byte_size,
|
|
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
|
|
ExecutionContextScope *exe_scope) {
|
|
if (!type) {
|
|
s->Printf("no type value\n");
|
|
return false;
|
|
}
|
|
|
|
if (IsScalarType(type)) {
|
|
return data.Dump(s, byte_offset, format, byte_size, 1, UINT64_MAX,
|
|
LLDB_INVALID_ADDRESS, bitfield_bit_size,
|
|
bitfield_bit_offset, exe_scope);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void OCamlASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
|
|
ExecutionContext *exe_ctx, Stream *s,
|
|
const DataExtractor &data,
|
|
lldb::offset_t data_offset,
|
|
size_t data_byte_size) {
|
|
s->Printf("no summary\n");
|
|
}
|
|
|
|
void OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
|
|
StreamFile s(stdout, false);
|
|
DumpTypeDescription(type, &s);
|
|
}
|
|
|
|
void OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
|
|
Stream *s) {
|
|
static_cast<OCamlType *>(type)->Dump(s);
|
|
}
|
|
|
|
CompilerType OCamlASTContext::CreateBaseType(const ConstString &name,
|
|
uint64_t byte_size) {
|
|
if (m_base_type_map.empty()) {
|
|
OCamlPrimitiveType *type = new OCamlPrimitiveType(
|
|
OCamlPrimitiveType::eTypeInt, ConstString("ocaml_int"), byte_size);
|
|
m_base_type_map.emplace(type->GetName(),
|
|
std::unique_ptr<OCamlASTContext::OCamlType>(type));
|
|
}
|
|
|
|
auto it = m_base_type_map.find(name);
|
|
if (it == m_base_type_map.end()) {
|
|
OCamlPrimitiveType *type =
|
|
new OCamlPrimitiveType(OCamlPrimitiveType::eTypeInt, name, byte_size);
|
|
it = m_base_type_map
|
|
.emplace(name, std::unique_ptr<OCamlASTContext::OCamlType>(type))
|
|
.first;
|
|
}
|
|
|
|
return CompilerType(this, it->second.get());
|
|
}
|