Fix TestNameLookup for GCC

[labath]

Summary

GCC emits also symbols for the PRETTY_FUNCTION virtual variable,
which we accidentaly pick up when looking for functions for with
"unique_function_name" in the name. This makes the target.FindFunctions
call fail, as that symbol is not a function.

I also strenghten the test a bit to make sure we actually find all the
functions we are interested in. I've put a check that we find at least 6
functions, but maybe this should be *exactly* 6 ?

packages/Python/lldbsuite/test/python_api/name_lookup/TestNameLookup.py

 from lldbsuite.test import lldbutil
 
 
 class TestNameLookup(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll(compiler="gcc")
     def test_target(self):
         """Exercise SBTarget.FindFunctions() with various name masks.
         
         A previous regression caused mangled names to not be able to be looked up.
         This test verifies that using a mangled name with eFunctionNameTypeFull works
         and that using a function basename with eFunctionNameTypeFull works for all
         C++ functions that are at the global namespace level."""
         self.build();
         exe = os.path.join(os.getcwd(), 'a.out')
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         exe_module = target.FindModule(target.GetExecutable())
         
         c_name_to_symbol = {}
         cpp_name_to_symbol = {}
         mangled_to_symbol = {}
         num_symbols = exe_module.GetNumSymbols();
         for i in range(num_symbols):
             symbol = exe_module.GetSymbolAtIndex(i);
             name = symbol.GetName()
-            if name and 'unique_function_name' in name:
+            if name and 'unique_function_name' in name and '__PRETTY_FUNCTION__' not in name:
                 mangled = symbol.GetMangledName()
                 if mangled:
                     mangled_to_symbol[mangled] = symbol
                     if name:
                         cpp_name_to_symbol[name] = symbol
                 elif name:
                     c_name_to_symbol[name] = symbol
 
         # Make sure each mangled name turns up exactly one match when looking up
         # functions by full name and using the mangled name as the name in the 
         # lookup
+        self.assertGreaterEqual(len(mangled_to_symbol), 6)
         for mangled in mangled_to_symbol.keys():
             symbol_contexts = target.FindFunctions(mangled, lldb.eFunctionNameTypeFull)
             self.assertTrue(symbol_contexts.GetSize() == 1)
             for symbol_context in symbol_contexts:
                 self.assertTrue(symbol_context.GetFunction().IsValid())
                 self.assertTrue(symbol_context.GetSymbol().IsValid())