Make array symbol reading resilient to incomplete DWARF.

[sivachandra]

Summary

GCC emits DW_TAG_subrange_type for static member arrays, but with no
attributes. This in turn results in wrong type/value of the array when
printing with 'target variable <array var name>'. This patch fixes this
so that the array value is printed in this format:

(<element type> []) <array var name> = {}

Earlier, the array was being interpreted to be of its element type.

Note: This does not fix anything to do with 'expr' or 'p' commands.
Those commands still error out complaining about incomplete types.

[clayborg]

Back from holiday break, and looks good.

[sivachandra]

Thanks for the prompt review. I will put this in shortly.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

//                            }
                         if (element_type)
                         {
                             std::vector<uint64_t> element_orders;
                             ParseChildArrayInfo(sc, dwarf_cu, die, first_index, element_orders, byte_stride, bit_stride);
                             if (byte_stride == 0 && bit_stride == 0)
                                 byte_stride = element_type->GetByteSize();
                             ClangASTType array_element_type = element_type->GetClangForwardType();
                             uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
+                            if (element_orders.size() > 0)
+                            {
                                 uint64_t num_elements = 0;
                                 std::vector<uint64_t>::const_reverse_iterator pos;
                                 std::vector<uint64_t>::const_reverse_iterator end = element_orders.rend();
                                 for (pos = element_orders.rbegin(); pos != end; ++pos)
                                 {
                                     num_elements = *pos;
-                                clang_type = ast.CreateArrayType (array_element_type, 
+                                    clang_type = ast.CreateArrayType (array_element_type,
                                                                       num_elements,
                                                                       is_vector);
                                     array_element_type = clang_type;
-                                array_element_bit_stride = num_elements ? array_element_bit_stride * num_elements : array_element_bit_stride;
+                                    array_element_bit_stride = num_elements ?
+                                                               array_element_bit_stride * num_elements :
+                                                               array_element_bit_stride;
+                                }
+                            }
+                            else
+                            {
+                                clang_type = ast.CreateArrayType (array_element_type, 0, is_vector);
                             }
                             ConstString empty_name;
                             type_sp.reset( new Type (MakeUserID(die->GetOffset()), 
                                                      this, 
                                                      empty_name, 
                                                      array_element_bit_stride / 8, 
                                                      NULL, 
                                                      type_die_offset, 

test/lang/cpp/class_static/TestStaticVariables.py

class StaticVariableTestCase(TestBase):
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Test that file and class static variables display correctly."""
         self.buildDsym()
         self.static_variable_commands()
 
-    @expectedFailureFreeBSD('llvm.org/pr15261', failing_compilers) # lldb on FreeBSD does not display the size of (class or file)static arrays
-    @expectedFailureLinux('llvm.org/pr15261', failing_compilers) # lldb on Linux does not display the size of (class or file)static arrays
     @dwarf_test
     def test_with_dwarf_and_run_command(self):
         """Test that file and class static variables display correctly."""
         self.buildDwarf()
         self.static_variable_commands()
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @expectedFailureClang(9980907)
def static_variable_commands(self):
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
         # global variables are no longer displayed with the "frame variable" command. 
         self.expect('target variable A::g_points', VARIABLES_DISPLAYED_CORRECTLY,
-            substrs = ['(PointType [2]) A::g_points'])
+            patterns=['\(PointType \[[1-9]*\]\) A::g_points = {.*}'])
         self.expect('target variable g_points', VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['(PointType [2]) g_points'])
 
         # On Mac OS X, gcc 4.2 emits the wrong debug info for A::g_points.
         # A::g_points is an array of two elements.
-        if sys.platform.startswith("darwin") and self.getCompiler() in ['clang', 'llvm-gcc']:
+        if sys.platform.startswith("darwin") or sys.platform.startswith("linux"):
             self.expect("target variable A::g_points[1].x", VARIABLES_DISPLAYED_CORRECTLY,
                 startstr = "(int) A::g_points[1].x = 11")
 
     def static_variable_python(self):
         """Test Python APIs on file and class static variables."""
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)