[libunwind] Improve unwinder stack usage - II

[rmaprath]

Summary

This is a follow-up to D20119 (although not dependent on it).

unwind_phase1 and unwind_phase2 allocate their own copies of unw_cursor_t buffers on the stack. This can blow-up stack usage of the unwinder depending on how these two functions get inlined into _Unwind_RaiseException. Clang seems to inline unwind_phase1 into _Unwind_RaiseException but not unwind_phase2, thus creating two unw_cursor_t buffers on the stack.

One way to work-around this problem is to mark both unwind_phase1 and unwind_phase2 as noinline. I chose to take the less macro-dependent approach and explicitly allocate a unw_cursor_t buffer and pass that into unwind_phase1 and unwind_phase2 functions.

This shaves off about ~1000 bytes of stack usage on ARM targets.

The current patch together with D20119, shaves off about roughly 2KB of stack usage.

[bcraig]

LGTM. You probably need to get an approval from someone else though, as I haven't really established myself in the libunwind code base.

As a side note... one of these days clang / llvm stack compaction may actually work reasonably well, and tricks like this won't be necessary. I look forward to that day.

[rmaprath]

In D20320#439368, @bcraig wrote:

LGTM. You probably need to get an approval from someone else though, as I haven't really established myself in the libunwind code base.

As a side note... one of these days clang / llvm stack compaction may actually work reasonably well, and tricks like this won't be necessary. I look forward to that day.

Thanks.

Do you know if there are clang / llvm passes that attempts to achieve some sort of stack compaction? I couldn't find much.

@jroelofs: Gentle ping.

/ Asiri

[jroelofs]

Probably worth doing the same thing for the non-EHABI non-SJLJ implementation, too (that can of course go in a separate commit).

LGTM

[bcraig]

In D20320#442246, @rmaprath wrote:

Do you know if there are clang / llvm passes that attempts to achieve some sort of stack compaction? I couldn't find much.

I'm not sure if it belongs to its own pass, or if it is part of another pass, but the algorithm and discussion revolve around the term "stack coloring". The code lives in llvm lib/CodeGen/StackColoring. Here's a recent review that messed with it: http://reviews.llvm.org/D18827

src/Unwind-EHABI.cpp

 extern "C" _Unwind_Reason_Code __aeabi_unwind_cpp_pr2(
     _Unwind_State state,
     _Unwind_Control_Block *ucbp,
     _Unwind_Context *context) {
   return unwindOneFrame(state, ucbp, context);
 }
 
 static _Unwind_Reason_Code
-unwind_phase1(unw_context_t *uc, _Unwind_Exception *exception_object) {
+unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
   // EHABI #7.3 discusses preserving the VRS in a "temporary VRS" during
   // phase 1 and then restoring it to the "primary VRS" for phase 2. The
   // effect is phase 2 doesn't see any of the VRS manipulations from phase 1.
   // In this implementation, the phases don't share the VRS backing store.
   // Instead, they are passed the original |uc| and they create a new VRS
   // from scratch thus achieving the same effect.
-  unw_cursor_t cursor1;
-  unw_init_local(&cursor1, uc);
+  unw_init_local(cursor, uc);
 
   // Walk each frame looking for a place to stop.
   for (bool handlerNotFound = true; handlerNotFound;) {
 
 #if !_LIBUNWIND_ARM_EHABI
     // Ask libuwind to get next frame (skip over first which is
     // _Unwind_RaiseException).
-    int stepResult = unw_step(&cursor1);
+    int stepResult = unw_step(cursor);
     if (stepResult == 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_step() reached "
                                  "bottom => _URC_END_OF_STACK\n",
                                  static_cast<void *>(exception_object));
       return _URC_END_OF_STACK;
     } else if (stepResult < 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_step failed => "
                                  "_URC_FATAL_PHASE1_ERROR\n",
                                  static_cast<void *>(exception_object));
       return _URC_FATAL_PHASE1_ERROR;
     }
 #endif
 
     // See if frame has code to run (has personality routine).
     unw_proc_info_t frameInfo;
-    if (unw_get_proc_info(&cursor1, &frameInfo) != UNW_ESUCCESS) {
+    if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_get_proc_info "
                                  "failed => _URC_FATAL_PHASE1_ERROR\n",
                                  static_cast<void *>(exception_object));
       return _URC_FATAL_PHASE1_ERROR;
     }
 
     // When tracing, print state information.
     if (_LIBUNWIND_TRACING_UNWINDING) {
       char functionBuf[512];
       const char *functionName = functionBuf;
       unw_word_t offset;
-      if ((unw_get_proc_name(&cursor1, functionBuf, sizeof(functionBuf),
+      if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
                              &offset) != UNW_ESUCCESS) ||
           (frameInfo.start_ip + offset > frameInfo.end_ip))
         functionName = ".anonymous.";
       unw_word_t pc;
-      unw_get_reg(&cursor1, UNW_REG_IP, &pc);
+      unw_get_reg(cursor, UNW_REG_IP, &pc);
       _LIBUNWIND_TRACE_UNWINDING(
           "unwind_phase1(ex_ojb=%p): pc=0x%llX, start_ip=0x%llX, func=%s, "
           "lsda=0x%llX, personality=0x%llX\n",
           static_cast<void *>(exception_object), (long long)pc,
           (long long)frameInfo.start_ip, functionName,
           (long long)frameInfo.lsda, (long long)frameInfo.handler);
     }
 
     // If there is a personality routine, ask it if it will want to stop at
     // this frame.
     if (frameInfo.handler != 0) {
       __personality_routine p =
           (__personality_routine)(long)(frameInfo.handler);
       _LIBUNWIND_TRACE_UNWINDING(
           "unwind_phase1(ex_ojb=%p): calling personality function %p\n",
           static_cast<void *>(exception_object),
           reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p)));
