libcxxabi: Rename .hpp files to .h

[thakis]

Summary

LLVM uses .h as its extension for header files.

[EricWF]

LGTM.

libcxxabi/trunk/src/cxa_default_handlers.cpp

 //===------------------------- cxa_default_handlers.cpp -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //
 // This file implements the default terminate_handler and unexpected_handler.
 //===----------------------------------------------------------------------===//
 
 #include <stdexcept>
 #include <new>
 #include <exception>
 #include <cstdlib>
 #include "abort_message.h"
 #include "cxxabi.h"
-#include "cxa_handlers.hpp"
-#include "cxa_exception.hpp"
+#include "cxa_handlers.h"
+#include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h"
 
 #if !defined(LIBCXXABI_SILENT_TERMINATE)
 static const char* cause = "uncaught";
 
 __attribute__((noreturn))
 static void demangling_terminate_handler()

libcxxabi/trunk/src/cxa_exception.h

+//===------------------------- cxa_exception.h ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//  
+//  This file implements the "Exception Handling APIs"
+//  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
+//  
+//===----------------------------------------------------------------------===//
+
+#ifndef _CXA_EXCEPTION_H
+#define _CXA_EXCEPTION_H
+
+#include <exception> // for std::unexpected_handler and std::terminate_handler
+#include "cxxabi.h"
+#include "unwind.h"
+
+namespace __cxxabiv1 {
+
+static const uint64_t kOurExceptionClass          = 0x434C4E47432B2B00; // CLNGC++\0
+static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
+static const uint64_t get_vendor_and_language     = 0xFFFFFFFFFFFFFF00; // mask for CLNGC++
+
+uint64_t __getExceptionClass  (const _Unwind_Exception*);
+void     __setExceptionClass  (      _Unwind_Exception*, uint64_t);
+bool     __isOurExceptionClass(const _Unwind_Exception*);
+
+struct _LIBCXXABI_HIDDEN __cxa_exception {
+#if defined(__LP64__) || defined(_LIBCXXABI_ARM_EHABI)
+    // This is a new field to support C++ 0x exception_ptr.
+    // For binary compatibility it is at the start of this
+    // struct which is prepended to the object thrown in
+    // __cxa_allocate_exception.
+    size_t referenceCount;
+#endif
+
+    //  Manage the exception object itself.
+    std::type_info *exceptionType;
+    void (*exceptionDestructor)(void *);
+    std::unexpected_handler unexpectedHandler;
+    std::terminate_handler  terminateHandler;
+
+    __cxa_exception *nextException;
+
+    int handlerCount;
+
+#if defined(_LIBCXXABI_ARM_EHABI)
+    __cxa_exception* nextPropagatingException;
+    int propagationCount;
+#else
+    int handlerSwitchValue;
+    const unsigned char *actionRecord;
+    const unsigned char *languageSpecificData;
+    void *catchTemp;
+    void *adjustedPtr;
+#endif
+
+#if !defined(__LP64__) && !defined(_LIBCXXABI_ARM_EHABI)
+    // This is a new field to support C++ 0x exception_ptr.
+    // For binary compatibility it is placed where the compiler
+    // previously adding padded to 64-bit align unwindHeader.
+    size_t referenceCount;
+#endif
+    _Unwind_Exception unwindHeader;
+};
+
+// http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html
+// The layout of this structure MUST match the layout of __cxa_exception, with
+// primaryException instead of referenceCount.
+struct _LIBCXXABI_HIDDEN __cxa_dependent_exception {
+#if defined(__LP64__) || defined(_LIBCXXABI_ARM_EHABI)
+    void* primaryException;
+#endif
+
+    std::type_info *exceptionType;
+    void (*exceptionDestructor)(void *);
+    std::unexpected_handler unexpectedHandler;
+    std::terminate_handler terminateHandler;
+
+    __cxa_exception *nextException;
+
+    int handlerCount;
+
+#if defined(_LIBCXXABI_ARM_EHABI)
+    __cxa_exception* nextPropagatingException;
+    int propagationCount;
+#else
+    int handlerSwitchValue;
+    const unsigned char *actionRecord;
+    const unsigned char *languageSpecificData;
+    void * catchTemp;
+    void *adjustedPtr;
+#endif
+
+#if !defined(__LP64__) && !defined(_LIBCXXABI_ARM_EHABI)
+    void* primaryException;
+#endif
+    _Unwind_Exception unwindHeader;
+};
+
+struct _LIBCXXABI_HIDDEN __cxa_eh_globals {
+    __cxa_exception *   caughtExceptions;
+    unsigned int        uncaughtExceptions;
+#if defined(_LIBCXXABI_ARM_EHABI)
+    __cxa_exception* propagatingExceptions;
+#endif
+};
+
+extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals      ();
+extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals_fast ();
+
+extern "C" _LIBCXXABI_FUNC_VIS void * __cxa_allocate_dependent_exception ();
+extern "C" _LIBCXXABI_FUNC_VIS void __cxa_free_dependent_exception (void * dependent_exception);
+
+}  // namespace __cxxabiv1
+
+#endif  // _CXA_EXCEPTION_H

