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/ArrayRef.h" 12 #include "llvm/ADT/SmallString.h" 13 #include "llvm/Support/Dwarf.h" 14 #include "llvm/Support/Host.h" 15 #include "llvm/Support/LEB128.h" 16 #include "gtest/gtest.h" 17 #include <climits> 18 using namespace llvm; 19 using namespace dwarf; 20 21 namespace { 22 23 TEST(DWARFFormValue, FixedFormSizes) { 24 Optional<uint8_t> RefSize; 25 Optional<uint8_t> AddrSize; 26 // Test 32 bit DWARF version 2 with 4 byte addresses. 27 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 4, DWARF32); 28 AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 4, DWARF32); 29 EXPECT_TRUE(RefSize.hasValue()); 30 EXPECT_TRUE(AddrSize.hasValue()); 31 EXPECT_EQ(*RefSize, *AddrSize); 32 33 // Test 32 bit DWARF version 2 with 8 byte addresses. 34 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 8, DWARF32); 35 AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 8, DWARF32); 36 EXPECT_TRUE(RefSize.hasValue()); 37 EXPECT_TRUE(AddrSize.hasValue()); 38 EXPECT_EQ(*RefSize, *AddrSize); 39 40 // DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond. 41 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 3, 4, DWARF32); 42 EXPECT_TRUE(RefSize.hasValue()); 43 EXPECT_EQ(*RefSize, 4); 44 45 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 4, 4, DWARF32); 46 EXPECT_TRUE(RefSize.hasValue()); 47 EXPECT_EQ(*RefSize, 4); 48 49 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 5, 4, DWARF32); 50 EXPECT_TRUE(RefSize.hasValue()); 51 EXPECT_EQ(*RefSize, 4); 52 53 // DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond. 54 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 3, 8, DWARF64); 55 EXPECT_TRUE(RefSize.hasValue()); 56 EXPECT_EQ(*RefSize, 8); 57 58 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 4, 8, DWARF64); 59 EXPECT_TRUE(RefSize.hasValue()); 60 EXPECT_EQ(*RefSize, 8); 61 62 RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 5, 8, DWARF64); 63 EXPECT_TRUE(RefSize.hasValue()); 64 EXPECT_EQ(*RefSize, 8); 65 } 66 67 bool isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC) { 68 return DWARFFormValue(Form).isFormClass(FC); 69 } 70 71 TEST(DWARFFormValue, FormClass) { 72 EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address)); 73 EXPECT_FALSE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Address)); 74 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant)); 75 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset)); 76 EXPECT_TRUE( 77 isFormClass(DW_FORM_sec_offset, DWARFFormValue::FC_SectionOffset)); 78 EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String)); 79 EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address)); 80 EXPECT_FALSE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Address)); 81 EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference)); 82 EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference)); 83 } 84 85 template<typename RawTypeT> 86 DWARFFormValue createDataXFormValue(dwarf::Form Form, RawTypeT Value) { 87 char Raw[sizeof(RawTypeT)]; 88 memcpy(Raw, &Value, sizeof(RawTypeT)); 89 uint32_t Offset = 0; 90 DWARFFormValue Result(Form); 91 DataExtractor Data(StringRef(Raw, sizeof(RawTypeT)), 92 sys::IsLittleEndianHost, sizeof(void*)); 93 Result.extractValue(Data, &Offset, nullptr); 94 return Result; 95 } 96 97 DWARFFormValue createULEBFormValue(uint64_t Value) { 98 SmallString<10> RawData; 99 raw_svector_ostream OS(RawData); 100 encodeULEB128(Value, OS); 101 uint32_t Offset = 0; 102 DWARFFormValue Result(DW_FORM_udata); 103 DataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void*)); 104 Result.extractValue(Data, &Offset, nullptr); 105 return Result; 106 } 107 108 DWARFFormValue createSLEBFormValue(int64_t Value) { 109 SmallString<10> RawData; 110 raw_svector_ostream OS(RawData); 111 encodeSLEB128(Value, OS); 112 uint32_t Offset = 0; 113 DWARFFormValue Result(DW_FORM_sdata); 114 DataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void*)); 115 Result.extractValue(Data, &Offset, nullptr); 116 return Result; 117 } 118 119 TEST(DWARFFormValue, SignedConstantForms) { 120 // Check that we correctly sign extend fixed size forms. 121 auto Sign1 = createDataXFormValue<uint8_t>(DW_FORM_data1, -123); 122 auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345); 123 auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789); 124 auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1); 125 EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123); 126 EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345); 127 EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789); 128 EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1); 129 130 // Check that we can handle big positive values, but that we return 131 // an error just over the limit. 132 auto UMax = createULEBFormValue(LLONG_MAX); 133 auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1); 134 EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX); 135 EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false); 136 137 // Sanity check some other forms. 138 auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120); 139 auto Data2 = createDataXFormValue<uint16_t>(DW_FORM_data2, 32000); 140 auto Data4 = createDataXFormValue<uint32_t>(DW_FORM_data4, 2000000000); 141 auto Data8 = createDataXFormValue<uint64_t>(DW_FORM_data8, 0x1234567812345678LL); 142 auto LEBMin = createSLEBFormValue(LLONG_MIN); 143 auto LEBMax = createSLEBFormValue(LLONG_MAX); 144 auto LEB1 = createSLEBFormValue(-42); 145 auto LEB2 = createSLEBFormValue(42); 146 EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120); 147 EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000); 148 EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000); 149 EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL); 150 EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN); 151 EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX); 152 EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42); 153 EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42); 154 } 155 156 } // end anonymous namespace 157