[DebugInfo] Fix DwarfExpression::addConstantFP for float on big-endian

[bjope]

Summary

The byte swapping, when dealing with 4 byte (float) FP constants
in DwarfExpression::addConstantFP, added in commit ef8992b9f0189005
was not correct. It always performed byte swapping using an
uint64_t value. When dealing with 4 byte values the 4 interesting
bytes ended up in the big end of the uint64_t, but later we emitted
the 4 bytes at the little end. So we ended up with zeroes being
emitted and faulty debug information.

This patch simplifies things a bit, IMHO. Using the APInt
representation throughout the function, instead of looking at
the internal representation using getRawBytes and without using
reinterpret_cast etc. And using API.byteSwap() should result in
correct byte swapping independent of APInt being 4 or 8 bytes.

[bjope]

I do not have any upstream test case for this, but got failures in our downstream testing.

Looks like no test was added for 4-byte float + big-endian as part of the original patch. Wouldn't hurt if someone would add such a test case. I just focused on fixing the bug here.

[SouraVX]

Thanks @bjope for catching this bug! I do not have big-endian machine so it must've got un-noticed(test case for 4 bytes float was written and tested/verified on x86 machine).
But I got your point, I'll see if I can add a hand written test case to address this situation.

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

 //===- llvm/CodeGen/DwarfExpression.cpp - Dwarf Debug Framework -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void DwarfExpression::addConstantFP(const APFloat &APF, const AsmPrinter &AP) {
   assert(isImplicitLocation() || isUnknownLocation());
   APInt API = APF.bitcastToAPInt();
   int NumBytes = API.getBitWidth() / 8;
   if (NumBytes == 4 /*float*/ || NumBytes == 8 /*double*/) {
     // FIXME: Add support for `long double`.
     emitOp(dwarf::DW_OP_implicit_value);
     emitUnsigned(NumBytes /*Size of the block in bytes*/);
 
-    const uint64_t *Value = API.getRawData();
-    const bool IsLittleEndian = AP.getDataLayout().isLittleEndian();
-    uint64_t Swapped = support::endian::byte_swap(
-        *Value, IsLittleEndian ? support::little : support::big);
-
-    const char *SwappedBytes = reinterpret_cast<const char *>(&Swapped);
-    for (int i = 0; i < NumBytes; ++i)
-      emitData1(SwappedBytes[i]);
+    // The loop below is emitting the value starting at least significant byte,
+    // so we need to perform a byte-swap to get the byte order correct in case
+    // of a big-endian target.
+    if (AP.getDataLayout().isBigEndian())
+      API = API.byteSwap();
+
+    for (int i = 0; i < NumBytes; ++i) {
+      emitData1(API.getZExtValue() & 0xFF);
+      API = API.lshr(8);
+    }
 
     return;
   }
   LLVM_DEBUG(
       dbgs() << "Skipped DW_OP_implicit_value creation for ConstantFP of size: "
              << API.getBitWidth() << " bits\n");
 }