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