Updated DynamicLibrary test to support static linking against MSVC RT.

[ivankara]

Summary

In this test we allocate memory in executable, reallocate memory in library and trying to release memory in executable.
Static linking standard library against both executable and library file leads to allocators conflict. Each target has its own allocator which doesn't know about existence of the other.
This patch avoids allocating memory in library.

[ivankara]

Can anyone review this code?

[marsupial]

Sorry for the tardiness of this...

1. Could the the type change from std::string be to the new State type introduced (rather than int)
2. Have all State variables default initialized to a value that would cause the test to fail.

[ivankara]

I'll make changes according your comment a little bit later. Right now I don't have proper environment and time.

unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp

std::string LibPath(const std::string Name = "PipSqueak") {
   std::string Path = fs::getMainExecutable(Argv0, Ptr);
   llvm::SmallString<256> Buf(path::parent_path(Path));
   path::append(Buf, (Name + LTDL_SHLIB_EXT).c_str());
   return Buf.str();
 }
 
 #if defined(_WIN32) || (defined(HAVE_DLFCN_H) && defined(HAVE_DLOPEN))
 
-typedef void (*SetStrings)(std::string &GStr, std::string &LStr);
-typedef void (*TestOrder)(std::vector<std::string> &V);
+typedef void (*SetStrings)(int &GStr, int &LStr);
+typedef void (*TestOrder)(std::vector<int> &V);
 typedef const char *(*GetString)();
 
 template <class T> static T FuncPtr(void *Ptr) {
   union {
     T F;
     void *P;
   } Tmp;
   Tmp.P = Ptr;
TEST(DynamicLibrary, Overload) {
   EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
                   "TestA")) == nullptr);
 
   // Check serach ordering is reset to default after call to llvm_shutdown
   EXPECT_TRUE(DynamicLibrary::SearchOrder == DynamicLibrary::SO_Linker);
 }
 
 TEST(DynamicLibrary, Shutdown) {
-  std::string A("PipSqueak"), B, C("SecondLib");
-  std::vector<std::string> Order;
+  std::string A_lib("PipSqueak"), C_lib("SecondLib");
+  int A = State::FIRST_CONSTANT, B = 0, C = State::SECOND_CONSTANT;
+  std::vector<int> Order;
+  Order.reserve(2);
   {
     std::string Err;
     llvm_shutdown_obj Shutdown;
     DynamicLibrary DL =
-        DynamicLibrary::getPermanentLibrary(LibPath(A).c_str(), &Err);
+        DynamicLibrary::getPermanentLibrary(LibPath(A_lib).c_str(), &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     SetStrings SS_0 = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
     EXPECT_TRUE(SS_0 != nullptr);
 
     SS_0(A, B);
-    EXPECT_EQ(B, "Local::Local(PipSqueak)");
+    EXPECT_TRUE(B == State::LOCAL_CONSTRUCTOR_CALL);
 
     TestOrder TO_0 = FuncPtr<TestOrder>(
         DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
     EXPECT_TRUE(TO_0 != nullptr);
-    
     DynamicLibrary DL2 =
-        DynamicLibrary::getPermanentLibrary(LibPath(C).c_str(), &Err);
+        DynamicLibrary::getPermanentLibrary(LibPath(C_lib).c_str(), &Err);
     EXPECT_TRUE(DL2.isValid());
     EXPECT_TRUE(Err.empty());
 
     // Should find latest version of symbols in SecondLib
     SetStrings SS_1 = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
     EXPECT_TRUE(SS_1 != nullptr);
     EXPECT_TRUE(SS_0 != SS_1);
 
     TestOrder TO_1 = FuncPtr<TestOrder>(
         DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
     EXPECT_TRUE(TO_1 != nullptr);
     EXPECT_TRUE(TO_0 != TO_1);
 
-    B.clear();
+    B = 0;
     SS_1(C, B);
-    EXPECT_EQ(B, "Local::Local(SecondLib)");
 
+    EXPECT_TRUE(B == State::LOCAL_CONSTRUCTOR_CALL);
     TO_0(Order);
     TO_1(Order);
   }
-  EXPECT_EQ(A, "Global::~Global");
-  EXPECT_EQ(B, "Local::~Local");
+
+  EXPECT_TRUE(A == State::GLOBAL_DESTRUCTOR_CALL);
+  EXPECT_TRUE(B == State::LOCAL_DESTRUCTOR_CALL);
+
   EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
                   "SetStrings")) == nullptr);
 
   // Test unload/destruction ordering
   EXPECT_EQ(Order.size(), 2UL);
-  EXPECT_EQ(Order.front(), "SecondLib");
-  EXPECT_EQ(Order.back(), "PipSqueak");
+  EXPECT_EQ(Order.front(), State::SECOND_CONSTANT);
+  EXPECT_EQ(Order.back(), State::FIRST_CONSTANT);
 }
 
 #else
 
 TEST(DynamicLibrary, Unsupported) {
   std::string Err;
   DynamicLibrary DL =
       DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
   EXPECT_FALSE(DL.isValid());
   EXPECT_EQ(Err, "dlopen() not supported on this platform");
 }
 
 #endif

unittests/Support/DynamicLibrary/PipSqueak.h

 #endif
 
 #ifdef _WIN32
 #define PIPSQUEAK_EXPORT __declspec(dllexport)
 #else
 #define PIPSQUEAK_EXPORT
 #endif
 
+enum State { FIRST_CONSTANT,          SECOND_CONSTANT,
+             GLOBAL_CONSTRUCTOR_CALL, GLOBAL_DESTRUCTOR_CALL,
+             LOCAL_CONSTRUCTOR_CALL,  LOCAL_DESTRUCTOR_CALL };
+
 extern "C" PIPSQUEAK_EXPORT const char *TestA();
 
 #endif

unittests/Support/DynamicLibrary/PipSqueak.cpp

 //===- llvm/unittest/Support/DynamicLibrary/PipSqueak.cpp -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PipSqueak.h"
 
 struct Global {
-  std::string *Str;
-  std::vector<std::string> *Vec;
+  int *Str;
+  std::vector<int> *Vec;
   Global() : Str(nullptr), Vec(nullptr) {}
   ~Global() {
     if (Str) {
       if (Vec)
         Vec->push_back(*Str);
-      *Str = "Global::~Global";
+      *Str = State::GLOBAL_DESTRUCTOR_CALL;
     }
   }
 };
 
 static Global Glb;
 
 struct Local {
-  std::string &Str;
-  Local(std::string &S) : Str(S) {
-    Str = "Local::Local";
-    if (Glb.Str && !Glb.Str->empty())
-      Str += std::string("(") + *Glb.Str + std::string(")");
+  int &Str;
+  Local(int &S) : Str(S) {
+    Str = State::LOCAL_CONSTRUCTOR_CALL;
   }
-  ~Local() { Str = "Local::~Local"; }
+  ~Local() { Str = State::LOCAL_DESTRUCTOR_CALL; }
 };
 
-
-extern "C" PIPSQUEAK_EXPORT void SetStrings(std::string &GStr,
-                                            std::string &LStr) {
+extern "C" PIPSQUEAK_EXPORT void SetStrings(int &GStr,
+                                            int &LStr) {
   Glb.Str = &GStr;
   static Local Lcl(LStr);
 }
 
-extern "C" PIPSQUEAK_EXPORT void TestOrder(std::vector<std::string> &V) {
+extern "C" PIPSQUEAK_EXPORT void TestOrder(std::vector<int> &V) {
   Glb.Vec = &V;
 }
 
 #define PIPSQUEAK_TESTA_RETURN "LibCall"
 #include "ExportedFuncs.cpp"