Fix hang in global static initialization

[amccarth]

Summary

A previous patch introduced a global static ConstString instance. On Windows, this results in a hang because constructing the string pool appears to depend on other globals which haven't yet been initialized.

All other instances of static ConstStrings I could find were function static, so I modified the code to use a static function.

[zturner]

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

185

I wonder about returning this by reference. It seems like by convention we usually pass ConstStrings around by value.

[amccarth]

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

185

I was following the pattern used elsewhere, like Breakpoint::BreakpointEventData::GetFlavorString.

[zturner]

Ahh ok if there's already precedent for returning by reference then it's fine.

[EwanCrawford]

Thanks for fixing this Adrian

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

struct RenderScriptRuntime::Element
     empirical_type<DataKind> type_kind;                  // Defines pixel type if Allocation is created from an image
     empirical_type<uint32_t> type_vec_size;              // Vector size of each data point, e.g '4' for uchar4
     empirical_type<uint32_t> field_count;                // Number of Subelements
     empirical_type<uint32_t> datum_size;                 // Size of a single Element with padding
     empirical_type<uint32_t> padding;                    // Number of padding bytes
     empirical_type<uint32_t> array_size;                 // Number of items in array, only needed for strucrs
     ConstString type_name;                               // Name of type, only needed for structs
 
-    static const ConstString FallbackStructName;         // Print this as the type name of a struct Element
+    static const ConstString &GetFallbackStructName();   // Print this as the type name of a struct Element
                                                          // If we can't resolve the actual struct name
 };
 
 // This AllocationDetails class collects data associated with a single
 // allocation instance.
 struct RenderScriptRuntime::AllocationDetails
 {
     struct Dimension
struct RenderScriptRuntime::AllocationDetails
     empirical_type<uint32_t> stride;          // Stride between rows of the allocation
 
     // Give each allocation an id, so we can reference it in user commands.
     AllocationDetails(): id(ID++)
     {
     }
 };
 
-const ConstString RenderScriptRuntime::Element::FallbackStructName("struct");
+
+const ConstString &
+RenderScriptRuntime::Element::GetFallbackStructName()
+{
+    static const ConstString FallbackStructName("struct");
+    return FallbackStructName;
+}
 
 unsigned int RenderScriptRuntime::AllocationDetails::ID = 1;
 
 const char* RenderScriptRuntime::AllocationDetails::RsDataKindToString[] =
 {
    "User",
    "Undefined", "Undefined", "Undefined", // Enum jumps from 0 to 7
    "Undefined", "Undefined", "Undefined",

 void
 RenderScriptRuntime::FindStructTypeName(Element& elem, StackFrame* frame_ptr)
 {
     Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
     if (!elem.type_name.IsEmpty()) // Name already set
         return;
     else
-        elem.type_name = Element::FallbackStructName; // Default type name if we don't succeed
+        elem.type_name = Element::GetFallbackStructName(); // Default type name if we don't succeed
 
     // Find all the global variables from the script rs modules
     VariableList variable_list;
     for (auto module_sp : m_rsmodules)
         module_sp->m_module->FindGlobalVariables(RegularExpression("."), true, UINT32_MAX, variable_list);
 
     // Iterate over all the global variables looking for one with a matching type to the Element.
     // We make the assumption a match exists since there needs to be a global variable to reflect the
for (unsigned int z = 0; z < dim_z; ++z)
                 offset = prev_row + stride;
             prev_row = offset;
 
             // Print each element in the row individually
             for (unsigned int x = 0; x < dim_x; ++x)
             {
                 strm.Printf("\n(%u, %u, %u) = ", x, y, z);
                 if ((type == Element::RS_TYPE_NONE) && (alloc->element.children.size() > 0) &&
-                    (alloc->element.type_name != Element::FallbackStructName))
+                    (alloc->element.type_name != Element::GetFallbackStructName()))
                 {
                     // Here we are dumping an Element of struct type.
                     // This is done using expression evaluation with the name of the struct type and pointer to element.
 
                     // Don't print the name of the resulting expression, since this will be '$[0-9]+'
                     DumpValueObjectOptions expr_options;
                     expr_options.SetHideName(true);