unittests/IR/DebugInfoTest.cpp

   1 //===- llvm/unittest/IR/DebugInfo.cpp - DebugInfo tests -------------------===//
   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/IR/DebugInfo.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14
  15 namespace llvm {
  16
  17 static void PrintTo(const StringRef &S, ::std::ostream *os) {
  18   *os << "(" << (const void *)S.data() << "," << S.size() << ") = '";
  19   for (auto C : S)
  20     if (C)
  21       *os << C;
  22     else
  23       *os << "\\00";
  24   *os << "'";
  25 }
  26 static void PrintTo(const DIHeaderFieldIterator &I, ::std::ostream *os) {
  27   PrintTo(I.getCurrent(), os);
  28   *os << " in ";
  29   PrintTo(I.getHeader(), os);
  30 }
  31
  32 } // end namespace llvm
  33
  34 namespace {
  35
  36 #define MAKE_FIELD_ITERATOR(S)                                                 \
  37   DIHeaderFieldIterator(StringRef(S, sizeof(S) - 1))
  38 TEST(DebugInfoTest, DIHeaderFieldIterator) {
  39   ASSERT_EQ(DIHeaderFieldIterator(), DIHeaderFieldIterator());
  40
  41   ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR(""));
  42   ASSERT_EQ(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR(""));
  43   ASSERT_EQ("", *DIHeaderFieldIterator(""));
  44
  45   ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("stuff"));
  46   ASSERT_EQ(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("stuff"));
  47   ASSERT_EQ("stuff", *DIHeaderFieldIterator("stuff"));
  48
  49   ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("st\0uff"));
  50   ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("st\0uff"));
  51   ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("st\0uff"));
  52   ASSERT_EQ("st", *MAKE_FIELD_ITERATOR("st\0uff"));
  53   ASSERT_EQ("uff", *++MAKE_FIELD_ITERATOR("st\0uff"));
  54
  55   ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("stuff\0"));
  56   ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("stuff\0"));
  57   ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("stuff\0"));
  58   ASSERT_EQ("stuff", *MAKE_FIELD_ITERATOR("stuff\0"));
  59   ASSERT_EQ("", *++MAKE_FIELD_ITERATOR("stuff\0"));
  60
  61   ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("\0stuff"));
  62   ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("\0stuff"));
  63   ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("\0stuff"));
  64   ASSERT_EQ("", *MAKE_FIELD_ITERATOR("\0stuff"));
  65   ASSERT_EQ("stuff", *++MAKE_FIELD_ITERATOR("\0stuff"));
  66 }
  67
  68 TEST(DIDescriptorTest, getFlag) {
  69   // Some valid flags.
  70   EXPECT_EQ(DIDescriptor::FlagPublic, DIDescriptor::getFlag("DIFlagPublic"));
  71   EXPECT_EQ(DIDescriptor::FlagProtected,
  72             DIDescriptor::getFlag("DIFlagProtected"));
  73   EXPECT_EQ(DIDescriptor::FlagPrivate, DIDescriptor::getFlag("DIFlagPrivate"));
  74   EXPECT_EQ(DIDescriptor::FlagVector, DIDescriptor::getFlag("DIFlagVector"));
  75   EXPECT_EQ(DIDescriptor::FlagRValueReference,
  76             DIDescriptor::getFlag("DIFlagRValueReference"));
  77
  78   // FlagAccessibility shouldn't work.
  79   EXPECT_EQ(0u, DIDescriptor::getFlag("DIFlagAccessibility"));
  80
  81   // Some other invalid strings.
  82   EXPECT_EQ(0u, DIDescriptor::getFlag("FlagVector"));
  83   EXPECT_EQ(0u, DIDescriptor::getFlag("Vector"));
  84   EXPECT_EQ(0u, DIDescriptor::getFlag("other things"));
  85   EXPECT_EQ(0u, DIDescriptor::getFlag("DIFlagOther"));
  86 }
  87
  88 TEST(DIDescriptorTest, getFlagString) {
  89   // Some valid flags.
  90   EXPECT_EQ(StringRef("DIFlagPublic"),
  91             DIDescriptor::getFlagString(DIDescriptor::FlagPublic));
  92   EXPECT_EQ(StringRef("DIFlagProtected"),
  93             DIDescriptor::getFlagString(DIDescriptor::FlagProtected));
  94   EXPECT_EQ(StringRef("DIFlagPrivate"),
  95             DIDescriptor::getFlagString(DIDescriptor::FlagPrivate));
  96   EXPECT_EQ(StringRef("DIFlagVector"),
  97             DIDescriptor::getFlagString(DIDescriptor::FlagVector));
  98   EXPECT_EQ(StringRef("DIFlagRValueReference"),
  99             DIDescriptor::getFlagString(DIDescriptor::FlagRValueReference));
 100
 101   // FlagAccessibility actually equals FlagPublic.
 102   EXPECT_EQ(StringRef("DIFlagPublic"),
 103             DIDescriptor::getFlagString(DIDescriptor::FlagAccessibility));
 104
 105   // Some other invalid flags.
 106   EXPECT_EQ(StringRef(), DIDescriptor::getFlagString(DIDescriptor::FlagPublic |
 107                                                      DIDescriptor::FlagVector));
 108   EXPECT_EQ(StringRef(),
 109             DIDescriptor::getFlagString(DIDescriptor::FlagFwdDecl |
 110                                         DIDescriptor::FlagArtificial));
 111   EXPECT_EQ(StringRef(), DIDescriptor::getFlagString(0xffff));
 112 }
 113
 114 TEST(DIDescriptorTest, splitFlags) {
 115   // Some valid flags.
 116 #define CHECK_SPLIT(FLAGS, VECTOR, REMAINDER)                                  \
 117   {                                                                            \
 118     SmallVector<unsigned, 8> V;                                                \
 119     EXPECT_EQ(REMAINDER, DIDescriptor::splitFlags(FLAGS, V));                  \
 120     EXPECT_TRUE(makeArrayRef(V).equals VECTOR);                                \
 121   }
 122   CHECK_SPLIT(DIDescriptor::FlagPublic, (DIDescriptor::FlagPublic), 0u);
 123   CHECK_SPLIT(DIDescriptor::FlagProtected, (DIDescriptor::FlagProtected), 0u);
 124   CHECK_SPLIT(DIDescriptor::FlagPrivate, (DIDescriptor::FlagPrivate), 0u);
 125   CHECK_SPLIT(DIDescriptor::FlagVector, (DIDescriptor::FlagVector), 0u);
 126   CHECK_SPLIT(DIDescriptor::FlagRValueReference, (DIDescriptor::FlagRValueReference), 0u);
 127   CHECK_SPLIT(DIDescriptor::FlagFwdDecl | DIDescriptor::FlagVector,
 128               (DIDescriptor::FlagFwdDecl, DIDescriptor::FlagVector), 0u);
 129   CHECK_SPLIT(0x100000u, (), 0x100000u);
 130   CHECK_SPLIT(0x100000u | DIDescriptor::FlagVector, (DIDescriptor::FlagVector),
 131               0x100000u);
 132 #undef CHECK_SPLIT
 133 }
 134
 135 } // end namespace