Silence the implicit signed/unsigned conversion warning.

[logan]

Summary

This commit will silence various signed/unsigned conversion
warning by casting the value explicitly or changing the
variable type.

[thakis]

Thanks!

src/Unwind/Unwind-EHABI.cpp

110

No need for the 0x

Also, since we know this is always 32bit code, you can just write ~1u (everywhere)

213

Huh, your compiler warns when widening a unsigned byte to an unsigned int? Interesting.

[rsmith]

src/Unwind/Unwind-EHABI.cpp

213

Both subexpressions of the | used to be of type signed int; the warning will be for converting the result of the | to unsigned.

[logan]

Thanks for your review. Committed as r211912 .

Note:

• (uint32_t)0x1 is replaced with 1u to address the first suggestion.
• The second suggestion w.r.t. RegisterRange() won't work due to the integer promotion rules, thus that line is committed as-is.

src/Unwind/AddressSpace.hpp

#endif
     info.compact_unwind_section        = (uintptr_t)dyldInfo.compact_unwind_section;
     info.compact_unwind_section_length = dyldInfo.compact_unwind_section_length;
     return true;
   }
 #elif LIBCXXABI_ARM_EHABI
   int length = 0;
   info.arm_section = (uintptr_t) dl_unwind_find_exidx(
       (_Unwind_Ptr) targetAddr, &length);
-  info.arm_section_length = length;
+  info.arm_section_length = (uintptr_t)length;
   _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %X length %x\n",
                              info.arm_section, info.arm_section_length);
   if (info.arm_section && info.arm_section_length)
     return true;
 #endif
 
   return false;
 }

