llvm-project

1
//===-- ScalarTest.cpp ----------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "gtest/gtest.h"
10

11
#include "lldb/Utility/DataExtractor.h"
12
#include "lldb/Utility/Endian.h"
13
#include "lldb/Utility/Scalar.h"
14
#include "lldb/Utility/Status.h"
15
#include "lldb/Utility/StreamString.h"
16
#include "lldb/lldb-enumerations.h"
17
#include "llvm/ADT/APSInt.h"
18
#include "llvm/Testing/Support/Error.h"
19

20
#include <algorithm>
21
#include <cmath>
22

23
using namespace lldb_private;
24
using llvm::APFloat;
25
using llvm::APInt;
26
using llvm::Failed;
27
using llvm::Succeeded;
28

29
template <typename T>
30
bool checkInequality(T c1, T c2) {
31
  return (Scalar(c1) != Scalar(c2));
32
}
33

34
template <typename T>
35
bool checkEquality(T c1, T c2) {
36
  return (Scalar(c1) == Scalar(c2));
37
}
38

39
TEST(ScalarTest, Equality) {
40
  ASSERT_TRUE(checkInequality<int>(23, 24));
41
  ASSERT_TRUE(checkEquality<int>(96, 96));
42
  ASSERT_TRUE(checkInequality<float>(4.0f, 4.5f));
43
  ASSERT_TRUE(checkEquality<float>(4.0f, 4.0f));
44

45
  auto apint1 = APInt(64, 234);
46
  auto apint2 = APInt(64, 246);
47
  ASSERT_TRUE(checkInequality<APInt>(apint1, apint2));
48
  ASSERT_TRUE(checkEquality<APInt>(apint1, apint1));
49

50
  Scalar void1;
51
  Scalar void2;
52
  float f1 = 2.0;
53
  ASSERT_TRUE(void1 == void2);
54
  ASSERT_FALSE(void1 == Scalar(f1));
55
}
56

57
TEST(ScalarTest, Comparison) {
58
  auto s1 = Scalar(23);
59
  auto s2 = Scalar(46);
60
  ASSERT_TRUE(s1 < s2);
61
  ASSERT_TRUE(s1 <= s2);
62
  ASSERT_TRUE(s2 > s1);
63
  ASSERT_TRUE(s2 >= s1);
64
}
65

66
TEST(ScalarTest, ComparisonFloat) {
67
  auto s1 = Scalar(23.0f);
68
  auto s2 = Scalar(46.0f);
69
  ASSERT_TRUE(s1 < s2);
70
  ASSERT_TRUE(s1 <= s2);
71
  ASSERT_TRUE(s2 > s1);
72
  ASSERT_TRUE(s2 >= s1);
73
}
74

75
template <typename T> static void CheckConversion(T val) {
76
  SCOPED_TRACE("val = " + std::to_string(val));
77
  EXPECT_EQ((signed char)val, Scalar(val).SChar());
78
  EXPECT_EQ((unsigned char)val, Scalar(val).UChar());
79
  EXPECT_EQ((short)val, Scalar(val).SShort());
80
  EXPECT_EQ((unsigned short)val, Scalar(val).UShort());
81
  EXPECT_EQ((int)val, Scalar(val).SInt());
82
  EXPECT_EQ((unsigned)val, Scalar(val).UInt());
83
  EXPECT_EQ((long)val, Scalar(val).SLong());
84
  EXPECT_EQ((unsigned long)val, Scalar(val).ULong());
85
  EXPECT_EQ((long long)val, Scalar(val).SLongLong());
86
  EXPECT_EQ((unsigned long long)val, Scalar(val).ULongLong());
87
  EXPECT_NEAR((float)val, Scalar(val).Float(), std::abs(val / 1e6));
88
  EXPECT_NEAR((double)val, Scalar(val).Double(), std::abs(val / 1e12));
89
  EXPECT_NEAR((long double)val, Scalar(val).LongDouble(), std::abs(val / 1e12));
90
}
91

