Make Lit tests C++11 compatible - accessible destructors

[tigerleapgorge]

Summary

I am continuing to make Lit tests C++11 compatible.
This patch contains 2 tests previously in D20710.

In both tests, I have made the base class destructors “protected” so they are accessible to derived classes.
In C++11, an inaccessible destructor is considered implicitly deleted and this causes the following type of compilation errors.

f.h:82:13: error: deleted function '~C3' cannot override a non-deleted function
            C3:
            ^
f.h:61:15: note: overridden virtual function is here
      virtual ~
              ^
f.h:83:15: note: destructor of 'C3' is implicitly deleted because base class '(anonymous namespace)::AAA' has an inaccessible destructor
              AAA {
              ^

[tigerleapgorge]

D20710 is a superset of this patch.
D20710 has been committed in rL296184.
No need for this patch.

test/CodeGenCXX/debug-info-use-after-free.cpp

 // RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++98 %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++11 %s
 // Check that we don't crash.
 // PR12305, PR12315
 
 # 1 "a.h"  3
 template < typename T1 > struct Types1
 {
   typedef T1 Head;
 };

 __gnu_cxx::hash_map;
 class
 C2;
 template < class > class scoped_ptr {
 };
 namespace {
 class
     AAA {
+protected:
       virtual ~
           AAA () {
           }};
 }
 template < typename > class EEE;
 template < typename CCC, typename =
 typename CCC::key_equal, typename =
 EEE < CCC > >class III {

test/CodeGenCXX/dynamic-cast-hint.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++98 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++11 -o - %s | FileCheck %s
 
-class A { virtual ~A() {} };
-class B { virtual ~B() {} };
+class A { protected: virtual ~A() {} };
+class B { protected: virtual ~B() {} };
 
 class C : A { char x; };
 class D : public A { short y; };
 class E : public A, public B { int z; };
 class F : public virtual A { long long w; };
 class G : virtual A { long long w; };
 
 class H : public E { int a; };