src/Unwind/Unwind-EHABI.cpp

 
 #if LIBCXXABI_ARM_EHABI
 namespace {
 
 // Strange order: take words in order, but inside word, take from most to least
 // signinficant byte.
 uint8_t getByte(uint32_t* data, size_t offset) {
   uint8_t* byteData = reinterpret_cast<uint8_t*>(data);
-  return byteData[(offset & ~0x03) + (3 - (offset&0x03))];
+  return byteData[(offset & ~(size_t)0x03) + (3 - (offset & (size_t)0x03))];
 }
 
 const char* getNextWord(const char* data, uint32_t* out) {
   *out = *reinterpret_cast<const uint32_t*>(data);
   return data + 4;
 }
 
 const char* getNextNibble(const char* data, uint32_t* out) {

 };
 
 _Unwind_Reason_Code ProcessDescriptors(
     _Unwind_State state,
     _Unwind_Control_Block* ucbp,
     struct _Unwind_Context* context,
     Descriptor::Format format,
     const char* descriptorStart,
-    int flags) {
+    uint32_t flags) {
+
   // EHT is inlined in the index using compact form. No descriptors. #5
   if (flags & 0x1)
     return _URC_CONTINUE_UNWIND;
 
   // TODO: We should check the state here, and determine whether we need to
   // perform phase1 or phase2 unwinding.
   (void)state;
 
switch (format) {
         return _URC_FAILURE;
     }
 
     // See # 9.2 table for decoding the kind of descriptor. It's a 2-bit value.
     Descriptor::Kind kind =
         static_cast<Descriptor::Kind>((length & 0x1) | ((offset & 0x1) << 1));
 
     // Clear off flag from last bit.
-    length &= ~1;
-    offset &= ~1;
+    length &= ~(uint32_t)0x1;
+    offset &= ~(uint32_t)0x1;
     uintptr_t scopeStart = ucbp->pr_cache.fnstart + offset;
     uintptr_t scopeEnd = scopeStart + length;
     uintptr_t pc = _Unwind_GetIP(context);
     bool isInScope = (scopeStart <= pc) && (pc < scopeEnd);
 
     switch (kind) {
       case Descriptor::CLEANUP: {
         // TODO(ajwong): Handle cleanup descriptors.

 // _UVRSD_UINT32.
 uint32_t RegisterMask(uint8_t start, uint8_t count_minus_one) {
   return ((1U << (count_minus_one + 1)) - 1) << start;
 }
 
 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_VFP /
 // _UVRSD_DOUBLE.
 uint32_t RegisterRange(uint8_t start, uint8_t count_minus_one) {
-  return (start << 16) | (count_minus_one + 1);
+  return ((uint32_t)start << 16) | ((uint32_t)count_minus_one + 1);
 }
 
 } // end anonymous namespace
 
 _Unwind_Reason_Code _Unwind_VRS_Interpret(
     _Unwind_Context* context,
     uint32_t* data,
     size_t offset,
     size_t len) {
   bool wrotePC = false;
   bool finish = false;
   while (offset < len && !finish) {
     uint8_t byte = getByte(data, offset++);
     if ((byte & 0x80) == 0) {
       uint32_t sp;
       _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
       if (byte & 0x40)
-        sp -= ((byte & 0x3f) << 2) + 4;
+        sp -= (((uint32_t)byte & 0x3f) << 2) + 4;
       else
-        sp += (byte << 2) + 4;
+        sp += ((uint32_t)byte << 2) + 4;
       _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
     } else {
       switch (byte & 0xf0) {
         case 0x80: {
           if (offset >= len)
             return _URC_FAILURE;
-          uint16_t registers =
-              ((byte & 0x0f) << 12) | (getByte(data, offset++) << 4);
+          uint32_t registers =
+              (((uint32_t)byte & 0x0f) << 12) |
+              (((uint32_t)getByte(data, offset++)) << 4);
           if (!registers)
             return _URC_FAILURE;
-          if (registers & (1<<15))
+          if (registers & (1 << 15))
             wrotePC = true;
           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
           break;
         }
         case 0x90: {
           uint8_t reg = byte & 0x0f;
           if (reg == 13 || reg == 15)
             return _URC_FAILURE;
           uint32_t sp;
           _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_R0 + reg,
                           _UVRSD_UINT32, &sp);
           _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
                           &sp);
           break;
         }
         case 0xa0: {
           uint32_t registers = RegisterMask(4, byte & 0x07);
           if (byte & 0x08)
-            registers |= 1<<14;
+            registers |= 1 << 14;
           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
           break;
         }
         case 0xb0: {
           switch (byte) {
             case 0xb0:
               finish = true;
               break;
_LIBUNWIND_TRACE_API("_Unwind_VRS_Set(context=%p, regclass=%d, reg=%d, "
                        "rep=%d, value=0x%llX)\n", context, regclass,
                        regno, representation,
                        ValueAsBitPattern(representation, valuep));
   unw_cursor_t *cursor = (unw_cursor_t *)context;
   switch (regclass) {
     case _UVRSC_CORE:
       if (representation != _UVRSD_UINT32 || regno > 15)
         return _UVRSR_FAILED;
-      return unw_set_reg(cursor, UNW_ARM_R0 + regno, *(unw_word_t *)valuep) ==
-                     UNW_ESUCCESS
+      return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
+                         *(unw_word_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_WMMXC:
       if (representation != _UVRSD_UINT32 || regno > 3)
         return _UVRSR_FAILED;
-      return unw_set_reg(cursor, UNW_ARM_WC0 + regno, *(unw_word_t *)valuep) ==
-                     UNW_ESUCCESS
+      return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
+                         *(unw_word_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_VFP:
       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
         return _UVRSR_FAILED;
       if (representation == _UVRSD_VFPX) {
         // Can only touch d0-15 with FSTMFDX.
         if (regno > 15)
           return _UVRSR_FAILED;
         unw_save_vfp_as_X(cursor);
       } else {
         if (regno > 31)
           return _UVRSR_FAILED;
       }
-      return unw_set_fpreg(cursor, UNW_ARM_D0 + regno,
+      return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
                            *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_WMMXD:
       if (representation != _UVRSD_DOUBLE || regno > 31)
         return _UVRSR_FAILED;
-      return unw_set_fpreg(cursor, UNW_ARM_WR0 + regno,
+      return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
                            *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
   }
 }
 
 static _Unwind_VRS_Result _Unwind_VRS_Get_Internal(
     _Unwind_Context *context,
     _Unwind_VRS_RegClass regclass,
     uint32_t regno,
     _Unwind_VRS_DataRepresentation representation,
     void *valuep) {
   unw_cursor_t *cursor = (unw_cursor_t *)context;
   switch (regclass) {
     case _UVRSC_CORE:
       if (representation != _UVRSD_UINT32 || regno > 15)
         return _UVRSR_FAILED;
-      return unw_get_reg(cursor, UNW_ARM_R0 + regno, (unw_word_t *)valuep) ==
-                     UNW_ESUCCESS
+      return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
+                         (unw_word_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_WMMXC:
       if (representation != _UVRSD_UINT32 || regno > 3)
         return _UVRSR_FAILED;
-      return unw_get_reg(cursor, UNW_ARM_WC0 + regno, (unw_word_t *)valuep) ==
-                     UNW_ESUCCESS
+      return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
+                         (unw_word_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_VFP:
       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
         return _UVRSR_FAILED;
       if (representation == _UVRSD_VFPX) {
         // Can only touch d0-15 with FSTMFDX.
         if (regno > 15)
           return _UVRSR_FAILED;
         unw_save_vfp_as_X(cursor);
       } else {
         if (regno > 31)
           return _UVRSR_FAILED;
       }
-      return unw_get_fpreg(cursor, UNW_ARM_D0 + regno, (unw_fpreg_t *)valuep) ==
-                     UNW_ESUCCESS
+      return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
+                           (unw_fpreg_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
     case _UVRSC_WMMXD:
       if (representation != _UVRSD_DOUBLE || regno > 31)
         return _UVRSR_FAILED;
-      return unw_get_fpreg(cursor, UNW_ARM_WR0 + regno,
+      return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
                            (unw_fpreg_t *)valuep) == UNW_ESUCCESS
                  ? _UVRSR_OK
                  : _UVRSR_FAILED;
   }
 }
 
 _Unwind_VRS_Result _Unwind_VRS_Get(
     _Unwind_Context *context,
case _UVRSC_WMMXC: {
       // When popping SP from the stack, we don't want to override it from the
       // computed new stack location. See EHABI #7.5.4 table 3.
       bool poppedSP = false;
       uint32_t* sp;
       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
                           _UVRSD_UINT32, &sp) != _UVRSR_OK) {
         return _UVRSR_FAILED;
       }
-      for (int i = 0; i < 16; ++i) {
-        if (!(discriminator & (1<<i)))
+      for (uint32_t i = 0; i < 16; ++i) {
+        if (!(discriminator & (1 << i)))
           continue;
         uint32_t value = *sp++;
         if (regclass == _UVRSC_CORE && i == 13)
           poppedSP = true;
         if (_Unwind_VRS_Set(context, regclass, i,
                             _UVRSD_UINT32, &value) != _UVRSR_OK) {
           return _UVRSR_FAILED;
         }