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>
17using namespace llvm;
18using namespace dwarf;
19
20namespace {
21
22TEST(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
35bool isFormClass(uint16_t Form, DWARFFormValue::FormClass FC) {
36  return DWARFFormValue(Form).isFormClass(FC);
37}
38
39TEST(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
53template<typename RawTypeT>
54DWARFFormValue 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
65DWARFFormValue 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
76DWARFFormValue 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
87TEST(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
125