Just finishing off a test build. Give me a minute and I'll check it in. Jim
> On Aug 3, 2016, at 2:22 PM, Tamas Berghammer via lldb-commits > <lldb-commits@lists.llvm.org> wrote: > > It is failing because the new files have to be added to the xcode project. > Currently I don't have a Mac around to do it but if nobody fixes it then I > will try to find one. > > Tamás > > On Wed, 3 Aug 2016, 21:17 Tim Hammerquist, <pen...@gmail.com> wrote: > Hi Tamas, > > It looks like the LLDB Build and Check job started failing around the time of > this commit. You can see the error at this link: > > http://lab.llvm.org:8080/green/job/lldb_build_test/19751/consoleFull#-1586822805dd1929ea-7054-4089-b7ef-4624c3781fa4 > > Could you take a look? > > Thanks, > -Tim > > > On Tue, Aug 2, 2016 at 4:15 AM, Tamas Berghammer via lldb-commits > <lldb-commits@lists.llvm.org> wrote: > Author: tberghammer > Date: Tue Aug 2 06:15:55 2016 > New Revision: 277443 > > URL: http://llvm.org/viewvc/llvm-project?rev=277443&view=rev > Log: > Support for OCaml native debugging > > This introduces basic support for debugging OCaml binaries. > Use of the native compiler with DWARF emission support (see > https://github.com/ocaml/ocaml/pull/574) is required. > > Available variables are considered as 64 bits unsigned integers, > their interpretation will be left to a OCaml-made debugging layer. > > Differential revision: https://reviews.llvm.org/D22132 > > Added: > lldb/trunk/include/lldb/Symbol/OCamlASTContext.h > lldb/trunk/source/Plugins/Language/OCaml/ > lldb/trunk/source/Plugins/Language/OCaml/CMakeLists.txt > lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.cpp > lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.h > lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp > lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h > lldb/trunk/source/Symbol/OCamlASTContext.cpp > Modified: > lldb/trunk/cmake/LLDBDependencies.cmake > lldb/trunk/include/lldb/Symbol/TypeSystem.h > lldb/trunk/source/API/SystemInitializerFull.cpp > lldb/trunk/source/Plugins/Language/CMakeLists.txt > lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt > lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h > lldb/trunk/source/Symbol/CMakeLists.txt > > Modified: lldb/trunk/cmake/LLDBDependencies.cmake > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/cmake/LLDBDependencies.cmake?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/cmake/LLDBDependencies.cmake (original) > +++ lldb/trunk/cmake/LLDBDependencies.cmake Tue Aug 2 06:15:55 2016 > @@ -27,6 +27,7 @@ set( LLDB_USED_LIBS > lldbPluginJavaLanguage > lldbPluginObjCLanguage > lldbPluginObjCPlusPlusLanguage > + lldbPluginOCamlLanguage > > lldbPluginObjectFileELF > lldbPluginObjectFileJIT > > Added: lldb/trunk/include/lldb/Symbol/OCamlASTContext.h > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Symbol/OCamlASTContext.h?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/include/lldb/Symbol/OCamlASTContext.h (added) > +++ lldb/trunk/include/lldb/Symbol/OCamlASTContext.h Tue Aug 2 06:15:55 2016 > @@ -0,0 +1,355 @@ > +//===-- OCamlASTContext.h ------------------------------------------*- C++ > -*-===// > +// > +// The LLVM Compiler Infrastructure > +// > +// This file is distributed under the University of Illinois Open Source > +// License. See LICENSE.TXT for details. > +// > +//===----------------------------------------------------------------------===// > + > +#ifndef liblldb_OCamlASTContext_h_ > +#define liblldb_OCamlASTContext_h_ > + > +// C Includes > +// C++ Includes > +#include <map> > +#include <memory> > +#include <set> > +#include <string> > +#include <vector> > + > +// Other libraries and framework includes > +// Project includes > +#include "lldb/Core/ConstString.h" > +#include "lldb/Symbol/TypeSystem.h" > +#include "lldb/Symbol/CompilerType.h" > + > +namespace lldb_private > +{ > + > +class OCamlASTContext : public TypeSystem > +{ > + public: > + class OCamlType; > + typedef std::map<ConstString, std::unique_ptr<OCamlType>> OCamlTypeMap; > + > + OCamlASTContext(); > + ~OCamlASTContext() override; > + > + ConstString > + GetPluginName() override; > + > + uint32_t > + GetPluginVersion() override; > + > + static ConstString > + GetPluginNameStatic (); > + > + static lldb::TypeSystemSP > + CreateInstance (lldb::LanguageType language, Module *module, Target > *target); > + > + static void > + EnumerateSupportedLanguages(std::set<lldb::LanguageType> > &languages_for_types, > + std::set<lldb::LanguageType> > &languages_for_expressions); > + > + static void > + Initialize (); > + > + static void > + Terminate (); > + > + DWARFASTParser *GetDWARFParser() override; > + > + void > + SetAddressByteSize(int byte_size) > + { > + m_pointer_byte_size = byte_size; > + } > + > + static bool classof(const TypeSystem *ts) > + { > + return ts->getKind() == TypeSystem::eKindOCaml; > + } > + > + ConstString > + DeclGetName (void *opaque_decl) override > + { > + return ConstString(); > + } > + > + bool > + DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) override > + { > + return false; > + } > + > + ConstString > + DeclContextGetName(void *opaque_decl_ctx) override > + { > + return ConstString(); > + } > + > + ConstString > + DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override > + { > + return ConstString(); > + } > + > + bool > + DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType > *language_ptr, > + bool *is_instance_method_ptr, > + ConstString *language_object_name_ptr) override > + { > + return false; > + } > + > + bool SupportsLanguage (lldb::LanguageType language) override; > + uint32_t GetPointerByteSize() override; > + > + bool > + IsArrayType(lldb::opaque_compiler_type_t type, CompilerType > *element_type, > + uint64_t *size, bool *is_incomplete) override; > + > + bool IsAggregateType(lldb::opaque_compiler_type_t type) override; > + > + bool IsCharType(lldb::opaque_compiler_type_t type) override; > + > + bool IsCompleteType(lldb::opaque_compiler_type_t type) override; > + > + bool IsDefined(lldb::opaque_compiler_type_t type) override; > + > + bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t > &count, bool &is_complex) override; > + > + bool IsFunctionType(lldb::opaque_compiler_type_t type, bool > *is_variadic_ptr = nullptr) override; > + > + size_t GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) > override; > + > + CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t > type, const size_t index) override; > + > + bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override; > + > + bool IsBlockPointerType (lldb::opaque_compiler_type_t type, > + CompilerType *function_pointer_type_ptr) > override; > + > + bool > + IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed) > override; > + > + bool > + IsPossibleDynamicType(lldb::opaque_compiler_type_t type, > + CompilerType *target_type, > + bool check_cplusplus, bool check_objc) > override; > + > + bool IsPointerType(lldb::opaque_compiler_type_t type, CompilerType > *pointee_type = nullptr) override; > + > + bool IsScalarType(lldb::opaque_compiler_type_t type) override; > + > + bool IsVoidType(lldb::opaque_compiler_type_t type) override; > + > + bool GetCompleteType(lldb::opaque_compiler_type_t type) override; > + > + ConstString GetTypeName(lldb::opaque_compiler_type_t type) override; > + > + uint32_t > + GetTypeInfo(lldb::opaque_compiler_type_t type, > + CompilerType *pointee_or_element_compiler_type = nullptr) > override; > + > + lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) > override; > + > + lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override; > + > + CompilerType > + GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride > = nullptr) override; > + > + CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) > override; > + > + int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override; > + > + CompilerType > + GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t > idx) override; > + > + CompilerType > + GetFunctionReturnType(lldb::opaque_compiler_type_t type) override; > + > + size_t > + GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override; > + > + TypeMemberFunctionImpl > + GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) > override; > + > + CompilerType > + GetPointeeType(lldb::opaque_compiler_type_t type) override; > + > + CompilerType > + GetPointerType(lldb::opaque_compiler_type_t type) override; > + > + uint64_t > + GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope > *exe_scope) override; > + > + lldb::Encoding > + GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override; > + > + lldb::Format > + GetFormat(lldb::opaque_compiler_type_t type) override; > + > + uint32_t > + GetNumChildren(lldb::opaque_compiler_type_t type, bool > omit_empty_base_classes) override; > + > + lldb::BasicType > + GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override; > + > + CompilerType > + GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t > bit_size) override; > + > + uint32_t > + GetNumFields(lldb::opaque_compiler_type_t type) override; > + > + CompilerType > + 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) > override; > + > + uint32_t > + GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override > + { > + return 0; > + } > + > + uint32_t > + GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override > + { > + return 0; > + } > + > + CompilerType > + GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, > uint32_t *bit_offset_ptr) override > + { > + return CompilerType(); > + } > + > + CompilerType > + GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t > idx, uint32_t *bit_offset_ptr) override > + { > + return CompilerType(); > + } > + > + CompilerType > + 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) override; > + > + uint32_t > + GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char > *name, bool omit_empty_base_classes) override; > + > + size_t > + GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, > + const char *name, bool > omit_empty_base_classes, > + std::vector<uint32_t> &child_indexes) > override; > + > + size_t > + GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override > + { > + return 0; > + } > + > + CompilerType > + GetTemplateArgument(lldb::opaque_compiler_type_t type, > + size_t idx, lldb::TemplateArgumentKind &kind) > override > + { > + return CompilerType(); > + } > + > + void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext > *exe_ctx, > + Stream *s, lldb::Format format, const DataExtractor &data, > + lldb::offset_t data_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) override; > + > + bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, > + lldb::Format format, const DataExtractor &data, > + lldb::offset_t data_offset, size_t data_byte_size, > + uint32_t bitfield_bit_size, uint32_t > bitfield_bit_offset, > + ExecutionContextScope *exe_scope) override; > + > + void > + DumpTypeDescription(lldb::opaque_compiler_type_t type) override; > + > + void > + DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) > override; > + > + bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override; > + > + void > + 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) override; > + > + size_t > + ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char > *s, > + uint8_t *dst, size_t dst_size) override; > + > + bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, > + CompilerType *pointee_type = nullptr) > override; > + > + unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override; > + > + bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) > override; > + > + size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override; > + > + CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override; > + > + bool IsBeingDefined(lldb::opaque_compiler_type_t type) override; > + > + bool IsConst(lldb::opaque_compiler_type_t type) override; > + > + uint32_t > + IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType > *base_type_ptr) override; > + > + bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override; > + > + bool IsTypedefType(lldb::opaque_compiler_type_t type) override; > + > + CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) > override; > + > + bool > + IsVectorType(lldb::opaque_compiler_type_t type, CompilerType > *element_type, > + uint64_t *size) override; > + > + CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) > override; > + > + CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) > override; > + > + bool > + IsReferenceType(lldb::opaque_compiler_type_t type, > + CompilerType *pointee_type = nullptr, > + bool *is_rvalue = nullptr) override; > + > + CompilerType CreateBaseType(const ConstString &name, uint64_t); > + > + private: > + int m_pointer_byte_size; > + int m_int_byte_size; > + std::unique_ptr<DWARFASTParser> m_dwarf_ast_parser_ap; > + OCamlTypeMap m_base_type_map; > + > + OCamlASTContext(const OCamlASTContext &) = delete; > + const OCamlASTContext &operator=(const OCamlASTContext &) = delete; > +}; > + > +class OCamlASTContextForExpr : public OCamlASTContext > +{ > + public: > + OCamlASTContextForExpr(lldb::TargetSP target) : m_target_wp(target) > {} > + > + private: > + lldb::TargetWP m_target_wp; > +}; > + > +} > +#endif // liblldb_OCamlASTContext_h_ > > Modified: lldb/trunk/include/lldb/Symbol/TypeSystem.h > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Symbol/TypeSystem.h?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/include/lldb/Symbol/TypeSystem.h (original) > +++ lldb/trunk/include/lldb/Symbol/TypeSystem.h Tue Aug 2 06:15:55 2016 > @@ -75,6 +75,7 @@ public: > eKindSwift, > eKindGo, > eKindJava, > + eKindOCaml, > kNumKinds > }; > > > Modified: lldb/trunk/source/API/SystemInitializerFull.cpp > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SystemInitializerFull.cpp?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/source/API/SystemInitializerFull.cpp (original) > +++ lldb/trunk/source/API/SystemInitializerFull.cpp Tue Aug 2 06:15:55 2016 > @@ -27,6 +27,7 @@ > #include "lldb/Symbol/ClangASTContext.h" > #include "lldb/Symbol/GoASTContext.h" > #include "lldb/Symbol/JavaASTContext.h" > +#include "lldb/Symbol/OCamlASTContext.h" > > #include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h" > #include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h" > @@ -56,6 +57,7 @@ > #include "Plugins/Language/Java/JavaLanguage.h" > #include "Plugins/Language/ObjC/ObjCLanguage.h" > #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h" > +#include "Plugins/Language/OCaml/OCamlLanguage.h" > #include > "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h" > #include "Plugins/LanguageRuntime/Go/GoLanguageRuntime.h" > #include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h" > @@ -314,6 +316,7 @@ SystemInitializerFull::Initialize() > ClangASTContext::Initialize(); > GoASTContext::Initialize(); > JavaASTContext::Initialize(); > + OCamlASTContext::Initialize(); > > ABIMacOSX_i386::Initialize(); > ABIMacOSX_arm::Initialize(); > @@ -360,6 +363,7 @@ SystemInitializerFull::Initialize() > JavaLanguage::Initialize(); > ObjCLanguage::Initialize(); > ObjCPlusPlusLanguage::Initialize(); > + OCamlLanguage::Initialize(); > > #if defined(_MSC_VER) > ProcessWindowsLive::Initialize(); > @@ -444,6 +448,7 @@ SystemInitializerFull::Terminate() > ClangASTContext::Terminate(); > GoASTContext::Terminate(); > JavaASTContext::Terminate(); > + OCamlASTContext::Terminate(); > > ABIMacOSX_i386::Terminate(); > ABIMacOSX_arm::Terminate(); > @@ -488,6 +493,7 @@ SystemInitializerFull::Terminate() > JavaLanguage::Terminate(); > ObjCLanguage::Terminate(); > ObjCPlusPlusLanguage::Terminate(); > + OCamlLanguage::Terminate(); > > #if defined(__APPLE__) > DynamicLoaderDarwinKernel::Terminate(); > > Modified: lldb/trunk/source/Plugins/Language/CMakeLists.txt > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Language/CMakeLists.txt?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/source/Plugins/Language/CMakeLists.txt (original) > +++ lldb/trunk/source/Plugins/Language/CMakeLists.txt Tue Aug 2 06:15:55 2016 > @@ -3,3 +3,4 @@ add_subdirectory(Go) > add_subdirectory(Java) > add_subdirectory(ObjC) > add_subdirectory(ObjCPlusPlus) > +add_subdirectory(OCaml) > > Added: lldb/trunk/source/Plugins/Language/OCaml/CMakeLists.txt > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Language/OCaml/CMakeLists.txt?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Plugins/Language/OCaml/CMakeLists.txt (added) > +++ lldb/trunk/source/Plugins/Language/OCaml/CMakeLists.txt Tue Aug 2 > 06:15:55 2016 > @@ -0,0 +1,4 @@ > +add_lldb_library(lldbPluginOCamlLanguage > + OCamlLanguage.cpp > +) > + > > Added: lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.cpp > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.cpp?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.cpp (added) > +++ lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.cpp Tue Aug 2 > 06:15:55 2016 > @@ -0,0 +1,78 @@ > +//===-- OCamlLanguage.cpp ----------------------------------------*- C++ > -*-===// > +// > +// The LLVM Compiler Infrastructure > +// > +// This file is distributed under the University of Illinois Open Source > +// License. See LICENSE.TXT for details. > +// > +//===----------------------------------------------------------------------===// > + > +// C Includes > +#include <string.h> > +// C++ Includes > +#include <functional> > +#include <mutex> > + > +// Other libraries and framework includes > +#include "llvm/ADT/StringRef.h" > + > +// Project includes > +#include "OCamlLanguage.h" > +#include "lldb/Core/ConstString.h" > +#include "lldb/Core/PluginManager.h" > +#include "lldb/DataFormatters/DataVisualization.h" > +#include "lldb/DataFormatters/FormattersHelpers.h" > +#include "lldb/Symbol/OCamlASTContext.h" > + > +using namespace lldb; > +using namespace lldb_private; > + > +void > +OCamlLanguage::Initialize() > +{ > + PluginManager::RegisterPlugin(GetPluginNameStatic(), "OCaml Language", > CreateInstance); > +} > + > +void > +OCamlLanguage::Terminate() > +{ > + PluginManager::UnregisterPlugin(CreateInstance); > +} > + > +lldb_private::ConstString > +OCamlLanguage::GetPluginNameStatic() > +{ > + static ConstString g_name("OCaml"); > + return g_name; > +} > + > +lldb_private::ConstString > +OCamlLanguage::GetPluginName() > +{ > + return GetPluginNameStatic(); > +} > + > +uint32_t > +OCamlLanguage::GetPluginVersion() > +{ > + return 1; > +} > + > +Language * > +OCamlLanguage::CreateInstance(lldb::LanguageType language) > +{ > + if (language == eLanguageTypeOCaml) > + return new OCamlLanguage(); > + return nullptr; > +} > + > +bool > +OCamlLanguage::IsNilReference(ValueObject &valobj) > +{ > + if (!valobj.GetCompilerType().IsReferenceType()) > + return false; > + > + // If we failed to read the value then it is not a nil reference. > + return valobj.GetValueAsUnsigned(UINT64_MAX) == 0; > +} > + > > Added: lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.h > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.h?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.h (added) > +++ lldb/trunk/source/Plugins/Language/OCaml/OCamlLanguage.h Tue Aug 2 > 06:15:55 2016 > @@ -0,0 +1,61 @@ > +//===-- OCamlLanguage.h ------------------------------------------*- C++ > -*-===// > +// > +// The LLVM Compiler Infrastructure > +// > +// This file is distributed under the University of Illinois Open Source > +// License. See LICENSE.TXT for details. > +// > +//===----------------------------------------------------------------------===// > + > +#ifndef liblldb_OCamlLanguage_h_ > +#define liblldb_OCamlLanguage_h_ > + > +// C Includes > +// C++ Includes > +#include <vector> > + > +// Other libraries and framework includes > +#include "llvm/ADT/StringRef.h" > + > +// Project includes > +#include "lldb/Core/ConstString.h" > +#include "lldb/Target/Language.h" > +#include "lldb/lldb-private.h" > + > +namespace lldb_private > +{ > + > +class OCamlLanguage : public Language > +{ > +public: > + lldb::LanguageType > + GetLanguageType() const override > + { > + return lldb::eLanguageTypeOCaml; > + } > + > + static void > + Initialize(); > + > + static void > + Terminate(); > + > + static lldb_private::Language * > + CreateInstance(lldb::LanguageType language); > + > + static lldb_private::ConstString > + GetPluginNameStatic(); > + > + ConstString > + GetPluginName() override; > + > + uint32_t > + GetPluginVersion() override; > + > + bool > + IsNilReference(ValueObject &valobj) override; > +}; > + > +} // namespace lldb_private > + > +#endif // liblldb_OCamlLanguage_h_ > > Modified: lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt (original) > +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt Tue Aug 2 > 06:15:55 2016 > @@ -4,6 +4,7 @@ add_lldb_library(lldbPluginSymbolFileDWA > DWARFASTParserClang.cpp > DWARFASTParserGo.cpp > DWARFASTParserJava.cpp > + DWARFASTParserOCaml.cpp > DWARFAttribute.cpp > DWARFCompileUnit.cpp > DWARFDataExtractor.cpp > > Added: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp (added) > +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp Tue > Aug 2 06:15:55 2016 > @@ -0,0 +1,232 @@ > +//===-- DWARFASTParserOCaml.cpp ---------------------------------*- C++ > -*-===// > + > +#include "DWARFASTParserOCaml.h" > + > +#include "lldb/Core/Error.h" > +#include "lldb/Core/Log.h" > +#include "lldb/Core/Module.h" > +#include "lldb/Symbol/CompileUnit.h" > +#include "lldb/Symbol/Function.h" > +#include "lldb/Symbol/ObjectFile.h" > +#include "lldb/Symbol/Type.h" > +#include "lldb/Symbol/TypeList.h" > + > +using namespace lldb; > +using namespace lldb_private; > + > +DWARFASTParserOCaml::DWARFASTParserOCaml (OCamlASTContext &ast) : > + m_ast (ast) > +{} > + > +DWARFASTParserOCaml::~DWARFASTParserOCaml () {} > + > +TypeSP > +DWARFASTParserOCaml::ParseBaseTypeFromDIE(const DWARFDIE &die) > +{ > + SymbolFileDWARF *dwarf = die.GetDWARF(); > + dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED; > + > + ConstString type_name; > + uint64_t byte_size = 0; > + > + DWARFAttributes attributes; > + const size_t num_attributes = die.GetAttributes(attributes); > + for (uint32_t i = 0; i < num_attributes; ++i) > + { > + DWARFFormValue form_value; > + dw_attr_t attr = attributes.AttributeAtIndex(i); > + if (attributes.ExtractFormValueAtIndex(i, form_value)) > + { > + switch (attr) > + { > + case DW_AT_name: > + type_name.SetCString(form_value.AsCString()); > + break; > + case DW_AT_byte_size: > + byte_size = form_value.Unsigned(); > + break; > + case DW_AT_encoding: > + break; > + default: > + assert(false && "Unsupported attribute for > DW_TAG_base_type"); > + } > + } > + } > + > + Declaration decl; > + CompilerType compiler_type = m_ast.CreateBaseType(type_name, byte_size); > + return std::make_shared<Type>(die.GetID(), dwarf, type_name, byte_size, > nullptr, LLDB_INVALID_UID, > + Type::eEncodingIsUID, decl, compiler_type, > Type::eResolveStateFull); > +} > + > +lldb::TypeSP > +DWARFASTParserOCaml::ParseTypeFromDWARF (const SymbolContext& sc, > + const DWARFDIE &die, > + Log *log, > + bool *type_is_new_ptr) > +{ > + if (type_is_new_ptr) > + *type_is_new_ptr = false; > + > + if (!die) > + return nullptr; > + > + SymbolFileDWARF *dwarf = die.GetDWARF(); > + > + Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE()); > + if (type_ptr == DIE_IS_BEING_PARSED) > + return nullptr; > + if (type_ptr != nullptr) > + return type_ptr->shared_from_this(); > + > + TypeSP type_sp; > + if (type_is_new_ptr) > + *type_is_new_ptr = true; > + > + switch (die.Tag()) > + { > + case DW_TAG_base_type: > + { > + type_sp = ParseBaseTypeFromDIE(die); > + break; > + } > + case DW_TAG_array_type: > + { > + break; > + } > + case DW_TAG_class_type: > + { > + break; > + } > + case DW_TAG_reference_type: > + { > + break; > + } > + } > + > + if (!type_sp) > + return nullptr; > + > + DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die); > + dw_tag_t sc_parent_tag = sc_parent_die.Tag(); > + > + SymbolContextScope *symbol_context_scope = nullptr; > + if (sc_parent_tag == DW_TAG_compile_unit) > + { > + symbol_context_scope = sc.comp_unit; > + } > + else if (sc.function != nullptr && sc_parent_die) > + { > + symbol_context_scope = > sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); > + if (symbol_context_scope == nullptr) > + symbol_context_scope = sc.function; > + } > + > + if (symbol_context_scope != nullptr) > + type_sp->SetSymbolContextScope(symbol_context_scope); > + > + dwarf->GetTypeList()->Insert(type_sp); > + dwarf->m_die_to_type[die.GetDIE()] = type_sp.get(); > + > + return type_sp; > +} > + > +Function * > +DWARFASTParserOCaml::ParseFunctionFromDWARF (const SymbolContext& sc, > + const DWARFDIE &die) > +{ > + DWARFRangeList func_ranges; > + const char *name = NULL; > + const char *mangled = NULL; > + int decl_file = 0; > + int decl_line = 0; > + int decl_column = 0; > + int call_file = 0; > + int call_line = 0; > + int call_column = 0; > + DWARFExpression frame_base(die.GetCU()); > + > + Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_LANGUAGE)); > + > + if (die) > + { > + SymbolFileDWARF *dwarf = die.GetDWARF(); > + if (log) > + { > + dwarf->GetObjectFile()->GetModule()->LogMessage( > + log, "DWARFASTParserOCaml::ParseFunctionFromDWARF (die = > 0x%8.8x) %s name = '%s')", die.GetOffset(), > + DW_TAG_value_to_name(die.Tag()), die.GetName()); > + } > + } > + > + assert(die.Tag() == DW_TAG_subprogram); > + > + if (die.Tag() != DW_TAG_subprogram) > + return NULL; > + > + if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, > decl_line, decl_column, call_file, call_line, > + call_column, &frame_base)) > + { > + AddressRange func_range; > + lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase(0); > + lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd(0); > + if (lowest_func_addr != LLDB_INVALID_ADDRESS && lowest_func_addr <= > highest_func_addr) > + { > + ModuleSP module_sp(die.GetModule()); > + > func_range.GetBaseAddress().ResolveAddressUsingFileSections(lowest_func_addr, > module_sp->GetSectionList()); > + if (func_range.GetBaseAddress().IsValid()) > + func_range.SetByteSize(highest_func_addr - lowest_func_addr); > + } > + > + if (func_range.GetBaseAddress().IsValid()) > + { > + Mangled func_name; > + > + func_name.SetValue(ConstString(name), true); > + > + FunctionSP func_sp; > + std::unique_ptr<Declaration> decl_ap; > + if (decl_file != 0 || decl_line != 0 || decl_column != 0) > + decl_ap.reset(new > Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file), > decl_line, > + decl_column)); > + > + SymbolFileDWARF *dwarf = die.GetDWARF(); > + Type *func_type = dwarf->m_die_to_type.lookup(die.GetDIE()); > + > + assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED); > + > + if (dwarf->FixupAddress(func_range.GetBaseAddress())) > + { > + const user_id_t func_user_id = die.GetID(); > + func_sp.reset(new Function(sc.comp_unit, > + func_user_id, // UserID is the > DIE offset > + func_user_id, > + func_name, > + func_type, > + func_range)); // first address > range > + > + if (func_sp.get() != NULL) > + { > + if (frame_base.IsValid()) > + func_sp->GetFrameBaseExpression() = frame_base; > + sc.comp_unit->AddFunction(func_sp); > + return func_sp.get(); > + } > + } > + } > + } > + > + return NULL; > +} > + > +lldb_private::CompilerDeclContext > +DWARFASTParserOCaml::GetDeclContextForUIDFromDWARF (const DWARFDIE &die) > +{ > + return CompilerDeclContext(); > +} > + > +lldb_private::CompilerDeclContext > +DWARFASTParserOCaml::GetDeclContextContainingUIDFromDWARF (const DWARFDIE > &die) > +{ > + return CompilerDeclContext(); > +} > > Added: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h (added) > +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h Tue Aug > 2 06:15:55 2016 > @@ -0,0 +1,60 @@ > +//===-- DWARFASTParserOCaml.h -----------------------------------*- C++ > -*-===// > + > +#ifndef SymbolFileDWARF_DWARFASTParserOCaml_h_ > +#define SymbolFileDWARF_DWARFASTParserOCaml_h_ > + > +#include "DWARFASTParser.h" > +#include "DWARFCompileUnit.h" > +#include "DWARFDebugInfo.h" > +#include "DWARFDIE.h" > +#include "DWARFDefines.h" > +#include "SymbolFileDWARF.h" > + > +#include "lldb/Symbol/OCamlASTContext.h" > + > +class DWARFDebugInfoEntry; > +class DWARFDIECollection; > + > +class DWARFASTParserOCaml : public DWARFASTParser > +{ > +public: > + DWARFASTParserOCaml (lldb_private::OCamlASTContext &ast); > + > + virtual ~DWARFASTParserOCaml (); > + > + lldb::TypeSP > + ParseBaseTypeFromDIE(const DWARFDIE &die); > + > + lldb::TypeSP > + ParseTypeFromDWARF (const lldb_private::SymbolContext& sc, > + const DWARFDIE &die, > + lldb_private::Log *log, > + bool *type_is_new_ptr) override; > + > + lldb_private::Function * > + ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc, > + const DWARFDIE &die) override; > + > + bool > + CompleteTypeFromDWARF (const DWARFDIE &die, > + lldb_private::Type *type, > + lldb_private::CompilerType &compiler_type) > override { return false; } > + > + lldb_private::CompilerDecl > + GetDeclForUIDFromDWARF (const DWARFDIE &die) override { return > lldb_private::CompilerDecl(); } > + > + lldb_private::CompilerDeclContext > + GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override; > + > + lldb_private::CompilerDeclContext > + GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override; > + > + std::vector<DWARFDIE> > + GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) > override { return {}; } > + > +protected: > + > + lldb_private::OCamlASTContext &m_ast; > +}; > + > +#endif // SymbolFileDWARF_DWARFASTParserOCaml_h_ > > Modified: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h (original) > +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h Tue Aug 2 > 06:15:55 2016 > @@ -74,6 +74,7 @@ public: > friend class DWARFASTParserClang; > friend class DWARFASTParserGo; > friend class DWARFASTParserJava; > + friend class DWARFASTParserOCaml; > > //------------------------------------------------------------------ > // Static Functions > > Modified: lldb/trunk/source/Symbol/CMakeLists.txt > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Symbol/CMakeLists.txt?rev=277443&r1=277442&r2=277443&view=diff > ============================================================================== > --- lldb/trunk/source/Symbol/CMakeLists.txt (original) > +++ lldb/trunk/source/Symbol/CMakeLists.txt Tue Aug 2 06:15:55 2016 > @@ -21,6 +21,7 @@ add_lldb_library(lldbSymbol > LineEntry.cpp > LineTable.cpp > ObjectFile.cpp > + OCamlASTContext.cpp > Symbol.cpp > SymbolContext.cpp > SymbolFile.cpp > > Added: lldb/trunk/source/Symbol/OCamlASTContext.cpp > URL: > http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Symbol/OCamlASTContext.cpp?rev=277443&view=auto > ============================================================================== > --- lldb/trunk/source/Symbol/OCamlASTContext.cpp (added) > +++ lldb/trunk/source/Symbol/OCamlASTContext.cpp Tue Aug 2 06:15:55 2016 > @@ -0,0 +1,798 @@ > +//===-- 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/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/OCamlASTContext.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), > + m_int_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; > + default: > + break; > + } > + } > + > + 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()); > +} > + > > > _______________________________________________ > lldb-commits mailing list > lldb-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits > > > > -- > Tim <pen...@gmail.com> > _______________________________________________ > lldb-commits mailing list > lldb-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