libcxxabi/trunk/src/cxa_exception.hpp

-//===------------------------- cxa_exception.hpp --------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//  
-//  This file implements the "Exception Handling APIs"
-//  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
-//  
-//===----------------------------------------------------------------------===//
-
-#ifndef _CXA_EXCEPTION_H
-#define _CXA_EXCEPTION_H
-
-#include <exception> // for std::unexpected_handler and std::terminate_handler
-#include "cxxabi.h"
-#include "unwind.h"
-
-namespace __cxxabiv1 {
-
-static const uint64_t kOurExceptionClass          = 0x434C4E47432B2B00; // CLNGC++\0
-static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
-static const uint64_t get_vendor_and_language     = 0xFFFFFFFFFFFFFF00; // mask for CLNGC++
-
-uint64_t __getExceptionClass  (const _Unwind_Exception*);
-void     __setExceptionClass  (      _Unwind_Exception*, uint64_t);
-bool     __isOurExceptionClass(const _Unwind_Exception*);
-
-struct _LIBCXXABI_HIDDEN __cxa_exception {
-#if defined(__LP64__) || defined(_LIBCXXABI_ARM_EHABI)
-    // This is a new field to support C++ 0x exception_ptr.
-    // For binary compatibility it is at the start of this
-    // struct which is prepended to the object thrown in
-    // __cxa_allocate_exception.
-    size_t referenceCount;
-#endif
-
-    //  Manage the exception object itself.
-    std::type_info *exceptionType;
-    void (*exceptionDestructor)(void *);
-    std::unexpected_handler unexpectedHandler;
-    std::terminate_handler  terminateHandler;
-
-    __cxa_exception *nextException;
-
-    int handlerCount;
-
-#if defined(_LIBCXXABI_ARM_EHABI)
-    __cxa_exception* nextPropagatingException;
-    int propagationCount;
-#else
-    int handlerSwitchValue;
-    const unsigned char *actionRecord;
-    const unsigned char *languageSpecificData;
-    void *catchTemp;
-    void *adjustedPtr;
-#endif
-
-#if !defined(__LP64__) && !defined(_LIBCXXABI_ARM_EHABI)
-    // This is a new field to support C++ 0x exception_ptr.
-    // For binary compatibility it is placed where the compiler
-    // previously adding padded to 64-bit align unwindHeader.
-    size_t referenceCount;
-#endif
-    _Unwind_Exception unwindHeader;
-};
-
-// http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html
-// The layout of this structure MUST match the layout of __cxa_exception, with
-// primaryException instead of referenceCount.
-struct _LIBCXXABI_HIDDEN __cxa_dependent_exception {
-#if defined(__LP64__) || defined(_LIBCXXABI_ARM_EHABI)
-    void* primaryException;
-#endif
-
-    std::type_info *exceptionType;
-    void (*exceptionDestructor)(void *);
-    std::unexpected_handler unexpectedHandler;
-    std::terminate_handler terminateHandler;
-
-    __cxa_exception *nextException;
-
-    int handlerCount;
-
-#if defined(_LIBCXXABI_ARM_EHABI)
-    __cxa_exception* nextPropagatingException;
-    int propagationCount;
-#else
-    int handlerSwitchValue;
-    const unsigned char *actionRecord;
-    const unsigned char *languageSpecificData;
-    void * catchTemp;
-    void *adjustedPtr;
-#endif
-
-#if !defined(__LP64__) && !defined(_LIBCXXABI_ARM_EHABI)
-    void* primaryException;
-#endif
-    _Unwind_Exception unwindHeader;
-};
-
-struct _LIBCXXABI_HIDDEN __cxa_eh_globals {
-    __cxa_exception *   caughtExceptions;
-    unsigned int        uncaughtExceptions;
-#if defined(_LIBCXXABI_ARM_EHABI)
-    __cxa_exception* propagatingExceptions;
-#endif
-};
-
-extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals      ();
-extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals_fast ();
-
-extern "C" _LIBCXXABI_FUNC_VIS void * __cxa_allocate_dependent_exception ();
-extern "C" _LIBCXXABI_FUNC_VIS void __cxa_free_dependent_exception (void * dependent_exception);
-
-}  // namespace __cxxabiv1
-
-#endif  // _CXA_EXCEPTION_H

