unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp

   1 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===//
   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/DWARF/DWARFFormValue.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/Support/Dwarf.h"
  13 #include "llvm/Support/Host.h"
  14 #include "llvm/Support/LEB128.h"
  15 #include "gtest/gtest.h"
  16 #include <climits>
  17 using namespace llvm;
  18 using namespace dwarf;
  19
  20 namespace {
  21
  22 TEST(DWARFFormValue, FixedFormSizes) {
  23   // Size of DW_FORM_addr and DW_FORM_ref_addr are equal in DWARF2,
  24   // DW_FORM_ref_addr is always 4 bytes in DWARF32 starting from DWARF3.
  25   ArrayRef<uint8_t> sizes = DWARFFormValue::getFixedFormSizes(4, 2);
  26   EXPECT_EQ(sizes[DW_FORM_addr], sizes[DW_FORM_ref_addr]);
  27   sizes = DWARFFormValue::getFixedFormSizes(8, 2);
  28   EXPECT_EQ(sizes[DW_FORM_addr], sizes[DW_FORM_ref_addr]);
  29   sizes = DWARFFormValue::getFixedFormSizes(8, 3);
  30   EXPECT_EQ(4, sizes[DW_FORM_ref_addr]);
  31   // Check that we don't have fixed form sizes for weird address sizes.
  32   EXPECT_EQ(0U, DWARFFormValue::getFixedFormSizes(16, 2).size());
  33 }
  34
  35 bool isFormClass(uint16_t Form, DWARFFormValue::FormClass FC) {
  36   return DWARFFormValue(Form).isFormClass(FC);
  37 }
  38
  39 TEST(DWARFFormValue, FormClass) {
  40   EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address));
  41   EXPECT_FALSE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Address));
  42   EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant));
  43   EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset));
  44   EXPECT_TRUE(
  45       isFormClass(DW_FORM_sec_offset, DWARFFormValue::FC_SectionOffset));
  46   EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String));
  47   EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address));
  48   EXPECT_FALSE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Address));
  49   EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference));
  50   EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference));
  51 }
  52
  53 template<typename RawTypeT>
  54 DWARFFormValue createDataXFormValue(uint16_t Form, RawTypeT Value) {
  55   char Raw[sizeof(RawTypeT)];
  56   memcpy(Raw, &Value, sizeof(RawTypeT));
  57   uint32_t Offset = 0;
  58   DWARFFormValue Result(Form);
  59   DataExtractor Data(StringRef(Raw, sizeof(RawTypeT)),
  60                      sys::IsLittleEndianHost, sizeof(void*));
  61   Result.extractValue(Data, &Offset, nullptr);
  62   return Result;
  63 }
  64
  65 DWARFFormValue createULEBFormValue(uint64_t Value) {
  66   SmallString<10> RawData;
  67   raw_svector_ostream OS(RawData);
  68   encodeULEB128(Value, OS);
  69   uint32_t Offset = 0;
  70   DWARFFormValue Result(DW_FORM_udata);
  71   DataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void*));
  72   Result.extractValue(Data, &Offset, nullptr);
  73   return Result;
  74 }
  75
  76 DWARFFormValue createSLEBFormValue(int64_t Value) {
  77   SmallString<10> RawData;
  78   raw_svector_ostream OS(RawData);
  79   encodeSLEB128(Value, OS);
  80   uint32_t Offset = 0;
  81   DWARFFormValue Result(DW_FORM_sdata);
  82   DataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void*));
  83   Result.extractValue(Data, &Offset, nullptr);
  84   return Result;
  85 }
  86
  87 TEST(DWARFFormValue, SignedConstantForms) {
  88   // Check that we correctly sign extend fixed size forms.
  89   auto Sign1 = createDataXFormValue<uint8_t>(DW_FORM_data1, -123);
  90   auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345);
  91   auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789);
  92   auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1);
  93   EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123);
  94   EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345);
  95   EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789);
  96   EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1);
  97
  98   // Check that we can handle big positive values, but that we return
  99   // an error just over the limit.
 100   auto UMax = createULEBFormValue(LLONG_MAX);
 101   auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1);
 102   EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX);
 103   EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false);
 104
 105   // Sanity check some other forms.
 106   auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120);
 107   auto Data2 = createDataXFormValue<uint16_t>(DW_FORM_data2, 32000);
 108   auto Data4 = createDataXFormValue<uint32_t>(DW_FORM_data4, 2000000000);
 109   auto Data8 = createDataXFormValue<uint64_t>(DW_FORM_data8, 0x1234567812345678LL);
 110   auto LEBMin = createSLEBFormValue(LLONG_MIN);
 111   auto LEBMax = createSLEBFormValue(LLONG_MAX);
 112   auto LEB1 = createSLEBFormValue(-42);
 113   auto LEB2 = createSLEBFormValue(42);
 114   EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120);
 115   EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000);
 116   EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000);
 117   EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL);
 118   EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN);
 119   EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX);
 120   EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42);
 121   EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42);
 122 }
 123
 124 } // end anonymous namespace