-      struct _Unwind_Context *context = (struct _Unwind_Context *)(&cursor1);
+      struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
       exception_object->pr_cache.fnstart = frameInfo.start_ip;
       exception_object->pr_cache.ehtp =
           (_Unwind_EHT_Header *)frameInfo.unwind_info;
       exception_object->pr_cache.additional = frameInfo.flags;
       _Unwind_Reason_Code personalityResult =
           (*p)(_US_VIRTUAL_UNWIND_FRAME, exception_object, context);
       _LIBUNWIND_TRACE_UNWINDING(
           "unwind_phase1(ex_ojb=%p): personality result %d start_ip %x ehtp %p "

             static_cast<void *>(exception_object));
         return _URC_FATAL_PHASE1_ERROR;
       }
     }
   }
   return _URC_NO_REASON;
 }
 
-static _Unwind_Reason_Code unwind_phase2(unw_context_t *uc,
+static _Unwind_Reason_Code unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor,
                                          _Unwind_Exception *exception_object,
                                          bool resume) {
   // See comment at the start of unwind_phase1 regarding VRS integrity.
-  unw_cursor_t cursor2;
-  unw_init_local(&cursor2, uc);
+  unw_init_local(cursor, uc);
 
   _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)\n",
                              static_cast<void *>(exception_object));
   int frame_count = 0;
 
   // Walk each frame until we reach where search phase said to stop.
   while (true) {
     // Ask libuwind to get next frame (skip over first which is
     // _Unwind_RaiseException or _Unwind_Resume).
     //
     // Resume only ever makes sense for 1 frame.
     _Unwind_State state =
         resume ? _US_UNWIND_FRAME_RESUME : _US_UNWIND_FRAME_STARTING;
     if (resume && frame_count == 1) {
       // On a resume, first unwind the _Unwind_Resume() frame. The next frame
       // is now the landing pad for the cleanup from a previous execution of
       // phase2. To continue unwindingly correctly, replace VRS[15] with the
       // IP of the frame that the previous run of phase2 installed the context
       // for. After this, continue unwinding as if normal.
       //
       // See #7.4.6 for details.
-      unw_set_reg(&cursor2, UNW_REG_IP,
+      unw_set_reg(cursor, UNW_REG_IP,
                   exception_object->unwinder_cache.reserved2);
       resume = false;
     }
 
 #if !_LIBUNWIND_ARM_EHABI
-    int stepResult = unw_step(&cursor2);
+    int stepResult = unw_step(cursor);
     if (stepResult == 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step() reached "
                                  "bottom => _URC_END_OF_STACK\n",
                                  static_cast<void *>(exception_object));
       return _URC_END_OF_STACK;
     } else if (stepResult < 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step failed => "
                                  "_URC_FATAL_PHASE1_ERROR\n",
                                  static_cast<void *>(exception_object));
       return _URC_FATAL_PHASE2_ERROR;
     }
 #endif
 
     // Get info about this frame.
     unw_word_t sp;
     unw_proc_info_t frameInfo;
