[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/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/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/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"
 
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;
+          if (semantics_byte_size != 0) {
+                GetAPInt(DE, &offset, semantics_byte_size);
               if (!sv.empty()) {
                 s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
                 used_upfloat = true;
               }
             }
           }
         }
+      }
 
       if (!used_upfloat) {
         std::ostringstream ss;
         if (item_byte_size == sizeof(float) || item_byte_size == 2) {
           float f;
           if (item_byte_size == 2) {
             uint16_t half = DE.GetU16(&offset);
             f = half2float(half);

lldb/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: