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
23using namespace lldb_private;
24using llvm::APFloat;
25using llvm::APInt;
26using llvm::Failed;
27using llvm::Succeeded;
28
29template <typename T>
30bool checkInequality(T c1, T c2) {
31 return (Scalar(c1) != Scalar(c2));
32}
33
34template <typename T>
35bool checkEquality(T c1, T c2) {
36 return (Scalar(c1) == Scalar(c2));
37}
38
39TEST(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
57TEST(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
66TEST(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
75template <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
92TEST(ScalarTest, Getters) {
93 CheckConversion<int>(val: 0x87654321);
94 CheckConversion<unsigned int>(val: 0x87654321u);
95 CheckConversion<long>(val: 0x87654321l);
96 CheckConversion<unsigned long>(val: 0x87654321ul);
97 CheckConversion<long long>(val: 0x8765432112345678ll);
98 CheckConversion<unsigned long long>(val: 0x8765432112345678ull);
99 CheckConversion<float>(val: 42.25f);
100 CheckConversion<double>(val: 42.25);
101 CheckConversion<long double>(val: 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
117TEST(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
128TEST(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: Storage);
148 ASSERT_EQ(0, memcmp(&a, Storage, sizeof(a)));
149 b_scalar.GetBytes(storage: Storage);
150 ASSERT_EQ(0, memcmp(&b, Storage, sizeof(b)));
151 c_scalar.GetBytes(storage: Storage);
152 ASSERT_EQ(0, memcmp(&c, Storage, sizeof(c)));
153 d_scalar.GetBytes(storage: 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: 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: Storage);
166 ASSERT_EQ(0, memcmp(f, Storage, sizeof(f)));
167}
168
169TEST(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(first: v.begin(), last: 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
196TEST(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
215TEST(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
248TEST(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
272template <typename T> static std::string ScalarGetValue(T value) {
273 StreamString stream;
274 Scalar(value).GetValue(s&: stream, show_type: false);
275 return std::string(stream.GetString());
276}
277
278TEST(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
306TEST(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
316TEST(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
324TEST(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
349TEST(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
394TEST(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
403TEST(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
424TEST(ScalarTest, TruncOrExtendTo) {
425 Scalar S(0xffff);
426 S.TruncOrExtendTo(bits: 12, sign: true);
427 EXPECT_EQ(S.UInt128(APInt()), APInt(12, 0xfffu));
428 S.TruncOrExtendTo(bits: 20, sign: true);
429 EXPECT_EQ(S.UInt128(APInt()), APInt(20, 0xfffffu));
430 S.TruncOrExtendTo(bits: 24, sign: false);
431 EXPECT_EQ(S.UInt128(APInt()), APInt(24, 0x0fffffu));
432 S.TruncOrExtendTo(bits: 16, sign: false);
433 EXPECT_EQ(S.UInt128(APInt()), APInt(16, 0xffffu));
434}
435
436TEST(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
447TEST(ScalarTest, CreateAPFloats) {
448 llvm::APFloat ap_float(llvm::APFloatBase::IEEEsingle(), "3.14159");
449 llvm::APFloat ap_nan = llvm::APFloat::getNaN(Sem: 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(basic_type: lldb::eBasicTypeFloat);
457 llvm::APFloat out1_double =
458 I1.CreateAPFloatFromAPSInt(basic_type: lldb::eBasicTypeDouble);
459 llvm::APFloat out1_longdouble =
460 I1.CreateAPFloatFromAPSInt(basic_type: lldb::eBasicTypeLongDouble);
461 llvm::APFloat out1_nan =
462 I1.CreateAPFloatFromAPSInt(basic_type: 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(basic_type: lldb::eBasicTypeFloat);
470 llvm::APFloat out2_double =
471 I2.CreateAPFloatFromAPSInt(basic_type: lldb::eBasicTypeDouble);
472 llvm::APFloat out2_longdouble =
473 I2.CreateAPFloatFromAPSInt(basic_type: lldb::eBasicTypeLongDouble);
474 llvm::APFloat out2_nan =
475 I2.CreateAPFloatFromAPSInt(basic_type: 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(basic_type: lldb::eBasicTypeFloat);
483 llvm::APFloat out3_double =
484 F.CreateAPFloatFromAPFloat(basic_type: lldb::eBasicTypeDouble);
485 llvm::APFloat out3_longdouble =
486 F.CreateAPFloatFromAPFloat(basic_type: lldb::eBasicTypeLongDouble);
487 llvm::APFloat out3_nan =
488 F.CreateAPFloatFromAPFloat(basic_type: 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

source code of lldb/unittests/Utility/ScalarTest.cpp