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