[libunwind] Add casts to avoid warnings about implicit conversions losing precision

[mstorsjo]

Summary

This fixes warnings like these:

DwarfInstructions.hpp:85:25: warning: implicit conversion

loses integer precision: 'uint64_t' (aka 'unsigned long long') to
'libunwind::DwarfInstructions<libunwind::LocalAddressSpace,
libunwind::Registers_arm>::pint_t' (aka 'unsigned int')
[-Wshorten-64-to-32]

DwarfInstructions.hpp:88:25: warning: implicit conversion

loses integer precision: 'uint64_t' (aka 'unsigned long long') to
'libunwind::DwarfInstructions<libunwind::LocalAddressSpace,
libunwind::Registers_arm>::pint_t' (aka 'unsigned int')
[-Wshorten-64-to-32]

[ldionne]

I'm not really familiar with this code -- can you quickly explain why it's OK to lose precision here? Mostly for my education.

[mstorsjo]

In D56983#1366300, @ldionne wrote:

I'm not really familiar with this code -- can you quickly explain why it's OK to lose precision here? Mostly for my education.

The LocalAddressSpace class has got a getRegister method that returns uint64_t, while this method returns a variable sized to the actual size of registers on the current architecture. I.e. this fixes warnings on 32 bit architectures.

[ldionne]

In D56983#1366437, @mstorsjo wrote:

In D56983#1366300, @ldionne wrote:

I'm not really familiar with this code -- can you quickly explain why it's OK to lose precision here? Mostly for my education.

The LocalAddressSpace class has got a getRegister method that returns uint64_t, while this method returns a variable sized to the actual size of registers on the current architecture. I.e. this fixes warnings on 32 bit architectures.

I guess my question could have been rephrased as: why doesn't LocalAddressSpace::getRegister return a uint32_t on 32 bit architectures, but that's not useful because you might just as well always return a 64 bit value, which is larger than needed in the worst case. I see why that's the right place to put this cast now.

LGTM.

[mstorsjo]

In D56983#1366467, @ldionne wrote:

I guess my question could have been rephrased as: why doesn't LocalAddressSpace::getRegister return a uint32_t on 32 bit architectures, but that's not useful because you might just as well always return a 64 bit value, which is larger than needed in the worst case. I see why that's the right place to put this cast now.

Well, that might also be a valid way to fix it - but it's a much larger and potentially riskier endeavour. This patch just confirms to the compiler that the code currently does behave as intended in this regard, as it has worked so far.

libunwind/trunk/src/DwarfInstructions.hpp

 
 
 template <typename A, typename R>
 typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
     A &addressSpace, const R &registers, pint_t cfa,
     const RegisterLocation &savedReg) {
   switch (savedReg.location) {
   case CFI_Parser<A>::kRegisterInCFA:
-    return addressSpace.getRegister(cfa + (pint_t)savedReg.value);
+    return (pint_t)addressSpace.getRegister(cfa + (pint_t)savedReg.value);
 
   case CFI_Parser<A>::kRegisterAtExpression:
-    return addressSpace.getRegister(
-        evaluateExpression((pint_t)savedReg.value, addressSpace,
-                            registers, cfa));
+    return (pint_t)addressSpace.getRegister(evaluateExpression(
+        (pint_t)savedReg.value, addressSpace, registers, cfa));
 
   case CFI_Parser<A>::kRegisterIsExpression:
     return evaluateExpression((pint_t)savedReg.value, addressSpace,
                               registers, cfa);
 
   case CFI_Parser<A>::kRegisterInRegister:
     return registers.getRegister((int)savedReg.value);