LCOV - code coverage report
Current view: top level - lib/DebugInfo/CodeView - TypeIndex.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 19 20 95.0 %
Date: 2017-09-14 15:23:50 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- TypeIndex.cpp - CodeView type index ---------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #include "llvm/DebugInfo/CodeView/TypeIndex.h"
      11             : 
      12             : #include "llvm/DebugInfo/CodeView/TypeCollection.h"
      13             : #include "llvm/Support/ScopedPrinter.h"
      14             : 
      15             : using namespace llvm;
      16             : using namespace llvm::codeview;
      17             : 
      18             : namespace {
      19             : struct SimpleTypeEntry {
      20             :   StringRef Name;
      21             :   SimpleTypeKind Kind;
      22             : };
      23             : 
      24             : /// The names here all end in "*". If the simple type is a pointer type, we
      25             : /// return the whole name. Otherwise we lop off the last character in our
      26             : /// StringRef.
      27             : static const SimpleTypeEntry SimpleTypeNames[] = {
      28             :     {"void*", SimpleTypeKind::Void},
      29             :     {"<not translated>*", SimpleTypeKind::NotTranslated},
      30             :     {"HRESULT*", SimpleTypeKind::HResult},
      31             :     {"signed char*", SimpleTypeKind::SignedCharacter},
      32             :     {"unsigned char*", SimpleTypeKind::UnsignedCharacter},
      33             :     {"char*", SimpleTypeKind::NarrowCharacter},
      34             :     {"wchar_t*", SimpleTypeKind::WideCharacter},
      35             :     {"char16_t*", SimpleTypeKind::Character16},
      36             :     {"char32_t*", SimpleTypeKind::Character32},
      37             :     {"__int8*", SimpleTypeKind::SByte},
      38             :     {"unsigned __int8*", SimpleTypeKind::Byte},
      39             :     {"short*", SimpleTypeKind::Int16Short},
      40             :     {"unsigned short*", SimpleTypeKind::UInt16Short},
      41             :     {"__int16*", SimpleTypeKind::Int16},
      42             :     {"unsigned __int16*", SimpleTypeKind::UInt16},
      43             :     {"long*", SimpleTypeKind::Int32Long},
      44             :     {"unsigned long*", SimpleTypeKind::UInt32Long},
      45             :     {"int*", SimpleTypeKind::Int32},
      46             :     {"unsigned*", SimpleTypeKind::UInt32},
      47             :     {"__int64*", SimpleTypeKind::Int64Quad},
      48             :     {"unsigned __int64*", SimpleTypeKind::UInt64Quad},
      49             :     {"__int64*", SimpleTypeKind::Int64},
      50             :     {"unsigned __int64*", SimpleTypeKind::UInt64},
      51             :     {"__int128*", SimpleTypeKind::Int128},
      52             :     {"unsigned __int128*", SimpleTypeKind::UInt128},
      53             :     {"__half*", SimpleTypeKind::Float16},
      54             :     {"float*", SimpleTypeKind::Float32},
      55             :     {"float*", SimpleTypeKind::Float32PartialPrecision},
      56             :     {"__float48*", SimpleTypeKind::Float48},
      57             :     {"double*", SimpleTypeKind::Float64},
      58             :     {"long double*", SimpleTypeKind::Float80},
      59             :     {"__float128*", SimpleTypeKind::Float128},
      60             :     {"_Complex float*", SimpleTypeKind::Complex32},
      61             :     {"_Complex double*", SimpleTypeKind::Complex64},
      62             :     {"_Complex long double*", SimpleTypeKind::Complex80},
      63             :     {"_Complex __float128*", SimpleTypeKind::Complex128},
      64             :     {"bool*", SimpleTypeKind::Boolean8},
      65             :     {"__bool16*", SimpleTypeKind::Boolean16},
      66             :     {"__bool32*", SimpleTypeKind::Boolean32},
      67             :     {"__bool64*", SimpleTypeKind::Boolean64},
      68     2964546 : };
      69             : } // namespace
      70             : 
      71        1386 : StringRef TypeIndex::simpleTypeName(TypeIndex TI) {
      72             :   assert(TI.isNoneType() || TI.isSimple());
      73             : 
      74        1386 :   if (TI.isNoneType())
      75           4 :     return "<no type>";
      76             : 
      77             :   // This is a simple type.
      78       31370 :   for (const auto &SimpleTypeName : SimpleTypeNames) {
      79       32752 :     if (SimpleTypeName.Kind == TI.getSimpleKind()) {
      80        1382 :       if (TI.getSimpleMode() == SimpleTypeMode::Direct)
      81        1360 :         return SimpleTypeName.Name.drop_back(1);
      82             :       // Otherwise, this is a pointer type. We gloss over the distinction
      83             :       // between near, far, 64, 32, etc, and just give a pointer type.
      84          22 :       return SimpleTypeName.Name;
      85             :     }
      86             :   }
      87           0 :   return "<unknown simple type>";
      88             : }
      89             : 
      90        4838 : void llvm::codeview::printTypeIndex(ScopedPrinter &Printer, StringRef FieldName,
      91             :                                     TypeIndex TI, TypeCollection &Types) {
      92        4838 :   StringRef TypeName;
      93        4838 :   if (!TI.isNoneType()) {
      94        3782 :     if (TI.isSimple())
      95         711 :       TypeName = TypeIndex::simpleTypeName(TI);
      96             :     else
      97        3071 :       TypeName = Types.getTypeName(TI);
      98             :   }
      99             : 
     100        4838 :   if (!TypeName.empty())
     101        3688 :     Printer.printHex(FieldName, TypeName, TI.getIndex());
     102             :   else
     103        1150 :     Printer.printHex(FieldName, TI.getIndex());
     104      221756 : }

Generated by: LCOV version 1.13