523 lines · cpp
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-exception6//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>(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 117TEST(ScalarTest, RightShiftOperator) {118 int a = 0x00001000;119 int b = 0xFFFFFFFF;120 int c = 4;121 unsigned d = 0xFFFFFFFF;122 unsigned short e = 0xFFFF;123 Scalar a_scalar(a);124 Scalar b_scalar(b);125 Scalar c_scalar(c);126 Scalar d_scalar(d);127 Scalar e_scalar(e);128 ASSERT_EQ(a >> c, a_scalar >> c_scalar);129 ASSERT_EQ(b >> c, b_scalar >> c_scalar);130 ASSERT_EQ(d >> c, d_scalar >> c_scalar);131 ASSERT_EQ(e >> c, e_scalar >> c_scalar);132}133 134TEST(ScalarTest, GetBytes) {135 uint8_t Storage[256];136 int a = 0x01020304;137 long long b = 0x0102030405060708LL;138 float c = 1234567.89e32f;139 double d = 1234567.89e42;140 char e[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};141 char f[32] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,142 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32};143 Scalar a_scalar(a);144 Scalar b_scalar(b);145 Scalar c_scalar(c);146 Scalar d_scalar(d);147 Scalar e_scalar;148 Scalar f_scalar;149 DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(),150 sizeof(void *));151 DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(),152 sizeof(void *));153 a_scalar.GetBytes(Storage);154 ASSERT_EQ(0, memcmp(&a, Storage, sizeof(a)));155 b_scalar.GetBytes(Storage);156 ASSERT_EQ(0, memcmp(&b, Storage, sizeof(b)));157 c_scalar.GetBytes(Storage);158 ASSERT_EQ(0, memcmp(&c, Storage, sizeof(c)));159 d_scalar.GetBytes(Storage);160 ASSERT_EQ(0, memcmp(&d, Storage, sizeof(d)));161 ASSERT_THAT_ERROR(162 e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e))163 .ToError(),164 llvm::Succeeded());165 e_scalar.GetBytes(Storage);166 ASSERT_EQ(0, memcmp(e, Storage, sizeof(e)));167 ASSERT_THAT_ERROR(168 f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f))169 .ToError(),170 llvm::Succeeded());171 f_scalar.GetBytes(Storage);172 ASSERT_EQ(0, memcmp(f, Storage, sizeof(f)));173}174 175TEST(ScalarTest, GetData) {176 auto get_data = [](llvm::APSInt v) {177 DataExtractor data;178 Scalar(v).GetData(data);179 return data.GetData().vec();180 };181 182 auto vec = [](std::initializer_list<uint8_t> l) {183 std::vector<uint8_t> v(l.begin(), l.end());184 if (endian::InlHostByteOrder() == lldb::eByteOrderLittle)185 std::reverse(v.begin(), v.end());186 return v;187 };188 189 EXPECT_THAT(190 get_data(llvm::APSInt::getMaxValue(/*numBits=*/1, /*Unsigned=*/true)),191 vec({0x01}));192 193 EXPECT_THAT(194 get_data(llvm::APSInt::getMaxValue(/*numBits=*/8, /*Unsigned=*/true)),195 vec({0xff}));196 197 EXPECT_THAT(198 get_data(llvm::APSInt::getMaxValue(/*numBits=*/9, /*Unsigned=*/true)),199 vec({0x01, 0xff}));200 201 auto get_data_with_size = [](llvm::APInt v, size_t size) {202 DataExtractor data;203 Scalar(v).GetData(data, size);204 return data.GetData().vec();205 };206 207 EXPECT_THAT(get_data_with_size(llvm::APInt(16, 0x0123), 8),208 vec({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x23}));209 210 EXPECT_THAT(get_data_with_size(llvm::APInt(32, 0x01234567), 4),211 vec({0x01, 0x23, 0x45, 0x67}));212 213 EXPECT_THAT(get_data_with_size(llvm::APInt(48, 0xABCD01234567UL), 4),214 vec({0x01, 0x23, 0x45, 0x67}));215 216 EXPECT_THAT(get_data_with_size(llvm::APInt(64, 0xABCDEF0123456789UL), 2),217 vec({0x67, 0x89}));218}219 220TEST(ScalarTest, SetValueFromData) {221 uint8_t a[] = {1, 2, 3, 4};222 Scalar s;223 ASSERT_THAT_ERROR(224 s.SetValueFromData(225 DataExtractor(a, sizeof(a), lldb::eByteOrderLittle, sizeof(void *)),226 lldb::eEncodingSint, sizeof(a))227 .ToError(),228 llvm::Succeeded());229 EXPECT_EQ(0x04030201, s);230 ASSERT_THAT_ERROR(231 s.SetValueFromData(232 DataExtractor(a, sizeof(a), lldb::eByteOrderBig, sizeof(void *)),233 lldb::eEncodingSint, sizeof(a))234 .ToError(),235 llvm::Succeeded());236 EXPECT_EQ(0x01020304, s);237}238 239TEST(ScalarTest, CastOperations) {240 long long a = 0xf1f2f3f4f5f6f7f8LL;241 Scalar a_scalar(a);242 EXPECT_EQ((signed char)a, a_scalar.SChar());243 EXPECT_EQ((unsigned char)a, a_scalar.UChar());244 EXPECT_EQ((signed short)a, a_scalar.SShort());245 EXPECT_EQ((unsigned short)a, a_scalar.UShort());246 EXPECT_EQ((signed int)a, a_scalar.SInt());247 EXPECT_EQ((unsigned int)a, a_scalar.UInt());248 EXPECT_EQ((signed long)a, a_scalar.SLong());249 EXPECT_EQ((unsigned long)a, a_scalar.ULong());250 EXPECT_EQ((signed long long)a, a_scalar.SLongLong());251 EXPECT_EQ((unsigned long long)a, a_scalar.ULongLong());252 253 int a2 = 23;254 Scalar a2_scalar(a2);255 EXPECT_EQ((float)a2, a2_scalar.Float());256 EXPECT_EQ((double)a2, a2_scalar.Double());257 EXPECT_EQ((long double)a2, a2_scalar.LongDouble());258 259 EXPECT_EQ(std::numeric_limits<unsigned int>::min(), Scalar(-1.0f).UInt());260 EXPECT_EQ(std::numeric_limits<unsigned int>::max(), Scalar(1e11f).UInt());261 EXPECT_EQ(std::numeric_limits<unsigned long long>::min(),262 Scalar(-1.0).ULongLong());263 EXPECT_EQ(std::numeric_limits<unsigned long long>::max(),264 Scalar(1e22).ULongLong());265 266 EXPECT_EQ(std::numeric_limits<int>::min(), Scalar(-1e11f).SInt());267 EXPECT_EQ(std::numeric_limits<int>::max(), Scalar(1e11f).SInt());268 EXPECT_EQ(std::numeric_limits<long long>::min(), Scalar(-1e22).SLongLong());269 EXPECT_EQ(std::numeric_limits<long long>::max(), Scalar(1e22).SLongLong());270}271 272TEST(ScalarTest, ExtractBitfield) {273 uint32_t len = sizeof(long long) * 8;274 275 long long a1 = 0xf1f2f3f4f5f6f7f8LL;276 long long b1 = 0xff1f2f3f4f5f6f7fLL;277 Scalar s_scalar(a1);278 ASSERT_TRUE(s_scalar.ExtractBitfield(0, 0));279 EXPECT_EQ(s_scalar, a1);280 ASSERT_TRUE(s_scalar.ExtractBitfield(len, 0));281 EXPECT_EQ(s_scalar, a1);282 ASSERT_TRUE(s_scalar.ExtractBitfield(len - 4, 4));283 EXPECT_EQ(s_scalar, b1);284 285 unsigned long long a2 = 0xf1f2f3f4f5f6f7f8ULL;286 unsigned long long b2 = 0x0f1f2f3f4f5f6f7fULL;287 Scalar u_scalar(a2);288 ASSERT_TRUE(u_scalar.ExtractBitfield(0, 0));289 EXPECT_EQ(u_scalar, a2);290 ASSERT_TRUE(u_scalar.ExtractBitfield(len, 0));291 EXPECT_EQ(u_scalar, a2);292 ASSERT_TRUE(u_scalar.ExtractBitfield(len - 4, 4));293 EXPECT_EQ(u_scalar, b2);294}295 296template <typename T> static std::string ScalarGetValue(T value) {297 StreamString stream;298 Scalar(value).GetValue(stream, false);299 return std::string(stream.GetString());300}301 302TEST(ScalarTest, GetValue) {303 EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));304 EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));305 EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));306 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),307 ScalarGetValue(std::numeric_limits<unsigned short>::max()));308 309 EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));310 EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));311 EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));312 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),313 ScalarGetValue(std::numeric_limits<unsigned int>::max()));314 315 EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));316 EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));317 EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));318 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),319 ScalarGetValue(std::numeric_limits<unsigned long>::max()));320 321 EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));322 EXPECT_EQ("-1234567890123",323 ScalarGetValue<signed long long>(-1234567890123LL));324 EXPECT_EQ("1234567890123",325 ScalarGetValue<unsigned long long>(1234567890123ULL));326 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),327 ScalarGetValue(std::numeric_limits<unsigned long long>::max()));328}329 330TEST(ScalarTest, LongLongAssignmentOperator) {331 Scalar ull;332 ull = std::numeric_limits<unsigned long long>::max();333 EXPECT_EQ(std::numeric_limits<unsigned long long>::max(), ull.ULongLong());334 335 Scalar sll;336 sll = std::numeric_limits<signed long long>::max();337 EXPECT_EQ(std::numeric_limits<signed long long>::max(), sll.SLongLong());338}339 340TEST(ScalarTest, Division) {341 Scalar lhs(5.0);342 Scalar rhs(2.0);343 Scalar r = lhs / rhs;344 EXPECT_TRUE(r.IsValid());345 EXPECT_EQ(r, Scalar(2.5));346 347 Scalar inf = Scalar(1) / Scalar(0.0f);348 Scalar int0 = Scalar(1) / Scalar(0);349 Scalar ref_inf = llvm::APFloat::getInf(llvm::APFloat::IEEEsingle());350 EXPECT_EQ(inf, ref_inf);351 EXPECT_FALSE(int0.IsValid());352}353 354TEST(ScalarTest, Promotion) {355 Scalar a(47);356 EXPECT_TRUE(a.IntegralPromote(64, true));357 EXPECT_TRUE(a.IsSigned());358 EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));359 360 EXPECT_FALSE(a.IntegralPromote(32, true));361 EXPECT_FALSE(a.IntegralPromote(32, false));362 EXPECT_TRUE(a.IsSigned());363 364 EXPECT_TRUE(a.IntegralPromote(64, false));365 EXPECT_FALSE(a.IsSigned());366 EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));367 368 EXPECT_FALSE(a.IntegralPromote(64, true));369 370 EXPECT_TRUE(a.FloatPromote(APFloat::IEEEdouble()));371 EXPECT_EQ(Scalar::e_float, a.GetType());372 EXPECT_EQ(47.0, a.Double());373 374 EXPECT_FALSE(a.FloatPromote(APFloat::IEEEsingle()));375 EXPECT_TRUE(a.FloatPromote(APFloat::x87DoubleExtended()));376 EXPECT_EQ(47.0L, a.LongDouble());377}378 379TEST(ScalarTest, SetValueFromCString) {380 Scalar a;381 382 EXPECT_THAT_ERROR(383 a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 8).ToError(),384 Succeeded());385 EXPECT_EQ(1234567890123ull, a);386 387 EXPECT_THAT_ERROR(388 a.SetValueFromCString("-1234567890123", lldb::eEncodingSint, 8).ToError(),389 Succeeded());390 EXPECT_EQ(-1234567890123ll, a);391 392 EXPECT_THAT_ERROR(393 a.SetValueFromCString("asdf", lldb::eEncodingSint, 8).ToError(),394 Failed());395 EXPECT_THAT_ERROR(396 a.SetValueFromCString("asdf", lldb::eEncodingUint, 8).ToError(),397 Failed());398 EXPECT_THAT_ERROR(399 a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 4).ToError(),400 Failed());401 EXPECT_THAT_ERROR(a.SetValueFromCString("123456789012345678901234567890",402 lldb::eEncodingUint, 8)403 .ToError(),404 Failed());405 EXPECT_THAT_ERROR(406 a.SetValueFromCString("-123", lldb::eEncodingUint, 8).ToError(),407 Failed());408 EXPECT_THAT_ERROR(409 a.SetValueFromCString("-2147483648", lldb::eEncodingSint, 4).ToError(),410 Succeeded());411 EXPECT_EQ(-2147483648, a);412 EXPECT_THAT_ERROR(413 a.SetValueFromCString("-2147483649", lldb::eEncodingSint, 4).ToError(),414 Failed());415 EXPECT_THAT_ERROR(416 a.SetValueFromCString("47.25", lldb::eEncodingIEEE754, 4).ToError(),417 Succeeded());418 EXPECT_EQ(47.25f, a);419 EXPECT_THAT_ERROR(420 a.SetValueFromCString("asdf", lldb::eEncodingIEEE754, 4).ToError(),421 Failed());422}423 424TEST(ScalarTest, APIntConstructor) {425 for (auto &width : {8, 16, 32}) {426 Scalar A(APInt(width, 24));427 EXPECT_TRUE(A.IsSigned());428 EXPECT_EQ(A.GetType(), Scalar::e_int);429 EXPECT_EQ(APInt(width, 24), A.UInt128(APInt()));430 }431}432 433TEST(ScalarTest, Scalar_512) {434 Scalar Z(APInt(512, 0));435 ASSERT_TRUE(Z.IsZero());436 Z.MakeUnsigned();437 ASSERT_TRUE(Z.IsZero());438 439 Scalar S(APInt(512, 2000));440 ASSERT_STREQ(S.GetTypeAsCString(), "int");441 442 ASSERT_TRUE(S.MakeUnsigned());443 EXPECT_EQ(S.GetType(), Scalar::e_int);444 EXPECT_FALSE(S.IsSigned());445 ASSERT_STREQ(S.GetTypeAsCString(), "int");446 EXPECT_EQ(S.GetByteSize(), 64U);447 448 ASSERT_TRUE(S.MakeSigned());449 EXPECT_EQ(S.GetType(), Scalar::e_int);450 EXPECT_TRUE(S.IsSigned());451 EXPECT_EQ(S.GetByteSize(), 64U);452}453 454TEST(ScalarTest, TruncOrExtendTo) {455 Scalar S(0xffff);456 S.TruncOrExtendTo(12, true);457 EXPECT_EQ(S.UInt128(APInt()), APInt(12, 0xfffu));458 S.TruncOrExtendTo(20, true);459 EXPECT_EQ(S.UInt128(APInt()), APInt(20, 0xfffffu));460 S.TruncOrExtendTo(24, false);461 EXPECT_EQ(S.UInt128(APInt()), APInt(24, 0x0fffffu));462 S.TruncOrExtendTo(16, false);463 EXPECT_EQ(S.UInt128(APInt()), APInt(16, 0xffffu));464}465 466TEST(ScalarTest, APFloatConstructor) {467 llvm::APFloat my_single(llvm::APFloatBase::IEEEsingle(), "3.14159");468 llvm::APFloat my_double(llvm::APFloatBase::IEEEdouble(), "3.14159");469 Scalar S(my_single);470 Scalar D(my_double);471 472 EXPECT_EQ(S.GetType(), Scalar::e_float);473 EXPECT_EQ(D.GetType(), Scalar::e_float);474 ASSERT_TRUE(S != D);475}476 477TEST(ScalarTest, CreateAPFloats) {478 llvm::APFloat ap_float(llvm::APFloatBase::IEEEsingle(), "3.14159");479 llvm::APFloat ap_nan = llvm::APFloat::getNaN(llvm::APFloat::IEEEsingle());480 llvm::APSInt int1("12");481 llvm::APSInt int2("-4");482 Scalar I1(int1);483 Scalar I2(int2);484 Scalar F(ap_float);485 486 llvm::APFloat out1_float = I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloat);487 llvm::APFloat out1_double =488 I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeDouble);489 llvm::APFloat out1_longdouble =490 I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeLongDouble);491 llvm::APFloat out1_nan =492 I1.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloatComplex);493 EXPECT_TRUE(!out1_float.isNegative());494 EXPECT_TRUE(!out1_double.isNegative());495 EXPECT_TRUE(out1_double.bitwiseIsEqual(out1_longdouble));496 EXPECT_FALSE(out1_double.bitwiseIsEqual(out1_float));497 EXPECT_TRUE(out1_nan.bitwiseIsEqual(ap_nan));498 499 llvm::APFloat out2_float = I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloat);500 llvm::APFloat out2_double =501 I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeDouble);502 llvm::APFloat out2_longdouble =503 I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeLongDouble);504 llvm::APFloat out2_nan =505 I2.CreateAPFloatFromAPSInt(lldb::eBasicTypeFloatComplex);506 EXPECT_TRUE(out2_float.isNegative());507 EXPECT_TRUE(out2_double.isNegative());508 EXPECT_TRUE(out2_double.bitwiseIsEqual(out2_longdouble));509 EXPECT_FALSE(out2_double.bitwiseIsEqual(out2_float));510 EXPECT_TRUE(out2_nan.bitwiseIsEqual(ap_nan));511 512 llvm::APFloat out3_float = F.CreateAPFloatFromAPFloat(lldb::eBasicTypeFloat);513 llvm::APFloat out3_double =514 F.CreateAPFloatFromAPFloat(lldb::eBasicTypeDouble);515 llvm::APFloat out3_longdouble =516 F.CreateAPFloatFromAPFloat(lldb::eBasicTypeLongDouble);517 llvm::APFloat out3_nan =518 F.CreateAPFloatFromAPFloat(lldb::eBasicTypeFloatComplex);519 EXPECT_TRUE(out3_double.bitwiseIsEqual(out3_longdouble));520 EXPECT_FALSE(out3_double.bitwiseIsEqual(out3_float));521 EXPECT_TRUE(out3_nan.bitwiseIsEqual(ap_nan));522}523