-    unw_get_reg(&cursor2, UNW_REG_SP, &sp);
-    if (unw_get_proc_info(&cursor2, &frameInfo) != UNW_ESUCCESS) {
+    unw_get_reg(cursor, UNW_REG_SP, &sp);
+    if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_get_proc_info "
                                  "failed => _URC_FATAL_PHASE1_ERROR\n",
                                  static_cast<void *>(exception_object));
       return _URC_FATAL_PHASE2_ERROR;
     }
 
     // When tracing, print state information.
     if (_LIBUNWIND_TRACING_UNWINDING) {
       char functionBuf[512];
       const char *functionName = functionBuf;
       unw_word_t offset;
-      if ((unw_get_proc_name(&cursor2, functionBuf, sizeof(functionBuf),
+      if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
                              &offset) != UNW_ESUCCESS) ||
           (frameInfo.start_ip + offset > frameInfo.end_ip))
         functionName = ".anonymous.";
       _LIBUNWIND_TRACE_UNWINDING(
           "unwind_phase2(ex_ojb=%p): start_ip=0x%llX, func=%s, sp=0x%llX, "
           "lsda=0x%llX, personality=0x%llX\n",
           static_cast<void *>(exception_object), (long long)frameInfo.start_ip,
           functionName, (long long)sp, (long long)frameInfo.lsda,
           (long long)frameInfo.handler);
     }
 
     // If there is a personality routine, tell it we are unwinding.
     if (frameInfo.handler != 0) {
       __personality_routine p =
           (__personality_routine)(long)(frameInfo.handler);
-      struct _Unwind_Context *context = (struct _Unwind_Context *)(&cursor2);
+      struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
       // EHABI #7.2
       exception_object->pr_cache.fnstart = frameInfo.start_ip;
       exception_object->pr_cache.ehtp =
           (_Unwind_EHT_Header *)frameInfo.unwind_info;
       exception_object->pr_cache.additional = frameInfo.flags;
       _Unwind_Reason_Code personalityResult =
           (*p)(state, exception_object, context);
       switch (personalityResult) {

       case _URC_INSTALL_CONTEXT:
         _LIBUNWIND_TRACE_UNWINDING(
             "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT\n",
             static_cast<void *>(exception_object));
         // Personality routine says to transfer control to landing pad.
         // We may get control back if landing pad calls _Unwind_Resume().
         if (_LIBUNWIND_TRACING_UNWINDING) {
           unw_word_t pc;
-          unw_get_reg(&cursor2, UNW_REG_IP, &pc);
-          unw_get_reg(&cursor2, UNW_REG_SP, &sp);
+          unw_get_reg(cursor, UNW_REG_IP, &pc);
+          unw_get_reg(cursor, UNW_REG_SP, &sp);
           _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
                                      "user code with ip=0x%llX, sp=0x%llX\n",
                                      static_cast<void *>(exception_object),
                                      (long long)pc, (long long)sp);
         }
 
         {
           // EHABI #7.4.1 says we need to preserve pc for when _Unwind_Resume
           // is called back, to find this same frame.
           unw_word_t pc;
-          unw_get_reg(&cursor2, UNW_REG_IP, &pc);
+          unw_get_reg(cursor, UNW_REG_IP, &pc);
           exception_object->unwinder_cache.reserved2 = (uint32_t)pc;
         }
-        unw_resume(&cursor2);
+        unw_resume(cursor);
         // unw_resume() only returns if there was an error.
         return _URC_FATAL_PHASE2_ERROR;
 
       // # EHABI #7.4.3
       case _URC_FAILURE:
         abort();
 
       default:

 }
 
 /// Called by __cxa_throw.  Only returns if there is a fatal error.
 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)\n",
                        static_cast<void *>(exception_object));
   unw_context_t uc;
+  unw_cursor_t cursor;
   unw_getcontext(&uc);
 
   // This field for is for compatibility with GCC to say this isn't a forced
   // unwind. EHABI #7.2
   exception_object->unwinder_cache.reserved1 = 0;
 
   // phase 1: the search phase
-  _Unwind_Reason_Code phase1 = unwind_phase1(&uc, exception_object);
+  _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
   if (phase1 != _URC_NO_REASON)
     return phase1;
 
   // phase 2: the clean up phase
-  return unwind_phase2(&uc, exception_object, false);
+  return unwind_phase2(&uc, &cursor, exception_object, false);
 }
 
 _LIBUNWIND_EXPORT void _Unwind_Complete(_Unwind_Exception* exception_object) {
   // This is to be called when exception handling completes to give us a chance
   // to perform any housekeeping. EHABI #7.2. But we have nothing to do here.
   (void)exception_object;
 }
 
 /// When _Unwind_RaiseException() is in phase2, it hands control
 /// to the personality function at each frame.  The personality
 /// may force a jump to a landing pad in that function, the landing
 /// pad code may then call _Unwind_Resume() to continue with the
 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
 /// geneated user code.  All other _Unwind_* routines are called
 /// by the C++ runtime __cxa_* routines.
 ///
 /// Note: re-throwing an exception (as opposed to continuing the unwind)
 /// is implemented by having the code call __cxa_rethrow() which
 /// in turn calls _Unwind_Resume_or_Rethrow().
 _LIBUNWIND_EXPORT void
 _Unwind_Resume(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)\n",
                        static_cast<void *>(exception_object));
   unw_context_t uc;
+  unw_cursor_t cursor;
   unw_getcontext(&uc);
 
   // _Unwind_RaiseException on EHABI will always set the reserved1 field to 0,
   // which is in the same position as private_1 below.
   // TODO(ajwong): Who wronte the above? Why is it true?
-  unwind_phase2(&uc, exception_object, true);
+  unwind_phase2(&uc, &cursor, exception_object, true);
 
   // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
   _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
 }
 
 /// Called by personality handler during phase 2 to get LSDA for current frame.
 _LIBUNWIND_EXPORT uintptr_t
 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {