[builtins] Fix integer/pointer confusion in gcc_personality_v0.c

[jrtc27]

Summary

This fixes the implementation for architectures like CHERI with strong
pointer provenance (pointers, and thus uintptr_t, are represented as
hardware capabilities). On all currently-supported architectures this
should be an NFC, as size_t and uintptr_t end up being the same
underlying plain integer type.

[arichardson]

compiler-rt/lib/builtins/gcc_personality_v0.c

215

Maybe rename this to landingPadOffset to indicate that it's not a pointer?

[MaskRay]

Which statement has the type confusion?

[jrtc27]

In D95537#2525739, @MaskRay wrote:

Which statement has the type confusion?

Comments added to hopefully explain it.

compiler-rt/lib/builtins/gcc_personality_v0.c

46

This isn't strictly necessary but is more accurate, since this function just creates a machine word sized integer, not a pointer.

215

We could, it's just slightly more churn.

219

This start + length adds two uintptr_ts together, which does not make sense unless at least one is an integer rather than a pointer.

227

This funcStart + landingPad also adds two uintptr_ts together.

[MaskRay]

Thanks!

compiler-rt/lib/builtins/gcc_personality_v0.c

217

If I wrote it in the first place, I'd place landingPad == 0 below the range check, but it has no difference in practice, because __attribute__((cleanup)) has a landing pad.

compiler-rt/lib/builtins/gcc_personality_v0.c

 #define DW_EH_PE_pcrel 0x10
 #define DW_EH_PE_textrel 0x20
 #define DW_EH_PE_datarel 0x30
 #define DW_EH_PE_funcrel 0x40
 #define DW_EH_PE_aligned 0x50
 #define DW_EH_PE_indirect 0x80 // gcc extension
 
 // read a uleb128 encoded value and advance pointer
-static uintptr_t readULEB128(const uint8_t **data) {
-  uintptr_t result = 0;
-  uintptr_t shift = 0;
+static size_t readULEB128(const uint8_t **data) {
+  size_t result = 0;
+  size_t shift = 0;
   unsigned char byte;
   const uint8_t *p = *data;
   do {
     byte = *p++;
     result |= (byte & 0x7f) << shift;
     shift += 7;
   } while (byte & 0x80);
   *data = p;
   return result;
 }
 
 // read a pointer encoded value and advance pointer
 static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
   const uint8_t *p = *data;
   uintptr_t result = 0;
 
   if (encoding == DW_EH_PE_omit)
#endif
   // Walk call-site table looking for range that includes current PC.
   uint8_t callSiteEncoding = *lsda++;
   uint32_t callSiteTableLength = readULEB128(&lsda);
   const uint8_t *callSiteTableStart = lsda;
   const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength;
   const uint8_t *p = callSiteTableStart;
   while (p < callSiteTableEnd) {
     uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
-    uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
-    uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
+    size_t length = readEncodedPointer(&p, callSiteEncoding);
+    size_t landingPad = readEncodedPointer(&p, callSiteEncoding);
     readULEB128(&p); // action value not used for C code
     if (landingPad == 0)
       continue; // no landing pad for this entry
     if ((start <= pcOffset) && (pcOffset < (start + length))) {
       // Found landing pad for the PC.
       // Set Instruction Pointer to so we re-enter function
       // at landing pad. The landing pad is created by the compiler
       // to take two parameters in registers.
       _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
                     (uintptr_t)exceptionObject);
       _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
       _Unwind_SetIP(context, (funcStart + landingPad));
       return _URC_INSTALL_CONTEXT;
     }
   }
 
   // No landing pad found, continue unwinding.
   return continueUnwind(exceptionObject, context);
 }