92
TEST(ScalarTest, Getters) {
93
  CheckConversion<int>(0x87654321);
94
  CheckConversion<unsigned int>(0x87654321u);
95
  CheckConversion<long>(0x87654321l);
96
  CheckConversion<unsigned long>(0x87654321ul);
97
  CheckConversion<long long>(0x8765432112345678ll);
98
  CheckConversion<unsigned long long>(0x8765432112345678ull);
99
  CheckConversion<float>(42.25f);
100
  CheckConversion<double>(42.25);
101
  CheckConversion<long double>(42.25L);
102

103
  EXPECT_EQ(APInt(128, 1) << 70, Scalar(std::pow(2.0f, 70.0f)).SInt128(APInt()));
104
  EXPECT_EQ(APInt(128, -1, true) << 70,
105
            Scalar(-std::pow(2.0f, 70.0f)).SInt128(APInt()));
106
  EXPECT_EQ(APInt(128, 1) << 70,
107
            Scalar(std::pow(2.0f, 70.0f)).UInt128(APInt()));
108
  EXPECT_EQ(APInt(128, 0), Scalar(-std::pow(2.0f, 70.0f)).UInt128(APInt()));
109

110
  EXPECT_EQ(APInt(128, 1) << 70, Scalar(std::pow(2.0, 70.0)).SInt128(APInt()));
111
  EXPECT_EQ(APInt(128, -1, true) << 70,
112
            Scalar(-std::pow(2.0, 70.0)).SInt128(APInt()));
113
  EXPECT_EQ(APInt(128, 1) << 70, Scalar(std::pow(2.0, 70.0)).UInt128(APInt()));
114
  EXPECT_EQ(APInt(128, 0), Scalar(-std::pow(2.0, 70.0)).UInt128(APInt()));
115
}
116

117
TEST(ScalarTest, RightShiftOperator) {
118
  int a = 0x00001000;
119
  int b = 0xFFFFFFFF;
120
  int c = 4;
121
  Scalar a_scalar(a);
122
  Scalar b_scalar(b);
123
  Scalar c_scalar(c);
124
  ASSERT_EQ(a >> c, a_scalar >> c_scalar);
125
  ASSERT_EQ(b >> c, b_scalar >> c_scalar);
126
}
127

128
TEST(ScalarTest, GetBytes) {
129
  uint8_t Storage[256];
130
  int a = 0x01020304;
131
  long long b = 0x0102030405060708LL;
132
  float c = 1234567.89e32f;
133
  double d = 1234567.89e42;
134
  char e[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
135
  char f[32] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
136
                17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32};
137
  Scalar a_scalar(a);
138
  Scalar b_scalar(b);
139
  Scalar c_scalar(c);
140
  Scalar d_scalar(d);
141
  Scalar e_scalar;
142
  Scalar f_scalar;
143
  DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(),
144
                       sizeof(void *));
145
  DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(),
146
                       sizeof(void *));
147
  a_scalar.GetBytes(Storage);
148
  ASSERT_EQ(0, memcmp(&a, Storage, sizeof(a)));
149
  b_scalar.GetBytes(Storage);
150
  ASSERT_EQ(0, memcmp(&b, Storage, sizeof(b)));
151
  c_scalar.GetBytes(Storage);
152
  ASSERT_EQ(0, memcmp(&c, Storage, sizeof(c)));
153
  d_scalar.GetBytes(Storage);
154
  ASSERT_EQ(0, memcmp(&d, Storage, sizeof(d)));
155
  ASSERT_THAT_ERROR(
156
      e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e))
157
          .ToError(),
158
      llvm::Succeeded());
159
  e_scalar.GetBytes(Storage);
160
  ASSERT_EQ(0, memcmp(e, Storage, sizeof(e)));
161
  ASSERT_THAT_ERROR(
162
      f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f))
163
          .ToError(),
164
      llvm::Succeeded());
165
  f_scalar.GetBytes(Storage);
166
  ASSERT_EQ(0, memcmp(f, Storage, sizeof(f)));
167
}
168

169
TEST(ScalarTest, GetData) {
170
  auto get_data = [](llvm::APSInt v) {
171
    DataExtractor data;
172
    Scalar(v).GetData(data);
173
    return data.GetData().vec();
174
  };
175

176
  auto vec = [](std::initializer_list<uint8_t> l) {
177
    std::vector<uint8_t> v(l.begin(), l.end());
178
    if (endian::InlHostByteOrder() == lldb::eByteOrderLittle)
179
      std::reverse(v.begin(), v.end());
180
    return v;
181
  };
182

183
  EXPECT_THAT(
184
      get_data(llvm::APSInt::getMaxValue(/*numBits=*/1, /*Unsigned=*/true)),
185
      vec({0x01}));
186

187
  EXPECT_THAT(
188
      get_data(llvm::APSInt::getMaxValue(/*numBits=*/8, /*Unsigned=*/true)),
189
      vec({0xff}));
190

191
  EXPECT_THAT(
192
      get_data(llvm::APSInt::getMaxValue(/*numBits=*/9, /*Unsigned=*/true)),
193
      vec({0x01, 0xff}));
194
}
195

196
TEST(ScalarTest, SetValueFromData) {
197
  uint8_t a[] = {1, 2, 3, 4};
198
  Scalar s;
199
  ASSERT_THAT_ERROR(
200
      s.SetValueFromData(
201
           DataExtractor(a, sizeof(a), lldb::eByteOrderLittle, sizeof(void *)),
202
           lldb::eEncodingSint, sizeof(a))
203
          .ToError(),
204
      llvm::Succeeded());
205
  EXPECT_EQ(0x04030201, s);
206
  ASSERT_THAT_ERROR(
207
      s.SetValueFromData(
208
           DataExtractor(a, sizeof(a), lldb::eByteOrderBig, sizeof(void *)),
209
           lldb::eEncodingSint, sizeof(a))
210
          .ToError(),
211
      llvm::Succeeded());
212
  EXPECT_EQ(0x01020304, s);
213
}
214

215
TEST(ScalarTest, CastOperations) {
216
  long long a = 0xf1f2f3f4f5f6f7f8LL;
217
  Scalar a_scalar(a);
218
  EXPECT_EQ((signed char)a, a_scalar.SChar());
219
  EXPECT_EQ((unsigned char)a, a_scalar.UChar());
220
  EXPECT_EQ((signed short)a, a_scalar.SShort());
221
  EXPECT_EQ((unsigned short)a, a_scalar.UShort());
222
  EXPECT_EQ((signed int)a, a_scalar.SInt());
223
  EXPECT_EQ((unsigned int)a, a_scalar.UInt());
224
  EXPECT_EQ((signed long)a, a_scalar.SLong());
225
  EXPECT_EQ((unsigned long)a, a_scalar.ULong());
226
  EXPECT_EQ((signed long long)a, a_scalar.SLongLong());
227
  EXPECT_EQ((unsigned long long)a, a_scalar.ULongLong());
228

229
  int a2 = 23;
230
  Scalar a2_scalar(a2);
231
  EXPECT_EQ((float)a2, a2_scalar.Float());
232
  EXPECT_EQ((double)a2, a2_scalar.Double());
233
  EXPECT_EQ((long double)a2, a2_scalar.LongDouble());
234

235
  EXPECT_EQ(std::numeric_limits<unsigned int>::min(), Scalar(-1.0f).UInt());
236
  EXPECT_EQ(std::numeric_limits<unsigned int>::max(), Scalar(1e11f).UInt());
237
  EXPECT_EQ(std::numeric_limits<unsigned long long>::min(),
238
            Scalar(-1.0).ULongLong());
239
  EXPECT_EQ(std::numeric_limits<unsigned long long>::max(),
240
            Scalar(1e22).ULongLong());
241

242
  EXPECT_EQ(std::numeric_limits<int>::min(), Scalar(-1e11f).SInt());
243
  EXPECT_EQ(std::numeric_limits<int>::max(), Scalar(1e11f).SInt());
244
  EXPECT_EQ(std::numeric_limits<long long>::min(), Scalar(-1e22).SLongLong());
245
  EXPECT_EQ(std::numeric_limits<long long>::max(), Scalar(1e22).SLongLong());
246
}
247

248
TEST(ScalarTest, ExtractBitfield) {
249
  uint32_t len = sizeof(long long) * 8;
250

251
  long long a1 = 0xf1f2f3f4f5f6f7f8LL;
252
  long long b1 = 0xff1f2f3f4f5f6f7fLL;
253
  Scalar s_scalar(a1);
254
  ASSERT_TRUE(s_scalar.ExtractBitfield(0, 0));
255
  EXPECT_EQ(s_scalar, a1);
256
  ASSERT_TRUE(s_scalar.ExtractBitfield(len, 0));
257
  EXPECT_EQ(s_scalar, a1);
258
  ASSERT_TRUE(s_scalar.ExtractBitfield(len - 4, 4));
259
  EXPECT_EQ(s_scalar, b1);
260

261
  unsigned long long a2 = 0xf1f2f3f4f5f6f7f8ULL;
262
  unsigned long long b2 = 0x0f1f2f3f4f5f6f7fULL;
263
  Scalar u_scalar(a2);
264
  ASSERT_TRUE(u_scalar.ExtractBitfield(0, 0));
265
  EXPECT_EQ(u_scalar, a2);
266
  ASSERT_TRUE(u_scalar.ExtractBitfield(len, 0));
267
  EXPECT_EQ(u_scalar, a2);
268
  ASSERT_TRUE(u_scalar.ExtractBitfield(len - 4, 4));
269
  EXPECT_EQ(u_scalar, b2);
270
}
271

272
template <typename T> static std::string ScalarGetValue(T value) {
273
  StreamString stream;
274
  Scalar(value).GetValue(stream, false);
275
  return std::string(stream.GetString());
276
}
277

278
TEST(ScalarTest, GetValue) {
279
  EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));
280
  EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));
281
  EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));
282
  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),
283
            ScalarGetValue(std::numeric_limits<unsigned short>::max()));
284

285
  EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));
286
  EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));
287
  EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));
288
  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),
289
            ScalarGetValue(std::numeric_limits<unsigned int>::max()));
290

291
  EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));
292
  EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));
293
  EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));
294
  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),
295
            ScalarGetValue(std::numeric_limits<unsigned long>::max()));
296

297
  EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
298
  EXPECT_EQ("-1234567890123",
299
            ScalarGetValue<signed long long>(-1234567890123LL));
300
  EXPECT_EQ("1234567890123",
301
            ScalarGetValue<unsigned long long>(1234567890123ULL));
302
  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
303
            ScalarGetValue(std::numeric_limits<unsigned long long>::max()));
304
}
305

306
TEST(ScalarTest, LongLongAssigmentOperator) {
307
  Scalar ull;
308
  ull = std::numeric_limits<unsigned long long>::max();
309
  EXPECT_EQ(std::numeric_limits<unsigned long long>::max(), ull.ULongLong());
310

311
  Scalar sll;
312
  sll = std::numeric_limits<signed long long>::max();
313
  EXPECT_EQ(std::numeric_limits<signed long long>::max(), sll.SLongLong());
314
}
315

316
TEST(ScalarTest, Division) {
317
  Scalar lhs(5.0);
318
  Scalar rhs(2.0);
319
  Scalar r = lhs / rhs;
320
  EXPECT_TRUE(r.IsValid());
321
  EXPECT_EQ(r, Scalar(2.5));
322
}
323

324
TEST(ScalarTest, Promotion) {
325
  Scalar a(47);
326
  EXPECT_TRUE(a.IntegralPromote(64, true));
327
  EXPECT_TRUE(a.IsSigned());
328
  EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));
329

330
  EXPECT_FALSE(a.IntegralPromote(32, true));
331
  EXPECT_FALSE(a.IntegralPromote(32, false));
332
  EXPECT_TRUE(a.IsSigned());
333

334
  EXPECT_TRUE(a.IntegralPromote(64, false));
335
  EXPECT_FALSE(a.IsSigned());
336
  EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));
337

338
  EXPECT_FALSE(a.IntegralPromote(64, true));
339

340
  EXPECT_TRUE(a.FloatPromote(APFloat::IEEEdouble()));
341
  EXPECT_EQ(Scalar::e_float, a.GetType());
342
  EXPECT_EQ(47.0, a.Double());
343

344
  EXPECT_FALSE(a.FloatPromote(APFloat::IEEEsingle()));
345
  EXPECT_TRUE(a.FloatPromote(APFloat::x87DoubleExtended()));
346
  EXPECT_EQ(47.0L, a.LongDouble());
347
}
348

349
TEST(ScalarTest, SetValueFromCString) {
350
  Scalar a;
351

352
  EXPECT_THAT_ERROR(
353
      a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 8).ToError(),
354
      Succeeded());
355
  EXPECT_EQ(1234567890123ull, a);
356

357
  EXPECT_THAT_ERROR(
358
      a.SetValueFromCString("-1234567890123", lldb::eEncodingSint, 8).ToError(),
359
      Succeeded());
360
  EXPECT_EQ(-1234567890123ll, a);
361

362
  EXPECT_THAT_ERROR(
363
      a.SetValueFromCString("asdf", lldb::eEncodingSint, 8).ToError(),
364
      Failed());
365
  EXPECT_THAT_ERROR(
366
      a.SetValueFromCString("asdf", lldb::eEncodingUint, 8).ToError(),
367
      Failed());
368
  EXPECT_THAT_ERROR(
369
      a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 4).ToError(),
370
      Failed());
371
  EXPECT_THAT_ERROR(a.SetValueFromCString("123456789012345678901234567890",
372
                                          lldb::eEncodingUint, 8)
373
                        .ToError(),
374
                    Failed());
375
  EXPECT_THAT_ERROR(
376
      a.SetValueFromCString("-123", lldb::eEncodingUint, 8).ToError(),
377
      Failed());
378
  EXPECT_THAT_ERROR(
379
      a.SetValueFromCString("-2147483648", lldb::eEncodingSint, 4).ToError(),
380
      Succeeded());
381
  EXPECT_EQ(-2147483648, a);
382
  EXPECT_THAT_ERROR(
383
      a.SetValueFromCString("-2147483649", lldb::eEncodingSint, 4).ToError(),
384
      Failed());
385
  EXPECT_THAT_ERROR(
386
      a.SetValueFromCString("47.25", lldb::eEncodingIEEE754, 4).ToError(),
387
      Succeeded());
388
  EXPECT_EQ(47.25f, a);
389
  EXPECT_THAT_ERROR(
390
      a.SetValueFromCString("asdf", lldb::eEncodingIEEE754, 4).ToError(),
391
      Failed());
392
}
393

394
TEST(ScalarTest, APIntConstructor) {
395
  for (auto &width : {8, 16, 32}) {
396
    Scalar A(APInt(width, 24));
397
    EXPECT_TRUE(A.IsSigned());
398
    EXPECT_EQ(A.GetType(), Scalar::e_int);
399
    EXPECT_EQ(APInt(width, 24), A.UInt128(APInt()));
400
  }
401
}
402

403
TEST(ScalarTest, Scalar_512) {
404
  Scalar Z(APInt(512, 0));
405
  ASSERT_TRUE(Z.IsZero());
406
  Z.MakeUnsigned();
407
  ASSERT_TRUE(Z.IsZero());
408

409
  Scalar S(APInt(512, 2000));
410
  ASSERT_STREQ(S.GetTypeAsCString(), "int");
411

412
  ASSERT_TRUE(S.MakeUnsigned());
413
  EXPECT_EQ(S.GetType(), Scalar::e_int);
414
  EXPECT_FALSE(S.IsSigned());
415
  ASSERT_STREQ(S.GetTypeAsCString(), "int");
416
  EXPECT_EQ(S.GetByteSize(), 64U);
417

418
  ASSERT_TRUE(S.MakeSigned());
419
  EXPECT_EQ(S.GetType(), Scalar::e_int);
420
  EXPECT_TRUE(S.IsSigned());
421
  EXPECT_EQ(S.GetByteSize(), 64U);
422
}
423

424
TEST(ScalarTest, TruncOrExtendTo) {
425
  Scalar S(0xffff);
426
  S.TruncOrExtendTo(12, true);
427
  EXPECT_EQ(S.UInt128(APInt()), APInt(12, 0xfffu));
428
  S.TruncOrExtendTo(20, true);
429
  EXPECT_EQ(S.UInt128(APInt()), APInt(20, 0xfffffu));
430
  S.TruncOrExtendTo(24, false);
431
  EXPECT_EQ(S.UInt128(APInt()), APInt(24, 0x0fffffu));
432
  S.TruncOrExtendTo(16, false);
433
  EXPECT_EQ(S.UInt128(APInt()), APInt(16, 0xffffu));
434
}
435

436
TEST(ScalarTest, APFloatConstructor) {
437
  llvm::APFloat my_single(llvm::APFloatBase::IEEEsingle(), "3.14159");
438
  llvm::APFloat my_double(llvm::APFloatBase::IEEEdouble(), "3.14159");
439
  Scalar S(my_single);
440
  Scalar D(my_double);
441

442
  EXPECT_EQ(S.GetType(), Scalar::e_float);
443
  EXPECT_EQ(D.GetType(), Scalar::e_float);
444
  ASSERT_TRUE(S != D);
445
}
446

447
TEST(ScalarTest, CreateAPFloats) {
448
  llvm::APFloat ap_float(llvm::APFloatBase::IEEEsingle(), "3.14159");
449
  llvm::APFloat ap_nan = llvm::APFloat::getNaN(llvm::APFloat::IEEEsingle());
450
  llvm::APSInt int1("12");
451
  llvm::APSInt int2("-4");
452
  Scalar I1(int1);
453
  Scalar I2(int2);
454
  Scalar F(ap_float);
455

456
  llvm::APFloat out1_float = I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloat);
457
  llvm::APFloat out1_double =
458
      I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeDouble);
459
  llvm::APFloat out1_longdouble =
460
      I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeLongDouble);
461
  llvm::APFloat out1_nan =
462
      I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloatComplex);
463
  EXPECT_TRUE(!out1_float.isNegative());
464
  EXPECT_TRUE(!out1_double.isNegative());
465
  EXPECT_TRUE(out1_double.bitwiseIsEqual(out1_longdouble));
466
  EXPECT_FALSE(out1_double.bitwiseIsEqual(out1_float));
467
  EXPECT_TRUE(out1_nan.bitwiseIsEqual(ap_nan));
468

469
  llvm::APFloat out2_float = I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloat);
470
  llvm::APFloat out2_double =
471
      I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeDouble);
472
  llvm::APFloat out2_longdouble =
473
      I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeLongDouble);
474
  llvm::APFloat out2_nan =
475
      I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloatComplex);
476
  EXPECT_TRUE(out2_float.isNegative());
477
  EXPECT_TRUE(out2_double.isNegative());
478
  EXPECT_TRUE(out2_double.bitwiseIsEqual(out2_longdouble));
479
  EXPECT_FALSE(out2_double.bitwiseIsEqual(out2_float));
480
  EXPECT_TRUE(out2_nan.bitwiseIsEqual(ap_nan));
481

482
  llvm::APFloat out3_float = F.CreateAPFloatFromAPFloat(lldb::eBasicTypeFloat);
483
  llvm::APFloat out3_double =
484
      F.CreateAPFloatFromAPFloat(lldb::eBasicTypeDouble);
485
  llvm::APFloat out3_longdouble =
486
      F.CreateAPFloatFromAPFloat(lldb::eBasicTypeLongDouble);
487
  llvm::APFloat out3_nan =
488
      F.CreateAPFloatFromAPFloat(lldb::eBasicTypeFloatComplex);
489
  EXPECT_TRUE(out3_double.bitwiseIsEqual(out3_longdouble));
490
  EXPECT_FALSE(out3_double.bitwiseIsEqual(out3_float));
491
  EXPECT_TRUE(out3_nan.bitwiseIsEqual(ap_nan));
492
}
493