libcxxabi/trunk/src/cxa_exception.cpp

 //===------------------------- cxa_exception.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //  
 //  This file implements the "Exception Handling APIs"
 //  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
 //  
 //===----------------------------------------------------------------------===//
 
 #include "cxxabi.h"
 
 #include <exception>        // for std::terminate
 #include <cstring>          // for memset
-#include "cxa_exception.hpp"
-#include "cxa_handlers.hpp"
+#include "cxa_exception.h"
+#include "cxa_handlers.h"
 #include "fallback_malloc.h"
 #include "include/atomic_support.h"
 
 #if __has_feature(address_sanitizer)
 extern "C" void __asan_handle_no_return(void);
 #endif
 
 // +---------------------------+-----------------------------+---------------+

libcxxabi/trunk/src/cxa_exception_storage.cpp

 //===--------------------- cxa_exception_storage.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //  
 //  This file implements the storage for the "Caught Exception Stack"
 //  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#cxx-exc-stack
 //  
 //===----------------------------------------------------------------------===//
 
-#include "cxa_exception.hpp"
+#include "cxa_exception.h"
 
 #include <__threading_support>
 
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
 
 namespace __cxxabiv1 {
 extern "C" {
     static __cxa_eh_globals eh_globals;

libcxxabi/trunk/src/cxa_handlers.h

+//===------------------------- cxa_handlers.h -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//
+// This file implements the functionality associated with the terminate_handler,
+//   unexpected_handler, and new_handler.
+//===----------------------------------------------------------------------===//
+
+#ifndef _CXA_HANDLERS_H
+#define _CXA_HANDLERS_H
+
+#include <__cxxabi_config.h>
+
+#include <exception>
+
+namespace std
+{
+
+_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
+void
+__unexpected(unexpected_handler func);
+
+_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
+void
+__terminate(terminate_handler func) _NOEXCEPT;
+
+}  // std
+
+extern "C"
+{
+
+_LIBCXXABI_DATA_VIS extern void (*__cxa_terminate_handler)();
+_LIBCXXABI_DATA_VIS extern void (*__cxa_unexpected_handler)();
+_LIBCXXABI_DATA_VIS extern void (*__cxa_new_handler)();
+
+/*
+
+    At some point in the future these three symbols will become
+    C++11 atomic variables:
+
+    extern std::atomic<std::terminate_handler>  __cxa_terminate_handler;
+    extern std::atomic<std::unexpected_handler> __cxa_unexpected_handler;
+    extern std::atomic<std::new_handler>        __cxa_new_handler;
+
+    This change will not impact their ABI.  But it will allow for a
+    portable performance optimization.
+
+*/
+
+} // extern "C"
+
+#endif  // _CXA_HANDLERS_H

libcxxabi/trunk/src/cxa_handlers.hpp

-//===------------------------- cxa_handlers.cpp ---------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//
-// This file implements the functionality associated with the terminate_handler,
-//   unexpected_handler, and new_handler.
-//===----------------------------------------------------------------------===//
-
-#ifndef _CXA_HANDLERS_H
-#define _CXA_HANDLERS_H
-
-#include <__cxxabi_config.h>
-
-#include <exception>
-
-namespace std
-{
-
-_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
-void
-__unexpected(unexpected_handler func);
-
-_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
-void
-__terminate(terminate_handler func) _NOEXCEPT;
-
-}  // std
-
-extern "C"
-{
-
-_LIBCXXABI_DATA_VIS extern void (*__cxa_terminate_handler)();
-_LIBCXXABI_DATA_VIS extern void (*__cxa_unexpected_handler)();
-_LIBCXXABI_DATA_VIS extern void (*__cxa_new_handler)();
-
-/*
-
-    At some point in the future these three symbols will become
-    C++11 atomic variables:
-
-    extern std::atomic<std::terminate_handler>  __cxa_terminate_handler;
-    extern std::atomic<std::unexpected_handler> __cxa_unexpected_handler;
-    extern std::atomic<std::new_handler>        __cxa_new_handler;
-
-    This change will not impact their ABI.  But it will allow for a
-    portable performance optimization.
-
-*/
-
-} // extern "C"
-
-#endif  // _CXA_HANDLERS_H

libcxxabi/trunk/src/cxa_handlers.cpp

 //===------------------------- cxa_handlers.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //
 // This file implements the functionality associated with the terminate_handler,
 //   unexpected_handler, and new_handler.
 //===----------------------------------------------------------------------===//
 
 #include <stdexcept>
 #include <new>
 #include <exception>
 #include "abort_message.h"
 #include "cxxabi.h"
-#include "cxa_handlers.hpp"
-#include "cxa_exception.hpp"
+#include "cxa_handlers.h"
+#include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h"
 
 namespace std
 {
 
 unexpected_handler
 get_unexpected() _NOEXCEPT

libcxxabi/trunk/src/cxa_noexception.cpp

 //  
 //===----------------------------------------------------------------------===//
 
 // Support functions for the no-exceptions libc++ library
 
 #include "cxxabi.h"
 
 #include <exception>        // for std::terminate
-#include "cxa_exception.hpp"
-#include "cxa_handlers.hpp"
+#include "cxa_exception.h"
+#include "cxa_handlers.h"
 
 namespace __cxxabiv1 {
 
 extern "C" {
 
 void
 __cxa_increment_exception_refcount(void *thrown_object) throw() {
     if (thrown_object != nullptr)

libcxxabi/trunk/src/cxa_personality.cpp

 //===----------------------------------------------------------------------===//
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <typeinfo>
 
 #include "__cxxabi_config.h"
-#include "cxa_exception.hpp"
-#include "cxa_handlers.hpp"
+#include "cxa_exception.h"
+#include "cxa_handlers.h"
 #include "private_typeinfo.h"
 #include "unwind.h"
 
 #if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
 #include <windows.h>
 #include <winnt.h>
 
 extern "C" EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD,

libcxxabi/trunk/src/cxa_unexpected.cpp

 //===------------------------- cxa_unexpected.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <exception>
 #include "cxxabi.h"
-#include "cxa_exception.hpp"
+#include "cxa_exception.h"
 
 namespace __cxxabiv1
 {
 
 extern "C"
 {
 
 }
 
 }  // namespace __cxxabiv1
 

libcxxabi/trunk/test/dynamic_cast14.pass.cpp

 //===------------------------- dynamic_cast14.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
-#include "support/timer.hpp"
+#include "support/timer.h"
 
 namespace t1
 {
 
 struct A1
 {
     char _[43981];
     virtual ~A1() {}

libcxxabi/trunk/test/dynamic_cast3.pass.cpp

 //===------------------------- dynamic_cast3.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
-#include "support/timer.hpp"
+#include "support/timer.h"
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Winaccessible-base"
 #endif
 
 /*

libcxxabi/trunk/test/dynamic_cast5.pass.cpp

 //===------------------------- dynamic_cast5.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
-#include "support/timer.hpp"
+#include "support/timer.h"
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Winaccessible-base"
 #endif
 
 namespace t1

libcxxabi/trunk/test/dynamic_cast_stress.pass.cpp

 //===------------------------- dynamic_cast_stress.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 
 #include <cassert>
 #include <tuple>
-#include "support/timer.hpp"
+#include "support/timer.h"
 
 template <std::size_t Indx, std::size_t Depth>
 struct C
     : public virtual C<Indx, Depth-1>,
       public virtual C<Indx+1, Depth-1>
 {
     virtual ~C() {}
 };

libcxxabi/trunk/test/support/timer.h

+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef TIMER_HPP
+#define TIMER_HPP
+
+// Define LIBCXXABI_NO_TIMER to disable testing with a timer.
+#ifndef LIBCXXABI_NO_TIMER
+
+#include <chrono>
+#include <iostream>
+
+class timer
+{
+    typedef std::chrono::high_resolution_clock Clock;
+    typedef Clock::time_point TimePoint;
+    typedef std::chrono::microseconds MicroSeconds;
+public:
+    timer() : m_start(Clock::now()) {}
+
+    timer(timer const &) = delete;
+    timer & operator=(timer const &) = delete;
+
+    ~timer()
+    {
+        using std::chrono::duration_cast;
+        TimePoint end = Clock::now();
+        MicroSeconds us = duration_cast<MicroSeconds>(end - m_start);
+        std::cout << us.count() << " microseconds\n";
+    }
+
+private:
+    TimePoint m_start;
+};
+
+#else /* LIBCXXABI_NO_TIMER */
+
+class timer
+{
+public:
+    timer() {}
+    timer(timer const &) = delete;
+    timer & operator=(timer const &) = delete;
+    ~timer() {}
+};
+
+#endif /* LIBCXXABI_NO_TIMER */
+
+#endif /* TIMER_HPP */

libcxxabi/trunk/test/support/timer.hpp

-//===----------------------------------------------------------------------===////
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===////
-
-#ifndef TIMER_HPP
-#define TIMER_HPP
-
-// Define LIBCXXABI_NO_TIMER to disable testing with a timer.
-#ifndef LIBCXXABI_NO_TIMER
-
-#include <chrono>
-#include <iostream>
-
-class timer
-{
-    typedef std::chrono::high_resolution_clock Clock;
-    typedef Clock::time_point TimePoint;
-    typedef std::chrono::microseconds MicroSeconds;
-public:
-    timer() : m_start(Clock::now()) {}
-
-    timer(timer const &) = delete;
-    timer & operator=(timer const &) = delete;
-
-    ~timer()
-    {
-        using std::chrono::duration_cast;
-        TimePoint end = Clock::now();
-        MicroSeconds us = duration_cast<MicroSeconds>(end - m_start);
-        std::cout << us.count() << " microseconds\n";
-    }
-
-private:
-    TimePoint m_start;
-};
-
-#else /* LIBCXXABI_NO_TIMER */
-
-class timer
-{
-public:
-    timer() {}
-    timer(timer const &) = delete;
-    timer & operator=(timer const &) = delete;
-    ~timer() {}
-};
-
-#endif /* LIBCXXABI_NO_TIMER */
-
-#endif /* TIMER_HPP */

libcxxabi/trunk/test/test_demangle.pass.cpp

 //===-------------------------- test_demangle.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "support/timer.hpp"
+#include "support/timer.h"
 #include <iostream>
 #include <string>
 #include <cstdlib>
 #include <cxxabi.h>
 #include <cassert>
 
 // Is long double fp80?  (Only x87 extended double has 64-bit mantissa)
 #define LDBL_FP80 (__LDBL_MANT_DIG__ == 64)

libcxxabi/trunk/test/test_exception_storage.pass.cpp

 //===-------------------- test_exception_storage.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
 #include <algorithm>
 #include <iostream>
 #include <__threading_support>
 #include <unistd.h>
 
-#include "../src/cxa_exception.hpp"
+#include "../src/cxa_exception.h"
 
 typedef __cxxabiv1::__cxa_eh_globals globals_t ;
 
 void *thread_code (void *parm) {
     size_t *result = (size_t *) parm;
     globals_t *glob1, *glob2;
     
     glob1 = __cxxabiv1::__cxa_get_globals ();