[libcxx] Adjust trivial_abi tests for C++03 and C++11 testing

[miyuki]

Summary

This change replaces std::make_unique with manual construction of
std::unique_ptr to make the tests compatible with C++11
(std::make_unique is a C++14 feature).

libc++ supports std::unique_ptr and std::shared_ptr even in C++03 but
with some limitations: unique_ptr_array.pass.cpp and
shared_ptr_arg.pass.cpp fail to compile in C++03 mode and need to be
disabled.

libcxx/test/libcxx/memory/trivial_abi/shared_ptr_arg.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test shared_ptr<T> with trivial_abi as parameter type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
 
 // There were assertion failures in both parse and codegen, which are fixed in clang 11.
 // UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// UNSUPPORTED: c++03
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   int* shared_val;

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_arg.pass.cpp

int main(int, char**) {
   int shared = 0;
 
   // Without trivial-abi, the unique_ptr is deleted at the end of this
   // statement; expect_1 will see shared == 0 because it's not incremented (in
   // ~Node()) until expect_1 returns.
   //
   // With trivial-abi, expect_1 will see shared == 1 because shared_val is
   // incremented before get_val returns.
-  expect_1(&shared, get_val(std::make_unique<Node>(&shared)));
+  expect_1(&shared, get_val(std::unique_ptr<Node>(new Node(&shared))));
 
   // Check that the shared-value is still 1.
   expect_1(&shared, true);
   return 0;
 }

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_array.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test unique_ptr<T[]> with trivial_abi as parameter type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 
 // There were assertion failures in both parse and codegen, which are fixed in clang 11.
 // UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// UNSUPPORTED: c++03
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   int* shared_val;

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

__attribute__((noinline)) void func(A /*unused*/, std::unique_ptr<B> /*unused*/,
                                     C /*unused*/) {
   call_something();
 }
 
 int main(int, char**) {
   char shared_buf[3] = {'0', '0', '0'};
   int cur_idx = 0;
 
-  func(A(shared_buf, &cur_idx), std::make_unique<B>(shared_buf, &cur_idx),
+  func(A(shared_buf, &cur_idx), std::unique_ptr<B>(new B(shared_buf, &cur_idx)),
        C(shared_buf, &cur_idx));
 
   // With trivial_abi, the std::unique_ptr<B> arg is always destructed first.
   assert(shared_buf[0] == 'B');
   return 0;
 }

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_ret.pass.cpp

 struct Node {
   explicit Node() {}
   ~Node() {}
 };
 
 __attribute__((noinline)) std::unique_ptr<Node> make_val(void** local_addr) {
   call_something();
 
-  auto ret = std::make_unique<Node>();
+  auto ret = std::unique_ptr<Node>(new Node);
 
   // Capture the local address of ret.
   *local_addr = &ret;
 
   return ret;
 }
 
 int main(int, char**) {