Revert the lsda change to scan_eh_tab.

[logan]

Summary

The r211745 adds a new argument to scan_eh_tab(), i.e. lsda.
However, IMO, calling _Unwind_GetLanguageSpecificData() directly in
scan_eh_tab() was more intuitive and reduces several function call
to _Unwind_GetLanguageSpecificData() in __cxx_personality_v0().
Thus, I feel that it well be better to revert the lsda change.

This commit reverts the lsda change, and it is verified that
libcxxabi+libunwind still passes all test cases.

[thakis]

Looks good, thanks. I checked that all libcxxabi tests still pass on Android with this.

(We all think that we changed this for a good reason, but since the tests pass and we can't remember the reason let's land this. Worst case, we'll change it back once a good reason appears.)

[logan]

Thanks. Committed as r212037.

[ajwong]

IIRC, we might end up revisiting this later when we clean up cxxabi.h for
EHABI. In EHABI, there isn't a _Unwind_GetLanguageSpecificData() and this
modification was necessary to share code. We can revisit if/when someone
gets to cleaning up cxxabi.h.

[logan]

Hi Albert,

IMO, we can simply use #ifdef to provide different code for ARM EHABI.

There should be similar problem with _Unwind_GetRegionStart(), and I feel
it will be
less straightforward to introduce more and more arguments to scan_eh_tab().

Sincerely,
Logan

src/cxa_personality.cpp

3.  Scan for cleanups.  If a handler is found and this isn't forced unwind,
         May also report an error on invalid input.
         May terminate for invalid exception table.
         _UA_CLEANUP_PHASE && !_UA_HANDLER_FRAME
 */
 
 static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
                         bool native_exception,
                         _Unwind_Exception *unwind_exception,
-                        _Unwind_Context *context, const uint8_t *lsda) {
+                        _Unwind_Context *context) {
     // Initialize results to found nothing but an error
     results.ttypeIndex = 0;
     results.actionRecord = 0;
     results.languageSpecificData = 0;
     results.landingPad = 0;
     results.adjustedPtr = 0;
     results.reason = _URC_FATAL_PHASE1_ERROR;
     // Check for consistent actions
static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
     else // Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE is set
     {
         // One of these should be set.
         //   Client error
         results.reason = _URC_FATAL_PHASE1_ERROR;
         return;
     }
     // Start scan by getting exception table address
+    const uint8_t *lsda = (const uint8_t *)_Unwind_GetLanguageSpecificData(context);
     if (lsda == 0)
     {
         // There is no exception table
         results.reason = _URC_CONTINUE_UNWIND;
         return;
     }
     results.languageSpecificData = lsda;
     // Get the current instruction pointer and offset it before next
#endif
 
     bool native_exception = (exceptionClass     & get_vendor_and_language) ==
                             (kOurExceptionClass & get_vendor_and_language);
     scan_results results;
     if (actions & _UA_SEARCH_PHASE)
     {
         // Phase 1 search:  All we're looking for in phase 1 is a handler that
         //   halts unwinding
-        scan_eh_tab(
-            results, actions, native_exception, unwind_exception, context,
-            (const uint8_t *)_Unwind_GetLanguageSpecificData(context));
+        scan_eh_tab(results, actions, native_exception, unwind_exception, context);
         if (results.reason == _URC_HANDLER_FOUND)
         {
             // Found one.  Can we cache the results somewhere to optimize phase 2?
             if (native_exception)
             {
                 __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
                 exception_header->handlerSwitchValue = static_cast<int>(results.ttypeIndex);
                 exception_header->actionRecord = results.actionRecord;
if (actions & _UA_CLEANUP_PHASE)
                 results.actionRecord = exception_header->actionRecord;
                 results.languageSpecificData = exception_header->languageSpecificData;
                 results.landingPad = reinterpret_cast<uintptr_t>(exception_header->catchTemp);
                 results.adjustedPtr = exception_header->adjustedPtr;
             }
             else
             {
                 // No, do the scan again to reload the results.
-                scan_eh_tab(
-                    results, actions, native_exception,
-                    unwind_exception, context,
-                    (const uint8_t*)_Unwind_GetLanguageSpecificData(context));
+                scan_eh_tab(results, actions, native_exception, unwind_exception, context);
                 // Phase 1 told us we would find a handler.  Now in Phase 2 we
                 //   didn't find a handler.  The eh table should not be changing!
                 if (results.reason != _URC_HANDLER_FOUND)
                     call_terminate(native_exception, unwind_exception);
             }
             // Jump to the handler
             set_registers(unwind_exception, context, results);
             return _URC_INSTALL_CONTEXT;
         }
         // Either we didn't do a phase 1 search (due to forced unwinding), or
         //   phase 1 reported no catching-handlers.
         // Search for a (non-catching) cleanup
-        scan_eh_tab(
-            results, actions, native_exception, unwind_exception, context,
-            (const uint8_t*)_Unwind_GetLanguageSpecificData(context));
+        scan_eh_tab(results, actions, native_exception, unwind_exception, context);
         if (results.reason == _URC_HANDLER_FOUND)
         {
             // Found a non-catching handler.  Jump to it:
             set_registers(unwind_exception, context, results);
             return _URC_INSTALL_CONTEXT;
         }
         // Did not find a cleanup.  Return the results of the scan
         //    (normally _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE2_ERROR
#if LIBCXXABI_ARM_EHABI
     // +--------------------------------------+
 
     uint32_t *UnwindData = unwind_exception->pr_cache.ehtp + 1;
     uint32_t FirstDataWord = *UnwindData;
     size_t N = ((FirstDataWord >> 24) & 0xff);
     size_t NDataWords = N + 1;
 #endif
 
-    const uint8_t *lsda =
-        (const uint8_t *)_Unwind_GetLanguageSpecificData(context);
-
     // Copy the address of _Unwind_Control_Block to r12 so that
     // _Unwind_GetLanguageSpecificData() and _Unwind_GetRegionStart() can
     // return correct address.
     _Unwind_SetGR(context, REG_UCB, reinterpret_cast<uint32_t>(unwind_exception));
 
     scan_results results;
     switch (state) {
     case _US_VIRTUAL_UNWIND_FRAME:
         // Phase 1 search:  All we're looking for in phase 1 is a handler that halts unwinding
-        scan_eh_tab(results, _UA_SEARCH_PHASE, native_exception,
-                    unwind_exception, context, lsda);
+        scan_eh_tab(results, _UA_SEARCH_PHASE, native_exception, unwind_exception, context);
         if (results.reason == _URC_HANDLER_FOUND)
         {
             unwind_exception->barrier_cache.sp = _Unwind_GetGR(context, REG_SP);
             if (native_exception)
                 save_results_to_barrier_cache(unwind_exception, results);
             return _URC_HANDLER_FOUND;
         }
         // Did not find the catch handler
case _US_UNWIND_FRAME_STARTING:
                 // Load the result from the native exception barrier cache.
                 load_results_from_barrier_cache(results, unwind_exception);
                 results.reason = _URC_HANDLER_FOUND;
             }
             else
             {
                 // Search for the catching handler again for the foreign exception.
                 scan_eh_tab(results, static_cast<_Unwind_Action>(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME),
-                            native_exception, unwind_exception, context, lsda);
+                            native_exception, unwind_exception, context);
                 if (results.reason != _URC_HANDLER_FOUND)  // phase1 search should guarantee to find one
                     call_terminate(native_exception, unwind_exception);
             }
 
             // Install the context for the catching handler
             set_registers(unwind_exception, context, results);
             return _URC_INSTALL_CONTEXT;
         }
 
         // Either we didn't do a phase 1 search (due to forced unwinding), or
         //  phase 1 reported no catching-handlers.
         // Search for a (non-catching) cleanup
-        scan_eh_tab(results, _UA_CLEANUP_PHASE, native_exception,
-                    unwind_exception, context, lsda);
+        scan_eh_tab(results, _UA_CLEANUP_PHASE, native_exception, unwind_exception, context);
         if (results.reason == _URC_HANDLER_FOUND)
         {
             // Found a non-catching handler
 
             // ARM EHABI 8.4.2: Before we can jump to the cleanup handler, we have to setup some
             // internal data structures, so that __cxa_end_cleanup() can get unwind_exception from
             // __cxa_get_globals().
             __cxa_begin_cleanup(unwind_exception);