[Core] Remove use of ClangASTContext in DumpDataExtractor

[xiaobai]

Summary

DumpDataExtractor uses ClangASTContext in order to get the proper llvm
fltSemantics for the type it needs so that it can dump floats in a more
precise way. However, there's no reason that this behavior needs to be
specific ClangASTContext. Instead, I think it makes sense to ask
TypeSystems for the float semantics for a type of a given size.

[JDevlieghere]

Looks like a good improvement.

Does the APFloatBase::Bogus result of GetFloatTypeSemantics affect the functional behavior of the DumpDataExtractor or does GetAPInt just return None in that case?

[xiaobai]

Hmm, good question. If you call GetAPInt with a byte_size of 0, it should assert when trying to read 0 bytes with the DataExtractor. In the worst case, it gives you a broken APInt. I think guarded the call to GetAPInt to protect against this, but I think that it would also be a good idea to make GetAPInt return llvm::None in that case.

[xiaobai]

Refactored slightly to be a bit safer

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

public:
   // If the current object represents a typedef type, get the underlying type
   CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
 
   // Create related types using the current type's AST
   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
 
   // Exploring the type
 
+  const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) override;
+
   llvm::Optional<uint64_t> GetByteSize(lldb::opaque_compiler_type_t type,
                        ExecutionContextScope *exe_scope) {
     if (llvm::Optional<uint64_t> bit_size = GetBitSize(type, exe_scope))
       return (*bit_size + 7) / 8;
     return llvm::None;
   }
 
   llvm::Optional<uint64_t>

lldb/trunk/include/lldb/Symbol/TypeSystem.h

 //===-- TypeSystem.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_TypeSystem_h_
 #define liblldb_TypeSystem_h_
 
 #include <functional>
 #include <map>
 #include <mutex>
 #include <string>
 
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
public:
   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
                                      const char *name,
                                      const CompilerDeclContext &decl_ctx);
 
   // Exploring the type
 
+  virtual const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) = 0;
+
   virtual llvm::Optional<uint64_t>
   GetBitSize(lldb::opaque_compiler_type_t type,
              ExecutionContextScope *exe_scope) = 0;
 
   virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                                      uint64_t &count) = 0;
 
   virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0;

lldb/trunk/source/Core/DumpDataExtractor.cpp

 //===-- DumpDataExtractor.cpp -----------------------------------*- C++ -*-===//
 //
 // 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/Core/DumpDataExtractor.h"
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/ModuleList.h"
-#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
static float half2float(uint16_t half) {
   v <<= 13;
   u.u = v | 0x70000000U;
   return u.f * ldexpf(1, -112);
 }
 
 static llvm::Optional<llvm::APInt> GetAPInt(const DataExtractor &data,
                                             lldb::offset_t *offset_ptr,
                                             lldb::offset_t byte_size) {
+  if (byte_size == 0)
+    return llvm::None;
+
   llvm::SmallVector<uint64_t, 2> uint64_array;
   lldb::offset_t bytes_left = byte_size;
   uint64_t u64;
   const lldb::ByteOrder byte_order = data.GetByteOrder();
   if (byte_order == lldb::eByteOrderLittle) {
     while (bytes_left > 0) {
       if (bytes_left >= 8) {
         u64 = data.GetU64(offset_ptr);
for (uint32_t count = 0; DE.ValidOffset(offset) && count < item_count;
     } break;
 
     case eFormatFloat: {
       TargetSP target_sp;
       bool used_upfloat = false;
       if (exe_scope)
         target_sp = exe_scope->CalculateTarget();
       if (target_sp) {
-        ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
-        if (clang_ast) {
-          clang::ASTContext *ast = clang_ast->getASTContext();
-          if (ast) {
-            llvm::SmallVector<char, 256> sv;
-            // Show full precision when printing float values
-            const unsigned format_precision = 0;
-            const unsigned format_max_padding =
-                target_sp->GetMaxZeroPaddingInFloatFormat();
-            size_t item_bit_size = item_byte_size * 8;
+        auto type_system_or_err =
+            target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
+        if (!type_system_or_err) {
+          llvm::consumeError(type_system_or_err.takeError());
+        } else {
+          auto &type_system = *type_system_or_err;
 
-            if (item_bit_size == ast->getTypeSize(ast->FloatTy)) {
-              llvm::Optional<llvm::APInt> apint =
-                  GetAPInt(DE, &offset, item_byte_size);
-              if (apint.hasValue()) {
-                llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->FloatTy),
-                                      apint.getValue());
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            } else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) {
-              llvm::Optional<llvm::APInt> apint =
-                  GetAPInt(DE, &offset, item_byte_size);
-              if (apint.hasValue()) {
-                llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy),
-                                      apint.getValue());
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) {
-              const auto &semantics =
-                  ast->getFloatTypeSemantics(ast->LongDoubleTy);
-
-              offset_t byte_size = item_byte_size;
-              if (&semantics == &llvm::APFloatBase::x87DoubleExtended())
-                byte_size = (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
+              type_system.GetFloatTypeSemantics(item_byte_size);
 
-              llvm::Optional<llvm::APInt> apint =
-                  GetAPInt(DE, &offset, byte_size);
-              if (apint.hasValue()) {
-                llvm::APFloat apfloat(semantics, apint.getValue());
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) {
-              llvm::Optional<llvm::APInt> apint =
-                  GetAPInt(DE, &offset, item_byte_size);
-              if (apint.hasValue()) {
-                llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->HalfTy),
-                                      apint.getValue());
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            }
-
+          // Recalculate the byte size in case of a difference. This is possible
+          // when item_byte_size is 16 (128-bit), because you could get back the
+          // x87DoubleExtended semantics which has a byte size of 10 (80-bit).
+          const size_t semantics_byte_size =
+              (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
+              GetAPInt(DE, &offset, semantics_byte_size);
             if (!sv.empty()) {
               s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
               used_upfloat = true;
             }
           }
         }
       }
 

lldb/trunk/source/Symbol/ClangASTContext.cpp

 
 // Create related types using the current type's AST
 
 CompilerType ClangASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
   return ClangASTContext::GetBasicType(getASTContext(), basic_type);
 }
 // Exploring the type
 
+const llvm::fltSemantics &
+ClangASTContext::GetFloatTypeSemantics(size_t byte_size) {
+  if (auto *ast = getASTContext()) {
+    const size_t bit_size = byte_size * 8;
+    if (bit_size == ast->getTypeSize(ast->FloatTy))
+      return ast->getFloatTypeSemantics(ast->FloatTy);
+    else if (bit_size == ast->getTypeSize(ast->DoubleTy))
+      return ast->getFloatTypeSemantics(ast->DoubleTy);
+    else if (bit_size == ast->getTypeSize(ast->LongDoubleTy))
+      return ast->getFloatTypeSemantics(ast->LongDoubleTy);
+    else if (bit_size == ast->getTypeSize(ast->HalfTy))
+      return ast->getFloatTypeSemantics(ast->HalfTy);
+  }
+  return llvm::APFloatBase::Bogus();
+}
+
 Optional<uint64_t>
 ClangASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
                             ExecutionContextScope *exe_scope) {
   if (GetCompleteType(type)) {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record: